# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2002, 2007 Free Software Foundation, Inc.
# LI Daobing <lidaobing@gmail.com>, 2007.
# Wang Li <charles@linux.net.cn>, 2002.
#
msgid ""
msgstr ""
"Project-Id-Version: libc 2.7\n"
"POT-Creation-Date: 2007-10-15 21:18-0700\n"
"PO-Revision-Date: 2007-11-18 12:34+0800\n"
"Last-Translator: LI Daobing <lidaobing@gmail.com>\n"
"Language-Team: Chinese (simplified) <translation-team-zh-cn@lists.sourceforge.net>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: argp/argp-help.c:228
#, c-format
msgid "%.*s: ARGP_HELP_FMT parameter requires a value"
msgstr "%.*s：参数 ARGP_HELP_FMT 需要一个值"

#: argp/argp-help.c:238
#, c-format
msgid "%.*s: Unknown ARGP_HELP_FMT parameter"
msgstr "%.*s：未知的 ARGP_HELP_FMT 参数"

#: argp/argp-help.c:251
#, c-format
msgid "Garbage in ARGP_HELP_FMT: %s"
msgstr "ARGP_HELP_FMT 中有垃圾: %s"

#: argp/argp-help.c:1215
msgid "Mandatory or optional arguments to long options are also mandatory or optional for any corresponding short options."
msgstr "长选项的强制或可选参数对对应的短选项也是强制或可选的。"

#: argp/argp-help.c:1601
msgid "Usage:"
msgstr "用法："

#: argp/argp-help.c:1605
msgid "  or: "
msgstr "  或："

#: argp/argp-help.c:1617
msgid " [OPTION...]"
msgstr " [选项...]"

#: argp/argp-help.c:1644
#, c-format
msgid "Try `%s --help' or `%s --usage' for more information.\n"
msgstr "试用“%s --help”或“%s --usage”以获取更多信息。\n"

#: argp/argp-help.c:1672
#, c-format
msgid "Report bugs to %s.\n"
msgstr "将错误报告给 %s。\n"

#: argp/argp-parse.c:102
msgid "Give this help list"
msgstr "给出该系统求助列表"

#: argp/argp-parse.c:103
msgid "Give a short usage message"
msgstr "给出简要的用法信息"

#: argp/argp-parse.c:104
msgid "Set the program name"
msgstr "设定程序名"

#: argp/argp-parse.c:106
msgid "Hang for SECS seconds (default 3600)"
msgstr "挂起 SECS 秒 (默认 3600)"

#: argp/argp-parse.c:167
msgid "Print program version"
msgstr "打印程序版本号"

#: argp/argp-parse.c:183
msgid "(PROGRAM ERROR) No version known!?"
msgstr "(程序错误) 不知道版本号！？"

#: argp/argp-parse.c:623
#, c-format
msgid "%s: Too many arguments\n"
msgstr "%s：过多的选项\n"

#: argp/argp-parse.c:766
msgid "(PROGRAM ERROR) Option should have been recognized!?"
msgstr "(程序错误) 选项应该可识别！？"

#: assert/assert-perr.c:57
#, c-format
msgid "%s%s%s:%u: %s%sUnexpected error: %s.\n"
msgstr "%s%s%s：%u：%s%s意外的错误：%s。\n"

#: assert/assert.c:57
#, c-format
msgid "%s%s%s:%u: %s%sAssertion `%s' failed.\n"
msgstr "%s%s%s：%u：%s%s断言“%s”失败。\n"

#: catgets/gencat.c:110 catgets/gencat.c:114 nscd/nscd.c:97 nss/makedb.c:61
msgid "NAME"
msgstr "名称"

#: catgets/gencat.c:111
msgid "Create C header file NAME containing symbol definitions"
msgstr "创建含有符号定义的给定名称的 C 头文件"

#: catgets/gencat.c:113
msgid "Do not use existing catalog, force new output file"
msgstr "不使用现有的分类，强制创建新输出文件"

#: catgets/gencat.c:114 nss/makedb.c:61
msgid "Write output to file NAME"
msgstr "将输出写入到指定文件中"

#: catgets/gencat.c:119
msgid ""
"Generate message catalog.\vIf INPUT-FILE is -, input is read from standard input.  If OUTPUT-FILE\n"
"is -, output is written to standard output.\n"
msgstr ""

#: catgets/gencat.c:124
msgid ""
"-o OUTPUT-FILE [INPUT-FILE]...\n"
"[OUTPUT-FILE [INPUT-FILE]...]"
msgstr ""
"-o 输出文件 [输入文件]...\n"
"[输出文件 [输入文件]...]"

#: catgets/gencat.c:232 debug/pcprofiledump.c:204 iconv/iconv_prog.c:411
#: iconv/iconvconfig.c:380 locale/programs/localedef.c:371
#: login/programs/pt_chown.c:88 malloc/memusagestat.c:526 nss/makedb.c:231
msgid ""
"For bug reporting instructions, please see:\n"
"<http://www.gnu.org/software/libc/bugs.html>.\n"
msgstr ""

#: catgets/gencat.c:246 debug/xtrace.sh:64 elf/ldconfig.c:296
#: elf/ldd.bash.in:39 elf/sprof.c:355 iconv/iconv_prog.c:426
#: iconv/iconvconfig.c:395 locale/programs/locale.c:275
#: locale/programs/localedef.c:387 login/programs/pt_chown.c:59
#: malloc/memusage.sh:71 nscd/nscd.c:406 nss/getent.c:83 nss/makedb.c:245
#: posix/getconf.c:1012
#, c-format
msgid ""
"Copyright (C) %s Free Software Foundation, Inc.\n"
"This is free software; see the source for copying conditions.  There is NO\n"
"warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
msgstr ""

#: catgets/gencat.c:251 debug/xtrace.sh:68 elf/ldconfig.c:301 elf/sprof.c:361
#: iconv/iconv_prog.c:431 iconv/iconvconfig.c:400 locale/programs/locale.c:280
#: locale/programs/localedef.c:392 malloc/memusage.sh:75 nscd/nscd.c:411
#: nss/getent.c:88 nss/makedb.c:250 posix/getconf.c:1017
#, c-format
msgid "Written by %s.\n"
msgstr "由 %s 编写。\n"

#: catgets/gencat.c:282
msgid "*standard input*"
msgstr "*标准输入*"

#: catgets/gencat.c:288 iconv/iconv_charmap.c:158 iconv/iconv_prog.c:298
#: nss/makedb.c:170
#, c-format
msgid "cannot open input file `%s'"
msgstr "无法打开输入文件“%s”"

#: catgets/gencat.c:417 catgets/gencat.c:494
msgid "illegal set number"
msgstr "非法的集合编号"

#: catgets/gencat.c:444
msgid "duplicate set definition"
msgstr "重复的集合定义"

#: catgets/gencat.c:446 catgets/gencat.c:623 catgets/gencat.c:677
msgid "this is the first definition"
msgstr "这是第一个定义"

#: catgets/gencat.c:522
#, c-format
msgid "unknown set `%s'"
msgstr "未知集合“%s”"

#: catgets/gencat.c:563
msgid "invalid quote character"
msgstr "无效的引用字符"

#: catgets/gencat.c:576
#, c-format
msgid "unknown directive `%s': line ignored"
msgstr "未知的指令“%s”：忽略此行"

#: catgets/gencat.c:621
msgid "duplicated message number"
msgstr "重复的消息编号"

#: catgets/gencat.c:674
msgid "duplicated message identifier"
msgstr "重复的消息标识符"

#: catgets/gencat.c:731
msgid "invalid character: message ignored"
msgstr "无效的字符：忽略消息"

#: catgets/gencat.c:774
msgid "invalid line"
msgstr "无效的行"

#: catgets/gencat.c:828
msgid "malformed line ignored"
msgstr ""

#: catgets/gencat.c:992 catgets/gencat.c:1033 nss/makedb.c:183
#, c-format
msgid "cannot open output file `%s'"
msgstr "无法打开输出文件“%s”"

#: catgets/gencat.c:1195 locale/programs/linereader.c:560
msgid "invalid escape sequence"
msgstr "无效的转义序列"

#: catgets/gencat.c:1217
msgid "unterminated message"
msgstr "未终止的消息"

#: catgets/gencat.c:1241
#, c-format
msgid "while opening old catalog file"
msgstr "在打开旧分类文件时"

#: catgets/gencat.c:1332
#, c-format
msgid "conversion modules not available"
msgstr "转换模块不可用"

#: catgets/gencat.c:1358
#, c-format
msgid "cannot determine escape character"
msgstr "无法确定转义字符"

#: debug/pcprofiledump.c:53
msgid "Don't buffer output"
msgstr "不要对输出进行缓冲"

#: debug/pcprofiledump.c:58
msgid "Dump information generated by PC profiling."
msgstr ""

#: debug/pcprofiledump.c:61
msgid "[FILE]"
msgstr "[文件]"

#: debug/pcprofiledump.c:104
#, c-format
msgid "cannot open input file"
msgstr "无法打开输入文件"

#: debug/pcprofiledump.c:111
#, c-format
msgid "cannot read header"
msgstr "无法读入头"

#: debug/pcprofiledump.c:175
#, c-format
msgid "invalid pointer size"
msgstr "无效的指针大小"

#: debug/xtrace.sh:27 debug/xtrace.sh:45
msgid "Usage: xtrace [OPTION]... PROGRAM [PROGRAMOPTION]...\\n"
msgstr ""

#: debug/xtrace.sh:33
msgid "Try \\`xtrace --help' for more information.\\n"
msgstr "试用“xtrace --help”以获取更多信息。\\n"

#: debug/xtrace.sh:39
msgid "xtrace: option \\`$1' requires an argument.\\n"
msgstr "xtrace： 选项“$1”需要一个参数\\n"

#: debug/xtrace.sh:46
msgid ""
"Trace execution of program by printing currently executed function.\n"
"\n"
"     --data=FILE          Don't run the program, just print the data from FILE.\n"
"\n"
"   -?,--help              Print this help and exit\n"
"      --usage             Give a short usage message\n"
"   -V,--version           Print version information and exit\n"
"\n"
"Mandatory arguments to long options are also mandatory for any corresponding\n"
"short options.\n"
"\n"
"For bug reporting instructions, please see:\n"
"<http://www.gnu.org/software/libc/bugs.html>.\\n"
msgstr ""

#: debug/xtrace.sh:125
msgid "xtrace: unrecognized option \\`$1'\\n"
msgstr "xtrace：无法识别的选项“$1”\\n"

#: debug/xtrace.sh:138
msgid "No program name given\\n"
msgstr "未指定程序名"

#: debug/xtrace.sh:146
#, sh-format
msgid "executable \\`$program' not found\\n"
msgstr ""

#: debug/xtrace.sh:150
#, sh-format
msgid "\\`$program' is no executable\\n"
msgstr "“$program”不可执行\\n"

#: dlfcn/dlinfo.c:64
msgid "RTLD_SELF used in code not dynamically loaded"
msgstr ""

#: dlfcn/dlinfo.c:73
msgid "unsupported dlinfo request"
msgstr "不支持的 dlinfo 请求"

#: dlfcn/dlmopen.c:64
msgid "invalid namespace"
msgstr "无效的名字空间"

#: dlfcn/dlmopen.c:69
msgid "invalid mode"
msgstr "无效的模式"

#: dlfcn/dlopen.c:64
msgid "invalid mode parameter"
msgstr "无效的模式参数"

#: elf/cache.c:69
msgid "unknown"
msgstr "未知"

#: elf/cache.c:112
msgid "Unknown OS"
msgstr "未知的操作系统"

#: elf/cache.c:117
#, c-format
msgid ", OS ABI: %s %d.%d.%d"
msgstr ", OS ABI: %s %d.%d.%d"

#: elf/cache.c:134 elf/ldconfig.c:1270
#, c-format
msgid "Can't open cache file %s\n"
msgstr "无法打开缓冲文件 %s\n"

#: elf/cache.c:148
#, c-format
msgid "mmap of cache file failed.\n"
msgstr "缓冲文件的 mmap 失败。\n"

#: elf/cache.c:152 elf/cache.c:166
#, c-format
msgid "File is not a cache file.\n"
msgstr "文件不是缓冲区文件。\n"

#: elf/cache.c:199 elf/cache.c:209
#, c-format
msgid "%d libs found in cache `%s'\n"
msgstr "在缓冲区“%2$s”中找到 %1$d 个库\n"

#: elf/cache.c:403
#, c-format
msgid "Can't create temporary cache file %s"
msgstr "无法创建临时缓冲文件 %s"

#: elf/cache.c:411 elf/cache.c:421 elf/cache.c:425 elf/cache.c:430
#, c-format
msgid "Writing of cache data failed"
msgstr "写缓冲数据失败"

#: elf/cache.c:435
#, c-format
msgid "Changing access rights of %s to %#o failed"
msgstr "将 %s 的访问权限改变为 %#o 失败"

#: elf/cache.c:440
#, c-format
msgid "Renaming of %s to %s failed"
msgstr "将 %s 改名为 %s 失败"

#: elf/dl-close.c:378 elf/dl-open.c:460
msgid "cannot create scope list"
msgstr "无法创建范围列表"

#: elf/dl-close.c:724
msgid "shared object not open"
msgstr "共享库未打开"

#: elf/dl-deps.c:114
msgid "DST not allowed in SUID/SGID programs"
msgstr "在 SUID/SGID 程序中不允许 DST"

#: elf/dl-deps.c:127 elf/dl-open.c:282
msgid "empty dynamic string token substitution"
msgstr "空动态字符串替换"

#: elf/dl-deps.c:133
#, c-format
msgid "cannot load auxiliary `%s' because of empty dynamic string token substitution\n"
msgstr ""

#: elf/dl-deps.c:474
msgid "cannot allocate dependency list"
msgstr "无法分配倚赖列表"

#: elf/dl-deps.c:510 elf/dl-deps.c:565
msgid "cannot allocate symbol search list"
msgstr "无法分配符号搜索列表"

#: elf/dl-deps.c:550
msgid "Filters not supported with LD_TRACE_PRELINKING"
msgstr ""

#: elf/dl-error.c:77
msgid "DYNAMIC LINKER BUG!!!"
msgstr "动态链接器 BUG!!!"

#: elf/dl-error.c:124
msgid "error while loading shared libraries"
msgstr "装入共享库时出错"

#: elf/dl-fptr.c:88
msgid "cannot map pages for fdesc table"
msgstr "无法为 fdesc 表映射页"

#: elf/dl-fptr.c:192
msgid "cannot map pages for fptr table"
msgstr "无法为 fptr 表映射页"

#: elf/dl-fptr.c:221
msgid "internal error: symidx out of range of fptr table"
msgstr "内部错误: symidx 超出 fptr 表的范围"

#: elf/dl-load.c:372
msgid "cannot allocate name record"
msgstr "无法分配名记录"

#: elf/dl-load.c:474 elf/dl-load.c:582 elf/dl-load.c:667 elf/dl-load.c:780
msgid "cannot create cache for search path"
msgstr "无法创建搜索路径缓冲器"

#: elf/dl-load.c:565
msgid "cannot create RUNPATH/RPATH copy"
msgstr "无法创建 RUNPATH/RPATH 的副本"

#: elf/dl-load.c:653
msgid "cannot create search path array"
msgstr "无法创建搜索路径数组"

#: elf/dl-load.c:864
msgid "cannot stat shared object"
msgstr "无法对共享目标进行 stat 操作"

#: elf/dl-load.c:934
msgid "cannot open zero fill device"
msgstr "无法打开零填充设备"

#: elf/dl-load.c:979 elf/dl-load.c:2224
msgid "cannot create shared object descriptor"
msgstr "无法创建共享对象描述符"

#: elf/dl-load.c:998 elf/dl-load.c:1656 elf/dl-load.c:1748
msgid "cannot read file data"
msgstr "无法读入文件数据"

#: elf/dl-load.c:1042
msgid "ELF load command alignment not page-aligned"
msgstr "ELF 加载命令对齐不是按页对齐的"

#: elf/dl-load.c:1049
msgid "ELF load command address/offset not properly aligned"
msgstr "ELF 装入命令的地址/偏移量没有正确地对齐"

#: elf/dl-load.c:1132
msgid "cannot allocate TLS data structures for initial thread"
msgstr ""

#: elf/dl-load.c:1155
msgid "cannot handle TLS data"
msgstr "无法处理 TLS 数据"

#: elf/dl-load.c:1174
msgid "object file has no loadable segments"
msgstr "目标文件没有可加载段"

#: elf/dl-load.c:1210
msgid "failed to map segment from shared object"
msgstr "无法从共享目标中映射段"

#: elf/dl-load.c:1236
msgid "cannot dynamically load executable"
msgstr "无法动态装入可执行文件"

#: elf/dl-load.c:1298
msgid "cannot change memory protections"
msgstr "无法改变内存保护"

#: elf/dl-load.c:1317
msgid "cannot map zero-fill pages"
msgstr "无法映射用零填充的页"

#: elf/dl-load.c:1331
msgid "object file has no dynamic section"
msgstr "目标文件没有动态节"

#: elf/dl-load.c:1354
msgid "shared object cannot be dlopen()ed"
msgstr "无法用 dlopen() 打开共享库"

#: elf/dl-load.c:1367
msgid "cannot allocate memory for program header"
msgstr "无法为程序头分配内存"

#: elf/dl-load.c:1384 elf/dl-open.c:218
msgid "invalid caller"
msgstr "无效的调用者"

#: elf/dl-load.c:1423
msgid "cannot enable executable stack as shared object requires"
msgstr "无法启用共享目标需要的执行栈"

#: elf/dl-load.c:1436
msgid "cannot close file descriptor"
msgstr "无法关闭文件描述符"

#: elf/dl-load.c:1478
msgid "cannot create searchlist"
msgstr "无法创建搜索列表"

#: elf/dl-load.c:1656
msgid "file too short"
msgstr "文件过短"

#: elf/dl-load.c:1685
msgid "invalid ELF header"
msgstr "无效的 ELF 头"

#: elf/dl-load.c:1697
msgid "ELF file data encoding not big-endian"
msgstr "ELF 文件数据编码不是 big-endian"

#: elf/dl-load.c:1699
msgid "ELF file data encoding not little-endian"
msgstr "ELF 文件数据编码不是 little-endian"

#: elf/dl-load.c:1703
msgid "ELF file version ident does not match current one"
msgstr ""

#: elf/dl-load.c:1707
msgid "ELF file OS ABI invalid"
msgstr "ELF 文件 OS ABI 无效"

#: elf/dl-load.c:1709
msgid "ELF file ABI version invalid"
msgstr "ELF 文件 ABI 版本无效"

#: elf/dl-load.c:1712
msgid "internal error"
msgstr "内部错误"

#: elf/dl-load.c:1719
msgid "ELF file version does not match current one"
msgstr "ELF 文件版本与当前版本不匹配"

#: elf/dl-load.c:1727
msgid "only ET_DYN and ET_EXEC can be loaded"
msgstr ""

#: elf/dl-load.c:1733
msgid "ELF file's phentsize not the expected size"
msgstr ""

#: elf/dl-load.c:2240
msgid "wrong ELF class: ELFCLASS64"
msgstr "错误 ELF 类: ELFCLASS64"

#: elf/dl-load.c:2241
msgid "wrong ELF class: ELFCLASS32"
msgstr "错误 ELF 类: ELFCLASS32"

#: elf/dl-load.c:2244
msgid "cannot open shared object file"
msgstr "无法打开共享对象文件"

#: elf/dl-lookup.c:356
msgid "relocation error"
msgstr "重定位错误"

#: elf/dl-lookup.c:384
msgid "symbol lookup error"
msgstr "符号查询错误"

#: elf/dl-open.c:114
msgid "cannot extend global scope"
msgstr "无法扩展全局范围"

#: elf/dl-open.c:512
msgid "TLS generation counter wrapped!  Please report this."
msgstr ""

#: elf/dl-open.c:549
msgid "invalid mode for dlopen()"
msgstr "无效的 dlopen() 模式"

#: elf/dl-open.c:566
msgid "no more namespaces available for dlmopen()"
msgstr ""

#: elf/dl-open.c:579
msgid "invalid target namespace in dlmopen()"
msgstr "dlmopen() 中无效的目标名字空间"

#: elf/dl-reloc.c:54
msgid "cannot allocate memory in static TLS block"
msgstr "无法在静态 TLS 块中分配内存"

#: elf/dl-reloc.c:196
msgid "cannot make segment writable for relocation"
msgstr ""

#: elf/dl-reloc.c:277
#, c-format
msgid "%s: no PLTREL found in object %s\n"
msgstr ""

#: elf/dl-reloc.c:288
#, c-format
msgid "%s: out of memory to store relocation results for %s\n"
msgstr ""

#: elf/dl-reloc.c:304
msgid "cannot restore segment prot after reloc"
msgstr "重定位后无法恢复段 prot"

#: elf/dl-reloc.c:329
msgid "cannot apply additional memory protection after relocation"
msgstr "无法在重定位后应用额外的内存保护"

#: elf/dl-sym.c:162
msgid "RTLD_NEXT used in code not dynamically loaded"
msgstr ""

#: elf/dl-sysdep.c:469 elf/dl-sysdep.c:481
msgid "cannot create capability list"
msgstr "无法创建功能列表"

#: elf/dl-tls.c:825
msgid "cannot create TLS data structures"
msgstr "无法创建 TLS 数据结构"

#: elf/dl-version.c:303
msgid "cannot allocate version reference table"
msgstr "无法分配版本引用表格"

#: elf/ldconfig.c:138
msgid "Print cache"
msgstr "打印缓冲区"

#: elf/ldconfig.c:139
msgid "Generate verbose messages"
msgstr "生成详细消息"

#: elf/ldconfig.c:140
msgid "Don't build cache"
msgstr "不要创建缓冲区"

#: elf/ldconfig.c:141
msgid "Don't generate links"
msgstr "不要生成连接"

#: elf/ldconfig.c:142
msgid "Change to and use ROOT as root directory"
msgstr "进入 ROOT 目录并将其作为根目录"

#: elf/ldconfig.c:142
msgid "ROOT"
msgstr "ROOT"

#: elf/ldconfig.c:143
msgid "CACHE"
msgstr "CACHE"

#: elf/ldconfig.c:143
msgid "Use CACHE as cache file"
msgstr "将 CACHE 用作缓冲区文件"

#: elf/ldconfig.c:144
msgid "CONF"
msgstr "CONF"

#: elf/ldconfig.c:144
msgid "Use CONF as configuration file"
msgstr "将 CONF 用作配置文件"

#: elf/ldconfig.c:145
msgid "Only process directories specified on the command line.  Don't build cache."
msgstr "只在命令行中给出了进程目录。未创建缓冲区。"

#: elf/ldconfig.c:146
msgid "Manually link individual libraries."
msgstr "手工连接独立的库。"

#: elf/ldconfig.c:147
msgid "FORMAT"
msgstr "FORMAT"

#: elf/ldconfig.c:147
msgid "Format to use: new, old or compat (default)"
msgstr "采用的格式：新、旧或兼容(默认)"

#: elf/ldconfig.c:148
msgid "Ignore auxiliary cache file"
msgstr "忽略辅助缓存文件"

#: elf/ldconfig.c:156
msgid "Configure Dynamic Linker Run Time Bindings."
msgstr ""

#: elf/ldconfig.c:319
#, c-format
msgid "Path `%s' given more than once"
msgstr "多次给出路径“%s”"

#: elf/ldconfig.c:359
#, c-format
msgid "%s is not a known library type"
msgstr "%s 不是已知类型的库"

#: elf/ldconfig.c:384
#, c-format
msgid "Can't stat %s"
msgstr "无法对 %s 进行 stat 操作"

#: elf/ldconfig.c:458
#, c-format
msgid "Can't stat %s\n"
msgstr "无法对 %s 进行 stat 操作\n"

#: elf/ldconfig.c:468
#, c-format
msgid "%s is not a symbolic link\n"
msgstr "%s 不是符号连接\n"

#: elf/ldconfig.c:487
#, c-format
msgid "Can't unlink %s"
msgstr ""

#: elf/ldconfig.c:493
#, c-format
msgid "Can't link %s to %s"
msgstr "无法将 %s 连接到 %s"

#: elf/ldconfig.c:499
msgid " (changed)\n"
msgstr " (改变)\n"

#: elf/ldconfig.c:501
msgid " (SKIPPED)\n"
msgstr " (跳过)\n"

#: elf/ldconfig.c:556
#, c-format
msgid "Can't find %s"
msgstr "无法找到 %s"

#: elf/ldconfig.c:572 elf/ldconfig.c:745 elf/ldconfig.c:793 elf/ldconfig.c:827
#, c-format
msgid "Cannot lstat %s"
msgstr "无法对 %s 进行 lstat 操作"

#: elf/ldconfig.c:579
#, c-format
msgid "Ignored file %s since it is not a regular file."
msgstr "由于不是一个普通文件，忽略文件 %s"

#: elf/ldconfig.c:588
#, c-format
msgid "No link created since soname could not be found for %s"
msgstr "未创建链接，因为 %s 无法找到 soname"

#: elf/ldconfig.c:671
#, c-format
msgid "Can't open directory %s"
msgstr "无法打开目录 %s"

#: elf/ldconfig.c:759
#, c-format
msgid "Cannot stat %s"
msgstr "无法对 %s 进行 stat 操作"

#: elf/ldconfig.c:814 elf/readlib.c:91
#, c-format
msgid "Input file %s not found.\n"
msgstr "未找到输入文件 %s。\n"

#: elf/ldconfig.c:888
#, c-format
msgid "libc5 library %s in wrong directory"
msgstr "libc5 的库 %s 处于错误的目录中"

#: elf/ldconfig.c:891
#, c-format
msgid "libc6 library %s in wrong directory"
msgstr "libc5 的库 %s 处于错误的目录中"

#: elf/ldconfig.c:894
#, c-format
msgid "libc4 library %s in wrong directory"
msgstr "libc4 的库 %s 处于错误的目录中"

#: elf/ldconfig.c:922
#, c-format
msgid "libraries %s and %s in directory %s have same soname but different type."
msgstr "目录 %3$s 中的 %1$s 和 %2$s 的 so 名称相同但类型不同。"

#: elf/ldconfig.c:1031
#, c-format
msgid "Can't open configuration file %s"
msgstr "无法打开配置文件 %s"

#: elf/ldconfig.c:1095
#, c-format
msgid "%s:%u: bad syntax in hwcap line"
msgstr ""

#: elf/ldconfig.c:1101
#, c-format
msgid "%s:%u: hwcap index %lu above maximum %u"
msgstr ""

#: elf/ldconfig.c:1108 elf/ldconfig.c:1116
#, c-format
msgid "%s:%u: hwcap index %lu already defined as %s"
msgstr ""

#: elf/ldconfig.c:1119
#, c-format
msgid "%s:%u: duplicate hwcap %lu %s"
msgstr ""

