gcc 14.1-b20240218 - en to zh_CN translation catalogue (4470 entries)

en: 
    For bug reporting instructions, please see:
zh_CN: 
    报告程序缺陷的步骤请参见：

en: 
    For bug reporting instructions, please see:
    %s.
zh_CN: 
    提交错误报告的具体步骤请参见：
    %s。

en: 
    Go ahead? (y or n)
zh_CN: 
    继续？(y 或 n)

en: 
    Linker options
    ==============
zh_CN: 
    链接器选项
    =========

en: 
    Obsolete options:
zh_CN: 
    过时的选项：

en: 
    Options starting with -g, -f, -m, -O, -W, or --param are automatically
     passed on to the various sub-processes invoked by %s.  In order to pass
     other options on to these processes the -W<letter> options must be used.
zh_CN: 
    以 -g、-f、-m、-O、-W 或 --param 开头的选项将由 %s 自动传递给其调用的
     不同子进程。若要向这些进程传递其他选项，必须使用 -W<字母> 选项。

en: 
    ldd output with constructors/destructors.
zh_CN: 
    ldd 输出带有构造/析构函数。

en: 
    write_c_file - output name is %s, prefix is %s
zh_CN: 
    write_c_file - 输出名为 %s，前缀为 %s

en:                            Display specific types of command line options.
zh_CN:                            显示特定类型的命令行选项。

en:     -F, --fullname                      Print full filename
zh_CN:     -F, --fullname                      打印全名

en:     -f, --function                      Print function level info
zh_CN:     -f, --function                      打印函数级信息

en:     -h, --hotonly                       Only print info for hot objects/functions
zh_CN:     -h, --hotonly                       只打印热对象/函数的信息

en:     -n, --normalize <int64_t>           Normalize the profile
zh_CN:     -n, --normalize <int64_t>           归一化配置

en:     -o, --object                        Print object level info
zh_CN:     -o, --object                        打印对象级信息

en:     -o, --output <dir>                  Output directory
zh_CN:     -o, --output <dir>                  输出目录

en:     -s, --scale <float or simple-frac>  Scale the profile counters
zh_CN:     -s, --scale <浮点数或分数>            按比例缩放配置计数器

en:     -v, --verbose                       Verbose mode
zh_CN:     -v, --verbo      se                 输出更多信息

en:     -w, --weight <w1,w2>                Set weights (float point values)
zh_CN:     -w, --weight <w1,w2>                设置权重（浮点数）

en:     Included at %s:%d:
zh_CN:    包含于 %s:%d：

en:     inlined from %qs
zh_CN:     内联自%qs

en:     inlined from %qs at %r%s:%d%R
zh_CN:     内联自%qs于 %r%s:%d%R

en:     inlined from %qs at %r%s:%d:%d%R
zh_CN:     内联自%qs于 %r%s:%d:%d%R

en:    by earlier handler for %<%T%>
zh_CN: 为%<%T%>更早的处理者所捕获

en:    in pointer to member conversion
zh_CN: 在成员指针转换中

en:    in pointer to member function conversion
zh_CN: 在成员函数指针转换中

en:   (Use '-v --help' to display command line options of sub-processes).
zh_CN:  （使用‘-v --help’显示子进程的命令行参数）。

en:   -###                     Like -v but options quoted and commands not executed.
zh_CN:   -###                     与 -v 类似，但选项被引号括住，并且不执行命令。

en:   --help                   Display this information.
zh_CN:   --help                   显示此帮助说明。

en:   --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].
zh_CN:   --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]。

en:   --sysroot=<directory>    Use <directory> as the root directory for headers
                               and libraries.
zh_CN:   --sysroot=<目录>         将 <目录> 作为头文件和库文件的根目录。

en:   --version                Display compiler version information.
zh_CN:   --version                显示编译器版本信息。

en:   -B <directory>           Add <directory> to the compiler's search paths.
zh_CN:   -B <目录>                将 <目录> 添加到编译器的搜索路径中。

en:   -E                       Preprocess only; do not compile, assemble or link.
zh_CN:   -E                       仅作预处理，不进行编译、汇编或链接。

en:   -S                       Compile only; do not assemble or link.
zh_CN:   -S                       编译到汇编语言，不进行汇编和链接，

en:   -Wa,<options>            Pass comma-separated <options> on to the assembler.
zh_CN:   -Wa,<选项>               将逗号分隔的 <选项> 传递给汇编器。

en:   -Wl,<options>            Pass comma-separated <options> on to the linker.
zh_CN:   -Wl,<选项>               将逗号分隔的 <选项> 传递给链接器。

en:   -Wp,<options>            Pass comma-separated <options> on to the preprocessor.
zh_CN:   -Wp,<选项>               将逗号分隔的 <选项> 传递给预处理器。

en:   -Xassembler <arg>        Pass <arg> on to the assembler.
zh_CN:   -Xassembler <参数>       将 <参数> 传递给汇编器。

en:   -Xlinker <arg>           Pass <arg> on to the linker.
zh_CN:   -Xlinker <参数>          将 <参数> 传递给链接器。

en:   -Xpreprocessor <arg>     Pass <arg> on to the preprocessor.
zh_CN:   -Xpreprocessor <参数>    将 <参数> 传递给预处理器。

en:   -a, --all-blocks                Show information for every basic block
zh_CN:   -a, --all-blocks                显示每个基本块的信息

en:   -b, --branch-probabilities      Include branch probabilities in output
zh_CN:   -b, --branch-probabilities      输出包含分支概率

en:   -c                       Compile and assemble, but do not link.
zh_CN:   -c                       编译、汇编到目标代码，不进行链接。

en:   -c, --branch-counts             Output counts of branches taken
                                        rather than percentages
zh_CN:   -c, --branch-counts             给出跳转的分支数，而不是百分比

en:   -d, --display-progress          Display progress information
zh_CN:   -d, --display-progress          显示进度信息

en:   -dumpmachine             Display the compiler's target processor.
zh_CN:   -dumpmachine             显示编译器的目标处理器。

en:   -dumpspecs               Display all of the built in spec strings.
zh_CN:   -dumpspecs               显示所有内建 spec 字符串。

en:   -dumpversion             Display the version of the compiler.
zh_CN:   -dumpversion             显示编译器的版本号。

en:   -f, --function-summaries        Output summaries for each function
zh_CN:   -f, --function-summaries        输出每个函数的小结信息

en:   -h, --help                            Print this help, then exit
zh_CN:   -h, --help                           打印此帮助并退出

en:   -h, --help                      Print this help, then exit
zh_CN:   -h, --help                      打印此帮助并退出

en:   -i, --json-format               Replaced with -j, --json-format
zh_CN:   -i, --json-format               被 -j, --json-format 替代

en:   -j, --human-readable            Replaced with -H, --human-readable
zh_CN:   -j, --human-readable            被 -H, --human-readable 替代

en:   -k, --use-colors                Emit colored output
zh_CN:   -k, --use-colors                使用带颜色的输出

en:   -l, --long-file-names           Use long output file names for included
                                        source files
zh_CN:   -l, --long-file-names           为包含进来的源文件使用长输出文件名

en:   -m, --demangled-names           Output demangled function names
zh_CN:   -m, --demangled-names           输出解码后的函数名

en:   -n, --no-output                 Do not create an output file
zh_CN:   -n, --no-output                 不创建输出文件

en:   -no-canonical-prefixes   Do not canonicalize paths when building relative
                               prefixes to other gcc components.
zh_CN:   -no-canonical-prefixes   生成其他 gcc 组件的相对路径时不生成规范化的
                               前缀。

en:   -o <file>                Place the output into <file>.
zh_CN:   -o <文件>                输出到 <文件>。

en:   -o, --object-directory DIR|FILE Search for object files in DIR or called FILE
zh_CN:   -o, --object-directory DIR|FILE 在 DIR 中搜索目标文件，或搜索名为 FILE 的目标文件

en:   -p, --preserve-paths            Preserve all pathname components
zh_CN:   -p, --preserve-paths            保留所有路径名

en:   -pass-exit-codes         Exit with highest error code from a phase.
zh_CN:   -pass-exit-codes         在某一阶段退出时返回其中最高的错误码。

en:   -pie                     Create a dynamically linked position independent
                               executable.
zh_CN:   -pie                     生成动态链接的位置无关可执行文件。

en:   -pipe                    Use pipes rather than intermediate files.
zh_CN:   -pipe                    使用管道代替临时文件。

en:   -print-file-name=<lib>   Display the full path to library <lib>.
zh_CN:   -print-file-name=<库>    显示 <库> 的完整路径。

en:   -print-libgcc-file-name  Display the name of the compiler's companion library.
zh_CN:   -print-libgcc-file-name  显示编译器伴随库的名称。

en:   -print-multi-directory   Display the root directory for versions of libgcc.
zh_CN:   -print-multi-directory   显示不同版本 libgcc 的根目录。

en:   -print-multi-lib         Display the mapping between command line options and
                               multiple library search directories.
zh_CN:   -print-multi-lib         显示命令行选项和多个版本库搜索路径间的映射。

en:   -print-multi-os-directory Display the relative path to OS libraries.
zh_CN:   -print-multi-os-directory 显示操作系统库的相对路径。

en:   -print-multiarch         Display the target's normalized GNU triplet, used as
                               a component in the library path.
zh_CN:   -print-multiarch         显示目标的标准 GNU 三元组（被用于库路径的一部分）。

en:   -print-prog-name=<prog>  Display the full path to compiler component <prog>.
zh_CN:   -print-prog-name=<程序>  显示编译器组件 <程序> 的完整路径。

en:   -print-search-dirs       Display the directories in the compiler's search path.
zh_CN:   -print-search-dirs       显示编译器的搜索路径。

en:   -print-sysroot           Display the target libraries directory.
zh_CN:   -print-sysroot           显示目标库目录。

en:   -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.
zh_CN:   -print-sysroot-headers-suffix 显示用于寻找头文件的 sysroot 后缀。

en:   -r, --relative-only             Only show data for relative sources
zh_CN:   -r, --relative-only             只显示相对来源的信息

en:   -s, --source-prefix DIR         Source prefix to elide
zh_CN:   -s, --source-prefix 目录        要略去的来源前缀

en:   -save-temps              Do not delete intermediate files.
zh_CN:   -save-temps              不删除中间文件。

en:   -save-temps=<arg>        Do not delete intermediate files.
zh_CN:   -save-temps=<参数>       不删除中间文件。

en:   -shared                  Create a shared library.
zh_CN:   -shared                  生成一个共享库。

en:   -specs=<file>            Override built-in specs with the contents of <file>.
zh_CN:   -specs=<文件>            用 <文件> 的内容覆盖内建的 specs 文件。

en:   -std=<standard>          Assume that the input sources are for <standard>.
zh_CN:   -std=<标准>              假定输入源文件遵循给定的标准。

en:   -t, --stdout                    Output to stdout instead of a file
zh_CN:   -t, --stdout                    输出至标准输出而非文件

en:   -time                    Time the execution of each subprocess.
zh_CN:   -time                    为每个子进程计时。

en:   -u, --unconditional-branches    Show unconditional branch counts too
zh_CN:   -u, --unconditional-branches    同时显示无条件跳转数

en:   -v                       Display the programs invoked by the compiler.
zh_CN:   -v                       显示编译器调用的程序。

en:   -v, --version                         Print version number, then exit
zh_CN:   -v, --version                        打印版本号并退出

en:   -v, --version                   Print version number, then exit
zh_CN:   -v, --version                    打印版本号并退出

en:   -w, --verbose                   Print verbose informations
zh_CN:   -w, --verbose                   输出详细信息

en:   -x <language>            Specify the language of the following input files.
                               Permissible languages include: c c++ assembler none
                               'none' means revert to the default behavior of
                               guessing the language based on the file's extension.
zh_CN:   -x <语言>                指定其后输入文件的语言。
                               允许的语言包括：c、c++、assembler、none
                               ‘none’意味着恢复默认行为，即根据文件的扩展名猜测
                               源文件的语言。

en:   a qualified-id is required
zh_CN: 需要一个限定的标识符

en:   as it is a non-system directory that duplicates a system directory
zh_CN:   因为它是一个重复了系统目录的非系统目录

en:   base %qT
zh_CN: 基类%qT

en:   because conversion sequence for the argument is better
zh_CN: 因为前者的实参类型转换序列更好

en:   because the following virtual functions are pure within %qT:
zh_CN: 因为下列虚函数在%qT中为纯虚函数：

en:   but %d required
zh_CN: 但实际需要 %d 个

en:   candidate conversions include %qD and %qD
zh_CN:   备选转换包括%qD和%qD

en:   candidate expects %d argument, %d provided |   candidate expects %d arguments, %d provided
zh_CN[0]:  备选需要 %d 实参，但提供了 %d 个

en:   crosses initialization of %q#D
zh_CN:   跳过了%q+#D的初始化

en:   enters %<catch%> block
zh_CN:   进入了 catch 块

en:   enters %<consteval if%> statement
zh_CN:   需要语句

en:   enters %<constexpr if%> statement
zh_CN:   需要语句

en:   enters %<try%> block
zh_CN:   进入了 try 块

en:   enters OpenMP structured block
zh_CN:   进入了 OpenMP 结构块

en:   enters synchronized or atomic statement
zh_CN:   进入了同步化或原子化语句

en:   exits OpenMP structured block
zh_CN:   退出了 OpenMP 结构块

en:   expected a class template, got %qE
zh_CN: 需要一个类模板，却给出了%qE

en:   expected a class template, got %qT
zh_CN: 需要一个类模板，却给出了%qT

en:   expected a constant of type %qT, got %qT
zh_CN: 需要一个%qT类型的常量，却给出了%qT

en:   expected a template of type %qD, got %qT
zh_CN: 需要有%qD类型的模板，却得到了%qT

en:   expected a type, got %qE
zh_CN: 需要一个类型，却给出了%qE

en:   expected a type, got %qT
zh_CN: 需要一个类型，却给出了%qT

en:   from here
zh_CN:   从这里

en:   in call to %qD
zh_CN: 在调用%qD时

en:   in evaluation of %<%Q(%#T, %#T)%>
zh_CN: 在求%<%Q(%#T, %#T)%>值时

en:   in thrown expression
zh_CN:   在抛出的表达式中

en:   initializing argument %P of %qD
zh_CN:   初始化%2$qD的实参 %1$P

en:   merge [options] <dir1> <dir2>         Merge coverage file contents
zh_CN:   merge [选项] <目录1> <目录2>           合并测试覆盖率文件内容

en:   or %<operator=(const %T&)%>
zh_CN: 或者%<operator=(const %T&)%>

en:   overlap [options] <dir1> <dir2>       Compute the overlap of two profiles
zh_CN:  overlap [选项] <目录1> <目录2>          计算两个配置文件的重叠

en:   profiling support are only provided in archive format
zh_CN: 取样支持只支持存档格式

en:   rewrite [options] <dir>               Rewrite coverage file contents
zh_CN:   rewrite [选项] <目录>                  覆写测试覆盖率文件内容

en:   since %q+#D declared in base class
zh_CN: 因为%q+#D已在基类中声明过

en:   skips initialization of %q#D
zh_CN:   跳过了%q+#D的初始化

en:   trying to instantiate %qD
zh_CN:   试图实例化%qD

en:   when initialized here
zh_CN: 在此处初始化后被初始化

en:  All options with the desired characteristics have already been displayed
zh_CN:  所有具有指定特性的选项已被显示

en:  No options with the desired characteristics were found
zh_CN:  找不到具有指定特性的选项

en:  conflicting code gen style switches are used
zh_CN: 使用了相互冲突的代码生成风格

en: !$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L
zh_CN: %L处 !$OMP ATOMIC 赋值内建函数 IAND、IOR 或 IEOR 必须带两个实参

en: !$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L
zh_CN: %L处!$OMP ATOMIC 赋值内建函数必须是 MIN、MAX、IAND、IOR 或 IEOR

en: !$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L
zh_CN: %L处 !$OMP ATOMIC 赋值形式必须为“变量 = 变量 运算符 表达式”或“变量 = 表达式 运算符 变量”

en: !$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L
zh_CN: %L处 !$OMP ATOMIC 赋值的右手边必须有一个运算符或内建函数

en: !$OMP ATOMIC intrinsic arguments must be scalar at %L
zh_CN: %L处 !$OMP ATOMIC 内建函数的实参必须是标量

en: !$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L
zh_CN: %L处 !$OMP ATOMIC 语句必须设定一个内建类型的标量值

en: !$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L
zh_CN: %L处 !$OMP ATOMIC“变量 = 变量 运算符 表达式”与“变量 = 变量 运算符 (表达式)”在数学上不等价

en: !$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line
zh_CN: %C处的 !$OMP 开始了一个注释行，因为它既不是由一个空白符跟随也不是一个续行

en: "::" was expected after module nature at %C but was not found
zh_CN: %C处在模块本性后需要“::”

en: #include "..." search starts here:
zh_CN: #include "..." 搜索从这里开始：

en: #include <...> search starts here:
zh_CN: #include <...> 搜索从这里开始：

en: $ should be the last specifier in format at %L
zh_CN: $ 必须是%L处最后一个格式限定符

en: %<#pragma GCC optimize%> is not a string or number
zh_CN: %<#pragma GCC optimize%>不是字符串或数字

en: %<#pragma GCC option%> is not a string
zh_CN: %<#pragma GCC option%>不是个字符串

en: %<#pragma GCC pch_preprocess%> must be first
zh_CN: %<#pragma GCC pch_preprocess%>必须是第一个

en: %<#pragma GCC pop_options%> without a corresponding %<#pragma GCC push_options%>
zh_CN: %<#pragma GCC pop_options%>缺少相应的%<#pragma GCC push_options%>

en: %<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported for C++
zh_CN: %<#pragma STDC FLOAT_CONST_DECIMAL64%>不为 C++ 所支持

en: %<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported on this target
zh_CN: %<#pragma STDC FLOAT_CONST_DECIMAL64%>在此目标机上不受支持

en: %<#pragma omp section%> may only be used in %<#pragma omp sections%> construct
zh_CN: %<#pragma omp section%>只能用在%<#pragma omp sections%>结构中

en: %<#pragma%> is not allowed here
zh_CN: 在这里不允许使用%<#pragma%>

en: %<%%%> constraint used with last operand
zh_CN: %<%%%>约束用于最后一个操作数

en: %<%%%c%> yields only last 2 digits of year
zh_CN: %<%%%c%>只给出 2 位表示的年份

en: %<%%%c%> yields only last 2 digits of year in some locales
zh_CN: %<%%%c%>在某些区域设定下只给出 2 位表示的年份

en: %<%D::%D%> is not a member of %qT
zh_CN: %<%D::%D%>不是%qT的成员

en: %<%E::%E%> has not been declared
zh_CN: %<%E::%E%>尚未声明

en: %<%E::%E%> is not a class or namespace
zh_CN: %<%E::%E%>既不是类也不是命名空间

en: %<%E::%E%> is not a class, namespace, or enumeration
zh_CN: %<%E::%E%>不是类、命名空间或枚举

en: %<%E::%E%> is not a type
zh_CN: %<%E::%E%>不是一个类型

en: %<%T::%D%> names constructor in %qT
zh_CN: %<%T::%D%>在%qT内指定了构造函数

en: %<%T::%D%> names the constructor, not the type
zh_CN: %<%T::%D%>命名了一个构造函数而非类型

en: %<%T::%E%> has not been declared
zh_CN: %<%T::%E%>尚未声明

en: %<%T::%E%> is not a type
zh_CN: %<%T::%E%>不是一个类型

en: %<%T::%E%> names the constructor, not the type
zh_CN: %<%T::%E%>命名了一个构造函数而非类型

en: %<%c%E%> not found in protocol(s)
zh_CN: 在协议中找不到%<%c%E%>

en: %<&%> constraint used with no register class
zh_CN: %<&%>约束未与寄存器类型一起使用

en: %<-%s%> conflicts with the other architecture options, which specify a %s processor
zh_CN: %<-%s%>与指定了 %s 处理器的其他架构选项冲突

en: %<-Wabi=1%> is not supported, using =2
zh_CN: %<-Wabi=1%> 不受支持，将使用 =2

en: %<-femit-struct-debug-detailed=dir:...%> must allow at least as much as %<-femit-struct-debug-detailed=ind:...%>
zh_CN: %<-femit-struct-debug-detailed=dir:...%>必须至少允许%<-femit-struct-debug-detailed=ind:...%>所允许的

en: %<-fobjc-gc%> is ignored for %<-fgnu-runtime%>
zh_CN: %<-fobjc-gc%>为%<-fgnu-runtime%>所忽略

en: %<-fobjc-sjlj-exceptions%> is ignored for %<-fgnu-runtime%>
zh_CN: %<-fobjc-sjlj-exceptions%>为%<-fgnu-runtime%>所忽略

en: %<-fsplit-stack%> currently only supported on GNU/Linux
zh_CN: %<-fsplit-stack%>只在 GNU/Linux 下被支持

en: %<-fsplit-stack%> requires assembler support for CFI directives
zh_CN: %<-fsplit-stack%>需要汇编器支持 CFI 伪指令

en: %<-gnat%> misspelled as %<-gant%>
zh_CN: %<-gnat%>被错误地拼写为%<-gant%>

en: %<-march=%s%> is not compatible with the selected ABI
zh_CN: %<-march=%s%>与所选 ABI 不兼容

en: %<-mcpu=%> is deprecated; use %<-mtune=%> or %<-march=%> instead
zh_CN: 已弃用%<-mcpu=%>；请改用%<-mtune=%>或%<-march=%>

en: %<-mdynamic-no-pic%> overrides %<-fpic%>, %<-fPIC%>, %<-fpie%> or %<-fPIE%>
zh_CN: %<-mdynamic-no-pic%> 覆盖了 %<-fpic%>, %<-fPIC%>, %<-fpie%> 及 %<-fPIE%>

en: %<-mfpxx%> requires %<-mlra%>
zh_CN: %<-mfpxx%> 需要 %<-mlra%>

en: %<-mfused-madd%> is deprecated; use %<-ffp-contract=%> instead
zh_CN: 已弃用%<-mfused-madd%>；请改用%<-ffp-contract=%>

en: %<-mgp32%> and %<-mfp64%> can only be combined if the target supports the mfhc1 and mthc1 instructions
zh_CN: %<-mgp32%>和%<-mfp64%>只有当目标机支持 mfhc1 和 mthc1 指令时才能一起使用

en: %<-mgp32%> and %<-mfp64%> can only be combined when using the o32 ABI
zh_CN: %<-mgp32%>和%<-mfp64%>只有当使用 o32 ABI 时才能一起使用

en: %<-mgp32%> used with a 64-bit ABI
zh_CN: %<-mgp32%>与 64 位 ABI 一起使用

en: %<-mgp64%> used with a 32-bit ABI
zh_CN: %<-mgp64%>与 32 位 ABI 一起使用

en: %<-mgp64%> used with a 32-bit processor
zh_CN: %<-mgp64%>与 32 位处理器一起使用

en: %<-mintel-syntax%> and %<-mno-intel-syntax%> are deprecated; use %<-masm=intel%> and %<-masm=att%> instead
zh_CN: 已弃用%<-mintel-syntax%>和 %<-mno-intel-syntax%>；请改用%<-masm=intel%>和%<-masm=att%>

en: %<-mips3d%> requires %<-mpaired-single%>
zh_CN: %<-mips3d%>需要%<-mpaired-single%>

en: %<-mno-gpopt%> needs %<-mexplicit-relocs%>
zh_CN: %<-mno-gpopt%>需要%<-mexplicit-relocs%>

en: %<-msse5%> was removed
zh_CN: %<-msse5%>已被移除

en: %<...%> handler must be the last handler for its try block
zh_CN: %<...%>处理者必须是其 try 块中的最后一个处理者

en: %<::%D%> has not been declared
zh_CN: %<::%D%>未被声明

en: %<::%E%> has not been declared
zh_CN: %<::%E%>尚未声明

en: %<::%E%> is not a class or namespace
zh_CN: %<::%E%>既不是类也不是命名空间

en: %<::%E%> is not a class, namespace, or enumeration
zh_CN: %<::%E%>不是类、命名空间或枚举

en: %<::%E%> is not a type
zh_CN: %<::%E%>不是一个类型

en: %<::main%> must return %<int%>
zh_CN: %<::main%>必须返回%<int%>

en: %<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>
zh_CN: %<<:%>是%<[%>的另一种拼法。请在%<<%>和%<::%>间加上空格

en: %<<::%> cannot begin a template-argument list
zh_CN: 不能以%<<::%>开始一个模板实参列表

en: %<>>%> should be %<> >%> within a nested template argument list
zh_CN: 在嵌套模板实参列表中应当使用%<> >%>而非%<>>%>

en: %<@dynamic%> is not available in Objective-C 1.0
zh_CN: %<@dynamic%> 在 Objective-C 1.0 里不可用

en: %<@dynamic%> not in @implementation context
zh_CN: @implemention 上下文中缺少 %<@dynamic%>

en: %<@encode%> must specify a type as an argument
zh_CN: %<@encode%>必须指定一个类型作为实参

en: %<@end%> missing in implementation context
zh_CN: 实现上下文中缺少%<@end%>

en: %<@end%> must appear in an @implementation context
zh_CN: %<@end%>必须出现在 @implementation 上下文中

en: %<@synchronized%> argument is not an object
zh_CN: %<@synchronized%> 参数不是一个对象

en: %<@synthesize%> is not available in Objective-C 1.0
zh_CN: %<@synthesize%> 在 Objective-C 1.0 里不可用

en: %<@synthesize%> not in @implementation context
zh_CN: %<@synthesize%> 不在 @implementation 上下文中

en: %<@synthesize%> requires the @interface of the class to be available
zh_CN: %<@synthesize%> 需要类的 @interface 的可用

en: %<@throw%> argument is not an object
zh_CN: %<@throw%> 参数不是一个对象

en: %<@try%> without %<@catch%> or %<@finally%>
zh_CN: %<@try%>缺少对应的%<@catch%>或%<@finally%>

en: %<[*]%> not allowed in other than function prototype scope
zh_CN: %<[*]%>不能用于函数原型以外

en: %<[*]%> not in a declaration
zh_CN: %<[*]%>不在声明中

en: %<_Sat%> is used without %<_Fract%> or %<_Accum%>
zh_CN: %<_Sat%>使用时缺少%<_Fract%>或%<_Accum%>

en: %<__BELOW100__%> attribute only applies to variables
zh_CN: 属性%<__BELOW100__%>只对变量类型起作用

en: %<__alignof%> applied to a bit-field
zh_CN: 将%<__alignof%>用于位段

en: %<__builtin_longjmp%> second argument must be 1
zh_CN: %<__builtin_longjmp%>的第二个实参必须是 1

en: %<__builtin_next_arg%> called without an argument
zh_CN: 调用%<__builtin_next_arg%>时没有给定实参

en: %<__gcc_host_wide_int__%> is not defined as %<long%> or %<long long%>
zh_CN: %<__gcc_host_wide_int__%>未被定义为%<long%>或%<long long%>

en: %<__gcc_host_wide_int__%> is not defined as a type
zh_CN: %<__gcc_host_wide_int__%>未被定义为一个类型

en: %<__label__%> not at the beginning of a block
zh_CN: %<__label__%>未出现在块起始

en: %<__thread%> before %<extern%>
zh_CN: %<__thread%>出现在%<extern%>之前

en: %<__thread%> before %<static%>
zh_CN: %<__thread%>出现在%<static%>之前

en: %<__thread%> before %qD
zh_CN: %<__thread%>出现在%qD之前

en: %<and%> of mutually exclusive equal-tests is always 0
zh_CN: 对两个互斥的相等比较取%<and%>的结果永远是 0

en: %<asm%> operand constraint incompatible with operand size
zh_CN: %<asm%>操作数的约束与操作数大小不兼容

en: %<asm%> operand has impossible constraints
zh_CN: %<asm%>操作数中有不可能的约束

en: %<asm%> operand requires impossible reload
zh_CN: %<asm%>要求不可能的重新加载

en: %<asm%> specifiers are not permitted on non-static data members
zh_CN: %<asm%>指定不允许用于非静态数据成员

en: %<auto%> in file-scope empty declaration
zh_CN: 文件作用域中出现%<auto%>空声明

en: %<bank_switch%> has no effect on non-interrupt functions
zh_CN: %<bank_switch%>对非中断函数不起作用

en: %<default%> label not within a switch statement
zh_CN: %<default%>标号未出现在 switch 语句内

en: %<else%> without a previous %<if%>
zh_CN: %<else%>之前没有%<if%>

en: %<enum %E%> declared in %<for%> loop initial declaration
zh_CN: %<enum %E%>声明于%<for%>循环初始声明中

en: %<explicit%> can only be specified for constructors
zh_CN: 只能为构造函数指定%<explicit%>

en: %<externally_visible%> attribute have effect only on public objects
zh_CN: %<externally_visible%>属性只对公共对象有效

en: %<fast_interrupt%> attribute directive ignored
zh_CN: 忽略%<fast_interrupt%>属性指定

en: %<friend%> can only be specified inside a class
zh_CN: %<friend%>只能在类中指定

en: %<friend%> used outside of class
zh_CN: %<friend%>用在类外

en: %<gnu_inline%> attribute present on %q+D
zh_CN: %q+D上有%<gnu_inline%>属性

en: %<inline%> in empty declaration
zh_CN: %<inline%>用于空声明中

en: %<inline%> is not allowed in declaration of friend template specialization %qD
zh_CN: %<inline%>不允许用于友元模板特例化%qD的声明

en: %<inline%> specified for friend class declaration
zh_CN: 友元函数声明中出现了%<inline%>

en: %<inline%> specifier invalid for function %qs declared out of global scope
zh_CN: 在全局作用域外为函数%qs指定%<inline%>无效

en: %<location_t%> is not defined as a type
zh_CN: %<location_t%>未被定义为一个类型

en: %<locus%> is not defined as a type
zh_CN: %<locus%>未被定义为一个类型

en: %<long long long%> is too long for GCC
zh_CN: %<long long long%>对 GCC 来说太长了

en: %<long%> switch expression not converted to %<int%> in ISO C
zh_CN: 在 ISO C 中，%<long%>开关表达式不被转换为%<int%>

en: %<namespace%> definition is not allowed here
zh_CN: 在这里不允许使用%<namespace%>定义

en: %<noreturn%> function does return
zh_CN: %<noreturn%>函数返回了

en: %<num_threads%> value must be positive
zh_CN: %<num_threads%>值必须为正

en: %<operator delete%> must return type %qT
zh_CN: %<operator delete%>必须返回%qT

en: %<operator delete%> takes type %qT as first parameter
zh_CN: %<operator delete%>的第一个形参类型为%qT

en: %<operator new%> must return type %qT
zh_CN: %<operator new%>必须返回%qT

en: %<operator new%> takes type %<size_t%> (%qT) as first parameter
zh_CN: %<operator new%>的第一个形参类型为%<size_t%>(%qT)

en: %<operator=%> should return a reference to %<*this%>
zh_CN: %<operator=%>应当返回一个对%<*this%>的引用

en: %<or%> of unmatched not-equal tests is always 1
zh_CN: 对两个不匹配的不等比较取%<or%>的结果总为 1

en: %<readonly%> attribute conflicts with %<setter%> attribute
zh_CN: %<readonly%>属性与%<setter%>属性冲突

en: %<register%> in file-scope empty declaration
zh_CN: 文件作用域中出现%<register%>空声明

en: %<return%> with a value, in function returning void
zh_CN: 在无返回值的函数中，%<return%>带返回值

en: %<return%> with no value, in function returning non-void
zh_CN: 在有返回值的的函数中，%<return%>不带返回值

en: %<sizeof%> applied to a bit-field
zh_CN: 对位段使用%<sizeof%>

en: %<static%> may not be used when defining (as opposed to declaring) a static data member
zh_CN: 与声明不同，定义静态数据成员时不能使用%<static%>

en: %<struct %E%> declared in %<for%> loop initial declaration
zh_CN: %<struct %E%>声明于%<for%>循环初始声明中

en: %<this%> is unavailable for static member functions
zh_CN: 静态成员函数中不能使用%<this%>

en: %<this%> may not be used in this context
zh_CN: %<this%>不能用在此上下文中

en: %<this%> was not captured for this lambda function
zh_CN: lambda 函数中无法捕获%<this%>

en: %<threadprivate%> %qD is not file, namespace or block scope variable
zh_CN: %<threadprivate%>%qD不是一个文件、命名空间或块作用域变量

en: %<threadprivate%> %qE directive not in %qT definition
zh_CN: %<threadprivate%>%qE指示不在%qT定义中

en: %<threadprivate%> %qE has incomplete type
zh_CN: %<threadprivate%>%qE的类型不完全

en: %<tree%> is not defined as a pointer type
zh_CN: %<tree%>未被定义为一个指针类型

en: %<tree%> is not defined as a type
zh_CN: %<tree%>未被定义为一个类型

en: %<typedef%> was ignored in this declaration
zh_CN: 此声明中的%<typedef%>被忽略

en: %<typename %T::%D%> names %q#T, which is not a class template
zh_CN: %<typename %T::%D%>指定了%q#T，但后者不是一个类模板

en: %<typeof%> applied to a bit-field
zh_CN: 为位段使用%<typeof%>

en: %<union %E%> declared in %<for%> loop initial declaration
zh_CN: %<union %E%>声明于%<for%>循环初始声明中

en: %<virtual%> outside class declaration
zh_CN: %<virtual%>用在类声明以外

en: %<void%> as only parameter may not be qualified
zh_CN: %<void%>作为仅有的参数时不能被限定

en: %<void%> must be the only parameter
zh_CN: %<void%>必须是仅有的形参

en: %<weakref%> attribute should be accompanied with an %<alias%> attribute
zh_CN: %<weakref%> 属性应与 %<alias%> 同时使用

en: %d constructor found
     | %d constructors found
zh_CN[0]: 找到 %d 个构造函数

en: %d destructor found
     | %d destructors found
zh_CN[0]: 找到 %d 个析构函数

en: %d exits recorded for loop %d (having %d exits)
zh_CN: 循环 %2$d 记录了 %1$d 个退出(有 %3$d 个退出)

en: %d frame table found
     | %d frame tables found
zh_CN[0]: 找到 %d 个框架表

en: %i-bit mode not compiled in
zh_CN: 未编译入对 %i 位模式的支持

en: %q#D is a static data member; it can only be initialized at its definition
zh_CN: %q#D是一个静态数据成员；它只能在定义时被初始化

en: %q#D is not a non-static data member of %qT
zh_CN: %q#D不是%qT的非静态数据成员

en: %q#D is not a valid template argument for type %qT because a reference variable does not have a constant address
zh_CN: %q#D不是类型%qT的有效模板参数，因为一个引用变量没有常量地址

en: %q#D is not const
zh_CN: %q#D不是 const

en: %q#D is volatile
zh_CN: %q#D是 volatile

en: %q#D not declared in class
zh_CN: %q#D未在类中声明

en: %q#T has no user-provided default constructor
zh_CN: %q#T没有用户提供的默认构造函数

en: %q#T has pointer data members
zh_CN: %q#T有指针数据成员

en: %q#T has virtual functions and accessible non-virtual destructor
zh_CN: %q#T有虚函数和可访问的非虚拟析构函数

en: %q#T is not a class
zh_CN: %q#T不是一个类

en: %q#T is not a template
zh_CN: %q#T不是一个模板

en: %q#T only defines a private destructor and has no friends
zh_CN: %q#T仅定义了一个私有析构函数且没有友元

en: %q#T only defines private constructors and has no friends
zh_CN: %q#T仅定义了一个私有构造函数且没有友元

en: %q#T used where a %qT was expected
zh_CN: 不应使用%q#T而应使用%qT

en: %q+#D cannot be declared
zh_CN: 无法声明%q+#D

en: %q+D aliased to external symbol %qE
zh_CN: %q+D是外部符号%qE的别名

en: %q+D aliased to undefined symbol %qE
zh_CN: %q+D是未定义符号%qE的别名

en: %q+D already declared with dllexport attribute: dllimport ignored
zh_CN: %q+D已被声明为具有 dllexport 属性：忽略 dllimport

en: %q+D declared as a friend
zh_CN: %q+D声明为友元

en: %q+D declared with an exception specification
zh_CN: %q+D声明时带有异常规范

en: %q+D is static but declared in inline function %qD which is not static
zh_CN: %q+D是静态的，但却在非静态的内联函数%qD中被声明

en: %q+D is usually a function
zh_CN: %q+D通常是一个函数

en: %q+D redeclared as different kind of symbol
zh_CN: %q+D被重新声明为不同意义的符号

en: %q+D redeclared inline with %<gnu_inline%> attribute
zh_CN: %q+D重声明内联并有%<gnu_inline%>属性

en: %q+D redeclared inline without %<gnu_inline%> attribute
zh_CN: %q+D重声明为内联而没有%<gnu_inline%>属性

en: %q+D redeclared without dllimport attribute after being referenced with dll linkage
zh_CN: %q+D重声明时没有 dllimport 属性，但已被作为 dllimport 链接引用过

en: %q+D redeclared without dllimport attribute: previous dllimport ignored
zh_CN: %q+D重声明时没有 dllimport 属性：忽略先前的 dllimport

en: %q+D takes only zero or two arguments
zh_CN: %q+D只带零或两个参数

en: %q+E is not a constant expression
zh_CN: %q+E不是一个常量表达式

en: %q+F declared %<static%> but never defined
zh_CN: %q+F声明为%<static%>却从未定义过

en: %q+F used but never defined
zh_CN: %q+F使用过但从未定义

en: %qD appears more than once in data clauses
zh_CN: %qD在数据子句中多次出现

en: %qD attribute directive ignored
zh_CN: 指定%qD属性被忽略

en: %qD attribute is meaningless since members of the anonymous namespace get local symbols
zh_CN: %qD属性无意义，因为匿名命名空间的成员拥有局部符号

en: %qD attribute requires a single NTBS argument
zh_CN: %qD属性需要一个 NTBS 作为实参

en: %qD cannot appear in a constant-expression
zh_CN: %qD不能出现在常量表达式中

en: %qD cannot be defaulted
zh_CN: %qD不能被默认化

en: %qD cannot have default arguments
zh_CN: %qD不能有默认参数

en: %qD changed semantics in GCC 4.4
zh_CN: %qD在 GCC 4.4 中语义已经改变

en: %qD conflicts with used function
zh_CN: %qD与已用的函数冲突

en: %qD declared as a %<virtual%> field
zh_CN: %qD声明为%<virtual%>字段

en: %qD declared as a %<virtual%> parameter
zh_CN: %qD声明为%<virtual%>参数

en: %qD declared as a %<virtual%> type
zh_CN: %qD声明为%<virtual%>类型

en: %qD declared as a %<virtual%> variable
zh_CN: %qD声明为%<virtual%>变量

en: %qD declared as a non-parameter
zh_CN: %qD没有声明为一个参数

en: %qD declared as an %<inline%> field
zh_CN: %qD声明为%<inline%>字段

en: %qD declared as an %<inline%> parameter
zh_CN: %qD声明为%<inline%>参数

en: %qD declared as an %<inline%> type
zh_CN: %qD声明为%<inline%>类型

en: %qD declared as reference but not initialized
zh_CN: %qD声明为引用却未被初始化

en: %qD declared here
zh_CN: %qD在此声明

en: %qD has already been defined
zh_CN: %qD已定义过

en: %qD has invalid argument list
zh_CN: %qD 带有无效参数列表

en: %qD has the same name as the class in which it is declared
zh_CN: %qD与其声明所在的类重名

en: %qD is a namespace
zh_CN: %qD是一个命名空间

en: %qD is already a friend of %qT
zh_CN: %qD已经是%qT的友元

en: %qD is already a friend of class %qT
zh_CN: %qD已经是类%qT的友元

en: %qD is already defined in %qT
zh_CN: %qD已在%qT中定义过

en: %qD is already defined in class %qT
zh_CN: %qD已在类%qT中定义过

en: %qD is already defined in the class %qT
zh_CN: %qD已在类%qT中定义过

en: %qD is an enumeration template
zh_CN: %qD不是一个枚举模板

en: %qD is both a direct base and an indirect virtual base
zh_CN: %qD既是一个直接基类又是一个间接虚基类

en: %qD is declared in header %qs
zh_CN: %qD 在 %qs 头文件中声明

en: %qD is normally a non-static function
zh_CN: %qD通常不是一个静态函数

en: %qD is not a class or namespace
zh_CN: %qD既不是类也不是命名空间

en: %qD is not a function template
zh_CN: %qD不是一个函数模板

en: %qD is not a member of %qD
zh_CN: %qD不是%qD的成员

en: %qD is not a member of %qT
zh_CN: %qD不是%qT的成员

en: %qD is not a member template function
zh_CN: %qD不是一个成员模板函数

en: %qD is not a namespace-name
zh_CN: %qD不是一个命名空间名

en: %qD is not a static data member of a class template
zh_CN: %qD不是类模板的非静态数据成员

en: %qD is not a template
zh_CN: %qD不是一个模板

en: %qD is not a template function
zh_CN: %qD不是一个模板函数

en: %qD is not a type
zh_CN: %qD不是一个类型

en: %qD is not a valid template argument because %qD is a variable, not the address of a variable
zh_CN: %qD不是一个有效模板实参，因为%qD是一个变量，而非变量的地址

en: %qD is not a variable
zh_CN: %qD不是一个变量

en: %qD is not a variable in clause %<firstprivate%>
zh_CN: %qD在%<firstprivate%>子句中不是一个变量

en: %qD is not a variable in clause %<lastprivate%>
zh_CN: %qD在%<lastprivate%>子句中不是一个变量

en: %qD is not a variable in clause %qs
zh_CN: %qD在子句%qs中不是一个变量

en: %qD is not captured
zh_CN: %qD未被捕获

en: %qD is not defined outside of function scope
zh_CN: %qD在函数作用域外未被定义

en: %qD is static but used in inline function %qD which is not static
zh_CN: %qD是静态的，但却在非静态的内联函数%qD中被使用

en: %qD may not be declared as static
zh_CN: %qD不能被声明为静态的

en: %qD may not be declared within a namespace
zh_CN: %qD不能在命名空间声明

en: %qD must be either a non-static member function or a non-member function
zh_CN: %qD必须是一个非静态成员函数或非成员函数

en: %qD must have an argument of class or enumerated type
zh_CN: %qD的实参必须有类或枚举类型

en: %qD must not have variable number of arguments
zh_CN: %qD不能带可变数量的实参

en: %qD not defined
zh_CN: %qD未定义

en: %qD redeclared with different access
zh_CN: %qD重声明时有不同的可访问性

en: %qD redeclared with different visibility
zh_CN: %qD重声明时有不同的可见性

en: %qD should be initialized
zh_CN: %qD应当被赋值

en: %qD should be initialized in the member initialization list
zh_CN: %qD应该在成员初始化列表中被初始化

en: %qD should have been declared inside %qD
zh_CN: %qD应当先在%qD内声明

en: %qD should return by value
zh_CN: %qD应当返回值而非引用

en: %qD used in its own initializer
zh_CN: %qD用在其自身的初始值设定中

en: %qD was declared %<extern%> and later %<static%>
zh_CN: %qD先被声明为%<extern%>后又被声明为%<static%>

en: %qD was declared %qs which implies default visibility
zh_CN: %qD声明为有默认可见性的%qs

en: %qD was declared here
zh_CN: %qD在此声明

en: %qD was not declared in this scope
zh_CN: %qD在此作用域中尚未声明

en: %qD was used with no declaration before its definition
zh_CN: 使用%qD时先前既没有声明也没有定义

en: %qD was used with no prototype before its definition
zh_CN: 使用%qD时先前既没有原型也没有定义

en: %qE 2.95 vtable-compatibility attribute applies only to C++ classes
zh_CN: %qE 2.95 虚表兼容属性只对 C++ 类有效

en: %qE 2.95 vtable-compatibility attribute applies only when compiling a kext
zh_CN: %qE 2.95 虚表兼容属性只在编译内核扩展时有效

en: %qE appears more than once in data clauses
zh_CN: %qE在数据子句中多次出现

en: %qE attribute allows only an integer constant argument
zh_CN: %qE属性需要一个整常量作为实参

en: %qE attribute applies only to functions
zh_CN: %qE属性只能用于函数

en: %qE attribute applies only to initialized variables with external linkage
zh_CN: %qE属性只能为具有外部链接的已初始化的变量使用

en: %qE attribute argument not a string constant
zh_CN: %qE属性需要一个字符串常量作为实参

en: %qE attribute argument not an integer constant
zh_CN: %qE属性需要一个整常量作为实参

en: %qE attribute argument should be between 0 to 255
zh_CN: %qE属性的参数应当在 0 和 255 之间

en: %qE attribute argument should be between 18 to 255
zh_CN: %qE属性的参数应当在 18 和 255 之间

en: %qE attribute cannot be specified for local variables
zh_CN: 不能为局部变量指定%qE属性

en: %qE attribute directive ignored
zh_CN: %qE属性指定被忽略

en: %qE attribute does not apply to types
zh_CN: 不能向类型添加属性%qE

en: %qE attribute have effect only on public objects
zh_CN: %qE属性只能应用到公共对象上

en: %qE attribute ignored
zh_CN: %qE属性被忽略

en: %qE attribute ignored because %qT is already defined
zh_CN: %qE属性被忽略，因为%qT已被定义

en: %qE attribute ignored for %qE
zh_CN: %qE属性为%qE所忽略

en: %qE attribute ignored for field of type %qT
zh_CN: %qE属性为类型为%qT的字段所忽略

en: %qE attribute ignored on non-class types
zh_CN: %qE属性在不是类的类型上被忽略

en: %qE attribute ignored on types
zh_CN: %qE属性在类型上被忽略

en: %qE attribute is not supported for R8C target
zh_CN: %qE属性在 R8C 目标机上不受支持

en: %qE attribute is supported only for SH2A
zh_CN: %qE属性只为 SH2A 所支持

en: %qE attribute only applies to SH2A
zh_CN: %qE属性只能用于 SH2A

en: %qE attribute only applies to function types
zh_CN: %qE属性只能用于函数类型

en: %qE attribute only applies to functions
zh_CN: %qE属性只能用于函数

en: %qE attribute only applies to interrupt functions
zh_CN: %qE属性只能用于中断函数

en: %qE attribute only applies to variables
zh_CN: 属性%qE只能用于变量

en: %qE attribute only applies to variadic functions
zh_CN: %qE属性只能用于带可变参数函数

en: %qE attribute only available for 32-bit
zh_CN: %qE属性只能在 32 位下使用

en: %qE attribute requires a string constant argument
zh_CN: %qE属性需要一个字符串常量作为实参

en: %qE attribute requires an integer constant argument
zh_CN: %qE属性需要一个整常量作为实参

en: %qE attribute requires prototypes with named arguments
zh_CN: %qE属性需要带有名实参的原型

en: %qE cannot be used as a function
zh_CN: %qE不能用作函数

en: %qE cannot be used as a member pointer, since it is of type %qT
zh_CN: %qE不能用作成员指针，因为它的类型为%qT

en: %qE declared %<threadprivate%> after first use
zh_CN: %qE在其首次使用后被声明为%<threadprivate%>

en: %qE declared as function returning a function
zh_CN: %qE声明为返回一个函数的函数

en: %qE declared as function returning an array
zh_CN: %qE声明为返回一个数组的函数

en: %qE defined as wrong kind of tag
zh_CN: %qE定义为类型错误的标记

en: %qE does not name a type
zh_CN: %qE不是一个类型名

en: %qE fails to be a typedef or built in type
zh_CN: %qE不是一个 typedef 类型，也不是一个内建类型

en: %qE has both %<extern%> and initializer
zh_CN: %qE既有%<extern%>又有初始值设定

en: %qE has invalid type for %<reduction(%s)%>
zh_CN: %qE的类型对%<reduction(%s)%>无效

en: %qE has not been declared
zh_CN: %qE未声明

en: %qE implies default visibility, but %qD has already been declared with a different visibility
zh_CN: %qE意味着默认可见性；但%qD已经被声明为有不同的可见性

en: %qE in namespace %qE does not name a type
zh_CN: %qE不是命名空间%qE中的一个类型名

en: %qE incompatible attribute ignored
zh_CN: %qE不兼容的属性已被忽略

en: %qE initialized and declared %<extern%>
zh_CN: %qE已初始化，却又被声明为%<extern%>

en: %qE is an unrecognized format function type
zh_CN: %qE是一个无法识别的格式字符串函数类型

en: %qE is deprecated
zh_CN: 已弃用%qE

en: %qE is deprecated: %s
zh_CN: 已弃用%qE：%s

en: %qE is neither function nor member function; cannot be declared friend
zh_CN: %qE既不是函数也不是成员函数；不能声明为友元

en: %qE is not a class or namespace
zh_CN: %qE既不是类也不是命名空间

en: %qE is not a class, namespace, or enumeration
zh_CN: %qE不是一个类、命名空间或枚举

en: %qE is not a constant expression
zh_CN: %qE不是一个常量表达式

en: %qE is not a template
zh_CN: %qE不是一个模板

en: %qE is not a type
zh_CN: %qE不是一个类型

en: %qE is not a valid template argument for type %qT
zh_CN: %qE不是类型%qT的有效模板参数

en: %qE is not a valid template argument for type %qT because it is a pointer
zh_CN: %qE不是类型%qT的有效模板实参，因为它是一个指针

en: %qE is not a valid template argument for type %qT because it is not an lvalue
zh_CN: %qE不是类型%qT的有效模板实参，因为它不是一个左值

en: %qE is not a valid template argument for type %qT because it is of type %qT
zh_CN: %qE不是类型%qT的有效模板实参，因为它的类型是%qT

en: %qE is not a valid template argument for type %qT because of conflicts in cv-qualification
zh_CN: %qE不是类型%qT的有效模板实参，因为 cv 限定冲突

en: %qE is not a valid template argument for type %qT because string literals can never be used in this context
zh_CN: %qE不是类型%qT的有效模板实参，因为字面字符串不能用在此上下文中

en: %qE is not a variable in clause %<firstprivate%>
zh_CN: %qE在子句%<firstprivate%>中不是一个变量

en: %qE is not a variable in clause %<lastprivate%>
zh_CN: %qE在子句%<lastprivate%>中不是一个变量

en: %qE is not a variable in clause %qs
zh_CN: %qE在子句%qs中不是一个变量

en: %qE is not an Objective-C class name or alias
zh_CN: %qE不是一个 Objective-C 类名或别名

en: %qE is not at beginning of declaration
zh_CN: %qE没有出现在声明的开头

en: %qE is not initialized
zh_CN: %qE未经初始化

en: %qE is not of type %qT
zh_CN: %qE的类型不是%qT

en: %qE is predetermined %qs for %qs
zh_CN: %qE可被预先确定为%qs，为%qs

en: %qE may not respond to %<%c%E%>
zh_CN: %qE可能不能响应%<%c%E%>

en: %qE must be %<threadprivate%> for %<copyin%>
zh_CN: %qE必须是%<threadprivate%>方可%<copyin%>

en: %qE needs isa option %s
zh_CN: %qE需要 ISA 选项 %s

en: %qE needs unknown isa option
zh_CN: %qE需要未知的 ISA 选项

en: %qE redeclared as different kind of symbol
zh_CN: %qE被重新声明为不同意义的符号

en: %qE redeclared with conflicting %qs attributes
zh_CN: %qE重声明有冲突的属性%qs

en: %qE undeclared (first use in this function)
zh_CN: %qE未声明(在此函数内第一次使用)

en: %qE undeclared here (not in a function)
zh_CN: %qE未声明(不在函数内)

en: %qF requires %<-mvx%>
zh_CN: %qF 需要 %<-mvx%>

en: %qF requires z14 or higher
zh_CN: %qF 需要 z14 或更高

en: %qF requires z15 or higher
zh_CN: %qF 需要 z15 或更高

en: %qT and %qT are in disjoint named address spaces
zh_CN: %qT和%qT在不相交的有名地址空间里

en: %qT declared with greater visibility than its base %qT
zh_CN: %qT被声明为比其基类%qT有更高的可见性

en: %qT declared with greater visibility than the type of its field %qD
zh_CN: %qT被声明为比其字段%qD的类型有更高的可见性

en: %qT has no member named %qE
zh_CN: %qT没有名为%qE的成员

en: %qT has no non-static data member named %qD
zh_CN: %qT没有名为%qD的非静态数据成员

en: %qT is a variably modified type
zh_CN: %qT是一个可变类型

en: %qT is already a friend of %qT
zh_CN: %qT已经是%qT的友元

en: %qT is an ambiguous base of %qT
zh_CN: %qT是%qT的有歧义的基类

en: %qT is an inaccessible base of %qT
zh_CN: %qT是%qT不可访问的基类

en: %qT is not a base of %qT
zh_CN: %qT不是%qT的基类

en: %qT is not a class or namespace
zh_CN: %qT既不是类也不是命名空间

en: %qT is not a class type
zh_CN: %qT不是一个类

en: %qT is not a class, struct, or union type
zh_CN: %qT不是类、结构或联合类型

en: %qT is not a member class template of %qT
zh_CN: %qT不是%qT的成员类模板

en: %qT is not a member of %qT
zh_CN: %qT不是%qT的成员

en: %qT is not a nested class of %qT
zh_CN: %qT不是%qT的嵌套类

en: %qT is not a pointer-to-object type
zh_CN: %qT不是一个指向对象的类型

en: %qT is not a template
zh_CN: %qT不是一个模板

en: %qT is not a template type
zh_CN: %qT不是一个模板类型

en: %qT is not an accessible base of %qT
zh_CN: %qT是%qT的一个不可访问的基类

en: %qT is promoted to %qT when passed through %<...%>
zh_CN: 通过%<...%>传递时%qT被提升为%qT

en: %qT referred to as %qs
zh_CN: %qT作为%qs被引用

en: %qT referred to as enum
zh_CN: %qT作为枚举被引用

en: %qT resolves to %qT, which is not an enumeration type
zh_CN: %qT被解析到非枚举类型%qT

en: %qV qualifiers cannot be applied to %qT
zh_CN: %qV限定符不能应用到%qT上

en: %qs at %L is not a VALUE
zh_CN: %2$L 处的 %1$qs 不是一个 VALUE

en: %qs attribute ignored
zh_CN: 忽略%qs属性

en: %qs attribute only applies to functions
zh_CN: %qs属性只能应用于函数

en: %qs attribute only applies to variadic functions
zh_CN: %qs属性只能用于带可变参数函数

en: %qs attribute requires prototypes with named arguments
zh_CN: %qs属性需要带有名参数的原型

en: %qs combined with %<auto%> qualifier for %qE
zh_CN: %qs和%<auto%>限定符同时用于%qE

en: %qs combined with %<register%> qualifier for %qE
zh_CN: %qs和%<register%>限定符同时用于%qE

en: %qs declared as function returning a function
zh_CN: %qs声明为返回一个函数的函数

en: %qs declared as function returning an array
zh_CN: %qs声明为返回一个数组的函数

en: %qs defined in a non-class scope
zh_CN: %qs定义在在非类作用域中

en: %qs does not support MIPS16 code
zh_CN: %qs不支持 MIPS16 代码

en: %qs expects a constant argument
zh_CN: %qs需要一个常量实参

en: %qs has both %<extern%> and initializer
zh_CN: %qs既有%<extern%>又有初始值设定

en: %qs has overflowed
zh_CN: %qs溢出

en: %qs initialized and declared %<extern%>
zh_CN: %qs已初始化，却又被声明为%<extern%>

en: %qs is deprecated
zh_CN: %qs 已弃用

en: %qs is deprecated; use -fno-zero-initialized-in-bss
zh_CN: %qs 已弃用；请换用 -fno-zero-initialized-in-bss

en: %qs is deprecated; use -fstack-check
zh_CN: %qs 已弃用；请换用 -fstack-check

en: %qs is narrower than values of its type
zh_CN: %qs比其类型的值要窄

en: %qs is not a directory
zh_CN: %qs 不是目录

en: %qs is not a gcov data file
zh_CN: %qs不是一个 gcov 数据文件

en: %qs is not valid for %qs
zh_CN: %qs对%qs而言无效

en: %qs is version %q.*s, expected version %q.*s
zh_CN: %qs的版本是%q.*s，需要的版本%q.*s

en: %qs must be used with %qs
zh_CN: %qs必须与%qs一起使用

en: %qs requires VSX support
zh_CN: %qs 需要 VSX 支持

en: %qs requires a target that provides the %qs instruction
zh_CN: %qs需要一个能提供%qs指令的目标机

en: %qs requires branch-likely instructions
zh_CN: %qs需要 Branch-Likely 指令

en: %qs specified for auto variable %qE
zh_CN: 为 auto 变量%2$qE指定了%1$qs

en: %qs specified for parameter %qE
zh_CN: 为形参%2$qE指定了%1$qs

en: %qs specified for structure field
zh_CN: 为结构字段指定了%qs

en: %qs specified for structure field %qE
zh_CN: 为结构字段%2$qE指定了%1$qs

en: %qs specified for unnamed parameter
zh_CN: 为无名形参指定了%qs

en: %qs tag used in naming %q#T
zh_CN: 使用了%qs标记，在命名%q#T时

en: %qs uses dynamic stack allocation
zh_CN: %qs使用动态栈分配

en: %s  Same as %s.
zh_CN: %s  与 %s 相同。

en: %s %qE does not fully implement the %qE protocol
zh_CN: %s%qE没有完全实现%qE协议

en: %s %qs
zh_CN: %s%qs

en: %s '%s'
zh_CN: %s‘%s’

en: %s at %L must be INTEGER
zh_CN: %s (%L处)必须是 INTEGER

en: %s at %L must be a scalar
zh_CN: %s (%L处)必须是一个标量

en: %s attribute applied to %s %s at %L
zh_CN: %1$s 属性应用于%4$L处的 %2$s %3$s

en: %s attribute at %L is not allowed outside of the specification part of a module
zh_CN: %2$L处的 %1$s 属性不允许出现在模块规格说明以外

en: %s attribute conflicts with %s attribute at %L
zh_CN: %s 属性与 %s 属性在%L处冲突

en: %s attribute not allowed in BLOCK DATA program unit at %L
zh_CN: %s 属性在%L处不允许出现在 BLOCAK DATA 程序单元中

en: %s does not support %%n$ operand number formats
zh_CN: %s 不支持 %%n$ 操作数号格式字符串

en: %s does not support %s
zh_CN: %s 不支持 %s

en: %s does not support %s with the %<%%%c%> %s format
zh_CN: %s 不支持 %s 出现在%<%%%c%>%s 格式字符串中

en: %s does not support block_ends_with_call_p
zh_CN: %s 不支持 block_ends_with_call_p

en: %s does not support block_ends_with_condjump_p
zh_CN: %s 不支持 block_ends_with_condjump_p

en: %s does not support can_duplicate_block_p
zh_CN: %s 不支持 can_duplicate_block_p

en: %s does not support can_merge_blocks_p
zh_CN: %s 不支持 can_merge_blocks_p

en: %s does not support can_remove_branch_p
zh_CN: %s 不支持 can_remove_branch_p

en: %s does not support create_basic_block
zh_CN: %s 不支持 create_basic_block

en: %s does not support delete_basic_block
zh_CN: %s 不支持 delete_basic_block

en: %s does not support dump_bb_for_graph
zh_CN: %s 不支持 dump_bb_for_graph

en: %s does not support duplicate_block
zh_CN: %s 不支持 duplicate_block

en: %s does not support flow_call_edges_add
zh_CN: %s 不支持 flow_call_edges_add

en: %s does not support force_nonfallthru
zh_CN: %s 不支持 force_nonfallthru

en: %s does not support make_forwarder_block
zh_CN: %s 不支持 make_forwarder_block

en: %s does not support merge_blocks
zh_CN: %s 不支持 merge_blocks

en: %s does not support move_block_after
zh_CN: %s 不支持t move_block_after

en: %s does not support predict_edge
zh_CN: %s 不支持 predict_edge

en: %s does not support predicted_by_p
zh_CN: %s 不支持 predicted_by_p

en: %s does not support redirect_edge_and_branch
zh_CN: %s 不支持 redirect_edge_and_branch

en: %s does not support redirect_edge_and_branch_force
zh_CN: %s 不支持 redirect_edge_and_branch_force

en: %s does not support split_block
zh_CN: %s 不支持 split_block

en: %s does not support split_edge
zh_CN: %s 不支持 split_edge

en: %s does not support the %<%%%c%> %s format
zh_CN: %s 不支持%<%%%c%>%s 格式

en: %s does not support the %<%%%s%c%> %s format
zh_CN: %s 不支持%<%%%s%c%>%s 格式

en: %s does not support the %qs %s length modifier
zh_CN: %s 不支持%qs%s 长度修饰符

en: %s expression list treated as compound expression
zh_CN: %s 表达式列表被看作复合表达式

en: %s ignored with %s and %<%%%c%> %s format
zh_CN: %s 与 %s 和%<%%%c%>%s 格式字符串合用时被忽略

en: %s ignored with %s in %s format
zh_CN: %s 和 %s 出现在 %s 格式字符串中时被忽略

en: %s is not supported by this configuration
zh_CN: %s 不为这个配置所支持

en: %s procedure at %L is already declared as %s procedure
zh_CN: %2$L处的 %1$s 过程已经被声明为 %3$s 过程

en: %s returned %d exit status
zh_CN: %s 以返回值 %d 退出

en: %s statement at %C cannot follow %s statement at %L
zh_CN: %s 语句在%C处不能跟随 %s 语句在%L处

en: %s statement at %C cannot terminate a non-block DO loop
zh_CN: %2$C处的 %1$s 语句不能终止一个不成块的 DO 循环

en: %s statement at %C follows another accessibility specification
zh_CN: %2$C处 %1$s 语句出现在其他访问规格之后

en: %s statement expected at %L
zh_CN: 需要 %s 语句在%L处

en: %s statement is not allowed inside of BLOCK at %C
zh_CN: %s 语句不能用在%C处 BLOCK 内

en: %s statement must appear in a MODULE
zh_CN: %s 语句必须出现在 MODULE 中

en: %s statement not allowed in PURE procedure at %C
zh_CN: %s 语句不允许出现在%C处的 PURE 程序中

en: %s tag
zh_CN: %s 标记

en: %s tag at %L must be of type %s
zh_CN: %s 标记在%L处必须具有类型 %s

en: %s tag at %L must be scalar
zh_CN: %s 标记在%L处必须是标量

en: %s terminated with signal %d [%s]%s
zh_CN: %s 以信号 %d [%s]%s 退出

en: %s used with %<%%%c%> %s format
zh_CN: %s 与%<%%%c%>%s 格式并用

en: %s variable %qE is private in outer context
zh_CN: %s 变量%qE在外层上下文中是私有的

en: %s%qs%s is invalid
zh_CN: %s%qs%s 无效

en: %s%s%s %sversion %s (%s)
    %s	compiled by GNU C version %s,
zh_CN: %s%s%s %s版本 %s (%s)
    %s	由 GNU C 版本 %s 编译，

en: %s%s%s %sversion %s (%s) compiled by CC,
zh_CN: %s%s%s %s版本 %s (%s)，由 CC 编译，

en: %s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
zh_CN: %s%sGGC 准则：--param ggc-min-expand=%d --param ggc-min-heapsize=%d

en: %s%swarning: %s header version %s differs from library version %s.
zh_CN: %s%s警告：%s 头文件版本 %s 与库版本 %s 不同。

en: %s-%s is an empty range
zh_CN: %s-%s 是一个空的范围

en: %s: %d basic blocks and %d edges/basic block
zh_CN: %s：%d 个基本块，%d 边/基本块

en: %s: %m
zh_CN: %s：%m

en: %s: %s
zh_CN: %s：%s

en: %s: %s compiler not installed on this system
zh_CN: %s：此系统未安装 %s 编译器

en: %s: %s: %s
zh_CN: %s：%s：%s

en: %s: PCH file was invalid
zh_CN: %s：PCH 文件无效

en: %s: all warnings being treated as errors
zh_CN: %s：所有的警告都被当作是错误

en: %s: cannot open as COFF file
zh_CN: %s：不能打开 COFF 文件

en: %s: could not determine length of compare-debug file %s
zh_CN: %s：无法确定比较调试文件 %s 的长度

en: %s: could not open compare-debug file %s
zh_CN: %s：无法打开比较调试文件 %s

en: %s: couldn%'t open PCH file: %m
zh_CN: %s：无法打开 PCH 文件：%m

en: %s: linker input file unused because linking not done
zh_CN: %s：未使用链接器输入文件，因为链接尚未完成

en: %s: not a COFF file
zh_CN: %s：不是一个 COFF 文件

en: %s: some warnings being treated as errors
zh_CN: %s：有些警告被当作是错误

en: %s:%d: confused by earlier errors, bailing out
zh_CN: %s:%d：不能从先前的错误中恢复，退出

en: %s:'%s' has arcs from exit block
zh_CN: %s：‘%s’有来自出口块的弧

en: %s:'%s' has arcs to entry block
zh_CN: %s：‘%s’有去往入口块的弧

en: %s:'%s' lacks entry and/or exit blocks
zh_CN: %s：‘%s’缺少入口/出口块

en: %s:already seen blocks for '%s'
zh_CN: %s：已经遇过‘%s’的块

en: %s:cannot open data file, assuming not executed
zh_CN: %s：无法打开数据文件，假定未被执行过

en: %s:cannot open notes file
zh_CN: %s:无法打开说明文件

en: %s:corrupted
zh_CN: %s：已损坏

en: %s:graph is unsolvable for '%s'
zh_CN: %s：图为‘%s’不可解

en: %s:no functions found
zh_CN: %s：找不到函数

en: %s:no lines for '%s'
zh_CN: %s：‘%s’没有行

en: %s:not a gcov data file
zh_CN: %s：不是一个 gcov 数据文件

en: %s:not a gcov notes file
zh_CN: %s:不是一个 gcov 说明文件

en: %s:overflowed
zh_CN: %s：溢出

en: %s:profile mismatch for '%s'
zh_CN: %s：样本文件与‘%s’不匹配

en: %s:source file is newer than notes file '%s'
zh_CN: %s源文件较说明文件‘%s’新

en: %s:stamp mismatch with notes file
zh_CN: %s:时间戳与说明文件不匹配

en: %s:version '%.4s', prefer '%.4s'
zh_CN: %s：版本‘%.4s’，首选‘%.4s’

en: %s:version '%.4s', prefer version '%.4s'
zh_CN: %s：版本‘%.4s’，首选版本‘%.4s’

en: '
zh_CN: ’

en: ' ' flag
zh_CN: ‘ ’标记

en: '!' flag
zh_CN: ‘!’标记

en: '#' flag
zh_CN: ‘#’标记

en: '%%%c' is not a valid operand prefix
zh_CN: ‘%%%c’不是一个有效的操作数前缀

en: '%%&' used without any local dynamic TLS references
zh_CN: 使用‘%%&’ 时没有指定任何动态 TLS 引用

en: '%%l' operand isn't a label
zh_CN: ‘%%l’操作数不是一个标号

en: '%s' file is already processed
zh_CN: 文件 '%s' 已经被处理

en: ''' flag
zh_CN: ‘'’标记

en: '(' flag
zh_CN: ‘(’标记

en: '+' flag
zh_CN: ‘+’标记

en: '-' flag
zh_CN: ‘-’标记

en: '0' flag
zh_CN: ‘0’标记

en: 'B' operand has multiple bits set
zh_CN: ‘B’操作数设置了多个位

en: 'B' operand is not constant
zh_CN: ‘B’操作数不是一个常量

en: 'E' modifier
zh_CN: ‘E’修饰符

en: 'I' flag
zh_CN: ‘I’标记

en: 'O' modifier
zh_CN: ‘O’修饰符

en: '^' flag
zh_CN: ‘^’标记

en: '_' flag
zh_CN: ‘_’标记

en: 'a' flag
zh_CN: ‘a’标记

en: 'm' flag
zh_CN: ‘m’标记

en: 'o' operand is not constant
zh_CN: ‘o’操作数不是一个常量

en: 'q' flag
zh_CN: ‘q’标记

en: (C)
zh_CN: ©

en: (Obsolete)	This is the default.
zh_CN: （已过时）这是默认情况。

en: (Obsolete) LD_PREBIND is no longer supported.
zh_CN: （已过时）LD_PREBIND 不再受支持。

en: (Obsolete) This is the default.
zh_CN: （已过时）这是默认情况。

en: (a pointer to member can only be formed with %<&%E%>)
zh_CN: (成员指针只能用%<&%E%>构成)

en: (an out of class initialization is required)
zh_CN: (需要一个类外的初始化)

en: (anonymous)
zh_CN: (匿名)

en: (if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)
zh_CN: (如果您使用%<-fpermissive%>，G++ 会接受您的代码，但是允许使用未定义的名称是已弃用的风格)

en: (near initialization for %qs)
zh_CN: (在%qs的初始化附近)

en: (perhaps %<typename %T::%E%> was intended)
zh_CN: (也许您本意是想用%<typename %T::%E%>)

en: (perhaps a semicolon is missing after the definition of %qT)
zh_CN: (%qT的定义末尾可能缺少一个分号)

en: (so you should pass %qT not %qT to %<va_arg%>)
zh_CN: (因此您应该向%<va_arg%>传递%qT而不是%qT)

en: (static destructors for %s)
zh_CN: (%s 的静态析构函数)

en: (static initializers for %s)
zh_CN: (%s 的静态初始值设定)

en: (the message is displayed only once per source file)
zh_CN: (此信息只对每个源文件显示一次)

en: ({anonymous})
zh_CN: ({匿名})

en: *** WARNING *** there are active plugins, do not report this as a bug unless you can reproduce it without enabling any plugins.
zh_CN: ***警告*** 存在活跃的插件；除非可以在不加载任何插件的情况下重现，请勿向 gcc 报告软件问题。

en: --param inline-unit-growth limit reached
zh_CN: 到达 --param inline-unit-growth 给定的极限

en: --param large-function-growth limit reached
zh_CN: 到达 --param large-function-growth 给定的极限

en: --param large-stack-frame-growth limit reached
zh_CN: 到达 --param large-stack-frame-growth 给定的极限

en: --param max-inline-insns-auto limit reached
zh_CN: 到达 --param max-inline-insns-single 给定的极限

en: --param max-inline-insns-single limit reached
zh_CN: 到达 --param max-inline-insns-single 给定的极限

en: -E or -x required when input is from standard input
zh_CN: 当输入来自标准输入设备时，需要 -E 或 -x

en: -J<directory>	Put MODULE files in 'directory'.
zh_CN: -J<目录>	将 MODULE 文件放入指定目录。

en: -U<macro>	Undefine <macro>.
zh_CN: -U<宏>	取消定义<宏>。

en: -Xbind-now and -Xbind-lazy are incompatible
zh_CN: -Xbind-now 与 -Xbind-lazy 不兼容

en: -bundle not allowed with -dynamiclib
zh_CN: -bundle 不允许与 -dynamiclib 一起使用

en: -bundle_loader not allowed with -dynamiclib
zh_CN: -bundle_loader 不能和 -dynamiclib 一起使用

en: -c or -S required for Ada
zh_CN: Ada 需要指定 -c 或 -S

en: -c required for gnat2scil
zh_CN: gnat2scil 需要 -c

en: -c required for gnat2why
zh_CN: gnat2why 需要 -c

en: -client_name not allowed with -dynamiclib
zh_CN: -client_name 不能和 -dynamiclib 一起使用

en: -compatibility_version only allowed with -dynamiclib
zh_CN: -compatibility_version 只能和 -dynamiclib 一起使用

en: -current_version only allowed with -dynamiclib
zh_CN: -current_version 只能和 -dynamiclib 一起使用

en: -f%s ignored (not supported for DJGPP)
zh_CN: -f%s 已被忽略（不支持 DJGPP）

en: -fconvert=<big-endian|little-endian|native|swap|r16_ieee|r16_ibm>	The endianness used for unformatted files.
zh_CN: -fconvert=<big-endian|little-endian|native|swap|r16_ieee|r16_ibm>	用于非格式化文件的字节序。

en: -fdoc-dir=<dir>	Write documentation file to directory <dir>.
zh_CN: -fdoc-dir=<dir>	将文档写入指定目录 <dir> 中。

en: -fdoc-file=<file>	Write documentation to <file>.
zh_CN: -o <文件>	将文档写入指定 <文件>。

en: -finline-arg-packing	Perform argument packing inline.
zh_CN: -finline-arg-packing	内联执行参数打包。

en: -fira-verbose=<number>	Control IRA's level of diagnostic messages.
zh_CN: -fira-verbose=<N>	控制 IRA 诊断信息的级别。

en: -force_flat_namespace not allowed with -dynamiclib
zh_CN: -force_flat_namespace 不能和 -dynamiclib 一起使用

en: -fsanitize=address is not supported in this configuration
zh_CN: 该配置不支持 -fsanitize=address

en: -fuse-linker-plugin is not supported in this configuration
zh_CN: -fuse-linker-plugin 在此配置下不受支持

en: -fvtable-verify=preinit is not supported in this configuration
zh_CN: -fvtable-verify=preinit 在此配置下不受支持

en: -fvtable-verify=std is not supported in this configuration
zh_CN: -fvtable-verify=std 在此配置下不受支持

en: -gz is not supported in this configuration
zh_CN: -gz 在此配置下不受支持

en: -gz=zstd is not supported in this configuration
zh_CN: -gz=zstd 在此配置下不受支持

en: -install_name only allowed with -dynamiclib
zh_CN: -install_name 只能和 -dynamiclib 一起使用

en: -keep_private_externs not allowed with -dynamiclib
zh_CN: -keep_private_externs 不能和 -dynamiclib 一起使用

en: -mas100-syntax is incompatible with -gdwarf
zh_CN: -mas100-syntax 与 -gdwarf 不兼容

en: -mcode-region requires the large memory model (-mlarge)
zh_CN: -mcode-region 需要大内存模型(-mlarge)

en: -mdata-region requires the large memory model (-mlarge)
zh_CN: -mdata-region 需要大内存模型(-mlarge)

en: -mdebug=	Enable debug output.
zh_CN: -mdebug=	启用调试输出。

en: -mhard-float not supported
zh_CN: 不支持 -mhard-float

en: -msim	Use simulator runtime.
zh_CN: -msim	使用仿真器运行时。

en: -msingle-float and -msoft-float cannot both be specified
zh_CN: 不能同时指定 -msingle-float 和 -msoft-float

en: -mx32 is not supported on Solaris
zh_CN: Solaris 不支持 -mx32

en: -pg and -fomit-frame-pointer are incompatible
zh_CN: -pg 和 -fomit-frame-pointer 互不兼容

en: -pie is not supported in this configuration
zh_CN: -pie 在此配置下不受支持

en: -private_bundle not allowed with -dynamiclib
zh_CN: -private_bundle 不能和 -dynamiclib 一起使用

en: -stdlib=[libstdc++|libc++]	The standard library to be used for C++ headers and runtime.
zh_CN: -stdlib=[libstdc++|libc++]	要为 C++ 头文件和运行时使用的标准库。

en: -trigraphs	Support ISO C trigraphs.
zh_CN: -trigraphs	支持 ISO C 三元符。

en: .NOT. operator in expression at %L must have a LOGICAL operand
zh_CN: %L处的表达式中的 .NOT. 运算符必须带 LOGICAL 操作数

en: 31 bit ABI.
zh_CN: 31 位 ABI。

en: 387 instruction set disabled, using SSE arithmetics
zh_CN: 387 指令集已禁用，使用 SSE 指令

en: 64 bit ABI.
zh_CN: 64 位 ABI。

en: 64-bit ABI not supported in ESA/390 mode
zh_CN: 64-bit ABI 在 ESA/390 模式下不受支持

en: <During initialization>
zh_CN: <在初始化过程中>

en: <anonymous>
zh_CN: <匿名>

en: <brace-enclosed initializer list>
zh_CN: <花括号内的初始值列表>

en: <command-line>
zh_CN: <命令行>

en: <declaration error>
zh_CN: <声明错误>

en: <enumerator>
zh_CN: <枚举值>

en: <erroneous-expression>
zh_CN: <错误表达式>

en: <expression error>
zh_CN: <表达式错误>

en: <missing>
zh_CN: <丢失>

en: <return value>
zh_CN: <返回值>

en: <return-value>
zh_CN: <返回值>

en: <statement>
zh_CN: <语句>

en: <tag-error>
zh_CN: <tag 错误>

en: <template parameter error>
zh_CN: <模板参数数错误>

en: <throw-expression>
zh_CN: <throw 表达式>

en: <type error>
zh_CN: <类型错误>

en: <type-error>
zh_CN: <类型错误>

en: <typedef-error>
zh_CN: <typedef 错误>

en: <typeprefixerror>
zh_CN: <类型前缀错误>

en: <unknown operator>
zh_CN: <未知的运算符>

en: <unknown>
zh_CN: <未知>

en: <unnamed-fixed:
zh_CN: <无名定点数：

en: <unnamed-float:
zh_CN: <无名浮点数：

en: <unnamed-unsigned:
zh_CN: <无名无符号：

en: <unnamed>
zh_CN: <无名>

en: <unparsed>
zh_CN: <未解析>

en: <unresolved overloaded function type>
zh_CN: <未解决的重载函数类型>

en: ACCESS specification at %L was already specified
zh_CN: %L处的 ACCESS 规格已经被指定

en: ALLOCATABLE specified outside of INTERFACE body at %L
zh_CN: %L 处 ALLOCATABLE 指定在 INTERFACE 体之外

en: ALTERNATE RETURN not permitted at %L
zh_CN: %L 不允许有 ALTERNATIVE RETURN

en: APCS reentrant code not supported.  Ignored
zh_CN: 不支持 APCS 重入代码。已忽略

en: ASSIGN statement at %L requires a scalar default INTEGER variable
zh_CN: %L处的 ASSIGN 语句需要一个默认标量 INTEGER 变量

en: AUX pointer initialized for edge %d->%d
zh_CN: 为边 %d->%d 初始化 AUX 指针

en: AVX vector argument without AVX enabled changes the ABI
zh_CN: 没有启用 AVX，却出现了 AVX 向量实参，这改变了 ABI

en: Abbreviation for "-g -feliminate-unused-debug-symbols".
zh_CN: "-g -feliminate-unused-debug-symbols" 的缩写。

en: Abbreviation for "-g -fno-eliminate-unused-debug-symbols".
zh_CN: "-g -fno-eliminate-unused-debug-symbols" 的缩写。

en: Access specification of the %s operator at %C has already been specified
zh_CN: %2$C处的 %1$s 运算符的访问规格说明已经被指定

en: Access specification of the .%s. operator at %C has already been specified
zh_CN: %2$C处的 .%1$s. 运算符的访问规格说明已经被指定

en: Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)
zh_CN: 字符串的实际长度不匹配其虚参声明‘%s’(%ld/%ld)

en: Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)
zh_CN: 字符串的实际长度短于其虚参声明‘%s’(%ld/%ld)

en: Align code and data to 32 bits.
zh_CN: 将代码和数据对齐到 32 位边界上。

en: Allocatable component of structure at %C must have a deferred shape
zh_CN: %C处可分配的组件必须有延迟的外形

en: Allocate-object at %L also appears at %L
zh_CN: %L处分配的对象也出现在%L处

en: Allocate-object at %L must be ALLOCATABLE or a POINTER
zh_CN: %L处的分配对象必须是 ALLOCATABLE 或 POINTER

en: Allow a BOZ literal constant to appear in an invalid context and with X instead of Z.
zh_CN: 允许 BOZ 字面常量在无效上下文中出现，并且使用 X 代替 Z.

en: Allow dollar signs in entity names.
zh_CN: 允许在实体名中使用美元符号。

en: Allow implicit conversions between vectors with differing numbers of subparts and/or differing element types.
zh_CN: 允许具有不同元素数量和/或元素类型的向量间的转换。

en: Already inside a CONTAINS block at %C
zh_CN: %C处已在一个 CONTAINS 块内部

en: Alternate RETURN statement at %C is only allowed within a SUBROUTINE
zh_CN: %C处的替代 RETURN 语句只允许出现在 SUBROUTINE 中

en: Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier
zh_CN: %L处的替代 RETURN 语句需要一个 SCALAR-INTEGER 返回限定符

en: Alternate return cannot appear in operator interface at %L
zh_CN: 替代返回不能出现在%L处的运算符接口中

en: AltiVec argument passed to unprototyped function
zh_CN: 传递 AltiVec 参数给无原型的函数

en: AltiVec not supported in this target
zh_CN: AltiVec 在此目标机上不受支持

en: Always generate long calls.
zh_CN: 总是生成长调用。

en: Always treat bitfields as int-sized.
zh_CN: 总认为位段长与 int 相同。

en: Ambiguous symbol in TYPE definition at %C
zh_CN: %C处 TYPE 定义中的歧义符号

en: An alternate return at %L without a * dummy argument
zh_CN: %L 不带 * 虚参的替代返回

en: An outer FORALL construct already has an index with this name %L
zh_CN: %L处外部 FORALL 构造已经有一个同名的索引

en: Argument NCOPIES of REPEAT intrinsic is negative at %L
zh_CN: %L处内建 REPEAT 的 NCOPIES 实参是负的

en: Argument NCOPIES of REPEAT intrinsic is too large
zh_CN: 内建函数 REPEAT 的 NCOPIES 参数太大

en: Argument NCOPIES of REPEAT intrinsic is too large at %L
zh_CN: %L处内建 REPEAT 的 NCOPIES 实参太大

en: Argument dim at %L must be of INTEGER type
zh_CN: %L处实参维数必须具有 INTEGER 类型

en: Argument dim at %L must be scalar
zh_CN: %L 实参维数必须是标量

en: Argument of %s at %L must be of length one
zh_CN: %s 的参数(位于 %L)长度必须为 1

en: Argument of %s function at %L is negative
zh_CN: %2$L处 %1$s 函数的参数是负的

en: Argument of %s function at %L is too large for the collating sequence of kind %d
zh_CN: %2$L处的 %1$s 函数的参数对于种别为 %3$d 的对比序列来说太大

en: Argument of %s function at %L outside of range [0,127]
zh_CN: %2$L处 %1$s 函数的参数不在[0，127]范围内

en: Argument of ACOS at %L must be between -1 and 1
zh_CN: %L处 ACOS 的参数必须在 -1 和 1 之间

en: Argument of ACOSH at %L must not be less than 1
zh_CN: %L处 ACOSH 的参数必须不小于 1

en: Argument of ASIN at %L must be between -1 and 1
zh_CN: %L处 ASIN 的参数必须在 -1 和 1 之间

en: Argument of ATANH at %L must be inside the range -1 to 1
zh_CN: %L处 ATANH 的参数必须在 -1 和 1 之间

en: Argument of FINAL procedure at %L must not be ALLOCATABLE
zh_CN: %L处 FINAL 过程的参数必须不是 ALLOCATABLE

en: Argument of FINAL procedure at %L must not be INTENT(OUT)
zh_CN: %L处 FINAL 过程的参数必须不是 INTENT(OUT)

en: Argument of FINAL procedure at %L must not be OPTIONAL
zh_CN: %L处 FINAL 过程的参数必须不是 OPTIONAL

en: Argument of FINAL procedure at %L must not be a POINTER
zh_CN: %L处 FINAL 过程的参数必须不是 POINTER

en: Argument of IACHAR at %L must be of length one
zh_CN: %L处 IACHAR 的参数长度必须为 1

en: Argument of IACHAR function at %L outside of range 0..127
zh_CN: %L处 IACHAR 函数的实参不在 0..127 范围内

en: Argument of ICHAR at %L must be of length one
zh_CN: %L处 ICHAR 的参数长度必须为 1

en: Argument of LOG at %L cannot be less than or equal to zero
zh_CN: %L处 LOG 的实参不可以小于或等于零

en: Argument of LOG10 at %L cannot be less than or equal to zero
zh_CN: %L处 LOG10 的实参不可以小于或等于零

en: Argument of SELECT statement at %L cannot be %s
zh_CN: %L处 SELECT 语句的实参不能是 %s

en: Argument of SELECT statement at %L must be a scalar expression
zh_CN: %L处 SELECT 语句中的实参必须为标量

en: Argument of SQRT at %L has a negative value
zh_CN: %L处 SQRT 的参数为负

en: Arithmetic IF statement at %C
zh_CN: %C 处的算术 IF 语句

en: Arithmetic NaN at %L
zh_CN: %L处算术 NaN

en: Arithmetic OK at %L
zh_CN: %L处算术正常

en: Arithmetic OK converting %s to %s at %L
zh_CN: %3$L处从 %1$s 转换到 %2$s 算术正常

en: Arithmetic overflow at %L
zh_CN: %L处算术上溢

en: Arithmetic underflow at %L
zh_CN: %L处算术下溢

en: Array component of structure at %C must have an explicit shape
zh_CN: %C处结构的数组组件必须有显式的外形

en: Array component of structure at %C must have explicit or deferred shape
zh_CN: %C处结构的数组组件必须有显式或延迟的外形

en: Array index at %L is an array of rank %d
zh_CN: %L处数组索引是一个秩为 %d 的数组

en: Array index at %L must be of INTEGER type, found %s
zh_CN: %L处数组索引必须具有 INTEGER 类型而不是 %s

en: Array index at %L must be scalar
zh_CN: %L处数组索引必须是标量

en: Array operands are incommensurate at %L
zh_CN: %L处数组操作数无法被使用

en: Array operands are incommensurate converting %s to %s at %L
zh_CN: %3$L处从 %1$s 到 %2$s 的转换不适合数组操作数

en: Array reference at %C cannot have more than %d dimensions
zh_CN: %C处的任何引用都不能多于 %d 维

en: Array reference at %L is out of bounds (%ld < %ld) in dimension %d
zh_CN: %1$L处数组引用在第 %4$d 维中越界(%2$ld < %3$ld)

en: Array reference at %L is out of bounds (%ld > %ld) in dimension %d
zh_CN: %1$L处数组引用在第 %4$d 维中越界(%2$ld > %3$ld)

en: Array reference in EQUIVALENCE at %C cannot be an array section
zh_CN: %C处 EQUIVALENCE 中的数组引用不能是个数组段

en: Array reference out of bounds
zh_CN: 对数组的引用超出范围

en: Array section with a vector subscript at %L shall not be the target of a pointer
zh_CN: %L处由向量下标选择的数组段不应是指针的目标

en: Array specification at %C has more than %d dimensions
zh_CN: %C处数组规格中有多于 %d 的维数

en: Array specification must be deferred at %L
zh_CN: %L处数组规格必须延迟

en: Array specification required in ALLOCATE statement at %L
zh_CN: %L处的 ALLOCATE 语句中需要数组规格说明

en: Assembler options
    =================
zh_CN: 汇编器选项
    =========

en: Assigned GOTO statement at %C
zh_CN: %C 处赋值 GOTO 语句

en: Assigned label is not a target label
zh_CN: 赋值标号不是目标标号

en: Assigning value other than 0 or 1 to LOGICAL has undefined result at %L
zh_CN: %L处向 LOGICAL 赋 0 或 1 以外的值有未定义的结果

en: Assignment operator interface at %L must be a SUBROUTINE
zh_CN: %L处的运算符接口必须是一个 SUBROUTINE

en: Assignment operator interface at %L must have two arguments
zh_CN: %L处的赋值运算符接口必须有两个实参

en: Assignment operator interface at %L must not redefine an INTRINSIC type assignment
zh_CN: %L处的赋值运算符接口不能重复定义一个 INTRINSIC 类型赋值

en: Assignment to a FORALL index variable at %L
zh_CN: %L处向 FORALL 索引变量赋值

en: Assume ICPLBs are enabled at runtime.
zh_CN: 假定在运行时 ICPLB 是被启用的。

en: Assume code will be assembled by GAS.
zh_CN: 假定代码将由 GAS 汇编。

en: Assume code will be linked by GNU ld.
zh_CN: 假定代码将由 GNU ld 链接。

en: Assume code will be linked by HP ld.
zh_CN: 假定代码将由 HP ld 链接。

en: Assume normal C execution environment.
zh_CN: 假定一般的 C 执行环境。

en: Assumed shape array at %L must be a dummy argument
zh_CN: %L处假定外形的数组必须是一个虚参

en: Assumed size array at %L must be a dummy argument
zh_CN: %L处假定大小的数组必须是一个虚参

en: At global scope:
zh_CN: 在全局域：

en: At top level:
zh_CN: 在文件作用域：

en: Attempt to DEALLOCATE unallocated '%s'
zh_CN: 试图 DEALLOCATE 未分配的‘%s’

en: Attempt to indirectly overlap COMMON blocks %s and %s by EQUIVALENCE at %C
zh_CN: %3$C处的 EQUIVALENCE 试图间接地重叠 COMMON 块 %1$s 和 %2$s

en: Attribute at %L is not allowed in a TYPE definition
zh_CN: %L处的属性不允许出现在 TYPE 定义中

en: Avoid speculative loads to work around a hardware anomaly.
zh_CN: 禁用投机载入以避免一个硬件异常。

en: BB %i has incorrect edge
zh_CN: 基本块 %i 有不正确的边

en: BB %i has incorrect fallthru edge
zh_CN: 基本块 %i 有不正确的下落边

en: BB %i has multiple EH edges
zh_CN: 基本块 %i 有多个 EH 边

en: BB %i is missing an EH edge
zh_CN: 基本块 %i 缺少一条 EH 边

en: BB %i is missing an edge
zh_CN: 基本块 %i 缺少一条边

en: BB %i last statement has incorrectly set lp
zh_CN: 基本块 %i 最后一条语句设置了不正确的 lp

en: BB %i too many fallthru edges
zh_CN: 基本块 %i 下落边太多

en: BB_RTL flag not set for block %d
zh_CN: 块 %d 没有设置 BB_RTL 标志

en: BIND(C) applied to %s %s at %L
zh_CN: BIND(C) 应用于%3$L处的 %1$s %2$s

en: BIND(C) attribute at %C requires an interface with BIND(C)
zh_CN: %C处的 BIND(C) 属性要求一个具有 BIND(C)的接口

en: BIND(C) attribute at %L can only be used for variables or common blocks
zh_CN: %L处的 BIND(C) 属性只能用于变量或公共块

en: BIND(C) procedure with NAME may not have POINTER attribute at %C
zh_CN: %C处带有 NAME 的 BIND(C)过程不能有 POINTER 属性

en: BYTE type used at %C is not available on the target machine
zh_CN: %C处使用到的 BYTE 类型在目标机上不可用

en: Bad INTENT specification at %C
zh_CN: %C处错误的 INTENT 规格

en: Bad IO basetype (%d)
zh_CN: 错误的 IO 基类型(%d)

en: Bad allocate-object at %C for a PURE procedure
zh_CN: %C处 PURE 过程中分配对象错误

en: Bad array reference at %L
zh_CN: %L处数组引用错误

en: Bad array specification for an explicitly shaped array at %C
zh_CN: %C处显式外形数组的数组规格说明错误

en: Bad array specification for assumed shape array at %C
zh_CN: %C处假定外形数组的数组规格说明错误

en: Bad array specification in ALLOCATE statement at %L
zh_CN: %L处的 ALLOCATE 语句中有错误的数组规格

en: Bad continuation line at %C
zh_CN: %C处错误的续行

en: Bad kind for logical constant at %C
zh_CN: %C处逻辑常量的种别错误

en: Bad name
zh_CN: 错误的名字

en: Bad operator
zh_CN: 错误的运算符

en: Bad specification for assumed size array at %C
zh_CN: %C处假定大小数组的规格说明错误

en: Bad specification for deferred shape array at %C
zh_CN: %C处延迟外形数组的规格说明错误

en: Bad target in pointer assignment in PURE procedure at %L
zh_CN: %L处 PURE 过程中指针赋值目标错误

en: Bad type in constant expression
zh_CN: 常量表达式中类型错误

en: Base object for NOPASS type-bound procedure call at %L must be scalar
zh_CN: %L处 NOPASS 类型限定过程调用的基对象必须是标量

en: Binding attributes already specify passing, illegal NOPASS at %C
zh_CN: 捆绑属性已经指定传递，%C处 NOPASS 非法

en: Binding attributes already specify passing, illegal PASS at %C
zh_CN: 捆绑属性已经指定传递， %C处 PASS 非法

en: Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L
zh_CN: %C处空白 BLOCK DATA 与%L处先前的 BLOCK DATA 冲突

en: Blanket SAVE statement at %C follows previous SAVE statement
zh_CN: %C处覆盖 SAVE 语句跟随以前的 SAVE 语句

en: Block label is not appropriate for IF statement at %C
zh_CN: %C处的块标号不适于 IF 语句

en: Block label not appropriate for arithmetic IF statement at %C
zh_CN: %C处的块标号不适于算术 IF 语句

en: Board name [and memory region].
zh_CN: 板名字[和内存区域]。

en: Branch at %L may result in an infinite loop
zh_CN: %L处的分支可能导致无穷循环

en: Branches executed:%s of %d
zh_CN: 执行的分支：%s (共有 %d 个)

en: By-value argument at %L cannot be an array or an array section
zh_CN: %L处按值传递的实参不能是数组或数组段

en: By-value argument at %L is not allowed in this context
zh_CN: %L处上下文中不允许使用按值传递的实参

en: By-value argument at %L is not of numeric type
zh_CN: %L处按值传递的实参不具有数字类型

en: C kind type parameter is for type %s but type at %L is %s
zh_CN: C 种别类型参数对应类型 %s 但%L处的类型却是 %s

en: C++ constructors and destructors will not be invoked for Objective-C fields
zh_CN: 不会为 Objective-C 字段调用 C++ 构造和析构函数

en: C++ lookup of %qD would return a field, not a type
zh_CN: %qD的 C++ 查询会返回一个字段而非类型

en: C++ requires promoted type, not enum type, in %<va_arg%>
zh_CN: C++ 在%<va_arg%>中需要提升后的类型而不是枚举

en: CASE label at %L overlaps with CASE label at %L
zh_CN: %L处的 CASE 标号与%L处的 CASE 标号重叠

en: CFString literal expression is not a string constant
zh_CN: CFString 字面表达式不是一个字符串常量

en: CFString literal is missing
zh_CN: 缺少 CFString 字面量

en: CLOSE statement at %L requires a UNIT number
zh_CN: %L处的 CLOSE 语句需要一个 UNIT 数

en: CLOSE statement not allowed in PURE procedure at %C
zh_CN: CLOSE 语句不允许出现在%C处的 PURE 过程中

en: COLLAPSE clause argument not constant positive integer at %C
zh_CN: %C处的 COLLAPSE 分句参数不是正整数常量

en: COMMON block /%s/ not found at %C
zh_CN: %2$C处未发现 COMMON 块 /%1$s/

en: COMPLEX quantities cannot be compared at %L
zh_CN: %L处复数不能比较大小

en: CONTAINS statement at %C is already in a contained program unit
zh_CN: %C处的 CONTAINS 语句已经在包含的程序单元中

en: CPU you selected does not support x86-64 instruction set
zh_CN: 您选择的 CPU 不支持 x86-64 指令集

en: Calls executed:%s of %d
zh_CN: 执行的调用：%s (共 %d)

en: Cannot change attributes of USE-associated symbol %s at %L
zh_CN: 不能改变%2$L处 USE 关联的符号‘%1$s’的属性

en: Cannot change attributes of USE-associated symbol at %L
zh_CN: 不能改变%L处 USE 关联的符号的属性

en: Cannot find symbol %qs
zh_CN: 无法找到符号 %qs

en: Cannot map %s
zh_CN: 无法映射 %s

en: Cannot open %s
zh_CN: 无法打开 %s

en: Cannot open JSON output file %s
zh_CN: 无法打开 JSON 输出文件 %s

en: Cannot open file %qs
zh_CN: 无法打开文件 %qs

en: Cannot open source file %s
zh_CN: 无法打开源文件 %s

en: Cannot read %s
zh_CN: 无法读取 %s

en: Cannot specify IMPLICIT at %C after IMPLICIT NONE
zh_CN: 在 IMPLICIT NONE 后不能在%C处指定 IMPLICIT

en: Compile for 32-bit pointers.
zh_CN: 为 32 位指针编译。

en: Compile for 64-bit pointers.
zh_CN: 为 64 位指针编译。

en: Compile for ETRAX 100 (CRIS v8).
zh_CN: 为 ETRAX 100 (CRIS v8) 编译。

en: Compile for ETRAX 4 (CRIS v3).
zh_CN: 为 ETRAX 4 (CRIS v3) 编译。

en: Compile for V8+ ABI.
zh_CN: 为 V8+ ABI 编译。

en: Compile for the m32r.
zh_CN: 为 m32r 编译。

en: Compile for the m32r2.
zh_CN: 为 m32r2 编译。

en: Compile for the m32rx.
zh_CN: 为 m32rx 编译。

en: Compile for the v850 processor.
zh_CN: 为 v850 处理器编译。

en: Compile for the v850e processor.
zh_CN: 为 v850e 处理器编译。

en: Compile for the v850e1 processor.
zh_CN: 为 v850e1 处理器编译。

en: Compile for the v850e2 processor.
zh_CN: 为 v850e2 处理器编译。

en: Compile for the v850e2v3 processor.
zh_CN: 为 v850e2v3 处理器编译。

en: Compile for the v850e3v5 processor.
zh_CN: 为 v850e2v3 处理器编译。

en: Compile in debug code.
zh_CN: 生成大端序模式的代码

en: Compile release version.
zh_CN: 编译发布版本。

en: Complex argument of LOG at %L cannot be zero
zh_CN: %L处 LOG 的复数实参不可为零

en: Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute
zh_CN: %2$L处声明的有 SEQUENCE 类型的组件 %1$s 没有 SEQUENCE 属性

en: Component at %C must have the POINTER attribute
zh_CN: %C处的组件必须有 POINTER 属性

en: Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L
zh_CN: %L处对有非零秩的部分引用的右侧的组件不能有 ALLOCATABLE 属性

en: Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L
zh_CN: %L处对有非零秩的部分引用的右侧的组件不能有 POINTER 属性

en: Components in TYPE at %C must precede CONTAINS
zh_CN: %C处 TYPE 中的组件必须先于 CONTAINS

en: Concat operator at %L must concatenate strings of the same kind
zh_CN: %L处的毗连运算符必须毗连同一种别的字符串

en: Concatenation operator in expression at %L must have two CHARACTER operands
zh_CN: %L处表达式中的毗连运算符必须有两个 CHARACTER 操作数

en: Configured with: %s
zh_CN: 配置为：%s

en: Conform to nothing in particular.
zh_CN: 不特别遵循任何标准。

en: Conform to the ISO 1990 C standard as amended in 1994.
zh_CN: 遵循 ISO 1990 C 标准于 1994 年修订的版本。

en: Conform to the ISO 1990 C standard with GNU extensions.
zh_CN: 遵循 ISO 1990 C 标准，也支持 GNU 扩展。

en: Conform to the ISO 1990 C standard.
zh_CN: 遵循 ISO 1990 C 标准。

en: Conform to the ISO 1998 C++ standard revised by the 2003 technical corrigendum with GNU extensions.
zh_CN: 遵循 ISO 1998 C++ 标准于 2003 年的技术勘误版本，也支持 GNU 扩展。

en: Conform to the ISO 1998 C++ standard revised by the 2003 technical corrigendum.
zh_CN: 遵循 ISO 1998 C++ 标准于 2003 年的技术勘误版本。

en: Conform to the ISO 1999 C standard with GNU extensions.
zh_CN: 遵循 ISO 1999 C 标准，也支持 GNU 扩展。

en: Conform to the ISO 1999 C standard.
zh_CN: 遵循 ISO 1999 C 标准。

en: Conform to the ISO 2011 C standard with GNU extensions.
zh_CN: 遵循 ISO 2011 C 标准，也支持 GNU 扩展。

en: Conform to the ISO 2011 C standard.
zh_CN: 遵循 ISO 2011 C 标准。

en: Conform to the ISO 2011 C++ standard with GNU extensions.
zh_CN: 遵循 ISO 2011 C++ 标准，也支持 GNU 扩展。

en: Conform to the ISO 2011 C++ standard.
zh_CN: 遵循 ISO 2011 C++ 标准。

en: Conform to the ISO 2014 C++ standard with GNU extensions.
zh_CN: 遵循 ISO 2014 C++ 标准，也支持 GNU 扩展。

en: Conform to the ISO 2014 C++ standard.
zh_CN: 遵循 ISO 2014 C++ 标准。

en: Conform to the ISO 2017 C standard (published in 2018) with GNU extensions.
zh_CN: 遵循 ISO 2017 C 标准（发布于2018年），也支持 GNU 扩展

en: Conform to the ISO 2017 C standard (published in 2018).
zh_CN: 遵循 ISO 2017 C 标准（于2018年发布）。

en: Conform to the ISO 2017 C++ standard with GNU extensions.
zh_CN: 遵循 ISO 2017 C++ 标准，也支持 GNU 扩展。

en: Conform to the ISO 2017 C++ standard.
zh_CN: 遵循 ISO 2017 C++ 标准。

en: Conform to the ISO 2020 C++ standard (experimental and incomplete support).
zh_CN: 遵循 ISO 2020 C++ 标准（试验性质的不完全支持）。

en: Conform to the ISO 2020 C++ standard with GNU extensions (experimental and incomplete support).
zh_CN: 遵循 ISO 2020 C++ 标准和 GNU 扩展（试验性质的不完全支持）

en: Conform to the ISO 2023 C standard draft (expected to be published in 2024) (experimental and incomplete support).
zh_CN: 遵循 ISO 2023 C++ 标准草案（预计于2024年发布）（试验性质的不完全支持）。

en: Conform to the ISO 2023 C++ draft standard (experimental and incomplete support).
zh_CN: 遵循 ISO 2023 C++ 标准草案（试验性质的不完全支持）。

en: Conform to the ISO 2026 C++ draft standard (experimental and incomplete support).
zh_CN: 遵循 ISO 2026 C++ 标准草案（试验性质的不完全支持）。

en: Conform to the ISO Fortran 2003 standard.
zh_CN: 遵循 ISO Fortran 2003 标准。

en: Conform to the ISO Fortran 2008 standard including TS 29113.
zh_CN: 遵循 ISO Fortran 2008 标准，包括 TS 29113.

en: Conform to the ISO Fortran 2008 standard.
zh_CN: 遵循 ISO Fortran 2008 标准。

en: Conform to the ISO Fortran 2018 standard.
zh_CN: 遵循 ISO Fortran 2008 标准。

en: Conform to the ISO Fortran 95 standard.
zh_CN: 遵循 ISO Fortran 95 标准。

en: Conform to the Objective-C 1.0 language as implemented in GCC 4.0.
zh_CN: 遵循于 GCC 4.0 实现的 Ojbective-C 1.0 语言。

en: Consider access to byte sized memory slow.
zh_CN: 认为按字节访问内存速度较慢。

en: Consider type 'int' to be 32 bits wide.
zh_CN: 认为‘int’类型有 32 位宽。

en: Constant expression in FORMAT tag at %L must be of type default CHARACTER
zh_CN: %L处 FORMAT 标记中的常量表达式默认类型必须为 CHARACTER

en: Constant expression required at %C
zh_CN: %C处需要常量表达式

en: Conversion from %s to %s at %L
zh_CN: 从 %s 转换到 %s，位于 %L

en: Conversion of an Infinity or Not-a-Number at %L to INTEGER
zh_CN: 在%L处把一个无穷大或非数转换为 INTEGER

en: Could not open output file '%s'
zh_CN: 无法打开输出文件 '%s'

en: Cray Pointee at %C cannot be assumed shape array
zh_CN: %C处 Cray 指针不能指向假定外形数组

en: Cray Pointee at %L appears in multiple pointer() statements
zh_CN: %L处 Cray 指针指向的对象出现在多个 pointer() 语句中

en: Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes
zh_CN: %C处的 Cray 指针精度为 %d；内存地址需要 %d 字节

en: Cray pointer at %C must be an integer
zh_CN: %C处 Cray 指针必须是一个整数

en: Create GUI application.
zh_CN: 创建图形界面应用程序。

en: Create a shared library.
zh_CN: 生成一个共享库。

en: Create console application.
zh_CN: 创建控制台程序。

en: Creating '%s'
zh_CN: 正在创建 '%s'

en: Creating array temporary at %L
zh_CN: 在%L处建立临时数组

en: DATA statement at %C is not allowed in a PURE procedure
zh_CN: DATA 语句不允许出现在%C处的 PURE 过程中

en: DATA statement at %L has more values than variables
zh_CN: %L处的 DATA 语句中值比变量多

en: DATA statement at %L has more variables than values
zh_CN: %L处的 DATA 语名中变量比值多

en: DIM argument at %L is out of bounds
zh_CN: %L处的 DIM 参数越界

en: DO step value is zero
zh_CN: DO 步进值为零

en: Darwin does not support -mfentry or associated options
zh_CN: Darwin 不支持 -mfentry 以及相关选项

en: Darwin is not an mx32 platform
zh_CN: Darwin 不是 mx32 平台

en: Data element above array upper bound at %L
zh_CN: %L处数据元素高于数组上限

en: Data element below array lower bound at %L
zh_CN: %L处数据元素低于数组下限

en: Data is stored in big-endian format.
zh_CN: 数据被存储为大端在前的格式。

en: Data is stored in little-endian format.  (Default).
zh_CN: 数据被存储为小端在前的格式。(默认)

en: Data transfer element at %L cannot be a full reference to an assumed-size array
zh_CN: %L处数据传输元素不能是对一个假定大小数组的全引用

en: Data transfer element at %L cannot have PRIVATE components
zh_CN: %L处数据传输元素不能有 PRIVATE 组件

en: Deleted feature:
zh_CN: 删除的特性：

en: Deprecated in favor of -std=c++11.
zh_CN: 已弃用，请改用 -std=c++11。

en: Deprecated in favor of -std=c++14.
zh_CN: 已弃用，请改用 -std=c++14。

en: Deprecated in favor of -std=c++17.
zh_CN: 已弃用，请改用 -std=c++17。

en: Deprecated in favor of -std=c11.
zh_CN: 已弃用，请改用 -std=c11。

en: Deprecated in favor of -std=c23.
zh_CN: 已弃用，请改用 -std=c23。

en: Deprecated in favor of -std=c99.
zh_CN: 已弃用，请改用 -std=c99。

en: Deprecated in favor of -std=gnu++11.
zh_CN: 已弃用，请改用 -std=gnu++11。

en: Deprecated in favor of -std=gnu++14.
zh_CN: 已弃用，请改用 -std=gnu++14。

en: Deprecated in favor of -std=gnu++17.
zh_CN: 已弃用，请改用 -std=gnu+17。

en: Deprecated in favor of -std=gnu11.
zh_CN: 已弃用，请改用 -std=gnu11。

en: Deprecated in favor of -std=gnu23.
zh_CN: 已弃用，请改用 -std=gnu23。

en: Deprecated in favor of -std=gnu99.
zh_CN: 已弃用，请改用 -std=gnu99。

en: Deprecated in favor of -std=iso9899:1999.
zh_CN: 已弃用，请改用 -std=iso9899:1999。

en: Deprecated.  This switch has no effect.
zh_CN: 已弃用。此开关不起作用。

en: Derived type at %C can only be PRIVATE in the specification part of a module
zh_CN: %C处的派生类型在模块规格说明部分内只能是 PRIVATE

en: Derived type at %C can only be PUBLIC in the specification part of a module
zh_CN: %C处的派生类型在模块规格说明部分内只能是 PUBLIC

en: Derived type at %C has not been previously defined and so cannot appear in a derived type definition
zh_CN: %C处的派生类型以前尚未被定义，因此不能出现在派生类型定义中

en: Derived type component %C is not a permitted EQUIVALENCE member
zh_CN: 派生类型组件%C不是允许的 EQUIVALENCE 成员

en: Derived type declaration with FINAL at %C must be in the specification part of a MODULE
zh_CN: %C处带有 FINAL 的派生类型声明必须在 MODULE 的规格说明部分内

en: Different CHARACTER lengths (%ld/%ld) in array constructor
zh_CN: 数组构造函数中 CHARACTER 长度不同(%ld/%ld)

en: Different kind type parameters in pointer assignment at %L
zh_CN: %L处指针赋值时参数种别类型不同

en: Different ranks in pointer assignment at %L
zh_CN: %L处指针赋值时秩不同

en: Different shape for %s at %L on dimension %d (%d and %d)
zh_CN: %2$L处 %1$s 在第 %3$d 维上外形不同(%4$d 和 %5$d)

en: Different types in pointer assignment at %L; attempted assignment of %s to %s
zh_CN: %L处指针赋值时类型不同；试图将 %s 赋值给 %s

en: Disable preprocessing.
zh_CN: 禁用预处理。

en: Disable space regs.
zh_CN: 禁用空间寄存器。

en: Display the compiler's version.
zh_CN: 显示编译器版本。

en: Display the symbols in reverse order.
zh_CN: 以逆序显示符号。

en: Display this information.
zh_CN: 显示此信息。

en: Division by zero at %L
zh_CN: %L处被零除

en: Division by zero converting %s to %s at %L
zh_CN: %3$L处从 %1$s 转换到 %2$s 时被零除

en: Do not assume that standard C libraries and "main" exist.
zh_CN: 不假定标准 C 库和“main”存在。

en: Do not disable space regs.
zh_CN: 不禁用空间寄存器。

en: Do not discard comments in macro expansions.
zh_CN: 展开宏时不丢弃注释。

en: Do not discard comments.
zh_CN: 不丢弃注释。

en: Do not enforce strict alignment.
zh_CN: 不强制严格对齐。

en: Do not inline integer division.
zh_CN: 不内联整数除法。

en: Do not inline square root.
zh_CN: 不内联平方根函数。

en: Do not predefine system-specific and GCC-specific macros.
zh_CN: 不预定义系统或 GCC 特有的宏。

en: Do not search standard system include directories (those specified with -isystem will still be used).
zh_CN: 不搜索标准系统头文件目录（但仍将使用由 -isystem 指定的目录）。

en: Do not search standard system include directories for C++.
zh_CN: 不搜索 C++ 标准系统头文件目录。

en: Do not support SSE4.1 and SSE4.2 built-in functions and code generation.
zh_CN: 不支持 SSE4.1 和 SSE4.2 内建函数及代码生成。

en: Do not suppress C++ class debug information.
zh_CN: 保留 C++ 类调试信息。

en: Do not use the callt instruction (default).
zh_CN: 不要使用 callt 指令（默认）.

en: Does nothing.  Preserved for backward compatibility.
zh_CN: 不起作用。为向前兼容保留的选项。

en: Does nothing. Preserved for backward compatibility.
zh_CN: 不起作用。为向前兼容保留的选项。

en: Don't align items in code or data.
zh_CN: 不在代码或数据中对齐条目。

en: Don't generate privileged-mode only code; implies -mno-inline-ic_invalidate if the inline code would not work in user mode.
zh_CN: 不生成仅特权模式的代码；如果在用户模式中内联代码不工作则包含 -mno-inline-ic_invalidate。

en: Don't use any of r32..r63.
zh_CN: 不使用 r32..r63 中的任何一个。

en: Don't warn about uses of Microsoft extensions.
zh_CN: 使用微软扩展时不给出警告。

en: Double CLASS IS block in SELECT TYPE statement at %L
zh_CN: %L处 SELECT TYPE 语句中有双重的 CLASS IS 块

en: Driving:
zh_CN: 驱动：

en: Dummy procedure at %C may not have BIND(C) attribute with NAME
zh_CN: %C处的哑过程不能有带有 NAME 的 BIND(C) 属性

en: Dump declarations to a .decl file.
zh_CN: 将声明转储到一个 .decl 文件中。

en: Dump the details of LTO objects.
zh_CN: 转储 LTO 对象的详细信息。

en: Duplicate %s attribute at %L
zh_CN: 重复的 %s 属性，位于 %L

en: Duplicate %s attribute specified at %L
zh_CN: 重复的 %s 属性在%L处被指定

en: Duplicate %s label specification at %C
zh_CN: %2$C处重复的 %1$s 标号规格

en: Duplicate %s specification at %C
zh_CN: %2$C处重复的 %1$s 规格

en: Duplicate ASYNCHRONOUS attribute specified at %L
zh_CN: %L处指定了重复的 ASYNCHRONOUS 属性

en: Duplicate BIND attribute specified at %L
zh_CN: %L处指定了重复的 BIND 属性

en: Duplicate DEFERRED at %C
zh_CN: %C处重复的 DEFERRED 语句

en: Duplicate ELSE statements at %L and %C
zh_CN: %L 和%C处重复的 ELSE 语句

en: Duplicate EXTENDS attribute specified at %L
zh_CN: %L处指定了重复的 EXTENDS 属性

en: Duplicate IMPLICIT NONE statement at %C
zh_CN: %C处 IMPLICIT NONE 语句重复

en: Duplicate NML specification at %C
zh_CN: %C处重复的 NML 规格

en: Duplicate NON_OVERRIDABLE at %C
zh_CN: %C处 NON_OVERRIDABLE 重复

en: Duplicate POINTER attribute at %C
zh_CN: %C处 POINTER 属性重复

en: Duplicate PRIVATE statement at %C
zh_CN: %C处重复的 PRIVATE 语句

en: Duplicate PROTECTED attribute specified at %L
zh_CN: %L处指定了重复的 PROTECTED 属性

en: Duplicate SAVE attribute specified at %L
zh_CN: %L 指定了重复的 SAVE 属性

en: Duplicate SEQUENCE statement at %C
zh_CN: %C处重复的 SEQUENCE 语句

en: Duplicate UNIT specification at %C
zh_CN: %C处重复的 UNIT 规格

en: Duplicate VALUE attribute specified at %L
zh_CN: %L处指定了重复的 VALUE 属性

en: Duplicate VOLATILE attribute specified at %L
zh_CN: %L处指定了重复的 VOLATILE 属性

en: Duplicate access-specifier at %C
zh_CN: %C处重复访问限定符

en: Duplicate array spec for Cray pointee at %C
zh_CN: %C处 Cray 指针重复指定了数组

en: Duplicate format specification at %C
zh_CN: %C处重复的格式规格

en: Duplicate statement label %d at %L and %L
zh_CN: 重复的语句标号 %d 出现在 %L 和%L处

en: ELSE IF statement at %C cannot follow ELSE statement at %L
zh_CN: %C处的 ELSE IF 语句不能出现在%L处的 ELSE 语句之后

en: ELSEWHERE statement at %C follows previous unmasked ELSEWHERE
zh_CN: %C处的 ELSEWHERE 语句出现在未屏蔽的 ELSEWHERE 之后

en: ELSEWHERE statement at %C not enclosed in WHERE block
zh_CN: %C处的 ELSEWHERE 语句不在 WHERE 块中

en: END tag at %C not allowed in output statement
zh_CN: %C处的 END 标记不允许出现在输出语句中

en: END tag label %d at %L not defined
zh_CN: END 标号 %d 在%L处未定义

en: ENTRY statement at %C cannot appear in a contained procedure
zh_CN: %C处 ENTRY 语句不能出现在被包含的过程中

en: ENTRY statement at %C cannot appear within a BLOCK DATA
zh_CN: %C处的 ENTRY 语句不能出现在 BLOCK DATA 中

en: ENTRY statement at %C cannot appear within a DERIVED TYPE block
zh_CN: %C处的 ENTRY 语句不能出现在 DERIVED TYPE 块中

en: ENTRY statement at %C cannot appear within a DO block
zh_CN: %C处的 ENTRY 语句不能出现在 DO 块中

en: ENTRY statement at %C cannot appear within a FORALL block
zh_CN: %C处的 ENTRY 语句不能出现在 FORALL 块中

en: ENTRY statement at %C cannot appear within a MODULE
zh_CN: %C处的 ENTRY 语句不能出现在 MODULE 中

en: ENTRY statement at %C cannot appear within a PROGRAM
zh_CN: %C处的 ENTRY 语句不能出现在 PROGRAM 中

en: ENTRY statement at %C cannot appear within a SELECT block
zh_CN: %C处的 ENTRY 语句不能出现在 SELECT 块中

en: ENTRY statement at %C cannot appear within a WHERE block
zh_CN: %C处的 ENTRY 语句不能出现在 WHERE 块中

en: ENTRY statement at %C cannot appear within a contained subprogram
zh_CN: %C处的 ENTRY 语句不能出现在嵌套的子程序中

en: ENTRY statement at %C cannot appear within an IF-THEN block
zh_CN: %C处的 ENTRY 语句不能出现在 IF-THEN 块中

en: ENTRY statement at %C cannot appear within an INTERFACE
zh_CN: %C处的 ENTRY 语句不能出现在 INTERFACE 中

en: ENTRY_BLOCK has IL associated with it
zh_CN: ENTRY_BLOCK 有与之关联的 IL

en: ENUM declaration at %C has no ENUMERATORS
zh_CN: %C处的 ENUM 声明没有 ENUMERATORS

en: ENUM definition statement expected before %C
zh_CN: %C 前需要 ENUM 定义语句

en: ENUMERATOR %L not initialized with integer expression
zh_CN: ENUMERATOR %L没有用整数表达式初始化

en: EOR tag label %d at %L not defined
zh_CN: EOR 标号 %d 在%L处未定义

en: EQUIVALENCE at %C requires two or more objects
zh_CN: %C处的 EQUIVALENCE 需要两个或更多的对象

en: ERR tag label %d at %L not defined
zh_CN: ERR 标号 %d 在%L处未定义

en: ERRMSG at %L is useless without a STAT tag
zh_CN: %L处的 ERRMSG 没有 STAT 标记所以不起作用

en: EXIT statement at %C terminating !$OMP DO loop
zh_CN: %C处的 EXIT 语句终结了 !$OMP DO 循环

en: EXIT_BLOCK has IL associated with it
zh_CN: EXIT_BLOCK 有与之关联的 IL

en: Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute
zh_CN: %L处 EQUIVALENCE 集中的对象必须都带有或者都不带有 PROTECTED 属性

en: Element in %s array constructor at %L is %s
zh_CN: %s 数组构造中的元素在%L处是 %s

en: Emit call graph information.
zh_CN: 生成调用图信息。

en: Emit long load/store sequences.
zh_CN: 生成长读/写序列。

en: Empty FINAL at %C
zh_CN: %C处的 FINAL 为空

en: Empty IMPLICIT statement at %C
zh_CN: %C处 IMPLICIT 语句为空

en: Empty array constructor at %C is not allowed
zh_CN: %C处的空数组构造不被允许

en: Empty set of digits in BOZ constant at %C
zh_CN: %C处 BOZ 常量中的数字符集合为空

en: Enable C++ coroutines (experimental).
zh_CN: 启用 C++ 协程（实验性）。

en: Enable CFI tables via GAS assembler directives.
zh_CN: 用 GAS 汇编指示来启用 CFI 表。

en: Enable FT32B code compression.
zh_CN: 启用 FT32B 代码压缩。

en: Enable MUL instructions.
zh_CN: 启用 MUL 指令。

en: Enable OpenACC.
zh_CN: 启用 OpenACC。

en: Enable backend debugging.
zh_CN: 启用后端调试.

en: Enable copy propagation of scalar-evolution information.
zh_CN: 为标量演化信息进行复写传递。

en: Enable debug output.
zh_CN: 开启调试输出。

en: Enable front end optimization.
zh_CN: 启用前端优化。

en: Enable hardware floating point.
zh_CN: 启用硬件浮点单元。

en: Enable hoisting loads from conditional pointers.
zh_CN: 为条件指针外提内存读取操作。

en: Enable link-time optimization.
zh_CN: 启用链接时优化。

en: Enable linker optimizations.
zh_CN: 启用链接器优化。

en: Enable linker relaxation.
zh_CN: 使用更短的地址引用。

en: Enable linker relaxing.
zh_CN: 启用链接器松弛 (relax)。

en: Enable most warning messages.
zh_CN: 启用大部分警告信息。

en: Enable multicore support.
zh_CN: 启用多核支持。

en: Enable preprocessing.
zh_CN: 启用预处理。

en: Enable strict 32-bit psABI struct return checking.
zh_CN: 启用严格的 32 位 psABI 结构返回检查。

en: Enable support for C++ concepts.
zh_CN: 启用对 C++ concepts 的支持。

en: Enable support for the old GCC ABI.
zh_CN: 启用对旧有 GCC ABI 的支持。

en: Enable the normal mode.
zh_CN: 启用正常（normal）模式。

en: Enable the use of 64-bit floating point registers in fmov instructions.  See -mdalign if 64-bit alignment is required.
zh_CN: 在 fmov 指令中启用 64 位浮点寄存器。如需要 64 位对齐请参见 -mdalign。

en: Enable the use of RX FPU instructions.  This is the default.
zh_CN: 启用使用 RX FPU 指令。这是默认值。

en: Enable traditional preprocessing.
zh_CN: 启用传统预处理。

en: Enable verbose output.
zh_CN: 启用详细输出。

en: Encode SSE instructions with VEX prefix.
zh_CN: 编码带 VEX 前缀的 SSE 指令。

en: End expression in DO loop
zh_CN: DO 循环中结束表达式

en: End of nonblock DO statement at %C is interwoven with another DO loop
zh_CN: %C处结束的非块 DO 语句与另一个 DO 循环交错

en: End of nonblock DO statement at %C is within another block
zh_CN: %C处结束的非块 DO 语句在另一个块当中

en: End of search list.
zh_CN: 搜索列表结束。

en: Entity with assumed character length at %L must be a dummy argument or a PARAMETER
zh_CN: %L处假定字符长度的实体必须是个虚参或是个 PARAMETER

en: Enumerator exceeds the C integer type at %C
zh_CN: %C处：枚举量超过 C 整数类型

en: Errmsg-variable at %L shall not be %sd within the same %s statement
zh_CN: %1$L处的错误信息变量不能在同一 %3$s 语句中被 %2$s

en: Error
zh_CN: 错误

en: Error allocating %lu bytes
zh_CN: 分配 %lu 字节出错

en: Error converting PARAMETER constant in complex constant at %C
zh_CN: %C处在复数常量中转换 PARAMETER 常量时出错

en: Error converting integer
zh_CN: 转换整数时出错

en: Error writing JSON output file %s
zh_CN: 写入到 JSON 输出文件 %s 时出错

en: Error writing modules file: %s
zh_CN: 写入模块文件时出错：%s

en: Error writing output file '%s'
zh_CN: 写入到输出文件 '%s' 时出错

en: Event
zh_CN: 事件

en: Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression
zh_CN: %L处 DO WHILE 循环的退出条件必须是一个标量 LOGICAL 表达式

en: Expand 32bit/64bit integer divide into 8bit unsigned integer divide with run-time check.
zh_CN: 将 32/64 位整数除法扩展为带运行时检查的 8 位无符号整数除法。

en: Expected ")" at %C
zh_CN: 在%C处需要“)”

en: Expected "," at %C
zh_CN: 在%C处需要“,”

en: Expected :: in TYPE definition at %C
zh_CN: %C 在 TYPE 定义中需要 ::

en: Expected = sign in PARAMETER statement at %C
zh_CN: %C 在 PARAMETER 语句中需要 = 符号

en: Expected PARAMETER symbol in complex constant at %C
zh_CN: %C处复数常量中需要 PARAMETER 符号

en: Expected TYPE IS, CLASS IS or END SELECT statement following SELECT TYPE at %C
zh_CN: %C处的 SELECT TYPE 之后需要 TYPE IS、CLASS IS 或 END SELECT 语句

en: Expected a CASE or END SELECT statement following SELECT CASE at %C
zh_CN: %C处 SELECT CASE 之后需要 CASE 或 END SELECT 语句

en: Expected a nameless interface at %C
zh_CN: %C 需要一个无名接口

en: Expected a right parenthesis in expression at %C
zh_CN: %C处表达式中需要右括号

en: Expected a step value in iterator at %C
zh_CN: %C处的迭代子需要一个步进值

en: Expected access-specifier at %C
zh_CN: %C需要访问限定符

en: Expected alternate return label at %C
zh_CN: %C处需要替代的返回标号

en: Expected an initialization expression at %C
zh_CN: %C处需要一个初始化表达式

en: Expected another dimension in array declaration at %C
zh_CN: %C处数组声明需要另外一维

en: Expected argument list at %C
zh_CN: %C处需要实参列表

en: Expected array subscript at %C
zh_CN: %C处需要数组下标

en: Expected array subscript stride at %C
zh_CN: %C处需要数组下标间隔

en: Expected attribute bit name
zh_CN: 需要属性位名

en: Expected binding attribute at %C
zh_CN: %C处需要绑定属性

en: Expected binding name at %C
zh_CN: %C处需要绑定名

en: Expected comma in I/O list at %C
zh_CN: %C处 I/O 列表中需要逗号

en: Expected component reference at %C
zh_CN: %C处需要组件引用

en: Expected exponent in expression at %C
zh_CN: %C处表达式中需要指数部分

en: Expected expression at %C in PARAMETER statement
zh_CN: %C 在 PARAMETER 语句中需要表达式

en: Expected expression in %s statement at %C
zh_CN: %2$C处需要 %1$s 语句

en: Expected expression in array specification at %C
zh_CN: %C处数组规格中需要表达式

en: Expected expression type
zh_CN: 需要表达式类型

en: Expected formal argument list in function definition at %C
zh_CN: 函数定义在%C处需要形参列表

en: Expected generic name or operator descriptor at %C
zh_CN: %C处需要泛型名或运算符描述子

en: Expected initialization expression at %C
zh_CN: %C处需要初始化表达式

en: Expected initialization expression in CASE at %C
zh_CN: %C处 CASE 中需要初始化表达式

en: Expected integer
zh_CN: 需要整数

en: Expected integer string
zh_CN: 需要整数字符串

en: Expected left parenthesis
zh_CN: 需要左圆括号

en: Expected module procedure name at %C
zh_CN: %C处期待模块过程名

en: Expected name
zh_CN: 需要名字

en: Expected real string
zh_CN: 需要实数字符串

en: Expected right parenthesis
zh_CN: 需要右圆括号

en: Expected scalar initialization expression at %C
zh_CN: %C处需要标量初始化表达式

en: Expected specific binding name at %C
zh_CN: %C处需要特定的绑定名

en: Expected string
zh_CN: 需要字符串

en: Expected structure component name at %C
zh_CN: %C处需要结构组件名

en: Expected terminating name at %C
zh_CN: %C处需要结束名

en: Expected type-bound procedure or procedure pointer component at %C
zh_CN: %C处需要一个类型限定的过程或过程指针组件

en: Expected variable name at %C
zh_CN: 在%C处需要变量名

en: Expected variable name at %C in PARAMETER statement
zh_CN: %C处的 PARAMETER 语句需要变量名

en: Expecting a comma in EQUIVALENCE at %C
zh_CN: %C处 EQUIVALENCE 中需要逗号

en: Expecting list of named entities at %C
zh_CN: %C处需要有名实体列表

en: Expression at %L must be of INTEGER type, found %s
zh_CN: %L处的表达式必须具有 INTEGER 类型而不是 %s

en: Expression at %L must be scalar
zh_CN: %L处的表达式必须具有标量类型

en: Expression in CASE statement at %L must be of kind %d
zh_CN: %L 处 CASE 语句中的表达式种别必须为 %d

en: Expression in CASE statement at %L must be of type %s
zh_CN: %L处 CASE 语句中的表达式必须具有 %s 类型

en: Expression in CASE statement at %L must be scalar
zh_CN: %L处 CASE 语句中的表达式必须为标量

en: Extension: Conversion from %s to %s at %L
zh_CN: 扩展：从 %s 到 %s，位于 %L

en: Extension: Unary operator following arithmetic operator (use parentheses) at %C
zh_CN: 扩展：%C处单目运算符出现在算术运算符之后

en: Extension: backslash character at %C
zh_CN: 扩展：%C处的反斜杠字符

en: External IO UNIT cannot be an array at %L
zh_CN: %L处的外部 IO UNIT 不能是数组

en: FINAL declaration at %C must be inside CONTAINS
zh_CN: %C处的 FINAL 声明必须在 CONTAINS 内

en: FINAL declaration at %C must be inside a derived type CONTAINS section
zh_CN: %C处的 FINAL 声明必须在一个派生类型的 CONTAINS 节内

en: FINAL procedure at %L must have exactly one argument
zh_CN: %L处的 FINAL 过程有且只有一个参数

en: FLUSH statement at %C
zh_CN: %C处 FLUSH 语句

en: FORALL end expression at %L must be a scalar INTEGER
zh_CN: %L处 FORALL 结束表达式必须是一个标量整数

en: FORALL index-name at %L must be a scalar INTEGER
zh_CN: %L处 FORALL 索引名必须是一个标量整数

en: FORALL start expression at %L must be a scalar INTEGER
zh_CN: %L处 FORALL 起始表达式必须是一个标量整数

en: FORALL stride expression at %L cannot be zero
zh_CN: %L处 FORALL 间隔表达式不能是零

en: FORALL stride expression at %L must be a scalar %s
zh_CN: %L处 FORALL 间隔表达式必须是一个标量 %s

en: FORMAT label %d at %L not defined
zh_CN: FORMAT 标号 %d 在%L处未定义

en: FORMAT statement at %L does not have a statement label
zh_CN: %L处 FORMAT 语句没有语句标号

en: FPU types of LoongArch:
zh_CN: LoongArch 的 FPU 类型。

en: Fatal Error
zh_CN: 致命错误

en: First argument of defined assignment at %L must be INTENT(OUT) or INTENT(INOUT)
zh_CN: %L处定义赋值的第一个参数必须是 INTENT(OUT) 或 INTENT(INOUT)

en: First argument of operator interface at %L cannot be optional
zh_CN: %L处运算符接口的第一个参数不能是可选的

en: First argument of operator interface at %L must be INTENT(IN)
zh_CN: %L处运算符接口的第一个参数必须是 INTENT(IN)

en: For dummy procedure %s, no binding name is allowed in BIND(C) at %C
zh_CN: 对于哑过程 %s，%C 处的 BIND(C) 中不允许有绑定名

en: For nested functions on stack executable permission is set.
zh_CN: 为嵌套函数设定可执行堆栈权限。

en: Format statement in module main block at %C
zh_CN: %C处模块主块中的格式语句

en: Fortran 2018 deleted feature:
zh_CN: Fortran 2018 删除的特性：

en: Fortran 2018:
zh_CN: Fortran 2018：

en: Fortran 95 requires default INTEGER in %s tag at %L
zh_CN: Fortran 95 在%2$L处的 %1$s 标记中需要默认的 INTEGER

en: Function %qs in initialization expression at %L must be an intrinsic function
zh_CN: %2$L 处初始化表达式中的函数 ‘%1$qs’ 必须是一个内建函数

en: Function %s at %L has entries with mismatched array specifications
zh_CN: %2$L处函数‘%1$s’有不匹配的数组规格说明

en: GCC cannot support operators with integer types and fixed-point types that have too many integral and fractional bits together
zh_CN: GCC 不支持整数类型和整数及分数位太多的定点类型间的运算符

en: GCC supports only %u nested scopes
zh_CN: GCC 只支持 %u 个嵌套的作用域

en: GCC vector passed by reference: non-standard ABI extension with no compatibility guarantee
zh_CN: GCC 传递向量引用：非标准的 ABI 扩展，不保证兼容性

en: GCC vector returned by reference: non-standard ABI extension with no compatibility guarantee
zh_CN: GCC 返回向量引用：非标准的 ABI 扩展，不保证兼容性

en: GCSE disabled
zh_CN: GCSE 被禁用

en: GENERIC at %C must be inside a derived-type CONTAINS
zh_CN: %C处的 GENERIC 必须是在派生类型 CONTAINS 内

en: GMP version %s, MPFR version %s, MPC version %s, isl version %s
zh_CN: GMP 版本 %s，MPFR 版本 %s，MPC 版本 %s，isl 版本 %s

en: GNU C no longer supports -traditional without -E
zh_CN: GNU C 不再支持不带 -E 的 -traditional

en: GNU Extension:
zh_CN: GNU 扩展：

en: GNU Objective C no longer supports traditional compilation
zh_CN: GNU Objective C 不再支持传统编译

en: Generate 16-bit instructions.
zh_CN: 生成 16 位指令。

en: Generate 16bit i386 code.
zh_CN: 生成 16 位 i386 代码。

en: Generate 32-bit code.
zh_CN: 生成 32 位代码。

en: Generate 32bit i386 code.
zh_CN: 生成 32 位 i386 代码。

en: Generate 32bit x86-64 code.
zh_CN: 生成 32 位 x86-64 代码。

en: Generate 64-bit code.
zh_CN: 生成 64 位代码。

en: Generate 64bit x86-64 code.
zh_CN: 生成 64 位 x86-64 代码。

en: Generate C header of platform-specific features.
zh_CN: 生成有平台相关特性的 C 头文件。

en: Generate C++ Module dependency information.
zh_CN: 生成 C++ 模块依赖信息。

en: Generate H8/300H code.
zh_CN: 生成 H8/300H 代码。

en: Generate H8S code.
zh_CN: 生成 H8S 代码。

en: Generate H8S/2600 code.
zh_CN: 生成 H8S/2600 代码。

en: Generate H8SX code.
zh_CN: 生成 H8SX 代码。

en: Generate ILP32 code.
zh_CN: 生成 ILP32 代码。

en: Generate JSON file.
zh_CN: 生成 JSON 文件。

en: Generate LP64 code.
zh_CN: 生成 LP64 代码。

en: Generate MIPS16 code.
zh_CN: 生成 MIPS16 代码。

en: Generate PA1.0 code.
zh_CN: 生成 PA1.0 代码。

en: Generate PA1.1 code.
zh_CN: 生成 PA1.1 代码。

en: Generate PA2.0 code (requires binutils 2.10 or later).
zh_CN: 生成 PA2.0 代码 (需要 binutils 2.10 或更新版本)。

en: Generate SH1 code.
zh_CN: 生成 SH1 代码。

en: Generate SH2 code.
zh_CN: 生成 SH2 代码。

en: Generate SH2e code.
zh_CN: 生成 SH2e 代码。

en: Generate SH3 code.
zh_CN: 生成 SH3 代码。

en: Generate SH3e code.
zh_CN: 生成 SH3e 代码。

en: Generate SH4 code.
zh_CN: 生成 SH4 代码。

en: Generate SH4-100 code.
zh_CN: 生成 SH4-100 代码。

en: Generate SH4-200 code.
zh_CN: 生成 SH4-200 代码。

en: Generate SH4-300 code.
zh_CN: 生成 SH4-300 代码。

en: Generate SH4a code.
zh_CN: 生成 SH4a 代码。

en: Generate big endian code.
zh_CN: 生成大端在前的代码。

en: Generate big-endian code.
zh_CN: 生成大端在前的代码。

en: Generate cld instruction in the function prologue.
zh_CN: 在函数序言中生成 cld 指令。

en: Generate code for GNU as.
zh_CN: 为 GNU as 生成代码。

en: Generate code for GNU ld.
zh_CN: 为 GNU ld 生成代码。

en: Generate code for GNU runtime environment.
zh_CN: 为 GNU 运行时环境生成代码。

en: Generate code for SH4 500 series (FPU-less).
zh_CN: 为缺少 FPU 的 SH4 500 系列生成代码。

en: Generate code for a 32-bit ABI.
zh_CN: 为 32 位 ABI 生成代码。

en: Generate code for a 5206e.
zh_CN: 为 5206e 生成代码。

en: Generate code for a 520X.
zh_CN: 为 520X 生成代码。

en: Generate code for a 528x.
zh_CN: 为 528x 生成代码。

en: Generate code for a 5307.
zh_CN: 为 5307 生成代码。

en: Generate code for a 5407.
zh_CN: 为 5407 生成代码。

en: Generate code for a 64-bit ABI.
zh_CN: 为 64 位 ABI 生成代码。

en: Generate code for a 68000.
zh_CN: 为 68000 生成代码。

en: Generate code for a 68010.
zh_CN: 为 68010 生成代码。

en: Generate code for a 68020.
zh_CN: 为 68020 生成代码。

en: Generate code for a 68030.
zh_CN: 为 68030 生成代码。

en: Generate code for a 68040, without any new instructions.
zh_CN: 为 68040 生成代码，不使用新指令。

en: Generate code for a 68040.
zh_CN: 为 68040 生成代码。

en: Generate code for a 68060, without any new instructions.
zh_CN: 为 68060 生成代码，不使用新指令。

en: Generate code for a 68060.
zh_CN: 为 68060 生成代码。

en: Generate code for a 68302.
zh_CN: 为 68302 生成代码。

en: Generate code for a 68332.
zh_CN: 为 68332 生成代码。

en: Generate code for a 68851.
zh_CN: 为 68851 生成代码。

en: Generate code for a DLL.
zh_CN: 生成动态链接库的代码。

en: Generate code for given CPU.
zh_CN: 为给定的 CPU 生成代码。

en: Generate code for the Android platform.
zh_CN: 为 Android 平台生成代码。

en: Generate code in big-endian mode.
zh_CN: 生成大端序模式的代码。

en: Generate code in little-endian mode.
zh_CN: 生成小端序模式的代码。

en: Generate cpp defines for server IO.
zh_CN: 为服务器 IO 生成 cpp 定义。

en: Generate cpp defines for workstation IO.
zh_CN: 为工作站 IO 生成 cpp 定义。

en: Generate documentation.
zh_CN: 生成文档。

en: Generate fast indirect calls.
zh_CN: 生成快速间接调用。

en: Generate inline square root, optimize for latency.
zh_CN: 生成内联的平方根，为最小延迟优化。

en: Generate inline square root, optimize for throughput.
zh_CN: 生成内联的平方根，为最大吞吐量优化。

en: Generate isel instructions.
zh_CN: 生成 isel 指令。

en: Generate little endian code.
zh_CN: 生成小端在前的代码。

en: Generate little-endian code.
zh_CN: 生成小端在前的代码。

en: Generate make dependencies and compile.
zh_CN: 生成 make 依赖规则并编译。

en: Generate make dependencies.
zh_CN: 生成 make 依赖项。

en: Generate phony targets for all headers.
zh_CN: 为所有头文件生成伪目标。

en: Generate reciprocals instead of divss and sqrtss.
zh_CN: 生成倒数指令而不是 divss 和 sqrtss。

en: Generate sin, cos, sqrt for FPU.
zh_CN: 为 FPU 生成 sin、cos 和 sqrt 指令。

en: IF clause at %L requires a scalar LOGICAL expression
zh_CN: %L处的 IF 分句需要一个标量 LOGICAL 表达式

en: IMPORT statement at %C only permitted in an INTERFACE body
zh_CN: %C处 IMPORT 语句只允许出现在接口体中

en: INQUIRE statement at %L cannot contain both FILE and UNIT specifiers
zh_CN: %L处的 INQUIRE 语句不能包含 FILE 和 UNIT 限定符

en: INQUIRE statement at %L requires a PENDING= specifier with the ID= specifier
zh_CN: %L处的 INQUIRE 语句需要带有 ID= 指定的 PENDING=

en: INQUIRE statement at %L requires either FILE or UNIT specifier
zh_CN: %L处的 INQUIRE 语句需要 FILE 或 UNIT 限定符

en: INQUIRE statement not allowed in PURE procedure at %C
zh_CN: INQUIRE 语句不允许出现在%C处的 PURE 过程中

en: INTENT (%s) conflicts with INTENT(%s) at %L
zh_CN: INTENT (%s) 与 INTENT(%s) 在 %L 冲突

en: INTENT is not allowed inside of BLOCK at %C
zh_CN: INTENT 不能用在%C处 BLOCK 内

en: INTENT(%s) actual argument at %L might interfere with actual argument at %L.
zh_CN: INTENT(%s) %L处的实参可能干涉%L处的实参。

en: IOLENGTH tag invalid in INQUIRE statement at %C
zh_CN: %C处的 INQUIRE 语句中 IOLENGTH 标记无效

en: ISO C does not allow extra %<;%> outside of a function
zh_CN: ISO C 不支持在函数外使用多余的%<;%>

en: ISO C does not support %<#pragma STDC FLOAT_CONST_DECIMAL64%>
zh_CN: ISO C 不支持%<#pragma STDC FLOAT_CONST_DECIMAL64%>

en: ISO C does not support %<++%> and %<--%> on complex types
zh_CN: ISO C 不支持对复数类型进行%<++%>或%<--%>操作

en: ISO C does not support %<__int%d%> types
zh_CN: ISO C 不支持 %<__int%d%> 类型

en: ISO C does not support %<~%> for complex conjugation
zh_CN: ISO C 不支持用%<~%>求共轭复数

en: ISO C does not support complex integer types
zh_CN: ISO C 不支持复整数

en: ISO C does not support fixed-point types
zh_CN: ISO C 不支持定点类型

en: ISO C does not support plain %<complex%> meaning %<double complex%>
zh_CN: ISO C 不支持单独用%<complex%>表示%<double complex%>

en: ISO C does not support saturating types
zh_CN: ISO C 不支持饱和类型

en: ISO C forbids %<goto *expr;%>
zh_CN: ISO C++ 不允许%<goto *expr;%>

en: ISO C forbids %<return%> with expression, in function returning void
zh_CN: ISO C 不允许在无返回值的函数中%<return%>带返回值

en: ISO C forbids an empty translation unit
zh_CN: ISO C 不允许翻译单元为空

en: ISO C forbids assignment between function pointer and %<void *%>
zh_CN: ISO C 不允许在函数指针和%<void *%>间赋值

en: ISO C forbids braced-groups within expressions
zh_CN: ISO C 不允许在表达式中使用花括号组

en: ISO C forbids casting nonscalar to the same type
zh_CN: ISO C 不允许将非标量转换为其自身类型

en: ISO C forbids casts to union type
zh_CN: ISO C 不允许转换为联合类型

en: ISO C forbids comparison of %<void *%> with function pointer
zh_CN: ISO C 不允许在%<void *%>和函数指针间比较

en: ISO C forbids conditional expr between %<void *%> and function pointer
zh_CN: ISO C 不允许在条件表达式中同时使用%<void *%>和函数指针

en: ISO C forbids conditional expr with only one void side
zh_CN: ISO C 不允许条件表达式仅有一边为空

en: ISO C forbids const or volatile function types
zh_CN: ISO C 不允许使用 const 或 volatile 限定函数类型

en: ISO C forbids conversion of function pointer to object pointer type
zh_CN: ISO C 不允许将一个函数指针转换为一个对象指针

en: ISO C forbids conversion of object pointer to function pointer type
zh_CN: ISO C 不允许将一个对象指针转换为一个函数指针

en: ISO C forbids forward parameter declarations
zh_CN: ISO C 不允许前向参数声明

en: ISO C forbids forward references to %<enum%> types
zh_CN: ISO C 不允许%<enum%>类型的前向引用

en: ISO C forbids initialization between function pointer and %<void *%>
zh_CN: ISO C 不允许在函数指针和%<void *%>间初始化

en: ISO C forbids label declarations
zh_CN: HISO C 不允许标号声明

en: ISO C forbids member declarations with no members
zh_CN: ISO C 不允许不含成员的成员声明

en: ISO C forbids nested functions
zh_CN: ISO C 不允许嵌套函数

en: ISO C forbids ordered comparisons of pointers to functions
zh_CN: ISO C 不允许函数指针间比较大小

en: ISO C forbids passing argument %d of %qE between function pointer and %<void *%>
zh_CN: ISO C 不允许将%2$qE的第 %1$d 个实参在函数指针和%<void *%>间传递

en: ISO C forbids qualified function types
zh_CN: ISO C 不允许使用 const 或 volatile 限定函数类型

en: ISO C forbids return between function pointer and %<void *%>
zh_CN: ISO C 不允许在函数指针和%<void *%>间返回

en: ISO C forbids specifying range of elements to initialize
zh_CN: ISO C 不允许在初始化指定元素的范围

en: ISO C forbids subscripting %<register%> array
zh_CN: ISO C 不允许按下标访问%<register%>数组

en: ISO C forbids zero-size array
zh_CN: ISO C 不允许大小为 0 的数组

en: ISO C forbids zero-size array %qE
zh_CN: ISO C 不允许大小为 0 的数组%qE

en: ISO C prohibits argument conversion to union type
zh_CN: ISO C 不允许将实参转换为联合

en: ISO C++ 1998 does not support %<long long%>
zh_CN: ISO C++ 1998 不支持%<long long%>

en: ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations
zh_CN: ISO C++ 1998 不允许在显式实例化时使用%<extern%>

en: ISO C++ does not allow %<alignof%> with a non-type
zh_CN: ISO C++ 不允许对非类型使用%<alignof%>

en: ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>
zh_CN: ISO C++ 不允许将%<%T::%D%>定义为%<%T::%D%>

en: ISO C++ does not support %<__int%d%> for %qs
zh_CN: ISO C++ 对 %2$qs 不支持 %<__int%1$d%>

en: ISO C++ does not support plain %<complex%> meaning %<double complex%>
zh_CN: ISO C++ 不支持单独以 %<complex%> 表示 %<double complex%>

en: ISO C++ forbids applying %<__alignof%> to an expression of function type
zh_CN: ISO C++ 不允许将%<__alignof%>应用到函数类型的表达式上

en: ISO C++ forbids applying %<sizeof%> to an expression of function type
zh_CN: ISO C++ 不允许将%<sizeof%>应用到函数类型的表达式上

en: ISO C++ forbids braced-groups within expressions
zh_CN: ISO C++ 不允许在表达式中使用花括号组

en: ISO C++ forbids calling %<::main%> from within program
zh_CN: ISO C++ 不允许在程序里调用%<::main%>

en: ISO C++ forbids casting to an array type %qT
zh_CN: ISO C++ 不允许转换为数组类型%qT

en: ISO C++ forbids comparison between pointer and integer
zh_CN: ISO C++ 不允许比较指针和整数的值

en: ISO C++ forbids comparison between pointer of type %<void *%> and pointer-to-function
zh_CN: ISO C++ 不允许在%<void *%>和函数指针间比较

en: ISO C++ forbids compound-literals
zh_CN: ISO C++ 不允许复合字面量

en: ISO C++ forbids computed gotos
zh_CN: ISO C++ 不允许计算转移

en: ISO C++ forbids conditional expression between pointer of type %<void *%> and pointer-to-function
zh_CN: ISO C++ 不允许%<void *%>和函数指针组成的条件表达式

en: ISO C++ forbids conversion between pointer of type %<void *%> and pointer-to-function
zh_CN: ISO C++ 不允许在%<void *%>和函数指针间转换

en: ISO C++ forbids declaration of %qs with no type
zh_CN: ISO C++ 不允许声明无类型的%qs

en: ISO C++ forbids decrementing a pointer of type %qT
zh_CN: ISO C++ 不允许对类型为%qT的指针自减

en: ISO C++ forbids decrementing an enum
zh_CN: ISO C++ 不允许枚举自减

en: ISO C++ forbids in-class initialization of non-const static member %qD
zh_CN: ISO C++ 不允许在类内初始化非常量静态成员%qD

en: ISO C++ forbids incrementing a pointer of type %qT
zh_CN: ISO C++ 不允许对类型为%qT的指针自增

en: ISO C++ forbids incrementing an enum
zh_CN: ISO C++ 不允许枚举自增

en: ISO C++ forbids initialization of member constant %qD of non-integral type %qT
zh_CN: ISO C++ 不允许初始化成员常量%qD，因为它有非整数的类型%qT

en: ISO C++ forbids nested type %qD with same name as enclosing class
zh_CN: ISO C++ 不允许嵌类的类型%qD与其所属的类重名

en: ISO C++ forbids taking address of function %<::main%>
zh_CN: ISO C++ 不允许取函数%<::main%>的地址

en: ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>
zh_CN: ISO C++ 不允许通过取已绑定的成员函数的地址来构造成员函数指针。请改用%<&%T::%D%>

en: ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to member function.  Say %<&%T::%D%>
zh_CN: ISO C++ 不允许通过提取一个未限定的或带括号的非静态成员函数的地址来形成一个成员函数指针。请使用%<&%T::%D%>

en: ISO C++ forbids the use of %qE on explicit instantiations
zh_CN: ISO C++ 不允许在显式实例化时使用%qE

en: ISO C++ forbids using pointer of type %<void *%> in subtraction
zh_CN: ISO C++ 不允许在减法中使用类型为%<void *%>的指针

en: ISO C++ forbids using pointer to a function in subtraction
zh_CN: ISO C++ 不允许在减法中使用函数指针

en: ISO C++ forbids using pointer to a method in subtraction
zh_CN: ISO C++ 不允许在减法中使用指向方法的指针

en: ISO C++ forbids variable length array
zh_CN: ISO C++ 不允许变长数组

en: ISO C++ forbids variable length array %qD
zh_CN: ISO C++ 不允许变长数组%qD

en: ISO C++ forbids zero-size array
zh_CN: ISO C++ 不允许大小为 0 的数组

en: ISO C++ forbids zero-size array %qD
zh_CN: ISO C 不允许大小为 0 的数组%qD

en: ISO C++ prohibits anonymous structs
zh_CN: ISO C++ 不允许匿名结构

en: ISO C++ says that these are ambiguous, even though the worst conversion for the first is better than the worst conversion for the second:
zh_CN: ISO C++ 认为有歧义，尽管第一个备选的最差类型转换要好于第二个备选的最差类型转换：

en: ISO C90 does not support %<[*]%> array declarators
zh_CN: ISO C90 不支持%<[*]%>数组声明

en: ISO C90 does not support %<_Generic%>
zh_CN: ISO C90 不支持 %<_Generic%>

en: ISO C90 does not support %<_Noreturn%>
zh_CN: ISO C90 不支持 %<_Noreturn%>

en: ISO C90 does not support %<__func__%> predefined identifier
zh_CN: ISO C90 不支持 %<__func__%> 预定义标识符

en: ISO C90 does not support %<long long%>
zh_CN: ISO C90 不支持%<long long%>

en: ISO C90 does not support %<static%> or type qualifiers in parameter array declarators
zh_CN: ISO C90 不支持在形参数组声明中使用%<static%>或类型限定符

en: ISO C90 does not support %qE
zh_CN: ISO C90 不支持 %qE

en: ISO C90 does not support boolean types
zh_CN: ISO C90 不支持布尔类型

en: ISO C90 does not support complex types
zh_CN: ISO C90 不支持复数类型

en: ISO C90 does not support flexible array members
zh_CN: ISO C90 不允许可变数组成员

en: ISO C90 does not support the %<_Atomic%> qualifier
zh_CN: ISO C90 不支持 %<_Atomic%> 限定符

en: ISO C90 doesn%'t support unnamed structs/unions
zh_CN: ISO C90 不支持无名结构/联合

en: ISO C90 forbids compound literals
zh_CN: ISO C90 不允许复合字面量

en: ISO C90 forbids mixed declarations and code
zh_CN: ISO C90 不允许混合使用声明和代码

en: ISO C90 forbids specifying subobject to initialize
zh_CN: ISO C90 不允许指定子对象的初始值

en: ISO C90 forbids subscripting non-lvalue array
zh_CN: ISO C90 不允许非左值的数组作为下标运算的左操作数

en: ISO C90 forbids variable length array
zh_CN: ISO C90 不允许变长数组

en: ISO C90 forbids variable length array %qE
zh_CN: ISO C90 不允许变长数组%qE

en: ISO C99 does not support %<_Generic%>
zh_CN: ISO C99 不支持 %<_Generic%>

en: ISO C99 does not support %<_Noreturn%>
zh_CN: ISO C99 不支持 %<_Noreturn%>

en: ISO C99 does not support %qE
zh_CN: ISO C99 不支持 %qE

en: ISO C99 does not support the %<_Atomic%> qualifier
zh_CN: ISO C99 不支持 %<_Atomic%> 限定符

en: ISO C99 doesn%'t support unnamed structs/unions
zh_CN: ISO C99 不支持无名结构/联合

en: Ignore dllimport for functions.
zh_CN: 忽略函数的 dllimport 属性。

en: Ignore unsupported pragmas.
zh_CN: 忽略不支持的 pragma。

en: Ignored.
zh_CN: 已忽略。

en: Illegal allocate-object at %C for a PURE procedure
zh_CN: %C处 PURE 过程中的分配对象非法

en: Illegal character in BOZ constant at %C
zh_CN: %C处的 BOZ 常量中有非法字符

en: Illegal reference type at %L as EQUIVALENCE object
zh_CN: %L处的非法引用类型作为 EQUIVALENCE 对象

en: Illegal stride of zero at %L
zh_CN: %L 零间隔非法

en: In C++, nonzero means warn about deprecated conversion from string literals to 'char *'.  In C, similar warning, except that the conversion is of course not deprecated by the ISO C standard.
zh_CN: 在 C++ 中，非零值表示将字面字符串转换为‘char *’时给出警告。在 C 中，给出相似的警告，但这种类型转换是符合 ISO C 标准的。

en: In function %qs
zh_CN: 在函数%qs中

en: In lambda function
zh_CN: 在 lambda 函数中

en: In member function %qs
zh_CN: 在成员函数%qs中

en: Incompatible derived type in PARAMETER at %L
zh_CN: %L处 PARAMETER 中派生类型不兼容

en: Incompatible ranks %d and %d in assignment at %L
zh_CN: 赋值中有不兼容的秩 %d 和 %d，位于 %L

en: Incompatible ranks in %s (%d and %d) at %L
zh_CN: %4$L%1$s 中秩(%2$d 和 %3$d)不兼容

en: Incompatible types in DATA statement at %L; attempted conversion of %s to %s
zh_CN: %L处 DATA 语句中类型不兼容；试图从 %s 转换到 %s

en: Inconsistent ranks for operator at %%L and %%L
zh_CN: %%L和%%L处的操作数的秩不一致

en: Incorrect EH edge %i->%i
zh_CN: 不正确的 EH 边 %i->%i

en: Index in dimension %d is out of bounds at %L
zh_CN: %2$L处第 %1$d 维下标越界

en: Initialization at %C is not allowed in a PURE procedure
zh_CN: 初始化不允许出现在%C处的 PURE 过程中

en: Initialization at %C isn't for a pointer variable
zh_CN: %C处的初始化不是为指针变量准备的

en: Initialization of allocatable component at %C is not allowed
zh_CN: 不允许在%C处初始化可分配的组件

en: Initialization of pointer at %C is not allowed in a PURE procedure
zh_CN: %C处对指针的初始化不允许出现在 PURE 过程中

en: Initialization of variable at %C is not allowed in a PURE procedure
zh_CN: %C处对变量的初始化不允许出现在 PURE 过程中

en: Initialize ptx registers.
zh_CN: 初始化 ptx 寄存器。

en: Initializing already initialized variable at %C
zh_CN: %C处初始化已经初始化的变量

en: Integer expression required at %C
zh_CN: %C处需要整数表达式

en: Integer kind %d at %C not available
zh_CN: 整数种别 %d 在%C处不可用

en: Integer outside symmetric range implied by Standard Fortran at %L
zh_CN: %L处整数超出标准 Fortran 隐含的对称范围

en: Integer outside symmetric range implied by Standard Fortran converting %s to %s at %L
zh_CN: %3$L处将%1$s转换为%2$s时整数超过了标准 Fortran 所规定的对称范围

en: Integer too large at %C
zh_CN: %C处整数太大

en: Integer value too large in expression at %C
zh_CN: %C处表达式中整数值太大

en: Interface mismatch in procedure pointer assignment at %L: %s
zh_CN: %L处过程指针赋值中接口不匹配：%s

en: Interface must be specified for DEFERRED binding at %C
zh_CN: %C处必须为 DEFERRED 绑定指定接口

en: Internal compiler error:
zh_CN: 编译器内部错误：

en: Internal unit with vector subscript at %L
zh_CN: %L处内部单位带向量下标

en: Interpret any REAL(4) as a REAL(10).
zh_CN: 将所有 REAL(4) 解译为 REAL(10)。

en: Interpret any REAL(4) as a REAL(16).
zh_CN: 将所有 REAL(4) 解译为 REAL(16)。

en: Interpret any REAL(4) as a REAL(8).
zh_CN: 将所有 REAL(4) 解译为 REAL(8)。

en: Interpret any REAL(8) as a REAL(10).
zh_CN: 将所有 REAL(8) 解译为 REAL(10)。

en: Interpret any REAL(8) as a REAL(16).
zh_CN: 将所有 REAL(8) 解译为 REAL(16)。

en: Interpret any REAL(8) as a REAL(4).
zh_CN: 将所有 REAL(8) 解译为 REAL(4)。

en: Intrinsic operator interface at %L must be a FUNCTION
zh_CN: %L处内建运算符接口必须是一个 FUNCTION

en: Intrinsic procedure at %L cannot be a MODULE PROCEDURE
zh_CN: %L处内建过程不能是 MODULE PROCEDURE

en: Invalid Hollerith constant at %L contains a wide character
zh_CN: %L处无效的荷勒瑞斯常量包含一个宽字符

en: Invalid Hollerith constant: %L must contain at least one character
zh_CN: 无效的荷勒瑞斯常量：%L 必须包含至少一个字符

en: Invalid Hollerith constant: Integer kind at %L should be default
zh_CN: 无效的荷勒瑞斯常量：%L处的整数种别应当是默认的

en: Invalid KIND parameter of %s at %L
zh_CN: %s 位于 %L 的 KIND 参数无效

en: Invalid character in name at %C
zh_CN: %C处的名字中有非法字符

en: Invalid context for NULL() pointer at %%L
zh_CN: %%L处 NULL() 指针上下文无效

en: Invalid form of PROGRAM statement at %C
zh_CN: %C处 PROGRAM 语句格式无效

en: Invalid form of WRITE statement at %L, UNIT required
zh_CN: %L处 WRITE 语句形式无效，需要 UNIT

en: Invalid form of array reference at %C
zh_CN: %C处数组引用形式无效

en: Invalid initializer %s in Data statement at %C
zh_CN: %2$C处 DATA 语句初始值设定 %1$s 无效

en: Invalid kind %d for CHARACTER constant at %C
zh_CN: CHARACTER 常量的种别 %d 无效，在%C处

en: Invalid kind for %s at %L
zh_CN: %2$L处 %1$s 种别无效

en: Invalid procedure argument at %L
zh_CN: %L过程参数无效

en: Invalid procedure pointer assignment at %L
zh_CN: %L处过程指针赋值非法

en: Invalid real kind %d at %C
zh_CN: 无效的实型种别 %d，在%C处

en: Invalid type-spec at %C
zh_CN: %C处类型指定无效

en: Invalid value for %s specification at %C
zh_CN: %2$C处‘%1$s’规格无效

en: Iterator step at %L cannot be zero
zh_CN: %L处游标步进不能为零

en: Junk after CALL at %C
zh_CN: %C处在 CALL 以后有垃圾字符

en: Junk after GENERIC binding at %C
zh_CN: %C 处的泛型绑定后有垃圾字符

en: KIND parameter of %s at %L must be an initialization expression
zh_CN: KIND 参数 %s 在%L处必须是初始化表达式

en: Kind %d is not supported for CHARACTER at %C
zh_CN: 种别 %d 在%C处不为 CHARACTER 所支持

en: Kind %d not supported for type %s at %C
zh_CN: 种别 %1$d 不为类型%3$C处 %2$s 所支持

en: Kind type parameter for entity at %L differs from the kind type parameter of the typespec
zh_CN: %L实体的种别类型参数与类型限定中的种别类型参数不同

en: Known AArch64 ABIs (for use with the -mabi= option):
zh_CN: 已知 AArch64 ABI (用于 -mabi= 选项)：

en: Known ABIs (for use with the -mabi= option):
zh_CN: 已知 ABI (用于 -mabi= 选项)：

en: Known ARM ABIs (for use with the -mabi= option):
zh_CN: 已知 ARM ABI (用于 -mabi= 选项)：

en: Known ARM CPUs (for use with the -mcpu= and -mtune= options):
zh_CN: 已知 ARM 处理器 (用于 -mcpu= 和 -mtune= 选项)：

en: Known ARM FPUs (for use with the -mfpu= option):
zh_CN: 已知 ARM 浮点处理器 (用于 -mfpu= 选项)：

en: Known ARM architectures (for use with the -march= option):
zh_CN: 已知 ARM 架构 (用于 -march= 选项)：

en: Known C6X ISAs (for use with the -march= option):
zh_CN: 已知 C6X ISA (用于 -march= 选项)：

en: Known CPUs (for use with the -mcpu= and -mtune= options):
zh_CN: 已知处理器 (用于 -mcpu= 和 -mtune= 选项)：

en: Known FR-V CPUs (for use with the -mcpu= option):
zh_CN: 已知 FR-V 处理器 (用于 -mcpu= 选项)：

en: Known IQ2000 CPUs (for use with the -mcpu= option):
zh_CN: 已知 IQ2000 处理器 (用于 -mcpu= 选项)：

en: Known Itanium CPUs (for use with the -mtune= option):
zh_CN: 已知 Itanium 处理器 (用于 -mtune= 选项)：

en: Known M68K CPUs (for use with the -mcpu= option):
zh_CN: 已知 M68K 处理器 (用于 -mcpu= 选项)：

en: Known M68K ISAs (for use with the -march= option):
zh_CN: 已知 M68K ISA (用于 -march= 选项)：

en: Known M68K microarchitectures (for use with the -mtune= option):
zh_CN: 已知 M68K 微架构 (用于 -mtune= 选项)：

en: Known MIPS ABIs (for use with the -mabi= option):
zh_CN: 已知 MIPS ABI (用于 -mabi= 选项)：

en: Known MIPS CPUs (for use with the -march= and -mtune= options):
zh_CN: 已知 MIPS 处理器 (用于 -march= 和 -mtune= 选项)：

en: Known MIPS IEEE 754 settings (for use with the -mabs= and -mnan= options):
zh_CN: 已知 MIPS IEEE 754 设置 (用于 -march= 和 -mtune= 选项)：

en: Known MIPS ISA levels (for use with the -mips option):
zh_CN: 已知 MIPS ISA 等级 (用于 -mips 选项)：

en: Known TLS dialects (for use with the -mtls-dialect= option):
zh_CN: 已知 TLS 方言 (用于 -mtls-dialect= 选项)：

en: Known address mode (for use with the -maddress-mode= option):
zh_CN: 已知寻址模式 (用于 -mcmodel= 选项)：

en: Known code models (for use with the -mcmodel= option):
zh_CN: 已知编码模型 (用于 -mcmodel= 选项)：

en: Known floating-point ABIs (for use with the -mfloat-abi= option):
zh_CN: 已知浮点 ABI (用于 -mfloat-abi= 选项)：

en: L%d cache latency unknown for %s
zh_CN: L%d 缓存延迟未知，对 %s 来说

en: LOGICAL operands are required in expression at %L
zh_CN: %L处的表达式需要 LOGICAL 操作数

en: LTO support has not been enabled in this configuration
zh_CN: LTO 支持在此配置下未被启用

en: Label %d at %C already referenced as a format label
zh_CN: %2$C处的标号 %1$d 已作为格式标号引用

en: Label %d at %C already referenced as branch target
zh_CN: %2$C处的标号 %1$d 已作为分支目标引用

en: Label %d at %C previously used as a FORMAT label
zh_CN: %2$C处的标号 %1$d 先前用作 FORMAT 标号

en: Label %d at %C previously used as branch target
zh_CN: %2$C处的标号 %1$d 先前用作分支目标

en: Label %d at %L defined but cannot be used
zh_CN: 标号 %d 于 %L 经定义但无法被使用

en: Label %d at %L defined but not used
zh_CN: 标号 %d 于 %L 经定义但未被使用

en: Label %d referenced at %L is never defined
zh_CN: 标号 %d(引用自 %L)从未被定义

en: Label at %L is not in the same block as the GOTO statement at %L
zh_CN: %L处的标号与%L处 GOTO 语句不在相同的块中

en: Letters must be in alphabetic order in IMPLICIT statement at %C
zh_CN: %C处 IMPLICIT 语句中的字母必须按序排列

en: Like -M but ignore system header files.
zh_CN: 与 -M 类似，但是忽略系统头文件。

en: Like -MD but ignore system header files.
zh_CN: 与 -MD 类似，但是忽略系统头文件。

en: Limit of %d continuations exceeded in statement at %C
zh_CN: %2$C处语句超出 %1$d 个续行的限制

en: Line truncated at %L
zh_CN: 行在%L处被截断

en: Lines executed:%s of %d
zh_CN: 已执行的行数：%s (共 %d 行)

en: Link with the fast floating-point library.
zh_CN: 与快速浮点库链接。

en: List all available debugging counters with their limits and counts.
zh_CN: 列出所有可用的调试计数器及其极限和计数。

en: Logical SELECT CASE block at %L has more that two cases
zh_CN: %L处逻辑 SELECT CASE 块有多于两个的情况

en: Logical range in CASE statement at %L is not allowed
zh_CN: %L处 CASE 语句中的逻辑范围是不被允许的

en: Logicals at %%L must be compared with %s instead of %s
zh_CN: %%L处逻辑值必须与 %s 比较，而不是 %s

en: Loop iterates infinitely
zh_CN: 循环无限次迭代

en: Loop variable
zh_CN: 循环变量

en: Loop variable at %C cannot be a sub-component
zh_CN: %C处的循环变量不能是一个子组件

en: Loop variable has been modified
zh_CN: 循环变量已被修改

en: Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d
zh_CN: %1$L处数组下限引用在第 %4$d 维中越界(%2$ld < %3$ld)

en: Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d
zh_CN: %1$L处数组下限引用在第 %4$d 维中越界(%2$ld > %3$ld)

en: MIPS16 PIC for ABIs other than o32 and o64
zh_CN: MIPS16 PIC 代码的 ABI 不是 o32 或 o64

en: MMIX Internal: Bad register: %d
zh_CN: MMIX 内部错误：错误的寄存器：%d

en: MMIX Internal: Bad value for 'm', not a CONST_INT
zh_CN: MMIX 内部错误：‘m’值错误，不是一个整常量

en: MMIX Internal: Cannot decode this operand
zh_CN: MMIX 内部错误：无法解码此操作数

en: MMIX Internal: Expected a CONST_INT, not this
zh_CN: MMIX 内部错误：预期的是整常量，不是这个

en: MMIX Internal: Expected a constant, not this
zh_CN: MMIX 内部错误：需要一个常量，不是这个

en: MMIX Internal: Expected a register, not this
zh_CN: MMIX 内部错误：需要一个寄存器，不是这个

en: MMIX Internal: Last named vararg would not fit in a register
zh_CN: MMIX 内部错误：最后一个有名的不定参数无法放入寄存器中

en: MMIX Internal: This is not a constant:
zh_CN: MMIX 内部错误：这不是一个常量：

en: MMIX Internal: This is not a recognized address
zh_CN: MMIX 内部错误：这不是一个可识别的地址

en: MMIX Internal: Trying to output invalidly reversed condition:
zh_CN: MMIX 内部错误：试图输出无效地反转的条件：

en: MMIX Internal: What is the CC of this?
zh_CN: MMIX 内部错误：它的比较条件是什么？

en: MMIX Internal: What's the CC of this?
zh_CN: MMIX 内部错误：它的比较条件是什么？

en: MMX vector argument without MMX enabled changes the ABI
zh_CN: 没有启用 MMX，却出现了 MMX 向量实参，这改变了 ABI

en: MMX vector return without MMX enabled changes the ABI
zh_CN: 没有启用 MMX却返回 MMX 向量，这改变了 ABI

en: MODULE PROCEDURE at %C must be in a generic module interface
zh_CN: %C处的 MODULE PROCEDURE 必须在一个泛型接口内

en: Make "char" signed by default.
zh_CN: 使“char”类型默认为有符号。

en: Make "char" unsigned by default.
zh_CN: 使“char”类型默认为无符号。

en: Make integers 32 bits wide.
zh_CN: 让整数有 32 位宽。

en: Maximum size in bytes of constant values allowed as operands.
zh_CN: 用字节表示的能被用作操作数的常量的最大尺寸。

en: Maximum size of global and static variables which can be placed into the small data area.
zh_CN: 能被放在小内存区的全局和静态变量的最大尺寸。

en: Maximum subrecord length cannot exceed %d
zh_CN: 子记录长度不能超过 %d

en: Maximum supported identifier length is %d
zh_CN: 支持的标识符的最大长度为 %d

en: Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention
zh_CN: %L处过程指针赋值不匹配：调用约定不匹配

en: Missing -mcpu option in ASM_CPU_SPEC?
zh_CN: 是否在 ASM_CPU_SPEC 中缺少 -mcpu 选项？

en: Missing alternate return spec in subroutine call at %L
zh_CN: %L处子进程调用缺少替代返回限定

en: Missing array specification at %L in DIMENSION statement
zh_CN: %L处的 DIMENSION 语句缺少数组规格

en: Missing character range in IMPLICIT at %C
zh_CN: %C处 IMPLICIT 缺少字符范围

en: Missing closing paren for binding label at %C
zh_CN: %C处绑定标号缺少右括号

en: Missing dimension specification at %C
zh_CN: %C处没有维数规格

en: Missing entity or common block name for attribute specification statement at %C
zh_CN: %C处的属性规格说明语句缺少实体或公共块名

en: Missing exponent in real number at %C
zh_CN: %C处实数缺少指数部分

en: Missing format label at %C
zh_CN: %C处缺少格式标号

en: Missing generic specification in USE statement at %C
zh_CN: %C处的 USE 语句缺少泛型规格

en: Missing keyword name in actual argument list at %C
zh_CN: %C处的实参数列中缺少关键字名

en: Missing kind-parameter at %C
zh_CN: %C处缺少种别参数

en: Missing required parentheses before BIND(C) at %C
zh_CN: %C 处 BIND(C) 前缺少要求的括号

en: Missing right parenthesis at %C
zh_CN: %C处缺少右括号

en: Missing right parenthesis or comma at %C
zh_CN: %C处缺少右括号或逗号

en: Module nature in USE statement at %C shall be either INTRINSIC or NON_INTRINSIC
zh_CN: %C处 USE 语句中的模块本性应该是 INTRINSIC 或 NON_INTRINSIC 中的一个

en: More actual than formal arguments in procedure call at %L
zh_CN: %L处调用过程时实参比形参多

en: Multiple identifiers provided with single NAME= specifier at %C
zh_CN: %C处为单个 NAME= 指定了多个标识符

en: NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C
zh_CN: %C 处的 ABSTRACT INTERFACE 的 BIND(C)上不允许有 NAME

en: NOPASS or explicit interface required at %C
zh_CN: %C处需要 NOPASS 或显式接口

en: NOTE_INSN_BASIC_BLOCK %d in middle of basic block %d
zh_CN: NOTE_INSN_BASIC_BLOCK %d 在基本块 %d 中间

en: NOTE_INSN_BASIC_BLOCK is missing for block %d
zh_CN: 块 %d 缺少 NOTE_INSN_BASIC_BLOCK

en: NO_ARG_CHECK attribute
zh_CN: NO_ARG_CHECK 属性

en: NULL appears on right-hand side in assignment at %L
zh_CN: %L处赋值右手边出现 NULL

en: NULL used in arithmetic
zh_CN: 算术表达式中使用了 NULL

en: NULL() initialization at %C is ambiguous
zh_CN: %C处的 NULL() 初始化有歧义

en: Name after !$omp critical and !$omp end critical does not match at %C
zh_CN: %C处 !$omp critical 和 !$omp end critical 后的名字不匹配

en: Name at %C is too long
zh_CN: %C 的名字太长

en: Name of system library to link against.
zh_CN: 要链接的系统库的名称。

en: Name too long
zh_CN: 名字太长

en: Named block DO at %L requires matching ENDDO name
zh_CN: %L处有名的块 DO 需要匹配的 ENDDO 名

en: Named constant at %C in an EQUIVALENCE
zh_CN: %C处有名常量出现在 EQUIVALENCE 中

en: Need either entity or common block name for attribute specification statement at %C
zh_CN: %C处的属性规格说明语句需要实体或公共块名

en: No binding name is allowed in BIND(C) at %C
zh_CN: %C处的 BIND(C) 中不允许有绑定名

en: No branches
zh_CN: 没有跳转

en: No calls
zh_CN: 没有调用

en: No description yet.
zh_CN: 尚无描述。

en: No executable lines
zh_CN: 没有可执行行

en: No longer supported.
zh_CN: 不再支持。

en: Non-ELEMENTAL user-defined assignment in WHERE at %L
zh_CN: %L处 WHERE 中用户定义的非 ELEMENTAL 用户赋值

en: Non-character assumed shape array element in FORMAT tag at %L
zh_CN: %L处的 FORMAT 标记中假定外形数组中有非字符元素

en: Non-character assumed size array element in FORMAT tag at %L
zh_CN: %L处的 FORMAT 标记中假定大小数组中有非字符元素

en: Non-character pointer array element in FORMAT tag at %L
zh_CN: %L处的 FORMAT 标记中有非字符指针数组元素

en: Non-numeric character in statement label at %C
zh_CN: %C处语句标号中出现非数字字符

en: Non-scalar FINAL procedure at %L should have assumed shape argument
zh_CN: %L处的非标量 FINAL 过程应当有假定外形的参数

en: Nonconforming tab character at %C
zh_CN: %C处的制表符不相容

en: Nonconforming tab character in column %d of line %d
zh_CN: 第 %d 列第 %d 行有不相容的制表符

en: Nonconstant array section at %L in DATA statement
zh_CN: %L处 DATA 语句中有非常量数组段

en: Nonexistent include directory %qs
zh_CN: 不存在的 include 目录 %qs

en: Nonstandard type declaration %s*%d at %C
zh_CN: %3$C处的 %1$s*%2$d 类型声明不符合标准

en: Numeric PARAMETER required in complex constant at %C
zh_CN: %C处数值 PARAMETER 要求复数常量

en: Numeric operands are required in expression at %L
zh_CN: %L处的表达式需要数字操作数

en: Numeric or CHARACTER operands are required in expression at %L
zh_CN: %L处的表达式中需要数字或 CHARACTER 操作数

en: OPEN statement not allowed in PURE procedure at %C
zh_CN: OPEN 语句不允许出现在%C处的 PURE 过程中

en: OPTIONAL is not allowed inside of BLOCK at %C
zh_CN: OPTIONAL 不能用在%C处 BLOCK 内

en: Objective-C declarations may only appear in global scope
zh_CN: Objective-C 声明只能出现在全局作用域中

en: Offline tool to handle gcda counts
zh_CN: 用于处理 gcda 计数的离线工具

en: Old-style type declaration %s*%d not supported at %C
zh_CN: %3$C处旧式的类型声明 %1$s*%2$d 不受支持

en: Only generate absolute relocations on word sized values.
zh_CN: 对字大小的值仅产生绝对重定位。

en: Only intrinsic operators can be used in expression at %L
zh_CN: %L处只有内建运算符才能用于表达式中

en: Only retained for backward compatibility.
zh_CN: 不起作用，仅为向前兼容保留。

en: Operand of .not. operator at %%L is %s
zh_CN: %%L处的 .not. 运算符的操作数为 %s

en: Operands of string concatenation operator at %%L are %s/%s
zh_CN: 字符串毗连运算符(位于 %%L)的操作数为 %s/%s

en: Operator interface at %L conflicts with intrinsic interface
zh_CN: %L处运算符接口与内建接口冲突

en: Operator interface at %L has the wrong number of arguments
zh_CN: %L处的运算符接口实参数错误

en: Operator interface at %L must have, at most, two arguments
zh_CN: %L处的运算符接口必须有至多两个实参

en: Optimize for CPU.
zh_CN: 为 CPU 优化。

en: Options:
zh_CN: 选项：

en: Out of stack space.
zh_CN: 堆栈溢出。

en: Output .debug_types section when using DWARF v4 debuginfo.
zh_CN: 使用 DWARF v4 debuginfo 时输出 .debug_types 区段。

en: Overlapping unequal initializers in EQUIVALENCE at %L
zh_CN: %L 处  EQUIVALENCE 中不等的初始值设定重叠

en: PARAMETER at %L is missing an initializer
zh_CN: %L处 PARAMETER 缺少初始值设定

en: PCS variant
zh_CN: PCS 变动

en: PHI argument is missing for edge %d->%d
zh_CN: 边 %d->%d 缺少 PHI 参数

en: PHI argument is not SSA_NAME, or invariant
zh_CN: PHI 参数不是 SSA_NAME 或不变量

en: PIC code generation is not compatible with fast indirect calls
zh_CN: PIC 代码生成与快速间接调用不兼容

en: PIC code generation is not supported in the portable runtime model
zh_CN: PIC 代码生成在可移植运行时模型中不受支持

en: PIC is only supported for RTPs
zh_CN: PIC 只在 RTP 上受支持

en: PIC is required but not supported with CONST16 instructions
zh_CN: 需要 PIC，但 CONST16 指令不支持

en: PIC support for %<-fstack-limit-symbol%>
zh_CN: %<-fstack-limit-symbol%> 的 PIC 支持

en: POINTER attribute is required for procedure pointer component at %C
zh_CN: %C处的过程指针组件需要 POINTER 属性

en: PRE disabled
zh_CN: PRE 被禁用

en: PRINT namelist at %C is an extension
zh_CN: %C处的 PRINT 名字列表是一个扩展

en: PRINT statement at %C not allowed within PURE procedure
zh_CN: PRINT 语句不允许出现在%C处的 PURE 过程中

en: PRIVATE statement at %C is only allowed in the specification part of a module
zh_CN: %C处的 PRIVATE 语句仅允许出现在模块规格说明部分内

en: PRIVATE statement at %C must precede procedure bindings
zh_CN: %C处 PRIVATE 语句必须先于过程绑定

en: PRIVATE statement at %C must precede structure components
zh_CN: %C处 PRIVATE 语句必须先于结构组件

en: PRIVATE statement in TYPE at %C must be inside a MODULE
zh_CN: %C处 TYPE 中的 PRIVATE 语句必须在 MODULE 中

en: PROCEDURE at %C must be in a generic interface
zh_CN: %C处的 PROCEDURE 必须在一个泛型接口内

en: PROCEDURE(interface) at %C should be declared DEFERRED
zh_CN: %C处的 PROCEDURE(接口) 需要声明为 DEFERRED

en: PROTECTED at %C only allowed in specification part of a module
zh_CN: %C处的 PROTECTED 仅允许出现在模块规格说明部分内

en: PUBLIC statement at %C is only allowed in the specification part of a module
zh_CN: %C处的 PUBLIC 语句只不允许出现在模块规格说明部分内

en: Passed-object at %L must be scalar
zh_CN: %L处传递的对象必须是标量

en: Passing internal procedure at %L by location not allowed
zh_CN: 不允许按位置传递%L处的内部过程

en: Perform conversions of switch initializations.
zh_CN: 转换开关初始化。

en: Perform function-local points-to analysis on trees.
zh_CN: 在树上进行函数内的指向分析。

en: Period required in format specifier %s at %L
zh_CN: %2$L处的格式限定符%1$s中需要句号

en: Period required in format specifier at %L
zh_CN: %L处的格式限定符需要句号

en: Plugins
zh_CN: 插件

en: Pointer array component of structure at %C must have a deferred shape
zh_CN: %C处结构的指针数组组件必须有延迟的外形

en: Pointer assignment target has PROTECTED attribute at %L
zh_CN: %L处指针赋值目标对象有 PROTECTED 属性

en: Pointer assignment target is neither TARGET nor POINTER at %L
zh_CN: %L处指针赋值的目标既不是 TARGET 也不是 POINTER

en: Pointer assignment target is not a POINTER at %L
zh_CN: %L处指针赋值的目标不是一个 POINTER

en: Pointer assignment with vector subscript on rhs at %L
zh_CN: %L处指针赋值的右手边带有向量下标

en: Pointers are 32-bit.
zh_CN: 指针是 32 位。

en: Pointers are 64-bit.
zh_CN: 指针是 64 位。

en: Positive width required in format specifier %s at %L
zh_CN: %2$L处的格式指定 %1$s 需要正的宽度

en: Preprocess directives only.
zh_CN: 仅预处理指示。

en: Preprocessed source stored into %s file, please attach this to your bugreport.
zh_CN: 预处理后的源码储存于文件 %s，请将其附在错误报告内。

en: Pretend a branch-around-a-move is a conditional move.
zh_CN: 将数据传输周围的跳转认为是条件转移。

en: Print code coverage information.
zh_CN: 显示代码覆盖信息。

en: Procedure argument at %L is local to a PURE procedure and has the POINTER attribute
zh_CN: %L处的过程参数对于 PURE 过程是局部的，但是有 POINTER 属性

en: Processing spec (%s), which is '%s'
zh_CN: 处理 spec (%s)，即‘%s’

en: Program is entirely located in low 64k of memory.
zh_CN: 程序完全位于内存的低 64K。

en: Prohibit PC relative function calls.
zh_CN: 禁止相对 PC 的函数调用。

en: RESULT variable at %C must be different than function name
zh_CN: %C处 RESULT 变量不能与函数重名

en: RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d
zh_CN: RTL 检查：在 %4$s 中访问了‘%2$s’的 elt %1$d，最后的 elt %3$d，于 %5$s:%6$d

en: RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d
zh_CN: RTL 检查：在 %3$s 中访问了向量 elt %1$d，最后的 elt %2$d，于 %4$s:%5$d

en: RTL check: attempt to treat non-block symbol as a block symbol in %s, at %s:%d
zh_CN: RTL 检查：在 %s 中试图将非块符号处理为块符号，于 %s:%d

en: RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d
zh_CN: RTL 检查：需要代码‘%s’或‘%s’，却得到‘%s’在 %s，于 %s:%d

en: RTL check: expected code '%s', have '%s' in %s, at %s:%d
zh_CN: RTL 检查：需要代码‘%s’，却得到‘%s’在 %s，于 %s:%d

en: RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d
zh_CN: RTL 检查：在 %6$s 中需要 elt %1$d 类型‘%2$c’或‘%3$c’，得到了‘%4$c’(rtx %5$s)，于 %7$s:%8$d

en: RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d
zh_CN: RTL 检查：在 %5$s 中需要 elt %1$d 类型‘%2$c’，得到了‘%3$c’(rtx %4$s)，于 %6$s:%7$d

en: RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d
zh_CN: RTL 标记检查：%3$s 中与非预期 rtx 代码‘%2$s’一起使用的 %1$s，于 %4$s:%5$d

en: RTP PIC is incompatible with Thumb
zh_CN: RTP PIC 与 Thumb 不兼容

en: RX FPU instructions do not support NaNs and infinities
zh_CN: RX FPU  指令不支持 NaN 和无限

en: Raising a negative REAL at %L to a REAL power is prohibited
zh_CN: %L处不能为负的 REAL 取 REAL 次幂

en: Range specification at %L can never be matched
zh_CN: %L处范围规格无法匹配

en: Rank mismatch in array reference at %L (%d/%d)
zh_CN: %L处数组引用中秩不匹配(%d/%d)

en: Reading specs from %s
zh_CN: 从 %s 读取 specs

en: Real constant overflows its kind at %C
zh_CN: %C处实常数上溢其种别

en: Real constant underflows its kind at %C
zh_CN: %C处实常数下溢其种别

en: Recognize GNU-defined keywords.
zh_CN: 识别 GNU 定义的关键字。

en: Recognize built-in functions.
zh_CN: 识别内建函数。

en: Recognize the "asm" keyword.
zh_CN: 识别“asm”关键字。

en: Record gcc command line switches in the object file.
zh_CN: 在目标文件中记录 gcc 命令行开关。

en: Remap file names when including files.
zh_CN: 包含文件时重映射文件名。

en: Removed in GCC 10.  This switch has no effect.
zh_CN: 已在 GCC 10 中移除。此开关不起作用。

en: Removed in GCC 8.  This switch has no effect.
zh_CN: 已在 GCC 8 中移除。此开关不起作用。

en: Removed in GCC 9.  This switch has no effect.
zh_CN: 已在 GCC 9 被移除。此开关不起作用。

en: Removing '%s'
zh_CN: 正在移除 '%s'

en: Result of %s gives range error for its kind at %L
zh_CN: %s 的结果在%L处为其种别给出范围错误

en: Result of %s is NaN at %L
zh_CN: %s 的结果在%L处为 NaN

en: Result of %s overflows its kind at %L
zh_CN: %s 的结果在%L处上溢其种别

en: Result of %s underflows its kind at %L
zh_CN: %s 的结果在%L处下溢其种别

en: Result of NEAREST is NaN at %L
zh_CN: NEAREST 的结果在%L处为 NaN

en: Result of SCALE overflows its kind at %L
zh_CN: %L处 SCALE 的结果上溢其种别

en: Reuse r30 on a per function basis.
zh_CN: 按函数重用 r30。

en: Rewrite subcommand usage:
zh_CN: Rewrite 子命令用法:

en: Rightmost upper bound of assumed size array section not specified at %L
zh_CN: %L处未指定假定大小数组段的最右端上限

en: Run predictive commoning optimization.
zh_CN: 启用预测公因子优化。

en: Run the link-time optimizer in local transformation (LTRANS) mode.
zh_CN: 在局部转化(LTRANS)模式下运行链接时优化器。

en: Run the link-time optimizer in whole program analysis (WPA) mode.
zh_CN: 在全程序分析(WPA)模式下运行链接时优化器。

en: Runtime name.
zh_CN: 运行时名称。

en: SAVE attribute at %L cannot be specified in a PURE procedure
zh_CN: %L处 PURE 过程不能指定 SAVE 属性

en: SAVE statement at %C follows blanket SAVE statement
zh_CN: %C处 SAVE 语句跟随空白 SAVE 语句

en: SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression
zh_CN: %L处的 SCHEDULE 分句的 chunk_size 需要一个标量 INTEGER 表达式

en: SEQUENCE attribute at %C already specified in TYPE statement
zh_CN: %C处 SEQUENCE 属性已经在 TYPE 语句中指定

en: SEQUENCE statement at %C must precede CONTAINS
zh_CN: %C处 SEQUENCE 语句必须先于 CONTAINS

en: SEQUENCE statement at %C must precede structure components
zh_CN: %C处 SEQUENCE 语句必须先于结构组件

en: SH2a does not support little-endian
zh_CN: SH2a 不支持小端在前

en: SOURCE tag at %L conflicts with the typespec at %L
zh_CN: %L处的 SOURCE 标记与%L处的类型指定冲突

en: SSA corruption
zh_CN: SSA 损坏

en: SSA_NAME created in two different blocks %i and %i
zh_CN: SSA_NAME 在基本块 %i 和 %i 中均被创建

en: SSA_NAME_DEF_STMT is wrong
zh_CN: SSA_NAME_DEF_STMT 不正确

en: SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set
zh_CN: 应该设置 SSA_NAME_OCCURS_IN_ABNORMAL_PHI

en: SSE instruction set disabled, using 387 arithmetics
zh_CN: SSE 指令集已禁用，使用 387 指令

en: SSE register argument with SSE disabled
zh_CN: 已禁用 SSE 却在 SSE 寄存器中传递参数

en: SSE register return with SSE disabled
zh_CN: 已禁用 SSE 却在 SSE 寄存器中返回

en: SSE vector argument without SSE enabled changes the ABI
zh_CN: 没有启用 SSE，却出现了 SSE 向量实参，这改变了 ABI

en: SSE vector return without SSE enabled changes the ABI
zh_CN: 没有启用 SSE，却有 SSE 向量返回值，这改变了 ABI

en: Same as -fassociative-math for expressions which include division.
zh_CN: 与 -fassociative-math 相同，作用于包含除法的表达式。

en: Same as -mA6.
zh_CN: 与 -mA6 相同。

en: Same as -mA7.
zh_CN: 与 -mA7 相同。

en: Same as: -mep -mprolog-function.
zh_CN: 等同于：-mep -mprolog-function。

en: Scalar PARAMETER required in complex constant at %C
zh_CN: %C处标量 PARAMETER 要求复数常量

en: Second argument of defined assignment at %L must be INTENT(IN)
zh_CN: %L处定义赋值的第二个参数必须是 INTENT(IN)

en: Second argument of operator interface at %L cannot be optional
zh_CN: %L处运算符接口的第二个参数不能是可选的

en: Second argument of operator interface at %L must be INTENT(IN)
zh_CN: %L处运算符接口的第二个参数必须是 INTENT(IN)

en: See %s for instructions.
zh_CN: 参阅 %s 以获取指示。

en: Select code model.
zh_CN: 选择代码模型。

en: Select the runtime.
zh_CN: 选择运行时。

en: Selection expression in computed GOTO statement at %L must be a scalar integer expression
zh_CN: %L处计算转移 GOTO 语句的选择表达式必须是一个标量整数表达式

en: Selector in SELECT TYPE at %C is not a named variable; use associate-name=>
zh_CN: %C处 SELECT TYPE 中的选择子不是一个有名变量；请使用 associate-name=>

en: Semicolon at %C needs to be preceded by statement
zh_CN: %C处分号前必须是一个语句

en: Set 80387 floating-point precision to 32-bit.
zh_CN: 设定 80387 浮点精度为32位。

en: Set 80387 floating-point precision to 64-bit.
zh_CN: 设定 80387 浮点精度为64位。

en: Set 80387 floating-point precision to 80-bit.
zh_CN: 设定 80387 浮点精度为80位。

en: Set Windows defines.
zh_CN: 设定 Windows 定义。

en: Set branch cost.
zh_CN: 设定分支的开销。

en: Set default accessibility of module entities to PRIVATE.
zh_CN: 将模块实体的默认访问权限设置为 PRIVATE。

en: Set sizeof(bool) to 1.
zh_CN: 设定 sizeof(bool) 为 1。

en: Set start-address of data.
zh_CN: 设定数据的起始地址。

en: Set start-address of the program.
zh_CN: 设定程序的起始地址。

en: Setting spec %s to '%s'
zh_CN: 将 spec %s 设为‘%s’

en: Shape specification for allocatable scalar at %C
zh_CN: %C处可分配标量的外形规格说明

en: Shapes for operands at %L and %L are not conformable
zh_CN: %L和%L处的操作数外形不相容

en: Share slots for saving different hard registers.
zh_CN: 为保存不同的硬寄存器的共享槽。

en: Share stack slots for spilled pseudo-registers.
zh_CN: 为溢出的伪寄存器共享堆栈槽。

en: Sort the symbols according to size.
zh_CN: 根据大小对符号进行排序。

en: Sort the symbols alphabetically.
zh_CN: 按字母顺序对符号进行排序。

en: Source-expr at %L and allocate-object at %L must have the same shape
zh_CN: %L处的源表达式和%L处的分配对象必须有相同的外形

en: Source-expr at %L must be scalar or have the same rank as the allocate-object at %L
zh_CN: %L处的源表达式必须是标量或者与%L处的分配对象有相同的秩

en: Specifies the number of registers to reserve for interrupt handlers.
zh_CN: 指定保留给中断处理函数使用的寄存器的数量。

en: Specifies whether interrupt functions should save and restore the accumulator register.
zh_CN: 指定中断函数是否要保存和恢复累积寄存器。

en: Specify CPU for scheduling purposes.  Valid arguments are 700, 7100, 7100LC, 7200, 7300, and 8000.
zh_CN: 指定调度优化的目标 CPU。有效的选项是 700、7100、7100LC、7200、7300，和 8000。

en: Specify TLS dialect.
zh_CN: 指定 TLS 方言。

en: Specify UNIX standard for predefines and linking.
zh_CN: 指定用于预定义和链接的 UNIX 标准。

en: Specify a file to which a list of files output by LTRANS is written.
zh_CN: 指定存放 LTRANS 输出的文件列表的文件。

en: Specify an ABI.
zh_CN: 指定一个 ABI。

en: Specify the MCU to build for.
zh_CN: 指定要构建的目标 MCU。

en: Specify the name of the target CPU.
zh_CN: 指定目标 CPU 的名称。

en: Specify the target CPU.
zh_CN: 指定目标 CPU。

en: Specify the target RX cpu type.
zh_CN: 指定目标 RX CPU 的类型。

en: Split 32-byte AVX unaligned load.
zh_CN: 分割 32 字节的 AVX 未对齐加载。

en: Split 32-byte AVX unaligned store.
zh_CN: 分割 32 字节的 AVX 未对齐储存。

en: Start expression in DO loop
zh_CN: DO 循环中的开始表达式

en: Stat-variable at %L must be a scalar INTEGER variable
zh_CN: %L处 stat 变量必须是一个标量 INTEGER 变量

en: Stat-variable at %L shall not be %sd within the same %s statement
zh_CN: %1$L处的统计变量不能在同一个 %3$s 语句中被 %2$s

en: Statement at %L is not a valid branch target statement for the branch statement at %L
zh_CN: %L处的语句对%L处的分支语句而言不是一个有效的分支目标语句

en: Statement function at %L is recursive
zh_CN: %L处的语句函数是递归的

en: Statement label at %C is zero
zh_CN: %C处的语句标号为零

en: Statement label in ENDDO at %C doesn't match DO label
zh_CN: %C处 ENDDO 中的语句标号与 DO 标号不匹配

en: Statement label list in GOTO at %C cannot be empty
zh_CN: %C处 GOTO 中的语句标号列表不能为空

en: Step expression in DO loop
zh_CN: DO 循环中的步进表达式

en: Step expression in DO loop at %L cannot be zero
zh_CN: %L处的 DO 循环中的步进表达式不能为零

en: Store doubles in 64 bits.
zh_CN: 以 64 位存储双精度数。

en: Stores doubles in 32 bits.  This is the default.
zh_CN: 以 32 位双精度数存储。这是默认值。

en: String length at %L is too large
zh_CN: %L处字符串太长

en: Substring at %L has length zero
zh_CN: %L 的子字符串长度为零

en: Substring end index at %L exceeds the string length
zh_CN: %L处的子字符串终止索引超过了字符串长度

en: Substring end index at %L is too large
zh_CN: %L处子串结束索引太大

en: Substring end index at %L must be of type INTEGER
zh_CN: %L处的子字符串终止索引类型必须为 INTEGER

en: Substring end index at %L must be scalar
zh_CN: %L处的子字符串终止索引必须是标量

en: Substring start index at %L is less than one
zh_CN: %L处的子字符串起始索引小于 1

en: Substring start index at %L must be of type INTEGER
zh_CN: %L处的子字符串起始索引类型必须为 INTEGER

en: Substring start index at %L must be scalar
zh_CN: %L处的子字符串起始索引必须是标量

en: Sum of second and third arguments of IBITS exceeds bit size at %L
zh_CN: %L处 IBSET 的第二个和第三个参数的总和超过位大小

en: Support 3DNow! built-in functions.
zh_CN: 支持 3DNow! 内建函数。

en: Support AES built-in functions and code generation.
zh_CN: 支持 AES 内建函数及代码生成。

en: Support AMX-BF16 built-in functions and code generation.
zh_CN: 支持 AMX-BF16 内建函数及代码生成。

en: Support AMX-INT8 built-in functions and code generation.
zh_CN: 支持 AMX-INT8 内建函数及代码生成

en: Support AMX-TILE built-in functions and code generation.
zh_CN: 支持 AMX-TILE 内建函数及代码生成。

en: Support Athlon 3Dnow! built-in functions.
zh_CN: 支持 Athlon 3DNow! 内建函数。

en: Support BMI built-in functions and code generation.
zh_CN: 支持 BMI 内建函数及代码生成。

en: Support BMI2 built-in functions and code generation.
zh_CN: 支持 BMI2 内建函数及代码生成。

en: Support CLFLUSHOPT instructions.
zh_CN: 支持 CLFLUSHOPT 指令。

en: Support CLWB instruction.
zh_CN: 支持 CLWB 指令。

en: Support CLZERO built-in functions and code generation.
zh_CN: 支持 CLZERO 内建函数及代码。

en: Support ENQCMD built-in functions and code generation.
zh_CN: 支持 ENQCMD 内建函数及代码生成。

en: Support F16C built-in functions and code generation.
zh_CN: 支持 F16C 内建函数及代码生成。

en: Support FMA4 built-in functions and code generation.
zh_CN: 支持 FMA4 内建函数及代码生成。

en: Support FSGSBASE built-in functions and code generation.
zh_CN: 支持 FSGSBASE 内建函数及代码生成。

en: Support FXSAVE and FXRSTOR instructions.
zh_CN: 支持 FXSAVE 和 FXRSTOR 指令。

en: Support HRESET built-in functions and code generation.
zh_CN: 支持 HRESET 内建函数及代码生成。

en: Support KL built-in functions and code generation.
zh_CN: 支持 KL 内建函数及代码生成。

en: Support LWP built-in functions and code generation.
zh_CN: 支持 LWP 内建函数及代码生成。

en: Support LZCNT built-in function and code generation.
zh_CN: 支持 LCZNT 内建函数及代码生成。

en: Support MMX and SSE built-in functions and code generation.
zh_CN: 支持 MMX 和 SSE 内建函数及代码生成。

en: Support MMX built-in functions.
zh_CN: 支持 MMX 内建函数。

en: Support MMX, SSE and SSE2 built-in functions and code generation.
zh_CN: 支持 MMX、SSE 和 SSE2 内建函数及代码生成。

en: Support MMX, SSE, SSE2 and SSE3 built-in functions and code generation.
zh_CN: 支持 MMX、SSE、SSE2 和 SSE3 内建函数及代码生成。

en: Support MMX, SSE, SSE2, SSE3 and SSE4A built-in functions and code generation.
zh_CN: 支持 MMX、SSE、SSE2、SSE3 和 SSE4A 内建函数及代码生成。

en: Support MMX, SSE, SSE2, SSE3 and SSSE3 built-in functions and code generation.
zh_CN: 支持 MMX、SSE、SSE2、SSE3 和 SSSE3 内建函数及代码生成。

en: Support MMX, SSE, SSE2, SSE3, SSSE3 and SSE4.1 built-in functions and code generation.
zh_CN: 支持 MMX、SSE、SSE2、SSE3、SSSE3 和 SSE4.1 内建函数及代码生成。

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 and SSE4.2 built-in functions and code generation.
zh_CN: 支持 MMX、SSE、SSE2、SSE3、SSSE3、SSE4.1 和 SSE4.2 内建函数及代码生成。

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2 and AVX built-in functions and code generation.
zh_CN: 支持 MMX、SSE、SSE2、SSE3、SSSE3、SSE4.1、SSE4.2 和 AVX 内建函数及代码生成。

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and AVX2 built-in functions and code generation.
zh_CN: 支持 MMX、SSE、SSE2、SSE3、SSSE3、SSE4.1、SSE4.2、AVX 和 AVX2 内建函数及代码生成。

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and FMA built-in functions and code generation.
zh_CN: 支持 MMX、SSE、SSE2、SSE3、SSSE3、SSE4.1、SSE4.2、AVX 和 FMA 内建函数及代码生成。

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512BW built-in functions and code generation.
zh_CN: 支持 MMX、SSE、SSE2、SSE3、SSSE3、SSE4.1、SSE4.2、AVX、AVX2、AVX512F 和 AVX512BW 内建函数及代码生成。

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512CD built-in functions and code generation.
zh_CN: 支持 MMX、SSE、SSE2、SSE3、SSSE3、SSE4.1、SSE4.2、AVX、AVX2、AVX512F 和 AVX512CD 内建函数及代码生成。

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512DQ built-in functions and code generation.
zh_CN: 支持 MMX、SSE、SSE2、SSE3、SSSE3、SSE4.1、SSE4.2、AVX、AVX2、AVX512F 和 AVX512DQ 内建函数及代码生成。

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512ER built-in functions and code generation.
zh_CN: 支持 MMX、SSE、SSE2、SSE3、SSSE3、SSE4.1、SSE4.2、AVX、AVX2、AVX512F 和 AVX512ER 内建函数及代码生成。

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512IFMA built-in functions and code generation.
zh_CN: 支持 MMX、SSE、SSE2、SSE3、SSSE3、SSE4.1、SSE4.2、AVX、AVX2、AVX512F 和 AVX512IFMA 内建函数及代码生成。

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512PF built-in functions and code generation.
zh_CN: 支持 MMX、SSE、SSE2、SSE3、SSSE3、SSE4.1、SSE4.2、AVX、AVX2、AVX512F 和 AVX512PF 内建函数及代码生成。

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512VBMI built-in functions and code generation.
zh_CN: 支持 MMX、SSE、SSE2、SSE3、SSSE3、SSE4.1、SSE4.2、AVX、AVX2、AVX512F 和 AVX512VBMI 内建函数及代码生成。

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512VL built-in functions and code generation.
zh_CN: 支持 MMX、SSE、SSE2、SSE3、SSSE3、SSE4.1、SSE4.2、AVX、AVX2、AVX512F 和 AVX512VL 内建函数及代码生成。

en: Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F built-in functions and code generation.
zh_CN: 支持 MMX、SSE、SSE2、SSE3、SSSE3、SSE4.1、SSE4.2、AVX、AVX2 和 AVX512F 内建函数及代码生成。

en: Support MWAITX and MONITORX built-in functions and code generation.
zh_CN: 支持 MWAITX 和 MONITORX 内建函数及代码生成。

en: Support PCLMUL built-in functions and code generation.
zh_CN: 支持 PCLMUL 内建函数及代码生成。

en: Support PKU built-in functions and code generation.
zh_CN: 支持 PKU 内建函数及代码生成。

en: Support PREFETCHW instruction.
zh_CN: 支持 PREFETCHW 指令。

en: Support PREFETCHWT1 built-in functions and code generation.
zh_CN: 支持 PREFETCHWT1 内建函数及代码生成。

en: Support RDRND built-in functions and code generation.
zh_CN: 支持 RDRND 内建函数及代码生成。

en: Support RDSEED instruction.
zh_CN: 支持 RDSEED 指令。

en: Support RTM built-in functions and code generation.
zh_CN: 支持 RTM 内建函数及代码生成。

en: Support SERIALIZE built-in functions and code generation.
zh_CN: 支持 SERIALIZE 内建函数及代码生成。

en: Support SHA1 and SHA256 built-in functions and code generation.
zh_CN: 支持 SHA1 和 SHA256 内建函数及代码生成。

en: Support TBM built-in functions and code generation.
zh_CN: 支持 TBM 内建函数及代码生成。

en: Support TSXLDTRK built-in functions and code generation.
zh_CN: 支持 TSXLDTRK 内建函数及代码生成。

en: Support WIDEKL built-in functions and code generation.
zh_CN: 支持 WIDEKL 内建函数及代码生成。

en: Support XOP built-in functions and code generation.
zh_CN: 支持 XOP 内建函数及代码生成。

en: Support XSAVE and XRSTOR instructions.
zh_CN: 支持 XSAVE 和 XRSTOR 指令。

en: Support XSAVEC instructions.
zh_CN: 支持 XSAVEC 指令。

en: Support XSAVEOPT instruction.
zh_CN: 支持 XSAVEOPT 指令。

en: Support XSAVES and XRSTORS instructions.
zh_CN: 支持 XSAVES 和 XRSTORS 指令。

en: Support code generation of Advanced Bit Manipulation (ABM) instructions.
zh_CN: 支持生成高级位操作(ABM)指令。

en: Support code generation of cmpxchg16b instruction.
zh_CN: 支持生成 cmpxchg16b 指令。

en: Support code generation of crc32 instruction.
zh_CN: 支持生成 crc32 指令。

en: Support code generation of movbe instruction.
zh_CN: 支持生成 movbe 指令。

en: Support code generation of popcnt instruction.
zh_CN: 支持生成 popcnt 指令。

en: Support code generation of sahf instruction in 64bit x86-64 code.
zh_CN: 支持在 x86-64 模式下生成 sahf 指令。

en: Support flag-preserving add-carry instructions.
zh_CN: 支持保存标志的加进位（add-carry）指令。

en: Support legacy multi-threading.
zh_CN: 支持传统多线程。

en: Support multi-threading.
zh_CN: 支持多线程。

en: Supported LTO compression algorithms: zlib
zh_CN: 支持的 LTO 压缩算法：zlib

en: Suppress warnings.
zh_CN: 不显示警告。

en: Symbol at %C is not appropriate for an expression
zh_CN: %C处的符号不适用于表达式

en: Symbol at %L is not a DUMMY variable
zh_CN: %L处的符号不是一个 DUMMY 变量

en: Synonym for "image_base".
zh_CN: “image_base”的同义词。

en: Synonym for -Wcomment.
zh_CN: -Wcomment 的同义词。

en: Synonym of -gnatk8.
zh_CN: -gnatk8 的同义词。

en: Syntax error in !$OMP THREADPRIVATE list at %C
zh_CN: %C处 !$OMP THREADPRIVATE 列表语法错误

en: Syntax error in !GCC$ ATTRIBUTES statement at %C
zh_CN: %C处 !GCC$ ATTRIBUTES 语句中的语法错误

en: Syntax error in %s statement at %C
zh_CN: %s 语句在%C处语法错误

en: Syntax error in ABSTRACT INTERFACE statement at %C
zh_CN: %C处 ABSTRACT INTERFACE 语句语法错误

en: Syntax error in ASYNCHRONOUS statement at %C
zh_CN: %C处 ASYNCHRONOUS 语句语法错误

en: Syntax error in CASE specification at %C
zh_CN: %C处 CASE 规格语法错误

en: Syntax error in CHARACTER declaration at %C
zh_CN: %C处 CHARACTER 声明语法错误

en: Syntax error in CLASS IS specification at %C
zh_CN: %C处 CLASS IS 规格语法错误

en: Syntax error in COMPLEX constant at %C
zh_CN: %C处的复常量语法错误

en: Syntax error in ENUMERATOR definition at %C
zh_CN: %C处 ENUMERATOR 定义中语法错误

en: Syntax error in EQUIVALENCE statement at %L
zh_CN: %L处 EQUIVALENCE 语句语法错误

en: Syntax error in FORALL iterator at %C
zh_CN: %C处 FORALL 游标语法错误

en: Syntax error in I/O iterator at %C
zh_CN: %C处 I/O 游标语法错误

en: Syntax error in IF-expression at %C
zh_CN: %C处 IF 表达式语法错误

en: Syntax error in IMPORT statement at %C
zh_CN: %C处的 IMPORT 语句语法错误

en: Syntax error in NAME= specifier for binding label at %C
zh_CN: %C绑定标号的 NAME= 限定符语法错误

en: Syntax error in OpenMP variable list at %C
zh_CN: %C处的 OpenMP 变量列表语法错误

en: Syntax error in PROCEDURE statement at %C
zh_CN: %C处 PROCEDURE 语句语法错误

en: Syntax error in PROTECTED statement at %C
zh_CN: %C处 PROTECTED 语句语法错误

en: Syntax error in SAVE statement at %C
zh_CN: %C SAVE 语句语法错误

en: Syntax error in SUBSTRING specification at %C
zh_CN: %C处 SUBSTRING 规格语法错误

en: Syntax error in TYPE IS specification at %C
zh_CN: %C处 TYPE IS 规格语法错误

en: Syntax error in VALUE statement at %C
zh_CN: %C处 VALUE 语句语法错误

en: Syntax error in VOLATILE statement at %C
zh_CN: %C处的 VOLATILE 语句语法错误

en: Syntax error in argument list at %C
zh_CN: %C处的参数列表语法错误

en: Syntax error in array constructor at %C
zh_CN: %C处数组构造语法错误

en: Syntax error in character length specification at %C
zh_CN: %C处字符长度规格语法错误

en: Syntax error in common block name at %C
zh_CN: %C处公共块名语法错误

en: Syntax error in data declaration at %C
zh_CN: %C处数据声明语法错误

en: Syntax error in expression at %C
zh_CN: %C 表达式语法错误

en: Syntax error in generic specification at %C
zh_CN: %C处泛型规格语法错误

en: Syntax error in iterator at %C
zh_CN: %C处游标语法错误

en: Syntax error in procedure pointer component at %C
zh_CN: %C处过程指针组件语法错误

en: Syntax error: Trailing garbage in END INTERFACE statement at %C
zh_CN: 语法错误：%C处 END INTERFACE 语句后有垃圾字符

en: Syntax error: Trailing garbage in INTERFACE statement at %C
zh_CN: 语法错误：在 %C处 INTERFACE 语句后有垃圾字符

en: TLS dialect to use:
zh_CN: 要使用的 TLS 方言：

en: Taken at least once:%s of %d
zh_CN: 至少执行一次的跳转：%s(总数为 %d)

en: Target: %s
zh_CN: 目标：%s

en: The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L
zh_CN: %L处的 DEFAULT CASE 为%L处的第二个 DEFAULT CASE 所跟随

en: The H format specifier at %L is a Fortran 95 deleted feature
zh_CN: %L处的 H 格式限定符已在 Fortran 95 中被删除

en: The allocate-object at %L and the source-expr at %L shall have the same kind type parameter
zh_CN: %L处的分配对象和%L处的源表达式应该有相同的种别类型参数

en: The argument list functions %%VAL, %%LOC or %%REF are not allowed in this context at %L
zh_CN: 参数列表函数 %%VAL、%%LOC 或 %%REF 在%L处该上下文中不被允许

en: The bug is not reproducible, so it is likely a hardware or OS problem.
zh_CN: 此 bug 不可重现，可能是硬件或操作系统问题。

en: The earliest macOS version on which this program will run.
zh_CN: 这个程序可能在其上运行的最早的 macOS 版本。

en: The following options are language-independent
zh_CN: 下列选项与具体语言无关

en: The following options are language-related
zh_CN: 下列选项与语言相关

en: The following options are not documented
zh_CN: 下列选项未列入文档

en: The following options are specific to just the language
zh_CN: 下列选项只与特定语言相关

en: The following options are supported by the language
zh_CN: 下列选项被语言支持

en: The following options are target specific
zh_CN: 下列选项与特定目标机相关

en: The following options control compiler warning messages
zh_CN: 下列选项控制编译器警告信息

en: The following options control optimizations
zh_CN: 下列选项控制优化

en: The following options take joined arguments
zh_CN: 下列选项带联合的参数

en: The following options take separate arguments
zh_CN: 下列选项带分立的参数

en: The minimal probability of speculation success (in percents), so that speculative insn will be scheduled.
zh_CN: 以百分比表示的投机成功的最小概率，影响对投机指令的调度。

en: The value of n in %<-finit-character=n%> must be between 0 and 127
zh_CN: %<-finit-character=n%> 中 n 的值必须在 0 和 127 之间

en: The version of the C++ ABI used for -Wabi warnings and link compatibility aliases.
zh_CN: 用于 -Wabi 警告和链接兼容性别名的 C++ ABI 版本。

en: This is free software; see the source for copying conditions.  There is NO
    warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
zh_CN: 本程序是自由软件；请参看源代码的版权声明。本软件没有任何担保；
    包括没有适销性和某一专用目的下的适用性担保。

en: This is the default.
zh_CN: 这是默认情况。

en: This option lacks documentation.
zh_CN: 此开关缺少文档。

en: This switch is deprecated; use -Werror=implicit-function-declaration instead.
zh_CN: 已弃用此开关；请改用 -Werror=implicit-function-declaration。

en: This switch is deprecated; use -Wextra instead.
zh_CN: 已弃用此开关；请改用 -Wextra。

en: Thread model: %s
zh_CN: 线程模型：%s

en: Threadprivate at %L isn't SAVEd
zh_CN: %L处的线程私有变量未被保存

en: Threadprivate variable at %C is an element of a COMMON block
zh_CN:  %C 处线程局部变量是个 COMMON 块的元素

en: Too many arguments to %s at %L
zh_CN: 给予函数 %s 的参数太多，于 %L

en: Too many digits in statement label at %C
zh_CN: %C处语句标号中数字太多

en: Treat missing header files as generated files.
zh_CN: 将缺失的头文件视为生成的文件。

en: Try running '%s' in the shell to raise its limit.
zh_CN: 尝试在命令解释器中运行‘%s’以提升它的极限。

en: Two main PROGRAMs at %L and %C
zh_CN: %L 和%C处有两个主 PROGRAM

en: Two or more part references with nonzero rank must not be specified at %L
zh_CN: %L处不能指定两个或以上秩不为零的部分引用

en: Type of entity at %L is type incompatible with source-expr at %L
zh_CN: %L处实体的类型与%L处的源表达式类型不兼容

en: Type of entity at %L is type incompatible with typespec
zh_CN: %L处实体类型与 typepec 类型不兼容

en: UNIT not specified at %L
zh_CN: %L没有指定 UNIT

en: UNIT number in CLOSE statement at %L must be non-negative
zh_CN: %L处 CLOSE 语句中的 UNIT 数必须是非负的

en: UNIT number in statement at %L must be non-negative
zh_CN: %L处的语句中 UNIT 数必须为非负的数

en: UNIT specification at %L must be an INTEGER expression or a CHARACTER variable
zh_CN: %L处的 UNIT 规格必须是 INTEGER 表达式或一个 CHARACTER 变量

en: Unable to load DLL.
zh_CN: 无法加载 DLL。

en: Unclassifiable GCC directive at %C
zh_CN: %C处的 GCC 指示无法分类

en: Unclassifiable OpenMP directive at %C
zh_CN: %C处的 OpenMP 指示无法分类

en: Unclassifiable statement at %C
zh_CN: %C语句无法归类

en: Unequal character lengths (%ld/%ld) in %s
zh_CN: %3$s 中字符长度不相等 (%1$ld/%2$ld)

en: Unequal character lengths (%ld/%ld) in %s at %L
zh_CN: %4$L处 %3$s 中字符长度不相等 (%1$ld/%2$ld)

en: Unexpected %s statement at %C
zh_CN: %2$C处有非预期的 %1$s 语句

en: Unexpected %s statement at %C in INTERFACE body
zh_CN: 非预期的 %s 语句出现在%C处的 INTERFACE 体中

en: Unexpected %s statement in BLOCK DATA at %C
zh_CN: 非预期的 %s 语句出现在%C处的 BLOCK DATA 块中

en: Unexpected %s statement in CONTAINS section at %C
zh_CN: 非预期的 %s 语句出现在%C处的 CONTAINS 段中

en: Unexpected %s statement in FORALL block at %C
zh_CN: 非预期的 %s 语句出现在%C处的 FORALL 块中

en: Unexpected %s statement in INTERFACE block at %C
zh_CN: 非预期的 %s 语句出现在%C处的 INTERFACE 块中

en: Unexpected %s statement in MODULE at %C
zh_CN: 非预期的 %s 语句出现在%C处的 MODULE 中

en: Unexpected %s statement in WHERE block at %C
zh_CN: 非预期的 %s 语句出现在%C处的 WHERE 块中

en: Unexpected CASE statement at %C
zh_CN: %C处非预期的 CASE 语句

en: Unexpected END statement at %C
zh_CN: %C处非预期的 END 语句

en: Unexpected EOF
zh_CN: 非预期的文件结束

en: Unexpected TYPE IS statement at %C
zh_CN: %C处非预期的 TYPE IS 语句

en: Unexpected character in variable list at %C
zh_CN: %C处变量列表中有非预期的垃圾字符

en: Unexpected characters in PARAMETER statement at %C
zh_CN: %C处 PARAMETER 语句中有非预期的字符

en: Unexpected end of module
zh_CN: 非预期的模块结束

en: Unexpected junk after function declaration at %C
zh_CN: %C处的函数声明后有非预期的垃圾字符

en: Unexpected junk in formal argument list at %C
zh_CN: %C处形参列表中有非预期的垃圾字符

en: Unit number in I/O statement too large
zh_CN: I/O 语句中单位数太大

en: Unit number in I/O statement too small
zh_CN: I/O 语句中单位数太小

en: Unknown argument list function at %L
zh_CN: %L处参数列表函数未知

en: Unknown attribute in !GCC$ ATTRIBUTES statement at %C
zh_CN: %C处 !GCC$ ATTRIBUTES 语句中有未知的属性

en: Unknown intrinsic op
zh_CN: 未知的内建操作

en: Unsupported statement inside WHERE at %L
zh_CN: %L处在 WHERE 内不支持的语句

en: Unterminated character constant beginning at %C
zh_CN: 开始于 %C 的未终结的字符常量

en: Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d
zh_CN: %1$L处数组上限引用在第 %4$d 维中越界(%2$ld < %3$ld)

en: Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d
zh_CN: %1$L处数组上限引用在第 %4$d 维中越界(%2$ld > %3$ld)

en: Usage: %s [OPTION]... SUB_COMMAND [OPTION]...
zh_CN: 用法：%s [选项]... 子命令 [选项]...

en: Usage: %s [options] file...
zh_CN: 用法：%s [选项] 文件...

en: Usage: gcov [OPTION...] SOURCE|OBJ...
zh_CN: 用法：gconv [选项...] 源文件|对象文件...

en: Use "-Wa,OPTION" to pass "OPTION" to the assembler.
zh_CN: 使用“-Wa,选项”将“选项”传递给汇编器。

en: Use "-Wl,OPTION" to pass "OPTION" to the linker.
zh_CN: 使用“-Wl,选项”将“选项”传递给链接器。

en: Use 128-bit AVX instructions instead of 256-bit AVX instructions in the auto-vectorizer.
zh_CN: 自动向量化时使用 128 位 AVX 指令而不是 256 位 AVX 指令。

en: Use 128-bit long double.
zh_CN: 使用 128 位 long double。

en: Use 16 bit int.
zh_CN: 使用 16 位整型。

en: Use 32 bit int.
zh_CN: 使用 32 位整型。

en: Use 32-bit ABI.
zh_CN: 使用 32 位 ABI。

en: Use 4 byte entries in switch tables.
zh_CN: 在 switch 分支表中使用 4 字节长的条目。

en: Use 64-bit ABI.
zh_CN: 使用 64 位 ABI。

en: Use 64-bit long double.
zh_CN: 使用 64 位 long double。

en: Use 80-bit long double.
zh_CN: 使用 80 位 long double。

en: Use AltiVec instructions.
zh_CN: 使用 AltiVec 指令。

en: Use Bionic C library.
zh_CN: 使用 Bionic C 标准库。

en: Use EABI.
zh_CN: 使用 EABI。

en: Use GNU C library.
zh_CN: 使用 GNU C 标准库。

en: Use H8/300 alignment rules.
zh_CN: 使用 H8/300 对齐规则。

en: Use IEEE math for fp comparisons.
zh_CN: 浮点数间的比较严格遵循 IEEE 标准。

en: Use MIPS-3D instructions.
zh_CN: 使用 MIPS-3D 指令。

en: Use Mingw-specific thread support.
zh_CN: 使用 Mingw 特定的线程支持。

en: Use PowerPC-64 instruction set.
zh_CN: 使用 PowerPC-64 指令集。

en: Use SmartMIPS instructions.
zh_CN: 使用 SmartMIPS 指令。

en: Use Virtualization (VZ) instructions.
zh_CN: 使用虚拟化（VZ）指令。

en: Use an 8-bit 'int' type.
zh_CN: 使用 8 位‘int’类型。

en: Use big-endian byte order.
zh_CN: 令大端在前。

en: Use f2c calling convention.
zh_CN: 使用 f2c 调用约定。

en: Use fp double instructions.
zh_CN: 使用浮点双精度指令。

en: Use given address mode.
zh_CN: 使用给定的地址模式。

en: Use given assembler dialect.
zh_CN: 使用给定的汇编风格。

en: Use given x86-64 code model.
zh_CN: 使用给定的 x86-64 代码模式。

en: Use hardware fp.
zh_CN: 使用硬件浮点单元。

en: Use little-endian byte order.
zh_CN: 令小端在前。

en: Use musl C library.
zh_CN: 使用 musl C 标准库。

en: Use of the NUMERIC_STORAGE_SIZE named constant from intrinsic module ISO_FORTRAN_ENV at %C is incompatible with option %s
zh_CN: %C处在内建模块 ISO_FORTRAN_ENV 中对 NUMERIC_STORAGE_SIZE 命名常数的使用与选项 %s 不兼容

en: Use portable calling conventions.
zh_CN: 使用可移植调用约定。

en: Use registers for argument passing.
zh_CN: 使用寄存器传递参数。

en: Use registers r2 and r5.
zh_CN: 使用寄存器 r2 和 r5。

en: Use shared libraries.
zh_CN: 使用共享库。

en: Use simulator runtime.
zh_CN: 使用仿真器运行时。

en: Use software floating point comparisons.
zh_CN: 使用软件浮点比较。

en: Use software floating point.
zh_CN: 使用软件浮点单元。

en: Use software integer multiplication.
zh_CN: 使用软件整型乘法。

en: Use stubs for function prologues.
zh_CN: 使用占位程序完成函数前言。

en: Use the AltiVec ABI extensions.
zh_CN: 使用 AltiVec ABI 扩展。

en: Use the ELFv1 ABI.
zh_CN: 使用 ELFv1 ABI。

en: Use the ELFv2 ABI.
zh_CN: 使用 ELFv2 ABI。

en: Use the divide instruction.
zh_CN: 使用除法指令。

en: Use the simulator runtime.
zh_CN: 使用仿真器运行时。

en: Use traditional GNU semantics for inline functions.
zh_CN: 为内联函数使用传统的 GNU 语义。

en: Use uClibc C library.
zh_CN: 使用 uClibc C 标准库。

en: Uses of this option are diagnosed.
zh_CN: 对此选项的使用将被诊断。

en: Using built-in specs.
zh_CN: 使用内建 specs。

en: VALUE is not allowed inside of BLOCK at %C
zh_CN: VALUE 不能用在%C处 BLOCK 内

en: VOIDmode on an output
zh_CN: 输出有 VOIDmode

en: Valid arguments to -malign-:
zh_CN: -malign- 的有效参数为：

en: Valid arguments to -mcode-readable=:
zh_CN: -mcode-readable= 的有效参数为：

en: Valid arguments to -mfpmath=:
zh_CN: -fpmath= 的有效参数为：

en: Valid arguments to -mr10k-cache-barrier=:
zh_CN: -m10k-cache-barrier= 的有效参数为：

en: Valid arguments to -mstringop-strategy=:
zh_CN: -mstringop-strategy= 的有效参数为：

en: Valid arguments to -mtp=:
zh_CN: -mtp= 的有效参数为：

en: Variable %s cannot be INTENT(IN) at %C
zh_CN: %2$C处的变量 %1$s 不能是 INTENT(IN)

en: Variable %s cannot be assigned in PURE procedure at %C
zh_CN: 变量 %s 在%C处的 PURE 过程中不能被赋值

en: Variable type is UNKNOWN in assignment at %L
zh_CN: %L处赋值中的变量类型是 UNKNOWN

en: WAIT statement not allowed in PURE procedure at %C
zh_CN: %C处的 PURE 过程中不允许 WAIT 语句

en: WHERE assignment target at %L has inconsistent shape
zh_CN: %L处 WHERE 赋值目标外形不一致

en: WHERE mask at %L has inconsistent shape
zh_CN: %L处的 WHERE 掩码外形不一致

en: WHERE/ELSEWHERE clause at %L requires a LOGICAL array
zh_CN: %L处的 WHERE/ELSEWHERE 子句需要一个 LOGICAL 数组

en: Warn about C constructs that are not in the common subset of C and C++.
zh_CN: 对在 C 语言中使用了 C 与 C++ 交集以外的构造时给出警告。

en: Warn about C++ constructs whose meaning differs between ISO C++ 1998 and ISO C++ 2011.
zh_CN: 当 C++ 构造的意义在 ISO C++ 1998 和 ISO C++ 2011 中不同时给出警告。

en: Warn about C++ constructs whose meaning differs between ISO C++ 2011 and ISO C++ 2014.
zh_CN: 当 C++ 构造的意义在 ISO C++ 2011 和 ISO C++ 2014 中不同时给出警告。

en: Warn about C++ constructs whose meaning differs between ISO C++ 2014 and ISO C++ 2017.
zh_CN: 当 C++ 构造的意义在 ISO C++ 2014 和 ISO C++ 2017 中不同时给出警告。

en: Warn about C++ constructs whose meaning differs between ISO C++ 2017 and ISO C++ 2020.
zh_CN: 当 C++ 构造的意义在 ISO C++ 2017 和 ISO C++ 2020 中不同时给出警告。

en: Warn about C++11 constructs in code compiled with an older standard.
zh_CN: 对使用较旧标准编译的代码给出 C++11 构造的警告。

en: Warn about C++14 constructs in code compiled with an older standard.
zh_CN: 对使用较旧标准编译的代码给出 C++14 构造的警告。

en: Warn about C++17 constructs in code compiled with an older standard.
zh_CN: 对使用较旧标准编译的代码给出 C++17 构造的警告。

en: Warn about C++20 constructs in code compiled with an older standard.
zh_CN: 对使用较旧标准编译的代码给出 C++20 构造的警告。

en: Warn about C++23 constructs in code compiled with an older standard.
zh_CN: 对使用较旧标准编译的代码给出 C++23 构造的警告。

en: Warn about C++26 constructs in code compiled with an older standard.
zh_CN: 对使用较旧标准编译的代码给出 C++26 构造的警告。

en: Warn about __TIME__, __DATE__ and __TIMESTAMP__ usage.
zh_CN: 当 __TIME__、__DATE__ 和 __TIMESTAMP__ 被使用时给出警告。

en: Warn about an invalid DO loop.
zh_CN: 对无效的 DO 循环给出警告。

en: Warn about casts between incompatible function types.
zh_CN: 当把函数转换为不兼容类型时给出警告。

en: Warn about code paths in which a pointer can be freed more than once.
zh_CN: 对指针可以被释放多次的代码路径给出警告。

en: Warn about code paths in which a stdio FILE can be closed more than once.
zh_CN: 对标准输入输出文件（stdio FILE）可以被多次关闭的代码路径进行警告。

en: Warn about code paths in which sensitive data is written to a file.
zh_CN: 对将敏感数据写入文件的代码路径给出警告。

en: Warn about dangling else.
zh_CN: 对悬空的 else 给出警告。

en: Warn about features not present in ISO C90, but present in ISO C99.
zh_CN: 对 ISO C90 中不存在但 ISO C99 中存在的特性给出警告。

en: Warn about features not present in ISO C99, but present in ISO C11.
zh_CN: 对 ISO C99 中不存在但 ISO C11 中存在的特性给出警告。

en: Warn about features not present in traditional C.
zh_CN: 使用了传统 C 不支持的特性时给出警告。

en: Warn about format strings that are not literals.
zh_CN: 当格式字符串不是字面量时给出警告。

en: Warn about function pointer arithmetic.
zh_CN: 当在算术表达式中使用函数指针时给出警告。

en: Warn about implicit conversions from "float" to "double".
zh_CN: 对从“float”到“double”的隐式转换给出警告。

en: Warn about implicit declarations.
zh_CN: 对隐式函数声明给出警告。

en: Warn about implicit function declarations.
zh_CN: 对隐式函数声明给出警告。

en: Warn about invalid UTF-8 characters.
zh_CN: 对无效 UTF-8 字符给出警告。

en: Warn about misuses of pragmas.
zh_CN: 对错误使用的 pragma 给出警告。

en: Warn about most implicit conversions.
zh_CN: 对大多数隐式类型转换给出警告。

en: Warn about multiple declarations of the same object.
zh_CN: 对同一个对象多次声明时给出警告。

en: Warn about redundant calls to std::move.
zh_CN: 对多余的 std::move 调用给出警告。

en: Warn about suspicious OpenMP code.
zh_CN: 对可疑的 OpenMP 代码给出警告。

en: Warn about suspicious declarations of "main".
zh_CN: 对可疑的“main”声明给出警告。

en: Warn about truncated character expressions.
zh_CN: 对被截断的字符表达式给出警告。

en: Warn about unrecognized pragmas.
zh_CN: 对无法识别的 pragma 加以警告。

en: Warn about unused dummy arguments.
zh_CN: 对未使用的哑元给出警告。

en: Warn about useless casts.
zh_CN: 对无用的类型转换给出警告。

en: Warn about variables which are initialized to themselves.
zh_CN: 对初始化为自身的变量给出警告。

en: Warn about zero-length formats.
zh_CN: 对长度为 0 的格式字符串给出警告。

en: Warn for infinitely recursive calls.
zh_CN: 为无限递归调用给出警告。

en: Warn for missing parameter types in function declarations.
zh_CN: 当函数生命中缺失参数类型时给出警告。

en: Warn if "defined" is used outside #if.
zh_CN: 当 "defined" 在 #if 之外使用时给出警告。

en: Warn if a C-style cast is used in a program.
zh_CN: 程序使用 C 风格的类型转换时给出警告。

en: Warn if a variable length array is used.
zh_CN: 使用变长数组时给出警告。

en: Warn if loops have been interchanged.
zh_CN: 当循环被互换时给出警告。

en: Warn if the type of a variable might be not interoperable with C.
zh_CN: 对可能不与C语言互通的类型给出警告。

en: Warn that -fno-automatic may break recursion.
zh_CN: 当 -fno-automatic 可能破坏递归时给警告。

en: Warn when __builtin_frame_address or __builtin_return_address is used unsafely.
zh_CN: 当 __builtin_frame_address 或 __builtin_return_address 被不安全地使用时给出警告。

en: Warn when a built-in function is declared with the wrong signature.
zh_CN: 当内奸函数使用了错误的签名被声明时给出警告。

en: Warn when a built-in preprocessor macro is undefined or redefined.
zh_CN: 当内建预处理宏未定义或重定义时给出警告。

en: Warn when a const variable is unused.
zh_CN: 有未使用的常变量时警告。

en: Warn when a declaration is found after a statement.
zh_CN: 当声明出现在语句后时给出警告。

en: Warn when a literal '0' is used as null pointer.
zh_CN: 在字面“0”被用作空指针时给出警告。

en: Warn when a pointer is cast to an integer of a different size.
zh_CN: 将一个指针转换为大小不同的整数时给出警告。

en: Warn when deleting a pointer to incomplete type.
zh_CN: 在删除不兼容类型的指针时给出警告。

en: Warn whenever type qualifiers are ignored.
zh_CN: 当类型限定符被忽略时给出警告。

en: Warning
zh_CN: 警告

en: While setting up signal handler: %m
zh_CN: 当设置信号处理者时：%m

en: While setting up signal stack: %m
zh_CN: 当设定信号栈时：%m

en: Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape
zh_CN: 若没有填充，%L处内建 ESHAPE 源中没有足够的元素去与外形匹配

en: You need a C startup file for -msys-crt0=
zh_CN: -msys-crt0 需要指定C语言启动文件

en: Zero is not a valid statement label at %C
zh_CN: 零不是%C处的一个有效的语句标号

en: [Leaving %s]
zh_CN: [离开 %s]

en: [cannot find %s]
zh_CN: [找不到 %s]

en: [default]
zh_CN: [默认]

en: [disabled]
zh_CN: [禁用]

en: [enabled]
zh_CN: [启用]

en: `
zh_CN: ‘

en: a cast to a type other than an integral or enumeration type cannot appear in a constant-expression
zh_CN: 常量表达式中不能出现目标不是整型或枚举型的类型转换

en: a function call cannot appear in a constant-expression
zh_CN: 函数调用不能出现在常量表达式中

en: a label can only be part of a statement and a declaration is not a statement
zh_CN: 标号只能是语句的一部分，而声明并非语句

en: a member of a structure or union cannot have a variably modified type
zh_CN: 结构或联合成员不能具有可变类型

en: a storage class can only be specified for objects and functions
zh_CN: 只能为对象和函数指定存储类

en: a template-id may not appear in a using-declaration
zh_CN: 模板标识符不允许出现在 using 声明中

en: a wide string is invalid in this context
zh_CN: 此上下文中宽字符串无效

en: abnormal edges for no purpose in bb %i
zh_CN: 在基本块 %i 中无用途的反常边

en: abort in %s, at %s:%d
zh_CN: 在 %s 中放弃，于 %s:%d

en: abstract declarator %qT used as declaration
zh_CN: 抽象声明%qT被用作声明

en: accessing data memory with program memory address
zh_CN: 用程序内存地址访问数据内存

en: accumulator is not a constant integer
zh_CN: 累加数不是一个整常量

en: accumulator number is out of bounds
zh_CN: 累加器个数越界

en: address area attribute cannot be specified for functions
zh_CN: 不能为函数指定地址区域属性

en: address area of %q+D conflicts with previous declaration
zh_CN: %q+D的数据区域与先前的声明冲突

en: address of explicit register variable %qD requested
zh_CN: 要求显式寄存器变量%qD的地址。

en: address of global register variable %qD requested
zh_CN: 要求全局寄存器变量%qD的地址

en: address of overloaded function with no contextual type information
zh_CN: 访问没有上下文类型信息的重载函数的地址

en: address of register variable %qD requested
zh_CN: 要求寄存器变量 %qD 的地址

en: address offset not a constant
zh_CN: 地址偏移量不是一个常量

en: address operand requires constraint for X, Y, or Z register
zh_CN: 地址操作数需要 X、Y 或 Z 寄存器约束

en: address requested for %qD, which is declared %<register%>
zh_CN: 请求声明为%<register%>的%qD的地址

en: address taken, but ADDRESSABLE bit not set
zh_CN: 已取地址，但是 ADDRESSABLE 位未被设置

en: aggregate %q#D has incomplete type and cannot be defined
zh_CN: 聚合%q#D类型不完全，无法被定义

en: aggregate value used where a complex was expected
zh_CN: 需要复数时使用了聚合值

en: aggregate value used where a fixed-point was expected
zh_CN: 需要定点数时使用了聚合值

en: aggregate value used where an integer was expected
zh_CN: 需要整数时使用了聚合值

en: aka
zh_CN: 或称

en: alias definitions not supported in Mach-O; ignored
zh_CN: 重叠定义在 Mach-O 中不受支持；已忽略

en: alias definitions not supported in this configuration
zh_CN: 别名定义在此配置下不受支持

en: alignment may not be specified for %q+D
zh_CN: 不能为%q+D指定对齐

en: alignment must be a small power of two, not %d
zh_CN: 对齐边界必须是 2 的较小次方，而不是 %d

en: alignment of %qD is bigger than original declaration
zh_CN: %qD的对齐

en: alignment of array elements is greater than element size
zh_CN: 数组元素的对齐边界比元素大小还要大

en: all member functions in class %qT are private
zh_CN: 类%qT中所有成员函数都是私有的

en: also found %<%c%s%>
zh_CN: 也找到了%<%c%s%>

en: ambiguous conversion for array subscript
zh_CN: 为数组下标的转换有歧义

en: ambiguous default type conversion from %qT
zh_CN: %qT的默认类型转换有歧义

en: ambiguous method %s%s%s
zh_CN: 有歧义的方法%s%s%s

en: ambiguous template specialization %qD for %q+D
zh_CN: 有歧义的模板特例化%qD(为%q+D)

en: an address area attribute cannot be specified for local variables
zh_CN: 不能为局部变量指定地址区域属性

en: an decrement cannot appear in a constant-expression
zh_CN: 自减不能出现在常量表达式中

en: an explicit specialization must be preceded by %<template <>%>
zh_CN: 显式特例化前必须有%<template <>%>

en: an increment cannot appear in a constant-expression
zh_CN: 自增不能出现在常量表达式中

en: anachronism
zh_CN: 历史遗留

en: anachronism:
zh_CN: 历史遗留：

en: anachronistic old-style base class initializer
zh_CN: 年代错误的旧式基类初始值设定

en: and %qT has no template constructors
zh_CN: 且%qT没有模板构造函数

en: anonymous struct not inside named type
zh_CN: 匿名结构不在有名类型内

en: anonymous union with no members
zh_CN: 匿名联合没有成员

en: argument %d of %qE might be a candidate for a format attribute
zh_CN: %2$qE的第 %1$d 个实参可能是 format 属性的备选

en: argument %q+D might be clobbered by %<longjmp%> or %<vfork%>
zh_CN: 实参%q+D可能为%<longjmp%>或%<vfork%>所篡改

en: argument %qD doesn%'t match built-in prototype
zh_CN: 实参%qD与内建原型不符

en: argument %qD doesn%'t match prototype
zh_CN: 实参%qD与原型不符

en: argument %qd is not a constant
zh_CN: 实参%qd不是一个常数

en: argument %qs to %<-Wnormalized%> not recognized
zh_CN: 实参%qs(给予%<-Wnormalized%>)无法识别

en: argument %qs to %<-femit-struct-debug-detailed%> not recognized
zh_CN: %<-femit-struct-debug-detailed%>的参数%qs不可识别

en: argument %qs to %<-femit-struct-debug-detailed%> unknown
zh_CN: %<-femit-struct-debug-detailed%>的参数%qs未知

en: argument list function at %C
zh_CN: %C 处的参数列表函数

en: argument must be channel
zh_CN: 实参必须是通道

en: argument must have complex type
zh_CN: 实参必须具有复数类型

en: argument of %<__builtin_eh_return_regno%> must be constant
zh_CN: %<__builtin_eh_return_regno%>的实参必须是常量

en: argument of %qE attribute is not "ilink1" or "ilink2"
zh_CN: %qE属性的实参不是“ilink1”或“ilink2”

en: argument of %qE attribute is not a string constant
zh_CN: %qE属性的实参不是一个字符串常量

en: argument of function call might be a candidate for a format attribute
zh_CN: 函数的实参可能是 format 属性的备选

en: argument to %qE attribute larger than %d
zh_CN: %qE属性的实参大于 %d

en: arguments '%s' and '%s' for intrinsic %s
zh_CN: ‘%s’和‘%s’用作内建函数‘%s’的参数

en: arguments '%s' and '%s' for intrinsic '%s'
zh_CN: ‘%s’和‘%s’用作内建函数‘%s’的参数

en: arguments 'a%d' and 'a%d' for intrinsic '%s'
zh_CN: ‘a%d’和‘a%d’用作内建函数‘%s’的参数

en: arguments to destructor are not allowed
zh_CN: 析构函数不能有参数

en: arithmetic IF
zh_CN: 算术 IF

en: arithmetic on pointer to an incomplete type
zh_CN: 在指向不完全类型的指针上执行算术运算

en: array %q+D assumed to have one element
zh_CN: 假定数组%q+D有一个元素

en: array %qD initialized by parenthesized string literal %qE
zh_CN: 数组%qD被有括号的字面字符串%qE所初始化

en: array assignment
zh_CN: 数组赋值

en: array bound forbidden after parenthesized type-id
zh_CN: 括起的类型标识符后面不能出现数组边界

en: array bound is not an integer constant
zh_CN: 数组边界不是一个整数常量

en: array index in initializer exceeds array bounds
zh_CN: 初始化时数组索引越界

en: array index in initializer is not an integer constant expression
zh_CN: 初始值设定中数组索引不是整型常量表达式

en: array index in initializer not of integer type
zh_CN: 初始值设定中数组索引不是整型

en: array index in non-array initializer
zh_CN: 在非数组初始值设定项中出现数组索引

en: array index range in initializer exceeds array bounds
zh_CN: 初始值设定中数据索引范围超出数组边界

en: array initialized from non-constant array expression
zh_CN: 用非常量的数组表达式初始化数组

en: array initialized from parenthesized string constant
zh_CN: 用括号中的字符串常量初始化数组

en: array must be initialized with a brace-enclosed initializer
zh_CN: 数组必须为一个由花括号包围的初始值设定所初始化

en: array of inappropriate type initialized from string constant
zh_CN: 用字符串常量初始化的数组类型不合适

en: array result
zh_CN: 数组结果

en: array size missing in %q+D
zh_CN: 在%q+D中缺少数组大小

en: array size missing in %qD
zh_CN: %qD缺少数组大小

en: array subscript has type %<char%>
zh_CN: 数组下标类型为%<char%>

en: array subscript is not an integer
zh_CN: 数组下标不是一个整数

en: array used as initializer
zh_CN: 数组被用作初始值设定

en: arrays of functions are not meaningful
zh_CN: 函数数组是没有意义的

en: assertion missing after %qs
zh_CN: %qs后断言

en: assignment
zh_CN: 赋值

en: assignment (not initialization) in declaration
zh_CN: 赋值(不是初始化)出现在声明中

en: assignment from distinct Objective-C type
zh_CN: 从独一无二的 Objective-C 类型赋值

en: assignment from pointer to non-enclosed address space
zh_CN: 将指针赋值给未被包围的地址空间

en: assignment left-hand side might be a candidate for a format attribute
zh_CN: 赋值的左手边可能是 format 属性的备选时

en: assignment of constant field %qD
zh_CN: 向只读字段%qD赋值

en: assignment of function %qD
zh_CN: 向函数%qD赋值

en: assignment of read-only location %qE
zh_CN: 向只读位置%qE赋值

en: assignment of read-only member %qD
zh_CN: 向只读成员%qD赋值

en: assignment of read-only named return value %qD
zh_CN: 向有名只读返回值%qD赋值

en: assignment of read-only parameter %qD
zh_CN: 向只读形参%qD赋值

en: assignment of read-only reference %qD
zh_CN: 向只读形参%qD赋值

en: assignment of read-only variable %qD
zh_CN: 向只读变量%qD赋值

en: assignment suppression
zh_CN: 取消赋值

en: assuming cast to type %qT from overloaded function
zh_CN: 假定从重载函数转换到类型%qT

en: assuming pointer to member %qD
zh_CN: 假定是成员指针%qD

en: assuming signed overflow does not occur when combining constants around a comparison
zh_CN: 在比较周围组合变量时假定有符号数从不溢出

en: assuming signed overflow does not occur when reducing constant in comparison
zh_CN: 在比较中归约常量时假定有符号数从不溢出

en: assuming signed overflow does not occur when simplifying range test
zh_CN: 简化范围检查时假定有符号数从不溢出

en: atexit failed
zh_CN: atexit 失败

en: attempt to take address of bit-field structure member %qD
zh_CN: 试图取位段结构成员%qD的地址

en: attribute %qs applies to array types only
zh_CN: %qs属性只能为数组类型使用

en: attribute declaration
zh_CN: 属性声明

en: attributes after parenthesized initializer ignored
zh_CN: 括起的初始值设定后出现的属性被忽略

en: attributes are not allowed on a function-definition
zh_CN: 函数定义中不允许有属性

en: attributes ignored on elaborated-type-specifier that is not a forward declaration
zh_CN: 类型在非前向声明的详尽类型限定符中被忽略

en: attributes ignored on template instantiation
zh_CN: 属性在模板实例化上被忽略

en: attributes ignored on uninstantiated type
zh_CN: 属性在未初始化类型上被忽略

en: attributes in parameter array declarator ignored
zh_CN: 出现在形参数组声明中的属性被忽略

en: automatic variable %qE cannot be %<threadprivate%>
zh_CN: 自动变量%qE不能是%<threadprivate%>

en: aux field set for edge %s->%s
zh_CN: 为边 %s->%s 设定辅助域

en: bad address
zh_CN: 错误地址

en: bad address, not (reg+disp):
zh_CN: 地址错误，不是(reg+disp)：

en: bad address, not post_inc or pre_dec:
zh_CN: 错误的地址，不是 post_inc 或 pre_dec：

en: bad amount of stack space removal: %d
zh_CN: 堆栈空间移除量错误：%d

en: bad builtin code
zh_CN: 错误的内建代码

en: bad builtin fcode
zh_CN: 错误的内建 fcode

en: bad condition code
zh_CN: 错误的条件码

en: bad expression type during walk (%d)
zh_CN: 走过错误的表达式类型(%d)

en: bad insn for 'A'
zh_CN: ‘A’的指令错误

en: bad insn in frv_print_operand, 0 case
zh_CN: frv_print_operand 中有错误指令，0 case

en: bad insn in frv_print_operand, bad const_double
zh_CN: frv_print_operand 中有错误指令，错误的 const_double

en: bad insn in frv_print_operand, z case
zh_CN: frv_print_operand 中有错误指令，z case

en: bad insn to frv_print_operand, 'F' modifier:
zh_CN: 给 frv_print_operand 错误的指令，‘F’修饰符：

en: bad insn to frv_print_operand, 'L' modifier:
zh_CN: 给 frv_print_operand 错误的指令，‘L’修饰符：

en: bad insn to frv_print_operand, 'M/N' modifier:
zh_CN: 给 frv_print_operand 错误的指令，‘M/N’修饰符：

en: bad insn to frv_print_operand, 'O' modifier:
zh_CN: 给 frv_print_operand 错误的指令，‘O’修饰符：

en: bad insn to frv_print_operand, 'e' modifier:
zh_CN: 给 frv_print_operand 错误的指令，‘e’修饰符：

en: bad insn to frv_print_operand, 'f' modifier:
zh_CN: 给 frv_print_operand 错误的指令，‘f’修饰符：

en: bad insn to frv_print_operand, 'g' modifier:
zh_CN: 给 frv_print_operand 错误的指令，‘g’修饰符：

en: bad insn to frv_print_operand, P modifier:
zh_CN: 给 frv_print_operand 错误的指令，P 修饰符：

en: bad insn to frv_print_operand_address:
zh_CN: 给 frv_print_operand_address 错误的指令：

en: bad insn to frv_print_operand_memory_reference:
zh_CN: 给 frv_print_operand_memory_reference 错误的指令：

en: bad move
zh_CN: 错误的移动

en: bad operand
zh_CN: 错误的操作数

en: bad output_condmove_single operand
zh_CN: 错误的 output_condmove_single 操作数

en: bad output_move_double operand
zh_CN: 错误的 output_move_double 操作数

en: bad output_move_single operand
zh_CN: 错误的 output_move_single 操作数

en: bad register
zh_CN: 错误的寄存器名

en: bad register to frv_print_operand_memory_reference_reg:
zh_CN: 给 frv_print_operand_memory_reference_reg 错误的寄存器：

en: bad test
zh_CN: 错误的测试

en: badly nested C headers from preprocessor
zh_CN: 预处理器生成的嵌套 C 头 错误

en: base %qT will be initialized after
zh_CN: 基类%qT将在

en: base class %q#T should be explicitly initialized in the copy constructor
zh_CN: 基类%q#T应该在复制构造函数中显式地初始化

en: base operand of %<->%> has non-pointer type %qT
zh_CN: %<->%>的基操作数具有非指针类型%qT

en: base operand of %<->%> is not a pointer
zh_CN: %<->%>的左操作数不是一个指针

en: base type %qT fails to be a struct or class type
zh_CN: 基类型%qT不是结构或类

en: basic block %d pred edge is corrupted
zh_CN: 基本块 %d 的前驱边已损坏

en: basic block %d should be marked irreducible
zh_CN: 基本块 %d 应被标记为不可归约的

en: basic block %d should not be marked irreducible
zh_CN: 基本块 %d 不应被标记为不可归约的

en: basic block %i edge lists are corrupted
zh_CN: 基本块 %i 的边列表已损坏

en: basic blocks not laid down consecutively
zh_CN: 基本块不连贯

en: bb %d on wrong place
zh_CN: 基本块 %d 位置不对

en: bit-field %q+D width not an integer constant
zh_CN: 位段%q+D的宽度不是一个整数常量

en: bit-field %qs has invalid type
zh_CN: 位段%qs类型无效

en: bit-field %qs width not an integer constant
zh_CN: 位段%qs的宽度不是一个整数常量

en: bit-field %qs width not an integer constant expression
zh_CN: 位段%qs的宽度不是一个整数常量表达式

en: block IF
zh_CN: 块 IF

en: bogus DISPOSE construction: %d
zh_CN: 误判的 DISPOSE 构造：%d

en: bogus JR construction: %d
zh_CN: 误判的 JR 构造：%d

en: bogus PREPEARE construction: %d
zh_CN: 误判的 PREPEARE 构造：%d

en: boolean registers required for the floating-point option
zh_CN: 浮点选项需要布尔寄存器

en: both arguments to %<__builtin___clear_cache%> must be pointers
zh_CN: %<__builtin___clear_cache%>的两个参数必须都是指针

en: braced-group within expression allowed only inside a function
zh_CN: 表达式中的花括号组只允许出现在函数中

en: braces around scalar initializer
zh_CN: 标量初始化带花括号

en: braces around scalar initializer for type %qT
zh_CN: 类型%qT的标量初始化带花括号

en: break statement not within loop or switch
zh_CN: break 语句不在循环或开关语句内

en: break statement used with OpenMP for loop
zh_CN: OpenMP for 循环中使用了 break 语句

en: built-in function %q+D declared as non-function
zh_CN: 内建函数%q+D未被声明为函数

en: built-in function %qD takes one argument only
zh_CN: 内建函数%qD只需要一个实参

en: built-in function %qE not supported for MIPS16
zh_CN: MIPS16 不支持内建函数%qE

en: builtin %qF is deprecated
zh_CN: 内建的 %qF 已被弃用

en: but not here
zh_CN: 但不是这里

en: bytecode stream: expected tag %s instead of %s
zh_CN: 字节码流：需要标记 %s 而非 %s

en: bytecode stream: found empty cgraph node
zh_CN: 字节码流：找到空的 cgraph 节点

en: bytecode stream: found non-null terminated string
zh_CN: 字节码流：找到非 NULL 结尾的字符串

en: bytecode stream: garbage at the end of symbols section
zh_CN: 字节码流：符号节结尾有垃圾字符

en: bytecode stream: no callee found while reading edge
zh_CN: 字节码流：读取边时找不到被调用者

en: bytecode stream: no caller found while reading edge
zh_CN: 字节码流：读取边时找不到调用者

en: bytecode stream: string too long for the string table
zh_CN: 字节码流：字符串对字符串表而言太长

en: bytecode stream: tag %s is not in the expected range [%s, %s]
zh_CN: 字节码流：标记 %s 不在预期的范围[%s，%s]内

en: bytecode stream: trying to read %d bytes after the end of the input buffer
zh_CN: 字节码流：试图在输入缓冲区结束处读取 %d 字节

en: bytecode stream: unexpected LTO section %s
zh_CN: 字节码流：非预期的 LTO 节 %s

en: bytecode stream: unexpected tag %s
zh_CN: 字节码流：非预期的标记 %s

en: bytecode stream: unknown GIMPLE statement tag %s
zh_CN: 字节码流：未知的 GIMPLE 语句标记 %s

en: call   %2d never executed
zh_CN: call   %2d 从未被执行

en: call   %2d returned %s
zh_CN: call   %2d 返回了 %s

en: call has circular dependency
zh_CN: 调用存在循环依赖

en: call is considered never executed and code size would grow
zh_CN: 调用将被视为永远不会被执行且会导致代码膨胀

en: call is unlikely and code size would grow
zh_CN: 调用不太可能且会导致代码膨胀

en: call of %<(%T) (%A)%> is ambiguous
zh_CN: 对%<(%T) (%A)%>的调用有歧义

en: call of overloaded %<%D(%A)%> is ambiguous
zh_CN: 调用重载的%<%D(%A)%>有歧义

en: call of overloaded %<%s(%A)%> is ambiguous
zh_CN: 对重载的%<%s(%A)%>的调用有歧义

en: call to function %qD which throws incomplete type %q#T
zh_CN: 调用的函数%qD会抛出不完全的类型%q#T

en: call to function which throws incomplete type %q#T
zh_CN: 调用的函数会抛出不完全的类型%q#T

en: call to non-function %qD
zh_CN: 调用非函数的%qD

en: call-clobbered register used for global register variable
zh_CN: 调用篡改寄存器用作全局寄存器变量

en: called from here
zh_CN: 从此处调用

en: callee refers to comdat-local symbols
zh_CN: 被调用者是指 comdat 本地符号

en: caller is not optimized
zh_CN: 调用方未被优化

en: calling %qD with attribute sseregparm without SSE/SSE2 enabled
zh_CN: 带属性 sseregparm 调用%qD却没有启用 SSE/SSE2

en: calling %qT with attribute sseregparm without SSE/SSE2 enabled
zh_CN: 带属性 sseregparm 调用%qT却没有启用 SSE/SSE2

en: can only use %qE attribute on file-scope definitions of objects of class type
zh_CN: 只能将%qE属性用于某个类的对象的文件作用域定义

en: can't use non gp relative absolute address
zh_CN: 不能使用非 GP 相对的绝对地址

en: candidate 1:
zh_CN: 备选 1：

en: candidate 2:
zh_CN: 备选 2：

en: candidate is: | candidates are:
zh_CN[0]: 备选是：

en: candidate:
zh_CN: 备选：

en: candidates are:
zh_CN: 备选为：

en: cannot allocate an object of abstract type %qT
zh_CN: 无法为有抽象类型%qT的对象分配内存

en: cannot apply %<offsetof%> to a non constant address
zh_CN: 不能为非常量地址应用%<offsetof%>

en: cannot apply %<offsetof%> to destructor %<~%T%>
zh_CN: 不能为析构函数%<~%T%>使用%<offsetof%>

en: cannot apply %<offsetof%> to member function %qD
zh_CN: 不能为成员函数%qD应用%<offsetof%>

en: cannot apply %<offsetof%> to static data member %qD
zh_CN: 不能对静态数据成员%qD取%<offsetof%>

en: cannot apply %<offsetof%> when %<operator[]%> is overloaded
zh_CN: %<operator[]%>重载后便不能使用%<offsetof%>

en: cannot apply member pointer %qE to %qE, which is of non-class type %qT
zh_CN: 无法将成员指针%qE应用到%qE上，因为后者的类型%qT不是一个类

en: cannot bind packed field %qE to %qT
zh_CN: 不能将紧实的字段%qE绑定到%qT

en: cannot bind rvalue %qE to %qT
zh_CN: 无法将右值%qE绑定到%qT

en: cannot call constructor %<%T::%D%> directly
zh_CN: 不能直接调用构造函数%<%T::%D%>

en: cannot call member function %qD without object
zh_CN: 没有对象无法调用成员函数%qD

en: cannot capture %qE by reference
zh_CN: 无法通过引用捕获%qE

en: cannot convert %qE from type %qT to type %qT
zh_CN: 无法将%qE从类型%qT转换到类型%qT

en: cannot convert to a pointer type
zh_CN: 无法转换为指针类型

en: cannot create pointer to reference member %qD
zh_CN: 不能创建指向引用成员%qD的指针

en: cannot create type information for type %qT because it involves types of variable size
zh_CN: 无法为类型%qT创建类型信息，因为它的大小是可变的

en: cannot declare %<::main%> to be a template
zh_CN: 不能将%<::main%>声明为一个模板

en: cannot declare %<::main%> to be inline
zh_CN: 不能将%<::main%>声明为 inline

en: cannot declare %<::main%> to be static
zh_CN: 不能将%<::main%>声明为 static

en: cannot declare %qD to be a bit-field type
zh_CN: 不能将%qD声明为位段类型

en: cannot declare bit-field %qD with function type
zh_CN: 不能将位段%qD声明为函数类型

en: cannot declare field %q+D to be of abstract type %qT
zh_CN: 不能将字段%q+D声明为具有抽象类型%qT

en: cannot declare member %<%T::%s%> within %qT
zh_CN: 无法声明成员%<%T::%s%>，在%qT中

en: cannot declare member function %qD to have static linkage
zh_CN: 不能将成员函数%qD声明为有静态链接

en: cannot declare parameter %q+D to be of abstract type %qT
zh_CN: 不能将形参%q+D声明为具有抽象类型%qT

en: cannot declare pointer to %q#T
zh_CN: 无法声明指向%q#T的指针

en: cannot declare pointer to %q#T member
zh_CN: 无法声明指向%q#T成员的指针

en: cannot declare pointer to qualified function type %qT
zh_CN: 不能声明指向限定函数类型%qT的指针

en: cannot declare reference to %q#T
zh_CN: 无法声明对%q#T的引用

en: cannot declare reference to %q#T, which is not a typedef or a template type argument
zh_CN: 无法声明对%q#T的引用，因为它不是 typedef 或者模板类型实参

en: cannot declare reference to qualified function type %qT
zh_CN: 不能声明指向限定函数类型%qT的引用

en: cannot declare static function inside another function
zh_CN: 不能在另一个函数中声明一个静态函数

en: cannot declare variable %q+D to be of abstract type %qT
zh_CN: 不能将变量%q+D声明为具有抽象类型%qT

en: cannot decompose address
zh_CN: 无法分解地址

en: cannot decrement a pointer to incomplete type %qT
zh_CN: 指向不完全类型%qT的指针不能自减

en: cannot define member of dependent typedef %qT
zh_CN: 生成引用类型%qT的成员指针

en: cannot delete a function.  Only pointer-to-objects are valid arguments to %<delete%>
zh_CN: 不能 delete 一个函数。只有指向对象的指针才是%<delete%>的有效参数

en: cannot disable built-in function %qs
zh_CN: 无法禁用内建函数%qs

en: cannot explicitly declare member %q#D to have extern linkage
zh_CN: 不能显式地将成员%q#D声明为有外部链接

en: cannot find %<ldd%>
zh_CN: 找不到 %<ldd%>

en: cannot find %<nm%>
zh_CN: 找不到 %<nm%>

en: cannot find %s in plugin %s
    %s
zh_CN: 在插件 %2$s 中找不到 %1$s
    %3$s

en: cannot find class %qE
zh_CN: 找不到类%qE

en: cannot find interface declaration for %qE
zh_CN: 找不到%qE的接口声明

en: cannot find interface declaration for %qE, superclass of %qE
zh_CN: 找不到%2$qE超类%1$qE的接口声明

en: cannot find protocol declaration for %qE
zh_CN: 找不到%qE的协议声明

en: cannot find reference tag for class %qE
zh_CN: 找不到类%qE的引用标记

en: cannot get program status: %m
zh_CN: 无法获取程序状态：%m

en: cannot handle inconsistent calls to %qs
zh_CN: 无法处理对%qs不一致的调用

en: cannot increment a pointer to incomplete type %qT
zh_CN: 指向不完全类型%qT的指针不能自增

en: cannot initialize aggregate of type %qT with a compound literal
zh_CN: 无法用复合字面常量初始化类型为%qT的聚集

en: cannot inline function %<main%>
zh_CN: 不能内联%<main%>函数

en: cannot load plugin %s
    %s
zh_CN: 无法加载插件 %s
    %s

en: cannot open %s
zh_CN: 不能打开 %s

en: cannot open %s: %m
zh_CN: 无法打开 %s：%m

en: cannot open '%s'
zh_CN: 无法打开“%s”

en: cannot open nm output: %m
zh_CN: 无法打开 nm 输出：%m

en: cannot put object with volatile field into register
zh_CN: 不能将带有 volatile 字段的对象放入寄存器

en: cannot reload integer constant operand in %<asm%>
zh_CN: 不能在%<asm%>中重新加载整数常量操作数

en: cannot resolve overloaded function %qD based on conversion to type %qT
zh_CN: 无法解析重载函数%qD，基于向类型%qT的转换

en: cannot return from a handler of a function-try-block of a constructor
zh_CN: 不能从构造函数的异常处理中返回

en: cannot set interrupt attribute: no current function
zh_CN: 无法设定中断属性：没有当前函数

en: cannot set interrupt attribute: no such identifier
zh_CN: 无法设定中断属性：没有这个标识符

en: cannot specify %<override%> for a class
zh_CN: 不能为类指定 %<override%>

en: cannot specify -static with -fsanitize=address
zh_CN: 不能同时指定 -static 和 -fsanitize=address

en: cannot specify -static with -fsanitize=hwaddress
zh_CN: 不能同时指定 -static 和 -fsanitize=hwaddress

en: cannot specify -static with -fsanitize=thread
zh_CN: 不能同时指定 -static 及 -fsanitize=thread

en: cannot tail-call: %s
zh_CN: 无法尾调用：%s

en: cannot take address of bit-field %qD
zh_CN: 无法取得位段%qD的地址

en: cannot take the address of %<this%>, which is an rvalue expression
zh_CN: 无法取右值表达式%<this%>的地址

en: cannot use %<::%> in parameter declaration
zh_CN: 不能在参数声明中使用%<::%>

en: cannot use mshared and static together
zh_CN: 不能同时使用 mshared 和 static

en: cannot use mthreads and mlegacy-threads together
zh_CN: 不能同时使用 mthreads 和 mlegacy-threads

en: cannot use small-data accesses for %qs
zh_CN: 不能为%qs使用小数据访问

en: cannot use type %s as type %s
zh_CN: 不能将类型 %s 用作 %s

en: case label %qE not within a switch statement
zh_CN: case 标号%qE未出现在 switch 语句中

en: case label does not reduce to an integer constant
zh_CN: case 标号不能还原为一个整常量

en: case label is not an integer constant expression
zh_CN: case 标号不是一个整数常量表达式

en: case label not within a switch statement
zh_CN: case 标号出现在开关语句外

en: case label value exceeds maximum value for type
zh_CN: case 标号值比该类型的最大值还要大

en: case label value is less than minimum value for type
zh_CN: case 标号值比该类型的最小值还要小

en: case labels not sorted:
zh_CN: case 标号未排序：

en: case value %qs not in enumerated type
zh_CN: case 值%qs不在枚举类型内

en: case value %qs not in enumerated type %qT
zh_CN: case 值%qs不在枚举类型%qT内

en: cast from function call of type %qT to non-matching type %qT
zh_CN: 从类型为%qT的函数调用转换到不匹配的类型%qT

en: cast from pointer to integer of different size
zh_CN: 将一个指针转换为大小不同的整数

en: cast from type %qT to type %qT casts away qualifiers
zh_CN: 从类型%qT到类型%qT的类型转换丢失了限定符

en: cast increases required alignment of target type
zh_CN: 类型转换增大了目标类型的对齐需求

en: cast specifies array type
zh_CN: 类型转换指定了数组类型

en: cast specifies function type
zh_CN: 类型转换指定了函数类型

en: cast to pointer from integer of different size
zh_CN: 将一个整数转换为大小不同的指针

en: cast to union type from type not present in union
zh_CN: 类型转换的源类型未出现在联合中

en: casting %qT to %qT does not dereference pointer
zh_CN: 从%qT转换到%qT并未提领指针

en: cdecl and thiscall attributes are not compatible
zh_CN: cdecl 和 thiscall 属性互不兼容

en: check_dimension(): Bad array reference
zh_CN: check_dimension()：不当的数组引用

en: choosing %qD over %qD
zh_CN: 选择%qD而不是%qD

en: circular pointer delegation detected
zh_CN: 检测到循环指针代理

en: class %qE already exists
zh_CN: 类%qE已存在

en: class %qE is deprecated
zh_CN: 已弃用类 %qE

en: class %qE is not available
zh_CN: 类 %qE 不可用

en: class %qE is unavailable
zh_CN: 类 %qE 不可用

en: class %qT does not have any field named %qD
zh_CN: 类%qT没有名为%qD的字段

en: class %qT is implicitly friends with itself
zh_CN: 类%qT隐式地成为其自身的友元

en: class %qs does not implement the %qE protocol
zh_CN: 类%qs没有实现%qE协议

en: class definition may not be declared a friend
zh_CN: 类定义不能被声明为友元

en: cleanup argument not a function
zh_CN: cleanup 实参不是一个函数

en: cleanup argument not an identifier
zh_CN: cleanup 实参不是一个标识符

en: close: %s
zh_CN: close：%s

en: closing LTRANS output list %s: %m
zh_CN: 关闭 LTRANS 输出列表 %s：%m

en: closing dependency file %s: %m
zh_CN: 关闭依赖文件 %s：%m

en: code model %qs not supported in the %s bit mode
zh_CN: 代码模式%qs在 %s 位模式下不受支持

en: code model %s does not support PIC mode
zh_CN: 代码模式 %s 在 PIC 模式下不受支持

en: collapse argument needs positive constant integer expression
zh_CN: 折叠参数需要正整常量表达式

en: collect2 version %s
zh_CN: collect2 版本 %s

en: comma at end of enumerator list
zh_CN: 枚举表以逗号结尾

en: comparison between %q#T and %q#T
zh_CN: 在%q#T和%q#T间比较

en: comparison between %qT and %qT
zh_CN: 在%qT和%qT间比较

en: comparison between distinct pointer types %qT and %qT lacks a cast
zh_CN: 在不同的指针类型%qT和%qT之间的比较需要一个类型转换

en: comparison between distinct pointer-to-member types %qT and %qT lacks a cast
zh_CN: 在不同的成员指针类型%qT和%qT之间的比较需要一个类型转换

en: comparison between pointer and integer
zh_CN: 比较指针和整数

en: comparison between types %qT and %qT
zh_CN: 在类型%qT和%qT间比较

en: comparison is always %d
zh_CN: 比较结果始终为 %d

en: comparison is always %d due to width of bit-field
zh_CN: 由于位段宽度所限，比较结果永远为 %d

en: comparison is always false due to limited range of data type
zh_CN: 由于数据类型范围限制，比较结果永远为假

en: comparison is always true due to limited range of data type
zh_CN: 由于数据类型范围限制，比较结果永远为真

en: comparison of complete and incomplete pointers
zh_CN: 在完全和不完全指针间比较

en: comparison of distinct Objective-C types lacks a cast
zh_CN: 比较独一无二的 Objective-C 类型时缺少转换

en: comparison of distinct pointer types lacks a cast
zh_CN: 比较不相关的指针时缺少类型转换

en: comparison of pointers to disjoint address spaces
zh_CN: 比较指向不相交的地址空间的指针

en: comparison with string literal results in unspecified behavior
zh_CN: 与字面字符串比较的结构是不可预测的

en: comparisons like %<X<=Y<=Z%> do not have their mathematical meaning
zh_CN: 形如%<X<=Y<=Z%>的比较并不具备其在数学上的意义

en: compilation terminated due to -Wfatal-errors.
zh_CN: 编译因为 -Wfatal-errors 而中止。

en: compilation terminated due to -fmax-errors=%u.
zh_CN: 编译中止因为 -fmax-errors=%u。

en: compilation terminated.
zh_CN: 编译中断。

en: complex arguments must have floating-point type
zh_CN: 复数实参必须具有浮点类型

en: complex arguments must have identical types
zh_CN: 复数实参必须具有相同的类型

en: complex invalid for %qs
zh_CN: 对%qs而言无效的复数

en: compound literal has variable size
zh_CN: 复合字面量大小可变

en: compound literal of non-object type %qT
zh_CN: 非对象类型%qT的复合字面常量

en: compound literal qualified by address-space qualifier
zh_CN: 组合字面常量有地址空间限定

en: compressed stream: %s
zh_CN: 压缩的流：%s

en: conditional expression between distinct pointer types %qT and %qT lacks a cast
zh_CN: 不同的指针类型%qT和%qT组成的条件表达式中需要一个类型转换

en: conditional expression between distinct pointer-to-member types %qT and %qT lacks a cast
zh_CN: 不同的成员指针类型%qT和%qT组成的条件表达式中需要一个类型转换

en: conflicting access specifications for field %qE, ignored
zh_CN: 字段%qE的权限设定冲突，已忽略

en: conflicting access specifications for method %q+D, ignored
zh_CN: 方法%q+D的权限设定冲突，已忽略

en: conflicting named address spaces (%s vs %s)
zh_CN: 冲突的有名地址空间(%s和%s)

en: conflicting named address spaces (%s vs %s) for %q+D
zh_CN: 为%3$q+D指定了冲突的有名寻址空间(%1$s和 %2$s)

en: conflicting named address spaces (%s vs generic) for %q+D
zh_CN: 为%2$q+D指定了冲突的有名寻址空间(%1$s 和泛型)

en: conflicting named address spaces (generic vs %s) for %q+D
zh_CN: 为%2$q+D指定了冲突的有名寻址空间(泛型和 %1$s)

en: conflicting return type specified for %q+#D
zh_CN: 为%q+#D指定了冲突的返回类型

en: conflicting super class name %qE
zh_CN: 冲突的超类名%qE

en: conflicting type attributes specified for %q+#D
zh_CN: 为%q+#D指定了冲突的属性

en: conflicting type qualifiers for %q+D
zh_CN: %q+D的类型限定冲突

en: conflicting types for %<%c%s%>
zh_CN: %<%c%s%>类型冲突

en: conflicting types for %q+D
zh_CN: 与%q+D类型冲突

en: consider using '-pg' instead of '-p' with gprof(1)
zh_CN: 与 gprof(1) 一起使用时请考虑使用‘-pg’以代替‘-p’

en: consider using `-pg' instead of `-p' with gprof (1)
zh_CN: 与 gprof (1) 一起使用时请考虑使用‘-pg’以代替‘-p’

en: consider using `-pg' instead of `-p' with gprof(1)
zh_CN: 与 gprof(1) 一起使用时请考虑使用‘-pg’而非‘-p’

en: const/copy propagation disabled
zh_CN: 常量/复制传递被禁用

en: const_double_split got a bad insn:
zh_CN: const_double_split 得到一个错误的指令：

en: constant argument out of range for %qs
zh_CN: 常量实参超过%qs的范围

en: constant refers to itself
zh_CN: 常数指向自身

en: constructor for alien class %qT cannot be a member
zh_CN: 其他类%qT的构造函数不能用作成员

en: constructor priorities are not supported
zh_CN: 不支持构造函数优先级

en: constructor priorities from 0 to %d are reserved for the implementation
zh_CN: 构造函数优先级 0 到 %d 为实现所保留

en: constructor priorities must be integers from 0 to %d inclusive
zh_CN: 构造函数优先级必须为 0 到 %d 间的整数

en: constructor syntax used, but no constructor declared for type %qT
zh_CN: 使用了构造函数的语法，但没有为类型%qT声明构造函数

en: continue statement not within a loop
zh_CN: continue 语句出现在循环以外

en: control flow in the middle of basic block %d
zh_CN: 基本块 %d 中出现流程控制

en: control reaches end of non-void function
zh_CN: 在有返回值的函数中，控制流程到达函数尾

en: conversion between distinct pointer types %qT and %qT lacks a cast
zh_CN: 在不同的指针类型%qT和%qT之间的转换要一个类型转换

en: conversion between distinct pointer-to-member types %qT and %qT lacks a cast
zh_CN: 在不同的成员指针类型%qT和%qT之间的转换需要一个类型转换

en: conversion casts away constness
zh_CN: 转换丢失了常量属性

en: conversion from %q#T to %q#T
zh_CN: 从%q#T到%q#T的转换

en: conversion lacks type at end of format
zh_CN: 格式字符串末尾的转换缺少类型

en: conversion of unsigned constant value to negative integer
zh_CN: 将无符号常量转换为负整数

en: conversion to %qT alters %qT constant value
zh_CN: 向%qT的转换改变了%qT常量值

en: conversion to %qT from %qT may change the sign of the result
zh_CN: %qT转换自%qT时可能会改变结果的符号

en: conversion to %qT from boolean expression
zh_CN: 将布尔表达式转化为%qT

en: conversion to incomplete type
zh_CN: 转换为不完全类型

en: conversion to non-const reference type %q#T from rvalue of type %qT
zh_CN: 将类型为%2$qT的右值转换为非常量引用类型%1$q#T

en: conversion to non-scalar type requested
zh_CN: 请求转换到非标量类型

en: conversion to void will not access object %qE of incomplete type %qT
zh_CN: 向 void 的转换不会访问具有不完全类型%2$qT的对象%1$qE

en: conversion to void will not access object of incomplete type %qT
zh_CN: 向 void 的类型转换不会访问具有不完全类型%qT的对象

en: conversion to void will not access object of non-trivially-copyable type %qT
zh_CN: 向 void 的转换不会访问具有不能平凡复制类型%qT的对象

en: conversion to void will not access object of type %qT
zh_CN: 向 void 的转换不会访问具有类型%qT的对象

en: conversion to volatile reference type %q#T from rvalue of type %qT
zh_CN: 将类型为%2$qT的右值转换为%1$qT的 volatile 引用

en: converting %<false%> to pointer type for argument %P of %qD
zh_CN: 将%<false%>转换为指向%2$qD的实参 %1$P 的指针类型

en: converting NULL to non-pointer type
zh_CN: 将 NULL 转换为非指针类型

en: converting overloaded function %qD to type %q#T is ambiguous
zh_CN: 将重载函数%qD转换为类型%q#T有歧义

en: converting to %qT from initializer list would use explicit constructor %qD
zh_CN: 从初始化列表转换为%qT将使用显式构造函数%qD

en: converting to non-pointer type %qT from NULL
zh_CN: 将 NULL 转换到非指针类型%qT

en: corrupted exits list of loop %d
zh_CN: 循环 %d 的出口列表已损坏

en: corrupted head of the exits list of loop %d
zh_CN: 循环 %d 的退出列表头已损坏

en: corrupted profile info: number of executions for edge %d-%d thought to be %i
zh_CN: 损坏的样本信息：边 %d-%d 的执行次数被认为是 %i

en: corrupted profile info: number of iterations for basic block %d thought to be %i
zh_CN: 损坏的样本信息：基本块 %d 的迭代次数被认为是 %i

en: corrupted profile info: profile data is not flow-consistent
zh_CN: 损坏的样本信息：样本数据不是流一致的

en: could not close response file %s
zh_CN: 无法关闭响应文件 %s

en: could not close temporary response file %s
zh_CN: 无法关闭临时响应文件 %s

en: could not find a spill register
zh_CN: 找不到可溢出的寄存器

en: could not find class %qE
zh_CN: 找不到类%qE

en: could not find interface for class %qE
zh_CN: 找不到类%qE的接口

en: could not find setter/getter for %qE in class %qE
zh_CN: 类 %2$qE 中找不到 %1$qE 的存取器。

en: could not find specs file %s
zh_CN: 找不到 specs 文件 %s

en: could not open response file %s
zh_CN: 无法打开响应文件 %s

en: could not open temporary response file %s
zh_CN: 无法打开临时响应文件 %s

en: could not parse file offset
zh_CN: 不能解析文件偏移量

en: could not parse hex number
zh_CN: 不能解析 16 进制数

en: could not split insn
zh_CN: 无法分离指令

en: could not write to response file %s
zh_CN: 无法写入响应文件 %s

en: could not write to temporary response file %s
zh_CN: 无法写入临时响应文件 %s

en: created and used with different ABIs
zh_CN: 创建和使用时使用了不同的 ABI

en: created and used with different architectures / ABIs
zh_CN: 创建和使用时使用了不同的架构/ABI

en: created and used with different endianness
zh_CN: 创建和使用时使用了不同的大小端设定

en: created and used with differing settings of '%s'
zh_CN: 创建和使用时使用了不同的‘%s’设定

en: creating array of %qT
zh_CN: 生成%qT的数组

en: creating array of %qT, which is an abstract class type
zh_CN: 生成抽象类型%qT的数组

en: creating array of function members
zh_CN: 创建函数成员的组织

en: creating array of functions
zh_CN: 创建函数的数组

en: creating array of references
zh_CN: 创建引用的数组

en: creating array of void
zh_CN: 创建 void 数组

en: creating pointer to member function of non-class type %qT
zh_CN: 生成非类类型%qT的成员函数指针

en: creating pointer to member of non-class type %qT
zh_CN: 生成非类类型%qT的成员指针

en: creating pointer to member of type void
zh_CN: 创建指向 void 类型的成员指针

en: creating pointer to member reference type %qT
zh_CN: 生成引用类型%qT的成员指针

en: creating selector for nonexistent method %qE
zh_CN: 为不存在的方法%qE创建选择子

en: data area attributes cannot be specified for local variables
zh_CN: 不能为局部变量指定地址区域属性

en: data area of %q+D conflicts with previous declaration
zh_CN: %q+D的数据区域与先前的声明冲突

en: data declaration
zh_CN: 数据声明

en: data definition has no type or storage class
zh_CN: 数据定义时没有类型或存储类

en: data member %qD cannot be a member template
zh_CN: 数据成员%qD不能是成员模板

en: data member may not have variably modified type %qT
zh_CN: 数据成员不能具有可变类型%qT

en: data type of %q+D isn%'t suitable for a register
zh_CN: 为%q+D指定的寄存器不适合此数据类型

en: dead histogram
zh_CN: 不活跃直方图

en: debug
zh_CN: 调试

en: debug:
zh_CN: 调试：

en: declaration %qD does not declare anything
zh_CN: 声明%qD没有声明任何东西

en: declaration does not declare anything
zh_CN: 没有声明任何东西

en: declaration for parameter %qD but no such parameter
zh_CN: 声明的形参%qD不存在

en: declaration of %<extern%> variable %qD in %<for%> loop initial declaration
zh_CN: 在%<for%>循环初始声明中声明了%<extern%>变量%qD

en: declaration of %<~%T%> as member of %qT
zh_CN: %<~%T%>声明为%qT的一个成员

en: declaration of %q#D has %<extern%> and is initialized
zh_CN: %q#D声明有%<extern%>并被初始化

en: declaration of %q#D has no initializer
zh_CN: %q#D声明有缺少初始值设定

en: declaration of %q#D outside of class is not definition
zh_CN: 出现在类外的%q#D的声明不是定义

en: declaration of %q#D shadows a parameter
zh_CN: %q#D的声明隐藏了一个形参

en: declaration of %q+D shadows a built-in function
zh_CN: %q+D的声明隐藏了一个内建函数

en: declaration of %q+D shadows previous non-variable
zh_CN: %q+D的声明隐藏了先前的一个非变量声明

en: declaration of %q+D with no linkage follows extern declaration
zh_CN: %q+D声明为没有外部链接的，之前却有外部声明

en: declaration of %qD as array of function members
zh_CN: %qD声明为函数成员的数组

en: declaration of %qD as array of functions
zh_CN: %qD声明为函数的数组

en: declaration of %qD as array of references
zh_CN: %qD声明为引用的数组

en: declaration of %qD as array of void
zh_CN: %qD声明为 void 的数组

en: declaration of %qD as member of %qT
zh_CN: %qD声明为%qT的一个成员

en: declaration of %qD as multidimensional array must have bounds for all dimensions except the first
zh_CN: 多维数组%qD的声明必须至少指定除第一维以外所有维的大小

en: declaration of %qD as non-function
zh_CN: %qD没有声明为一个函数

en: declaration of %qD in %qD which does not enclose %qD
zh_CN: %qD声明出现在%qD中，而后者并不包含%qD

en: declaration of %qD in namespace %qD which does not enclose %qD
zh_CN: %qD声明出现在命名空间%qD中，而后者并不包含%qD

en: declaration of %qD not in a namespace surrounding %qD
zh_CN: %qD的声明不在包含%qD的命名空间中

en: declaration of %qD shadows a global declaration
zh_CN: %qD的声明隐藏了一个全局声明

en: declaration of %qD shadows a previous local
zh_CN: %qD的声明隐藏了先前的一个局部变量

en: declaration of %qE as array of functions
zh_CN: %qE声明为函数的数组

en: declaration of %qE as array of voids
zh_CN: %qE声明为 void 的数组

en: declaration of non-variable %qD in %<for%> loop initial declaration
zh_CN: 在%<for%>循环初始声明中声明了非变量%qD

en: declaration of static variable %qD in %<for%> loop initial declaration
zh_CN: 在%<for%>循环初始声明中声明了静态变量%qD

en: declaration of type name as array of functions
zh_CN: 类型名声明为函数的数组

en: declaration of type name as array of voids
zh_CN: 类型名声明为 void 的数组

en: declarator-id missing; using reserved word %qD
zh_CN: 缺少声明标识符：使用了保留字%qD

en: declared here
zh_CN: 在此声明

en: decrement of constant field %qD
zh_CN: 令只读字段%qD自减

en: decrement of enumeration value is invalid in C++
zh_CN: C++ 中枚举自减操作无效

en: decrement of function %qD
zh_CN: 令函数%qD自减

en: decrement of read-only location %qE
zh_CN: 令只读位置%qE自减

en: decrement of read-only member %qD
zh_CN: 令只读成员%qD自减

en: decrement of read-only named return value %qD
zh_CN: 令有名只读返回值%qD自减

en: decrement of read-only parameter %qD
zh_CN: 令只读形参%qD自减

en: decrement of read-only reference %qD
zh_CN: 令只读引用%qD自减

en: decrement of read-only variable %qD
zh_CN: 令只读成员%qD自增

en: default argument %qE uses local variable %qD
zh_CN: 默认实参%qE使用了局部变量%qD

en: default argument for template parameter for class enclosing %qD
zh_CN: 包含%qD的类的模板参数有默认参数

en: default argument given for parameter %d of %q#D
zh_CN: 为%2$q#D的第 %1$d 个形参指定了默认实参

en: default argument mismatch in overload resolution
zh_CN: 重载解决时默认参数不匹配

en: default argument specified for lambda parameter
zh_CN: 为 lambda 形参指定了默认参数

en: default argument specified in explicit specialization
zh_CN: 显式特例化时指定了默认参数

en: default arguments are not allowed in declaration of friend template specialization %qD
zh_CN: 友元模板特例化%qD中不允许出现默认参数

en: default arguments are only permitted for function parameters
zh_CN: 默认参数只允许出现在函数参数中

en: default template arguments may not be used in function template friend re-declaration
zh_CN: 默认参数不能用在函数模板友元重声明中

en: default template arguments may not be used in partial specializations
zh_CN: 默认参数不能用在部分特例化中

en: defaulted function %q+D with default argument
zh_CN: 默认化函数%q+D有默认参数

en: defining a type in a cast is invalid in C++
zh_CN: C++ 禁止在类型转换中定义类型

en: defining a type in a compound literal is invalid in C++
zh_CN: C++ 不允许在组合字面常量中定义类型

en: defining explicit specialization %qD in friend declaration
zh_CN: 在友元声明中定义显式特例化%qD

en: defining type in %qs expression is invalid in C++
zh_CN: C++ 不允许在%qs表达式中定义类型

en: definition in block %i does not dominate use in block %i
zh_CN: 块 %i 中的定义不支配块 %i 中的使用

en: definition in block %i follows the use
zh_CN: 块 %i 的定义在使用之后

en: definition of %q#D is marked %<dllimport%>
zh_CN: %q#D的定义被标记为 %<dllimport%>

en: definition of %q#T inside template parameter list
zh_CN: 在模板参数列表中定义了%q#T

en: definition of %qD is not in namespace enclosing %qT
zh_CN: %qD的定义不在包含%qT的命名空间中

en: definition of implicitly-declared %qD
zh_CN: 隐式声明的%qD的定义

en: definition of protocol %qE not found
zh_CN: 找不到协议%qE的方法定义

en: definition provided for explicit instantiation
zh_CN: 为显式实例化提供的定义

en: deleted in Fortran 95
zh_CN: 在 Fortran 95 中删除

en: deleting %qT is undefined
zh_CN: 删除%qT未定义

en: dependent-name %qE is parsed as a non-type, but instantiation yields a type
zh_CN: 依赖名%qE被解析为非类型，但实例化却产生了一个类型

en: deprecated conversion from string constant to %qT
zh_CN: 已弃用从字符串常量到%qT的转换

en: deprecated message is not a string
zh_CN: 过时消息不是一个字符串

en: dereferencing %<void *%> pointer
zh_CN: 提领%<void *%>指针

en: dereferencing type-punned pointer might break strict-aliasing rules
zh_CN: 提领类型双关的指针可能破坏强重叠规则

en: dereferencing type-punned pointer will break strict-aliasing rules
zh_CN: 提领类型双关的指针将破坏强重叠规则

en: derived type declaration
zh_CN: 派生的类型声明

en: derived union %qT invalid
zh_CN: 派生联合%qT无效

en: destructor %qD declared as member template
zh_CN: 析构函数%qD被声明为一个成员模板

en: destructor cannot be static member function
zh_CN: 析构函数不能是静态成员函数

en: destructor for %qE shall not be run either
zh_CN: %qE的析构函数也不能被调用

en: destructor for alien class %qT cannot be a member
zh_CN: 其他类%qT的析构函数不能用作成员

en: destructor priorities are not supported
zh_CN: 不支持析构函数优先级

en: destructor priorities from 0 to %d are reserved for the implementation
zh_CN: 析构函数优先级 0 到 %d 为实现所保留

en: destructor priorities must be integers from 0 to %d inclusive
zh_CN: 析构函数优先级必须为 0 到 %d 间的整数

en: destructors may not be cv-qualified
zh_CN: 析构函数不能被 cv 限定

en: destructors may not have parameters
zh_CN: 析构函数不能有参数

en: difference between %qE and %qD does not have integer type
zh_CN: %qE和%qD之间的差不具有整数类型

en: different number of parameters
zh_CN: 形参数量不同

en: different parameter types
zh_CN: 形参类型不同

en: different receiver types
zh_CN: 不同的接收器类型

en: different varargs
zh_CN: 不同的可变参数

en: direct base %qT inaccessible in %qT due to ambiguity
zh_CN: 由于存在歧义，直接基类%qT在%qT中无法访问

en: distinct Objective-C type in return
zh_CN: 返回独一无二的 Objective-C 类型

en: division by zero
zh_CN: 被零除

en: do not specify both -march=... and -mcpu=...
zh_CN: 请勿同时指定 -march=... 和 -mcpu=...

en: does not support multilib
zh_CN: 不支持 multilib

en: dominator of %d should be %d, not %d
zh_CN: %d 的主导者应该为 %d，而不是 %d

en: dominator of %d status unknown
zh_CN: %d 的主导者状态未知

en: double linked list of clones corrupted
zh_CN: 双向克隆链接列表已损坏

en: due to different exception specifications
zh_CN: 因为异常规范不一致

en: dump file: %s
zh_CN: 转储文件：%s

en: duplicate %<_Atomic%>
zh_CN: 重复的%<_Atomic%>

en: duplicate %<const%>
zh_CN: 重复的%<const%>

en: duplicate %<restrict%>
zh_CN: 重复的%<restrict%>

en: duplicate %<volatile%>
zh_CN: 重复的%<volatile%>

en: duplicate %qE
zh_CN: 重复的%qE

en: duplicate %qs
zh_CN: 重复的%qs

en: duplicate (or overlapping) case value
zh_CN: 重复 (或重叠) 的 case 值

en: duplicate base type %qT invalid
zh_CN: 重复的基类型%qT无效

en: duplicate case value
zh_CN: 重复的 case 常量

en: duplicate cv-qualifier
zh_CN: 重复的 cv 限定

en: duplicate declaration for protocol %qE
zh_CN: 重复声明协议%qE

en: duplicate explicit instantiation of %q#D
zh_CN: 对%q#D重复的显式实例化

en: duplicate explicit instantiation of %q#T
zh_CN: 对%q#T重复的显式实例化

en: duplicate initialization of %qD
zh_CN: ISO C++ 不允许成员%qD的初始化

en: duplicate interface declaration for category %<%E(%E)%>
zh_CN: 类别%<%E(%E)%>有重复的接口声明

en: duplicate interface declaration for class %qE
zh_CN: 类%qE的接口声明重复

en: duplicate label %qD
zh_CN: 重复的标号%qD

en: duplicate label declaration %qE
zh_CN: 重复的标号定义%qE

en: duplicate member %q+D
zh_CN: 重复的成员%q+D

en: dynamic dependency %s not found
zh_CN: 找不到动态依赖项 %s

en: each undeclared identifier is reported only once for each function it appears in
zh_CN: 每个未声明的标识符在其出现的函数内只报告一次

en: edge %s->%s has no corresponding call_stmt
zh_CN: 边 %s->%s 没有对应的 call_stmt

en: edge from %d to %d should be marked irreducible
zh_CN: 从 %d 到 %d 的边应被标记为不可归约的

en: edge from %d to %d should not be marked irreducible
zh_CN: 从 %d 到 %d 的边不应被标记为不可归约的

en: edge points to wrong declaration:
zh_CN: 边指向错误的声明：

en: element types must be the same
zh_CN: 元素类型必须一样

en: elemental binary operation
zh_CN: 基本二元操作

en: elemental function arguments at %C are not compliant
zh_CN: %C处基本函数的实参不兼容

en: elemental procedure
zh_CN: 基本过程

en: elements of array %q#D have incomplete type
zh_CN: 数组%q#D的元素类型不完全

en: elements of array %q#T have incomplete type
zh_CN: 数组%q#T的元素类型不完全

en: embedded %<\0%> in format
zh_CN: 格式字符串嵌有%<\0%>

en: empty declaration
zh_CN: 空声明

en: empty declaration with storage class specifier does not redeclare tag
zh_CN: 带有存储类的空声明没有重声明标记

en: empty declaration with type qualifier does not redeclare tag
zh_CN: 带有类型限定的空声明没有重声明标记

en: empty index range in initializer
zh_CN: 初始值设定项中索引范围为空

en: empty left precision in %s format
zh_CN: %s 格式字符串中左精度为空

en: empty precision in %s format
zh_CN: %s 格式字符串中精度为空

en: empty range specified
zh_CN: 指定范围为空

en: enabling backtrace support is only meaningful when compiling for the Thumb
zh_CN: 函数调用回溯支持只在为 Thumb 编译时有意义

en: enabling callee interworking support is only meaningful when compiling for the Thumb
zh_CN: 被调用者协作只在为 Thumb 编译时有意义

en: enclosing class templates are not explicitly specialized
zh_CN: 所包含的类模板并未被显式特例化

en: end insn %d for block %d not found in the insn stream
zh_CN: 块 %2$d 的结束指令 %1$d 在指令流中找不到

en: enum constant defined here
zh_CN: 枚举常量在此定义

en: enum conversion in assignment is invalid in C++
zh_CN: C++ 禁止在赋值时进行枚举转换

en: enum conversion in initialization is invalid in C++
zh_CN: C++ 禁止在初始化时进行枚举转换

en: enum conversion when passing argument %d of %qE is invalid in C++
zh_CN: C++ 禁止在传递%2$qE的第 %1$d 个参数时进行枚举转换

en: enum type defined here
zh_CN: 枚举类型在此定义

en: enumeration value %qE not handled in switch
zh_CN: switch 没有处理枚举值%qE

en: enumeration values exceed range of largest integer
zh_CN: 枚举值超过了最大整数类型可表示的范围

en: enumerator value for %qD is not an integer constant
zh_CN: %qD的枚举值不是一个整数常量

en: enumerator value for %qE is not an integer constant
zh_CN: %qE的枚举值不是一个整数常量

en: enumerator value for %qE is not an integer constant expression
zh_CN: %qE的枚举值不是一个整数常量

en: environment variable %<COLLECT_LTO_WRAPPER%> must be set
zh_CN: 环境变量 %<COLLECT_LTO_WRAPPER%> 必须被设置

en: environment variable %qs not defined
zh_CN: 环境变量%qs未定义

en: environment variable COLLECT_GCC_OPTIONS must be set
zh_CN: 环境变量 COLLECT_GCC_OPTIONS 必须被设置

en: error
zh_CN: 错误

en: error closing %s: %m
zh_CN: 关闭 %s 时出错：%m

en: error writing %qs
zh_CN: 写入%qs时错误

en: error writing to %s: %m
zh_CN: 写入 %s 时出错：%m

en: error:
zh_CN: 错误：

en: exception of type %<%T%> will be caught
zh_CN: 类型为%<%T%>的异常将会

en: excess elements in array initializer
zh_CN: 数组初始值设定项中有多余的元素

en: excess elements in scalar initializer
zh_CN: 标量初始值设定项中有多余元素

en: excess elements in struct initializer
zh_CN: 结构初始值设定项中有多余元素

en: excess elements in union initializer
zh_CN: 联合初始值设定项中有多余元素

en: excess elements in vector initializer
zh_CN: 向量初始值设定项中有多余元素

en: exit %d->%d not recorded
zh_CN: 退出 %d->%d 未被记录

en: expected %<#pragma omp section%> or %<}%>
zh_CN: 需要%<#pragma omp section%>或%<}%>

en: expected %<(%>
zh_CN: 需要%<(%>

en: expected %<(%> or end of line
zh_CN: 需要%<(%>或行尾

en: expected %<)%>
zh_CN: 需要%<)%>

en: expected %<*%>
zh_CN: 需要%<*%>

en: expected %<,%>
zh_CN: 需要 %<,%>

en: expected %<,%> or %<)%>
zh_CN: 需要 %<,%> 或 %<)%>

en: expected %<,%> or %<...%>
zh_CN: 需要%<,%>或%<...%>

en: expected %<,%> or %<;%>
zh_CN: 需要%<,%>或%<;%>

en: expected %<,%> or %<}%>
zh_CN: 需要%<,%>或%<}%>

en: expected %<,%>, %<;%> or %<}%>
zh_CN: 需要%<,%>、%<;%>或%<}%>

en: expected %<.%>
zh_CN: 需要%<.%>

en: expected %<...%>
zh_CN: 需要%<...%>

en: expected %<:%>
zh_CN: 需要 %<:%>

en: expected %<:%> or %<...%>
zh_CN: 需要%<:%>或%<...%>

en: expected %<:%> or %<::%>
zh_CN: 需要%<:%>或%<::%>

en: expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%>
zh_CN: 需要%<:%>，%<,%>，%<;%>，%<}%>或%<__attribute__%>

en: expected %<::%>
zh_CN: 需要%<::%>

en: expected %<;%>
zh_CN: 需要%<;%>

en: expected %<;%> after class definition
zh_CN: 类定义后需要%<;%>

en: expected %<;%> after struct definition
zh_CN: 结构定义后需要%<;%>

en: expected %<;%> after union definition
zh_CN: 联合定义后需要%<;%>

en: expected %<;%>, %<,%> or %<)%>
zh_CN: 需要 %<;%>、%<,%> 或 %<)%>

en: expected %<<%>
zh_CN: 需要%<<%>

en: expected %<=%>
zh_CN: 需要%<=%>

en: expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>
zh_CN: 需要%<=%>，%<,%>，%<;%>，%<asm%>或%<__attribute__%>

en: expected %<>%>
zh_CN: 需要 %<>%>

en: expected %<@end%>
zh_CN: 需要 %<@end%>

en: expected %<@synchronized%>
zh_CN: 需要%<@synchronized%>

en: expected %<@throw%>
zh_CN: 需要%<@throw%>

en: expected %<@try%>
zh_CN: 需要%<@try%>

en: expected %<[%>
zh_CN: 需要%<[%>

en: expected %<]%>
zh_CN: 需要%<]%>

en: expected %<__label__%>
zh_CN: 需要%<__label__%>

en: expected %<asm%>
zh_CN: 需要%<asm%>

en: expected %<catch%>
zh_CN: 需要%<catch%>

en: expected %<class%>
zh_CN: 需要%<class%>

en: expected %<class%>, %<typename%>, or %<template%>
zh_CN: 需要%<class%>、%<typename%>或%<template%>

en: expected %<decltype%>
zh_CN: 需要%<decltype%>

en: expected %<delete%>
zh_CN: 需要%<delete%>

en: expected %<extern%>
zh_CN: 需要%<extern%>

en: expected %<namespace%>
zh_CN: 需要%<namespace%>

en: expected %<new%>
zh_CN: 需要%<new%>

en: expected %<operator%>
zh_CN: 需要%<operator%>

en: expected %<return%>
zh_CN: 需要%<return%>

en: expected %<static_assert%>
zh_CN: 需要%<static_assert%>

en: expected %<template%>
zh_CN: 需要%<template%>

en: expected %<throw%>
zh_CN: 需要%<throw%>

en: expected %<try%>
zh_CN: 需要%<try%>

en: expected %<using%>
zh_CN: 需要%<using%>

en: expected %<while%>
zh_CN: 需要 %<while%>

en: expected %<{%>
zh_CN: 需要%<{%>

en: expected %<{%> or %<:%>
zh_CN: 需要%<{%>或%<:%>

en: expected %<}%>
zh_CN: 需要 %<}%>

en: expected %<}%> before %<else%>
zh_CN: %<else%>前需要%<}%>

en: expected %<~%>
zh_CN: 需要%<~%>

en: expected %d levels of template parms for %q#D, got %d
zh_CN: 需要 %d 级的%q#D模板参数，却给出了 %d 级

en: expected %qT but argument is of type %qT
zh_CN: 需要类型%qT，但实参的类型为%qT

en: expected a string after %<#pragma message%>
zh_CN: %<#pragma message%>后需要一个字符串

en: expected an SSA_NAME object
zh_CN: 需要一个 SSA_NAME 对象

en: expected boolean expression
zh_CN: 需要布尔表达式

en: expected boolean type
zh_CN: 需要布尔类型

en: expected channel
zh_CN: 需要通道

en: expected class name
zh_CN: 需要类名

en: expected class-name
zh_CN: 需要类名

en: expected declaration
zh_CN: 需要声明

en: expected declaration or statement
zh_CN: 需要声明或语句

en: expected declaration specifiers
zh_CN: 需要指定声明

en: expected declaration specifiers or %<...%>
zh_CN: 需要指定声明或%<...%>

en: expected declarator
zh_CN: 需要声明

en: expected end of capture-list
zh_CN: 捕获列表应在此结束

en: expected end of line
zh_CN: 需要行尾

en: expected expression
zh_CN: 需要表达式

en: expected function
zh_CN: 需要函数

en: expected identifier
zh_CN: 需要标识符

en: expected identifier or %<(%>
zh_CN: 需要标识符或%<(%>

en: expected identifier or %<*%>
zh_CN: 需要标识符或%<*%>

en: expected initializer
zh_CN: 需要初始值设定

en: expected integer
zh_CN: 需要整数

en: expected integer expression
zh_CN: 需要整数表达式

en: expected iteration declaration or initialization
zh_CN: 需要迭代声明或初始化

en: expected iteration-statement
zh_CN: 需要循环语句

en: expected jump-statement
zh_CN: 需要跳转语句

en: expected labeled-statement
zh_CN: 需要标号语句

en: expected namespace-name
zh_CN: 需要命名空间名

en: expected numeric type
zh_CN: 需要数字类型

en: expected operator
zh_CN: 需要操作符

en: expected parameter pack before %<...%>
zh_CN: %<...%>前需要形参包

en: expected pointer
zh_CN: 需要指针

en: expected primary-expression
zh_CN: 需要元表达式

en: expected qualified name in friend declaration for constructor %qD
zh_CN: 在构造函数%qD中的友元声明需要限定名

en: expected qualified name in friend declaration for destructor %qD
zh_CN: 在析构函数%qD中的友元声明需要限定名

en: expected selection-statement
zh_CN: 需要选择语句

en: expected specifier-qualifier-list
zh_CN: 需要指定符-限制符列表

en: expected statement
zh_CN: 需要语句

en: expected string literal
zh_CN: 需要字面字符串

en: expected string-literal
zh_CN: 需要字面字符串

en: expected template-argument
zh_CN: 需要模板实参

en: expected template-id
zh_CN: 需要模板 ID

en: expected template-name
zh_CN: 需要模板名

en: expected type-name
zh_CN: 需要类型名

en: expected type-specifier
zh_CN: 需要类型限定

en: explicit goto at end of bb %d
zh_CN: 基本块 %d 末尾显式的 goto

en: explicit instantiation of %q#D
zh_CN: 对%q#D的显式实例化

en: explicit instantiation of %q#T before definition of template
zh_CN: %q#T的显式实例化出现在模板定义之前

en: explicit instantiation of %qD but no definition available
zh_CN: 显式实例化%qD时没有可用的定义

en: explicit instantiation of %qD in namespace %qD (which does not enclose namespace %qD)
zh_CN: %qD的显式实例化出现在命名空间%qD中，而后者并不包含命名空间%qD

en: explicit instantiation of non-template %q#D
zh_CN: 对非模板%q#D的显式实例化

en: explicit instantiation of non-template type %qT
zh_CN: 显式实例化非模板类型%qT

en: explicit instantiation shall not use %<constexpr%> specifier
zh_CN: 显式实例化不应当使用%<constexpr%>限定符

en: explicit instantiation shall not use %<inline%> specifier
zh_CN: 显式实例化不应当使用%<inline%>限定符

en: explicit qualification in declaration of %qD
zh_CN: %qD的声明中有显式的限定

en: explicit specialization in non-namespace scope %qD
zh_CN: 显式特例化出现在非命名空间作用域%qD中

en: explicit specialization of %qD after first use
zh_CN: 在初次使用后显式特例化%qD

en: explicit specialization of %qD must be introduced by %<template <>%>
zh_CN: %qD的显式特例化必须由%<template <>%>引入

en: explicit specialization of non-template %qT
zh_CN: 显式特例化非模板%qT

en: explicit template argument list not allowed
zh_CN: 不允许显式模板参数列表

en: explicit template specialization cannot have a storage class
zh_CN: 显式特例化不能有存储类型

en: expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L
zh_CN: %L处 !$OMP ATOMIC 赋值“变量 = 变量 运算符 表达式”中的“表达式”必须是标量并且不能引用“变量”

en: expression in new-declarator must have integral or enumeration type
zh_CN: new 声明中的表达式必须具有整数或枚举类型

en: expression statement has incomplete type
zh_CN: 表达式语句类型不完全

en: extended registers have no high halves
zh_CN: 扩展的寄存器没有高半部分

en: extern declaration of %q+D follows declaration with no linkage
zh_CN: %q+D声明为没有外部链接的，之前却有外部声明

en: external linkage required for symbol %q+D because of %qE attribute
zh_CN: 符号%q+D需要外部链接，因为%qE属性

en: extra %<;%>
zh_CN: 多余的%<;%>

en: extra brace group at end of initializer
zh_CN: 初始值设定项末尾有多余的花括号组

en: extra elements in scalar initializer
zh_CN: 标量初始值设定中有多余元素

en: extra outgoing edge %d->%d
zh_CN: 多余的出边 %d->%d

en: extra qualification %<%T::%> on member %qs
zh_CN: 有多余的限定%<%T::%>在成员%qs上

en: extra qualification not allowed
zh_CN: 不允许有多余的限定

en: extra semicolon in method definition specified
zh_CN: 为方法定义指定了多余的分号

en: extra semicolon in struct or union specified
zh_CN: 为联合或结构指定了多余的分号

en: extra type qualifiers in format argument (argument %d)
zh_CN: 格式字符串实参 %d 有多余的类型限定

en: fail to initialize plugin %s
zh_CN: 无法初始化插件 %s

en: failed to reclaim unneeded function
zh_CN: 无法收回不需要的函数

en: failure to simplify substring reference in DATA statement at %L
zh_CN: %L处 DATA 语句简化子串引用时失败

en: failure trying to reload:
zh_CN: 试图重新载入时失败：

en: fallthru edge after a control statement in bb %d
zh_CN: 在基本块 %d 中控制语句后的直通边

en: fallthru to exit from bb %d
zh_CN: 直通边从基本块 %d 退出

en: fast enumeration is not available in Objective-C 1.0
zh_CN: 快速枚举在 Objective-C 1.0 里不可用

en: fastcall and cdecl attributes are not compatible
zh_CN: fastcall 和 cdecl 属性互不兼容

en: fastcall and regparm attributes are not compatible
zh_CN: fastcall 和 regparm 属性互不兼容

en: fastcall and stdcall attributes are not compatible
zh_CN: fastcall 和 stdcall 属性互不兼容

en: fastcall and thiscall attributes are not compatible
zh_CN: fastcall 和 thiscall 属性互不兼容

en: fatal error:
zh_CN: 致命错误：

en: field %qE declared as a function
zh_CN: 字段%qE声明为一个函数

en: field %qE has incomplete type
zh_CN: 字段%qE的类型不完全

en: field name not in record or union initializer
zh_CN: 字段名不在记录或联合初始值设定中

en: field precision specifier
zh_CN: 字段精度限定

en: field width
zh_CN: 域宽

en: field width in printf format
zh_CN: printf 格式的字段宽度

en: field width in scanf format
zh_CN: scanf 格式的字段宽

en: field width in strfmon format
zh_CN: strfmon 格式的字段宽度

en: field width in strftime format
zh_CN: strftime 格式的字段宽度

en: field width specifier
zh_CN: 字段宽度限定

en: file ends in default argument
zh_CN: 文件在默认参数处结束

en: file-scope declaration of %qE specifies %<auto%>
zh_CN: 文件作用域声明%qE指定了%<auto%>

en: file-scope declaration of %qE specifies %<register%>
zh_CN: 文件作用域声明%qE指定了%<register%>

en: fill character
zh_CN: 填充字符

en: fill character in strfmon format
zh_CN: strfmon 格式的填充字符

en: find_enum(): Enum not found
zh_CN: find_enum()：找不到枚举

en: fini function found in object %s
zh_CN: 在对象 %s 中发现 fini 函数

en: first argument of %q+D should be %<int%>
zh_CN: %q+D的第一个参数的类型应该是%<int%>

en: first argument to %<__builtin_choose_expr%> not a constant
zh_CN: %<__builtin_choose_expr%>的第一个实参不是一个常量

en: first argument to %<va_arg%> not of type %<va_list%>
zh_CN: 给%<va_arg%>的第一个参数的类型不是%<va_list%>

en: fixed-point types not supported for this target
zh_CN: 定点类型在此目标机上不受支持

en: fixed-point types not supported in C++
zh_CN: C++ 不支持定点类型

en: flexible array member in union
zh_CN: 联合和可变数组成员

en: flexible array member not at end of struct
zh_CN: 可变数组成员没有出现在结构的末尾

en: floating constant exceeds range of %qT
zh_CN: 浮点常量超出%qT的范围

en: floating constant misused
zh_CN: 错误地使用了浮点常量

en: floating constant truncated to zero
zh_CN: 浮点常量向零截断

en: flow control insn inside a basic block
zh_CN: 基本块内有流程控制指令

en: fold check: original tree changed by fold
zh_CN: 折叠检查: 原始树因折叠而改变

en: for %qD
zh_CN: 为 %qD

en: for increment expression has no effect
zh_CN: for 循环増量表达式不起作用

en: for statement expected
zh_CN: 需要 for 语句

en: for template declaration %q+D
zh_CN: 对于模板声明%q+D

en: format
zh_CN: 格式

en: format argument %d used more than once in %s format
zh_CN: 格式实参 %d 在 %s 格式字符串中使用不止一次

en: format is a wide character string
zh_CN: 格式字符串是一个宽字符串

en: format not a string literal and no format arguments
zh_CN: 格式字符串不是一个字面字符串而且没有待格式化的实参

en: format not a string literal, argument types not checked
zh_CN: 格式字符串不是一个字面字符串，没有进行实参类型检查

en: format not a string literal, format string not checked
zh_CN: 格式字符串不是一个字面字符串，格式字符串未被检查

en: forming pointer to reference type %qT
zh_CN: 生成指向引用类型%qT的指针

en: forming reference to reference type %qT
zh_CN: 生成指向引用类型%qT的引用

en: forming reference to void
zh_CN: 形成对 void 的引用

en: found %<%c%s%>
zh_CN: 找到了%<%c%s%>

en: found %<-%E%> instead of %<+%E%> in protocol(s)
zh_CN: 在协议中找到%<-%E%>而非%<+%E%>

en: found a default name with a non-empty defining statement
zh_CN: 找到一个有非空定义语句的默认名字

en: found a real definition for a non-register
zh_CN: 为一个非寄存器找到一个真实定义

en: found a virtual definition for a GIMPLE register
zh_CN: 为一个 GIMPLE 寄存器找到一个虚拟定义

en: found an SSA_NAME that had been released into the free pool
zh_CN: 找到一个已经被释放的 SSA_NAME

en: found default case not at the start of case vector
zh_CN: 默认 case 不在 case 向量的开头

en: fr30_print_operand: invalid %%F code
zh_CN: fr30_print_operand：无效的 %%F 代码

en: fr30_print_operand: invalid %%x code
zh_CN: fr30_print_operand：无效的 %%x 代码

en: fr30_print_operand: invalid operand to %%A code
zh_CN: fr30_print_operand：%%A 代码操作数无效

en: fr30_print_operand: unhandled MEM
zh_CN: fr30_print_operand：未处理的 MEM

en: fr30_print_operand: unknown code
zh_CN: fr30_print_operand：未知代码

en: fr30_print_operand: unrecognized %%B code
zh_CN: fr30_print_operand：无法识别的 %%B 代码

en: fr30_print_operand: unrecognized %%b code
zh_CN: fr30_print_operand：无法识别的 %%b 代码

en: fr30_print_operand: unrecognized %%p code
zh_CN: fr30_print_operand：无法识别的 %%p 代码

en: fr30_print_operand_address: unhandled address
zh_CN: fr30_print_operand：未处理的指针

en: frame size too large for reliable stack checking
zh_CN: 对可靠的堆栈检查来说框架太大了

en: friend declaration %q#D declares a non-template function
zh_CN: 友元声明%q#D声明了一个非模板函数

en: friend declaration does not name a class or function
zh_CN: 友元声明没有指定类或函数名

en: friend declaration not in class definition
zh_CN: 友元声明不在类定义内

en: friend declaration requires class-key, i.e. %<friend %#T%>
zh_CN: 友元声明需要 class，即%<friend %#T%>

en: friend declaration requires class-key, i.e. %<friend class %T::%D%>
zh_CN: 友元声明需要 class，即%<friend class %T::%D%>

en: frv_print_operand: unknown code
zh_CN: frv_print_operand：未知代码

en: function %q#D is initialized like a variable
zh_CN: 函数%q#D像变量一样被初始化

en: function %q+D definition is marked dllimport
zh_CN: 函数%q+D的定义被标记为 dllimport

en: function %q+F can never be copied because it receives a non-local goto
zh_CN: 函数%q+F无法被复制，因为它接受了非局部的 goto

en: function %q+F can never be copied because it saves address of local label in a static variable
zh_CN: 函数%q+F无法被复制，因为它在一个静态变量中保存了局部标号的地址

en: function %q+F can never be inlined because it contains a computed goto
zh_CN: 函数%q+F无法被内联，因为包含一个计算转移

en: function %q+F can never be inlined because it uses alloca (override using the always_inline attribute)
zh_CN: 函数%q+F无法被内联，因为它使用了 alloca (使用 always_inline 属性强制内联)

en: function %q+F can never be inlined because it uses attributes conflicting with inlining
zh_CN: 函数%q+F无法被内联，因为它使用了与内联冲突的属性

en: function %q+F can never be inlined because it uses non-local goto
zh_CN: 函数%q+F无法被内联，因为使用了非局部的 goto

en: function %q+F can never be inlined because it uses setjmp
zh_CN: 函数%q+F无法被内联，因为它使用了 setjmp

en: function %q+F can never be inlined because it uses setjmp-longjmp exception handling
zh_CN: 函数%q+F无法被内联，因为它使用了 setjmp-longjmp 异常处理

en: function %q+F can never be inlined because it uses variable argument lists
zh_CN: 函数%q+F无法被内联，因为它使用了变长实参表

en: function %qD is initialized like a variable
zh_CN: 函数%qD像变量一样被初始化

en: function %qD redeclared as variable
zh_CN: 函数%qD重声明为变量

en: function %qD used as %<asm%> output
zh_CN: 函数%qD用作%<asm%>的输出

en: function %qs cannot be declared %<mutable%>
zh_CN: 函数%qs不能被声明为%<mutable%>

en: function body can be overwritten at link time
zh_CN: 函数体可能在链接时被改写

en: function body not available
zh_CN: 函数体不可用

en: function call has aggregate value
zh_CN: 函数调用有聚合类型

en: function called through a non-compatible type
zh_CN: 函数经由不兼容的类型调用

en: function declaration isn%'t a prototype
zh_CN: 函数声明不是一个原型

en: function declared %<noreturn%> has a %<return%> statement
zh_CN: 被声明为%<noreturn%>的函数却有%<return%>语句

en: function definition declared %<auto%>
zh_CN: 函数声明定义为%<auto%>

en: function definition declared %<register%>
zh_CN: 函数声明定义为%<register%>

en: function definition declared %<typedef%>
zh_CN: 函数声明定义为%<typedef%>

en: function definition does not declare parameters
zh_CN: 函数定义未声明形参

en: function definition has qualified void return type
zh_CN: 函数定义有限定的 void 返回类型

en: function does not return string type
zh_CN: 函数不返回字符串类型

en: function may return address of local variable
zh_CN: 函数可能返回局部变量的地址

en: function not considered for inlining
zh_CN: 不考虑内联函数

en: function not declared inline and code size would grow
zh_CN: 函数未被声明成内联且会导致代码膨胀

en: function not inlinable
zh_CN: 函数不能内联

en: function not inline candidate
zh_CN: 函数不是内联备选

en: function return type cannot be function
zh_CN: 函数不能返回函数

en: function return types not compatible due to %<volatile%>
zh_CN: 由于%<volatile%>，函数返回类型不兼容

en: function returning a function
zh_CN: 函数返回了一个函数

en: function returning an array
zh_CN: 函数返回了一个数组

en: function returns address of local variable
zh_CN: 函数返回局部变量的地址

en: function returns an aggregate
zh_CN: 函数返回一个聚合

en: function template %qD redeclared as a class template
zh_CN: 函数模板%qD重声明为类模板

en: function types not truly compatible in ISO C
zh_CN: 函数类型与 ISO C 不完全兼容

en: function with qualified void return type called
zh_CN: 调用了有限定 void 返回类型的函数

en: function-scope %qs implicitly auto and declared %<__thread%>
zh_CN: 函数作用域的%qs隐式为 auto，却被声明为%<__thread%>

en: gcc driver version %s %sexecuting gcc version %s
zh_CN: 版本为 %s %s的 gcc 驱动程序，执行版本为 %s 的 gcc

en: gcc version %s %s
zh_CN: gcc 版本 %s %s

en: generate the main function
zh_CN: 生成 main 函数

en: getting core file size maximum limit: %m
zh_CN: 获取核心文件大小上限：%m

en: gfc_basic_typename(): Undefined type
zh_CN: gfc_basic_typename()：未定义的类型

en: gfc_caf_attr(): Bad array reference
zh_CN: gfc_caf_attr()︰不当的数组引用

en: gfc_caf_attr(): Expression isn't a variable
zh_CN: gfc_caf_attr()︰表达式不是一个变量

en: gfc_simplify_abs(): Bad type
zh_CN: gfc_simplify_abs()：不恰当的类型

en: gfc_simplify_dcmplx(): Bad type (x)
zh_CN: gfc_simplify_dcmplx()：不恰当的类型（x）

en: gfc_simplify_dcmplx(): Bad type (y)
zh_CN: gfc_simplify_dcmplx()：不恰当的类型（y）

en: gfc_simplify_dim(): Bad type
zh_CN: gfc_simplify_dim()：不恰当的类型

en: gfc_simplify_floor(): Bad kind
zh_CN: gfc_simplify_floor()：不恰当的种类

en: gfc_trans_code(): Bad statement code
zh_CN: gfc_trans_code()：错误的语句代码

en: gfc_trans_omp_workshare(): Bad statement code
zh_CN: gfc_trans_omp_workshare()：错误的语句代码

en: gfc_typename(): Undefined type
zh_CN: gfc_typename()：未定义的类型

en: gfc_variable_attr(): Expression isn't a variable
zh_CN: gfc_variable_attr()︰表达式不是一个变量

en: gfortran does not support -E without -cpp
zh_CN: gfortran 不支持单独使用 -E 而不带 -cpp

en: gimple call has no target
zh_CN: gimple 调用无目标

en: gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d
zh_CN: gimple 检查：需要 %s(%s)，得到 %s(%s) 在 %s 中，于 %s:%d

en: gimple_bb (phi) is set to a wrong basic block
zh_CN: gimple_bb (phi) 设置为一个错误的基本块

en: gimple_bb (stmt) is set to a wrong basic block
zh_CN: gimple_bb (stmt) 设置为一个错误的基本块

en: gimplification failed
zh_CN: gimplification 失败

en: global constructors not supported on this target
zh_CN: 全局构造函数在此目标机上不受支持

en: global destructors not supported on this target
zh_CN: 全局析构函数在此目标机上不受支持

en: global register variable %qD used in nested function
zh_CN: 嵌套函数中使用了全局寄存器变量%qD

en: global register variable follows a function definition
zh_CN: 全局寄存器变量出现在函数定义后

en: global register variable has initial value
zh_CN: 全局寄存器变量有初始值

en: global/static variable assignment has been intercepted
zh_CN: 全局/静态变量赋值已被打断

en: got %d template parameters for %q#D
zh_CN: 得到 %d 个模板参数，为%q#D

en: got %d template parameters for %q#T
zh_CN: %2$q#T得到了 %1$d 个模板参数

en: goto destination is neither a label nor a pointer
zh_CN: goto 的目标既非标号亦非指针

en: gsplit-dwarf is not supported on this platform
zh_CN: gsplit-dwarf 在此平台上不受支持

en: head insn %d for block %d not found in the insn stream
zh_CN: 块 %2$d 的头指令 %1$d 在指令流中找不到

en: iWMMXt and NEON are incompatible
zh_CN: iWMMXt 与 NEON 互不兼容

en: ia64_print_operand: unknown code
zh_CN: ia64_print_operand：未知代码

en: identifier %qE conflicts with C++ keyword
zh_CN: 标识符%qE与 C++ 关键字冲突

en: identifier expected after %<@protocol%>
zh_CN: %<@protocol%>需要标识符

en: if this code is reached, the program will abort
zh_CN: 如果执行到这段代码，程序将中止

en: ignoring %<#pragma align%> for explicitly aligned %q+D
zh_CN: 为显式对齐的%q+D忽略%<#pragma align%>

en: ignoring attributes applied to %qT after definition
zh_CN: 忽略在其定义之后为%qT应用的属性

en: ignoring attributes applied to class type %qT outside of definition
zh_CN: 忽略在定义之外为类类型%qT应用的属性

en: ignoring attributes applied to dependent type %qT without an associated declaration
zh_CN: 忽略在关联定义之外为依赖类类型%qT应用的属性

en: ignoring duplicate directory "%s"
zh_CN: 忽略重复的目录“%s”

en: ignoring nonexistent directory "%s"
zh_CN: 忽略不存在的目录“%s”

en: illegal aggregate type %qE specified for instance variable %qs
zh_CN: 非法的聚合类型%qE指定给实例变量%qs

en: illegal operand detected
zh_CN: 检测到无效的操作数

en: illegal reference type specified for instance variable %qs
zh_CN: 为实例变量%qs指定了无效的引用类型

en: implicit declaration of function %qE
zh_CN: 隐式声明函数%qE

en: implicit dereference will not access object of type %qT in for increment expression
zh_CN: 隐式提领不会访问 for 循环增量表达式中具有类型%qT的对象

en: implicit dereference will not access object of type %qT in left operand of comma operator
zh_CN: 隐式提领不会访问作为逗号操作符左操作数的具有类型%qT的对象

en: implicit dereference will not access object of type %qT in right operand of comma operator
zh_CN: 隐式提领不会访问作为逗号操作符右操作数的具有类型%qT的对象

en: implicit dereference will not access object of type %qT in second operand of conditional expression
zh_CN: 隐式提领不会访问作为条件表达式第二个操作数的具有类型%qT的对象

en: implicit dereference will not access object of type %qT in statement
zh_CN: 隐式提领不会访问语句中类型为%qT的对象

en: implicit dereference will not access object of type %qT in third operand of conditional expression
zh_CN: 隐式提领不会访问作为条件表达式第三个操作数的具有类型%qT的对象

en: implied END DO
zh_CN: 暗示的 END DO

en: impossible constraint in %<asm%>
zh_CN: %<asm%>中不可能的约束

en: impossible register constraint in %<asm%>
zh_CN: %<asm%>中不可能的寄存器约束

en: in %s, at %s:%d
zh_CN: 在 %s 中，于 %s:%d

en: in C++98 %qD must be initialized by constructor, not by %<{...}%>
zh_CN: 在 C++98 中%qD必须由构造函数而不是%<{...}%>初始化

en: in argument to unary !
zh_CN: 单目 ! 的参数中

en: in basic block %d:
zh_CN: 在基本块 %d 中：

en: in declaration %q+D
zh_CN: 在声明%q+D中

en: in gfc_simplify_acos(): Bad type
zh_CN: 在 gfc_simplify_acos()：不恰当的类型

en: in gfc_simplify_acosh(): Bad type
zh_CN: 在 gfc_simplify_acosh()：不恰当的类型

en: in gfc_simplify_asin(): Bad type
zh_CN: 在 gfc_simplify_asin()：不恰当的类型

en: in gfc_simplify_asinh(): Bad type
zh_CN: 在 gfc_simplify_asinh()：不恰当的类型

en: in gfc_simplify_atan(): Bad type
zh_CN: 在 gfc_simplify_atan()：不恰当的类型

en: in gfc_simplify_atanh(): Bad type
zh_CN: 在 gfc_simplify_atanh()：不恰当的类型

en: in gfc_simplify_cos(): Bad type
zh_CN: 在 gfc_simplify_cos()：不恰当的类型

en: in gfc_simplify_exp(): Bad type
zh_CN: 在 gfc_simplify_exp()：不恰当的类型

en: inappropriate accumulator for %qs
zh_CN: %qs的累加器不合适

en: incoming edge count does not match number of PHI arguments
zh_CN: 引入边计数不匹配 PHI 参数数目

en: incompatible address space qualifiers %qs and %qs
zh_CN: 不兼容的地址空间限定符%qs和%qs

en: incompatible implicit declaration of built-in function %qD
zh_CN: 隐式声明与内建函数%qD不兼容

en: incompatible implicit declaration of function %qD
zh_CN: 隐式声明与函数%qD不兼容

en: incompatible type for argument %d of %qE
zh_CN: %2$qE的第 %1$d 个实参类型不兼容

en: incompatible type for map index
zh_CN: 映射索引类型不兼容

en: incompatible type for method %s%s%s
zh_CN: 方法%s%s%s类型不兼容

en: incompatible type for receiver
zh_CN: 接收器类型不兼容

en: incompatible types in assignment of %qT to %qT
zh_CN: 将%qT赋值给%qT时类型不兼容

en: incompatible types when assigning to type %qT from type %qT
zh_CN: 将%2$qT赋值给%1$qT时类型不兼容

en: incompatible types when initializing type %qT using type %qT
zh_CN: 用%2$qT初始化%1$qT时类型不兼容

en: incompatible types when returning type %qT but %qT was expected
zh_CN: 将%qT返回为%qT时类型不兼容

en: incomplete implementation of category %qE
zh_CN: 类别%qE的实现不完全

en: incomplete implementation of class %qE
zh_CN: 类%qE的实现不完全

en: incomplete type %qT does not have member %qD
zh_CN: 不完全类型%qT没有成员%qD

en: incomplete type %qT used in nested name specifier
zh_CN: 嵌套名指定中使用了不完全的类型%qT

en: inconsistent deduction for %qT: %qT and then %qT
zh_CN: 对%qT不一致的演绎：先是%qT然后是%qT

en: inconsistent instance variable specification
zh_CN: 不一致的实例变量指定

en: inconsistent operand constraints in an %<asm%>
zh_CN: %<asm%>中操作数约束不一致

en: inconsistent types %qT and %qT deduced for lambda return type
zh_CN: Lambda 返回类型演绎得到不一致的类型%qT和%qT

en: incorrect comparison mode
zh_CN: 不正确的比较模式

en: incorrect format in scaling, using 1/1
zh_CN: 缩放格式错误，使用 1/1

en: incorrect insn:
zh_CN: 错误指令：

en: incorrect setting of landing pad number
zh_CN: 着陆场号码设置不正确

en: incorrect sharing of tree nodes
zh_CN: 对树结节的共享不正确

en: increment of constant field %qD
zh_CN: 令只读字段%qD自增

en: increment of enumeration value is invalid in C++
zh_CN: C++ 中枚举自增操作无效

en: increment of function %qD
zh_CN: 令函数%qD自增

en: increment of read-only location %qE
zh_CN: 令只读位置%qE自增

en: increment of read-only member %qD
zh_CN: 令只读成员%qD自增

en: increment of read-only named return value %qD
zh_CN: 令只读有名返回值%qD自增

en: increment of read-only parameter %qD
zh_CN: 令只读形参%qD自增

en: increment of read-only reference %qD
zh_CN: 令只读引用%qD自增

en: increment of read-only variable %qD
zh_CN: 令只读变量%qD自增

en: index %E denotes an offset greater than size of %qT
zh_CN: 索引 %E 指定了一个大于%qT大小的偏移量

en: index in dimension %d is out of bounds at %L
zh_CN: %2$L处第 %1$d 维下标越界

en: index value instead of field name in union initializer
zh_CN: 在联合初始值设定中出现了索引值而不是字段名

en: index value is out of bound
zh_CN: 索引值越界

en: indirect function call with a yet undetermined callee
zh_CN: 间接函数调用目标未定义

en: indirection will not access object of incomplete type %qT in for increment expression
zh_CN: 提领不会访问 for 循环增量表达式中具有不完全类型%qT的对象

en: indirection will not access object of incomplete type %qT in left operand of comma operator
zh_CN: 提领不会访问作为逗号操作符左操作数的具有不完全类型%qT的对象

en: indirection will not access object of incomplete type %qT in right operand of comma operator
zh_CN: 提领不会访问作为逗号操作符右操作数的具有不完全类型%qT的对象

en: indirection will not access object of incomplete type %qT in second operand of conditional expression
zh_CN: 提领不会访问作为条件表达式第二个操作数的具有不完全类型%qT的对象

en: indirection will not access object of incomplete type %qT in statement
zh_CN: 提领不会访问语句中具有不完全类型的对象%qT

en: indirection will not access object of incomplete type %qT in third operand of conditional expression
zh_CN: 提领不会访问作为条件表达式第三个操作数的具有不完全类型%qT的对象

en: indirection will not access object of non-trivially-copyable type %qT in for increment expression
zh_CN: 提领不会访问 for 循环增量表达式中具有不能平凡复制类型%qT的对象

en: indirection will not access object of non-trivially-copyable type %qT in left operand of comma operator
zh_CN: 提领不会访问作为逗号操作符左操作数的具有不能平凡复制类型%qT的对象

en: indirection will not access object of non-trivially-copyable type %qT in right operand of comma operator
zh_CN: 提领不会访问作为逗号操作符右操作数的具有不能平凡复制类型%qT的对象

en: indirection will not access object of non-trivially-copyable type %qT in second operand of conditional expression
zh_CN: 提领不会访问作为条件表达式第二个操作数的具有不能平凡复制类型%qT的对象

en: indirection will not access object of non-trivially-copyable type %qT in statement
zh_CN: 提领不会访问语句中具有不能平凡复制类型%qT的对象

en: indirection will not access object of non-trivially-copyable type %qT in third operand of conditional expression
zh_CN: 提领不会访问作为条件表达式第三个操作数的具有不能平凡复制类型%qT的对象

en: init function found in object %s
zh_CN: 在对象 %s 中发现 init 函数

en: initialization from distinct Objective-C type
zh_CN: 从独一无二的 Objective-C 类型初始化

en: initialization from pointer to non-enclosed address space
zh_CN: 从指针向未被包围的地址空间初始化

en: initialization left-hand side might be a candidate for a format attribute
zh_CN: 初始化的左手边可能是 format 属性的备选时

en: initialization of a flexible array member
zh_CN: 对可变数组成员的初始化

en: initialization of flexible array member in a nested context
zh_CN: 在嵌套的上下文中初始化可变数组成员

en: initialization of non-const reference type %q#T from rvalue of type %qT
zh_CN: 用类型为%2$qT的右值初始化非常量引用类型%1$q#T

en: initialization of volatile reference type %q#T from rvalue of type %qT
zh_CN: 用类型为%2$qT的右值初始化类型为%1$q#T的 volatile 引用

en: initializations for multiple members of %qT
zh_CN: 初始化%qT的多个成员

en: initialized field overwritten
zh_CN: 已初始化的字段被覆盖

en: initialized field with side-effects overwritten
zh_CN: 带副作用的字段初始值设定被覆盖

en: initialized variable %q+D is marked dllimport
zh_CN: 经初始化的变量%q+D被标记为 dllimport

en: initializer element is not a constant expression
zh_CN: 初始值设定中元素不是常量表达式

en: initializer element is not computable at load time
zh_CN: 初始值设定中的元素在载入时无法被计算出

en: initializer element is not constant
zh_CN: 初始值设定元素不是常量

en: initializer ends prematurely
zh_CN: 初始值设定在完成之前结束

en: initializer fails to determine size of %q+D
zh_CN: 初始值设定无法决定%q+D的大小

en: initializer fails to determine size of %qD
zh_CN: 初始值设定无法决定%qD的大小

en: initializer for %qT must be brace-enclosed
zh_CN: %qT的初始值设定必须在花括号内

en: initializer for floating value is not a floating constant
zh_CN: 浮点值的初始值设定不是一个浮点常量

en: initializer for integer/fixed-point value is too complicated
zh_CN: 整数/定点值的初始值设定太复杂

en: initializer invalid for static member with constructor
zh_CN: 构造函数中对静态成员的初始化无效

en: initializer provided for function
zh_CN: 为函数提供了初始值设定

en: initializer specified for non-virtual method %q+D
zh_CN: 为非虚方法%q+D指定了初始值设定项

en: initializer specified for static member function %qD
zh_CN: 为静态成员函数%qD指定了初始值

en: injected-class-name %qD used as template template argument
zh_CN: 注入的类名%qD被用作模板的模板参数

en: inline function %q+D declared but never defined
zh_CN: 内联函数%q+D声明过但从未定义

en: inlined_to pointer is set but no predecessors found
zh_CN: 设定了 inlined_to 指针却找不到前驱

en: inlined_to pointer is wrong
zh_CN: inlined_to pointer 错误

en: inlined_to pointer refers to itself
zh_CN: inlined_to pointer 指向自身

en: inlined_to pointer set for noninline callers
zh_CN: 为非内联的调用者设定了 inlined_to pointer

en: inlining failed in call to %q+F: %s
zh_CN: 调用%q+F时内联失败：%s

en: input operand constraint contains %qc
zh_CN: 输入操作数约束包含%qc

en: insn %d basic block pointer is %d, should be %d
zh_CN: 指令 %d 基本块指针是 %d，应该是 %d

en: insn %d in footer of bb %d has non-NULL basic block
zh_CN: 基本块 %2$d 尾中的指令 %1$d 有非空的基本块

en: insn %d in header of bb %d has non-NULL basic block
zh_CN: 基本块 %2$d 头中的指令 %1$d 有非空的基本块

en: insn %d is in multiple basic blocks (%d and %d)
zh_CN: 指令 %d 在多个基本块内(%d 和 %d)

en: insn %d outside of basic blocks has non-NULL bb field
zh_CN: 基本块外指令 %d 有非 NULL 的 bb 域

en: insn contains an invalid address !
zh_CN: 指令包含无效地址！

en: insn does not satisfy its constraints:
zh_CN: 指令不满足其约束：

en: insn outside basic block
zh_CN: 基本块外出现指令

en: install: %s%s
zh_CN: 安装：%s%s

en: instance variable %qE accessed in class method
zh_CN: 实例变量%qE在类方法中被访问

en: instance variable %qE is %s; this will be a hard error in the future
zh_CN: 实例变量%qE是 %s；这在将来会是一个严重的错误

en: instance variable %qE is declared %s
zh_CN: 实例变量%qE被声明为 %s

en: instance variable %qE is declared private
zh_CN: 实例变量%qE被声明为私有的

en: instance variable %qs has unknown size
zh_CN: 实例变量%qs大小未知

en: instance variable assignment has been intercepted
zh_CN: 实例变量的赋值被打断

en: instruction never executed
zh_CN: 指令从不被执行

en: instruction scheduling not supported on this target machine
zh_CN: 指令调度在此目标机上不受支持

en: insufficient contextual information to determine type
zh_CN: 上下文信息不足以确定类型

en: integer constant is too large for %<unsigned long%> type
zh_CN: 对%<unsigned long%>类型而言整数常量太大

en: integral expression %qE is not constant
zh_CN: 整型表达式%qE不是常量

en: interface %qE does not have valid constant string layout
zh_CN: 接口%qE常量字符串布局无效

en: internal compiler error
zh_CN: 编译器内部错误

en: internal compiler error.  Bad address:
zh_CN: 编译器内部错误。错误的地址：

en: internal compiler error.  Incorrect shift:
zh_CN: 编译器内部错误。不正确的移位量：

en: internal compiler error.  Unknown mode:
zh_CN: 编译器内部错误。未知的模式：

en: internal compiler error:
zh_CN: 编译器内部错误：

en: internal consistency failure
zh_CN: 内部一致性错误

en: internal error: bad register: %d
zh_CN: 内部错误：错误的寄存器：%dt

en: interrupt handlers cannot be MIPS16 functions
zh_CN: 中断处理程序不能是 MIPS16 函数

en: intrinsic variable which isn't a procedure
zh_CN: 内建函数变量不是一个过程

en: invalid %%-code
zh_CN: 无效的 %%-code

en: invalid %%A operand
zh_CN: 无效的 %%A 操作数

en: invalid %%B operand
zh_CN: 无效的 %%B 操作数

en: invalid %%C value
zh_CN: 无效 %%C 值

en: invalid %%D value
zh_CN: 无效的 %%D 值

en: invalid %%E value
zh_CN: 无效 %%E 值

en: invalid %%F value
zh_CN: 无效 %%F 值

en: invalid %%G mode
zh_CN: 无效 %%G 模式

en: invalid %%G value
zh_CN: 无效 %%G 值

en: invalid %%J code
zh_CN: 无效 %%J 代码

en: invalid %%J value
zh_CN: 无效 %%J 值

en: invalid %%K value
zh_CN: 无效 %%K 值

en: invalid %%L value
zh_CN: 无效 %%L 值

en: invalid %%M value
zh_CN: 无效 %%M 值

en: invalid %%N value
zh_CN: 无效 %%N 值

en: invalid %%O value
zh_CN: 无效 %%O 值

en: invalid %%P operand
zh_CN: 无效的 %%P 操作数

en: invalid %%P value
zh_CN: 无效 %%P 值

en: invalid %%R value
zh_CN: 无效 %%R 值

en: invalid %%T value
zh_CN: 无效 %%T 值

en: invalid %%U value
zh_CN: 无效 %%U 值

en: invalid %%V value
zh_CN: 无效 %%V 值

en: invalid %%Y operand
zh_CN: 无效的 %%Y 操作数

en: invalid %%d value
zh_CN: 无效的 %%d 值

en: invalid %%e value
zh_CN: 无效 %%e 值

en: invalid %%f operand
zh_CN: 无效的 %%f 操作数

en: invalid %%f value
zh_CN: 无效 %%f 值

en: invalid %%h value
zh_CN: 无效 %%h 值

en: invalid %%j code
zh_CN: 无效 %%j 代码

en: invalid %%j value
zh_CN: 无效的 %%j 值

en: invalid %%k value
zh_CN: 无效 %%k 值

en: invalid %%m value
zh_CN: 无效 %%m 值

en: invalid %%p value
zh_CN: 无效的 %%p 值

en: invalid %%q value
zh_CN: 无效 %%q 值

en: invalid %%r value
zh_CN: 无效 %%r 值

en: invalid %%s operand
zh_CN: 无效的 %%s 操作数

en: invalid %%s value
zh_CN: 无效 %%s 值

en: invalid %%t value
zh_CN: 无效 %%t 值

en: invalid %%t/%%b value
zh_CN: 无效的 %%t/%%b 值

en: invalid %%u value
zh_CN: 无效 %%u 值

en: invalid %%v value
zh_CN: 无效 %%v 值

en: invalid %%x value
zh_CN: 无效 %%x 值

en: invalid %%xn code
zh_CN: 无效的 %%xn 代码

en: invalid %%y value, try using the 'Z' constraint
zh_CN: 无效 %%y 值，请试用“Z”约束

en: invalid %%z value
zh_CN: 无效 %%z 值

en: invalid 'asm':
zh_CN: 无效的‘asm’：

en: invalid IACC argument
zh_CN: 无效的 IACC 实参

en: invalid JSON syntax
zh_CN: 无效的 JSON 语法

en: invalid LHS in gimple call
zh_CN: gimple 调用中左操作数无效

en: invalid Objective-C++ selector name
zh_CN: 无效的 Objective-C++ 选择子名

en: invalid UNSPEC as operand
zh_CN: 无效的 UNSPEC 用作操作数

en: invalid abstract return type for function %q+#D
zh_CN: 函数%q+#D的抽象返回类型无效

en: invalid abstract return type for member function %q+#D
zh_CN: 成员函数%q+#D的抽象返回类型无效

en: invalid abstract type %qT for %qE
zh_CN: 抽象类型%qT无效，对于%qE无效

en: invalid abstract type for %q+D
zh_CN: %q+D的抽象类型无效

en: invalid address
zh_CN: 无效地址

en: invalid addressing mode
zh_CN: 无效寻址模式

en: invalid alignment for %<#pragma align%>, ignoring
zh_CN: %<#pragma align%>指定的对齐边界无效，忽略

en: invalid application of %<__alignof%> to a bit-field
zh_CN: 对位段使用%<__alignof%>无效

en: invalid application of %<sizeof%> to a bit-field
zh_CN: 对位段使用%<sizeof%>无效

en: invalid application of %<sizeof%> to a function type
zh_CN: %<sizeof%>不能用于函数类型

en: invalid application of %qs to a member function
zh_CN: %qs用于成员函数无效

en: invalid application of %qs to a void type
zh_CN: %qs不能用于 void 类型

en: invalid argument of %qE attribute
zh_CN: 属性%qE的参数无效

en: invalid argument of %qs attribute
zh_CN: 属性%qs的参数无效

en: invalid argument to built-in function
zh_CN: 内建函数实参无效

en: invalid argument to gimple call
zh_CN: gimple 调用中参数无效

en: invalid array assignment
zh_CN: 无效的数组赋值

en: invalid base-class specification
zh_CN: 无效的基类

en: invalid cast from type %qT to type %qT
zh_CN: 从类型%qT到类型%qT的转换无效

en: invalid cast to function type %qT
zh_CN: 向函数类型%qT的转换无效

en: invalid class name in declaration of %qD
zh_CN: %qD的声明中类名无效

en: invalid combination of multiple type-specifiers
zh_CN: 无效的类型限定符组合

en: invalid comparison code in gimple cond
zh_CN: gimple 条件中比较代码无效

en: invalid const_double operand
zh_CN: 无效的双精度常量操作数

en: invalid constant in %<#pragma pack%> - ignored
zh_CN: %<#pragma pack%>中有无效常量 - 已忽略

en: invalid constraints for operand
zh_CN: 操作数的约束无效

en: invalid constructor; you probably meant %<%T (const %T&)%>
zh_CN: 无效的构造函数：您要的可能是%<%T (const %T&)%>

en: invalid controlling predicate
zh_CN: 无效的控制谓词

en: invalid conversion from %<__fpreg%>
zh_CN: 从%<__fpreg%>的转换无效

en: invalid conversion in gimple call
zh_CN: gimple 调用中转换无效

en: invalid conversion in return statement
zh_CN: 返回语句转换无效

en: invalid conversion to %<__fpreg%>
zh_CN: 向%<__fpreg%>的转换无效

en: invalid conversion to type %qT from type %qT
zh_CN: 到类型%qT的转换无效，从类型%qT

en: invalid covariant return type for %q+#D
zh_CN: %q+#D的协变返回类型无效

en: invalid declaration of %<%T::%E%>
zh_CN: %<%T::%E%>声明无效

en: invalid declaration of member template in local class
zh_CN: 局部类中对成员模板的声明无效

en: invalid declarator
zh_CN: 无效的声明

en: invalid default argument for a template template parameter
zh_CN: 模板的模板形参的默认实参无效

en: invalid definition of qualified type %qT
zh_CN: 对限定类型%qT的定义无效

en: invalid element type for attribute %qs
zh_CN: 属性%qs的元素类型无效

en: invalid embedcfg: missing Files
zh_CN: 无效的 embedcfg：缺失文件

en: invalid embedcfg: not a JSON object
zh_CN: 无效的 embedcfg：不是 JSON 对象

en: invalid exit from OpenMP structured block
zh_CN: OpenMP 结构块出口无效

en: invalid expression as operand
zh_CN: 无效的表达式用作操作数

en: invalid expression for min lvalue
zh_CN: 无效的最小左值表达式

en: invalid expression type for %<#pragma omp atomic%>
zh_CN: %<#pragma omp atomic%>表达式类型无效

en: invalid function in gimple call
zh_CN: gimple 调用中有非法函数

en: invalid hex digit
zh_CN: 无效的16进制数

en: invalid in-class initialization of static data member of non-integral type %qT
zh_CN: 类中对具有非整数类型%qT的静态数据成员的初始化无效

en: invalid increment expression
zh_CN: 无效的自增语句

en: invalid initial value for member %qE
zh_CN: 成员%qE的初始值无效

en: invalid initializer
zh_CN: 无效的初始值设定

en: invalid initializer for member function %qD
zh_CN: 成员函数%qD的初始值设定无效

en: invalid insn:
zh_CN: 无效指令：

en: invalid labels in gimple cond
zh_CN: gimple 条件中的标号无效

en: invalid location for %<pragma %s%>, ignored
zh_CN: %<pragma %s%>位置错误，已忽略

en: invalid mask
zh_CN: 无效掩码

en: invalid member template declaration %qD
zh_CN: 无效的成员模板声明%qD

en: invalid operand code '%c'
zh_CN: 无效的操作数代码‘%c’

en: invalid operand for 'A' modifier
zh_CN: ‘A’修饰符的操作数无效

en: invalid operand for 'D' modifier
zh_CN: ‘D’修饰符的操作数无效

en: invalid operand for 'H' modifier
zh_CN: ‘H’修饰符的操作数无效

en: invalid operand for 'O' modifier
zh_CN: ‘O’修饰符的操作数无效

en: invalid operand for 'T' modifier
zh_CN: ‘T’修饰符的操作数无效

en: invalid operand for 'b' modifier
zh_CN: ‘b’修饰符的操作数无效

en: invalid operand for 'e' modifier
zh_CN: ‘e’修饰符的操作数无效

en: invalid operand for 'm' modifier
zh_CN: ‘m’修饰符的操作数无效

en: invalid operand for 'o' modifier
zh_CN: ‘o’修饰符的操作数无效

en: invalid operand for 'p' modifier
zh_CN: ‘p’修饰符的操作数无效

en: invalid operand for 'z' modifier
zh_CN: ‘z’修饰符的操作数无效

en: invalid operand for code '%c'
zh_CN: 代码‘%c’的操作数无效

en: invalid operand in return statement
zh_CN: 返回语句操作数无效

en: invalid operand in unary operation
zh_CN: 单目操作中操作数无效

en: invalid operand modifier letter
zh_CN: 无效的操作数修饰符字母

en: invalid operand output code
zh_CN: 无效的操作数输出代码

en: invalid operand to %%H/%%L code
zh_CN: %%H/%%L 代码的操作数无效

en: invalid operand to %%M code
zh_CN: %%M 代码的操作数无效

en: invalid operand to %%N code
zh_CN: %%N 代码的操作数无效

en: invalid operand to %%O code
zh_CN: %%O 代码的操作数无效

en: invalid operand to %%R
zh_CN: %%R 的操作数无效

en: invalid operand to %%R code
zh_CN: %%R 代码的操作数无效

en: invalid operand to %%S
zh_CN: %%S 的操作数无效

en: invalid operand to %%T/%%B code
zh_CN: %%T/%%B 代码的操作数无效

en: invalid operand to %%U code
zh_CN: %%U 代码的操作数无效

en: invalid operand to %%V code
zh_CN: %%V 代码的操作数无效

en: invalid operand to %%Z code
zh_CN: %%Z 代码的操作数无效

en: invalid operand to %%p code
zh_CN: %%p 代码的操作数无效

en: invalid operand to %%s code
zh_CN: %%s 代码的操作数无效

en: invalid operand to %%z code
zh_CN: %%z 代码的操作数无效

en: invalid operand to switch statement
zh_CN: 开关语句操作数无效

en: invalid operands in binary operation
zh_CN: 二元操作中中操作数无效

en: invalid operands in gimple comparison
zh_CN: gimple 比较中操作数无效

en: invalid operands of types %qT and %qT to binary %qO
zh_CN: 操作数类型%qT和%qT对双目%qO而言无效

en: invalid operands to binary %s (have %qT and %qT)
zh_CN: 双目运算符 %s 操作数(%qT和%qT)无效

en: invalid operation (%s)
zh_CN: 无效的操作（%s）

en: invalid operation on %<__fpreg%>
zh_CN: 对%<__fpreg%>的操作无效

en: invalid operator for %<#pragma omp atomic%>
zh_CN: %<#pragma omp atomic%>运算符无效

en: invalid parameter type %qT
zh_CN: 无效的参数类型%qT

en: invalid pointer mode %qs
zh_CN: 无效的指针模式%qs

en: invalid pointer to bit-field %qD
zh_CN: 指向位段%qD指针无效

en: invalid punctuation %qc in constraint
zh_CN: 约束中出现无效的标点%qc

en: invalid pure const state for function
zh_CN: 纯常函数状态无效

en: invalid qualifiers on non-member function type
zh_CN: 非成员函数类型上的限定符无效

en: invalid qualifying scope in pseudo-destructor name
zh_CN: 伪析构函数名的限定作用域无效

en: invalid receiver type %qs
zh_CN: 无效的接收者类型%qs

en: invalid reduction-identifier
zh_CN: 无效还原标识符

en: invalid register name for %q+D
zh_CN: %q+D的寄存器名无效

en: invalid rtl sharing found in the insn
zh_CN: 指令中有无效的 RTL 共享

en: invalid schedule kind
zh_CN: 无效的调度类型

en: invalid second argument to %<__builtin_prefetch%>; using zero
zh_CN: %<__builtin_prefetch%>的第二个实参无效；使用 0

en: invalid shift operand
zh_CN: 无效的移位操作数

en: invalid static chain in gimple call
zh_CN: gimple 调用中静态链无效

en: invalid storage class for function %qE
zh_CN: 函数%qE存储类无效

en: invalid template declaration of %qD
zh_CN: %qD模板声明无效

en: invalid template-id
zh_CN: 无效的模板 ID

en: invalid third argument to %<__builtin_prefetch%>; using zero
zh_CN: %<__builtin_prefetch%>的第三个实参无效；使用 0

en: invalid type %qT as initializer for a vector of type %qT
zh_CN: 无效类型%qT被用作类型为%qT的向量的初始值设定

en: invalid type %qT declared %<friend%>
zh_CN: 无效的类型%qT声明为%<friend%>

en: invalid type argument of %<->%> (have %qT)
zh_CN: %<->%>参数类型无效(有%qT)

en: invalid type argument of array indexing (have %qT)
zh_CN: 数组索引参数类型无效(有%qT)

en: invalid type argument of unary %<*%> (have %qT)
zh_CN: 一元 %<*%>参数类型无效(有%qT)

en: invalid type for iteration variable %qE
zh_CN: 迭代变量%qE类型无效

en: invalid types %<%T[%T]%> for array subscript
zh_CN: %<%T[%T]%>用作数组下标类型无效

en: invalid types in address space conversion
zh_CN: 地址空间转换中类型无效

en: invalid types in conversion to integer
zh_CN: 向整数转换时类型无效

en: invalid types in fixed-point conversion
zh_CN: 整点转换中类型无效

en: invalid types in nop conversion
zh_CN: 空转换中类型无效

en: invalid use of %%d, %%x, or %%X
zh_CN: 对 %%d、%%x 或 %%X 的使用无效

en: invalid use of %<::%>
zh_CN: 错误地使用了%<::%>

en: invalid use of %<auto%> in conversion operator
zh_CN: 在转换运算符中使用%<auto%>无效

en: invalid use of %<restrict%>
zh_CN: 错误地使用了%<restrict%>

en: invalid use of %<this%> at top level
zh_CN: 在文件作用域使用%<this%>无效

en: invalid use of %<this%> in non-member function
zh_CN: 在非成员函数中使用%<this%>无效

en: invalid use of %qD
zh_CN: 错误地使用了%qD

en: invalid use of %qD in linkage specification
zh_CN: 指定链接时使用%qD无效

en: invalid use of %qE to form a pointer-to-member-function
zh_CN: 用%qE形成成员函数指针的用法无效

en: invalid use of %qT
zh_CN: 对%qT的使用非法

en: invalid use of '%%%c'
zh_CN: 对‘%%%c’的使用无效

en: invalid use of a pointer to an incomplete type in pointer arithmetic
zh_CN: 在指针算术中使用指向不完全类型的指针无效

en: invalid use of array indexing on pointer to member
zh_CN: 对成员指针数组索引的使用无效

en: invalid use of array with unspecified bounds
zh_CN: 对未指定边界的数组的使用无效

en: invalid use of constructor as a template
zh_CN: 将构造函数用作模板无效

en: invalid use of dependent type %qT
zh_CN: 对依赖类型%qT的使用无效

en: invalid use of destructor %qD as a type
zh_CN: 将析构函数%qD用作类型无效

en: invalid use of flexible array member
zh_CN: 对可变数组成员的使用无效

en: invalid use of implicit conversion on pointer to member
zh_CN: 隐式转换成员指针用法无效

en: invalid use of incomplete type %q#T
zh_CN: 对不完全的类型%q#T的非法使用

en: invalid use of non-lvalue array
zh_CN: 对非左值数组的使用无效

en: invalid use of non-static data member %qD
zh_CN: 对非静态数据成员%qD的无效使用

en: invalid use of non-static member function %qD
zh_CN: 对非静态成员函数%qD的使用无效

en: invalid use of pack expansion expression
zh_CN: 对集展开表达式的无效使用

en: invalid use of qualified-name %<%D::%D%>
zh_CN: 对限定名%<%D::%D%>的使用无效

en: invalid use of qualified-name %<%T::%D%>
zh_CN: 对限定名%<%T::%D%>的使用无效

en: invalid use of qualified-name %<::%D%>
zh_CN: 对限定名%<::%D%>的使用无效

en: invalid use of structure with flexible array member
zh_CN: 对包含可变数组成员的结构的无效使用

en: invalid use of template template parameter %qT
zh_CN: 对模板的模板参数%qT的使用无效

en: invalid use of template type parameter %qT
zh_CN: 对模板类型参数%qT的使用无效

en: invalid use of template-id %qD in declaration of primary template
zh_CN: 在基本模板的声明中对模板标识符%qD的使用无效

en: invalid use of template-name %qE without an argument list
zh_CN: 使用模板名%qE时不带实参表无效

en: invalid use of type %qT as a default value for a template template-parameter
zh_CN: 将类型%qT用作模板的模板参数的默认值无效

en: invalid use of unary %<*%> on pointer to member
zh_CN: 对成员指针使用一元%<*%>非法

en: invalid use of void expression
zh_CN: 对 void 表达式的使用无效

en: invalid vector type for attribute %qE
zh_CN: 属性%qE的向量类型无效

en: invalid version number %qs
zh_CN: 无效的版本号%qs

en: it must be the address of a function with external linkage
zh_CN: 它必须是一个具有外部链接函数的地址

en: iterating variable in fast enumeration is not an object
zh_CN: 快速枚举中的迭代变量不是对象

en: iteration variable %qD should not be firstprivate
zh_CN: 迭代变量%qD不应当是 firstprivate

en: iteration variable %qD should not be reduction
zh_CN: 迭代变量%qD不应当是 reduction

en: iteration variable %qE should be private
zh_CN: 迭代变量%qE应当是私有的

en: iteration variable %qE should not be firstprivate
zh_CN: 迭代变量%qE不应当是 firstprivate

en: iteration variable %qE should not be reduction
zh_CN: 迭代变量%qE不应当是 reduction

en: its dest_idx should be %d, not %d
zh_CN: 它的 dest_idx 应当是 %d 而不是 %d

en: iwmmxt abi requires an iwmmxt capable cpu
zh_CN: iwmmxt abi 需要相应 CPU 的支持

en: iwmmxt requires an AAPCS compatible ABI for proper operation
zh_CN: iwmmxt 需要与 AAPCS 兼容的 ABI 方能正确操作

en: jump into scope of identifier with variably modified type
zh_CN: 跳至具有可变类型的标识符的作用域中

en: jump into statement expression
zh_CN: 跳转至语句表达式中

en: jump skips variable initialization
zh_CN: 跳转略过了变量初始化

en: jump to case label
zh_CN: 跳转至 case 标号

en: jump to label %qD
zh_CN: 跳转至标号%qD

en: junk at end of %<#pragma %s%>
zh_CN: %<#pragma %s%>末尾有垃圾

en: junk at end of %<#pragma GCC visibility%>
zh_CN: %<#pragma GCC visibility%>末尾有垃圾字符

en: junk at end of %<#pragma align%>
zh_CN: %<#pragma align%>末尾有垃圾字符

en: junk at end of %<#pragma fini%>
zh_CN: %<#pragma fini%>末尾有垃圾字符

en: junk at end of %<#pragma init%>
zh_CN: %<#pragma init%>末尾有垃圾字符

en: junk at end of %<#pragma message%>
zh_CN: %<#pragma message%>末尾有垃圾字符

en: junk at end of %<#pragma pack%>
zh_CN: %<#pragma pack%>末尾有垃圾字符

en: junk at end of %<#pragma redefine_extname%>
zh_CN: %<#pragma redefine_extname%>末尾有垃圾字符

en: junk at end of %<#pragma reset_options%>
zh_CN: %<#pragma reset_options%>末尾有垃圾字符

en: junk at end of %<#pragma weak%>
zh_CN: %<#pragma weak%>末尾有垃圾字符

en: junk at end of '#pragma extern_model'
zh_CN: '#pragma extern_model' 末尾有垃圾字符

en: keyword %<export%> not implemented, and will be ignored
zh_CN: 关键字%<export%>未实现，将被忽略

en: keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)
zh_CN: 关键字%<typename%>不允许用在此上下文中(限定的初始值设定隐式地是一个类型)

en: keyword %<typename%> not allowed in this context (the base class is implicitly a type)
zh_CN: 关键字%<typename%>不允许用在此上下文中(基类隐式地是一个类型)

en: keyword %<typename%> not allowed outside of templates
zh_CN: 关键字%<typename%>不能在模板以外使用

en: label %q+D declared but not defined
zh_CN: 标号%q+D声明后未定义

en: label %q+D defined but not used
zh_CN: 标号%q+D定义后未使用

en: label %q+D used but not defined
zh_CN: 标号%q+D使用前未定义

en: label %qD defined here
zh_CN: 标号%qD在此定义

en: label %qE referenced outside of any function
zh_CN: 标号%qE在所有函数外被引用

en: label at end of compound statement
zh_CN: 标号位于复合语句末尾

en: language %s not recognized
zh_CN: 语言 %s 未能被识别

en: language string %<"%E"%> not recognized
zh_CN: 语言字符串%<"%E"%>不可识别

en: large fixed-point constant implicitly truncated to fixed-point type
zh_CN: 大定点常量隐式截断为定点类型

en: large integer implicitly truncated to unsigned type
zh_CN: 大整数隐式截断为无符号类型

en: last argument must be an immediate
zh_CN: 最后一个实参必须是一个立即数

en: ld returned %d exit status
zh_CN: ld 返回 %d

en: left argument must be a slice
zh_CN: 左实参必须是一个切片

en: left precision
zh_CN: 左精度

en: left precision in strfmon format
zh_CN: strfmon 格式的左精度

en: left shift count >= width of type
zh_CN: 左移次数大于或等于类型宽度

en: left shift count is negative
zh_CN: 左移次数为负

en: left-hand operand of comma expression has no effect
zh_CN: 逗号表达式的左操作数不起作用

en: length modifier
zh_CN: 长度修饰符

en: length modifier in printf format
zh_CN: printf 格式的长度修饰符

en: length modifier in scanf format
zh_CN: scanf 格式的长度修饰符

en: length modifier in strfmon format
zh_CN: strfmon 格式的长度修饰符

en: letter %c was found & insn was not CONST_INT
zh_CN: 找到字母 %c 且指令不是 CONST_INT

en: libraries: %s
zh_CN: 库：%s

en: library function %q#D redeclared as non-function %q#D
zh_CN: 库函数%q#D重声明为非函数%q#D

en: library lib%s not found
zh_CN: 找不到库 lib%s

en: lo_sum not of register
zh_CN: lo_sum 不是寄存器

en: local class %q#T shall not have static data member %q#D
zh_CN: 局部类%q#T不应当拥有静态数据成员%q#D

en: local declaration of %qE hides instance variable
zh_CN: %qE的局部声明隐藏了实例变量

en: local variable %qD may not appear in this context
zh_CN: 局部变量%qD不应出现在此上下文中

en: local variable memory requirements exceed capacity
zh_CN: 局部变量内存需求超过容量限制

en: logical %<and%> applied to non-boolean constant
zh_CN: 逻辑%<and%>被用在非布尔型常量上

en: logical %<and%> of mutually exclusive tests is always false
zh_CN: 对两个互斥的测试取逻辑%<and%>的结果永远为假

en: logical %<or%> applied to non-boolean constant
zh_CN: 逻辑%<or%>被用在非布尔型常量上

en: logical %<or%> of collectively exhaustive tests is always true
zh_CN: 对两个互补的测试取逻辑%<or%>的结果永远为真

en: lookup of %qT in %qT is ambiguous
zh_CN: 在%2$qT中查询%1$qT有歧义

en: lower value in case label range less than minimum value for type
zh_CN: case 标号范围的下限值比该类型的最小值还要小

en: lvalue required as decrement operand
zh_CN: 自减操作数必须是左值

en: lvalue required as increment operand
zh_CN: 自增操作数必须是左值

en: lvalue required as left operand of assignment
zh_CN: 赋值运算的左操作数必须是左值

en: lvalue required as unary %<&%> operand
zh_CN: 单目%<&%>的操作数必须是左值

en: macro name missing after %qs
zh_CN: %qs后缺少宏名

en: making multiple clones of %qD
zh_CN: %qD做了多次复本

en: malformed %<#pragma %s%>, ignored
zh_CN: %<#pragma %s%>格式错误，已忽略

en: malformed %<#pragma align%>
zh_CN: %<#pragma align%>格式错误

en: malformed %<#pragma align%>, ignoring
zh_CN: %<#pragma align%>格式错误 - 已忽略

en: malformed %<#pragma fini%>
zh_CN: %<#pragma fini%>格式错误

en: malformed %<#pragma fini%>, ignoring
zh_CN: %<#pragma fini%>格式错误 - 已忽略

en: malformed %<#pragma init%>
zh_CN: %<#pragma init%>格式错误

en: malformed %<#pragma init%>, ignoring
zh_CN: %<#pragma init%>格式错误 - 已忽略

en: malformed %<#pragma message%>, ignored
zh_CN: %<#pragma message%>格式错误，已忽略

en: malformed %<#pragma pack%> - ignored
zh_CN: %<#pragma pack%>格式错误 - 已忽略

en: malformed %<#pragma pack(pop[, id])%> - ignored
zh_CN: %<#pragma pack(pop[, id])%>格式错误 - 已忽略

en: malformed %<#pragma pack(push[, id][, <n>])%> - ignored
zh_CN: %<#pragma pack(push[, id][, <n>])%>格式错误 - 已忽略

en: malformed ptx file
zh_CN: 格式错误的 ptx 文件

en: malformed spec function arguments
zh_CN: spec 函数参数格式错误

en: malformed spec function name
zh_CN: spec 函数名格式错误

en: mangling %C
zh_CN: 修饰 %C

en: mask must be an immediate
zh_CN: 掩码必须是一个立即数

en: matching constraint does not allow a register
zh_CN: 匹配的约束不允许使用寄存器

en: matching constraint not valid in output operand
zh_CN: 匹配的约束在输出操作数中无效

en: matching constraint references invalid operand number
zh_CN: 匹配的约束引用了无效的操作数号

en: may not use both -EB and -EL
zh_CN: 不能同时使用 -EB 和 -EL

en: may not use both -m32 and -m64
zh_CN: 不能同时使用 -m32 和 -m64

en: member %q+#D with constructor not allowed in anonymous aggregate
zh_CN: 有构造函数的成员%q+#D不允许在匿名聚合中出现

en: member %q+#D with constructor not allowed in union
zh_CN: 有构造函数的成员%q+#D不能用在联合中

en: member %q+#D with copy assignment operator not allowed in anonymous aggregate
zh_CN: 有拷贝赋值运算符的成员%q+#D不能用在联合中

en: member %q+#D with copy assignment operator not allowed in union
zh_CN: 有拷贝赋值运算符的成员%q+#D不能用在联合中

en: member %q+#D with destructor not allowed in anonymous aggregate
zh_CN: 有构构函数的成员%q+#D不允许在匿名聚合中出现

en: member %q+#D with destructor not allowed in union
zh_CN: 有析构函数的成员%q+#D不能用在联合中

en: member %qD declared as friend before type %qT defined
zh_CN: 成员%qD在类型%qT被定义之前声明为友元

en: member %qD is uninitialized reference
zh_CN: 成员%qD是未初始化的引用

en: member functions are implicitly friends of their class
zh_CN: 成员函数隐式地成为所属类的友元

en: memory input %d is not directly addressable
zh_CN: 内存输入 %d 不可直接寻址

en: method declaration not in @interface context
zh_CN: 方法声明不在@interface 上下文中

en: method definition for %<%c%E%> not found
zh_CN: 找不到%<%c%E%>的方法定义

en: method definition not in @implementation context
zh_CN: 方法定义不在 @implementation 上下文中

en: method possibly missing a [super dealloc] call
zh_CN: 方法可能缺少一个 [super dealloc] 调用

en: method type does not match object type
zh_CN: 方法类型不匹配对象类型

en: mips16 function profiling
zh_CN: mips16 函数取样

en: mismatched declarations during linktime optimization
zh_CN: 链接时优化中的不匹配的声明

en: misplaced %<@%D%> Objective-C++ construct
zh_CN: 位置错误的%<@%D%>Objective-C++ 构造

en: missing $ operand number in format
zh_CN: 格式字符串缺少 $ 操作数号

en: missing %<(%> after %<#pragma GCC visibility push%> - ignored
zh_CN: %<#pragma GCC visibility push%>缺少%<(%>- 已忽略

en: missing %<(%> after %<#pragma pack%> - ignored
zh_CN: %<#pragma pack%>后缺少%<(%>，忽略

en: missing argument to %qs
zh_CN: %qs缺少参数

en: missing barrier after block %i
zh_CN: 块 %i 后缺少屏障

en: missing braces around initializer
zh_CN: 初始值设定周围缺少花括号

en: missing braces around initializer for %qT
zh_CN: %qT的初始值设定周围缺少花括号

en: missing callgraph edge for call stmt:
zh_CN: 调用语句缺少 callgraph 边：

en: missing close brace for named operand
zh_CN: 有名操作数后缺少右花括号

en: missing close paren
zh_CN: 缺少右括号

en: missing controlling predicate
zh_CN: 缺少控制谓词

en: missing definition
zh_CN: 定义缺失

en: missing edge %i->%i
zh_CN: 缺少边 %i->%i

en: missing filename after %qs
zh_CN: %qs后缺少文件名

en: missing fill character at end of strfmon format
zh_CN: strfmon 格式字符串末尾缺少填充字符

en: missing increment expression
zh_CN: 缺少自增语句

en: missing initializer for member %qD
zh_CN: 成员%qD缺少初始值设定

en: missing makefile target after %qs
zh_CN: %qs后缺少 makefile 目标

en: missing method %s%s%s
zh_CN: 缺少方法%s%s%s

en: missing module name
zh_CN: 缺少模块名称

en: missing number
zh_CN: 缺少数字

en: missing open paren
zh_CN: 缺少左括号

en: missing operand
zh_CN: 缺少操作数

en: missing option after %<#pragma GCC diagnostic%> kind
zh_CN: %<#pragma GCC diagnostic%>后选项缺失

en: missing path after %qs
zh_CN: %qs后缺少路径

en: missing sentinel in function call
zh_CN: 函数调用中缺少哨兵

en: missing terminating %c character
zh_CN: 缺少结尾的 %c 字符

en: missing type-name in typedef-declaration
zh_CN: typedef 声明中缺少类型名

en: mixing declarations and function-definitions is forbidden
zh_CN: 不能混合声明和函数定义

en: mode %qs applied to inappropriate type
zh_CN: 对不合适的类型应用模式%qs

en: more than %d operands in %<asm%>
zh_CN: %<asm%>中的操作数超过 %d 个

en: multidimensional array must have bounds for all dimensions except the first
zh_CN: 声明多维数组必须至少指定除第一维以外所有维的大小

en: multiple default labels in one switch
zh_CN: 单个 switch 语句中出现了多个 default 标号

en: multiple definition of %q#T
zh_CN: %q#T多次定义

en: multiple fields in union %qT initialized
zh_CN: 初始化了联合%qT中的多个字段

en: multiple function type attributes specified
zh_CN: 指定了多个函数类型属性

en: multiple hot/cold transitions found (bb %i)
zh_CN: 发现多个热/冷转换(基本块 %i)

en: multiple initializations given for %qD
zh_CN: 为%qD给定了多个初始值设定

en: multiple initializations given for base %qT
zh_CN: 为基类%qT给定了多个初始值设定

en: multiple inline callers
zh_CN: 多个内联调用者

en: multiple interrupt attributes not allowed
zh_CN: 不允许多个中断属性

en: multiple methods named %<%c%E%> found
zh_CN: 多个名为%<%c%E%>的方法

en: multiple parameters named %qD
zh_CN: 多个名为%qD的形参

en: multiple selectors named %<%c%E%> found
zh_CN: 多个名为%<%c%E%>的选择子

en: multiple storage classes in declaration of %qs
zh_CN: %qs的声明指定了多个存储类

en: multiple storage classes in declaration specifiers
zh_CN: 声明指定了多个存储类

en: multiple types in one declaration
zh_CN: 一个声明指定了多个类型

en: must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>
zh_CN: 必须用%<.*%>or%<->*%>调用%<%E (...)%>中的成员函数指针，例如%<(... ->* %E) (...)%>

en: name %qD used in a GNU-style designated initializer for an array
zh_CN: 名字%qD用在 GNU 风格的数组指定元素初始值设定中

en: name %qT has incomplete type
zh_CN: 名字%qT类型不完全

en: name missing for member function
zh_CN: 成员函数没有名字

en: name of class shadows template template parameter %qD
zh_CN: 类名隐藏了模板的模板形参%qD

en: name used in a GNU-style designated initializer for an array
zh_CN: 名字被用在 GNU 风格的数组指定元素初始值设定中

en: named return values are no longer supported
zh_CN: 有名返回值不再被支持

en: namespace alias %qD not allowed here, assuming %qD
zh_CN: 这里不允许命名空间别名%qD，假定为%qD

en: namespace-scope anonymous aggregates must be static
zh_CN: 命名空间域的匿名聚合必须是静态的

en: need %<typename%> before %<%T::%E%> because %qT is a dependent scope
zh_CN: %<%T::%E%>之前需要%<typename%>，因为%qT是一个有依赖的作用域

en: need %<typename%> before %qE because %qT is a dependent scope
zh_CN: %qE之前需要%<typename%>，因为%qT是一个有依赖的作用域

en: need explicit conversion
zh_CN: 需要显式转换

en: need explicit conversion; missing method %s%s%s
zh_CN: 需要显式转换；缺少方法%s%s%s

en: negative insn length
zh_CN: 指令长度为负

en: negative integer implicitly converted to unsigned type
zh_CN: 负整数隐式转换为无符号类型

en: negative nesting depth of region %i
zh_CN: 区域 %i 的嵌套深度为负

en: negative shift count
zh_CN: 移位次数为负

en: negative width in bit-field %q+D
zh_CN: 位段%q+D宽度为负

en: negative width in bit-field %qs
zh_CN: 位段%qs宽度为负

en: nested assembly dialect alternatives
zh_CN: 嵌套的汇编风格指示

en: nested extern declaration of %qD
zh_CN: 对%qD的嵌套的外部声明

en: nested function %q+D declared but never defined
zh_CN: 嵌套函数%q+D声明过但从未定义

en: nested function %qE declared %<extern%>
zh_CN: 嵌套函数%qE被声明为%<extern%>

en: nested function %qs declared %<extern%>
zh_CN: 嵌套函数%qs被声明为%<extern%>

en: nested function trampolines not supported on this target
zh_CN: 嵌套函数蹦床在此目标机上不受支持

en: nested functions not supported on this target
zh_CN: 嵌套函数在此目标机上不受支持

en: nested redefinition of %<enum %E%>
zh_CN: 嵌套的%<enum %E%>重定义

en: nested redefinition of %<struct %E%>
zh_CN: 嵌套的%<struct %E%>重定义

en: nested redefinition of %<union %E%>
zh_CN: 嵌套的%<union %E%>重定义

en: new cannot be applied to a function type
zh_CN: new 不能用于函数类型

en: new cannot be applied to a reference type
zh_CN: new 不能用于引用类型

en: new in Fortran 2003
zh_CN: 在 Fortran 2003 中新增

en: new in Fortran 2008
zh_CN: 在 Fortran 2008 中新增

en: new in Fortran 2018
zh_CN: 在 Fortran 2018 中新增

en: new in Fortran 95
zh_CN: 在 Fortran 95 中新增

en: new types may not be defined in a return type
zh_CN: 不能在返回类型中定义新类型

en: no %<%D(int)%> declared for postfix %qs
zh_CN: 没有为后缀%2$qs声明%<%1$D(int)%>

en: no %<%D(int)%> declared for postfix %qs, trying prefix operator instead
zh_CN: %<%D(int)%>没有出现在后缀%qs中，尝试使用前缀运算符

en: no %<%c%E%> method found
zh_CN: 找不到方法%<%c%E%>

en: no %q#D member function declared in class %qT
zh_CN: 成员函数%q#D未在类%qT中声明

en: no %qs getter found
zh_CN: 找不到 %qs 的取值器

en: no arguments
zh_CN: 没有参数

en: no arguments for spec function
zh_CN: spec 函数没有参数

en: no class name specified with %qs
zh_CN: %qs没有指定类名

en: no class template named %q#T in %q#T
zh_CN: 没有名为%q#T的类模板，在%q#T中

en: no closing %<]%> for %<%%[%> format
zh_CN: %<%%[%>格式没有相应的%<]%>

en: no context to resolve type of %qE
zh_CN: 缺少用以解析%qE类型的上下文

en: no corresponding deallocation function for %qD
zh_CN: %qD没有相应的释放函数

en: no data type for mode %qs
zh_CN: 没有模式为%qs的数据类型

en: no default argument for %qD
zh_CN: %qD没有默认参数

en: no field %qD found in union being initialized
zh_CN: 在初始化的联合中找不到字段%qD

en: no immediate_use list
zh_CN: 没有 immediate_use 列表

en: no input files
zh_CN: 没有输入文件

en: no input files; unwilling to write output files
zh_CN: 没有输入文件；不能写入输出文件

en: no integral type can represent all of the enumerator values for %qT
zh_CN: 没有一个整数类型可以表示%qT的所有枚举值

en: no low registers available for popping high registers
zh_CN: 高寄存器弹栈时没有可用的低寄存器

en: no match for call to %<(%T) (%A)%>
zh_CN: 对%<(%T) (%A)%>的调用没有匹配

en: no matches converting function %qD to type %q#T
zh_CN: 没有可将函数%qD转换到类型%q#T的匹配项

en: no matching function for call to %<%D(%A)%>
zh_CN: 对%<%D(%A)%>的调用没有匹配的函数

en: no matching push for %<#pragma GCC visibility pop%>
zh_CN: 没有与%<#pragma GCC visibility pop%>对应的 push

en: no matching template for %qD found
zh_CN: 没有找到与%qD匹配的模板

en: no member function %qD declared in %qT
zh_CN: 成员函数%qD未在%qT中声明

en: no post-decrement operator for type
zh_CN: 类型没有后自减运算符

en: no post-increment operator for type
zh_CN: 类型没有后自增运算符

en: no pre-decrement operator for type
zh_CN: 类型没有前自减运算符

en: no pre-increment operator for type
zh_CN: 类型没有前自增运算符

en: no previous declaration for %qD
zh_CN: %qD先前没有声明

en: no previous prototype for %qD
zh_CN: %qD先前没有原型

en: no processor type specified for linking
zh_CN: 没有指定链接用的处理器类型

en: no profiling of 64-bit code for this ABI
zh_CN: 此 ABI 不支持取样 64 位代码

en: no register in address
zh_CN: 地址中无寄存器

en: no return statement in function returning non-void
zh_CN: 在有返回值的函数中未发现 return 语句

en: no semicolon at end of struct or union
zh_CN: 结构或联合后没有分号

en: no suitable %<operator %s%> for %qT
zh_CN: 没有合适的%<operator %s%>给%qT

en: no suitable %qD found in class %qT
zh_CN: 找不到合适的%qD，在类%qT中

en: no super class declared in @interface for %qE
zh_CN: 没有为%qE在 @interface 中声明超类

en: no super class declared in interface for %qE
zh_CN: 没有在%qE的接口中声明超类

en: no unique final overrider for %qD in %qT
zh_CN: %qD的最终重载在%qT中不唯一

en: nodes with unreleased memory found
zh_CN: 找到未释放内存的节点

en: non-const integer argument %u in call to function %qE
zh_CN: 给予函数%2$qE的参数%1$u不是整型常量

en: non-constant array in DATA statement %L
zh_CN: %L处 DATA 语句中有非常量数组

en: non-constant condition for static assertion
zh_CN: 静态断言中出现非常量条件

en: non-constant initialization expression at %L
zh_CN: %L处非常量初始化表达式

en: non-floating-point argument in call to function %qE
zh_CN: 给予函数%qE的参数不是浮点数

en: non-floating-point arguments in call to function %qE
zh_CN: 给予函数%qE的参数不是浮点数

en: non-function in gimple call
zh_CN: gimple 调用了非函数

en: non-lvalue array in conditional expression
zh_CN: 非左值数组出现在条件表达式中

en: non-member %qs cannot be declared %<mutable%>
zh_CN: 非成员%qs不能被声明为%<mutable%>

en: non-member function %qD cannot have cv-qualifier
zh_CN: 非成员函数%qD不能拥有 cv 限定符

en: non-memory input %d must stay in memory
zh_CN: 非内存输入 %d 必须在内存中

en: non-nested function with variably modified type
zh_CN: 非嵌套函数有动态可变类型

en: non-object member %qs cannot be declared %<mutable%>
zh_CN: 非对象成员%qs不能被声明为%<mutable%>

en: non-parameter %qs cannot be a parameter pack
zh_CN: 非形参%qs不能是一个参数包

en: non-register as LHS of binary operation
zh_CN: 非寄存器作为二元操作的左操作数

en: non-register as LHS of unary operation
zh_CN: 非寄存器作为单目操作的左操作数

en: non-scalar type
zh_CN: 非标准类型

en: non-standard suffix on floating constant
zh_CN: 非标准的浮点常量后缀

en: non-static declaration of %q+D follows static declaration
zh_CN: 对%q+D的静态声明出现在非静态声明之后

en: non-static initialization of a flexible array member
zh_CN: 对可变数组成员非静态地初始化

en: non-template %qD used as template
zh_CN: 非模板%qD用作模板

en: non-template type %qT used as a template
zh_CN: 非模板类型%qT用作模板

en: non-thread-local declaration of %q#D follows thread-local declaration
zh_CN: %q#D的非线程局部声明出现在其线程局部声明之后

en: non-thread-local declaration of %q+D follows thread-local declaration
zh_CN: %q+D的线程局部声明跟在其非线程局部声明之后

en: non-trivial conversion in unary operation
zh_CN: 单目操作时不平凡的转换

en: non-trivial designated initializers not supported
zh_CN: 不平凡的代理初始值设定不受支持

en: nonconstant array index in initializer
zh_CN: 初始值设定中数组索引不是常数

en: nonempty exits list of loop %d, but exits are not recorded
zh_CN: 循环 %d 退出列表非空，但是退出未被记录

en: normalization cannot co-exist with scaling
zh_CN: 归一化不能和缩放共存，跳过

en: not configured with sysroot headers suffix
zh_CN: 没有配置 sysroot 头文件后缀

en: not enough arguments
zh_CN: 实参太少

en: not enough type information
zh_CN: 类型信息不充分

en: not enough variable arguments to fit a sentinel
zh_CN: 变量实参太少，不足以填满一个哨兵

en: note
zh_CN: 附注

en: note:
zh_CN: 附注：

en: null pointer
zh_CN: 空指针

en: number must be 0 or 1
zh_CN: 数字必须是 0 或 1

en: number of arguments doesn%'t match built-in prototype
zh_CN: 实参个数与内建原型不符

en: number of arguments doesn%'t match prototype
zh_CN: 实参数目与原型不符

en: number of bb notes in insn chain (%d) != n_basic_blocks (%d)
zh_CN: 指令链中记录的基本块数 (%d) != n_basic_blocks (%d)

en: number of results does not match number of values
zh_CN: 返回值的数量不匹配值的数量

en: objc++-cpp-output is deprecated; please use objective-c++-cpp-output instead
zh_CN: objc++-cpp-output 已被弃用；请使用 objective-c++-cpp-output 作为替代

en: objc-cpp-output is deprecated; please use objective-c-cpp-output instead
zh_CN: objc-cpp-output 已被弃用；请使用 objective-c-cpp-output 作为替代

en: object is not a method
zh_CN: 对象不是一个方法

en: object missing in use of %qE
zh_CN: 使用%qE时缺少对象

en: object type %qT does not match destructor name ~%qT
zh_CN: 对象类型%qT的析构函数名~%qT不匹配

en: object with variably modified type must have no linkage
zh_CN: 可变类型对象不能有外部链接

en: obsolete use of designated initializer with %<:%>
zh_CN: 使用%<:%>来指定元素初始值的作法已过时

en: obsolete use of designated initializer without %<=%>
zh_CN: 过时的用法，应使用%<=%>来指定元素初始值

en: old-style function definition
zh_CN: 旧式的函数定义

en: old-style parameter declarations in prototyped function definition
zh_CN: 原型函数定义中使用了旧式参数声明

en: omitted middle operand to %<?:%> operand cannot be mangled
zh_CN: 省略的%<?:%>中操作数不能被修饰

en: only 0.0 can be loaded as an immediate
zh_CN: 只有 0.0 可以作为立即数装载

en: only weak aliases are supported in this configuration
zh_CN: 此配置下只支持弱别名

en: opaque vector types cannot be initialized
zh_CN: 不透明的向量类型不能被初始化

en: open %s failed: %s
zh_CN: 打开 %s 失败：%s

en: open /dev/zero: %m
zh_CN: 打开 /dev/zero：%m

en: opening LTRANS output list %s: %m
zh_CN: 打开 LTRANS 输出列表 %s：%m

en: opening dependency file %s: %m
zh_CN: 打开依赖文件 %s：%m

en: opening output file %s: %m
zh_CN: 打开输出文件 %s：%m

en: operand constraint contains incorrectly positioned %<+%> or %<=%>
zh_CN: 操作数约束包括位置不当的%<+%>或%<=%>

en: operand constraints for %<asm%> differ in number of alternatives
zh_CN: %<asm%>的操作数约束备选数不一致

en: operand is not a condition code, invalid operand code 'D'
zh_CN: 操作数不是一个条件码，无效的操作数代码‘D’

en: operand is not a condition code, invalid operand code 'Y'
zh_CN: 操作数不是一个条件码，无效的操作数代码‘Y’

en: operand number missing after %%-letter
zh_CN: %% 字母后缺少操作数号

en: operand number out of range
zh_CN: 操作数号超出范围

en: operand number out of range in format
zh_CN: 格式字符中操作数号越界

en: operand number specified for format taking no argument
zh_CN: 为格式字符串指定的操作数号不带参数

en: operand number specified with suppressed assignment
zh_CN: 为格式字符串指定的操作数号取消了赋值

en: operation on %qE may be undefined
zh_CN: %qE上的运算结果可能是未定义的

en: optimization level attribute mismatch
zh_CN: 优化等级属性不匹配

en: optimization may eliminate reads and/or writes to register variables
zh_CN: 优化可能会去除对寄存器变量的读写

en: optional argument
zh_CN: 可选参数

en: ordered comparison of pointer with integer zero
zh_CN: 指针与整数 0 比较大小

en: original definition appeared here
zh_CN: 原始定义在此

en: originally defined here
zh_CN: 原先在这里定义

en: originally indirect function call not considered for inlining
zh_CN: 原本间接的函数调用不被考虑内联

en: originally specified here
zh_CN: 原先在这里定义

en: outer block of region %i is wrong
zh_CN: 区域 %i 的外围块错误

en: output constraint %d must specify a single register
zh_CN: 输出约束 %d 必须指定单个寄存器

en: output constraint %qc for operand %d is not at the beginning
zh_CN: 输出约束%qc(对操作数 %d)没有出现在开头

en: output filename specified twice
zh_CN: 输出文件名指定了两次

en: output number %d not directly addressable
zh_CN: 输出数 %d 不可直接寻址

en: output operand %d must use %<&%> constraint
zh_CN: 输出操作数 %d 必须使用%<&%>约束

en: output operand constraint lacks %<=%>
zh_CN: 输出操作数约束缺少%<=%>

en: output operand is constant in %<asm%>
zh_CN: %<asm%>的输出操作数是常量

en: output_move_single:
zh_CN: output_move_single：

en: overflow in array dimension
zh_CN: 数组维数溢出

en: overflow in constant expression
zh_CN: 常量表达式溢出

en: overflow in enumeration values
zh_CN: 枚举值溢出

en: overflow in enumeration values at %qD
zh_CN: %qD处枚举值溢出

en: overflow in implicit constant conversion
zh_CN: 隐式常量转换溢出

en: overloaded function with no contextual type information
zh_CN: 被重载的函数缺少上下文信息

en: packed attribute causes inefficient alignment
zh_CN: packed 属性导致低效率的对齐

en: packed attribute causes inefficient alignment for %q+D
zh_CN: packed 属性导致%q+D低效率的对齐

en: packed attribute causes inefficient alignment for %qE
zh_CN: packed 属性导致%qE低效率的对齐

en: packed attribute is unnecessary
zh_CN: 不需要 packed 属性

en: packed attribute is unnecessary for %q+D
zh_CN: packed 属性对%q+D来说是不需要的

en: packed attribute is unnecessary for %qE
zh_CN: packed 属性对%qE来说是不需要的

en: padding struct to align %q+D
zh_CN: 填补结构以对齐%q+D

en: parameter %P has incomplete type %qT
zh_CN: 形参 %P 的类型%qT不完全

en: parameter %P of %qD has incomplete type %qT
zh_CN: %2$qD的第 %1$P 个形参的类型%3$qT不完全

en: parameter %q+D declared %<inline%>
zh_CN: 形参%q+D声明为%<inline%>

en: parameter %q+D has just a forward declaration
zh_CN: 形参%q+D有一个前向声明

en: parameter %qD declared with void type
zh_CN: 形参%qD被声明为有 void 类型

en: parameter %qD has incomplete type
zh_CN: 形参%qD类型不完全

en: parameter %qD includes pointer to array of unknown bound %qT
zh_CN: 形参%qD包含了指向具有未知边界数组%qT的指针

en: parameter %qD includes reference to array of unknown bound %qT
zh_CN: 形参%qD包含了指向具有未知边界数组%qT的引用

en: parameter %qD invalidly declared method type
zh_CN: 形参%qD被无效地被声明为具有方法类型

en: parameter %qD is initialized
zh_CN: 形参%qD已初始化

en: parameter %qD set but not used
zh_CN: 形参%qD被设定但未被使用

en: parameter %u (%q+D) has incomplete type
zh_CN: 形参 %u (%q+D) 的类型不完全

en: parameter %u (%q+D) has void type
zh_CN: 形参 %u (%q+D)类型为 void

en: parameter %u has incomplete type
zh_CN: 形参 %u 的类型不完全

en: parameter %u has void type
zh_CN: 第 %u 个参数类型为 void

en: parameter declared %<auto%>
zh_CN: 形参声明为%<auto%>

en: parameter may not have variably modified type %qT
zh_CN: 参数不能具有可变类型%qT

en: parameter name missing from parameter list
zh_CN: 形参列表中缺少形参名

en: parameter names (without types) in function declaration
zh_CN: 函数声明中出现形参名却未指定类型

en: parameter pack argument %qE must be at the end of the template argument list
zh_CN: 参数包实参%qE必须出现在模板实参表末尾

en: parameter pack argument %qT must be at the end of the template argument list
zh_CN: 参数包实参%qT必须出现在模板实参表末尾

en: parameter packs not expanded with %<...%>:
zh_CN: 参数包未能在%<...%>中被展开：

en: parentheses around %qE cannot be used to form a pointer-to-member-function
zh_CN: %qE两边的括号不能用来构造一个成员函数指针

en: parenthesized initialization is not allowed in OpenMP %<for%> loop
zh_CN: 括起的初始化不允许使用在 OpenMP %<for%>循环中

en: parse error in template argument list
zh_CN: 模板实参表语法错误

en: partial specialization %qT declared %<friend%>
zh_CN: 部分特例化模板%qT声明为%<friend%>

en: pass %qs not found but is referenced by new pass %qs
zh_CN: 找不到趟处理%qs，但却被新的趟处理%qs所引用

en: pass %s does not support cloning
zh_CN: 过程 %s 不支持克隆

en: passing %qT chooses %qT over %qT
zh_CN: 传递%qT时选择%qT而不是%qT

en: passing NULL to non-pointer argument %P of %qD
zh_CN: 将 NULL 作为非指针实参 %P 传递给%qD

en: passing argument %d of %qE as %<float%> rather than %<double%> due to prototype
zh_CN: 根据原型，实参 %d (%qE) 将作为%<float%>而不是%<double%>传递

en: passing argument %d of %qE as %qT rather than %qT due to prototype
zh_CN: 根据原型，实参 %d (%qE)将作为%qT而不是%qT传递

en: passing argument %d of %qE as complex rather than floating due to prototype
zh_CN: 根据原型，实参 %d (%qE) 将作为复数而不是浮点数传递

en: passing argument %d of %qE as complex rather than integer due to prototype
zh_CN: 根据原型，实参 %d (%qE) 将作为复数而不是整数传递

en: passing argument %d of %qE as floating rather than complex due to prototype
zh_CN: 根据原型，实参 %d (%qE) 将作为浮点数而不是复数传递

en: passing argument %d of %qE as floating rather than integer due to prototype
zh_CN: 根据原型，实参 %d (%qE) 将作为浮点数而不是整数传递

en: passing argument %d of %qE as integer rather than complex due to prototype
zh_CN: 根据原型，实参 %d (%qE) 将作为整数而不是复数传递

en: passing argument %d of %qE as integer rather than floating due to prototype
zh_CN: 根据原型，实参 %d (%qE) 将作为整数而不是浮点数传递

en: passing argument %d of %qE as signed due to prototype
zh_CN: 根据原型，实参 %d (%qE) 将作为有符号数传递

en: passing argument %d of %qE as unsigned due to prototype
zh_CN: 根据原型，实参 %d (%qE) 将作用无符号数传递

en: passing argument %d of %qE from distinct Objective-C type
zh_CN: 从不同的 Objective-C 类型传递%2$qE的第 %1$d 个参数

en: passing argument %d of %qE from incompatible pointer type
zh_CN: 传递%2$qE的第 %1$d 个参数时在不兼容的指针类型间转换

en: passing argument %d of %qE from pointer to non-enclosed address space
zh_CN: 传递%2$qE的第 %1$d 个参数时从指针转换为未被包围的地址空间

en: passing argument %d of %qE makes integer from pointer without a cast
zh_CN: 传递%2$qE的第 %1$d 个参数时将指针赋给整数，未作类型转换

en: passing argument %d of %qE makes pointer from integer without a cast
zh_CN: 传递%2$qE的第 %1$d 个参数时将整数赋给指针，未作类型转换

en: passing argument %d of %qE with different width due to prototype
zh_CN: 根据原型，实参 %d (%qE) 将以不同的宽度传递

en: path:
zh_CN: 路径：

en: pedwarn
zh_CN: 保守警告

en: pedwarn:
zh_CN: 保守警告：

en: permerror
zh_CN: 永久错误

en: permerror:
zh_CN: 永久错误：

en: plugin %s is not licensed under a GPL-compatible license
    %s
zh_CN: 插件 %s 带有与 GPL 不兼容的许可
    %s

en: plugin cannot register a missing pass
zh_CN: 插件无法注册一趟缺失的处理

en: plugin cannot register an unnamed pass
zh_CN: 插件不能注册一趟无名处理

en: plugin cannot register pass %qs without reference pass name
zh_CN: 插件不能不引用处理名就注册一趟处理%qs

en: pointer
zh_CN: 指针

en: pointer arithmetic for garbage-collected objects not allowed
zh_CN: 不允许在被垃圾收集的对象上进行指针算术运算

en: pointer assignment
zh_CN: 指针赋值

en: pointer of type %<void *%> used in arithmetic
zh_CN: %<void *%>型指针用在了算术表达式中

en: pointer of type %<void *%> used in subtraction
zh_CN: 在减法中使用类型为%<void *%>的指针

en: pointer target types incompatible in C++
zh_CN: 指针目标类型在 C++ 中不兼容

en: pointer targets in passing argument %d of %qE differ in signedness
zh_CN: 传递%2$qE的第 %1$d 个参数给指针时，目标与指针符号不一致

en: pointer to a function used in arithmetic
zh_CN: 在算术表达式中使用了函数指针

en: pointer to a function used in subtraction
zh_CN: 函数指针不能相减

en: pointer to member conversion via virtual base %qT
zh_CN: 成员指针转换经由虚基类%qT

en: pointer to member type %qT incompatible with object type %qT
zh_CN: 成员指针类型%qT与对象类型%qT不兼容

en: pointer type mismatch in conditional expression
zh_CN: 条件表达式指针类型不匹配

en: pointer value used where a complex was expected
zh_CN: 需要复数时使用了指针值

en: pointer/integer type mismatch in conditional expression
zh_CN: 条件表达式中指针/整数类型不匹配

en: pointers are not permitted as case values
zh_CN: 指针不能用作 case 常量

en: pointers to disjoint address spaces used in conditional expression
zh_CN: 条件表达式中使用了指向不相交地址空间的指针

en: post-increment address is not a register
zh_CN: 后自增地址不是一个寄存器

en: postfix %qD should return %qT
zh_CN: 后缀%qD应当返回%qT

en: pre-decrement address is not a register
zh_CN: 前自减地址不是一个寄存器

en: pre-increment address is not a register
zh_CN: 前自增地址不是一个寄存器

en: precision
zh_CN: 精度

en: precision in printf format
zh_CN: printf 格式的精度

en: predicated Thumb instruction
zh_CN: 预测到的 Thumb 指令

en: predicated instruction in conditional sequence
zh_CN: 在条件序列中预测到的指令

en: prefix %qD should return %qT
zh_CN: 前缀%qD应当返回%qT

en: prev_bb of %d should be %d, not %d
zh_CN: %d 的 prev_bb 应该为 %d，而不是 %d

en: previous declaration
zh_CN: 上一个声明

en: previous declaration of %<%c%s%>
zh_CN: %<%c%s%>的上一个声明

en: previous declaration of %q+D
zh_CN: %q+D的前一个声明

en: previous declaration of %qE
zh_CN: %qE的上一个声明

en: previous definition here
zh_CN: 先前的定义在这里

en: previously declared here
zh_CN: 以前在此声明过

en: previously defined here
zh_CN: 以前在此定义过

en: previously used here
zh_CN: 已在这里使用过

en: profiler support for VxWorks
zh_CN: 对 VxWorks 的取样支持

en: profiling not supported with -mg
zh_CN: 取样不支持 -mg

en: programs: %s
zh_CN: 程序：%s

en: promoted argument %qD doesn%'t match built-in prototype
zh_CN: 提升后的实参%qD与内建原型不符

en: promoted argument %qD doesn%'t match prototype
zh_CN: 提升后的实参%qD与原型不符

en: protocol %qE has circular dependency
zh_CN: 协议%qE存在循环依赖

en: protocol %qE is deprecated
zh_CN: 已弃用协议%qE

en: protocol %qE is unavailable
zh_CN: 协议 %qE 不可用

en: prototype declaration
zh_CN: 原型声明

en: prototype for %q+D declares argument %d with incompatible type
zh_CN: %q+D的原型对实参 %d 声明类型不兼容

en: prototype for %q+D declares fewer arguments than previous old-style definition
zh_CN: %q+D的原型声明的参数少于先前旧式的定义

en: prototype for %q+D declares more arguments than previous old-style definition
zh_CN: %q+D的原型声明的参数多于先前旧式的定义

en: prototype for %q+D follows non-prototype definition
zh_CN: %q+D的原型出现在非原型定义之后

en: pseudo-destructor is not called
zh_CN: 伪析构函数未被调用

en: pure-specifier on function-definition
zh_CN: 函数定义上有 pure 指定

en: qualified type %qT does not match destructor name ~%qT
zh_CN: 限定的类型%qT不匹配析构函数名 ~%qT

en: qualifiers are not allowed on declaration of %<operator %T%>
zh_CN: %<operator %T%>的声明中不能使用限定符

en: qualifying type %qT does not match destructor name ~%qT
zh_CN: 限定类型%qT不匹配析构函数名 ~%qT

en: r0 needs to be available as a call-clobbered register
zh_CN: r0 需要用作调用篡改的寄存器

en: range expressions in switch statements are non-standard
zh_CN: 在 switch 语句中使用范围表达式不符合标准

en: rdynamic is not supported
zh_CN: 不支持 rdynamic

en: read-only location %qE used as %<asm%> output
zh_CN: 只读位置%qE用作%<asm%>的输出

en: read-only member %qD used as %<asm%> output
zh_CN: 只读成员%qD用作%<asm%>的输出

en: read-only variable %qD used as %<asm%> output
zh_CN: 只读变量%qD被用作%<asm%>的输出

en: reading through null pointer (argument %d)
zh_CN: 对空指针指向内容的读操作(实参 %d)

en: recursive evaluation of default argument for %q#D
zh_CN: 递归计算%q#D的默认参数

en: recursive inlining
zh_CN: 递归内联

en: recursive type %qT undefined
zh_CN: 递归的类型%qT未定义

en: redeclaration of %<enum %E%>
zh_CN: %<enum %E%>重声明

en: redeclaration of %q#D
zh_CN: %q#D重声明

en: redeclaration of %q+D with different visibility (old visibility preserved)
zh_CN: 对%q+D的再次声明中指定了不同的可见性 (保留原有的可见性)

en: redeclaration of %q+D with no linkage
zh_CN: %q+D重声明为没有外部链接

en: redeclaration of %qT as a non-template
zh_CN: %qT重声明为非模板

en: redeclaration of C++ built-in type %qT
zh_CN: 对 C++ 内建类型%qT的重声明

en: redeclaration of enumerator %q+D
zh_CN: 枚举%q+D重声明

en: redeclaration of friend %q#D may not have default template arguments
zh_CN: 友元%q#D的重声明不能有默认模板参数

en: redeclaration of property %qD
zh_CN: 属性 %qD 重声明

en: redeclared here as %q#D
zh_CN: 在这里又被声明为%q#D

en: redeclared with %d template parameter | redeclared with %d template parameters
zh_CN[0]: 重声明为具有 %d 个模板参数

en: redefined extern inline functions are not considered for inlining
zh_CN: 不考虑内联重定义的外部内联函数

en: redefinition of %<struct %E%>
zh_CN: %<struct %E%>重定义

en: redefinition of %<union %E%>
zh_CN: %<union %E%>重定义

en: redefinition of %q#D
zh_CN: %q#D 重定义

en: redefinition of %q#T
zh_CN: %q#T重定义

en: redefinition of %q+D
zh_CN: %q+D重定义

en: redefinition of parameter %q+D
zh_CN: 形参%q+D重定义

en: redefinition of typedef %q+D
zh_CN: typedef%q+D重定义

en: redefinition of typedef %q+D with different type
zh_CN: typedef%q+D重定义时具有不同类型

en: redundant redeclaration of %q+D
zh_CN: 对%q+D冗余的重声明

en: redundant redeclaration of %qD in same scope
zh_CN: 同一作用域中%qD冗余的重声明

en: reference to %<%T::%D%> is ambiguous
zh_CN: 对%<%T::%D%>的引用有歧义

en: reference to %qD is ambiguous
zh_CN: 对%qD的引用有歧义

en: region of lp %i is wrong
zh_CN: 区域 %i 的 lp 错误

en: register name given for non-register variable %q+D
zh_CN: 为非寄存器变量%q+D给定了寄存器名

en: register name not specified for %q+D
zh_CN: %q+D的寄存器名无效

en: register specified for %q+D isn%'t suitable for data type
zh_CN: 为%q+D指定的寄存器不适合此数据类型

en: register variable %qD used in nested function
zh_CN: 嵌套函数中使用了寄存器变量%qD

en: reimplementation of class %qE
zh_CN: 类 %qE 的重新实现

en: rename spec %s to %s
zh_CN: 将 spec %s 重命名为 %s

en: repeated %s in format
zh_CN: 格式字符串中有重复的 %s

en: request for implicit conversion from %qT to %qT not permitted in C++
zh_CN: C++ 中不允许从%qT到%qT的隐式转换

en: request for member %qD in %qE, which is of non-class type %qT
zh_CN: 对成员%qD的请求出现在%qE中，而后者具有非类类型%qT

en: request for member %qD is ambiguous
zh_CN: 对成员%qD的请求有歧义

en: request for member %qD is ambiguous in multiple inheritance lattice
zh_CN: 在多继承网格中对%qD的访问有歧义

en: request for member %qE in non-class type %qT
zh_CN: 在非类类型%2$qT中请求成员%1$qE

en: request for member %qE in something not a structure or union
zh_CN: 在非结构或联合中请求成员%qE

en: requested alignment for %q+D is greater than implemented alignment of %wu
zh_CN: %q+D需要的对齐边界大于实现的对齐边界 %wu

en: requested alignment is too large
zh_CN: 要求的对齐边界太大

en: requested position is less than zero
zh_CN: 要求的位置小于 0

en: requested position is not an integer constant
zh_CN: 要求的位置不是一个整数常量

en: result of %<operator->()%> yields non-pointer result
zh_CN: %<operator->()%>的结果给出了非指针的结果

en: return edge does not point to exit in bb %d
zh_CN: 基本块 %d 中，返回边并不指向退出

en: return from pointer to non-enclosed address space
zh_CN: 返回时将指针赋值给未被包围的地址空间

en: return not followed by barrier
zh_CN: return 后没有屏障

en: return type %q#T is incomplete
zh_CN: 返回值类型%q#T不完全

en: return type defaults to %<int%>
zh_CN: 返回类型默认为%<int%>

en: return type is an incomplete type
zh_CN: 返回不完全的类型

en: return type might be a candidate for a format attribute
zh_CN: 返回类型可能是 format 属性的备选

en: return type of %qD is not %<int%>
zh_CN: %qD的返回类型不是%<int%>

en: return type specification for constructor invalid
zh_CN: 为构造函数指定返回值无效

en: return type specification for destructor invalid
zh_CN: 指定析构函数的返回类型无效

en: return type specified for %<operator %T%>
zh_CN: 为%<operator %T%>指定了返回值

en: return-statement with no value, in function returning %qT
zh_CN: 在返回%qT的函数中，返回语句不带返回值

en: returning a value from a constructor
zh_CN: 构造函数返回值

en: returning a value from a destructor
zh_CN: 析构函数返回值

en: returning reference to temporary
zh_CN: 返回临时变量的引用

en: right precision
zh_CN: 右精度

en: right precision in strfmon format
zh_CN: strfmon 格式的右精度

en: right shift count >= width of type
zh_CN: 右移次数大于或等于类型宽度

en: right shift count is negative
zh_CN: 右移次数为负

en: rounding mode not supported for VAX floats
zh_CN: 舍入模式不为 VAX 浮点数所支持

en: rv32e requires ilp32e ABI
zh_CN: rv32e 需要 ilp32e ABI

en: rx100 cpu does not have FPU hardware
zh_CN: rx100 cpu 没有 FPU 硬件

en: rx200 cpu does not have FPU hardware
zh_CN: RX200 CPU 没有 FPU 硬件

en: save temporary preprocessed files
zh_CN: 保存临时预处理过的文件

en: saw %d %<template<>%>, need %d for specializing a member function template
zh_CN: 发现 %d 个%<template<>%>，需要 %d 来特例化一个成员函数模板

en: say %<typename %E%> if a type is meant
zh_CN: 如果您想指定类型，请使用%<typename %E%>

en: scalar object %qD requires one element in initializer
zh_CN: 标量对象%qD在初始值设定中需要一个元素

en: scaling cannot co-exist with normalization, skipping
zh_CN: 缩放不能和归一化共存，跳过

en: schedule %<auto%> does not take a %<chunk_size%> parameter
zh_CN: 调度%<auto%>不接受一个%<chunk_size%>参数

en: schedule %<runtime%> does not take a %<chunk_size%> parameter
zh_CN: 调度%<runtime%>不接受一个%<chunk_size%>参数

en: schedule chunk size expression must be integral
zh_CN: 调度块大小表达式必须为整型

en: scope %qT before %<~%> is not a class-name
zh_CN: %<~%>前的作用域%qT不是一个类名

en: second argument of %q+D should be %<char **%>
zh_CN: %q+D的第二个参数类型应该是%<char **%>

en: second argument to %<__builtin_prefetch%> must be a constant
zh_CN: %<__builtin_prefetch%>的第二个实参必须是一个常量

en: second operand to the conditional operator is of type %<void%>, but the third operand is neither a throw-expression nor of type %<void%>
zh_CN: 条件运算符的第二个操作数类型为%<void%>，但第三个操作数既不是异常表达式，也不拥有%<void%>类型

en: second parameter of %<va_start%> not last named argument
zh_CN: %<va_start%>的第二个参数不是最后一个有名参数

en: section anchors must be disabled when toplevel reorder is disabled
zh_CN: 当文件作用域重排序被禁用时也必须禁用节中锚点

en: section attribute cannot be specified for local variables
zh_CN: 不能为局部变量指定节属性

en: section attribute not allowed for %q+D
zh_CN: %q+D不能有 section 属性

en: section attributes are not supported for this target
zh_CN: 此目标机不支持节属性

en: section of %q+D cannot be overridden
zh_CN: 节%q+D无法被重载

en: section of %q+D conflicts with previous declaration
zh_CN: %q+D的节与早先的声明冲突

en: segmentation fault
zh_CN: 段错误

en: segmentation fault (code)
zh_CN: 段错误（代码）

en: selector must be an immediate
zh_CN: 选择子必须是立即数

en: setting core file size limit to maximum: %m
zh_CN: 将核心文件大小上限设为最大值：%m

en: shadowed declaration is here
zh_CN: 被隐藏的声明在这里

en: shadowing built-in function %q#D
zh_CN: 隐藏了内建函数%q#D

en: shadowing library function %q#D
zh_CN: 隐藏了库函数%q#D

en: shadowing previous type declaration of %q#D
zh_CN: 隐藏了早先的类型声明%q#D

en: shared and mdll are not compatible
zh_CN: shared 和 mdll 互不兼容

en: shared call_stmt:
zh_CN: 共享的 call_stmt：

en: shared is not supported
zh_CN: 不支持 shared

en: shared rtx
zh_CN: 共享的 rtx

en: signedness of type and machine mode %qs don%'t match
zh_CN: 类型的符号与机器模式%qs不匹配

en: simple IF
zh_CN: 简单的 IF

en: size in array new must have integral type
zh_CN: 数组 new 的大小必须有整数类型

en: size of array %qD has non-integral type %qT
zh_CN: 数组%qD的大小具有非整数类型%qT

en: size of array %qD is not an integral constant-expression
zh_CN: 数组%qD的大小不是一个整数常表达式

en: size of array %qE has non-integer type
zh_CN: 数组%qE的大小的类型不是整数

en: size of array %qE is negative
zh_CN: 数组%qE的大小为负

en: size of array %qE is too large
zh_CN: 数组%qE太大

en: size of array has non-integral type %qT
zh_CN: 数组%qT的大小的类型不是整数

en: size of array is not an integral constant-expression
zh_CN: 数组大小不是一个整数常表达式

en: size of array is too large
zh_CN: 数组太大

en: size of loop %d should be %d, not %d
zh_CN: 循环 %d 的大小应该为 %d，而不是%d

en: size of return value of %q+D is %u bytes
zh_CN: %q+D返回值的大小为 %u 字节

en: size of unnamed array has non-integer type
zh_CN: 无名数组的大小的类型不是整数

en: size of unnamed array is negative
zh_CN: 无名数组的大小为负

en: size of unnamed array is too large
zh_CN: 无名数组太大

en: size of variable %q+D is too large
zh_CN: 变量%q+D的大小太大

en: sizeof(long double) is 12.
zh_CN: sizeof(long double) 等于 12。

en: sizeof(long double) is 16.
zh_CN: sizeof(long double) 等于 16。

en: soft-float and long-double-128 are incompatible
zh_CN: soft-float 与 long-double-128 互不兼容

en: sorry, unimplemented
zh_CN: 对不起，尚未实现

en: sorry, unimplemented:
zh_CN: 对不起，尚未实现：

en: source is a pointer to incomplete type
zh_CN: 源是一个指向不完全类型的指针

en: source is not a pointer
zh_CN: 源不是一个指针

en: source is not a pointer to class
zh_CN: 源不是一个指向类的指针

en: source is not of class type
zh_CN: 源不具有类类型

en: source is of incomplete class type
zh_CN: 源有不完全的类类型

en: source type is not polymorphic
zh_CN: 源类型不是多态的

en: spec file has no spec for linking
zh_CN: spec 文件没有对链接的设定

en: spec is '%s'
zh_CN: spec 是‘%s’

en: specialization %qT after instantiation %qT
zh_CN: %qT的实例化在%qT的特例化之后

en: specialization of %qD after instantiation
zh_CN: %qD的特例化在实例化之后

en: specialization of %qD in different namespace
zh_CN: 在不同命名空间内对%qD的特例化

en: specialization of %qD must appear at namespace scope
zh_CN: %qD的特例化必须出现在命名空间内

en: specialization of %qT after instantiation
zh_CN: %qT的实例化在特例化之后

en: specialization of implicitly-declared special member function
zh_CN: 特例化了隐式声明的特殊成员函数

en: specializing member %<%T::%E%> requires %<template<>%> syntax
zh_CN: 特例化成员%<%T::%E%>需要%<template<>%>语法

en: specs %s spec was not found to be renamed
zh_CN: specs 找不到 %s spec 或已被重命名

en: spurious %<>>%>, use %<>%> to terminate a template argument list
zh_CN: 可疑的%<>>%>，使用%<>%>来结束模板实参列表

en: spurious trailing %<%%%> in format
zh_CN: 格式字符串尾有可疑的%<%%%>

en: stack frame not a multiple of 8 bytes: %wd
zh_CN: 栈帧大小不是 8 字节的倍数：%wd

en: stack frame not a multiple of octabyte: %wd
zh_CN: 栈帧大小不是 8 字节的倍数：%wd

en: stack frame too large
zh_CN: 栈帧太大

en: stack guard value must be an exact power of 2
zh_CN: 栈防护值必须是 2 的整数次方

en: stack limit expression is not supported
zh_CN: 不支持堆栈限制表达式

en: stack limits not supported on this target
zh_CN: 堆栈限制在此目标机上不受支持

en: stack size must be an exact power of 2
zh_CN: 栈大小必须刚好是 2 的某次方

en: stack size must be greater than the stack guard value
zh_CN: 栈大小必须大于栈防护值

en: stack size must not be greater than 64k
zh_CN: 栈大小不能大于 64K

en: stackframe too big: %d bytes
zh_CN: 栈帧太大：%d 字节

en: statement has no effect
zh_CN: 语句不起作用

en: statement marked for throw in middle of block
zh_CN: 语句在块中被标记为抛出

en: statement marked for throw, but doesn%'t
zh_CN: 语句被标记为抛出异常，但实际上并未抛出

en: statement with no effect
zh_CN: 语句不起作用

en: statement-expressions are not allowed outside functions nor in template-argument lists
zh_CN: 语句表达式只能用于函数或模板实参列表内

en: static assertion failed: %E
zh_CN: 静态断言错误：%E

en: static declaration of %q+D follows non-static declaration
zh_CN: 对%qD的静态声明出现在非静态声明之后

en: static is not supported on TPF-OS
zh_CN: TPF-OS 不支持 static

en: static member %qD cannot be a bit-field
zh_CN: 静态成员%qD不能是位段

en: static member %qD declared %<register%>
zh_CN: 静态成员%qD声明为%<register%>

en: static member function %q#D declared with type qualifiers
zh_CN: 静态成员函数%q#D的声明带有类型限定符

en: static member function %qD cannot have cv-qualifier
zh_CN: 成员函数%qD不能拥有 cv 限定符

en: static or type qualifiers in non-parameter array declarator
zh_CN: static 或类型限定符出现在非形参数组声明中

en: statically allocated instance of Objective-C class %qE
zh_CN: 静态分配的 Objective-C 类%qE的实例

en: stdcall and cdecl attributes are not compatible
zh_CN: stdcall 和 cdecl 属性互不兼容

en: stdcall and fastcall attributes are not compatible
zh_CN: stdcall 和 fastcall 属性互不兼容

en: stdcall and thiscall attributes are not compatible
zh_CN: stdcall 和 thiscall 属性互不兼容

en: stmt (%p) marked modified after optimization pass:
zh_CN: stmt (%p) 在优化以后标记为修改的：

en: storage class %<__thread%> invalid for function %qs
zh_CN: 函数%qs的存储类%<__thread%>无效

en: storage class %<auto%> invalid for function %qs
zh_CN: 函数%qs的存储类%<auto%>无效

en: storage class %<register%> invalid for function %qs
zh_CN: 函数%qs的存储类%<register%>无效

en: storage class %qD applied to template instantiation
zh_CN: 为模板实例化化应用了存储类型%qD

en: storage class specified for %qs
zh_CN: 为%qs指定了存储类

en: storage class specified for parameter %qE
zh_CN: 为形参%qE指定了存储类

en: storage class specified for parameter %qs
zh_CN: 为形参%qs指定了存储类

en: storage class specified for structure field
zh_CN: 为结构字段指定了存储类

en: storage class specified for structure field %qE
zh_CN: 为结构字段%qE指定了存储类

en: storage class specified for template parameter %qs
zh_CN: 为模板参数%qs指定了存储类

en: storage class specified for typename
zh_CN: 为类型名指定了存储类

en: storage class specified for unnamed parameter
zh_CN: 为无名形参指定了存储类

en: storage class specifiers invalid in friend function declarations
zh_CN: 为友元函数声明指定了无效的存储类

en: storage size of %q+D isn%'t constant
zh_CN: %q+D的存储大小不是常量

en: storage size of %q+D isn%'t known
zh_CN: %q+D的存储大小未知

en: storage size of %qD isn%'t constant
zh_CN: %qD的存储大小不是常量

en: storage size of %qD isn%'t known
zh_CN: %qD的存储大小未知

en: stray %<@%> in program
zh_CN: 程序中有游离的 %<@%>

en: stray %<\%o%> in program
zh_CN: 程序中有游离的%<\%o%>

en: stray %qc in program
zh_CN: 程序中有游离的%qc

en: stray %qs in program
zh_CN: 程序中有游离的%qs

en: strftime formats cannot format arguments
zh_CN: strftime 格式字符串无法格式化实参

en: string length %qd is greater than the length %qd ISO C%d compilers are required to support
zh_CN: 字符串长%qd比%qd(ISO C%d 被要求支持的最大长度) 还要长

en: strong-cast assignment has been intercepted
zh_CN: 强转换的赋值被打断

en: strong-cast may possibly be needed
zh_CN: 可能需要强类型转换

en: struct defined here
zh_CN: 结构在此定义

en: struct has no members
zh_CN: 结构体没有成员

en: struct has no named members
zh_CN: 结构不包含任何有名成员

en: subframework include %s conflicts with framework include
zh_CN: 子框架包含 %s 与框架包含冲突

en: subscript missing in array reference
zh_CN: 数组引用缺少下标

en: subscripted value is neither array nor pointer
zh_CN: 下标运算的左操作数既非数组也非指针

en: subscripted value is pointer to function
zh_CN: 下标运算的左操作数是函数指针

en: subscripting array declared %<register%>
zh_CN: 按下标访问声明为%<register%>的数组

en: suggest braces around empty body in %<do%> statement
zh_CN: 建议在空的%<do%>语句体周围加上花括号

en: suggest braces around empty body in an %<else%> statement
zh_CN: 建议在空的%<else%>语句体周围加上花括号

en: suggest braces around empty body in an %<if%> statement
zh_CN: 建议在空的%<if%>语句体周围加上花括号

en: suggest explicit braces around empty body in %<do%> statement
zh_CN: 建议在%<do%>的空语句体周围显式地加上花括号

en: suggest explicit braces to avoid ambiguous %<else%>
zh_CN: 建议显式地使用花括号以避免出现有歧义的%<else%>

en: suggest parentheses around %<&&%> within %<||%>
zh_CN: 建议在%<||%>的操作数中出现的%<&&%>前后加上括号

en: suggest parentheses around %<+%> in operand of %<&%>
zh_CN: 建议在%<&%>的操作数中出现的%<+%>前后加上括号

en: suggest parentheses around %<+%> inside %<<<%>
zh_CN: 建议在%<<<%>的操作数中出现的%<+%>前后加上括号

en: suggest parentheses around %<+%> inside %<>>%>
zh_CN: 建议在%<>>%>的操作数中出现的%<+%>前后加上括号

en: suggest parentheses around %<-%> in operand of %<&%>
zh_CN: 建议在%<&%>的操作数中出现的%<-%>前后加上括号

en: suggest parentheses around %<-%> inside %<<<%>
zh_CN: 建议在%<<<%>的操作数中出现的%<-%>前后加上括号

en: suggest parentheses around %<-%> inside %<>>%>
zh_CN: 建议在%<>>%>的操作数中出现的%<-%>前后加上括号

en: suggest parentheses around %<>>%> expression
zh_CN: 建议%<>>%>表达式周围加上括号

en: suggest parentheses around arithmetic in operand of %<^%>
zh_CN: 建议在%<^%>的操作数中的算术表达式前后加上括号

en: suggest parentheses around arithmetic in operand of %<|%>
zh_CN: 建议在%<|%>的操作数中的算术表达式前后加上括号

en: suggest parentheses around assignment used as truth value
zh_CN: 建议在用作真值的赋值语句前后加上括号

en: suggest parentheses around comparison in operand of %<!=%>
zh_CN: 建议在%<!=%>的操作数的比较前后加上括号

en: suggest parentheses around comparison in operand of %<&%>
zh_CN: 建议在%<&%>的操作数中的比较表达式前后加上括号

en: suggest parentheses around comparison in operand of %<==%>
zh_CN: 建议在%<==%>的操作数的比较表达式前后加上括号

en: suggest parentheses around comparison in operand of %<^%>
zh_CN: 建议在%<^%>的操作数中的比较表达式前后加上括号

en: suggest parentheses around comparison in operand of %<|%>
zh_CN: 建议在%<|%>的操作数中的比较表达式前后加上括号

en: suggest parentheses around operand of %<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>
zh_CN: 建议在%<!%>的操作数周围加上括号，或将%<&%>改为%<&&%>，或将%<!%>改为%<~%>

en: suggest parentheses around operand of %<!%> or change %<|%> to %<||%> or %<!%> to %<~%>
zh_CN: 建议在%<!%>的操作数周围加上括号，或将%<|%>改为%<||%>，或将%<!%>改为%<~%>

en: suggested alternative: | suggested alternatives:
zh_CN[0]: 建议的替代：

en: support for mode %qs
zh_CN: 支持%qs模式

en: switch %qs is no longer supported
zh_CN: 开关%qs不再被支持

en: switch jumps into statement expression
zh_CN: 开关跳转至语句表达式中

en: switch jumps over variable initialization
zh_CN: switch 跳过了变量初始化

en: switch missing default case
zh_CN: switch 没有默认 case

en: switch quantity not an integer
zh_CN: switch 语句中的值不是一个整数

en: switch starts here
zh_CN: 开关语句从此开始

en: switch statement of size %lu entries too large
zh_CN: switch 语句太大(%lu 个条目)

en: symbol used as immediate operand
zh_CN: 符号被用作立即操作数

en: symbol used with both base and indexed registers
zh_CN: 符号同时使用了基址和变址寄存器

en: symbol with offset used in PIC mode
zh_CN: 带偏移量的符号在 PIC 模式下被使用

en: symtab_node::verify failed
zh_CN: symtab_node::verify 失败

en: system path %qs is not absolute
zh_CN: 系统路径 %qs 不是绝对路径

en: taking address of expression of type %<void%>
zh_CN: 取一个类型为%<void%>的表达式的地址

en: taking the address of a label is non-standard
zh_CN: 取标号的地址不符合标准

en: target CPU does not support ARM mode
zh_CN: 目标 CPU 不支持 ARM 模式

en: target CPU does not support THUMB instructions
zh_CN: 目标 CPU 不支持 THUMB 指令

en: target CPU does not support interworking
zh_CN: 目标 CPU 不支持交互工作

en: target CPU does not support unaligned accesses
zh_CN: 目标 CPU 不支持未对齐的访问

en: target OS does not support unaligned accesses
zh_CN: 目标操作系统不支持未对齐的访问

en: target attribute or pragma changes AltiVec ABI
zh_CN: 目标属性或 pragma 改变了 AltiVec ABI

en: target attribute or pragma changes darwin64 ABI
zh_CN: 目标属性或 pragma 改变了 darwin64 ABI

en: target format does not support infinity
zh_CN: 目标格式不支持无限大浮点数

en: target is not pointer or reference
zh_CN: 目标不是一个指针或引用

en: target is not pointer or reference to class
zh_CN: 目标不是指向类的指针或引用

en: target is not pointer or reference to complete type
zh_CN: 目标不是指向完整类型的指针或引用

en: target specific builtin not available
zh_CN: 目标相关的内建函数不可用

en: target specific option mismatch
zh_CN: 目标相关的选项不匹配

en: target system does not support debug output
zh_CN: 目标系统不支持调试输出

en: target system does not support the %qs debug format
zh_CN: 目标系统不支持 %qs 调试格式

en: template argument %d is invalid
zh_CN: 模板第 %d 个参数无效

en: template argument for %qD uses local type %qT
zh_CN: %qD的模板实参使用了局部类型%qT

en: template argument required for %<%s %T%>
zh_CN: %<%s %T%>需要模板参数

en: template arguments to %qD do not match original template %qD
zh_CN: 给%qD的模板实参不匹配原先的模板%qD

en: template class without a name
zh_CN: 模板类没有名字

en: template declaration of %<typedef%>
zh_CN: %<typedef%>的模板声明

en: template declaration of %q#D
zh_CN: %q#D声明为模板

en: template definition of non-template %q#D
zh_CN: 对非模板%q#D的模板定义

en: template parameter %q+#D
zh_CN: 模板形参%q+#D

en: template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type
zh_CN: 模板参数%qD(类型为%qT)不允许出现在整数表达式中，因为它的类型不是整数或枚举

en: template parameter list used in explicit instantiation
zh_CN: 显式初始化中出现了模板参数列表

en: template parameter pack %qD cannot have a default argument
zh_CN: 模板参数包%qD不能有默认参数

en: template parameter pack cannot have a default argument
zh_CN: 模板参数包不能有默认参数

en: template parameter packs cannot have default arguments
zh_CN: 模板参数包不能有默认参数

en: template parameter type %qT declared %<friend%>
zh_CN: 模板形参类型%qT声明为%<friend%>

en: template parameters cannot be friends
zh_CN: 模板参数不能是友元

en: template specialization with C linkage
zh_CN: 特例化模板有 C 链接

en: template specifiers not specified in declaration of %qD
zh_CN: %qD的声明中没有 template 限定

en: template type parameters must use the keyword %<class%> or %<typename%>
zh_CN: 模板形参必须使用%<class%>或%<typename%>关键字

en: template with C linkage
zh_CN: 模板有 C 链接

en: template-id %qD for %q+D does not match any template declaration
zh_CN: %2$q+D的模板标识符%1$qD不匹配任何模板声明

en: template-id %qD used as a declarator
zh_CN: 模板标识符%qD用作声明

en: template-parameter-
zh_CN: 模板形参-

en: templates may not be %<virtual%>
zh_CN: 模板不能是%<virtual%>的

en: the %qs architecture does not support %<-m%s=2008%>
zh_CN: %qs 架构不支持 %<-m%s=2008%>

en: the %qs architecture does not support %<-m%s=legacy%>
zh_CN: %qs 架构不支持 %<-m%s=legacy%>

en: the %qs architecture does not support %<-mfp32%>
zh_CN: %qs 架构不支持 %<-mfp32%>

en: the %qs architecture does not support DSP instructions
zh_CN: %qs 架构不支持 DSP 诸指令

en: the %qs architecture does not support branch-likely instructions
zh_CN: %qs架构不支持 Branch-Likely 指令

en: the %qs architecture does not support madd or msub instructions
zh_CN: %qs 架构不支持 madd 或 msub 指令

en: the %qs architecture does not support paired-single instructions
zh_CN: %qs架构不支持配对单精度指令

en: the %qs architecture does not support the synci instruction
zh_CN: %qs架构不支持 synci 指令

en: the ' ' printf flag
zh_CN: ‘ ’printf 标记

en: the '!' strfmon flag
zh_CN: ‘!’strfmon 标记

en: the '#' printf flag
zh_CN: ‘#’printf 标记

en: the '#' strftime flag
zh_CN: ‘#’strftime 标记

en: the ''' printf flag
zh_CN: ‘'’printf 标记

en: the ''' scanf flag
zh_CN: ‘'’scanf 标记

en: the '(' strfmon flag
zh_CN: ‘(’strfmon 标记

en: the '+' printf flag
zh_CN: ‘+’printf 标记

en: the '+' strfmon flag
zh_CN: ‘+’strfmon 标记

en: the '-' printf flag
zh_CN: ‘-’printf 标记

en: the '-' strfmon flag
zh_CN: ‘-’strfmon 标记

en: the '-' strftime flag
zh_CN: ‘-’strftime 标记

en: the '0' printf flag
zh_CN: ‘0’printf 标记

en: the '0' strftime flag
zh_CN: ‘0’strftime 标记

en: the 'E' strftime modifier
zh_CN: ‘E’strftime 修饰符

en: the 'I' printf flag
zh_CN: ‘I’printf 标记

en: the 'I' scanf flag
zh_CN: ‘I’scanf 标记

en: the 'O' modifier
zh_CN: ‘O’修饰符

en: the 'O' strftime modifier
zh_CN: ‘O’strftime 修饰符

en: the '^' strfmon flag
zh_CN: ‘^’strfmon 标记

en: the '^' strftime flag
zh_CN: ‘^’strftime 标记

en: the '_' strftime flag
zh_CN: ‘_’strftime 标记

en: the 'a' scanf flag
zh_CN: ‘a’scanf 标记

en: the 'm' scanf flag
zh_CN: ‘m’scanf 标记

en: the 'q' diagnostic flag
zh_CN: ‘q’诊断标记

en: the -shared option is not currently supported for VAX ELF
zh_CN: -shared 选项目前在 VAX ELF 下不受支持

en: the ABI of passing struct with a flexible array member has changed in GCC 4.4
zh_CN: 在 GCC 4.4 中传递带有一个可变数组成员的结构的 ABI 有了改变

en: the RX200 cpu does not have FPU hardware
zh_CN: RX200 CPU 没有 FPU 硬件

en: the address of %qD will always evaluate as %<true%>
zh_CN: %qD的地址总是等价为%<true%>

en: the address of %qD will never be NULL
zh_CN: %qD的地址永远不会为 NULL

en: the assignment suppression scanf feature
zh_CN: scanf 的取消赋值特性

en: the dot syntax is not available in Objective-C 1.0
zh_CN: 点语法在 Objective-C 1.0 中不可用

en: the first parameter of %<operator new%> cannot have a default argument
zh_CN: %<operator new%>的第一个形参不能有默认参数

en: the last argument must be a 1-bit immediate
zh_CN: 最后一个实参必须是一个 1 位立即数

en: the last argument must be a 2-bit immediate
zh_CN: 最后一个实参必须是一个 2 位立即数

en: the last argument must be a 3-bit immediate
zh_CN: 最后一个实参必须是一个 3 位立即数

en: the last argument must be a 32-bit immediate
zh_CN: 最后一个参数必须是一个 32 位立即数

en: the last argument must be a 4-bit immediate
zh_CN: 最后一个实参必须是一个 4 位立即数

en: the last argument must be a 5-bit immediate
zh_CN: 最后一个实参必须是一个 5 位立即数

en: the last argument must be an 1-bit immediate
zh_CN: 最后一个实参必须是一个 1 位立即数

en: the last argument must be an 8-bit immediate
zh_CN: 最后一个实参必须是一个 8 位立即数

en: the m210 does not have little endian support
zh_CN: m210 不支持小端在前

en: the next to last argument must be an 8-bit immediate
zh_CN: 倒数第二个实参必须是一个 8 位立即数

en: the result of the conversion is unspecified because %qE is outside the range of type %qT
zh_CN: 转换的结果不能确定，因为%qE已经超过了类型%qT的范围

en: the type being destroyed is %qT, but the destructor refers to %qT
zh_CN: 被析构的类型是%qT，但析构函数却使用了%qT

en: there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available
zh_CN: %qD的实参不依赖模板参数，所以%qD的声明必须可用

en: third argument of %q+D should probably be %<char **%>
zh_CN: %q+D如果有第三个参数，类型应该是%<char **%>

en: third argument to %<__builtin_prefetch%> must be a constant
zh_CN: %<__builtin_prefetch%>的第三个实参必须是一个常量

en: third operand to the conditional operator is of type %<void%>, but the second operand is neither a throw-expression nor of type %<void%>
zh_CN: 条件运算符的第三个操作数类型为%<void%>，但第二个操作数既不是异常表达式，也不拥有%<void%>类型

en: this decimal constant is unsigned only in ISO C90
zh_CN: 这个十进制数常量仅在 ISO C90 中是无符号的

en: this decimal constant would be unsigned in ISO C90
zh_CN: 这个十进制数常量在 ISO C90 中将是无符号的

en: this is the first default label
zh_CN: 这是第一个默认标号

en: this is the first entry overlapping that value
zh_CN: 这是重叠此值的第一个条目

en: this is the insn:
zh_CN: 这是指令：

en: this media function is only available on the fr400 and fr550
zh_CN: 此多媒体函数只在 fr400 和 fr550 上可用

en: this media function is only available on the fr500
zh_CN: 此多媒体函数只在 fr500 上可用

en: this target does not support %qs
zh_CN: 此目标机不支持 %qs

en: this target is little-endian
zh_CN: 该目标为小端序

en: this target machine does not have delayed branches
zh_CN: 此目标机没有延迟转移指令

en: thread-local COMMON data not implemented
zh_CN: 线程局部的 COMMON 数据没有实现

en: thread-local declaration of %q#D follows non-thread-local declaration
zh_CN: %q#D的线程局部声明出现在其非线程局部声明之后

en: thread-local declaration of %q+D follows non-thread-local declaration
zh_CN: %q+D的线程局部声明跟在其非线程局部声明之后

en: throwing NULL, which has integral, not pointer type
zh_CN: 抛出 NULL，它的类型是整数而不是指针

en: to refer to a type member of a template parameter, use %<typename %E%>
zh_CN: 需要使用某个模板参数的类型成员时，请使用%<typename %E%>

en: too few arguments to %%:version-compare
zh_CN: %%：version-compare 的参数太少

en: too few arguments to function
zh_CN: 给予函数的实参太少

en: too few arguments to function %<va_start%>
zh_CN: 给函数%<va_start%>的参数太少

en: too few arguments to function %qE
zh_CN: 提供给函数%qE的实参太少

en: too few template parameter lists in declaration of %qD
zh_CN: %qD声明时模板参数表太少

en: too few template-parameter-lists
zh_CN: 模板参数表太少

en: too large function value type, needs %d registers, have only %d registers for this
zh_CN: 函数值类型太大，需要 %d 个寄存器，却只有 %d 个寄存器可用

en: too late for # directive to set debug directory
zh_CN: 使用 # 指示设定调试目录太迟

en: too many %<static%> arguments
zh_CN: 太多 %<static%> 参数

en: too many %qs clauses
zh_CN: 太多的%qs子句

en: too many alternatives in %<asm%>
zh_CN: %<asm%>中太多变数

en: too many arguments
zh_CN: 实参太多

en: too many arguments for format
zh_CN: 提供给格式字符串的实参太多

en: too many arguments to %%:compare-debug-dump-opt
zh_CN: %%:compare-debug-dump-opt 的参数太多

en: too many arguments to %%:compare-debug-self-opt
zh_CN: %%:compare-debug-self-opt 的参数太多

en: too many arguments to %%:version-compare
zh_CN: %%：version-compare 的参数太多

en: too many arguments to function
zh_CN: 给予函数的实参太多

en: too many arguments to function %qE
zh_CN: 提供给函数%qE的实参太多

en: too many braces around initializer for %qT
zh_CN: %qT的初始值设定周围花括号太多

en: too many initializers for %qT
zh_CN: %qT的初始值设定项太多

en: too many input files
zh_CN: 输入文件太多

en: too many outgoing branch edges from bb %i
zh_CN: 从基本块 %i 分出太多的分支边

en: too many template parameter lists in declaration of %qD
zh_CN: %qD声明时模板参数表太多

en: too many template-parameter-lists
zh_CN: 模板参数表太多

en: too many values in return statement
zh_CN: 返回语句中值太多

en: too much stack space to dispose of: %d
zh_CN: 要舍弃太多的堆栈空间：%d

en: too much stack space to prepare: %d
zh_CN: 要准备太多的堆栈空间：%d

en: top-level declaration of %qs specifies %<auto%>
zh_CN: 在文件层将%qs声明为%<auto%>

en: total size of local variables exceeds architecture limit
zh_CN: 局部变量大小总和超过架构极限

en: traditional C lacks a separate namespace for labels, identifier %qE conflicts
zh_CN: 传统 C 不为标号提供一个单独的命名空间，标识符%qE冲突

en: traditional C rejects ISO C style function definitions
zh_CN: 传统 C 不接受 ISO C 风格的函数定义

en: traditional C rejects automatic aggregate initialization
zh_CN: 传统 C 不接受自动的聚合初始化

en: traditional C rejects initialization of unions
zh_CN: 传统 C 不接受对联合的初始化

en: traditional C rejects string constant concatenation
zh_CN: 传统 C 不接受字符串常量毗连

en: traditional C rejects the unary plus operator
zh_CN: 传统 C 不接受单目 + 运算符

en: trap mode not supported for VAX floats
zh_CN: 陷阱模式不为 VAX 浮点数所支持

en: tree check: %s, have %s in %s, at %s:%d
zh_CN: 树检查：%s，得到 %s 在 %s，于 %s:%d

en: tree check: accessed operand %d of %s with %d operands in %s, at %s:%d
zh_CN: 树检查：在 %4$s 中访问有 %3$d 个操作数的 %2$s 的第 %1$d 个操作数，于 %5$s:%6$d

en: tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d
zh_CN: 树检查：不需要类%qs，得到%qs(%s) 在 %s，于 %s:%d

en: tree check: expected class %qs, have %qs (%s) in %s, at %s:%d
zh_CN: 树检查：需要类%qs，得到%qs(%s) 在 %s，于 %s:%d

en: tree check: expected none of %s, have %s in %s, at %s:%d
zh_CN: 树检查：不需要 %s，得到 %s 在 %s，于 %s:%d

en: tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d
zh_CN: 树检查：需要包含%qs结构的树，得到%qs在 %s，于 %s:%d

en: tree list ends on depth %i
zh_CN: 树列表结束于深度 %i

en: true/false edge after a non-GIMPLE_COND in bb %d
zh_CN: 基本块 %d 中非 GIMPLE_COND 后的真假边

en: try removing the parentheses around the type-id
zh_CN: 请尝试删除类型标识符两边的括号

en: try using %qE instead
zh_CN: 尝试使用%qE代替

en: trying to finish struct, but kicked out due to previous parse errors
zh_CN: 试图完成结构，但为先前的解析错误所中断

en: trying to make class %qT a friend of global scope
zh_CN: 试图让%qT成为全局域的友元

en: two or more data types in declaration of %qs
zh_CN: %qs的声明指定了两个以上的数据类型

en: two or more data types in declaration specifiers
zh_CN: 声明指定了两个以上的数据类型

en: type %q#T argument given to %<delete%>, expected pointer
zh_CN: %<delete%>的参数类型应为指针而非%q#T

en: type %qE has a user-defined constructor
zh_CN: 类型%qE有一个用户定义的构造函数

en: type %qE has a user-defined destructor
zh_CN: 类型%qE有一个用户定义的析构函数

en: type %qE has no default constructor to call
zh_CN: 类型%qE没有可以调用的默认构造函数

en: type %qE has virtual member functions
zh_CN: 类型%qE有虚成员函数

en: type %qT does not have a known size
zh_CN: 类型 %qT 大小未知

en: type %qT for explicit instantiation %qD does not match declared type %qT
zh_CN: 类型%qT用于显式实例化%qD时不匹配声明的类型%qT

en: type %qT is not a base type for type %qT
zh_CN: 类型%qT不是类型%qT的基类

en: type %qT is not a direct base of %qT
zh_CN: 类型%qT不是%qT的直接基类

en: type %qT is not a direct or virtual base of %qT
zh_CN: 类型%qT不是%qT的直接或虚基类

en: type %qT is too large
zh_CN: 类型 %qT 过大

en: type %qT of template argument %qE depends on a template parameter | type %qT of template argument %qE depends on template parameters
zh_CN[0]: 模板实参%2$qE的类型%1$qT取决于模板参数

en: type %qs does not conform to the %qE protocol
zh_CN: 类型%qs没有完全遵循%qE协议

en: type attributes ignored after type is already defined
zh_CN: 类型属性在定义后被忽略

en: type defaults to %<int%> in declaration of %qE
zh_CN: 在%qE的声明中，类型默认为%<int%>

en: type defaults to %<int%> in type name
zh_CN: 类型名中类型默认为%<int%>

en: type has no methods
zh_CN: 类型没有方法

en: type is deprecated
zh_CN: 已弃用此类型

en: type is deprecated: %s
zh_CN: 已弃用类型：%s

en: type mismatch between an SSA_NAME and its symbol
zh_CN: SSA_NAME 和其符号间类型不匹配

en: type mismatch in binary expression
zh_CN: 二元表达式中类型不匹配

en: type mismatch in conditional expression
zh_CN: 条件表达式中类型不匹配

en: type name declared as function returning a function
zh_CN: 类型名声明为返回一个数组的函数

en: type name declared as function returning an array
zh_CN: 类型名声明为返回一个数组的函数

en: type of %qD defaults to %<int%>
zh_CN: %qD的类型默认为%<int%>

en: type of %qD does not match original declaration
zh_CN: 类型%qD不匹配原先的声明

en: type of %qE is unknown
zh_CN: %qE的类型未知

en: type of array %q+D completed incompatibly with implicit initialization
zh_CN: 数组%q+D类型与隐式初始化不兼容

en: type of bit-field %qs is a GCC extension
zh_CN: 位段类型%qs是一个 GCC 扩展

en: type of formal parameter %d is incomplete
zh_CN: 实参 %d 的类型不完全

en: type qualifiers ignored on function return type
zh_CN: 忽略函数返回类型的类型限定

en: type to vector delete is neither pointer or array type
zh_CN: 向量 delete 的实参类型既非指针也非数组

en: type-punning to incomplete type might break strict-aliasing rules
zh_CN: 类型双关作用在不完全类型上可能破坏强重叠规则

en: type/value mismatch at argument %d in template parameter list for %qD
zh_CN: 实参 %d 的类型/值不匹配，在%qD的模板参数列表中

en: typedef %q+D declared %<inline%>
zh_CN: typedef%q+D声明为%<inline%>

en: typedef declaration invalid in parameter declaration
zh_CN: 形参声明中出现的 typedef 声明无效

en: typedef name may not be a nested-name-specifier
zh_CN: typedef 名不能是嵌套名指定

en: typedef-name %qD used as destructor declarator
zh_CN: typedef 名%qD用于析构函数声明

en: types are not quite compatible
zh_CN: 类型不完全兼容

en: types may not be defined in %<decltype%> expressions
zh_CN: 类型不能定义在%<decltype%>中

en: types may not be defined in a %<typeid%> expression
zh_CN: 类型不能定义在%<typeid%>表达式中

en: types may not be defined in a new-type-id
zh_CN: 类型不能定义在 new-type-id 中

en: types may not be defined in an exception-specification
zh_CN: 类型不能定义在异常规范中

en: types may not be defined in casts
zh_CN: 类型不能定义在类型转换中

en: types may not be defined in conditions
zh_CN: 类型不能定义在条件表达式中

en: types may not be defined in exception-declarations
zh_CN: 类型不能定义在异常声明中

en: types may not be defined in parameter types
zh_CN: 类型不能定义在参数类型中

en: types may not be defined in template arguments
zh_CN: 不能在模板实参中定义类型

en: unable to compute real location of stacked parameter
zh_CN: 无法计算出栈中参数的真实地址

en: unable to deduce %qT from %qE
zh_CN: 无法从%2$qE推导出%1$qT

en: unable to emulate %qs
zh_CN: 无法枚举%qs

en: unable to find a register to spill in class %qs
zh_CN: 在类%qs中找不到可溢出的寄存器

en: unable to generate reloads for:
zh_CN: 无法生成重新载入，为：

en: unable to open file
zh_CN: 无法打开文件

en: unconditional %2d never executed
zh_CN: 无条件 %2d 从未执行

en: unconditional %2d taken %s
zh_CN: unconditional %2d 被执行 %s

en: undeclared selector %qE
zh_CN: 未声明的选择子%qE

en: undefined named operand %qs
zh_CN: 未定义的有名操作数%qs

en: unexpected EOF
zh_CN: 非预期的文件结束

en: unexpected argument
zh_CN: 非预期的参数

en: unexpected attribute
zh_CN: 非预期的属性

en: unexpected base-type in cris_print_base
zh_CN: cris_print_base 中有非预期的基类型

en: unexpected file name %s in linker resolution file. Expected %s
zh_CN: 符号解析文件中有非预期的文件名 %s。需要 %s

en: unexpected index-type in cris_print_index
zh_CN: cris_print_index 中有非预期的索引类型

en: unexpected multiplicative operand
zh_CN: 无效的乘性操作数

en: unexpected offset
zh_CN: 非预期的偏移

en: unexpected operand
zh_CN: 非预期的操作数

en: unexpected side-effects in address
zh_CN: 地址中有非预期的副作用

en: uninitialized const in %<new%> of %q#T
zh_CN: %<new%>%q#T时常量未初始化

en: uninitialized reference member in %q#T
zh_CN: %q#T中有未初始化的引用成员

en: union cannot be made transparent
zh_CN: 联合不能成为透明的

en: union defined here
zh_CN: 联合在此定义

en: union has no members
zh_CN: 联合体没有成员

en: union has no named members
zh_CN: 联合包含无名成员

en: unknown C++ standard %qs
zh_CN: 未知的 C++ 标准 %qs

en: unknown IRA algorithm %qs
zh_CN: 未知的 IRA 算法 %qs

en: unknown Stack Reuse Level %qs
zh_CN: 未知的栈重用级别%qs

en: unknown TLS model %qs
zh_CN: 未知的 TLS 模型 %qs

en: unknown action %qE for %<#pragma pack%> - ignored
zh_CN: %<#pragma pack%>动作%qE无效 - 已忽略

en: unknown architecture specific memory model
zh_CN: 未知的架构特定的内存模型

en: unknown array size in delete
zh_CN: delete 时数组大小未知

en: unknown conversion type character %qc in format
zh_CN: 格式字符串中出现无效的类型转换字符%qc

en: unknown dest
zh_CN: 未知目标

en: unknown insn mode
zh_CN: 未知的指令模式

en: unknown machine mode %qE
zh_CN: 未知的机器模式%qE

en: unknown move insn:
zh_CN: 无效的 move 指令：

en: unknown option after %<#pragma GCC diagnostic%> kind
zh_CN: %<#pragma GCC diagnostic%>后选项未知

en: unknown register name %qs in %<asm%>
zh_CN: %<asm%>中出现未知的寄存器名%qs

en: unknown register name: %s
zh_CN: 未知的寄存器名：%s

en: unknown relocation unspec
zh_CN: 未指定未知的重定位方式

en: unknown src
zh_CN: 未知源

en: unknown type name %qE
zh_CN: 未知的类型名%qE

en: unnamed field has incomplete type
zh_CN: 无名字段类型不完全

en: unnamed initializer for %qT, which has no base classes
zh_CN: 对没有基类的%qT的无名初始化

en: unnamed initializer for %qT, which uses multiple inheritance
zh_CN: 对使用了多继承的%qT的无名初始化

en: unnamed struct/union that defines no instances
zh_CN: 未定义任何实例的无名结构/联合

en: unnamed variable or field declared void
zh_CN: 无名变量或字段声明为 void

en: unreachable
zh_CN: 不可达

en: unrecognizable insn:
zh_CN: 无法识别的指令：

en: unrecognized address
zh_CN: 无法识别的地址

en: unrecognized format specifier
zh_CN: 无法识别的格式限定符

en: unrecognized gcc debugging option: %c
zh_CN: 无法识别的 gcc 调试选项：%c

en: unrecognized register name %qs
zh_CN: 不可识别的寄存名%qs

en: unrecognized section name %qE
zh_CN: 无法识别的节名%qE

en: unrecognized string escape
zh_CN: 无法识别的字符串转义

en: unrecognized supposed constant
zh_CN: 预期的常量无法识别

en: unrecoverable error
zh_CN: 不可恢复错误

en: unsupported combination: %s
zh_CN: 不支持的组合：%s

en: unsupported non-standard concatenation of string literals
zh_CN: 不受支持的非标准字面字符串毗连

en: unsupported non-standard suffix on floating constant
zh_CN: 不被支持的非标准浮点常量后缀

en: unsupported operand size for extended register
zh_CN: 扩展的寄存器不支持的操作数大小

en: unterminated assembly dialect alternative
zh_CN: 未结束的汇编风格指示

en: unterminated format string
zh_CN: 未终止的格式字符串

en: unterminated string
zh_CN: 未终止的字符串

en: unused name %qE
zh_CN: 未使用的名称 %qE

en: unused variable %q+D
zh_CN: 未使用的变量%q+D

en: upper value in case label range exceeds maximum value for type
zh_CN: case 标号范围的上限值比该类型的最大值还要大

en: use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name
zh_CN: 使用%<%T::%D%>而不是%<%T::%D%>来以限定名指定构造函数

en: use %<%T::template %D%> to indicate that it is a template
zh_CN: 使用%<%T::template %D%>来表示这是一个模板

en: use %<...%> to expand argument pack
zh_CN: 使用%<...%>来展开实参集

en: use of %<complex%> in AltiVec types is invalid
zh_CN: 在 AltiVec 类型中使用%<complex%>无效

en: use of %<long double%> in AltiVec types is invalid
zh_CN: 在 AltiVec 类型中使用%<long double%>无效

en: use of %<long%> in AltiVec types is deprecated; use %<int%>
zh_CN: 已弃用在 AltiVec 类型中使用%<long%>；请改用%<int%>

en: use of %qs in template
zh_CN: 在模板中使用%qs

en: use of %s and %s together in %s format
zh_CN: 同时使用 %s 和 %s，在 %s 格式字符串中

en: use of %s and %s together with %<%%%c%> %s format
zh_CN: 同时使用 %s 和 %s，在%<%%%c%>%s 格式字符串中

en: use of boolean types in AltiVec types is invalid
zh_CN: 在 AltiVec 类型中使用布尔类型无效

en: use of class template %qT as expression
zh_CN: 将类模板%qT用作表达式

en: use of deleted function %qD
zh_CN: 使用了被删除的函数%qD

en: use of enum %q#D without previous declaration
zh_CN: 使用枚举%q#D前没有给出声明

en: used array that cannot be converted to pointer where scalar is required
zh_CN: 需要标量时使用了不能被转换为指针的数组

en: used struct type value where scalar is required
zh_CN: 需要标量时使用了结构类型

en: used union type value where scalar is required
zh_CN: 需要标量时使用了联合类型

en: useless storage class specifier in empty declaration
zh_CN: 空声明中指定存储类无用

en: useless type name in empty declaration
zh_CN: 空声明中类型名无用

en: useless type qualifier in empty declaration
zh_CN: 空声明中类型限定无用

en: user-defined %qD always evaluates both arguments
zh_CN: 用户定义的%qD总是计算所有两个参数

en: using %<%c%s%>
zh_CN: 使用%<%c%s%>

en: using darwin64 ABI
zh_CN: 使用 darwin64 ABI

en: using invalid field %qD
zh_CN: 使用无效字段%qD

en: using old darwin ABI
zh_CN: 使用旧式的 Darwin ABI

en: using result of function returning %<void%>
zh_CN: 使用返回%<void%>的函数的结果

en: using template type parameter %qT after %qs
zh_CN: 使用模板类型形参%qT，在%qs后

en: using typedef-name %qD after %qs
zh_CN: 使用 typedef 名%qD，在%qs后

en: using-declaration for non-member at class scope
zh_CN: 在类作用域使用非成员的 using 声明

en: value computed is not used
zh_CN: 计算出的值未被使用

en: var-tracking-assignments changes selective scheduling
zh_CN: var-tracking-assignments 改变了选择性调度

en: variable
zh_CN: 变量

en: variable %q#D has initializer but incomplete type
zh_CN: 变量%q#D有初始值设定，但是类型不完全

en: variable %q+D declared %<inline%>
zh_CN: 变量%q+D声明为%<inline%>

en: variable %q+D definition is marked dllimport
zh_CN: 变量%q+D的定义被标记为 dllimport

en: variable %q+D might be clobbered by %<longjmp%> or %<vfork%>
zh_CN: 变量%q+D能为%<longjmp%>或%<vfork%>所篡改

en: variable %qD has function type
zh_CN: 变量%qD有函数类型

en: variable %qD has initializer but incomplete type
zh_CN: 变量%qD有初始值设定但类型不完全

en: variable %qD redeclared as function
zh_CN: 变量%qD重声明为函数

en: variable %qD set but not used
zh_CN: 变量%qD被设定但未被使用

en: variable %qE of incomplete type %qT will not be accessed in for increment expression
zh_CN: for 循环增量表达式中的对象%qE具有不完全的类型%qT，不会被访问

en: variable %qE of incomplete type %qT will not be accessed in left operand of comma operator
zh_CN: 逗号操作符的左操作数中的对象%qE具有不完全的类型%qT，不会被访问

en: variable %qE of incomplete type %qT will not be accessed in right operand of comma operator
zh_CN: 逗号操作符的右操作数中的对象%qE具有不完全的类型%qT，不会被访问

en: variable %qE of incomplete type %qT will not be accessed in second operand of conditional expression
zh_CN: 条件表达式第二个操作数中的对象%qE具有不完全的类型%qT，不会被访问

en: variable %qE of incomplete type %qT will not be accessed in statement
zh_CN: 语句中的对象%qE具有不完全的类型%qT，不会被访问

en: variable %qE of incomplete type %qT will not be accessed in third operand of conditional expression
zh_CN: 条件表达式第三个操作数中的对象%qE具有不完全的类型%qT，不会被访问

en: variable length array %qD is used
zh_CN: 使用了变长数组%qD

en: variable length array is used
zh_CN: 使用了变长数组

en: variable or field %qE declared void
zh_CN: 变量或字段%qE声明为 void

en: variable or field declared void
zh_CN: 变量或字段声明为 void

en: variable previously declared %<static%> redeclared %<extern%>
zh_CN: 先前被声明为%<static%>的变量重声明为%<extern%>

en: variable tracking requested, but not supported by this debug format
zh_CN: 求追踪变量，但不为这种调试格式所支持

en: variable tracking requested, but useless unless producing debug info
zh_CN: 要求追踪变量，但若不生成调试信息则无用

en: variable tracking size limit exceeded
zh_CN: 变量跟踪大小越限

en: variable-sized compound literal
zh_CN: 变长复合字面量

en: variably modified %qE at file scope
zh_CN: 文件域中的动态可变的%qE

en: variably modified field at file scope
zh_CN: 文件域中的动态可变字段

en: vector size not an integral multiple of component size
zh_CN: 向量大小不是组件大小的整数倍

en: verify_cgraph_node failed
zh_CN: verify_cgraph_node 失败

en: verify_flow_info failed
zh_CN: verify_flow_info 失败

en: verify_flow_info: Basic block %d succ edge is corrupted
zh_CN: verify_flow_info：基本块 %d 的 succ 边已损坏

en: verify_flow_info: Block %i has loop_father, but there are no loops
zh_CN: verify_flow_info：块 %i 有 loop_father，但却没有循环

en: verify_flow_info: Block %i lacks loop_father
zh_CN: verify_flow_info：块 %i 缺少 loop_father

en: verify_flow_info: Duplicate edge %i->%i
zh_CN: verify_flow_info：重复的边 %i->%i

en: verify_flow_info: Incorrect blocks for fallthru %i->%i
zh_CN: verify_flow_info：直通边 %i->%i 块不正确

en: verify_flow_info: Incorrect fallthru %i->%i
zh_CN: verify_flow_info：错误的直通边 %i->%i

en: verify_flow_info: REG_BR_PROB does not match cfg %i %i
zh_CN: verify_flow_info：REG_BR_PROB 不匹配 cfg %i %i

en: verify_gimple failed
zh_CN: verify_gimple 失败

en: verify_ssa failed
zh_CN: verify_ssa 失败

en: version attribute is not a string
zh_CN: 版本属性不是一个字符串

en: virtual SSA name for non-VOP decl
zh_CN: 非 VOP 声明有虚拟 SSA 名

en: virtual base %qT inaccessible in %qT due to ambiguity
zh_CN: 由于存在歧义，虚基类%qT在%qT中无法访问

en: virtual functions cannot be friends
zh_CN: 虚函数不能是友元

en: virtual non-class function %qs
zh_CN: 虚函数%qs不是类成员

en: visibility argument not a string
zh_CN: visibility 的实参不是一个字符串

en: visibility attribute not supported in this configuration; ignored
zh_CN: 可见性属性在此配置下不受支持；已忽略

en: void value not ignored as it ought to be
zh_CN: void 值未如预期地被忽略

en: waitpid failed
zh_CN: waitpid 失败

en: warning:
zh_CN: 警告：

en: weak declaration of %q+D must be public
zh_CN: %q+D的弱声明必须是公共的

en: weak declaration of %q+D not supported
zh_CN: 不支持%q+D的弱声明

en: when writing output to %s: %m
zh_CN: 当写入输出到 %s 时：%m

en: width of %qs exceeds its type
zh_CN: %qs的宽度超过它自身的类型

en: writing into constant object (argument %d)
zh_CN: 对常量对象的写操作(实参 %d)

en: writing through null pointer (argument %d)
zh_CN: 对空指针指向内容的写操作(实参 %d)

en: writing to LTRANS output list %s: %m
zh_CN: 写入 LTRANS 输出列表 %s：%m

en: wrong amount of branch edges after unconditional jump %i
zh_CN: 非条件跳转 %i 之后的分支边数不对

en: wrong edge %d->%d for PHI argument
zh_CN: PHI 参数边 %d->%d 错误

en: wrong immediate use list
zh_CN: 错误的 immediate use 列表

en: wrong insn in the fallthru edge
zh_CN: 直通边上的错误指令

en: wrong number of arguments specified for %qE attribute
zh_CN: 为%qE属性给定的实参数目错误

en: wrong number of arguments to function %<__builtin_next_arg%>
zh_CN: 给函数%<__builtin_next_arg%>的参数数目不对

en: wrong number of arguments to function %<va_start%>
zh_CN: 给函数%<va_start%>的参数数目不对

en: wrong number of template arguments (%d, should be %d)
zh_CN: 模板参数数目不对(不应是 %d 个而应是 %d 个)

en: wrong outgoing edge flags at end of bb %d
zh_CN: 基本块 %d 结尾处有错误的出边标记

en: wrong type argument to abs
zh_CN: 不能对该类型的参数求绝对值

en: wrong type argument to bit-complement
zh_CN: 按位取反的参数类型错误

en: wrong type argument to conjugation
zh_CN: 不能对该类型的参数求共轭

en: wrong type argument to decrement
zh_CN: 该类型不支持自减

en: wrong type argument to increment
zh_CN: 该类型不支持自增

en: wrong type argument to unary exclamation mark
zh_CN: 单目 ! 的实参类型无效

en: wrong type argument to unary minus
zh_CN: 单目减的操作数类型错误

en: wrong type argument to unary plus
zh_CN: 单目加的操作数类型错误

en: x87 register return with x87 disabled
zh_CN: 已禁用 x87 却在 x87 寄存器中返回

en: xstormy16_print_operand: unknown code
zh_CN: xstormy16_print_operand：未知代码

en: zero or negative size array %q+D
zh_CN: 数组%q+D大小为 0 或负

en: zero vector size
zh_CN: 向量大小为 0

en: zero width for bit-field %q+D
zh_CN: 位段%q+D宽度为 0

en: zero width for bit-field %qs
zh_CN: 位段%qs宽度为 0

en: zero width in %s format
zh_CN: %s 格式字符串中域宽为 0

en: zero-length %s format string
zh_CN: 格式字符串 %s 长度为 0

en: zero-size array %qD
zh_CN: 大小为 0 的数组%qD

en: {anonymous}
zh_CN: {匿名}