#: elf/ldconfig.c:1141
#, c-format
msgid "need absolute file name for configuration file when using -r"
msgstr ""

#: elf/ldconfig.c:1148 locale/programs/xmalloc.c:70 malloc/obstack.c:434
#: malloc/obstack.c:436 posix/getconf.c:985 posix/getconf.c:1163
#, c-format
msgid "memory exhausted"
msgstr "内存耗尽"

#: elf/ldconfig.c:1178
#, c-format
msgid "%s:%u: cannot read directory %s"
msgstr "%s：%u: 无法读取目录 %s"

#: elf/ldconfig.c:1223
#, c-format
msgid "relative path `%s' used to build cache"
msgstr ""

#: elf/ldconfig.c:1249
#, c-format
msgid "Can't chdir to /"
msgstr "无法改变目录到 /"

#: elf/ldconfig.c:1291
#, c-format
msgid "Can't open cache file directory %s\n"
msgstr "无法打开缓冲文件目录 %s\n"

#: elf/ldd.bash.in:43
msgid "Written by %s and %s.\n"
msgstr "由 %s 和 %s 编写。\n"

#: elf/ldd.bash.in:48
msgid ""
"Usage: ldd [OPTION]... FILE...\n"
"      --help              print this help and exit\n"
"      --version           print version information and exit\n"
"  -d, --data-relocs       process data relocations\n"
"  -r, --function-relocs   process data and function relocations\n"
"  -u, --unused            print unused direct dependencies\n"
"  -v, --verbose           print all information\n"
"For bug reporting instructions, please see:\n"
"<http://www.gnu.org/software/libc/bugs.html>."
msgstr ""

#: elf/ldd.bash.in:80
msgid "ldd: option \\`$1' is ambiguous"
msgstr "ldd: 选项“$1”具有二义性"

#: elf/ldd.bash.in:87
msgid "unrecognized option"
msgstr "无法识别的选项"

#: elf/ldd.bash.in:88 elf/ldd.bash.in:126
msgid "Try \\`ldd --help' for more information."
msgstr "试用“ldd --help”以获取更多信息。"

#: elf/ldd.bash.in:125
msgid "missing file arguments"
msgstr "缺少文件参数"

#. TRANS No such file or directory.  This is a ``file doesn't exist'' error
#. TRANS for ordinary files that are referenced in contexts where they are
#. TRANS expected to already exist.
#: elf/ldd.bash.in:148 sysdeps/gnu/errlist.c:36
msgid "No such file or directory"
msgstr "没有那个文件或目录"

#: elf/ldd.bash.in:151 inet/rcmd.c:483
msgid "not regular file"
msgstr "不是普通文件"

#: elf/ldd.bash.in:154
msgid "warning: you do not have execution permission for"
msgstr "警告: 你没有执行权限 "

#: elf/ldd.bash.in:183
msgid "\tnot a dynamic executable"
msgstr "\t不是动态可执行文件"

#: elf/ldd.bash.in:191
msgid "exited with unknown exit code"
msgstr "以未知的退出码退出"

#: elf/ldd.bash.in:196
msgid "error: you do not have read permission for"
msgstr "错误: 你没有读权限 "

#: elf/readelflib.c:35
#, c-format
msgid "file %s is truncated\n"
msgstr "文件 %s 己被截断\n"

#: elf/readelflib.c:67
#, c-format
msgid "%s is a 32 bit ELF file.\n"
msgstr "%s 是一个 32 位 ELF 文件。\n"

#: elf/readelflib.c:69
#, c-format
msgid "%s is a 64 bit ELF file.\n"
msgstr "%s 是一个 64 位 ELF 文件。\n"

#: elf/readelflib.c:71
#, c-format
msgid "Unknown ELFCLASS in file %s.\n"
msgstr "文件 %s 中未知的 ELFCLASS。\n"

#: elf/readelflib.c:78
#, c-format
msgid "%s is not a shared object file (Type: %d).\n"
msgstr "%s 不是共享目标文件 (类型：%d)。\n"

#: elf/readelflib.c:109
#, c-format
msgid "more than one dynamic segment\n"
msgstr "多于一个动态段\n"

#: elf/readlib.c:97
#, c-format
msgid "Cannot fstat file %s.\n"
msgstr "无法对文件 %s 进行 fstat 操作。\n"

#: elf/readlib.c:108
#, c-format
msgid "File %s is empty, not checked."
msgstr "文件 %s 为空，未检查。"

#: elf/readlib.c:114
#, c-format
msgid "File %s is too small, not checked."
msgstr "文件 %s 过小，未检查。"

#: elf/readlib.c:124
#, c-format
msgid "Cannot mmap file %s.\n"
msgstr "无法对文件 %s 进行 mmap 操作。\n"

#: elf/readlib.c:162
#, c-format
msgid "%s is not an ELF file - it has the wrong magic bytes at the start.\n"
msgstr "%s 不是 ELF 文件 - 它起始的魔数错误。\n"

#: elf/sprof.c:77
msgid "Output selection:"
msgstr "输出选择："

#: elf/sprof.c:79
msgid "print list of count paths and their number of use"
msgstr "打印当前路径的列表和他们的使用次数"

#: elf/sprof.c:81
msgid "generate flat profile with counts and ticks"
msgstr ""

#: elf/sprof.c:82
msgid "generate call graph"
msgstr "生成调用图"

#: elf/sprof.c:89
msgid ""
"Read and display shared object profiling data.\vFor bug reporting instructions, please see:\n"
"<http://www.gnu.org/software/libc/bugs.html>.\n"
msgstr ""

#: elf/sprof.c:94
msgid "SHOBJ [PROFDATA]"
msgstr "SHOBJ [PROFDATA]"

#: elf/sprof.c:400
#, c-format
msgid "failed to load shared object `%s'"
msgstr "装入共享目标文件“%s”失败"

#: elf/sprof.c:409
#, c-format
msgid "cannot create internal descriptors"
msgstr "无法创建内部描述符"

#: elf/sprof.c:528
#, c-format
msgid "Reopening shared object `%s' failed"
msgstr "重现打开共享对象“%s”失败"

#: elf/sprof.c:535 elf/sprof.c:629
#, c-format
msgid "reading of section headers failed"
msgstr "读取节头部失败"

#: elf/sprof.c:543 elf/sprof.c:637
#, c-format
msgid "reading of section header string table failed"
msgstr "读取节头部字符串表失败"

#: elf/sprof.c:569
#, c-format
msgid "*** Cannot read debuginfo file name: %m\n"
msgstr "*** 无法读取调试信息文件名: %m\n"

#: elf/sprof.c:589
#, c-format
msgid "cannot determine file name"
msgstr "无法确定文件名"

#: elf/sprof.c:622
#, c-format
msgid "reading of ELF header failed"
msgstr "读取 ELF 头部失败"

#: elf/sprof.c:658
#, c-format
msgid "*** The file `%s' is stripped: no detailed analysis possible\n"
msgstr "*** 文件“%s”已剥离：不可能进行细节分析\n"

#: elf/sprof.c:688
#, c-format
msgid "failed to load symbol data"
msgstr "装入符号数据失败"

#: elf/sprof.c:755
#, c-format
msgid "cannot load profiling data"
msgstr "无法加载 profile 数据"

#: elf/sprof.c:764
#, c-format
msgid "while stat'ing profiling data file"
msgstr "当分析 profile 数据文件"

#: elf/sprof.c:772
#, c-format
msgid "profiling data file `%s' does not match shared object `%s'"
msgstr ""

#: elf/sprof.c:783
#, c-format
msgid "failed to mmap the profiling data file"
msgstr ""

#: elf/sprof.c:791
#, c-format
msgid "error while closing the profiling data file"
msgstr ""

#: elf/sprof.c:800 elf/sprof.c:870
#, c-format
msgid "cannot create internal descriptor"
msgstr "无法创建内部描述符"

#: elf/sprof.c:846
#, c-format
msgid "`%s' is no correct profile data file for `%s'"
msgstr ""

#: elf/sprof.c:1027 elf/sprof.c:1085
#, c-format
msgid "cannot allocate symbol data"
msgstr "无法分配符号数据"

#: iconv/iconv_charmap.c:176 iconv/iconv_prog.c:316
#, c-format
msgid "error while closing input `%s'"
msgstr "关闭输入“%s”时出错"

#: iconv/iconv_charmap.c:450
#, c-format
msgid "illegal input sequence at position %Zd"
msgstr "位于 %Zd 的非法输入序列"

#: iconv/iconv_charmap.c:469 iconv/iconv_prog.c:526
#, c-format
msgid "incomplete character or shift sequence at end of buffer"
msgstr "位于缓冲区末尾的不完整字符或转义序列"

#: iconv/iconv_charmap.c:514 iconv/iconv_charmap.c:550 iconv/iconv_prog.c:569
#: iconv/iconv_prog.c:605
#, c-format
msgid "error while reading the input"
msgstr "读取输入时出错"

#: iconv/iconv_charmap.c:532 iconv/iconv_prog.c:587
#, c-format
msgid "unable to allocate buffer for input"
msgstr "无法为输入分配缓冲区"

#: iconv/iconv_prog.c:60
msgid "Input/Output format specification:"
msgstr "输入/输出格式规范："

#: iconv/iconv_prog.c:61
msgid "encoding of original text"
msgstr "原始文本编码"

#: iconv/iconv_prog.c:62
msgid "encoding for output"
msgstr "输出编码"

#: iconv/iconv_prog.c:63
msgid "Information:"
msgstr "信息："

#: iconv/iconv_prog.c:64
msgid "list all known coded character sets"
msgstr "列举所有已知的字符集"

#: iconv/iconv_prog.c:65 locale/programs/localedef.c:127
msgid "Output control:"
msgstr "输出控制："

#: iconv/iconv_prog.c:66
msgid "omit invalid characters from output"
msgstr "从输出中忽略无效的字符"

#: iconv/iconv_prog.c:67
msgid "output file"
msgstr "输出文件"

#: iconv/iconv_prog.c:68
msgid "suppress warnings"
msgstr "关闭警告"

#: iconv/iconv_prog.c:69
msgid "print progress information"
msgstr "打印进度信息"

#: iconv/iconv_prog.c:74
msgid "Convert encoding of given files from one encoding to another."
msgstr "转换给定文件的编码。"

#: iconv/iconv_prog.c:78
msgid "[FILE...]"
msgstr "[文件...]"

#: iconv/iconv_prog.c:200
#, c-format
msgid "cannot open output file"
msgstr "无法打开输出文件"

#: iconv/iconv_prog.c:242
#, c-format
msgid "conversions from `%s' and to `%s' are not supported"
msgstr "不支持从“%s”到“%s”的转换"

#: iconv/iconv_prog.c:247
#, c-format
msgid "conversion from `%s' is not supported"
msgstr "不支持以“%s”为源头的转换"

#: iconv/iconv_prog.c:254
#, c-format
msgid "conversion to `%s' is not supported"
msgstr "不支持以“%s”为目标的转换"

#: iconv/iconv_prog.c:258
#, c-format
msgid "conversion from `%s' to `%s' is not supported"
msgstr "不支持从“%s”到“%s”的转换"

#: iconv/iconv_prog.c:268
#, c-format
msgid "failed to start conversion processing"
msgstr "启动转换处理失败"

#: iconv/iconv_prog.c:362
#, c-format
msgid "error while closing output file"
msgstr "关闭输出文件时出错"

#: iconv/iconv_prog.c:471 iconv/iconv_prog.c:497
#, c-format
msgid "conversion stopped due to problem in writing the output"
msgstr "由于写入输出时出现的问题转换停止"

#: iconv/iconv_prog.c:522
#, c-format
msgid "illegal input sequence at position %ld"
msgstr "未知 %ld 处的非法输入序列"

#: iconv/iconv_prog.c:530
#, c-format
msgid "internal error (illegal descriptor)"
msgstr "内部错误 (非法的描述符)"

#: iconv/iconv_prog.c:533
#, c-format
msgid "unknown iconv() error %d"
msgstr "未知的 iconv() 错误 %d"

#: iconv/iconv_prog.c:779
msgid ""
"The following list contain all the coded character sets known.  This does\n"
"not necessarily mean that all combinations of these names can be used for\n"
"the FROM and TO command line parameters.  One coded character set can be\n"
"listed with several different names (aliases).\n"
"\n"
"  "
msgstr ""

#: iconv/iconvconfig.c:110
msgid "Create fastloading iconv module configuration file."
msgstr "创建快速装入 iconv 模块配置文件。"

#: iconv/iconvconfig.c:114
msgid "[DIR...]"
msgstr "[目录...]"

#: iconv/iconvconfig.c:127
msgid "Prefix used for all file accesses"
msgstr "用于所有文件访问的前缀"

#: iconv/iconvconfig.c:128
msgid "Put output in FILE instead of installed location (--prefix does not apply to FILE)"
msgstr ""

#: iconv/iconvconfig.c:132
msgid "Do not search standard directories, only those on the command line"
msgstr ""

#: iconv/iconvconfig.c:301
#, c-format
msgid "Directory arguments required when using --nostdlib"
msgstr ""

#: iconv/iconvconfig.c:343 locale/programs/localedef.c:291
#, c-format
msgid "no output file produced because warnings were issued"
msgstr "由于出现警告而未生成输出文件"

#: iconv/iconvconfig.c:429
#, c-format
msgid "while inserting in search tree"
msgstr "插入搜索树时"

#: iconv/iconvconfig.c:1238
#, c-format
msgid "cannot generate output file"
msgstr "无法生成输出文件"

#: inet/rcmd.c:157
msgid "rcmd: Cannot allocate memory\n"
msgstr "rcmd：无法分配内存\n"

#: inet/rcmd.c:172
msgid "rcmd: socket: All ports in use\n"
msgstr "rcmd：socket：所有端口都已在使用了\n"

#: inet/rcmd.c:200
#, c-format
msgid "connect to address %s: "
msgstr "连接到地址 %s："

#: inet/rcmd.c:213
#, c-format
msgid "Trying %s...\n"
msgstr "正在尝试 %s...\n"

#: inet/rcmd.c:249
#, c-format
msgid "rcmd: write (setting up stderr): %m\n"
msgstr ""

#: inet/rcmd.c:265
#, c-format
msgid "rcmd: poll (setting up stderr): %m\n"
msgstr ""

#: inet/rcmd.c:268
msgid "poll: protocol failure in circuit setup\n"
msgstr ""

#: inet/rcmd.c:301
msgid "socket: protocol failure in circuit setup\n"
msgstr ""

#: inet/rcmd.c:325
#, c-format
msgid "rcmd: %s: short read"
msgstr ""

#: inet/rcmd.c:481
msgid "lstat failed"
msgstr "lstat 操作失败"

#: inet/rcmd.c:488
msgid "cannot open"
msgstr "无法打开"

#: inet/rcmd.c:490
msgid "fstat failed"
msgstr "fstat 失败"

#: inet/rcmd.c:492
msgid "bad owner"
msgstr "错误的拥有者"

#: inet/rcmd.c:494
msgid "writeable by other than owner"
msgstr "可由除所有者之外的人写入"

#: inet/rcmd.c:496
msgid "hard linked somewhere"
msgstr "某处的硬连接"

#: inet/ruserpass.c:170 inet/ruserpass.c:193
msgid "out of memory"
msgstr "内存不足"

#: inet/ruserpass.c:184
msgid "Error: .netrc file is readable by others."
msgstr "错误：.netrc 对其它人是可读的。"

#: inet/ruserpass.c:185
msgid "Remove password or make file unreadable by others."
msgstr "删除不能由其它人读入的口令或 make 文件"

#: inet/ruserpass.c:277
#, c-format
msgid "Unknown .netrc keyword %s"
msgstr "未知的 .netrc 关键字 %s"

#: libidn/nfkc.c:464
msgid "Character out of range for UTF-8"
msgstr "字符超出 UTF-8 的范围"

#: locale/programs/charmap-dir.c:59
#, c-format
msgid "cannot read character map directory `%s'"
msgstr "无法读入字母映射目录“%s”"

#: locale/programs/charmap.c:138
#, c-format
msgid "character map file `%s' not found"
msgstr "找不到字符映射文件“%s”"

#: locale/programs/charmap.c:195
#, c-format
msgid "default character map file `%s' not found"
msgstr "找不到默认字符映射文件“%s”"

#: locale/programs/charmap.c:258
#, c-format
msgid "character map `%s' is not ASCII compatible, locale not ISO C compliant\n"
msgstr ""

#: locale/programs/charmap.c:337
#, c-format
msgid "%s: <mb_cur_max> must be greater than <mb_cur_min>\n"
msgstr "%s：<mb_cur_max> 必须大于 <mb_cur_min>\n"

#: locale/programs/charmap.c:357 locale/programs/charmap.c:374
#: locale/programs/repertoire.c:174
#, c-format
msgid "syntax error in prolog: %s"
msgstr "序言中语法错误：%s"

#: locale/programs/charmap.c:358
msgid "invalid definition"
msgstr "无效的定义"

#: locale/programs/charmap.c:375 locale/programs/locfile.c:126
#: locale/programs/locfile.c:153 locale/programs/repertoire.c:175
msgid "bad argument"
msgstr "错误的参数"

#: locale/programs/charmap.c:403
#, c-format
msgid "duplicate definition of <%s>"
msgstr "重复定义 <%s>"

#: locale/programs/charmap.c:410
#, c-format
msgid "value for <%s> must be 1 or greater"
msgstr "<%s>的值必须是 1 或更大"

#: locale/programs/charmap.c:422
#, c-format
msgid "value of <%s> must be greater or equal than the value of <%s>"
msgstr "<%s> 的值必须大于等于 <%s> 的值"

#: locale/programs/charmap.c:445 locale/programs/repertoire.c:183
#, c-format
msgid "argument to <%s> must be a single character"
msgstr "<%s>的参数必须是单个字符"

#: locale/programs/charmap.c:471
msgid "character sets with locking states are not supported"
msgstr "不支持带有锁定状态的字符集"

#: locale/programs/charmap.c:498 locale/programs/charmap.c:552
#: locale/programs/charmap.c:584 locale/programs/charmap.c:678
#: locale/programs/charmap.c:733 locale/programs/charmap.c:774
#: locale/programs/charmap.c:815
#, c-format
msgid "syntax error in %s definition: %s"
msgstr "%s 的定义中的语法错误：%s"

#: locale/programs/charmap.c:499 locale/programs/charmap.c:679
#: locale/programs/charmap.c:775 locale/programs/repertoire.c:230
msgid "no symbolic name given"
msgstr "没有给出符号名"

#: locale/programs/charmap.c:553
msgid "invalid encoding given"
msgstr "给出无效的编码"

#: locale/programs/charmap.c:562
msgid "too few bytes in character encoding"
msgstr "字符编码中字节数过少"

#: locale/programs/charmap.c:564
msgid "too many bytes in character encoding"
msgstr "字符编码中字节数过多"

#: locale/programs/charmap.c:586 locale/programs/charmap.c:734
#: locale/programs/charmap.c:817 locale/programs/repertoire.c:296
msgid "no symbolic name given for end of range"
msgstr "没有为范围的结束给出符号化的名称"

#: locale/programs/charmap.c:610 locale/programs/ld-address.c:600
#: locale/programs/ld-collate.c:2767 locale/programs/ld-collate.c:3924
#: locale/programs/ld-ctype.c:2232 locale/programs/ld-ctype.c:2984
#: locale/programs/ld-identification.c:452
#: locale/programs/ld-measurement.c:238 locale/programs/ld-messages.c:332
#: locale/programs/ld-monetary.c:943 locale/programs/ld-name.c:307
#: locale/programs/ld-numeric.c:368 locale/programs/ld-paper.c:241
#: locale/programs/ld-telephone.c:313 locale/programs/ld-time.c:1221
#: locale/programs/repertoire.c:313
#, c-format
msgid "%1$s: definition does not end with `END %1$s'"
msgstr "%1$s：定义不以“END %1$s”结尾"

#: locale/programs/charmap.c:643
msgid "only WIDTH definitions are allowed to follow the CHARMAP definition"
msgstr ""

#: locale/programs/charmap.c:651 locale/programs/charmap.c:714
#, c-format
msgid "value for %s must be an integer"
msgstr "%s 的值必须为整数"

#: locale/programs/charmap.c:842
#, c-format
msgid "%s: error in state machine"
msgstr "%s：状态机出错"

#: locale/programs/charmap.c:850 locale/programs/ld-address.c:616
#: locale/programs/ld-collate.c:2764 locale/programs/ld-collate.c:4115
#: locale/programs/ld-ctype.c:2229 locale/programs/ld-ctype.c:3001
#: locale/programs/ld-identification.c:468
#: locale/programs/ld-measurement.c:254 locale/programs/ld-messages.c:348
#: locale/programs/ld-monetary.c:959 locale/programs/ld-name.c:323
#: locale/programs/ld-numeric.c:384 locale/programs/ld-paper.c:257
#: locale/programs/ld-telephone.c:329 locale/programs/ld-time.c:1237
#: locale/programs/locfile.c:826 locale/programs/repertoire.c:324
#, c-format
msgid "%s: premature end of file"
msgstr "%s：文件不完整"

#: locale/programs/charmap.c:869 locale/programs/charmap.c:880
#, c-format
msgid "unknown character `%s'"
msgstr "未知的字符“%s”"

#: locale/programs/charmap.c:888
#, c-format
msgid "number of bytes for byte sequence of beginning and end of range not the same: %d vs %d"
msgstr ""

#: locale/programs/charmap.c:993 locale/programs/ld-collate.c:3047
#: locale/programs/repertoire.c:419
msgid "invalid names for character range"
msgstr ""

#: locale/programs/charmap.c:1005 locale/programs/repertoire.c:431
msgid "hexadecimal range format should use only capital characters"
msgstr ""

#: locale/programs/charmap.c:1023 locale/programs/repertoire.c:449
#, c-format
msgid "<%s> and <%s> are invalid names for range"
msgstr "<%s> 和 <%s> 是无效的范围名"

#: locale/programs/charmap.c:1029 locale/programs/repertoire.c:456
msgid "upper limit in range is smaller than lower limit"
msgstr "范围的上限小于下限"

#: locale/programs/charmap.c:1087
msgid "resulting bytes for range not representable."
msgstr ""

#: locale/programs/ld-address.c:133 locale/programs/ld-collate.c:1556
#: locale/programs/ld-ctype.c:420 locale/programs/ld-identification.c:133
#: locale/programs/ld-measurement.c:94 locale/programs/ld-messages.c:97
#: locale/programs/ld-monetary.c:194 locale/programs/ld-name.c:94
#: locale/programs/ld-numeric.c:98 locale/programs/ld-paper.c:91
#: locale/programs/ld-telephone.c:94 locale/programs/ld-time.c:159
#, c-format
msgid "No definition for %s category found"
msgstr ""

#: locale/programs/ld-address.c:144 locale/programs/ld-address.c:182
#: locale/programs/ld-address.c:200 locale/programs/ld-address.c:229
#: locale/programs/ld-address.c:301 locale/programs/ld-address.c:320
#: locale/programs/ld-address.c:333 locale/programs/ld-identification.c:146
#: locale/programs/ld-measurement.c:105 locale/programs/ld-monetary.c:206
#: locale/programs/ld-monetary.c:250 locale/programs/ld-monetary.c:266
#: locale/programs/ld-monetary.c:278 locale/programs/ld-name.c:105
#: locale/programs/ld-name.c:142 locale/programs/ld-numeric.c:112
#: locale/programs/ld-numeric.c:126 locale/programs/ld-paper.c:102
#: locale/programs/ld-paper.c:111 locale/programs/ld-telephone.c:105
#: locale/programs/ld-telephone.c:162 locale/programs/ld-time.c:175
#: locale/programs/ld-time.c:196
#, c-format
msgid "%s: field `%s' not defined"
msgstr "%s：域“%s”未定义"

#: locale/programs/ld-address.c:156 locale/programs/ld-address.c:208
#: locale/programs/ld-address.c:238 locale/programs/ld-address.c:276
#: locale/programs/ld-name.c:117 locale/programs/ld-telephone.c:117
#, c-format
msgid "%s: field `%s' must not be empty"
msgstr "%s：域“%s”不能为空"

#: locale/programs/ld-address.c:168
#, c-format
msgid "%s: invalid escape `%%%c' sequence in field `%s'"
msgstr "%1$s：域“%3$s”中无效的转义“%%%2$c”序列"

#: locale/programs/ld-address.c:219
#, c-format
msgid "%s: terminology language code `%s' not defined"
msgstr ""

#: locale/programs/ld-address.c:244
#, c-format
msgid "%s: field `%s' must not be defined"
msgstr "%s：域“%s”必须未定义"

#: locale/programs/ld-address.c:258 locale/programs/ld-address.c:287
#, c-format
msgid "%s: language abbreviation `%s' not defined"
msgstr "%s：未定义的语言缩写“%s”"

#: locale/programs/ld-address.c:265 locale/programs/ld-address.c:293
#: locale/programs/ld-address.c:327 locale/programs/ld-address.c:339
#, c-format
msgid "%s: `%s' value does not match `%s' value"
msgstr "%s：“%s”的值不能匹配“%s”的值"

#: locale/programs/ld-address.c:312
#, c-format
msgid "%s: numeric country code `%d' not valid"
msgstr "%s：数值国家编码“%d”无效"

#: locale/programs/ld-address.c:508 locale/programs/ld-address.c:545
#: locale/programs/ld-address.c:583 locale/programs/ld-ctype.c:2608
#: locale/programs/ld-identification.c:364
#: locale/programs/ld-measurement.c:221 locale/programs/ld-messages.c:301
#: locale/programs/ld-monetary.c:701 locale/programs/ld-monetary.c:736
#: locale/programs/ld-monetary.c:777 locale/programs/ld-name.c:280
#: locale/programs/ld-numeric.c:263 locale/programs/ld-paper.c:224
#: locale/programs/ld-telephone.c:288 locale/programs/ld-time.c:1126
#: locale/programs/ld-time.c:1168
#, c-format
msgid "%s: field `%s' declared more than once"
msgstr "%s：多次声明域“%s”"

#: locale/programs/ld-address.c:512 locale/programs/ld-address.c:550
#: locale/programs/ld-identification.c:368 locale/programs/ld-messages.c:311
#: locale/programs/ld-monetary.c:705 locale/programs/ld-monetary.c:740
#: locale/programs/ld-name.c:284 locale/programs/ld-numeric.c:267
#: locale/programs/ld-telephone.c:292 locale/programs/ld-time.c:1020
#: locale/programs/ld-time.c:1089 locale/programs/ld-time.c:1131
#, c-format
msgid "%s: unknown character in field `%s'"
msgstr "%s：域“%s”中含有未知字符"

#: locale/programs/ld-address.c:597 locale/programs/ld-collate.c:3922
#: locale/programs/ld-ctype.c:2981 locale/programs/ld-identification.c:449
#: locale/programs/ld-measurement.c:235 locale/programs/ld-messages.c:330
#: locale/programs/ld-monetary.c:941 locale/programs/ld-name.c:305
#: locale/programs/ld-numeric.c:366 locale/programs/ld-paper.c:239
#: locale/programs/ld-telephone.c:311 locale/programs/ld-time.c:1219
#, c-format
msgid "%s: incomplete `END' line"
msgstr "%s：不完整的“END”行"

#: locale/programs/ld-address.c:607 locale/programs/ld-collate.c:542
#: locale/programs/ld-collate.c:594 locale/programs/ld-collate.c:890
#: locale/programs/ld-collate.c:903 locale/programs/ld-collate.c:2733
#: locale/programs/ld-collate.c:2754 locale/programs/ld-collate.c:4105
#: locale/programs/ld-ctype.c:1960 locale/programs/ld-ctype.c:2219
#: locale/programs/ld-ctype.c:2806 locale/programs/ld-ctype.c:2992
#: locale/programs/ld-identification.c:459
#: locale/programs/ld-measurement.c:245 locale/programs/ld-messages.c:339
#: locale/programs/ld-monetary.c:950 locale/programs/ld-name.c:314
#: locale/programs/ld-numeric.c:375 locale/programs/ld-paper.c:248
#: locale/programs/ld-telephone.c:320 locale/programs/ld-time.c:1228
#, c-format
msgid "%s: syntax error"
msgstr "%s：语法错误"

#: locale/programs/ld-collate.c:417
#, c-format
msgid "`%.*s' already defined in charmap"
msgstr "已经在字符映射表中定义了“%.*s”"

#: locale/programs/ld-collate.c:426
#, c-format
msgid "`%.*s' already defined in repertoire"
msgstr "已经在指令表中定义了“%.*s”"

#: locale/programs/ld-collate.c:433
#, c-format
msgid "`%.*s' already defined as collating symbol"
msgstr ""

#: locale/programs/ld-collate.c:440
#, c-format
msgid "`%.*s' already defined as collating element"
msgstr ""

#: locale/programs/ld-collate.c:471 locale/programs/ld-collate.c:497
#, c-format
msgid "%s: `forward' and `backward' are mutually excluding each other"
msgstr "%s：“forward”和“backward”是互斥的"

#: locale/programs/ld-collate.c:481 locale/programs/ld-collate.c:507
#: locale/programs/ld-collate.c:523
#, c-format
msgid "%s: `%s' mentioned more than once in definition of weight %d"
msgstr ""

#: locale/programs/ld-collate.c:579
#, c-format
msgid "%s: too many rules; first entry only had %d"
msgstr "%s：规则过多；第一个条目只含有 %d"

#: locale/programs/ld-collate.c:615
#, c-format
msgid "%s: not enough sorting rules"
msgstr "%s：排序规则不足"

#: locale/programs/ld-collate.c:780
#, c-format
msgid "%s: empty weight string not allowed"
msgstr "%s：不允许空权字符串"

#: locale/programs/ld-collate.c:875
#, c-format
msgid "%s: weights must use the same ellipsis symbol as the name"
msgstr ""

#: locale/programs/ld-collate.c:931
#, c-format
msgid "%s: too many values"
msgstr "%s：值过多"

#: locale/programs/ld-collate.c:1051 locale/programs/ld-collate.c:1226
#, c-format
msgid "order for `%.*s' already defined at %s:%Zu"
msgstr ""

#: locale/programs/ld-collate.c:1101
#, c-format
msgid "%s: the start and the end symbol of a range must stand for characters"
msgstr ""

#: locale/programs/ld-collate.c:1128
#, c-format
msgid "%s: byte sequences of first and last character must have the same length"
msgstr "%s：字节序列的第一个和最后一个字符的长度必须相同"

#: locale/programs/ld-collate.c:1170
#, c-format
msgid "%s: byte sequence of first character of range is not lower than that of the last character"
msgstr "%s：范围的字节序列的第一个字符不小于最后一个字符"

#: locale/programs/ld-collate.c:1295
#, c-format
msgid "%s: symbolic range ellipsis must not directly follow `order_start'"
msgstr ""

#: locale/programs/ld-collate.c:1299
#, c-format
msgid "%s: symbolic range ellipsis must not be directly followed by `order_end'"
msgstr ""

#: locale/programs/ld-collate.c:1319 locale/programs/ld-ctype.c:1477
#, c-format
msgid "`%s' and `%.*s' are not valid names for symbolic range"
msgstr "“%s”和“%.*s”是无效的符号范围名"

#: locale/programs/ld-collate.c:1369 locale/programs/ld-collate.c:3858
#, c-format
msgid "%s: order for `%.*s' already defined at %s:%Zu"
msgstr ""

#: locale/programs/ld-collate.c:1378
#, c-format
msgid "%s: `%s' must be a character"
msgstr "%s：“%s”必须是一个字符"

#: locale/programs/ld-collate.c:1573
#, c-format
msgid "%s: `position' must be used for a specific level in all sections or none"
msgstr ""

#: locale/programs/ld-collate.c:1598
#, c-format
msgid "symbol `%s' not defined"
msgstr "符号“%s”未定义"

#: locale/programs/ld-collate.c:1674 locale/programs/ld-collate.c:1780
#, c-format
msgid "symbol `%s' has the same encoding as"
msgstr ""

#: locale/programs/ld-collate.c:1678 locale/programs/ld-collate.c:1784
#, c-format
msgid "symbol `%s'"
msgstr "符号“%s”"

#: locale/programs/ld-collate.c:1826
#, c-format
msgid "no definition of `UNDEFINED'"
msgstr "没有关于“UNDEFINIED”的定义"

#: locale/programs/ld-collate.c:1855
#, c-format
msgid "too many errors; giving up"
msgstr "错误过多；放弃"

#: locale/programs/ld-collate.c:2659 locale/programs/ld-collate.c:4044
#, c-format
msgid "%s: nested conditionals not supported"
msgstr "%s: 不支持嵌套条件"

#: locale/programs/ld-collate.c:2677
#, c-format
msgid "%s: more then one 'else'"
msgstr "%s: 多于一个'else'"

#: locale/programs/ld-collate.c:2852
#, c-format
msgid "%s: duplicate definition of `%s'"
msgstr "%s：重复定义“%s”"

#: locale/programs/ld-collate.c:2888
#, c-format
msgid "%s: duplicate declaration of section `%s'"
msgstr "%s：重复声明节“%s”"

#: locale/programs/ld-collate.c:3027
#, c-format
msgid "%s: unknown character in collating symbol name"
msgstr ""

#: locale/programs/ld-collate.c:3159
#, c-format
msgid "%s: unknown character in equivalent definition name"
msgstr "%s：等价定义名中未知的字符"

#: locale/programs/ld-collate.c:3172
#, c-format
msgid "%s: unknown character in equivalent definition value"
msgstr "%s：等价定义值中未知的字符"

#: locale/programs/ld-collate.c:3182
#, c-format
msgid "%s: unknown symbol `%s' in equivalent definition"
msgstr "%s：等价定义中未知的符号“%s”"

#: locale/programs/ld-collate.c:3191
msgid "error while adding equivalent collating symbol"
msgstr ""

#: locale/programs/ld-collate.c:3221
#, c-format
msgid "duplicate definition of script `%s'"
msgstr "重复定义脚本“%s”"

#: locale/programs/ld-collate.c:3269
#, c-format
msgid "%s: unknown section name `%.*s'"
msgstr "%s：未知的节名“%.*s”"

#: locale/programs/ld-collate.c:3298
#, c-format
msgid "%s: multiple order definitions for section `%s'"
msgstr "%s：关于“%s”节出现多个顺序定义"

#: locale/programs/ld-collate.c:3326
#, c-format
msgid "%s: invalid number of sorting rules"
msgstr "%s：排序规则的数量无效"

#: locale/programs/ld-collate.c:3353
#, c-format
msgid "%s: multiple order definitions for unnamed section"
msgstr "%s：关于未命名节出现多个顺序定义"

#: locale/programs/ld-collate.c:3407 locale/programs/ld-collate.c:3537
#: locale/programs/ld-collate.c:3900
#, c-format
msgid "%s: missing `order_end' keyword"
msgstr "%s：遗漏关键字“order_end”"

#: locale/programs/ld-collate.c:3470
#, c-format
msgid "%s: order for collating symbol %.*s not yet defined"
msgstr ""

#: locale/programs/ld-collate.c:3488
#, c-format
msgid "%s: order for collating element %.*s not yet defined"
msgstr ""

#: locale/programs/ld-collate.c:3499
#, c-format
msgid "%s: cannot reorder after %.*s: symbol not known"
msgstr ""

#: locale/programs/ld-collate.c:3551 locale/programs/ld-collate.c:3912
#, c-format
msgid "%s: missing `reorder-end' keyword"
msgstr "%s：以后关键字“reorder-end”"

#: locale/programs/ld-collate.c:3585 locale/programs/ld-collate.c:3783
#, c-format
msgid "%s: section `%.*s' not known"
msgstr "%s：未知的节“%.*s”"

#: locale/programs/ld-collate.c:3650
#, c-format
msgid "%s: bad symbol <%.*s>"
msgstr ""

#: locale/programs/ld-collate.c:3846
#, c-format
msgid "%s: cannot have `%s' as end of ellipsis range"
msgstr ""

#: locale/programs/ld-collate.c:3896
#, c-format
msgid "%s: empty category description not allowed"
msgstr "%s：不允许空范畴描述"

#: locale/programs/ld-collate.c:3915
#, c-format
msgid "%s: missing `reorder-sections-end' keyword"
msgstr "%s：遗漏关键字“reorder-sections-end”"

#: locale/programs/ld-collate.c:4077
#, c-format
msgid "%s: '%s' without matching 'ifdef' or 'ifndef'"
msgstr ""

#: locale/programs/ld-collate.c:4095
#, c-format
msgid "%s: 'endif' without matching 'ifdef' or 'ifndef'"
msgstr ""

#: locale/programs/ld-ctype.c:439
#, c-format
msgid "No character set name specified in charmap"
msgstr "字符映射表中未给出字符集名称"

#: locale/programs/ld-ctype.c:468
#, c-format
msgid "character L'\\u%0*x' in class `%s' must be in class `%s'"
msgstr ""

# msgstr "类“%2$s”中的字符 L'\\u%0*x' 必须属于类“%3$s”"
#: locale/programs/ld-ctype.c:483
#, c-format
msgid "character L'\\u%0*x' in class `%s' must not be in class `%s'"
msgstr ""

#: locale/programs/ld-ctype.c:497 locale/programs/ld-ctype.c:555
#, c-format
msgid "internal error in %s, line %u"
msgstr "在 %s 的第 %u 行出现内部错误"

#: locale/programs/ld-ctype.c:526
#, c-format
msgid "character '%s' in class `%s' must be in class `%s'"
msgstr "类“%2$s”中的字符“%1$s”必须属于类“%3$s”"

#: locale/programs/ld-ctype.c:542
#, c-format
msgid "character '%s' in class `%s' must not be in class `%s'"
msgstr "类“%2$s”中的字符“%1$s”不得属于类“%3$s”"

#: locale/programs/ld-ctype.c:572 locale/programs/ld-ctype.c:610
#, c-format
msgid "<SP> character not in class `%s'"
msgstr "字符 <SP> 不在类“%s”中"

#: locale/programs/ld-ctype.c:584 locale/programs/ld-ctype.c:621
#, c-format
msgid "<SP> character must not be in class `%s'"
msgstr "字符 <SP> 不能属于类“%s”"

#: locale/programs/ld-ctype.c:599
#, c-format
msgid "character <SP> not defined in character map"
msgstr "字符映射中未定义字符 <SP>"

#: locale/programs/ld-ctype.c:714
#, c-format
msgid "`digit' category has not entries in groups of ten"
msgstr ""

#: locale/programs/ld-ctype.c:763
#, c-format
msgid "no input digits defined and none of the standard names in the charmap"
msgstr ""

#: locale/programs/ld-ctype.c:828
#, c-format
msgid "not all characters used in `outdigit' are available in the charmap"
msgstr ""

#: locale/programs/ld-ctype.c:845
#, c-format
msgid "not all characters used in `outdigit' are available in the repertoire"
msgstr ""

#: locale/programs/ld-ctype.c:1245
#, c-format
msgid "character class `%s' already defined"
msgstr "字符类“%s”已定义"

#: locale/programs/ld-ctype.c:1251
#, c-format
msgid "implementation limit: no more than %Zd character classes allowed"
msgstr ""

#: locale/programs/ld-ctype.c:1277
#, c-format
msgid "character map `%s' already defined"
msgstr ""

#: locale/programs/ld-ctype.c:1283
#, c-format
msgid "implementation limit: no more than %d character maps allowed"
msgstr "实现限制：不得多于 %d 个字符映射表"

#: locale/programs/ld-ctype.c:1548 locale/programs/ld-ctype.c:1673
#: locale/programs/ld-ctype.c:1779 locale/programs/ld-ctype.c:2471
#: locale/programs/ld-ctype.c:3467
#, c-format
msgid "%s: field `%s' does not contain exactly ten entries"
msgstr "%s：域“%s”含有条目的个数不是十个"

#: locale/programs/ld-ctype.c:1576 locale/programs/ld-ctype.c:2150
#, c-format
msgid "to-value <U%0*X> of range is smaller than from-value <U%0*X>"
msgstr ""

#: locale/programs/ld-ctype.c:1703
msgid "start and end character sequence of range must have the same length"
msgstr "范围的起始和终止字符序列必须具有相同的长度"

#: locale/programs/ld-ctype.c:1710
msgid "to-value character sequence is smaller than from-value sequence"
msgstr ""

#: locale/programs/ld-ctype.c:2070 locale/programs/ld-ctype.c:2121
msgid "premature end of `translit_ignore' definition"
msgstr ""

#: locale/programs/ld-ctype.c:2076 locale/programs/ld-ctype.c:2127
#: locale/programs/ld-ctype.c:2169
msgid "syntax error"
msgstr "语法错误"

#: locale/programs/ld-ctype.c:2303
#, c-format
msgid "%s: syntax error in definition of new character class"
msgstr "%s：在定义新字符集合中出现语法错误"

#: locale/programs/ld-ctype.c:2318
#, c-format
msgid "%s: syntax error in definition of new character map"
msgstr "%s：在新字符映射中出现语法错误"

#: locale/programs/ld-ctype.c:2493
msgid "ellipsis range must be marked by two operands of same type"
msgstr ""

#: locale/programs/ld-ctype.c:2502
msgid "with symbolic name range values the absolute ellipsis `...' must not be used"
msgstr ""

#: locale/programs/ld-ctype.c:2517
msgid "with UCS range values one must use the hexadecimal symbolic ellipsis `..'"
msgstr ""

#: locale/programs/ld-ctype.c:2531
msgid "with character code range values one must use the absolute ellipsis `...'"
msgstr ""

#: locale/programs/ld-ctype.c:2682
#, c-format
msgid "duplicated definition for mapping `%s'"
msgstr "重复定义映射“%s”"

#: locale/programs/ld-ctype.c:2768 locale/programs/ld-ctype.c:2912
#, c-format
msgid "%s: `translit_start' section does not end with `translit_end'"
msgstr "%s：“translit_start”节不以“translit_end”结束"

#: locale/programs/ld-ctype.c:2863
#, c-format
msgid "%s: duplicate `default_missing' definition"
msgstr "%s：重复定义“default_missing”"

#: locale/programs/ld-ctype.c:2868
msgid "previous definition was here"
msgstr "前一个定义在这里"

#: locale/programs/ld-ctype.c:2890
#, c-format
msgid "%s: no representable `default_missing' definition found"
msgstr ""

#: locale/programs/ld-ctype.c:3043 locale/programs/ld-ctype.c:3127
#: locale/programs/ld-ctype.c:3147 locale/programs/ld-ctype.c:3168
#: locale/programs/ld-ctype.c:3189 locale/programs/ld-ctype.c:3210
#: locale/programs/ld-ctype.c:3231 locale/programs/ld-ctype.c:3271
#: locale/programs/ld-ctype.c:3292 locale/programs/ld-ctype.c:3359
#: locale/programs/ld-ctype.c:3401 locale/programs/ld-ctype.c:3426
#, c-format
msgid "%s: character `%s' not defined while needed as default value"
msgstr ""

#: locale/programs/ld-ctype.c:3048 locale/programs/ld-ctype.c:3132
#: locale/programs/ld-ctype.c:3152 locale/programs/ld-ctype.c:3173
#: locale/programs/ld-ctype.c:3194 locale/programs/ld-ctype.c:3215
#: locale/programs/ld-ctype.c:3236 locale/programs/ld-ctype.c:3276
#: locale/programs/ld-ctype.c:3297 locale/programs/ld-ctype.c:3364
#, c-format
msgid "%s: character `%s' in charmap not representable with one byte"
msgstr ""

#: locale/programs/ld-ctype.c:3408 locale/programs/ld-ctype.c:3433
#, c-format
msgid "%s: character `%s' needed as default value not representable with one byte"
msgstr "%s：需要作为默认值的字符“%s”无法以单个字节来表示"

#: locale/programs/ld-ctype.c:3489
#, c-format
msgid "no output digits defined and none of the standard names in the charmap"
msgstr ""

#: locale/programs/ld-ctype.c:3780
#, c-format
msgid "%s: transliteration data from locale `%s' not available"
msgstr ""

#: locale/programs/ld-ctype.c:3881
#, c-format
msgid "%s: table for class \"%s\": %lu bytes\n"
msgstr ""

#: locale/programs/ld-ctype.c:3950
#, c-format
msgid "%s: table for map \"%s\": %lu bytes\n"
msgstr ""

#: locale/programs/ld-ctype.c:4083
#, c-format
msgid "%s: table for width: %lu bytes\n"
msgstr ""

#: locale/programs/ld-identification.c:170
#, c-format
msgid "%s: no identification for category `%s'"
msgstr ""

#: locale/programs/ld-identification.c:435
#, c-format
msgid "%s: duplicate category version definition"
msgstr ""

#: locale/programs/ld-measurement.c:113
#, c-format
msgid "%s: invalid value for field `%s'"
msgstr "%s：域“%s”中的值无效"

#: locale/programs/ld-messages.c:114 locale/programs/ld-messages.c:148
#, c-format
msgid "%s: field `%s' undefined"
msgstr "%s：解除域“%s”的定义"

#: locale/programs/ld-messages.c:121 locale/programs/ld-messages.c:155
#: locale/programs/ld-monetary.c:256 locale/programs/ld-numeric.c:118
#, c-format
msgid "%s: value for field `%s' must not be an empty string"
msgstr "%s：域“%s”的值不能是空字符串"

#: locale/programs/ld-messages.c:137 locale/programs/ld-messages.c:171
#, c-format
msgid "%s: no correct regular expression for field `%s': %s"
msgstr "%s：域“%s”中没有正确的常规表达式：%s"

#: locale/programs/ld-monetary.c:224
#, c-format
msgid "%s: value of field `int_curr_symbol' has wrong length"
msgstr "%s：域“int_curr_symbol”的值的长度错误"

#: locale/programs/ld-monetary.c:237
#, c-format
msgid "%s: value of field `int_curr_symbol' does not correspond to a valid name in ISO 4217"
msgstr "%s：域“int_curr_symbol”的值于 ISO 4217 中任何一个合法的名称都不对应"

#: locale/programs/ld-monetary.c:285 locale/programs/ld-monetary.c:315
#, c-format
msgid "%s: value for field `%s' must be in range %d...%d"
msgstr "%s：“%s”域的值必须在 %d...%d 的范围内"

#: locale/programs/ld-monetary.c:747 locale/programs/ld-numeric.c:274
#, c-format
msgid "%s: value for field `%s' must be a single character"
msgstr "%s：“%s”域的值必须是单个字符"

#: locale/programs/ld-monetary.c:844 locale/programs/ld-numeric.c:318
#, c-format
msgid "%s: `-1' must be last entry in `%s' field"
msgstr "%s：“-1”必须是“%s”域中的最后一个条目"

#: locale/programs/ld-monetary.c:866 locale/programs/ld-numeric.c:335
#, c-format
msgid "%s: values for field `%s' must be smaller than 127"
msgstr "%s：域“%s”的值必须小于 127"

#: locale/programs/ld-monetary.c:909
msgid "conversion rate value cannot be zero"
msgstr "转换率的值不能为 0"

#: locale/programs/ld-name.c:129 locale/programs/ld-telephone.c:126
#: locale/programs/ld-telephone.c:149
#, c-format
msgid "%s: invalid escape sequence in field `%s'"
msgstr "%s：域“%s”中含有无效转义序列"

#: locale/programs/ld-time.c:247
#, c-format
msgid "%s: direction flag in string %Zd in `era' field is not '+' nor '-'"
msgstr ""

#: locale/programs/ld-time.c:258
#, c-format
msgid "%s: direction flag in string %Zd in `era' field is not a single character"
msgstr ""

#: locale/programs/ld-time.c:271
#, c-format
msgid "%s: invalid number for offset in string %Zd in `era' field"
msgstr ""

#: locale/programs/ld-time.c:279
#, c-format
msgid "%s: garbage at end of offset value in string %Zd in `era' field"
msgstr ""

#: locale/programs/ld-time.c:330
#, c-format
msgid "%s: invalid starting date in string %Zd in `era' field"
msgstr ""

#: locale/programs/ld-time.c:339
#, c-format
msgid "%s: garbage at end of starting date in string %Zd in `era' field "
msgstr ""

#: locale/programs/ld-time.c:358
#, c-format
msgid "%s: starting date is invalid in string %Zd in `era' field"
msgstr ""

#: locale/programs/ld-time.c:407
#, c-format
msgid "%s: invalid stopping date in string %Zd in `era' field"
msgstr ""

#: locale/programs/ld-time.c:416
#, c-format
msgid "%s: garbage at end of stopping date in string %Zd in `era' field"
msgstr ""

#: locale/programs/ld-time.c:435
#, c-format
msgid "%s: stopping date is invalid in string %Zd in `era' field"
msgstr ""

#: locale/programs/ld-time.c:444
#, c-format
msgid "%s: missing era name in string %Zd in `era' field"
msgstr ""

#: locale/programs/ld-time.c:456
#, c-format
msgid "%s: missing era format in string %Zd in `era' field"
msgstr ""

#: locale/programs/ld-time.c:497
#, c-format
msgid "%s: third operand for value of field `%s' must not be larger than %d"
msgstr ""

#: locale/programs/ld-time.c:505 locale/programs/ld-time.c:513
#: locale/programs/ld-time.c:521
#, c-format
msgid "%s: values for field `%s' must not be larger than %d"
msgstr "%s：域“%s”的值不能大于 %d"

#: locale/programs/ld-time.c:1004
#, c-format
msgid "%s: too few values for field `%s'"
msgstr "%s：域“%s”的值过少"

#: locale/programs/ld-time.c:1049
msgid "extra trailing semicolon"
msgstr "多余的终止分号"

#: locale/programs/ld-time.c:1052
#, c-format
msgid "%s: too many values for field `%s'"
msgstr "%s：域“%s”的值过多"

#: locale/programs/linereader.c:130
msgid "trailing garbage at end of line"
msgstr ""

#: locale/programs/linereader.c:298
msgid "garbage at end of number"
msgstr "数字末尾有垃圾"

#: locale/programs/linereader.c:410
msgid "garbage at end of character code specification"
msgstr ""

#: locale/programs/linereader.c:496
msgid "unterminated symbolic name"
msgstr "未终止的符号名"

#: locale/programs/linereader.c:623
msgid "illegal escape sequence at end of string"
msgstr "字符串末尾的非法转义序列"

#: locale/programs/linereader.c:627 locale/programs/linereader.c:855
msgid "unterminated string"
msgstr "未终止的字符串"

#: locale/programs/linereader.c:669
msgid "non-symbolic character value should not be used"
msgstr "不应该使用非符号字符的值"

#: locale/programs/linereader.c:816
#, c-format
msgid "symbol `%.*s' not in charmap"
msgstr ""

#: locale/programs/linereader.c:837
#, c-format
msgid "symbol `%.*s' not in repertoire map"
msgstr ""

#: locale/programs/locale.c:74
msgid "System information:"
msgstr "系统信息："

#: locale/programs/locale.c:76
msgid "Write names of available locales"
msgstr "写出可用区域的名称"

#: locale/programs/locale.c:78
msgid "Write names of available charmaps"
msgstr "写出可用字符映射的名称"

#: locale/programs/locale.c:79
msgid "Modify output format:"
msgstr "修改输出格式："

#: locale/programs/locale.c:80
msgid "Write names of selected categories"
msgstr "写出选中范畴的名称"

#: locale/programs/locale.c:81
msgid "Write names of selected keywords"
msgstr "写出选中关键字的名称"

#: locale/programs/locale.c:82
msgid "Print more information"
msgstr "打印更多信息"

#: locale/programs/locale.c:87
msgid ""
"Get locale-specific information.\vFor bug reporting instructions, please see:\n"
"<http://www.gnu.org/software/libc/bugs.html>.\n"
msgstr ""

#: locale/programs/locale.c:92
msgid ""
"NAME\n"
"[-a|-m]"
msgstr ""

#: locale/programs/locale.c:193
#, c-format
msgid "Cannot set LC_CTYPE to default locale"
msgstr ""

#: locale/programs/locale.c:195
#, c-format
msgid "Cannot set LC_MESSAGES to default locale"
msgstr ""

#: locale/programs/locale.c:208
#, c-format
msgid "Cannot set LC_COLLATE to default locale"
msgstr ""

#: locale/programs/locale.c:224
#, c-format
msgid "Cannot set LC_ALL to default locale"
msgstr ""

#: locale/programs/locale.c:500
#, c-format
msgid "while preparing output"
msgstr "准备输出时"

#: locale/programs/localedef.c:120
msgid "Input Files:"
msgstr "输入文件："

#: locale/programs/localedef.c:122
msgid "Symbolic character names defined in FILE"
msgstr ""

#: locale/programs/localedef.c:123
msgid "Source definitions are found in FILE"
msgstr "在 FILE 中找到源定义"

#: locale/programs/localedef.c:125
msgid "FILE contains mapping from symbolic names to UCS4 values"
msgstr ""

#: locale/programs/localedef.c:129
msgid "Create output even if warning messages were issued"
msgstr "即使出现警告消息也创建输出"

#: locale/programs/localedef.c:130
msgid "Create old-style tables"
msgstr "创建旧风格表格"

#: locale/programs/localedef.c:131
msgid "Optional output file prefix"
msgstr "可选的输出文件前缀"

#: locale/programs/localedef.c:132
msgid "Be strictly POSIX conform"
msgstr "严格遵循 POSIX"

#: locale/programs/localedef.c:134
msgid "Suppress warnings and information messages"
msgstr "关闭警告和信息消息"

#: locale/programs/localedef.c:135
msgid "Print more messages"
msgstr "打印更多消息"

#: locale/programs/localedef.c:136
msgid "Archive control:"
msgstr "归档控制："

#: locale/programs/localedef.c:138
msgid "Don't add new data to archive"
msgstr "不要将新数据添加到归档文件中"

#: locale/programs/localedef.c:140
msgid "Add locales named by parameters to archive"
msgstr "将由参数命名的区域添加到归档文件中"

#: locale/programs/localedef.c:141
msgid "Replace existing archive content"
msgstr "替换现有的归档文件内容"

#: locale/programs/localedef.c:143
msgid "Remove locales named by parameters from archive"
msgstr "从归档文件中删除由参数命名的区域"

#: locale/programs/localedef.c:144
msgid "List content of archive"
msgstr "列出归档文件的内容"

#: locale/programs/localedef.c:146
msgid "locale.alias file to consult when making archive"
msgstr "在制作归档文件时参考 locale.alias 文件"

#: locale/programs/localedef.c:151
msgid "Compile locale specification"
msgstr "编译区域规范"

#: locale/programs/localedef.c:154
msgid ""
"NAME\n"
"[--add-to-archive|--delete-from-archive] FILE...\n"
"--list-archive [FILE]"
msgstr ""
"名称\n"
"[--add-to-archive|--delete-from-archive] 文件...\n"
"--list-archive [文件]"

#: locale/programs/localedef.c:232
#, c-format
msgid "cannot create directory for output files"
msgstr "无法为输出文件创建目录"

#: locale/programs/localedef.c:243
#, c-format
msgid "FATAL: system does not define `_POSIX2_LOCALEDEF'"
msgstr "致命错误：系统未定义“_POSIX2_LOCALEDEF”"

#: locale/programs/localedef.c:257 locale/programs/localedef.c:273
#: locale/programs/localedef.c:599 locale/programs/localedef.c:619
#, c-format
msgid "cannot open locale definition file `%s'"
msgstr "无法打开区域定义文件“%s”"

#: locale/programs/localedef.c:285
#, c-format
msgid "cannot write output files to `%s'"
msgstr "无法将输出文件写入“%s”"

#: locale/programs/localedef.c:366
#, c-format
msgid ""
"System's directory for character maps : %s\n"
"                       repertoire maps: %s\n"
"                       locale path    : %s\n"
"%s"
msgstr ""

#: locale/programs/localedef.c:567
#, c-format
msgid "circular dependencies between locale definitions"
msgstr "区域定义中的循环倚赖"

#: locale/programs/localedef.c:573
#, c-format
msgid "cannot add already read locale `%s' a second time"
msgstr "无法再次添加已经读入的“%s”"

#: locale/programs/locarchive.c:88 locale/programs/locarchive.c:261
#, c-format
msgid "cannot create temporary file"
msgstr "无法创建临时文件"

#: locale/programs/locarchive.c:118 locale/programs/locarchive.c:307
#, c-format
msgid "cannot initialize archive file"
msgstr "无法初始化归档文件"

#: locale/programs/locarchive.c:125 locale/programs/locarchive.c:314
#, c-format
msgid "cannot resize archive file"
msgstr "无法改变归档文件的大小"

#: locale/programs/locarchive.c:134 locale/programs/locarchive.c:323
#: locale/programs/locarchive.c:527
#, c-format
msgid "cannot map archive header"
msgstr "无法映射归档文件头"

#: locale/programs/locarchive.c:156
#, c-format
msgid "failed to create new locale archive"
msgstr "无法创建新区域归档文件"

#: locale/programs/locarchive.c:168
#, c-format
msgid "cannot change mode of new locale archive"
msgstr "无法改变新归档文件的模式"

#: locale/programs/locarchive.c:255
#, c-format
msgid "cannot map locale archive file"
msgstr "无法映射区域归档文件"

#: locale/programs/locarchive.c:331
#, c-format
msgid "cannot lock new archive"
msgstr "无法锁定新归档文件"

#: locale/programs/locarchive.c:396
#, c-format
msgid "cannot extend locale archive file"
msgstr "无法扩展区域归档文件"

#: locale/programs/locarchive.c:405
#, c-format
msgid "cannot change mode of resized locale archive"
msgstr "无法改变过大小的区域归档文件的模式"

#: locale/programs/locarchive.c:413
#, c-format
msgid "cannot rename new archive"
msgstr "无法改变新归档文件的名称"

#: locale/programs/locarchive.c:466
#, c-format
msgid "cannot open locale archive \"%s\""
msgstr "无法打开区域归档文件“%s”"

#: locale/programs/locarchive.c:471
#, c-format
msgid "cannot stat locale archive \"%s\""
msgstr "无法对区域归档文件“%s”进行 stat() 操作"

#: locale/programs/locarchive.c:490
#, c-format
msgid "cannot lock locale archive \"%s\""
msgstr "无法锁定区域归档文件“%s”"

#: locale/programs/locarchive.c:513
#, c-format
msgid "cannot read archive header"
msgstr "无法读入归档文件头"

#: locale/programs/locarchive.c:573
#, c-format
msgid "locale '%s' already exists"
msgstr "区域“%s”已存在"

#: locale/programs/locarchive.c:804 locale/programs/locarchive.c:819
#: locale/programs/locarchive.c:831 locale/programs/locarchive.c:843
#: locale/programs/locfile.c:344
#, c-format
msgid "cannot add to locale archive"
msgstr "无法添加到区域归档文件"

#: locale/programs/locarchive.c:998
#, c-format
msgid "locale alias file `%s' not found"
msgstr "找不到区域别名文件“%s”"

#: locale/programs/locarchive.c:1142
#, c-format
msgid "Adding %s\n"
msgstr "正在添加 %s\n"

#: locale/programs/locarchive.c:1148
#, c-format
msgid "stat of \"%s\" failed: %s: ignored"
msgstr "无法对“%s”运行 stat：%s：忽略"

#: locale/programs/locarchive.c:1154
#, c-format
msgid "\"%s\" is no directory; ignored"
msgstr "“%s”不是目录；忽略"

#: locale/programs/locarchive.c:1161
#, c-format
msgid "cannot open directory \"%s\": %s: ignored"
msgstr "无法打开目录“%s”：%s：忽略"

#: locale/programs/locarchive.c:1233
#, c-format
msgid "incomplete set of locale files in \"%s\""
msgstr "“%s”中的区域文件不完整"

#: locale/programs/locarchive.c:1297
#, c-format
msgid "cannot read all files in \"%s\": ignored"
msgstr "无法读入“%s”中的所有文件：忽略"

#: locale/programs/locarchive.c:1367
#, c-format
msgid "locale \"%s\" not in archive"
msgstr "区域“%s”在归档文件中"

#: locale/programs/locfile.c:132
#, c-format
msgid "argument to `%s' must be a single character"
msgstr "“%s”的参数必须是单个字符"

#: locale/programs/locfile.c:252
msgid "syntax error: not inside a locale definition section"
msgstr "语法错误：不在区域定义节之中"

#: locale/programs/locfile.c:626
#, c-format
msgid "cannot open output file `%s' for category `%s'"
msgstr "无法为范畴“%2$s”打开输出文件“%1$s”"

#: locale/programs/locfile.c:650
#, c-format
msgid "failure while writing data for category `%s'"
msgstr "为范畴“%s”写入数据失败"

#: locale/programs/locfile.c:746
#, c-format
msgid "cannot create output file `%s' for category `%s'"
msgstr "无法为范畴“%2$s”创建输出文件“%1$s”"

#: locale/programs/locfile.c:782
msgid "expect string argument for `copy'"
msgstr "“copy”需要字符串参数"

#: locale/programs/locfile.c:786
msgid "locale name should consist only of portable characters"
msgstr "区域名称应该仅由可移植的字符组成"

#: locale/programs/locfile.c:805
msgid "no other keyword shall be specified when `copy' is used"
msgstr "使用“copy”时不应再使用其它关键字"

#: locale/programs/locfile.c:819
#, c-format
msgid "`%1$s' definition does not end with `END %1$s'"
msgstr "对“%1$s”的定义并不以“END %1%s”结束"

#: locale/programs/repertoire.c:229 locale/programs/repertoire.c:270
#: locale/programs/repertoire.c:295
#, c-format
msgid "syntax error in repertoire map definition: %s"
msgstr ""

#: locale/programs/repertoire.c:271
msgid "no <Uxxxx> or <Uxxxxxxxx> value given"
msgstr "即未给出 <Uxxxx> 也未给出 <Uxxxxxxxx>"

#: locale/programs/repertoire.c:331
#, c-format
msgid "cannot save new repertoire map"
msgstr "无法保存新的指令表"

#: locale/programs/repertoire.c:342
#, c-format
msgid "repertoire map file `%s' not found"
msgstr ""

#: login/programs/pt_chown.c:74
#, c-format
msgid "Set the owner, group and access permission of the slave pseudo terminal corresponding to the master pseudo terminal passed on file descriptor `%d'.  This is the helper program for the `grantpt' function.  It is not intended to be run directly from the command line.\n"
msgstr ""

#: login/programs/pt_chown.c:84
#, c-format
msgid ""
"The owner is set to the current user, the group is set to `%s', and the access permission is set to `%o'.\n"
"\n"
"%s"
msgstr ""

#: login/programs/pt_chown.c:161
#, c-format
msgid "too many arguments"
msgstr "选项过多"

#: login/programs/pt_chown.c:169
#, c-format
msgid "needs to be installed setuid `root'"
msgstr ""

#: malloc/mcheck.c:330
msgid "memory is consistent, library is buggy\n"
msgstr "内存不一致，库有错误\n"

#: malloc/mcheck.c:333
msgid "memory clobbered before allocated block\n"
msgstr ""

#: malloc/mcheck.c:336
msgid "memory clobbered past end of allocated block\n"
msgstr ""

#: malloc/mcheck.c:339
msgid "block freed twice\n"
msgstr "块释放了两次\n"

#: malloc/mcheck.c:342
msgid "bogus mcheck_status, library is buggy\n"
msgstr ""

#: malloc/memusage.sh:27
msgid "Try \\`memusage --help' for more information."
msgstr "试用“memusage --help”以获取更多信息。"

#: malloc/memusage.sh:33
msgid "memusage: option \\`$1' requires an argument"
msgstr "memusage：选项“$1”需要一个参数"

#: malloc/memusage.sh:39
msgid ""
"Usage: memusage [OPTION]... PROGRAM [PROGRAMOPTION]...\n"
"Profile memory usage of PROGRAM.\n"
"\n"
"   -n,--progname=NAME     Name of the program file to profile\n"
"   -p,--png=FILE          Generate PNG graphic and store it in FILE\n"
"   -d,--data=FILE         Generate binary data file and store it in FILE\n"
"   -u,--unbuffered        Don't buffer output\n"
"   -b,--buffer=SIZE       Collect SIZE entries before writing them out\n"
"      --no-timer          Don't collect additional information through timer\n"
"   -m,--mmap              Also trace mmap & friends\n"
"\n"
"   -?,--help              Print this help and exit\n"
"      --usage             Give a short usage message\n"
"   -V,--version           Print version information and exit\n"
"\n"
" The following options only apply when generating graphical output:\n"
"   -t,--time-based        Make graph linear in time\n"
"   -T,--total             Also draw graph of total memory use\n"
"      --title=STRING      Use STRING as title of the graph\n"
"   -x,--x-size=SIZE       Make graphic SIZE pixels wide\n"
"   -y,--y-size=SIZE       Make graphic SIZE pixels high\n"
"\n"
"Mandatory arguments to long options are also mandatory for any corresponding\n"
"short options.\n"
"\n"
"For bug reporting instructions, please see:\n"
"<http://www.gnu.org/software/libc/bugs.html>."
msgstr ""

#: malloc/memusage.sh:99
msgid ""
"Syntax: memusage [--data=FILE] [--progname=NAME] [--png=FILE] [--unbuffered]\n"
"            [--buffer=SIZE] [--no-timer] [--time-based] [--total]\n"
"            [--title=STRING] [--x-size=SIZE] [--y-size=SIZE]\n"
"            PROGRAM [PROGRAMOPTION]..."
msgstr ""

#: malloc/memusage.sh:191
msgid "memusage: option \\`${1##*=}' is ambiguous"
msgstr "memusage：选项“${1##*=}”具有二义性"

#: malloc/memusage.sh:200
msgid "memusage: unrecognized option \\`$1'"
msgstr "memusage：无法识别的选项“$1”"

#: malloc/memusage.sh:213
msgid "No program name given"
msgstr "未指定程序名"

#: malloc/memusagestat.c:54
msgid "Name output file"
msgstr "名输出文件"

#: malloc/memusagestat.c:55
msgid "Title string used in output graphic"
msgstr "用于输出图形的标题字符串"

#: malloc/memusagestat.c:56
msgid "Generate output linear to time (default is linear to number of function calls)"
msgstr ""

#: malloc/memusagestat.c:58
msgid "Also draw graph for total memory consumption"
msgstr ""

#: malloc/memusagestat.c:59
msgid "Make output graphic VALUE pixels wide"
msgstr ""

#: malloc/memusagestat.c:60
msgid "Make output graphic VALUE pixels high"
msgstr ""

#: malloc/memusagestat.c:65
msgid "Generate graphic from memory profiling data"
msgstr ""

#: malloc/memusagestat.c:68
msgid "DATAFILE [OUTFILE]"
msgstr "数据文件 [输出文件]"

#: misc/error.c:118 timezone/zic.c:417
msgid "Unknown system error"
msgstr "未知的系统错误"

#: nis/nis_callback.c:189
msgid "unable to free arguments"
msgstr "无法释放参数"

#: nis/nis_error.h:1 nis/ypclnt.c:822 nis/ypclnt.c:910 posix/regcomp.c:132
#: sysdeps/gnu/errlist.c:20
msgid "Success"
msgstr "成功"

#: nis/nis_error.h:2
msgid "Probable success"
msgstr ""

#: nis/nis_error.h:3
msgid "Not found"
msgstr "找不到"

#: nis/nis_error.h:4
msgid "Probably not found"
msgstr ""

#: nis/nis_error.h:5
msgid "Cache expired"
msgstr "缓冲器过期"

#: nis/nis_error.h:6
msgid "NIS+ servers unreachable"
msgstr "NIS+ 服务器不可达"

#: nis/nis_error.h:7
msgid "Unknown object"
msgstr "未知的对象"

#: nis/nis_error.h:8
msgid "Server busy, try again"
msgstr "服务器忙，重试"

#: nis/nis_error.h:9
msgid "Generic system error"
msgstr "通用系统错误"

#: nis/nis_error.h:10
msgid "First/next chain broken"
msgstr ""

#. TRANS Permission denied; the file permissions do not allow the attempted operation.
#: nis/nis_error.h:11 nis/ypclnt.c:867 sysdeps/gnu/errlist.c:157
msgid "Permission denied"
msgstr "权限不够"

#: nis/nis_error.h:12
msgid "Not owner"
msgstr "不是所有者"

#: nis/nis_error.h:13
msgid "Name not served by this server"
msgstr ""

#: nis/nis_error.h:14
msgid "Server out of memory"
msgstr "服务器内存不足"

#: nis/nis_error.h:15
msgid "Object with same name exists"
msgstr "同名对象已存在"

#: nis/nis_error.h:16
msgid "Not master server for this domain"
msgstr "该域没有主服务器"

#: nis/nis_error.h:17
msgid "Invalid object for operation"
msgstr "操作无效的对象"

#: nis/nis_error.h:18
msgid "Malformed name, or illegal name"
msgstr ""

#: nis/nis_error.h:19
msgid "Unable to create callback"
msgstr "无法创建回调函数"

#: nis/nis_error.h:20
msgid "Results sent to callback proc"
msgstr ""

#: nis/nis_error.h:21
msgid "Not found, no such name"
msgstr "找不到，没有那个名字"

#: nis/nis_error.h:22
msgid "Name/entry isn't unique"
msgstr "名称/条目不唯一"

#: nis/nis_error.h:23
msgid "Modification failed"
msgstr "修改失败"

#: nis/nis_error.h:24
msgid "Database for table does not exist"
msgstr "表格数据库不存在"

#: nis/nis_error.h:25
msgid "Entry/table type mismatch"
msgstr "条目/表格类型不匹配"

#: nis/nis_error.h:26
msgid "Link points to illegal name"
msgstr "连接指向非法名称"

#: nis/nis_error.h:27
msgid "Partial success"
msgstr "部分成功"

#: nis/nis_error.h:28
msgid "Too many attributes"
msgstr "属性过多"

#: nis/nis_error.h:29
msgid "Error in RPC subsystem"
msgstr "RPC 子系统中出错"

#: nis/nis_error.h:30
msgid "Missing or malformed attribute"
msgstr "遗漏或畸形的属性"

#: nis/nis_error.h:31
msgid "Named object is not searchable"
msgstr "不能搜索命名对象"

#: nis/nis_error.h:32
msgid "Error while talking to callback proc"
msgstr "与回调函数交互时出错"

#: nis/nis_error.h:33
msgid "Non NIS+ namespace encountered"
msgstr ""

#: nis/nis_error.h:34
msgid "Illegal object type for operation"
msgstr "操作的非法对象类型"

#: nis/nis_error.h:35
msgid "Passed object is not the same object on server"
msgstr ""

#: nis/nis_error.h:36
msgid "Modify operation failed"
msgstr "修改操作失败"

#: nis/nis_error.h:37
msgid "Query illegal for named table"
msgstr "对命名表来说查询非法"

#: nis/nis_error.h:38
msgid "Attempt to remove a non-empty table"
msgstr "试图删除非空的表"

#: nis/nis_error.h:39
msgid "Error in accessing NIS+ cold start file.  Is NIS+ installed?"
msgstr "访问 NIS+ 冷启动文件出错。NIS+ 安装了吗？"

#: nis/nis_error.h:40
msgid "Full resync required for directory"
msgstr "需要对目录进行完全的重新同步"

#: nis/nis_error.h:41
msgid "NIS+ operation failed"
msgstr "NIS+ 操作失败"

#: nis/nis_error.h:42
msgid "NIS+ service is unavailable or not installed"
msgstr "NIS+ 服务器不可用或未安装"

#: nis/nis_error.h:43
msgid "Yes, 42 is the meaning of life"
msgstr ""

#: nis/nis_error.h:44
msgid "Unable to authenticate NIS+ server"
msgstr "无法认证 NIS+ 服务器"

#: nis/nis_error.h:45
msgid "Unable to authenticate NIS+ client"
msgstr "无法认证 NIS+ 客户端"

#: nis/nis_error.h:46
msgid "No file space on server"
msgstr "服务器上没有文件空间"

#: nis/nis_error.h:47
msgid "Unable to create process on server"
msgstr "无法在服务器上创建进程"

#: nis/nis_error.h:48
msgid "Master server busy, full dump rescheduled."
msgstr ""

#: nis/nis_local_names.c:122
#, c-format
msgid "LOCAL entry for UID %d in directory %s not unique\n"
msgstr ""

#: nis/nis_print.c:51
msgid "UNKNOWN"
msgstr "未知"

#: nis/nis_print.c:109
msgid "BOGUS OBJECT\n"
msgstr ""

#: nis/nis_print.c:112
msgid "NO OBJECT\n"
msgstr "无对象\n"

#: nis/nis_print.c:115
msgid "DIRECTORY\n"
msgstr "目录\n"

#: nis/nis_print.c:118
msgid "GROUP\n"
msgstr "组\n"

#: nis/nis_print.c:121
msgid "TABLE\n"
msgstr "表\n"

#: nis/nis_print.c:124
msgid "ENTRY\n"
msgstr "条目\n"

#: nis/nis_print.c:127
msgid "LINK\n"
msgstr "连接\n"

#: nis/nis_print.c:130
msgid "PRIVATE\n"
msgstr "私有\n"

#: nis/nis_print.c:133
msgid "(Unknown object)\n"
msgstr "(未知对象)\n"

#: nis/nis_print.c:167
#, c-format
msgid "Name : `%s'\n"
msgstr "名称 ：“%s”\n"

#: nis/nis_print.c:168
#, c-format
msgid "Type : %s\n"
msgstr "类型 ： %s\n"

#: nis/nis_print.c:173
msgid "Master Server :\n"
msgstr "主服务器 ：\n"

#: nis/nis_print.c:175
msgid "Replicate :\n"
msgstr ""

#: nis/nis_print.c:176
#, c-format
msgid "\tName       : %s\n"
msgstr "\t名称     ：%s\n"

#: nis/nis_print.c:177
msgid "\tPublic Key : "
msgstr "\t公钥     ："

#: nis/nis_print.c:181
msgid "None.\n"
msgstr "无。\n"

#: nis/nis_print.c:184
#, c-format
msgid "Diffie-Hellmann (%d bits)\n"
msgstr ""

#: nis/nis_print.c:189
#, c-format
msgid "RSA (%d bits)\n"
msgstr "RSA (%d 位)\n"

#: nis/nis_print.c:192
msgid "Kerberos.\n"
msgstr ""

#: nis/nis_print.c:195
#, c-format
msgid "Unknown (type = %d, bits = %d)\n"
msgstr "未知 (类型 = %d，位 = %d)\n"

#: nis/nis_print.c:206
#, c-format
msgid "\tUniversal addresses (%u)\n"
msgstr ""

#: nis/nis_print.c:228
msgid "Time to live : "
msgstr "存在的时间 ："

#: nis/nis_print.c:230
msgid "Default Access rights :\n"
msgstr "默认访问权限 ：\n"

#: nis/nis_print.c:239
#, c-format
msgid "\tType         : %s\n"
msgstr "\t类型     ：%s\n"

#: nis/nis_print.c:240
msgid "\tAccess rights: "
msgstr "\t访问权限 ："

#: nis/nis_print.c:254
msgid "Group Flags :"
msgstr "组标志 ："

#: nis/nis_print.c:257
msgid ""
"\n"
"Group Members :\n"
msgstr ""
"\n"
"组成员     ：\n"

#: nis/nis_print.c:269
#, c-format
msgid "Table Type          : %s\n"
msgstr "表格类型   ：%s\n"

#: nis/nis_print.c:270
#, c-format
msgid "Number of Columns   : %d\n"
msgstr "列的数量    ：%d\n"

#: nis/nis_print.c:271
#, c-format
msgid "Character Separator : %c\n"
msgstr "字符分隔符：%c\n"

#: nis/nis_print.c:272
#, c-format
msgid "Search Path         : %s\n"
msgstr "搜索路径  ：%s\n"

#: nis/nis_print.c:273
msgid "Columns             :\n"
msgstr ""

#: nis/nis_print.c:276
#, c-format
msgid "\t[%d]\tName          : %s\n"
msgstr "\t[%d]\t名称       ：%s\n"

#: nis/nis_print.c:278
msgid "\t\tAttributes    : "
msgstr "\t\t属性     ："

#: nis/nis_print.c:280
msgid "\t\tAccess Rights : "
msgstr "\t\t访问权限 ："

#: nis/nis_print.c:290
msgid "Linked Object Type : "
msgstr "连接到对象类型 ："

#: nis/nis_print.c:292
#, c-format
msgid "Linked to : %s\n"
msgstr "连接到 ：%s\n"

#: nis/nis_print.c:302
#, c-format
msgid "\tEntry data of type %s\n"
msgstr ""

#: nis/nis_print.c:305
#, c-format
msgid "\t[%u] - [%u bytes] "
msgstr "\t[%u] - [%u 字节] "

#: nis/nis_print.c:308
msgid "Encrypted data\n"
msgstr "已加密的数据\n"

#: nis/nis_print.c:310
msgid "Binary data\n"
msgstr "二进制数据\n"

#: nis/nis_print.c:326
#, c-format
msgid "Object Name   : %s\n"
msgstr "对象名称  ：%s\n"

#: nis/nis_print.c:327
#, c-format
msgid "Directory     : %s\n"
msgstr "目录     ：%s\n"

#: nis/nis_print.c:328
#, c-format
msgid "Owner         : %s\n"
msgstr "所有者 ：%s\n"

#: nis/nis_print.c:329
#, c-format
msgid "Group         : %s\n"
msgstr "组     ：%s\n"

#: nis/nis_print.c:330
msgid "Access Rights : "
msgstr "访问权限："

#: nis/nis_print.c:332
#, c-format
msgid ""
"\n"
"Time to Live  : "
msgstr ""
"\n"
"存在的时间 ："

#: nis/nis_print.c:335
#, c-format
msgid "Creation Time : %s"
msgstr "创建时间：%s"

#: nis/nis_print.c:337
#, c-format
msgid "Mod. Time     : %s"
msgstr "修改时间     ：%s"

#: nis/nis_print.c:338
msgid "Object Type   : "
msgstr "对象类型  ：%s"

#: nis/nis_print.c:358
#, c-format
msgid "    Data Length = %u\n"
msgstr "    数据长度 = %u\n"

#: nis/nis_print.c:372
#, c-format
msgid "Status            : %s\n"
msgstr "状态     ：%s\n"

#: nis/nis_print.c:373
#, c-format
msgid "Number of objects : %u\n"
msgstr "对象的数量 ：%u\n"

#: nis/nis_print.c:377
#, c-format
msgid "Object #%d:\n"
msgstr "对象 #%d：\n"

#: nis/nis_print_group_entry.c:117
#, c-format
msgid "Group entry for \"%s.%s\" group:\n"
msgstr ""

#: nis/nis_print_group_entry.c:125
msgid "    Explicit members:\n"
msgstr "    显式成员：\n"

#: nis/nis_print_group_entry.c:130
msgid "    No explicit members\n"
msgstr "    无显式成员\n"

#: nis/nis_print_group_entry.c:133
msgid "    Implicit members:\n"
msgstr "    隐含成员：\n"

#: nis/nis_print_group_entry.c:138
msgid "    No implicit members\n"
msgstr "    无隐含成员\n"

#: nis/nis_print_group_entry.c:141
msgid "    Recursive members:\n"
msgstr "    递归成员：\n"

#: nis/nis_print_group_entry.c:146
msgid "    No recursive members\n"
msgstr "    无递归成员\n"

#: nis/nis_print_group_entry.c:149
msgid "    Explicit nonmembers:\n"
msgstr ""

#: nis/nis_print_group_entry.c:154
msgid "    No explicit nonmembers\n"
msgstr ""

#: nis/nis_print_group_entry.c:157
msgid "    Implicit nonmembers:\n"
msgstr ""

#: nis/nis_print_group_entry.c:162
msgid "    No implicit nonmembers\n"
msgstr ""

#: nis/nis_print_group_entry.c:165
msgid "    Recursive nonmembers:\n"
msgstr "    递归非成员：\n"

#: nis/nis_print_group_entry.c:170
msgid "    No recursive nonmembers\n"
msgstr ""

#: nis/nss_nisplus/nisplus-publickey.c:101
#: nis/nss_nisplus/nisplus-publickey.c:183
#, c-format
msgid "DES entry for netname %s not unique\n"
msgstr ""

#: nis/nss_nisplus/nisplus-publickey.c:220
#, c-format
msgid "netname2user: missing group id list in `%s'"
msgstr ""

#: nis/nss_nisplus/nisplus-publickey.c:302
#: nis/nss_nisplus/nisplus-publickey.c:308
#: nis/nss_nisplus/nisplus-publickey.c:373
#: nis/nss_nisplus/nisplus-publickey.c:382
#, c-format
msgid "netname2user: (nis+ lookup): %s\n"
msgstr ""

#: nis/nss_nisplus/nisplus-publickey.c:321
#, c-format
msgid "netname2user: DES entry for %s in directory %s not unique"
msgstr ""

#: nis/nss_nisplus/nisplus-publickey.c:339
#, c-format
msgid "netname2user: principal name `%s' too long"
msgstr "netname2user：基本名称“%s”过长"

#: nis/nss_nisplus/nisplus-publickey.c:395
#, c-format
msgid "netname2user: LOCAL entry for %s in directory %s not unique"
msgstr ""

#: nis/nss_nisplus/nisplus-publickey.c:402
msgid "netname2user: should not have uid 0"
msgstr "netname2user：uid 不应为 0"

#: nis/ypclnt.c:825
msgid "Request arguments bad"
msgstr "请求参数错误"

#: nis/ypclnt.c:828
msgid "RPC failure on NIS operation"
msgstr ""

#: nis/ypclnt.c:831
msgid "Can't bind to server which serves this domain"
msgstr "无法于为此域服务的服务器绑定"

#: nis/ypclnt.c:834
msgid "No such map in server's domain"
msgstr ""

#: nis/ypclnt.c:837
msgid "No such key in map"
msgstr ""

#: nis/ypclnt.c:840
msgid "Internal NIS error"
msgstr "内部 NIS 错误"

#: nis/ypclnt.c:843
msgid "Local resource allocation failure"
msgstr "本地资源分配失败"

#: nis/ypclnt.c:846
msgid "No more records in map database"
msgstr ""

#: nis/ypclnt.c:849
msgid "Can't communicate with portmapper"
msgstr "无法与 portmapper 通讯"

#: nis/ypclnt.c:852
msgid "Can't communicate with ypbind"
msgstr "无法与 ypbind 通讯"

#: nis/ypclnt.c:855
msgid "Can't communicate with ypserv"
msgstr "无法与 ypserv 通讯"

#: nis/ypclnt.c:858
msgid "Local domain name not set"
msgstr "未设置本地域名"

#: nis/ypclnt.c:861
msgid "NIS map database is bad"
msgstr "NIS 映射数据库错误"

#: nis/ypclnt.c:864
msgid "NIS client/server version mismatch - can't supply service"
msgstr "NIS 客户端/服务器版本不匹配 - 无法支持服务"

#: nis/ypclnt.c:870
msgid "Database is busy"
msgstr "数据库忙"

#: nis/ypclnt.c:873
msgid "Unknown NIS error code"
msgstr "未知的 NIS 错误码"

#: nis/ypclnt.c:913
msgid "Internal ypbind error"
msgstr "内部 ypbind 错误"

#: nis/ypclnt.c:916
msgid "Domain not bound"
msgstr "未绑定域"

#: nis/ypclnt.c:919
msgid "System resource allocation failure"
msgstr "系统资源分配失败"

#: nis/ypclnt.c:922
msgid "Unknown ypbind error"
msgstr "未知的 ypbind 错误"

#: nis/ypclnt.c:963
msgid "yp_update: cannot convert host to netname\n"
msgstr "yp_update：无法将主机名转换为网名\n"

#: nis/ypclnt.c:981
msgid "yp_update: cannot get server address\n"
msgstr "yp_update：无法获取服务器地址\n"

#: nscd/aicache.c:77 nscd/hstcache.c:468
#, c-format
msgid "Haven't found \"%s\" in hosts cache!"
msgstr "无法在主机缓冲区中找到“%s”！"

#: nscd/aicache.c:79 nscd/hstcache.c:470
#, c-format
msgid "Reloading \"%s\" in hosts cache!"
msgstr "在主机缓冲区中重新加载“%s”！"

#: nscd/cache.c:146
#, c-format
msgid "add new entry \"%s\" of type %s for %s to cache%s"
msgstr ""

#: nscd/cache.c:148
msgid " (first)"
msgstr ""

#: nscd/cache.c:256 nscd/connections.c:810
#, c-format
msgid "cannot stat() file `%s': %s"
msgstr "无法对文件“%s”进行 stat() 操作：%s"

#: nscd/cache.c:285
#, c-format
msgid "pruning %s cache; time %ld"
msgstr ""

#: nscd/cache.c:312
#, c-format
msgid "considering %s entry \"%s\", timeout %<PRIu64>"
msgstr ""

#: nscd/connections.c:521 nscd/connections.c:533 nscd/connections.c:545
#: nscd/connections.c:564
#, c-format
msgid "invalid persistent database file \"%s\": %s"
msgstr ""

#: nscd/connections.c:535
msgid "header size does not match"
msgstr ""

#: nscd/connections.c:547
msgid "file size does not match"
msgstr "文件大小不匹配"

#: nscd/connections.c:566
msgid "verification failed"
msgstr "验证失败"

#: nscd/connections.c:580
#, c-format
msgid "suggested size of table for database %s larger than the persistent database's table"
msgstr ""

#: nscd/connections.c:591 nscd/connections.c:673
#, c-format
msgid "cannot create read-only descriptor for \"%s\"; no mmap"
msgstr "无法为“%s”创建只读描述符；没有 mmap"

#: nscd/connections.c:652
#, c-format
msgid "database for %s corrupted or simultaneously used; remove %s manually if necessary and restart"
msgstr ""

#: nscd/connections.c:659
#, c-format
msgid "cannot create %s; no persistent database used"
msgstr "无法创建 %s; 不使用持久数据库"

#: nscd/connections.c:662
#, c-format
msgid "cannot create %s; no sharing possible"
msgstr "无法创建 %s; 无法共享"

#: nscd/connections.c:733
#, c-format
msgid "cannot write to database file %s: %s"
msgstr "无法写入数据库文件 %s: %s"

#: nscd/connections.c:772
#, c-format
msgid "cannot set socket to close on exec: %s; disabling paranoia mode"
msgstr ""

#: nscd/connections.c:823
#, c-format
msgid "cannot open socket: %s"
msgstr "无法打开套接字：%s"

#: nscd/connections.c:840
#, c-format
msgid "cannot change socket to nonblocking mode: %s"
msgstr "无法转换套接字到非堵塞模式: %s"

#: nscd/connections.c:848
#, c-format
msgid "cannot set socket to close on exec: %s"
msgstr "无法设定套接字为 exec 时关闭: %s"

#: nscd/connections.c:859
#, c-format
msgid "cannot enable socket to accept connections: %s"
msgstr "无法启用套接字以接受连接：%s"

#: nscd/connections.c:955
#, c-format
msgid "provide access to FD %d, for %s"
msgstr ""

#: nscd/connections.c:967
#, c-format
msgid "cannot handle old request version %d; current version is %d"
msgstr "无法处理旧请求版本 %d；当前版本为 %d"

#: nscd/connections.c:1009 nscd/connections.c:1062
#, c-format
msgid "cannot write result: %s"
msgstr "无法写入结果：“%s”"

#: nscd/connections.c:1145
#, c-format
msgid "error getting caller's id: %s"
msgstr ""

#: nscd/connections.c:1204
#, c-format
msgid "cannot open /proc/self/cmdline: %s; disabling paranoia mode"
msgstr ""

#: nscd/connections.c:1218
#, c-format
msgid "cannot read /proc/self/cmdline: %s; disabling paranoia mode"
msgstr ""

#: nscd/connections.c:1258
#, c-format
msgid "cannot change to old UID: %s; disabling paranoia mode"
msgstr ""

#: nscd/connections.c:1268
#, c-format
msgid "cannot change to old GID: %s; disabling paranoia mode"
msgstr ""

#: nscd/connections.c:1281
#, c-format
msgid "cannot change to old working directory: %s; disabling paranoia mode"
msgstr ""

#: nscd/connections.c:1310
#, c-format
msgid "re-exec failed: %s; disabling paranoia mode"
msgstr ""

#: nscd/connections.c:1319
#, c-format
msgid "cannot change current working directory to \"/\": %s"
msgstr ""

#: nscd/connections.c:1437
#, c-format
msgid "short read while reading request: %s"
msgstr "读取请求时没有读入足够的数据：%s"

#: nscd/connections.c:1468
#, c-format
msgid "key length in request too long: %d"
msgstr "请求中的键过长：%d"

#: nscd/connections.c:1481
#, c-format
msgid "short read while reading request key: %s"
msgstr "读入请求键的时候没有读入足够的数据：%s"

#: nscd/connections.c:1490
#, c-format
msgid "handle_request: request received (Version = %d) from PID %ld"
msgstr "处理请求：已从进程ID %2$ld 收到请求 (版本 = %1$d)"

#: nscd/connections.c:1495
#, c-format
msgid "handle_request: request received (Version = %d)"
msgstr "处理请求：已收到请求 (版本 = %d)"

#: nscd/connections.c:1856
#, c-format
msgid "could only start %d threads; terminating"
msgstr ""

#: nscd/connections.c:1904 nscd/connections.c:1905 nscd/connections.c:1922
#: nscd/connections.c:1931 nscd/connections.c:1949 nscd/connections.c:1960
#: nscd/connections.c:1971
#, c-format
msgid "Failed to run nscd as user '%s'"
msgstr ""

#: nscd/connections.c:1923
#, c-format
msgid "initial getgrouplist failed"
msgstr "初始化 getgrouplist 失败"

#: nscd/connections.c:1932
#, c-format
msgid "getgrouplist failed"
msgstr "getgrouplist 失败"

#: nscd/connections.c:1950
#, c-format
msgid "setgroups failed"
msgstr "setgroups 失败"

#: nscd/grpcache.c:402 nscd/hstcache.c:418 nscd/initgrcache.c:412
#: nscd/pwdcache.c:397 nscd/servicescache.c:343
#, c-format
msgid "short write in %s: %s"
msgstr ""

#: nscd/grpcache.c:445 nscd/initgrcache.c:78
#, c-format
msgid "Haven't found \"%s\" in group cache!"
msgstr "无法在组缓冲区中找到“%s”！"

#: nscd/grpcache.c:447 nscd/initgrcache.c:80
#, c-format
msgid "Reloading \"%s\" in group cache!"
msgstr "在组缓冲区中重新加载“%s”！"

#: nscd/grpcache.c:524
#, c-format
msgid "Invalid numeric gid \"%s\"!"
msgstr ""

#: nscd/mem.c:383
#, c-format
msgid "freed %zu bytes in %s cache"
msgstr ""

#: nscd/mem.c:512
#, c-format
msgid "no more memory for database '%s'"
msgstr ""

#: nscd/nscd.c:98
msgid "Read configuration data from NAME"
msgstr "从 NAME 中读取配置数据"

#: nscd/nscd.c:100
msgid "Do not fork and display messages on the current tty"
msgstr ""

#: nscd/nscd.c:101
msgid "NUMBER"
msgstr ""

#: nscd/nscd.c:101
msgid "Start NUMBER threads"
msgstr "启动 NUMBER 个线程"

#: nscd/nscd.c:102
msgid "Shut the server down"
msgstr "关闭服务器"

#: nscd/nscd.c:103
msgid "Print current configuration statistic"
msgstr "打印当前配置统计"

#: nscd/nscd.c:104
msgid "TABLE"
msgstr ""

#: nscd/nscd.c:105
msgid "Invalidate the specified cache"
msgstr ""

#: nscd/nscd.c:106
msgid "TABLE,yes"
msgstr ""

#: nscd/nscd.c:107
msgid "Use separate cache for each user"
msgstr "为每个用户使用分离的缓冲区"

#: nscd/nscd.c:112
msgid "Name Service Cache Daemon."
msgstr ""

#: nscd/nscd.c:144 nss/getent.c:858 nss/makedb.c:123
#, c-format
msgid "wrong number of arguments"
msgstr "参数个数错误"

#: nscd/nscd.c:154
#, c-format
msgid "failure while reading configuration file; this is fatal"
msgstr "无法读入配置文件；这是致命的"

#: nscd/nscd.c:163
#, c-format
msgid "already running"
msgstr "已经在运行"

#: nscd/nscd.c:178 nscd/nscd.c:233
#, c-format
msgid "cannot fork"
msgstr "无法 fork"

#: nscd/nscd.c:241
#, c-format
msgid "cannot change current working directory to \"/\""
msgstr ""

#: nscd/nscd.c:249
msgid "Could not create log file"
msgstr "无法创建日志文件"

#: nscd/nscd.c:302 nscd/nscd.c:327 nscd/nscd_stat.c:172
#, c-format
msgid "Only root is allowed to use this option!"
msgstr "只有根用户允许使用本选项！"

#: nscd/nscd.c:364 nscd/nscd_stat.c:191
#, c-format
msgid "write incomplete"
msgstr "写入不完整"

#: nscd/nscd.c:375
#, c-format
msgid "cannot read invalidate ACK"
msgstr "无法读入 invalidate ACK"

#: nscd/nscd.c:381
#, c-format
msgid "invalidation failed"
msgstr "无效化失败"

#: nscd/nscd.c:391
#, c-format
msgid "secure services not implemented anymore"
msgstr ""

#: nscd/nscd_conf.c:57
#, c-format
msgid "database %s is not supported"
msgstr "不支持数据库“%s”"

#: nscd/nscd_conf.c:108
#, c-format
msgid "Parse error: %s"
msgstr "解析错误：%s"

#: nscd/nscd_conf.c:193
#, c-format
msgid "Must specify user name for server-user option"
msgstr ""

#: nscd/nscd_conf.c:200
#, c-format
msgid "Must specify user name for stat-user option"
msgstr ""

#: nscd/nscd_conf.c:244
#, c-format
msgid "invalid value for 'reload-count': %u"
msgstr "“reload-count”的值无效: %u"

#: nscd/nscd_conf.c:259
#, c-format
msgid "Must specify value for restart-interval option"
msgstr ""

#: nscd/nscd_conf.c:273
#, c-format
msgid "Unknown option: %s %s %s"
msgstr "未知的选项：%s %s %s"

#: nscd/nscd_conf.c:286
#, c-format
msgid "cannot get current working directory: %s; disabling paranoia mode"
msgstr ""

#: nscd/nscd_conf.c:306
#, c-format
msgid "maximum file size for %s database too small"
msgstr ""

#: nscd/nscd_stat.c:141
#, c-format
msgid "cannot write statistics: %s"
msgstr "无法写入统计：%s"

#: nscd/nscd_stat.c:156
msgid "yes"
msgstr ""

#: nscd/nscd_stat.c:157
msgid "no"
msgstr ""

#: nscd/nscd_stat.c:168
#, c-format
msgid "Only root or %s is allowed to use this option!"
msgstr "只有根用户或 %s 允许使用本选项！"

#: nscd/nscd_stat.c:179
#, c-format
msgid "nscd not running!\n"
msgstr "nscd 未运行！\n"

#: nscd/nscd_stat.c:203
#, c-format
msgid "cannot read statistics data"
msgstr "无法读入统计数据"

#: nscd/nscd_stat.c:206
#, c-format
msgid ""
"nscd configuration:\n"
"\n"
"%15d  server debug level\n"
msgstr ""
"nscd 配置：\n"
"\n"
"%15d  服务器调试级别\n"

#: nscd/nscd_stat.c:230
#, c-format
msgid "%3ud %2uh %2um %2lus  server runtime\n"
msgstr ""

#: nscd/nscd_stat.c:233
#, c-format
msgid "    %2uh %2um %2lus  server runtime\n"
msgstr ""

#: nscd/nscd_stat.c:235
#, c-format
msgid "        %2um %2lus  server runtime\n"
msgstr ""

#: nscd/nscd_stat.c:237
#, c-format
msgid "            %2lus  server runtime\n"
msgstr ""

#: nscd/nscd_stat.c:239
#, c-format
msgid ""
"%15d  current number of threads\n"
"%15d  maximum number of threads\n"
"%15lu  number of times clients had to wait\n"
"%15s  paranoia mode enabled\n"
"%15lu  restart internal\n"
msgstr ""

#: nscd/nscd_stat.c:273
#, c-format
msgid ""
"\n"
"%s cache:\n"
"\n"
"%15s  cache is enabled\n"
"%15s  cache is persistent\n"
"%15s  cache is shared\n"
"%15zu  suggested size\n"
"%15zu  total data pool size\n"
"%15zu  used data pool size\n"
"%15lu  seconds time to live for positive entries\n"
"%15lu  seconds time to live for negative entries\n"
"%15<PRIuMAX>  cache hits on positive entries\n"
"%15<PRIuMAX>  cache hits on negative entries\n"
"%15<PRIuMAX>  cache misses on positive entries\n"
"%15<PRIuMAX>  cache misses on negative entries\n"
"%15lu%% cache hit rate\n"
"%15zu  current number of cached values\n"
"%15zu  maximum number of cached values\n"
"%15zu  maximum chain length searched\n"
"%15<PRIuMAX>  number of delays on rdlock\n"
"%15<PRIuMAX>  number of delays on wrlock\n"
"%15<PRIuMAX>  memory allocations failed\n"
"%15s  check /etc/%s for changes\n"
msgstr ""

#: nscd/pwdcache.c:440
#, c-format
msgid "Haven't found \"%s\" in password cache!"
msgstr "无法在口令缓冲区中找到“%s”！"

#: nscd/pwdcache.c:442
#, c-format
msgid "Reloading \"%s\" in password cache!"
msgstr "在口令缓冲区中重新加载“%s”！"

#: nscd/pwdcache.c:520
#, c-format
msgid "Invalid numeric uid \"%s\"!"
msgstr ""

#: nscd/selinux.c:156
#, c-format
msgid "Failed opening connection to the audit subsystem: %m"
msgstr ""

#: nscd/selinux.c:177
msgid "Failed to set keep-capabilities"
msgstr ""

#: nscd/selinux.c:178 nscd/selinux.c:241
#, c-format
msgid "prctl(KEEPCAPS) failed"
msgstr ""

#: nscd/selinux.c:192
msgid "Failed to initialize drop of capabilities"
msgstr ""

#: nscd/selinux.c:193
#, c-format
msgid "cap_init failed"
msgstr "cap_init 失败"

#: nscd/selinux.c:214 nscd/selinux.c:231
msgid "Failed to drop capabilities"
msgstr ""

#: nscd/selinux.c:215 nscd/selinux.c:232
#, c-format
msgid "cap_set_proc failed"
msgstr "cap_set_proc 失败"

#: nscd/selinux.c:240
msgid "Failed to unset keep-capabilities"
msgstr ""

#: nscd/selinux.c:256
msgid "Failed to determine if kernel supports SELinux"
msgstr ""

#: nscd/selinux.c:271
#, c-format
msgid "Failed to start AVC thread"
msgstr ""

#: nscd/selinux.c:293
#, c-format
msgid "Failed to create AVC lock"
msgstr "无法创建 AVC 锁"

#: nscd/selinux.c:333
#, c-format
msgid "Failed to start AVC"
msgstr "无法启动 AVC"

#: nscd/selinux.c:335
msgid "Access Vector Cache (AVC) started"
msgstr ""

#: nscd/selinux.c:356
msgid "Error getting context of socket peer"
msgstr ""

#: nscd/selinux.c:361
msgid "Error getting context of nscd"
msgstr ""

#: nscd/selinux.c:367
msgid "Error getting sid from context"
msgstr "无法从上下文中获取 sid"

#: nscd/selinux.c:399
#, c-format
msgid ""
"\n"
"SELinux AVC Statistics:\n"
"\n"
"%15u  entry lookups\n"
"%15u  entry hits\n"
"%15u  entry misses\n"
"%15u  entry discards\n"
"%15u  CAV lookups\n"
"%15u  CAV hits\n"
"%15u  CAV probes\n"
"%15u  CAV misses\n"
msgstr ""

#: nscd/servicescache.c:390
#, c-format
msgid "Haven't found \"%s\" in services cache!"
msgstr "无法在服务缓冲区中找到“%s”！"

#: nscd/servicescache.c:392
#, c-format
msgid "Reloading \"%s\" in services cache!"
msgstr "在服务缓冲区中重新加载“%s”！"

#: nss/getent.c:52
msgid "database [key ...]"
msgstr "数据库 [键 ...]"

#: nss/getent.c:57
msgid "Service configuration to be used"
msgstr "要使用的服务配置"

#: nss/getent.c:62
msgid ""
"Get entries from administrative database.\vFor bug reporting instructions, please see:\n"
"<http://www.gnu.org/software/libc/bugs.html>.\n"
msgstr ""

#: nss/getent.c:145 nss/getent.c:394
#, c-format
msgid "Enumeration not supported on %s\n"
msgstr "%s 不支持枚举\n"

#: nss/getent.c:782
#, c-format
msgid "Unknown database name"
msgstr "未知的数据库名"

#: nss/getent.c:808
msgid "Supported databases:\n"
msgstr "支持的数据库：\n"

#: nss/getent.c:868
#, c-format
msgid "Unknown database: %s\n"
msgstr "未知的数据库：%s\n"

#: nss/makedb.c:60
msgid "Convert key to lower case"
msgstr ""

#: nss/makedb.c:63
msgid "Do not print messages while building database"
msgstr ""

#: nss/makedb.c:65
msgid "Print content of database file, one entry a line"
msgstr ""

#: nss/makedb.c:70
msgid "Create simple DB database from textual input."
msgstr ""

#: nss/makedb.c:73
msgid ""
"INPUT-FILE OUTPUT-FILE\n"
"-o OUTPUT-FILE INPUT-FILE\n"
"-u INPUT-FILE"
msgstr ""
"输入文件 输出文件\n"
"-o 输出文件 输入文件\n"
"-u 输入文件"

#: nss/makedb.c:142
#, c-format
msgid "No usable database library found."
msgstr "未找到可用的数据库函数库"

#: nss/makedb.c:149
#, c-format
msgid "cannot open database file `%s': %s"
msgstr "无法打开数据库文件“%s”: %s"

#: nss/makedb.c:151
msgid "incorrectly formatted file"
msgstr ""

#: nss/makedb.c:331
msgid "duplicate key"
msgstr ""

#: nss/makedb.c:337
#, c-format
msgid "while writing database file"
msgstr "当写数据库文件"

#: nss/makedb.c:348
#, c-format
msgid "problems while reading `%s'"
msgstr "读取“%s”时出错"

#: nss/makedb.c:368 nss/makedb.c:385
#, c-format
msgid "while reading database"
msgstr "当读数据库"

#: posix/getconf.c:945
#, c-format
msgid "Usage: %s [-v specification] variable_name [pathname]\n"
msgstr "用法：%s [-v 规范] 变量名 [路径名]\n"

#: posix/getconf.c:948
#, c-format
msgid "       %s -a [pathname]\n"
msgstr ""

#: posix/getconf.c:1067
#, c-format
msgid "unknown specification \"%s\""
msgstr "未知的规范“%s”"

#: posix/getconf.c:1095
#, c-format
msgid "Couldn't execute %s"
msgstr ""

#: posix/getconf.c:1135 posix/getconf.c:1151
msgid "undefined"
msgstr "未定义"

#: posix/getconf.c:1173
#, c-format
msgid "Unrecognized variable `%s'"
msgstr "不可识别的变量“%s”"

#: posix/getopt.c:571 posix/getopt.c:587
#, c-format
msgid "%s: option '%s' is ambiguous\n"
msgstr "%s：选项“%s”具有二义性\n"

#: posix/getopt.c:620 posix/getopt.c:624
#, c-format
msgid "%s: option '--%s' doesn't allow an argument\n"
msgstr "%s：选项“--%s”不接受任何参数\n"

#: posix/getopt.c:633 posix/getopt.c:638
#, c-format
msgid "%s: option '%c%s' doesn't allow an argument\n"
msgstr "%s：选项“%c%s”不接受参数\n"

#: posix/getopt.c:681 posix/getopt.c:700 posix/getopt.c:1016
#: posix/getopt.c:1035
#, c-format
msgid "%s: option '%s' requires an argument\n"
msgstr "%s：选项“%s”需要一个参数\n"

#: posix/getopt.c:738 posix/getopt.c:741
#, c-format
msgid "%s: unrecognized option '--%s'\n"
msgstr "%s：无法识别的选项“--%s”\n"

#: posix/getopt.c:749 posix/getopt.c:752
#, c-format
msgid "%s: unrecognized option '%c%s'\n"
msgstr "%s：无法识别的选项“%c%s”\n"

#: posix/getopt.c:804 posix/getopt.c:807
#, c-format
msgid "%s: illegal option -- '%c'\n"
msgstr "%s：无效选项 -- %c\n"

#: posix/getopt.c:813 posix/getopt.c:816
#, c-format
msgid "%s: invalid option -- '%c'\n"
msgstr "%s：无效选项 -- %c\n"

#: posix/getopt.c:868 posix/getopt.c:884 posix/getopt.c:1088
#: posix/getopt.c:1106
#, c-format
msgid "%s: option requires an argument -- '%c'\n"
msgstr "%s：选项需要一个参数 -- %c\n"

#: posix/getopt.c:937 posix/getopt.c:953
#, c-format
msgid "%s: option '-W %s' is ambiguous\n"
msgstr "%s：选项“-W %s”具有二义性\n"

#: posix/getopt.c:977 posix/getopt.c:995
#, c-format
msgid "%s: option '-W %s' doesn't allow an argument\n"
msgstr "%s：选项“-W %s”不接受参数\n"

#: posix/regcomp.c:135
msgid "No match"
msgstr "没有匹配"

#: posix/regcomp.c:138
msgid "Invalid regular expression"
msgstr "无效的常规表达式"

#: posix/regcomp.c:141
msgid "Invalid collation character"
msgstr ""

#: posix/regcomp.c:144
msgid "Invalid character class name"
msgstr "无效的字符类名"

#: posix/regcomp.c:147
msgid "Trailing backslash"
msgstr ""

#: posix/regcomp.c:150
msgid "Invalid back reference"
msgstr "无效的向后引用"

#: posix/regcomp.c:153
msgid "Unmatched [ or [^"
msgstr " 不匹配的 [ 或 [^"

#: posix/regcomp.c:156
msgid "Unmatched ( or \\("
msgstr "不匹配的 ( 或 \\("

#: posix/regcomp.c:159
msgid "Unmatched \\{"
msgstr "不匹配的 \\{"

#: posix/regcomp.c:162
msgid "Invalid content of \\{\\}"
msgstr "无效的 \\{\\} 的内容"

#: posix/regcomp.c:165
msgid "Invalid range end"
msgstr ""

#: posix/regcomp.c:168
msgid "Memory exhausted"
msgstr "内存耗尽"

#: posix/regcomp.c:171
msgid "Invalid preceding regular expression"
msgstr "无效的前导常规表达式"

#: posix/regcomp.c:174
msgid "Premature end of regular expression"
msgstr "常规表达式非正常结束"

#: posix/regcomp.c:177
msgid "Regular expression too big"
msgstr "常规表达式过大"

#: posix/regcomp.c:180
msgid "Unmatched ) or \\)"
msgstr "不匹配的 ) 或 \\)"

#: posix/regcomp.c:660
msgid "No previous regular expression"
msgstr "没有前一个常规表达式"

#: posix/wordexp.c:1798
msgid "parameter null or not set"
msgstr "参数为 null 或未设置"

#: resolv/herror.c:68
msgid "Resolver Error 0 (no error)"
msgstr "解析器错误 0 (无错误)"

#: resolv/herror.c:69
msgid "Unknown host"
msgstr "未知的主机"

#: resolv/herror.c:70
msgid "Host name lookup failure"
msgstr "主机名搜索失败"

#: resolv/herror.c:71
msgid "Unknown server error"
msgstr "未知的服务器错误"

#: resolv/herror.c:72
msgid "No address associated with name"
msgstr "没有与名字关联的地址"

#: resolv/herror.c:107
msgid "Resolver internal error"
msgstr "解析器内部错误"

#: resolv/herror.c:110
msgid "Unknown resolver error"
msgstr "未知的解析器错误"

#: resolv/res_hconf.c:124
#, c-format
msgid "%s: line %d: cannot specify more than %d trim domains"
msgstr "%s：行 %d：无法指定多于 %d 个规整域"

#: resolv/res_hconf.c:145
#, c-format
msgid "%s: line %d: list delimiter not followed by domain"
msgstr "%s：行 %d：列表分隔符没有出现在域之后"

#: resolv/res_hconf.c:204
#, c-format
msgid "%s: line %d: expected `on' or `off', found `%s'\n"
msgstr "%s：行 %d：应为“on”或“off”，得到“%s”\n"

#: resolv/res_hconf.c:247
#, c-format
msgid "%s: line %d: bad command `%s'\n"
msgstr "%s：行 %d：错误命令“%s”\n"

#: resolv/res_hconf.c:282
#, c-format
msgid "%s: line %d: ignoring trailing garbage `%s'\n"
msgstr ""

#: stdio-common/psignal.c:51
#, c-format
msgid "%s%sUnknown signal %d\n"
msgstr "%s%s未知的信号 %d\n"

#: stdio-common/psignal.c:52
msgid "Unknown signal"
msgstr "未知信号"

#: string/_strerror.c:45 sysdeps/mach/_strerror.c:87
msgid "Unknown error "
msgstr "未知的错误 "

#: string/strerror.c:43
msgid "Unknown error"
msgstr "未知的错误"

#: string/strsignal.c:65
#, c-format
msgid "Real-time signal %d"
msgstr "实时信号 %d"

#: string/strsignal.c:69
#, c-format
msgid "Unknown signal %d"
msgstr "未知信号 %d"

#: sunrpc/auth_unix.c:114
msgid "authunix_create: out of memory\n"
msgstr "authunix_create：内存不足\n"

#: sunrpc/auth_unix.c:350
msgid "auth_unix.c: Fatal marshalling problem"
msgstr ""

#: sunrpc/clnt_perr.c:118 sunrpc/clnt_perr.c:139
#, c-format
msgid "; low version = %lu, high version = %lu"
msgstr ""

#: sunrpc/clnt_perr.c:125
msgid "; why = "
msgstr ""

#: sunrpc/clnt_perr.c:132
#, c-format
msgid "(unknown authentication error - %d)"
msgstr "(未知的认证错误 - %d)"

#: sunrpc/clnt_perr.c:172
msgid "RPC: Success"
msgstr "RPC：成功"

#: sunrpc/clnt_perr.c:175
msgid "RPC: Can't encode arguments"
msgstr "RPC：无法对参数进行编码"

#: sunrpc/clnt_perr.c:179
msgid "RPC: Can't decode result"
msgstr "RPC：无法对结果进行解码"

#: sunrpc/clnt_perr.c:183
msgid "RPC: Unable to send"
msgstr "RPC：无法发送"

#: sunrpc/clnt_perr.c:187
msgid "RPC: Unable to receive"
msgstr "RPC：无法接收"

#: sunrpc/clnt_perr.c:191
msgid "RPC: Timed out"
msgstr "RPC：超时"

#: sunrpc/clnt_perr.c:195
msgid "RPC: Incompatible versions of RPC"
msgstr "RPC：RPC 版本不兼容"

#: sunrpc/clnt_perr.c:199
msgid "RPC: Authentication error"
msgstr "RPC：认证错误"

#: sunrpc/clnt_perr.c:203
msgid "RPC: Program unavailable"
msgstr "RPC：程序不可用"

#: sunrpc/clnt_perr.c:207
msgid "RPC: Program/version mismatch"
msgstr "RPC：程序/版本不匹配"

#: sunrpc/clnt_perr.c:211
msgid "RPC: Procedure unavailable"
msgstr ""

#: sunrpc/clnt_perr.c:215
msgid "RPC: Server can't decode arguments"
msgstr "RPC：服务器无法对参数进行解码"

#: sunrpc/clnt_perr.c:219
msgid "RPC: Remote system error"
msgstr "RPC：远程系统错误"

#: sunrpc/clnt_perr.c:223
msgid "RPC: Unknown host"
msgstr "RPC：未知主机"

#: sunrpc/clnt_perr.c:227
msgid "RPC: Unknown protocol"
msgstr "RPC：未知协议"

#: sunrpc/clnt_perr.c:231
msgid "RPC: Port mapper failure"
msgstr ""

#: sunrpc/clnt_perr.c:235
msgid "RPC: Program not registered"
msgstr "RPC：程序未注册"

#: sunrpc/clnt_perr.c:239
msgid "RPC: Failed (unspecified error)"
msgstr "RPC：失败 (未指明的错误)"

#: sunrpc/clnt_perr.c:280
msgid "RPC: (unknown error code)"
msgstr "RPC：(未知的错误码)"

#: sunrpc/clnt_perr.c:342
msgid "Authentication OK"
msgstr "认证成功"

#: sunrpc/clnt_perr.c:345
msgid "Invalid client credential"
msgstr "无效的客户证书"

#: sunrpc/clnt_perr.c:349
msgid "Server rejected credential"
msgstr "服务器拒绝证书"

#: sunrpc/clnt_perr.c:353
msgid "Invalid client verifier"
msgstr "无效的客户校验"

#: sunrpc/clnt_perr.c:357
msgid "Server rejected verifier"
msgstr "服务器拒绝校验"

#: sunrpc/clnt_perr.c:361
msgid "Client credential too weak"
msgstr "客户证书太弱"

#: sunrpc/clnt_perr.c:365
msgid "Invalid server verifier"
msgstr "无效的服务器校验"

#: sunrpc/clnt_perr.c:369
msgid "Failed (unspecified error)"
msgstr "失败 (未指明的错误)"

#: sunrpc/clnt_raw.c:117
msgid "clnt_raw.c: fatal header serialization error"
msgstr "clnt_raw.c: 致命的头编序错误。"

#: sunrpc/clnt_tcp.c:131
msgid "clnttcp_create: out of memory\n"
msgstr "clnttcp_create：内存不足\n"

#: sunrpc/clnt_udp.c:139
msgid "clntudp_create: out of memory\n"
msgstr "clntudp_create：内存不足\n"

#: sunrpc/clnt_unix.c:128
msgid "clntunix_create: out of memory\n"
msgstr "clntunix_create：内存不足\n"

#: sunrpc/pm_getmaps.c:83
msgid "pmap_getmaps.c: rpc problem"
msgstr ""

#: sunrpc/pmap_clnt.c:129
msgid "Cannot register service"
msgstr "无法注册服务"

#: sunrpc/pmap_rmt.c:248
msgid "Cannot create socket for broadcast rpc"
msgstr "无法为广播 rpc 创建套接字"

#: sunrpc/pmap_rmt.c:255
msgid "Cannot set socket option SO_BROADCAST"
msgstr "无法设置套接字选项 SO_BROADCAST"

#: sunrpc/pmap_rmt.c:307
msgid "Cannot send broadcast packet"
msgstr "无法发送广播包"

#: sunrpc/pmap_rmt.c:332
msgid "Broadcast poll problem"
msgstr ""

#: sunrpc/pmap_rmt.c:345
msgid "Cannot receive reply to broadcast"
msgstr "无法接收对广播的应答"

#: sunrpc/rpc_main.c:286
#, c-format
msgid "%s: output would overwrite %s\n"
msgstr "%s：输出将覆盖 %s\n"

#: sunrpc/rpc_main.c:293
#, c-format
msgid "%s: unable to open %s: %m\n"
msgstr "%s：无法打开 %s：%m\n"

#: sunrpc/rpc_main.c:305
#, c-format
msgid "%s: while writing output %s: %m"
msgstr "%s：写入输出 %s 时：%m"

#: sunrpc/rpc_main.c:340
#, c-format
msgid "cannot find C preprocessor: %s \n"
msgstr "无法找到 C 预处理器：%s\n"

#: sunrpc/rpc_main.c:348
msgid "cannot find any C preprocessor (cpp)\n"
msgstr "无法找到任何 C 预处理器 (cpp)\n"

#: sunrpc/rpc_main.c:417
#, c-format
msgid "%s: C preprocessor failed with signal %d\n"
msgstr "%s：C 预处理器因信号 %d 而失败\n"

#: sunrpc/rpc_main.c:420
#, c-format
msgid "%s: C preprocessor failed with exit code %d\n"
msgstr "%s：C 预处理器失败，返回 %d\n"

#: sunrpc/rpc_main.c:460
#, c-format
msgid "illegal nettype: `%s'\n"
msgstr "非法网络类型：“%s”\n"

#: sunrpc/rpc_main.c:1122
#, c-format
msgid "rpcgen: too many defines\n"
msgstr "rpcgen：定义过多\n"

#: sunrpc/rpc_main.c:1134
#, c-format
msgid "rpcgen: arglist coding error\n"
msgstr ""

#. TRANS: the file will not be removed; this is an
#. TRANS: informative message.
#: sunrpc/rpc_main.c:1167
#, c-format
msgid "file `%s' already exists and may be overwritten\n"
msgstr "文件“%s”已存在并可能被覆盖\n"

#: sunrpc/rpc_main.c:1212
#, c-format
msgid "Cannot specify more than one input file!\n"
msgstr "无法指定多个输入文件！\n"

#: sunrpc/rpc_main.c:1382
msgid "This implementation doesn't support newstyle or MT-safe code!\n"
msgstr ""

#: sunrpc/rpc_main.c:1391
#, c-format
msgid "Cannot use netid flag with inetd flag!\n"
msgstr "无法在使用 inetd 标志的同时使用 netid 标志！\n"

#: sunrpc/rpc_main.c:1403
msgid "Cannot use netid flag without TIRPC!\n"
msgstr "无法在未使用 TIRPC 的时候使用 netid 标志！\n"

#: sunrpc/rpc_main.c:1410
msgid "Cannot use table flags with newstyle!\n"
msgstr "无法以新风格使用表格标志！\n"

#: sunrpc/rpc_main.c:1429
#, c-format
msgid "\"infile\" is required for template generation flags.\n"
msgstr "“输入文件”对模板生成标志来说是必须的。\n"

#: sunrpc/rpc_main.c:1434
#, c-format
msgid "Cannot have more than one file generation flag!\n"
msgstr "无法使用多于一个的文件生成标志！\n"

#: sunrpc/rpc_main.c:1443
#, c-format
msgid "usage: %s infile\n"
msgstr "用法：%s 输入文件\n"

#: sunrpc/rpc_main.c:1444
#, c-format
msgid "\t%s [-abkCLNTM][-Dname[=value]] [-i size] [-I [-K seconds]] [-Y path] infile\n"
msgstr "\t%s [-abkCLNTM][-D名字[=值]] [-i 大小] [-I [-K 秒数]] [-Y 路径] 输入文件\n"

#: sunrpc/rpc_main.c:1446
#, c-format
msgid "\t%s [-c | -h | -l | -m | -t | -Sc | -Ss | -Sm] [-o outfile] [infile]\n"
msgstr "\t%s [-c | -h | -l | -m | -t | -Sc | -Ss | -Sm] [-o 输出文件] [输入文件]\n"

#: sunrpc/rpc_main.c:1448
#, c-format
msgid "\t%s [-s nettype]* [-o outfile] [infile]\n"
msgstr "\t%s [-s 网络类型]* [-o 输出文件] [输入文件]\n"

#: sunrpc/rpc_main.c:1449
#, c-format
msgid "\t%s [-n netid]* [-o outfile] [infile]\n"
msgstr "\t%s [-n 网络 id]* [-o 输出文件] [输入文件]\n"

#: sunrpc/rpc_scan.c:114
msgid "constant or identifier expected"
msgstr "应为常量或标识符"

#: sunrpc/rpc_scan.c:310
msgid "illegal character in file: "
msgstr "文件中的非法字符："

#: sunrpc/rpc_scan.c:349 sunrpc/rpc_scan.c:375
msgid "unterminated string constant"
msgstr "未终止的字符串常量"

#: sunrpc/rpc_scan.c:381
msgid "empty char string"
msgstr ""

#: sunrpc/rpc_scan.c:523 sunrpc/rpc_scan.c:533
msgid "preprocessor error"
msgstr "预处理错误"

#: sunrpc/rpcinfo.c:237 sunrpc/rpcinfo.c:383
#, c-format
msgid "program %lu is not available\n"
msgstr "程序 %lu 不可用\n"

#: sunrpc/rpcinfo.c:264 sunrpc/rpcinfo.c:310 sunrpc/rpcinfo.c:333
#: sunrpc/rpcinfo.c:407 sunrpc/rpcinfo.c:453 sunrpc/rpcinfo.c:476
#: sunrpc/rpcinfo.c:510
#, c-format
msgid "program %lu version %lu is not available\n"
msgstr "程序 %lu 版本 %lu 不可用\n"

#: sunrpc/rpcinfo.c:515
#, c-format
msgid "program %lu version %lu ready and waiting\n"
msgstr "程序 %lu 版本 %lu 就绪并等待\n"

#: sunrpc/rpcinfo.c:556 sunrpc/rpcinfo.c:563
msgid "rpcinfo: can't contact portmapper"
msgstr "rpcinfo：无法同 portmapper 交互"

#: sunrpc/rpcinfo.c:570
msgid "No remote programs registered.\n"
msgstr "没有注册的远程程序。\n"

#: sunrpc/rpcinfo.c:574
msgid "   program vers proto   port\n"
msgstr "   程序 版本 协议   端口\n"

#: sunrpc/rpcinfo.c:613
msgid "(unknown)"
msgstr "(未知)"

#: sunrpc/rpcinfo.c:637
#, c-format
msgid "rpcinfo: broadcast failed: %s\n"
msgstr "rpcinfo：广播失败：%s\n"

#: sunrpc/rpcinfo.c:658
msgid "Sorry. You are not root\n"
msgstr "抱歉。您不是根用户\n"

#: sunrpc/rpcinfo.c:665
#, c-format
msgid "rpcinfo: Could not delete registration for prog %s version %s\n"
msgstr "rpcinfo：无法删除程序 %s 版本 %s 的注册\n"

#: sunrpc/rpcinfo.c:674
msgid "Usage: rpcinfo [ -n portnum ] -u host prognum [ versnum ]\n"
msgstr "用法：rpcinfo [ -n 端口号 ] -u 主机名 程序号 [ 版本号 ]\n"

#: sunrpc/rpcinfo.c:676
msgid "       rpcinfo [ -n portnum ] -t host prognum [ versnum ]\n"
msgstr "       rpcinfo [ -n 端口号 ] -t 主机 程序号 [ 版本号 ]\n"

#: sunrpc/rpcinfo.c:678
msgid "       rpcinfo -p [ host ]\n"
msgstr "       rpcinfo -p [ 主机 ]\n"

#: sunrpc/rpcinfo.c:679
msgid "       rpcinfo -b prognum versnum\n"
msgstr "       rpcinfo -b 程序号 版本号\n"

#: sunrpc/rpcinfo.c:680
msgid "       rpcinfo -d prognum versnum\n"
msgstr "       rpcinfo -d 程序号 版本号\n"

#: sunrpc/rpcinfo.c:695
#, c-format
msgid "rpcinfo: %s is unknown service\n"
msgstr "rpcinfo：%s 是未知的服务\n"

#: sunrpc/rpcinfo.c:732
#, c-format
msgid "rpcinfo: %s is unknown host\n"
msgstr "rpcinfo：%s 是未知的主机\n"

#: sunrpc/svc_run.c:70
msgid "svc_run: - out of memory"
msgstr "svc_run： - 内存不足"

#: sunrpc/svc_run.c:90
msgid "svc_run: - poll failed"
msgstr ""

#: sunrpc/svc_simple.c:87
#, c-format
msgid "can't reassign procedure number %ld\n"
msgstr "无法重新指定进程编号 %ld\n"

#: sunrpc/svc_simple.c:97
msgid "couldn't create an rpc server\n"
msgstr "无法创建 rpc 服务器\n"

#: sunrpc/svc_simple.c:105
#, c-format
msgid "couldn't register prog %ld vers %ld\n"
msgstr "无法注册程序 %ld 版本 %ld\n"

#: sunrpc/svc_simple.c:113
msgid "registerrpc: out of memory\n"
msgstr "registerrpc：内存不足\n"

#: sunrpc/svc_simple.c:173
#, c-format
msgid "trouble replying to prog %d\n"
msgstr ""

#: sunrpc/svc_simple.c:182
#, c-format
msgid "never registered prog %d\n"
msgstr "从未注册的程序 %d\n"

#: sunrpc/svc_tcp.c:155
msgid "svc_tcp.c - tcp socket creation problem"
msgstr "svc_tcp.c - tcp 套接字创建问题"

#: sunrpc/svc_tcp.c:170
msgid "svc_tcp.c - cannot getsockname or listen"
msgstr "svc_tcp.c - 无法进行 getsockname 或 listen 操作"

#: sunrpc/svc_tcp.c:179
msgid "svctcp_create: out of memory\n"
msgstr "svctcp_create：内存不足\n"

#: sunrpc/svc_tcp.c:218
msgid "svc_tcp: makefd_xprt: out of memory\n"
msgstr "svc_tcp：makefd_xprt：内存不足\n"

#: sunrpc/svc_udp.c:128
msgid "svcudp_create: socket creation problem"
msgstr "svcudp_create: 套接字创建问题"

#: sunrpc/svc_udp.c:142
msgid "svcudp_create - cannot getsockname"
msgstr "svcudp_create - 无法调用 getsockname"

#: sunrpc/svc_udp.c:152
msgid "svcudp_create: out of memory\n"
msgstr "svcudp_create：内存不足\n"

#: sunrpc/svc_udp.c:174
msgid "svcudp_create: xp_pad is too small for IP_PKTINFO\n"
msgstr "svcudp_create：xp_pad 对 IP_PKTINFO 来说太小\n"

#: sunrpc/svc_udp.c:474
msgid "enablecache: cache already enabled"
msgstr "enablecache：缓冲区已经启用"

#: sunrpc/svc_udp.c:480
msgid "enablecache: could not allocate cache"
msgstr "enablecache：无法分配缓冲区"

#: sunrpc/svc_udp.c:489
msgid "enablecache: could not allocate cache data"
msgstr "enablecache：无法分配缓冲区数据"

#: sunrpc/svc_udp.c:497
msgid "enablecache: could not allocate cache fifo"
msgstr ""

#: sunrpc/svc_udp.c:532
msgid "cache_set: victim not found"
msgstr "cache_set：找不到 victim"

#: sunrpc/svc_udp.c:543
msgid "cache_set: victim alloc failed"
msgstr "cache_set：分配 victim 失败"

#: sunrpc/svc_udp.c:550
msgid "cache_set: could not allocate new rpc_buffer"
msgstr "cache_set：无法分配新的 rpc_buffer"

#: sunrpc/svc_unix.c:150
msgid "svc_unix.c - AF_UNIX socket creation problem"
msgstr "svc_unix.c - AF_UNIX 套接字创建问题"

#: sunrpc/svc_unix.c:166
msgid "svc_unix.c - cannot getsockname or listen"
msgstr "svc_unix.c - 无法进行 getsockname 或 listen 操作"

#: sunrpc/svc_unix.c:176
msgid "svcunix_create: out of memory\n"
msgstr "svcunix_create：内存不足\n"

#: sunrpc/svc_unix.c:215
msgid "svc_unix: makefd_xprt: out of memory\n"
msgstr "svc_unix：makefd_xprt：内存不足\n"

#: sunrpc/xdr.c:566
msgid "xdr_bytes: out of memory\n"
msgstr "xdr_bytes：内存不足\n"

#: sunrpc/xdr.c:718
msgid "xdr_string: out of memory\n"
msgstr "xdr_string：内存不足\n"

#: sunrpc/xdr_array.c:106
msgid "xdr_array: out of memory\n"
msgstr "xdr_array：内存不足\n"

#: sunrpc/xdr_rec.c:156
msgid "xdrrec_create: out of memory\n"
msgstr "xdrrec_create：内存不足\n"

#: sunrpc/xdr_ref.c:86
msgid "xdr_reference: out of memory\n"
msgstr "xdr_reference：内存不足\n"

#: sysdeps/generic/siglist.h:29 sysdeps/unix/siglist.c:27
msgid "Hangup"
msgstr "挂起"

#: sysdeps/generic/siglist.h:30 sysdeps/unix/siglist.c:28
msgid "Interrupt"
msgstr "中断"

#: sysdeps/generic/siglist.h:31 sysdeps/unix/siglist.c:29
msgid "Quit"
msgstr "退出"

#: sysdeps/generic/siglist.h:32 sysdeps/unix/siglist.c:30
msgid "Illegal instruction"
msgstr "非法指令"

#: sysdeps/generic/siglist.h:33 sysdeps/unix/siglist.c:31
msgid "Trace/breakpoint trap"
msgstr ""

#: sysdeps/generic/siglist.h:34
msgid "Aborted"
msgstr "已放弃"

#: sysdeps/generic/siglist.h:35 sysdeps/unix/siglist.c:34
msgid "Floating point exception"
msgstr "浮点数例外"

#: sysdeps/generic/siglist.h:36 sysdeps/unix/siglist.c:35
msgid "Killed"
msgstr "已杀死"

#: sysdeps/generic/siglist.h:37 sysdeps/unix/siglist.c:36
msgid "Bus error"
msgstr "总线错误"

#: sysdeps/generic/siglist.h:38 sysdeps/unix/siglist.c:37
msgid "Segmentation fault"
msgstr "段错误"

#. TRANS Broken pipe; there is no process reading from the other end of a pipe.
#. TRANS Every library function that returns this error code also generates a
#. TRANS @code{SIGPIPE} signal; this signal terminates the program if not handled
#. TRANS or blocked.  Thus, your program will never actually see @code{EPIPE}
#. TRANS unless it has handled or blocked @code{SIGPIPE}.
#: sysdeps/generic/siglist.h:39 sysdeps/gnu/errlist.c:359
#: sysdeps/unix/siglist.c:39
msgid "Broken pipe"
msgstr "断开的管道"

#: sysdeps/generic/siglist.h:40 sysdeps/unix/siglist.c:40
msgid "Alarm clock"
msgstr "闹钟"

#: sysdeps/generic/siglist.h:41 sysdeps/unix/siglist.c:41
msgid "Terminated"
msgstr "已终止"

#: sysdeps/generic/siglist.h:42 sysdeps/unix/siglist.c:42
msgid "Urgent I/O condition"
msgstr ""

#: sysdeps/generic/siglist.h:43 sysdeps/unix/siglist.c:43
msgid "Stopped (signal)"
msgstr "停止 (信号)"

#: sysdeps/generic/siglist.h:44 sysdeps/unix/siglist.c:44
msgid "Stopped"
msgstr "停止"

#: sysdeps/generic/siglist.h:45 sysdeps/unix/siglist.c:45
msgid "Continued"
msgstr "继续"

#: sysdeps/generic/siglist.h:46 sysdeps/unix/siglist.c:46
msgid "Child exited"
msgstr "子进程已退出"

#: sysdeps/generic/siglist.h:47 sysdeps/unix/siglist.c:47
msgid "Stopped (tty input)"
msgstr "停止 (tty 输入)"

#: sysdeps/generic/siglist.h:48 sysdeps/unix/siglist.c:48
msgid "Stopped (tty output)"
msgstr "停止 (tty 输出)"

#: sysdeps/generic/siglist.h:49 sysdeps/unix/siglist.c:49
msgid "I/O possible"
msgstr ""

#: sysdeps/generic/siglist.h:50 sysdeps/unix/siglist.c:50
msgid "CPU time limit exceeded"
msgstr "超出 CPU 时限"

#: sysdeps/generic/siglist.h:51 sysdeps/unix/siglist.c:51
msgid "File size limit exceeded"
msgstr "文件大小超出限制"

#: sysdeps/generic/siglist.h:52 sysdeps/unix/siglist.c:52
msgid "Virtual timer expired"
msgstr "虚拟计时器超时"

#: sysdeps/generic/siglist.h:53 sysdeps/unix/siglist.c:53
msgid "Profiling timer expired"
msgstr ""

#: sysdeps/generic/siglist.h:54 sysdeps/unix/siglist.c:54
msgid "Window changed"
msgstr ""

#: sysdeps/generic/siglist.h:55 sysdeps/unix/siglist.c:56
msgid "User defined signal 1"
msgstr "用户定义信号 1"

#: sysdeps/generic/siglist.h:56 sysdeps/unix/siglist.c:57
msgid "User defined signal 2"
msgstr "用户定义信号 2"

#: sysdeps/generic/siglist.h:60 sysdeps/unix/siglist.c:33
msgid "EMT trap"
msgstr ""

#: sysdeps/generic/siglist.h:63 sysdeps/unix/siglist.c:38
msgid "Bad system call"
msgstr "错误的系统调用"

#: sysdeps/generic/siglist.h:66
msgid "Stack fault"
msgstr "栈失效"

#: sysdeps/generic/siglist.h:69
msgid "Information request"
msgstr "信息请求"

#: sysdeps/generic/siglist.h:71
msgid "Power failure"
msgstr "电源失效"

#: sysdeps/generic/siglist.h:74 sysdeps/unix/siglist.c:55
msgid "Resource lost"
msgstr "资源丢失"

#. TRANS Operation not permitted; only the owner of the file (or other resource)
#. TRANS or processes with special privileges can perform the operation.
#: sysdeps/gnu/errlist.c:25
msgid "Operation not permitted"
msgstr "不允许的操作"

#. TRANS No process matches the specified process ID.
#: sysdeps/gnu/errlist.c:45
msgid "No such process"
msgstr "没有那个进程"

#. TRANS Interrupted function call; an asynchronous signal occurred and prevented
#. TRANS completion of the call.  When this happens, you should try the call
#. TRANS again.
#. TRANS
#. TRANS You can choose to have functions resume after a signal that is handled,
#. TRANS rather than failing with @code{EINTR}; see @ref{Interrupted
#. TRANS Primitives}.
#: sysdeps/gnu/errlist.c:60
msgid "Interrupted system call"
msgstr "被中断的系统调用"

#. TRANS Input/output error; usually used for physical read or write errors.
#: sysdeps/gnu/errlist.c:69
msgid "Input/output error"
msgstr "输入/输出错误"

#. TRANS No such device or address.  The system tried to use the device
#. TRANS represented by a file you specified, and it couldn't find the device.
#. TRANS This can mean that the device file was installed incorrectly, or that
#. TRANS the physical device is missing or not correctly attached to the
#. TRANS computer.
#: sysdeps/gnu/errlist.c:82
msgid "No such device or address"
msgstr "没有那个设备或地址"

#. TRANS Argument list too long; used when the arguments passed to a new program
#. TRANS being executed with one of the @code{exec} functions (@pxref{Executing a
#. TRANS File}) occupy too much memory space.  This condition never arises in the
#. TRANS GNU system.
#: sysdeps/gnu/errlist.c:94
msgid "Argument list too long"
msgstr "参数列表过长"

#. TRANS Invalid executable file format.  This condition is detected by the
#. TRANS @code{exec} functions; see @ref{Executing a File}.
#: sysdeps/gnu/errlist.c:104
msgid "Exec format error"
msgstr "可执行文件格式错误"

#. TRANS Bad file descriptor; for example, I/O on a descriptor that has been
#. TRANS closed or reading from a descriptor open only for writing (or vice
#. TRANS versa).
#: sysdeps/gnu/errlist.c:115
msgid "Bad file descriptor"
msgstr "错误的文件描述符"

#. TRANS There are no child processes.  This error happens on operations that are
#. TRANS supposed to manipulate child processes, when there aren't any processes
#. TRANS to manipulate.
#: sysdeps/gnu/errlist.c:126
msgid "No child processes"
msgstr "没有子进程"

#. TRANS Deadlock avoided; allocating a system resource would have resulted in a
#. TRANS deadlock situation.  The system does not guarantee that it will notice
#. TRANS all such situations.  This error means you got lucky and the system
#. TRANS noticed; it might just hang.  @xref{File Locks}, for an example.
#: sysdeps/gnu/errlist.c:138
msgid "Resource deadlock avoided"
msgstr "已避免资源死锁"

#. TRANS No memory available.  The system cannot allocate more virtual memory
#. TRANS because its capacity is full.
#: sysdeps/gnu/errlist.c:148
msgid "Cannot allocate memory"
msgstr "无法分配内存"

#. TRANS Bad address; an invalid pointer was detected.
#. TRANS In the GNU system, this error never happens; you get a signal instead.
#: sysdeps/gnu/errlist.c:167
msgid "Bad address"
msgstr "错误的地址"

#. TRANS A file that isn't a block special file was given in a situation that
#. TRANS requires one.  For example, trying to mount an ordinary file as a file
#. TRANS system in Unix gives this error.
#: sysdeps/gnu/errlist.c:178
msgid "Block device required"
msgstr "需要块设备"

#. TRANS Resource busy; a system resource that can't be shared is already in use.
#. TRANS For example, if you try to delete a file that is the root of a currently
#. TRANS mounted filesystem, you get this error.
#: sysdeps/gnu/errlist.c:189
msgid "Device or resource busy"
msgstr "设备或资源忙"

#. TRANS File exists; an existing file was specified in a context where it only
#. TRANS makes sense to specify a new file.
#: sysdeps/gnu/errlist.c:199
msgid "File exists"
msgstr "文件已存在"

#. TRANS An attempt to make an improper link across file systems was detected.
#. TRANS This happens not only when you use @code{link} (@pxref{Hard Links}) but
#. TRANS also when you rename a file with @code{rename} (@pxref{Renaming Files}).
#: sysdeps/gnu/errlist.c:210
msgid "Invalid cross-device link"
msgstr "无效的跨设备连接"

#. TRANS The wrong type of device was given to a function that expects a
#. TRANS particular sort of device.
#: sysdeps/gnu/errlist.c:220
msgid "No such device"
msgstr "没有那个设备"

#. TRANS A file that isn't a directory was specified when a directory is required.
#: sysdeps/gnu/errlist.c:229
msgid "Not a directory"
msgstr "不是目录"

#. TRANS File is a directory; you cannot open a directory for writing,
#. TRANS or create or remove hard links to it.
#: sysdeps/gnu/errlist.c:239
msgid "Is a directory"
msgstr "是一个目录"

#. TRANS Invalid argument.  This is used to indicate various kinds of problems
#. TRANS with passing the wrong argument to a library function.
#: sysdeps/gnu/errlist.c:249
msgid "Invalid argument"
msgstr "无效的参数"

#. TRANS The current process has too many files open and can't open any more.
#. TRANS Duplicate descriptors do count toward this limit.
#. TRANS
#. TRANS In BSD and GNU, the number of open files is controlled by a resource
#. TRANS limit that can usually be increased.  If you get this error, you might
#. TRANS want to increase the @code{RLIMIT_NOFILE} limit or make it unlimited;
#. TRANS @pxref{Limits on Resources}.
#: sysdeps/gnu/errlist.c:264
msgid "Too many open files"
msgstr "打开的文件过多"

#. TRANS There are too many distinct file openings in the entire system.  Note
#. TRANS that any number of linked channels count as just one file opening; see
#. TRANS @ref{Linked Channels}.  This error never occurs in the GNU system.
#: sysdeps/gnu/errlist.c:275
msgid "Too many open files in system"
msgstr "系统中打开的文件过多"

#. TRANS Inappropriate I/O control operation, such as trying to set terminal
#. TRANS modes on an ordinary file.
#: sysdeps/gnu/errlist.c:285
msgid "Inappropriate ioctl for device"
msgstr "对设备不适当的 ioctl 操作"

#. TRANS An attempt to execute a file that is currently open for writing, or
#. TRANS write to a file that is currently being executed.  Often using a
#. TRANS debugger to run a program is considered having it open for writing and
#. TRANS will cause this error.  (The name stands for ``text file busy''.)  This
#. TRANS is not an error in the GNU system; the text is copied as necessary.
#: sysdeps/gnu/errlist.c:298
msgid "Text file busy"
msgstr "文本文件忙"

#. TRANS File too big; the size of a file would be larger than allowed by the system.
#: sysdeps/gnu/errlist.c:307
msgid "File too large"
msgstr "文件过大"

#. TRANS No space left on device; write operation on a file failed because the
#. TRANS disk is full.
#: sysdeps/gnu/errlist.c:317
msgid "No space left on device"
msgstr "设备上没有空间"

#. TRANS Invalid seek operation (such as on a pipe).
#: sysdeps/gnu/errlist.c:326
msgid "Illegal seek"
msgstr "非法 seek 操作"

#. TRANS An attempt was made to modify something on a read-only file system.
#: sysdeps/gnu/errlist.c:335
msgid "Read-only file system"
msgstr "只读文件系统"

#. TRANS Too many links; the link count of a single file would become too large.
#. TRANS @code{rename} can cause this error if the file being renamed already has
#. TRANS as many links as it can take (@pxref{Renaming Files}).
#: sysdeps/gnu/errlist.c:346
msgid "Too many links"
msgstr "过多的连接"

#. TRANS Domain error; used by mathematical functions when an argument value does
#. TRANS not fall into the domain over which the function is defined.
#: sysdeps/gnu/errlist.c:369
msgid "Numerical argument out of domain"
msgstr "数值参数超出域"

#. TRANS Range error; used by mathematical functions when the result value is
#. TRANS not representable because of overflow or underflow.
#: sysdeps/gnu/errlist.c:379
msgid "Numerical result out of range"
msgstr "数值结果超出范围"

#. TRANS Resource temporarily unavailable; the call might work if you try again
#. TRANS later.  The macro @code{EWOULDBLOCK} is another name for @code{EAGAIN};
#. TRANS they are always the same in the GNU C library.
#. TRANS
#. TRANS This error can happen in a few different situations:
#. TRANS
#. TRANS @itemize @bullet
#. TRANS @item
#. TRANS An operation that would block was attempted on an object that has
#. TRANS non-blocking mode selected.  Trying the same operation again will block
#. TRANS until some external condition makes it possible to read, write, or
#. TRANS connect (whatever the operation).  You can use @code{select} to find out
#. TRANS when the operation will be possible; @pxref{Waiting for I/O}.
#. TRANS
#. TRANS @strong{Portability Note:} In many older Unix systems, this condition
#. TRANS was indicated by @code{EWOULDBLOCK}, which was a distinct error code
#. TRANS different from @code{EAGAIN}.  To make your program portable, you should
#. TRANS check for both codes and treat them the same.
#. TRANS
#. TRANS @item
#. TRANS A temporary resource shortage made an operation impossible.  @code{fork}
#. TRANS can return this error.  It indicates that the shortage is expected to
#. TRANS pass, so your program can try the call again later and it may succeed.
#. TRANS It is probably a good idea to delay for a few seconds before trying it
#. TRANS again, to allow time for other processes to release scarce resources.
#. TRANS Such shortages are usually fairly serious and affect the whole system,
#. TRANS so usually an interactive program should report the error to the user
#. TRANS and return to its command loop.
#. TRANS @end itemize
#: sysdeps/gnu/errlist.c:416
msgid "Resource temporarily unavailable"
msgstr "资源暂时不可用"

#. TRANS In the GNU C library, this is another name for @code{EAGAIN} (above).
#. TRANS The values are always the same, on every operating system.
#. TRANS
#. TRANS C libraries in many older Unix systems have @code{EWOULDBLOCK} as a
#. TRANS separate error code.
#: sysdeps/gnu/errlist.c:429
msgid "Operation would block"
msgstr "操作将阻塞"

#. TRANS An operation that cannot complete immediately was initiated on an object
#. TRANS that has non-blocking mode selected.  Some functions that must always
#. TRANS block (such as @code{connect}; @pxref{Connecting}) never return
#. TRANS @code{EAGAIN}.  Instead, they return @code{EINPROGRESS} to indicate that
#. TRANS the operation has begun and will take some time.  Attempts to manipulate
#. TRANS the object before the call completes return @code{EALREADY}.  You can
#. TRANS use the @code{select} function to find out when the pending operation
#. TRANS has completed; @pxref{Waiting for I/O}.
#: sysdeps/gnu/errlist.c:445
msgid "Operation now in progress"
msgstr "操作现在正在进行"

#. TRANS An operation is already in progress on an object that has non-blocking
#. TRANS mode selected.
#: sysdeps/gnu/errlist.c:455
msgid "Operation already in progress"
msgstr "操作已经在进行"

#. TRANS A file that isn't a socket was specified when a socket is required.
#: sysdeps/gnu/errlist.c:464
msgid "Socket operation on non-socket"
msgstr "对非套接字进行套接字操作"

#. TRANS The size of a message sent on a socket was larger than the supported
#. TRANS maximum size.
#: sysdeps/gnu/errlist.c:474
msgid "Message too long"
msgstr "消息过长"

#. TRANS The socket type does not support the requested communications protocol.
#: sysdeps/gnu/errlist.c:483
msgid "Protocol wrong type for socket"
msgstr "错误的 socket 协议类型"

#. TRANS You specified a socket option that doesn't make sense for the
#. TRANS particular protocol being used by the socket.  @xref{Socket Options}.
#: sysdeps/gnu/errlist.c:493
msgid "Protocol not available"
msgstr "不可用的协议"

#. TRANS The socket domain does not support the requested communications protocol
#. TRANS (perhaps because the requested protocol is completely invalid).
#. TRANS @xref{Creating a Socket}.
#: sysdeps/gnu/errlist.c:504
msgid "Protocol not supported"
msgstr "不支持的协议"

#. TRANS The socket type is not supported.
#: sysdeps/gnu/errlist.c:513
msgid "Socket type not supported"
msgstr "不支持的套接字类型"

#. TRANS The operation you requested is not supported.  Some socket functions
#. TRANS don't make sense for all types of sockets, and others may not be
#. TRANS implemented for all communications protocols.  In the GNU system, this
#. TRANS error can happen for many calls when the object does not support the
#. TRANS particular operation; it is a generic indication that the server knows
#. TRANS nothing to do for that call.
#: sysdeps/gnu/errlist.c:527
msgid "Operation not supported"
msgstr "不支持的操作"

#. TRANS The socket communications protocol family you requested is not supported.
#: sysdeps/gnu/errlist.c:536
msgid "Protocol family not supported"
msgstr "不支持的协议族"

#. TRANS The address family specified for a socket is not supported; it is
#. TRANS inconsistent with the protocol being used on the socket.  @xref{Sockets}.
#: sysdeps/gnu/errlist.c:546
msgid "Address family not supported by protocol"
msgstr "协议不支持的地址族"

#. TRANS The requested socket address is already in use.  @xref{Socket Addresses}.
#: sysdeps/gnu/errlist.c:555
msgid "Address already in use"
msgstr "地址已在使用"

#. TRANS The requested socket address is not available; for example, you tried
#. TRANS to give a socket a name that doesn't match the local host name.
#. TRANS @xref{Socket Addresses}.
#: sysdeps/gnu/errlist.c:566
msgid "Cannot assign requested address"
msgstr "无法指定被请求的地址"

#. TRANS A socket operation failed because the network was down.
#: sysdeps/gnu/errlist.c:575
msgid "Network is down"
msgstr "网络已关闭"

#. TRANS A socket operation failed because the subnet containing the remote host
#. TRANS was unreachable.
#: sysdeps/gnu/errlist.c:585
msgid "Network is unreachable"
msgstr "网络不可达"

#. TRANS A network connection was reset because the remote host crashed.
#: sysdeps/gnu/errlist.c:594
msgid "Network dropped connection on reset"
msgstr "重置时断开网络连接"

#. TRANS A network connection was aborted locally.
#: sysdeps/gnu/errlist.c:603
msgid "Software caused connection abort"
msgstr "由软件导致的连接断开"

#. TRANS A network connection was closed for reasons outside the control of the
#. TRANS local host, such as by the remote machine rebooting or an unrecoverable
#. TRANS protocol violation.
#: sysdeps/gnu/errlist.c:614
msgid "Connection reset by peer"
msgstr ""

#. TRANS The kernel's buffers for I/O operations are all in use.  In GNU, this
#. TRANS error is always synonymous with @code{ENOMEM}; you may get one or the
#. TRANS other from network operations.
#: sysdeps/gnu/errlist.c:625
msgid "No buffer space available"
msgstr "没有可用的缓冲区空间"

#. TRANS You tried to connect a socket that is already connected.
#. TRANS @xref{Connecting}.
#: sysdeps/gnu/errlist.c:635
msgid "Transport endpoint is already connected"
msgstr "传输端点已连接"

#. TRANS The socket is not connected to anything.  You get this error when you
#. TRANS try to transmit data over a socket, without first specifying a
#. TRANS destination for the data.  For a connectionless socket (for datagram
#. TRANS protocols, such as UDP), you get @code{EDESTADDRREQ} instead.
#: sysdeps/gnu/errlist.c:647
msgid "Transport endpoint is not connected"
msgstr "传输端点尚未连接"

#. TRANS No default destination address was set for the socket.  You get this
#. TRANS error when you try to transmit data over a connectionless socket,
#. TRANS without first specifying a destination for the data with @code{connect}.
#: sysdeps/gnu/errlist.c:658
msgid "Destination address required"
msgstr "需要目标地址"

#. TRANS The socket has already been shut down.
#: sysdeps/gnu/errlist.c:667
msgid "Cannot send after transport endpoint shutdown"
msgstr "无法在传输端点关闭以后发送"

#. TRANS ???
#: sysdeps/gnu/errlist.c:676
msgid "Too many references: cannot splice"
msgstr "过多的引用：无法接合"

#. TRANS A socket operation with a specified timeout received no response during
#. TRANS the timeout period.
#: sysdeps/gnu/errlist.c:686
msgid "Connection timed out"
msgstr "连接超时"

#. TRANS A remote host refused to allow the network connection (typically because
#. TRANS it is not running the requested service).
#: sysdeps/gnu/errlist.c:696
msgid "Connection refused"
msgstr "拒绝连接"

#. TRANS Too many levels of symbolic links were encountered in looking up a file name.
#. TRANS This often indicates a cycle of symbolic links.
#: sysdeps/gnu/errlist.c:706
msgid "Too many levels of symbolic links"
msgstr "符号连接的层数过多"

#. TRANS Filename too long (longer than @code{PATH_MAX}; @pxref{Limits for
#. TRANS Files}) or host name too long (in @code{gethostname} or
#. TRANS @code{sethostname}; @pxref{Host Identification}).
#: sysdeps/gnu/errlist.c:717
msgid "File name too long"
msgstr "文件名过长"

#. TRANS The remote host for a requested network connection is down.
#: sysdeps/gnu/errlist.c:726
msgid "Host is down"
msgstr "主机关闭"

#. TRANS The remote host for a requested network connection is not reachable.
#: sysdeps/gnu/errlist.c:735
msgid "No route to host"
msgstr "没有到主机的路由"

#. TRANS Directory not empty, where an empty directory was expected.  Typically,
#. TRANS this error occurs when you are trying to delete a directory.
#: sysdeps/gnu/errlist.c:745
msgid "Directory not empty"
msgstr "目录非空"

#. TRANS This means that the per-user limit on new process would be exceeded by
#. TRANS an attempted @code{fork}.  @xref{Limits on Resources}, for details on
#. TRANS the @code{RLIMIT_NPROC} limit.
#: sysdeps/gnu/errlist.c:756
msgid "Too many processes"
msgstr "进程过多"

#. TRANS The file quota system is confused because there are too many users.
#. TRANS @c This can probably happen in a GNU system when using NFS.
#: sysdeps/gnu/errlist.c:766
msgid "Too many users"
msgstr "用户过多"

#. TRANS The user's disk quota was exceeded.
#: sysdeps/gnu/errlist.c:775
msgid "Disk quota exceeded"
msgstr "超出磁盘限额"

#. TRANS Stale NFS file handle.  This indicates an internal confusion in the NFS
#. TRANS system which is due to file system rearrangements on the server host.
#. TRANS Repairing this condition usually requires unmounting and remounting
#. TRANS the NFS file system on the local host.
#: sysdeps/gnu/errlist.c:787
msgid "Stale NFS file handle"
msgstr ""

#. TRANS An attempt was made to NFS-mount a remote file system with a file name that
#. TRANS already specifies an NFS-mounted file.
#. TRANS (This is an error on some operating systems, but we expect it to work
#. TRANS properly on the GNU system, making this error code impossible.)
#: sysdeps/gnu/errlist.c:799
msgid "Object is remote"
msgstr "对象是远程的"

#. TRANS ???
#: sysdeps/gnu/errlist.c:808
msgid "RPC struct is bad"
msgstr "RPC 结构错误"

#. TRANS ???
#: sysdeps/gnu/errlist.c:817
msgid "RPC version wrong"
msgstr "RPC 版本错误"

#. TRANS ???
#: sysdeps/gnu/errlist.c:826
msgid "RPC program not available"
msgstr "RPC 程序不可用"

#. TRANS ???
#: sysdeps/gnu/errlist.c:835
msgid "RPC program version wrong"
msgstr "RPC 程序版本错误"

#. TRANS ???
#: sysdeps/gnu/errlist.c:844
msgid "RPC bad procedure for program"
msgstr ""

#. TRANS No locks available.  This is used by the file locking facilities; see
#. TRANS @ref{File Locks}.  This error is never generated by the GNU system, but
#. TRANS it can result from an operation to an NFS server running another
#. TRANS operating system.
#: sysdeps/gnu/errlist.c:856
msgid "No locks available"
msgstr "没有可用的锁"

#. TRANS Inappropriate file type or format.  The file was the wrong type for the
#. TRANS operation, or a data file had the wrong format.
#. TRANS
#. TRANS On some systems @code{chmod} returns this error if you try to set the
#. TRANS sticky bit on a non-directory file; @pxref{Setting Permissions}.
#: sysdeps/gnu/errlist.c:869
msgid "Inappropriate file type or format"
msgstr "不适当的文件类型或格式"

#. TRANS ???
#: sysdeps/gnu/errlist.c:878
msgid "Authentication error"
msgstr "认证错误"

#. TRANS ???
#: sysdeps/gnu/errlist.c:887
msgid "Need authenticator"
msgstr "需要认证器"

#. TRANS Function not implemented.  This indicates that the function called is
#. TRANS not implemented at all, either in the C library itself or in the
#. TRANS operating system.  When you get this error, you can be sure that this
#. TRANS particular function will always fail with @code{ENOSYS} unless you
#. TRANS install a new version of the C library or the operating system.
#: sysdeps/gnu/errlist.c:900
msgid "Function not implemented"
msgstr "函数未实现"

#. TRANS Not supported.  A function returns this error when certain parameter
#. TRANS values are valid, but the functionality they request is not available.
#. TRANS This can mean that the function does not implement a particular command
#. TRANS or option value or flag bit at all.  For functions that operate on some
#. TRANS object given in a parameter, such as a file descriptor or a port, it
#. TRANS might instead mean that only @emph{that specific object} (file
#. TRANS descriptor, port, etc.) is unable to support the other parameters given;
#. TRANS different file descriptors might support different ranges of parameter
#. TRANS values.
#. TRANS
#. TRANS If the entire function is not available at all in the implementation,
#. TRANS it returns @code{ENOSYS} instead.
#: sysdeps/gnu/errlist.c:920
msgid "Not supported"
msgstr "不支持"

#. TRANS While decoding a multibyte character the function came along an invalid
#. TRANS or an incomplete sequence of bytes or the given wide character is invalid.
#: sysdeps/gnu/errlist.c:930
msgid "Invalid or incomplete multibyte or wide character"
msgstr "无效或不完整的多字节字符或宽字符"

#. TRANS In the GNU system, servers supporting the @code{term} protocol return
#. TRANS this error for certain operations when the caller is not in the
#. TRANS foreground process group of the terminal.  Users do not usually see this
#. TRANS error because functions such as @code{read} and @code{write} translate
#. TRANS it into a @code{SIGTTIN} or @code{SIGTTOU} signal.  @xref{Job Control},
#. TRANS for information on process groups and these signals.
#: sysdeps/gnu/errlist.c:944
msgid "Inappropriate operation for background process"
msgstr "对后台进程的不适当操作"

#. TRANS In the GNU system, opening a file returns this error when the file is
#. TRANS translated by a program and the translator program dies while starting
#. TRANS up, before it has connected to the file.
#: sysdeps/gnu/errlist.c:955
msgid "Translator died"
msgstr ""

#. TRANS The experienced user will know what is wrong.
#. TRANS @c This error code is a joke.  Its perror text is part of the joke.
#. TRANS @c Don't change it.
#: sysdeps/gnu/errlist.c:966
msgid "?"
msgstr "？"

#. TRANS You did @strong{what}?
#: sysdeps/gnu/errlist.c:975
msgid "You really blew it this time"
msgstr ""

#. TRANS Go home and have a glass of warm, dairy-fresh milk.
#: sysdeps/gnu/errlist.c:984
msgid "Computer bought the farm"
msgstr ""

#. TRANS This error code has no purpose.
#: sysdeps/gnu/errlist.c:993
msgid "Gratuitous error"
msgstr ""

#: sysdeps/gnu/errlist.c:1001
msgid "Bad message"
msgstr "错误的消息"

#: sysdeps/gnu/errlist.c:1009
msgid "Identifier removed"
msgstr "标识符已删除"

#: sysdeps/gnu/errlist.c:1017
msgid "Multihop attempted"
msgstr ""

#: sysdeps/gnu/errlist.c:1025
msgid "No data available"
msgstr "没有可用的数据"

#: sysdeps/gnu/errlist.c:1033
msgid "Link has been severed"
msgstr ""

#: sysdeps/gnu/errlist.c:1041
msgid "No message of desired type"
msgstr ""

#: sysdeps/gnu/errlist.c:1049
msgid "Out of streams resources"
msgstr "流资源不足"

#: sysdeps/gnu/errlist.c:1057
msgid "Device not a stream"
msgstr "设备不是流"

#: sysdeps/gnu/errlist.c:1065
msgid "Value too large for defined data type"
msgstr "对已定义的数据类型来说值过大"

#: sysdeps/gnu/errlist.c:1073
msgid "Protocol error"
msgstr "协议错误"

#: sysdeps/gnu/errlist.c:1081
msgid "Timer expired"
msgstr "计时器超时"

#. TRANS Operation canceled; an asynchronous operation was canceled before it
#. TRANS completed.  @xref{Asynchronous I/O}.  When you call @code{aio_cancel},
#. TRANS the normal result is for the operations affected to complete with this
#. TRANS error; @pxref{Cancel AIO Operations}.
#: sysdeps/gnu/errlist.c:1093
msgid "Operation canceled"
msgstr "操作已取消"

#: sysdeps/gnu/errlist.c:1101
msgid "Interrupted system call should be restarted"
msgstr "被中断的系统调用应该重新启动"

#: sysdeps/gnu/errlist.c:1109
msgid "Channel number out of range"
msgstr "通道编号超出范围"

#: sysdeps/gnu/errlist.c:1117
msgid "Level 2 not synchronized"
msgstr "级别 2 尚未同步"

#: sysdeps/gnu/errlist.c:1125
msgid "Level 3 halted"
msgstr "级别 3 已关闭"

#: sysdeps/gnu/errlist.c:1133
msgid "Level 3 reset"
msgstr "级别 3 已重置"

#: sysdeps/gnu/errlist.c:1141
msgid "Link number out of range"
msgstr "连接数超出范围"

#: sysdeps/gnu/errlist.c:1149
msgid "Protocol driver not attached"
msgstr "未加载协议驱动程序"

#: sysdeps/gnu/errlist.c:1157
msgid "No CSI structure available"
msgstr "没有可用的 CSI 结构"

#: sysdeps/gnu/errlist.c:1165
msgid "Level 2 halted"
msgstr "级别 2 己关闭"

#: sysdeps/gnu/errlist.c:1173
msgid "Invalid exchange"
msgstr "无效的交换"

#: sysdeps/gnu/errlist.c:1181
msgid "Invalid request descriptor"
msgstr "无效的请求描述符"

#: sysdeps/gnu/errlist.c:1189
msgid "Exchange full"
msgstr "交换满"

#: sysdeps/gnu/errlist.c:1197
msgid "No anode"
msgstr "没有 anode"

#: sysdeps/gnu/errlist.c:1205
msgid "Invalid request code"
msgstr "无效的请求码"

#: sysdeps/gnu/errlist.c:1213
msgid "Invalid slot"
msgstr ""

#: sysdeps/gnu/errlist.c:1221
msgid "File locking deadlock error"
msgstr "文件锁死锁错误"

#: sysdeps/gnu/errlist.c:1229
msgid "Bad font file format"
msgstr "错误的字体文件格式"

#: sysdeps/gnu/errlist.c:1237
msgid "Machine is not on the network"
msgstr "机器不在网络中"

#: sysdeps/gnu/errlist.c:1245
msgid "Package not installed"
msgstr "包未安装"

#: sysdeps/gnu/errlist.c:1253
msgid "Advertise error"
msgstr ""

#: sysdeps/gnu/errlist.c:1261
msgid "Srmount error"
msgstr ""

#: sysdeps/gnu/errlist.c:1269
msgid "Communication error on send"
msgstr "发送时出现通讯错误"

#: sysdeps/gnu/errlist.c:1277
msgid "RFS specific error"
msgstr ""

#: sysdeps/gnu/errlist.c:1285
msgid "Name not unique on network"
msgstr ""

#: sysdeps/gnu/errlist.c:1293
msgid "File descriptor in bad state"
msgstr "文件描述符处于错误状态"

#: sysdeps/gnu/errlist.c:1301
msgid "Remote address changed"
msgstr "远程地址已改变"

#: sysdeps/gnu/errlist.c:1309
msgid "Can not access a needed shared library"
msgstr "无法访问必须的共享库"

#: sysdeps/gnu/errlist.c:1317
msgid "Accessing a corrupted shared library"
msgstr "正在访问一个已毁坏的共享库"

#: sysdeps/gnu/errlist.c:1325
msgid ".lib section in a.out corrupted"
msgstr "a.out 中的 .lib 节已毁坏"

#: sysdeps/gnu/errlist.c:1333
msgid "Attempting to link in too many shared libraries"
msgstr "试图于过多的共享库相连接"

#: sysdeps/gnu/errlist.c:1341
msgid "Cannot exec a shared library directly"
msgstr "无法直接执行共享库"

#: sysdeps/gnu/errlist.c:1349
msgid "Streams pipe error"
msgstr "流管道错误"

#: sysdeps/gnu/errlist.c:1357
msgid "Structure needs cleaning"
msgstr "结构需要清理"

#: sysdeps/gnu/errlist.c:1365
msgid "Not a XENIX named type file"
msgstr "不是 XENIX 命名的类型文件"

#: sysdeps/gnu/errlist.c:1373
msgid "No XENIX semaphores available"
msgstr "没有可用的 XENIX 信号量"

#: sysdeps/gnu/errlist.c:1381
msgid "Is a named type file"
msgstr "是一个有名类型文件"

#: sysdeps/gnu/errlist.c:1389
msgid "Remote I/O error"
msgstr "远程 I/O 错误"

#: sysdeps/gnu/errlist.c:1397
msgid "No medium found"
msgstr "找不到介质"

#: sysdeps/gnu/errlist.c:1405
msgid "Wrong medium type"
msgstr "错误的介质类型"

#: sysdeps/gnu/errlist.c:1413
msgid "Required key not available"
msgstr "需要的关键字不存在"

#: sysdeps/gnu/errlist.c:1421
msgid "Key has expired"
msgstr "关键字已过期"

#: sysdeps/gnu/errlist.c:1429
msgid "Key has been revoked"
msgstr ""

#: sysdeps/gnu/errlist.c:1437
msgid "Key was rejected by service"
msgstr ""

#: sysdeps/gnu/errlist.c:1445
msgid "Owner died"
msgstr ""

#: sysdeps/gnu/errlist.c:1453
msgid "State not recoverable"
msgstr ""

#: sysdeps/mach/_strerror.c:57
msgid "Error in unknown error system: "
msgstr "未知的错误系统中出错："

#: sysdeps/posix/gai_strerror-strs.h:1
msgid "Address family for hostname not supported"
msgstr "不支持的主机名地址族"

#: sysdeps/posix/gai_strerror-strs.h:2
msgid "Temporary failure in name resolution"
msgstr "域名解析暂时失败"

#: sysdeps/posix/gai_strerror-strs.h:3
msgid "Bad value for ai_flags"
msgstr "错误的 ai_flags 的值"

#: sysdeps/posix/gai_strerror-strs.h:4
msgid "Non-recoverable failure in name resolution"
msgstr "域名解析中出现不可修复的失败"

#: sysdeps/posix/gai_strerror-strs.h:5
msgid "ai_family not supported"
msgstr "不支持 ai_family"

#: sysdeps/posix/gai_strerror-strs.h:6
msgid "Memory allocation failure"
msgstr "内存分配失败"

#: sysdeps/posix/gai_strerror-strs.h:7
msgid "No address associated with hostname"
msgstr "没有与主机名关联的地址"

#: sysdeps/posix/gai_strerror-strs.h:8
msgid "Name or service not known"
msgstr "未知的名称或服务"

#: sysdeps/posix/gai_strerror-strs.h:9
msgid "Servname not supported for ai_socktype"
msgstr ""

#: sysdeps/posix/gai_strerror-strs.h:10
msgid "ai_socktype not supported"
msgstr "不支持 ai_socktype"

#: sysdeps/posix/gai_strerror-strs.h:11
msgid "System error"
msgstr "系统错误"

#: sysdeps/posix/gai_strerror-strs.h:12
msgid "Processing request in progress"
msgstr ""

#: sysdeps/posix/gai_strerror-strs.h:13
msgid "Request canceled"
msgstr "请求已取消"

#: sysdeps/posix/gai_strerror-strs.h:14
msgid "Request not canceled"
msgstr "请求未取消"

#: sysdeps/posix/gai_strerror-strs.h:15
msgid "All requests done"
msgstr "完成所有请求"

#: sysdeps/posix/gai_strerror-strs.h:16
msgid "Interrupted by a signal"
msgstr "被信号中断"

#: sysdeps/posix/gai_strerror-strs.h:17
msgid "Parameter string not correctly encoded"
msgstr ""

#: sysdeps/unix/siglist.c:26
msgid "Signal 0"
msgstr "信号 0"

#: sysdeps/unix/siglist.c:32
msgid "IOT trap"
msgstr ""

#: sysdeps/unix/sysv/linux/i386/readelflib.c:49
#, c-format
msgid "%s is for unknown machine %d.\n"
msgstr "%s 用于未知的机器 %d。\n"

#: sysdeps/unix/sysv/linux/ia64/makecontext.c:63
#, c-format
msgid "makecontext: does not know how to handle more than 8 arguments\n"
msgstr "makecontext：不知道该如何处理多于 8 个参数的情况\n"

#: sysdeps/unix/sysv/linux/lddlibc4.c:64
#, c-format
msgid "cannot open `%s'"
msgstr "无法打开“%s”"

#: sysdeps/unix/sysv/linux/lddlibc4.c:68
#, c-format
msgid "cannot read header from `%s'"
msgstr "无法从“%s”中读入头"

#: timezone/zdump.c:211
msgid "lacks alphabetic at start"
msgstr ""

#: timezone/zdump.c:213
msgid "has fewer than 3 alphabetics"
msgstr ""

#: timezone/zdump.c:215
msgid "has more than 6 alphabetics"
msgstr ""

#: timezone/zdump.c:223
msgid "differs from POSIX standard"
msgstr ""

#: timezone/zdump.c:229
#, c-format
msgid "%s: warning: zone \"%s\" abbreviation \"%s\" %s\n"
msgstr ""

#: timezone/zdump.c:280
#, c-format
msgid "%s: usage is %s [ --version ] [ -v ] [ -c [loyear,]hiyear ] zonename ...\n"
msgstr "%s：用法为 %s [ --version ] [ -v ] [ -c [loyear,]hiyear ] 区域名 ...\n"

#: timezone/zdump.c:297
#, c-format
msgid "%s: wild -c argument %s\n"
msgstr "%s： 怪异的 -c 选项 %s\n"

#: timezone/zdump.c:388
msgid "Error writing to standard output"
msgstr "写入标准输出出错"

#: timezone/zdump.c:411
#, c-format
msgid "%s: use of -v on system with floating time_t other than float or double\n"
msgstr ""

#: timezone/zic.c:392
#, c-format
msgid "%s: Memory exhausted: %s\n"
msgstr "%s：内存耗尽：%s\n"

#: timezone/zic.c:451
#, c-format
msgid "\"%s\", line %d: %s"
msgstr "“%s”，行 %d：%s"

#: timezone/zic.c:454
#, c-format
msgid " (rule from \"%s\", line %d)"
msgstr ""

#: timezone/zic.c:466
msgid "warning: "
msgstr "警告："

#: timezone/zic.c:476
#, c-format
msgid ""
"%s: usage is %s [ --version ] [ -v ] [ -l localtime ] [ -p posixrules ] \\\n"
"\t[ -d directory ] [ -L leapseconds ] [ -y yearistype ] [ filename ... ]\n"
msgstr ""
"%s：用法为 %s [ --version ] [ -v ] [ -l 本地时间 ] [ -p posix 规则 ] \\\n"
"\t[ -d 目录 ] [ -L leapseconds ] [ -y yearistype ] [ 文件名 ... ]\n"

#: timezone/zic.c:511
msgid "wild compilation-time specification of zic_t"
msgstr ""

#: timezone/zic.c:528
#, c-format
msgid "%s: More than one -d option specified\n"
msgstr "%s：给出了多个 -d 选项\n"

#: timezone/zic.c:538
#, c-format
msgid "%s: More than one -l option specified\n"
msgstr "%s：给出了多个 -l 选项\n"

#: timezone/zic.c:548
#, c-format
msgid "%s: More than one -p option specified\n"
msgstr "%s：给出了多个 -p 选项\n"

#: timezone/zic.c:558
#, c-format
msgid "%s: More than one -y option specified\n"
msgstr "%s：给出了多个 -y 选项\n"

#: timezone/zic.c:568
#, c-format
msgid "%s: More than one -L option specified\n"
msgstr "%s：给出了多个 -L 选项\n"

#: timezone/zic.c:617
msgid "link to link"
msgstr "链接到链接"

#: timezone/zic.c:682
msgid "hard link failed, symbolic link used"
msgstr "硬连接失败，使用符号连接"

#: timezone/zic.c:690
#, c-format
msgid "%s: Can't link from %s to %s: %s\n"
msgstr "%s：无法从 %s 连接到 %s：%s\n"

#: timezone/zic.c:762 timezone/zic.c:764
msgid "same rule name in multiple files"
msgstr "多个文件中的相同规则名"

#: timezone/zic.c:805
msgid "unruly zone"
msgstr ""

#: timezone/zic.c:812
#, c-format
msgid "%s in ruleless zone"
msgstr ""

#: timezone/zic.c:833
msgid "standard input"
msgstr "标准输入"

#: timezone/zic.c:838
#, c-format
msgid "%s: Can't open %s: %s\n"
msgstr "%s：无法打开 %s：%s\n"

#: timezone/zic.c:849
msgid "line too long"
msgstr "行过长"

#: timezone/zic.c:869
msgid "input line of unknown type"
msgstr "未知类型的输入行"

#: timezone/zic.c:885
#, c-format
msgid "%s: Leap line in non leap seconds file %s\n"
msgstr ""

#: timezone/zic.c:892 timezone/zic.c:1329 timezone/zic.c:1351
#, c-format
msgid "%s: panic: Invalid l_value %d\n"
msgstr ""

#: timezone/zic.c:900
#, c-format
msgid "%s: Error reading %s\n"
msgstr "%s：读 %s 错误\n"

#: timezone/zic.c:907
#, c-format
msgid "%s: Error closing %s: %s\n"
msgstr "%s：关闭 %s 错误：%s\n"

#: timezone/zic.c:912
msgid "expected continuation line not found"
msgstr "找不到应该出现的续行"

#: timezone/zic.c:956 timezone/zic.c:2489 timezone/zic.c:2508
msgid "time overflow"
msgstr "时间溢出"

#: timezone/zic.c:960
msgid "24:00 not handled by pre-1998 versions of zic"
msgstr ""

#: timezone/zic.c:963
msgid "values over 24 hours not handled by pre-2007 versions of zic"
msgstr ""

#: timezone/zic.c:976
msgid "wrong number of fields on Rule line"
msgstr "规则行中域的个数错误"

#: timezone/zic.c:980
msgid "nameless rule"
msgstr "无名规则"

#: timezone/zic.c:985
msgid "invalid saved time"
msgstr ""

#: timezone/zic.c:1006
msgid "wrong number of fields on Zone line"
msgstr "区域行中域的个数错误"

#: timezone/zic.c:1012
#, c-format
msgid "\"Zone %s\" line and -l option are mutually exclusive"
msgstr ""

#: timezone/zic.c:1020
#, c-format
msgid "\"Zone %s\" line and -p option are mutually exclusive"
msgstr ""

#: timezone/zic.c:1032
#, c-format
msgid "duplicate zone name %s (file \"%s\", line %d)"
msgstr "重复的区域名 %s (文件“%s”，行 %d)"

#: timezone/zic.c:1048
msgid "wrong number of fields on Zone continuation line"
msgstr ""

#: timezone/zic.c:1088
msgid "invalid UTC offset"
msgstr "无效的 UTC 偏移量"

#: timezone/zic.c:1091
msgid "invalid abbreviation format"
msgstr "无效的缩略格式"

#: timezone/zic.c:1120
msgid "Zone continuation line end time is not after end time of previous line"
msgstr ""

#: timezone/zic.c:1148
msgid "wrong number of fields on Leap line"
msgstr ""

#: timezone/zic.c:1157
msgid "invalid leaping year"
msgstr "无效的闰年"

#: timezone/zic.c:1177 timezone/zic.c:1283
msgid "invalid month name"
msgstr "无效的月名称"

#: timezone/zic.c:1190 timezone/zic.c:1396 timezone/zic.c:1410
msgid "invalid day of month"
msgstr "无效的日"

#: timezone/zic.c:1195
msgid "time before zero"
msgstr ""

#: timezone/zic.c:1199
msgid "time too small"
msgstr ""

#: timezone/zic.c:1203
msgid "time too large"
msgstr "时间过大"

#: timezone/zic.c:1207 timezone/zic.c:1312
msgid "invalid time of day"
msgstr "无效的时间"

#: timezone/zic.c:1226
msgid "illegal CORRECTION field on Leap line"
msgstr ""

#: timezone/zic.c:1231
msgid "illegal Rolling/Stationary field on Leap line"
msgstr ""

#: timezone/zic.c:1247
msgid "wrong number of fields on Link line"
msgstr "连接行中域的个数错误"

#: timezone/zic.c:1251
msgid "blank FROM field on Link line"
msgstr "Link 行中空白的 FROM 域"

#: timezone/zic.c:1255
msgid "blank TO field on Link line"
msgstr "Link 行中空白的 TO 域"

#: timezone/zic.c:1333
msgid "invalid starting year"
msgstr "无效的起始年份"

#: timezone/zic.c:1355
msgid "invalid ending year"
msgstr "无效的终止年份"

#: timezone/zic.c:1359
msgid "starting year greater than ending year"
msgstr "起始年份大于终止年份"

#: timezone/zic.c:1366
msgid "typed single year"
msgstr ""

#: timezone/zic.c:1401
msgid "invalid weekday name"
msgstr "无效的星期名"

#: timezone/zic.c:1579
#, c-format
msgid "%s: Can't remove %s: %s\n"
msgstr "%s：无法删除 %s：%s\n"

#: timezone/zic.c:1589
#, c-format
msgid "%s: Can't create %s: %s\n"
msgstr "%s：无法创建 %s：%s\n"

#: timezone/zic.c:1739
#, c-format
msgid "%s: Error writing %s\n"
msgstr "%s：写 %s 错误\n"

#: timezone/zic.c:2031
msgid "no POSIX environment variable for zone"
msgstr ""

#: timezone/zic.c:2185
msgid "can't determine time zone abbreviation to use just after until time"
msgstr ""

#: timezone/zic.c:2231
msgid "too many transitions?!"
msgstr ""

#: timezone/zic.c:2250
msgid "internal error - addtype called with bad isdst"
msgstr "内部错误 - 以错误的 isdst 调用 addtype"

#: timezone/zic.c:2254
msgid "internal error - addtype called with bad ttisstd"
msgstr "内部错误 - 以错误的 ttisstd 调用 addtype"

#: timezone/zic.c:2258
msgid "internal error - addtype called with bad ttisgmt"
msgstr "内部错误 - 以错误的 ttisgmt 调用 addtype"

#: timezone/zic.c:2277
msgid "too many local time types"
msgstr "过多的本地时间类型"

#: timezone/zic.c:2281
msgid "UTC offset out of range"
msgstr "UTC 偏移值超出范围"

#: timezone/zic.c:2309
msgid "too many leap seconds"
msgstr ""

#: timezone/zic.c:2315
msgid "repeated leap second moment"
msgstr ""

#: timezone/zic.c:2367
msgid "Wild result from command execution"
msgstr ""

#: timezone/zic.c:2368
#, c-format
msgid "%s: command was '%s', result was %d\n"
msgstr "%s：命令为“%s”，结果为 %d\n"

#: timezone/zic.c:2466
msgid "Odd number of quotation marks"
msgstr "奇数个引号"

#: timezone/zic.c:2555
msgid "use of 2/29 in non leap-year"
msgstr ""

#: timezone/zic.c:2590
msgid "rule goes past start/end of month--will not work with pre-2004 versions of zic"
msgstr ""

#: timezone/zic.c:2622
msgid "time zone abbreviation lacks alphabetic at start"
msgstr ""

#: timezone/zic.c:2624
msgid "time zone abbreviation has more than 3 alphabetics"
msgstr ""

#: timezone/zic.c:2626
msgid "time zone abbreviation has too many alphabetics"
msgstr ""

#: timezone/zic.c:2636
msgid "time zone abbreviation differs from POSIX standard"
msgstr ""

#: timezone/zic.c:2648
msgid "too many, or too long, time zone abbreviations"
msgstr "过多或过长的时区缩写"

#: timezone/zic.c:2689
#, c-format
msgid "%s: Can't create directory %s: %s\n"
msgstr "%s：无法创建目录 %s：%s\n"

#: timezone/zic.c:2711
#, c-format
msgid "%s: %d did not sign extend correctly\n"
msgstr ""

#~ msgid "Can't remove old temporary cache file %s"
#~ msgstr "无法删除旧临时缓冲文件 %s"

#~ msgid "Report bugs using the `glibcbug' script to <bugs@gnu.org>.\n"
#~ msgstr "用“glibcbug”脚本将错误报告给 <bugs@gnu.org>。\n"

#~ msgid "<%s> and <%s> are illegal names for range"
#~ msgstr "<%s> 和 <%s> 是非法的范围名"

#~ msgid "upper limit in range is not higher then lower limit"
#~ msgstr "范围的上限并不高于下限"

#~ msgid "%s: value for field `%s' must not be the empty string"
#~ msgstr "%s：域“%s”的值不能是空字符串"

#~ msgid "%s: values of field `%s' must not be larger than %d"
#~ msgstr "%s：域“%s”的值不能大于 %d"

#~ msgid "Get locale-specific information."
#~ msgstr "给出区域特定的信息。"

#~ msgid "cheese"
#~ msgstr "奶酪"

#~ msgid "First string for testing."
#~ msgstr "第一个用于测试的字符串。"

#~ msgid "Another string for testing."
#~ msgstr "另一个测试字符串。"

#~ msgid "Error 0"
#~ msgstr "错误 0"

#~ msgid "I/O error"
#~ msgstr "I/O 错误"

#~ msgid "Arg list too long"
#~ msgstr "参数列表过长"

#~ msgid "Bad file number"
#~ msgstr "错误的文件编号"

#~ msgid "Not enough space"
#~ msgstr "空间不够"

#~ msgid "Device busy"
#~ msgstr "设备忙"

#~ msgid "Cross-device link"
#~ msgstr "跨设备连接"

#~ msgid "File table overflow"
#~ msgstr "文件表溢出"

#~ msgid "Result too large"
#~ msgstr "结果太大"

#~ msgid "Deadlock situation detected/avoided"
#~ msgstr "探测到/已避免死锁"

#~ msgid "No record locks available"
#~ msgstr "没有可用的记录锁"

#~ msgid "Disc quota exceeded"
#~ msgstr "超出磁盘限额"

#~ msgid "Bad exchange descriptor"
#~ msgstr "错误的交换描述符"

#~ msgid "Bad request descriptor"
#~ msgstr "错误的请求描述符"

#~ msgid "Message tables full"
#~ msgstr "内存表已满"

#~ msgid "Anode table overflow"
#~ msgstr "Anode 表溢出"

#~ msgid "Bad request code"
#~ msgstr "错误的请求码"

#~ msgid "File locking deadlock"
#~ msgstr "文件锁死锁"

#~ msgid "Error 58"
#~ msgstr "错误 58"

#~ msgid "Error 59"
#~ msgstr "错误 59"

#~ msgid "Not a stream device"
#~ msgstr "不是流设备"

#~ msgid "Out of stream resources"
#~ msgstr "流资源不足"

#~ msgid "Error 72"
#~ msgstr "错误 72"

#~ msgid "Error 73"
#~ msgstr "错误 73"

#~ msgid "Error 75"
#~ msgstr "错误 75"

#~ msgid "Error 76"
#~ msgstr "错误 76"

#~ msgid "Not a data message"
#~ msgstr "不是数据消息"

#~ msgid "Attempting to link in more shared libraries than system limit"
#~ msgstr "试图连接的共享库个数超出系统限制"

#~ msgid "Can not exec a shared library directly"
#~ msgstr "无法直接执行共享库"

#~ msgid "Illegal byte sequence"
#~ msgstr "非法的字节序"

#~ msgid "Operation not applicable"
#~ msgstr "不可应用的操作"

#~ msgid "Number of symbolic links encountered during path name traversal exceeds MAXSYMLINKS"
#~ msgstr "路径遍历中遇到的符号连接的数量超过了 MAXSYMLINKS"

#~ msgid "Error 91"
#~ msgstr "错误 91"

#~ msgid "Error 92"
#~ msgstr "错误 92"

#~ msgid "Option not supported by protocol"
#~ msgstr "协议不支持的选项"

#~ msgid "Error 100"
#~ msgstr "错误 100"

#~ msgid "Error 101"
#~ msgstr "错误 101"

#~ msgid "Error 102"
#~ msgstr "错误 102"

#~ msgid "Error 103"
#~ msgstr "错误 103"

#~ msgid "Error 104"
#~ msgstr "错误 104"

#~ msgid "Error 105"
#~ msgstr "错误 105"

#~ msgid "Error 106"
#~ msgstr "错误 106"

#~ msgid "Error 107"
#~ msgstr "错误 107"

#~ msgid "Error 108"
#~ msgstr "错误 108"

#~ msgid "Error 109"
#~ msgstr "错误 109"

#~ msgid "Error 110"
#~ msgstr "错误 110"

#~ msgid "Error 111"
#~ msgstr "错误 111"

#~ msgid "Error 112"
#~ msgstr "错误 112"

#~ msgid "Error 113"
#~ msgstr "错误 113"

#~ msgid "Error 114"
#~ msgstr "错误 114"

#~ msgid "Error 115"
#~ msgstr "错误 115"

#~ msgid "Error 116"
#~ msgstr "错误 116"

#~ msgid "Error 117"
#~ msgstr "错误 117"

#~ msgid "Error 118"
#~ msgstr "错误 118"

#~ msgid "Error 119"
#~ msgstr "错误 119"

#~ msgid "Operation not supported on transport endpoint"
#~ msgstr "传输端点不支持的操作"

#~ msgid "Address family not supported by protocol family"
#~ msgstr "协议族不支持的地址族"

#~ msgid "Network dropped connection because of reset"
#~ msgstr "因为重置而断开网络连接"

#~ msgid "Error 136"
#~ msgstr "错误 136"

#~ msgid "Not available"
#~ msgstr "不可用"

#~ msgid "Is a name file"
#~ msgstr "是一个有名文件"

#~ msgid "Reserved for future use"
#~ msgstr "保留用于未来"

#~ msgid "Error 142"
#~ msgstr "错误 142"

#~ msgid "Cannot send after socket shutdown"
#~ msgstr "无法在套接字关闭后发送"

#~ msgid "%s: Can't unlink  %s: %s\n"
#~ msgstr "%s：无法解除连接 %s：%s\n"

#~ msgid "%s: line %d: expected service, found `%s'\n"
#~ msgstr "%s：行 %d：应为 service，得到“%s”\n"

#~ msgid "%s: line %d: cannot specify more than %d services"
#~ msgstr "%s：行 %d：无法指定多于 %d 个服务"

#~ msgid "%s: line %d: list delimiter not followed by keyword"
#~ msgstr "%s：行 %d：列表分隔符没有出现在关键字之后"

#~ msgid "getent - get entries from administrative database."
#~ msgstr "getent - 重管理数据库获取条目。"

#~ msgid "get_myaddress: ioctl (get interface configuration)"
#~ msgstr "get_myaddress：ioctl (获取界面配置)"

#~ msgid "__get_myaddress: ioctl (get interface configuration)"
#~ msgstr "__get_myaddress：ioctl (获取界面配置)"

#~ msgid "broadcast: ioctl (get interface configuration)"
#~ msgstr "broadcast：ioctl (获取界面配置)"

#~ msgid "broadcast: ioctl (get interface flags)"
#~ msgstr "broadcast：ioctl (获取界面标志)"

#~ msgid "YPBINDPROC_DOMAIN: %s\n"
#~ msgstr "YPBINDPROC_DOMAIN：%s\n"

#~ msgid "while allocating hash table entry"
#~ msgstr "分配杂凑表条目时"

#~ msgid "while allocating cache: %s"
#~ msgstr "分配缓冲区时：%s"

#~ msgid "while accepting connection: %s"
#~ msgstr "接受连接时：%s"

#~ msgid "while allocating key copy"
#~ msgstr "分配键副本时"

#~ msgid "while allocating cache entry"
#~ msgstr "分配缓冲区条目时"

#~ msgid "Haven't found \"%d\" in group cache!"
#~ msgstr "无法在组缓冲区中找到“%d”！"

#~ msgid "      no"
#~ msgstr "      否"

#~ msgid "     yes"
#~ msgstr "     是"

#~ msgid "Haven't found \"%d\" in password cache!"
#~ msgstr "无法在口令缓冲区中找到“%d”！"

#~ msgid "shared object cannot be dlopen()ed: static TLS memory too small"
#~ msgstr "无法用 dlopen() 打开共享对象：静态 TLS 内存过小"

#~ msgid "Can't lstat %s"
#~ msgstr "无法对 %s 进行 lstat 操作"

#~ msgid "\t\t\t\t\t\t\t      %s: value for field `%s' must be in range %d...%d"
#~ msgstr "\t\t\t\t\t\t\t      %s：域“%s”的值必须处于范围 %d...%d 之内"
