# Traditional Chinese Messages for libc.
# Copyright (C) 2011 Free Software Foundation, Inc.
# This file is distributed under the same license as the glibc package.
# Tung-Han Hsieh <thhsieh@linux.org.tw>, 2000.
# Yuan-Chung Cheng <platin@ch.ntu.edu.tw>, 2000.
# Wei-Lun Chao <william.chao@ossii.com.tw>, 2005, 2008, 2011.
# Wei-Lun Chao <bluebat@member.fsf.org>, 2012, 2013.
#
msgid ""
msgstr ""
"Project-Id-Version: libc 2.17.90.20130724\n"
"POT-Creation-Date: 2013-07-24 23:29-0700\n"
"PO-Revision-Date: 2013-09-03 13:39+0800\n"
"Last-Translator: Wei-Lun Chao <bluebat@member.fsf.org>\n"
"Language-Team: Chinese (traditional) <zh-l10n@linux.org.tw>\n"
"Language: zh_TW\n"
"X-Bugs: Report translation errors to the Language-Team address.\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: argp/argp-help.c:227
#, c-format
msgid "%.*s: ARGP_HELP_FMT parameter requires a value"
msgstr "%.*s: ARGP_HELP_FMT 參數需要一個值"

#: argp/argp-help.c:237
#, c-format
msgid "%.*s: Unknown ARGP_HELP_FMT parameter"
msgstr "%.*s: 未知的 ARGP_HELP_FMT 參數"

#: argp/argp-help.c:250
#, c-format
msgid "Garbage in ARGP_HELP_FMT: %s"
msgstr "ARGP_HELP_FMT 中無用的資訊: %s"

#: argp/argp-help.c:1214
msgid "Mandatory or optional arguments to long options are also mandatory or optional for any corresponding short options."
msgstr "長選項的必須或可選用的引數也是相對應短選項的必須或可選用的引數。"

#: argp/argp-help.c:1600
msgid "Usage:"
msgstr "使用方式:"

#: argp/argp-help.c:1604
msgid "  or: "
msgstr "  或者: "

#: argp/argp-help.c:1616
msgid " [OPTION...]"
msgstr " [參數…]"

#: argp/argp-help.c:1643
#, c-format
msgid "Try `%s --help' or `%s --usage' for more information.\n"
msgstr "請試著用 `%s --help' 或 `%s --usage' 來獲得更多相關訊息。\n"

#: argp/argp-help.c:1671
#, c-format
msgid "Report bugs to %s.\n"
msgstr "請將程式問題回報至 %s。\n"

#: argp/argp-parse.c:101
msgid "Give this help list"
msgstr "給出這個使用方式列表"

#: argp/argp-parse.c:102
msgid "Give a short usage message"
msgstr "給出簡短的使用訊息"

#: argp/argp-parse.c:103 catgets/gencat.c:109 catgets/gencat.c:113
#: iconv/iconv_prog.c:60 iconv/iconv_prog.c:61 nscd/nscd.c:115
#: nss/makedb.c:120
msgid "NAME"
msgstr "名稱"

#: argp/argp-parse.c:104
msgid "Set the program name"
msgstr "設定程式名稱"

#: argp/argp-parse.c:105
msgid "SECS"
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:35
#, c-format
msgid "%s%s%s:%u: %s%sUnexpected error: %s.\n"
msgstr "%s%s%s:%u: %s%s無法預料的錯誤: %s。\n"

#: assert/assert.c:101
#, c-format
msgid ""
"%s%s%s:%u: %s%sAssertion `%s' failed.\n"
"%n"
msgstr ""
"%s%s%s:%u：%s%s假設『%s』失敗。\n"
"%n"

#: catgets/gencat.c:110
msgid "Create C header file NAME containing symbol definitions"
msgstr "產生的 C 標頭檔名內含符號定義"

#: catgets/gencat.c:112
msgid "Do not use existing catalog, force new output file"
msgstr "不使用現存的 catalog, 強制使用新的輸出檔"

#: catgets/gencat.c:113 nss/makedb.c:120
msgid "Write output to file NAME"
msgstr "將輸出寫到檔案 NAME 中"

#: catgets/gencat.c:118
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 ""
"產生訊息 catelog。\\v如果輸入檔名是 -, 將從標準輸入讀取輸入。\n"
"如果輸出檔名是 -, 則輸出將寫到標準輸出去。\n"

#: catgets/gencat.c:123
msgid ""
"-o OUTPUT-FILE [INPUT-FILE]...\n"
"[OUTPUT-FILE [INPUT-FILE]...]"
msgstr ""
"-o 輸出檔案名稱 [輸入檔案名稱]...\n"
"[輸出檔案名稱 [輸入檔案名稱]...]"

#: catgets/gencat.c:229 debug/pcprofiledump.c:209 elf/ldconfig.c:307
#: elf/pldd.c:219 elf/sln.c:85 elf/sprof.c:372 iconv/iconv_prog.c:408
#: iconv/iconvconfig.c:379 locale/programs/locale.c:277
#: locale/programs/localedef.c:364 login/programs/pt_chown.c:88
#: malloc/memusagestat.c:563 nscd/nscd.c:450 nss/getent.c:965 nss/makedb.c:369
#: posix/getconf.c:1121 sunrpc/rpcinfo.c:691
#: sysdeps/unix/sysv/linux/lddlibc4.c:61
#, c-format
msgid ""
"For bug reporting instructions, please see:\n"
"%s.\n"
msgstr ""
"要知道錯誤報告指令，請參看：\n"
"%s。\n"

#: catgets/gencat.c:245 debug/pcprofiledump.c:225 debug/xtrace.sh:64
#: elf/ldconfig.c:323 elf/ldd.bash.in:38 elf/pldd.c:235 elf/sotruss.ksh:75
#: elf/sprof.c:389 iconv/iconv_prog.c:425 iconv/iconvconfig.c:396
#: locale/programs/locale.c:294 locale/programs/localedef.c:390
#: login/programs/pt_chown.c:62 malloc/memusage.sh:71
#: malloc/memusagestat.c:579 nscd/nscd.c:466 nss/getent.c:86 nss/makedb.c:385
#: posix/getconf.c:1103 sysdeps/unix/sysv/linux/lddlibc4.c:68
#, 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 ""
"版權所有 (C) %s 自由軟體基金會。\n"
"這是一個自由軟體；請見原始碼的授權條款。這沒有擔保；甚至也沒有專為銷\n"
"售或者適合某些特殊目的。\n"

#: catgets/gencat.c:250 debug/pcprofiledump.c:230 debug/xtrace.sh:68
#: elf/ldconfig.c:328 elf/pldd.c:240 elf/sprof.c:395 iconv/iconv_prog.c:430
#: iconv/iconvconfig.c:401 locale/programs/locale.c:299
#: locale/programs/localedef.c:395 malloc/memusage.sh:75
#: malloc/memusagestat.c:584 nscd/nscd.c:471 nss/getent.c:91 nss/makedb.c:390
#: posix/getconf.c:1108
#, c-format
msgid "Written by %s.\n"
msgstr "作者 %s。\n"

#: catgets/gencat.c:281
msgid "*standard input*"
msgstr "*標準輸入*"

#: catgets/gencat.c:287 iconv/iconv_charmap.c:167 iconv/iconv_prog.c:293
#: nss/makedb.c:246
#, c-format
msgid "cannot open input file `%s'"
msgstr "無法開啟輸入檔 `%s'"

#: catgets/gencat.c:416 catgets/gencat.c:491
msgid "illegal set number"
msgstr "不合法的集合編號"

#: catgets/gencat.c:443
msgid "duplicate set definition"
msgstr "複製集合定義"

#: catgets/gencat.c:445 catgets/gencat.c:617 catgets/gencat.c:669
msgid "this is the first definition"
msgstr "此為第一個定義"

#: catgets/gencat.c:516
#, c-format
msgid "unknown set `%s'"
msgstr "不明的集合 `%s'"

#: catgets/gencat.c:557
msgid "invalid quote character"
msgstr "不適用的引用字元"

#: catgets/gencat.c:570
#, c-format
msgid "unknown directive `%s': line ignored"
msgstr "不明的指令 `%s': 此列忽略"

#: catgets/gencat.c:615
msgid "duplicated message number"
msgstr "重複的訊息編號"

#: catgets/gencat.c:666
msgid "duplicated message identifier"
msgstr "重複的訊息識別符號"

#: catgets/gencat.c:723
msgid "invalid character: message ignored"
msgstr "不適用的字元: 忽略此訊息"

#: catgets/gencat.c:766
msgid "invalid line"
msgstr "無效的輸入列"

#: catgets/gencat.c:820
msgid "malformed line ignored"
msgstr "忽略奇怪的列"

#: catgets/gencat.c:984 catgets/gencat.c:1025
#, c-format
msgid "cannot open output file `%s'"
msgstr "無法開啟輸出檔 `%s'"

#: catgets/gencat.c:1187 locale/programs/linereader.c:560
msgid "invalid escape sequence"
msgstr "無效的跳脫序列"

#: catgets/gencat.c:1209
msgid "unterminated message"
msgstr "沒有結尾的訊息"

#: catgets/gencat.c:1233
#, c-format
msgid "while opening old catalog file"
msgstr "在開啟舊的類別檔案時"

#: catgets/gencat.c:1324
#, c-format
msgid "conversion modules not available"
msgstr "轉換模組不存在"

#: catgets/gencat.c:1350
#, 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 "將產生於 PC 測速評估的資料傾卸出來"

#: debug/pcprofiledump.c:61
msgid "[FILE]"
msgstr "[檔案]"

#: debug/pcprofiledump.c:108
#, c-format
msgid "cannot open input file"
msgstr "無法開啟輸入檔"

#: debug/pcprofiledump.c:115
#, c-format
msgid "cannot read header"
msgstr "無法讀取標頭資料"

#: debug/pcprofiledump.c:179
#, c-format
msgid "invalid pointer size"
msgstr "無效的指標大小"

#: debug/xtrace.sh:26 debug/xtrace.sh:44
msgid "Usage: xtrace [OPTION]... PROGRAM [PROGRAMOPTION]...\\n"
msgstr "用法：xtrace [選項]… 程式 [PROGRAMOPTION]…\\n"

#: debug/xtrace.sh:32 elf/sotruss.ksh:56 elf/sotruss.ksh:67
#: elf/sotruss.ksh:135 malloc/memusage.sh:26
msgid "Try \\`%s --help' or \\`%s --usage' for more information.\\n"
msgstr "請嘗試 \\『%s --help』或\\『%s --usage』以獲得更多資訊。\\n"

#: debug/xtrace.sh:38
msgid "%s: option '%s' requires an argument.\\n"
msgstr "%s：選項『%s』需要一個引數.\\n"

#: debug/xtrace.sh:45
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"
msgstr ""
"經由列印目前執行的函式來追蹤程式的執行。\n"
"\n"
"     --data=檔案          無法運行程式，僅從檔案印出資料。\n"
"\n"
"   -?,--help              列印這份說明然後離開\n"
"      --usage             給出簡短用法訊息\n"
"   -V,--version           印出版本資訊然後離開\n"
"\n"
"對於長選項必要的引數同樣必要於任何相應的\n"
"短選項。\n"
"\n"

#: debug/xtrace.sh:57 elf/ldd.bash.in:55 elf/sotruss.ksh:49
#: malloc/memusage.sh:64
msgid "For bug reporting instructions, please see:\\\\n%s.\\\\n"
msgstr "要知道錯誤報告指令，請參看:\\\\n%s.\\\\n"

#: 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 "未給定程式名稱\\n"

#: debug/xtrace.sh:146
#, sh-format
msgid "executable \\`$program' not found\\n"
msgstr "可執行檔案「$program」找不到\\n"

#: debug/xtrace.sh:150
#, sh-format
msgid "\\`$program' is no executable\\n"
msgstr "「$program」不是可執行檔案\\n"

#: dlfcn/dlinfo.c:63
msgid "RTLD_SELF used in code not dynamically loaded"
msgstr "程式碼所使用的 RTLD_SELF 沒有動態載入"

#: dlfcn/dlinfo.c:72
msgid "unsupported dlinfo request"
msgstr "未支援的 dlinfo 請求"

#: dlfcn/dlmopen.c:63
msgid "invalid namespace"
msgstr "無效的命名空間"

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

#: dlfcn/dlopen.c:64
msgid "invalid mode parameter"
msgstr "無效的模式參數"

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

#: elf/cache.c:126
msgid "Unknown OS"
msgstr "未知的作業系統"

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

#: elf/cache.c:148 elf/ldconfig.c:1318
#, c-format
msgid "Can't open cache file %s\n"
msgstr "無法開啟快取檔 %s\n"

#: elf/cache.c:162
#, c-format
msgid "mmap of cache file failed.\n"
msgstr "快取檔案 mmap 失敗。\n"

#: elf/cache.c:166 elf/cache.c:180
#, c-format
msgid "File is not a cache file.\n"
msgstr "檔案並非快取檔。\n"

#: elf/cache.c:213 elf/cache.c:223
#, c-format
msgid "%d libs found in cache `%s'\n"
msgstr "%d 函式庫在快取 `%s' 中找到\n"

#: elf/cache.c:417
#, c-format
msgid "Can't create temporary cache file %s"
msgstr "無法產生暫時的快取檔 %s"

#: elf/cache.c:425 elf/cache.c:435 elf/cache.c:439 elf/cache.c:444
#, c-format
msgid "Writing of cache data failed"
msgstr "寫入快取資料時發生錯誤"

#: elf/cache.c:449
#, c-format
msgid "Changing access rights of %s to %#o failed"
msgstr "更改 %s 的存取權限為 %#o 失敗"

#: elf/cache.c:454
#, c-format
msgid "Renaming of %s to %s failed"
msgstr "將 %s 改名為 %s 失敗"

#: elf/dl-close.c:384 elf/dl-open.c:470
msgid "cannot create scope list"
msgstr "無法建立作用域列表"

#: elf/dl-close.c:777
msgid "shared object not open"
msgstr "共用目的檔案沒有開啟"

#: elf/dl-deps.c:112
msgid "DST not allowed in SUID/SGID programs"
msgstr "DST 不允許在 SUID/SGID 的程式中"

#: elf/dl-deps.c:125
msgid "empty dynamic string token substitution"
msgstr "空的動態字串字組替換"

#: elf/dl-deps.c:131
#, c-format
msgid "cannot load auxiliary `%s' because of empty dynamic string token substitution\n"
msgstr "由於空的動態字串字組替換而無法載入外部的 `%s'\n"

#: elf/dl-deps.c:479
msgid "cannot allocate dependency list"
msgstr "無法配置相關性列表"

#: elf/dl-deps.c:516 elf/dl-deps.c:576
msgid "cannot allocate symbol search list"
msgstr "無法配置符號搜尋列表"

#: elf/dl-deps.c:556
msgid "Filters not supported with LD_TRACE_PRELINKING"
msgstr "過濾程式不支援與 LD_TRACE_PRELINKING 共用"

#: elf/dl-error.c:76
msgid "DYNAMIC LINKER BUG!!!"
msgstr "動態連接程式有問題!!!"

#: elf/dl-error.c:123
msgid "error while loading shared libraries"
msgstr "載入共用函式庫時發生錯誤"

#: elf/dl-fptr.c:87 ports/sysdeps/hppa/dl-fptr.c:93
msgid "cannot map pages for fdesc table"
msgstr "無法將頁面對映於 fdesc 表格"

#: elf/dl-fptr.c:191 ports/sysdeps/hppa/dl-fptr.c:206
msgid "cannot map pages for fptr table"
msgstr "無法將頁面對映於 fptr 表格"

#: elf/dl-fptr.c:220 ports/sysdeps/hppa/dl-fptr.c:235
msgid "internal error: symidx out of range of fptr table"
msgstr "內部錯誤：symidx 超出 fptr 表格的範圍"

#: elf/dl-hwcaps.c:184 elf/dl-hwcaps.c:196
msgid "cannot create capability list"
msgstr "無法建立 capability 列表"

#: elf/dl-load.c:465
msgid "cannot allocate name record"
msgstr "無法配置名稱紀錄"

#: elf/dl-load.c:542 elf/dl-load.c:658 elf/dl-load.c:743 elf/dl-load.c:862
msgid "cannot create cache for search path"
msgstr "無法為搜尋路徑建立快取"

#: elf/dl-load.c:633
msgid "cannot create RUNPATH/RPATH copy"
msgstr "無法建立 RUNPATH/RPATH 的副本"

#: elf/dl-load.c:729
msgid "cannot create search path array"
msgstr "無法建立搜尋路徑陣列"

#: elf/dl-load.c:934
msgid "cannot stat shared object"
msgstr "無法 stat 共用目的檔"

#: elf/dl-load.c:1012
msgid "cannot open zero fill device"
msgstr "無法開啟以零填滿的裝置"

#: elf/dl-load.c:1059 elf/dl-load.c:2342
msgid "cannot create shared object descriptor"
msgstr "無法建立共用目的檔敘述項"

#: elf/dl-load.c:1078 elf/dl-load.c:1755 elf/dl-load.c:1858
msgid "cannot read file data"
msgstr "無法讀取檔案資料"

#: elf/dl-load.c:1124
msgid "ELF load command alignment not page-aligned"
msgstr "ELF 載入命令對齊並沒有按照記憶體分頁 (page) 對齊"

#: elf/dl-load.c:1131
msgid "ELF load command address/offset not properly aligned"
msgstr "ELF 載入命令位址/位移並沒有適當地對齊"

#: elf/dl-load.c:1216
msgid "cannot allocate TLS data structures for initial thread"
msgstr "無法配置 TLS 資料結構用以起始執行緒"

#: elf/dl-load.c:1239
msgid "cannot handle TLS data"
msgstr "無法處理 TLS 資料"

#: elf/dl-load.c:1258
msgid "object file has no loadable segments"
msgstr "目的檔中沒有可載入的區段"

#: elf/dl-load.c:1294
msgid "failed to map segment from shared object"
msgstr "從共用目的檔中對映區段失敗"

#: elf/dl-load.c:1320
msgid "cannot dynamically load executable"
msgstr "無法動態載入執行檔"

#: elf/dl-load.c:1383 elf/dl-load.c:1492
msgid "cannot change memory protections"
msgstr "無法改變記憶體保護狀態"

#: elf/dl-load.c:1402
msgid "cannot map zero-fill pages"
msgstr "無法對應以零填滿的分頁區"

#: elf/dl-load.c:1416
msgid "object file has no dynamic section"
msgstr "共用目的檔中沒有動態區段"

#: elf/dl-load.c:1439
msgid "shared object cannot be dlopen()ed"
msgstr "共用目的檔無法被 dlopen()"

#: elf/dl-load.c:1452
msgid "cannot allocate memory for program header"
msgstr "無法配置記憶體給程式標頭區使用"

#: elf/dl-load.c:1469 elf/dl-open.c:195
msgid "invalid caller"
msgstr "無效的呼叫者"

#: elf/dl-load.c:1512
msgid "cannot enable executable stack as shared object requires"
msgstr "無法開啟可執行堆疊做為共用目的檔"

#: elf/dl-load.c:1525
msgid "cannot close file descriptor"
msgstr "無法關閉檔案描述符號"

#: elf/dl-load.c:1755
msgid "file too short"
msgstr "檔案太小"

#: elf/dl-load.c:1791
msgid "invalid ELF header"
msgstr "無效的 ELF 標頭"

#: elf/dl-load.c:1803
msgid "ELF file data encoding not big-endian"
msgstr "ELF 檔資料編碼並非大尾序"

#: elf/dl-load.c:1805
msgid "ELF file data encoding not little-endian"
msgstr "ELF 檔資料編碼並非小尾序"

#: elf/dl-load.c:1809
msgid "ELF file version ident does not match current one"
msgstr "ELF 檔版本 ident 不符合目前所使用的"

#: elf/dl-load.c:1813
msgid "ELF file OS ABI invalid"
msgstr "ELF 檔 OS ABI 版本不適用"

#: elf/dl-load.c:1816
msgid "ELF file ABI version invalid"
msgstr "ELF 檔 ABI 版本不適用"

#: elf/dl-load.c:1819
msgid "nonzero padding in e_ident"
msgstr "在 e_ident 中填補非零值"

#: elf/dl-load.c:1822
msgid "internal error"
msgstr "內部錯誤"

#: elf/dl-load.c:1829
msgid "ELF file version does not match current one"
msgstr "ELF 檔版本不符合目前的版本"

#: elf/dl-load.c:1837
msgid "only ET_DYN and ET_EXEC can be loaded"
msgstr "只有 ET_DYN 以及 ET_EXEC 可以載入"

#: elf/dl-load.c:1843
msgid "ELF file's phentsize not the expected size"
msgstr "ELF 檔的 phentsize 並不是預期中的大小"

#: elf/dl-load.c:2361
msgid "wrong ELF class: ELFCLASS64"
msgstr "錯誤 ELF 類別：ELFCLASS64"

#: elf/dl-load.c:2362
msgid "wrong ELF class: ELFCLASS32"
msgstr "錯誤 ELF 類別：ELFCLASS32"

#: elf/dl-load.c:2365
msgid "cannot open shared object file"
msgstr "無法開啟共用目的檔"

#: elf/dl-lookup.c:753 ports/sysdeps/mips/dl-lookup.c:771
msgid "relocation error"
msgstr "重定址錯誤"

#: elf/dl-lookup.c:780 ports/sysdeps/mips/dl-lookup.c:798
msgid "symbol lookup error"
msgstr "符號查找錯誤"

#: elf/dl-open.c:102
msgid "cannot extend global scope"
msgstr "無法延展全域變數的作用域"

#: elf/dl-open.c:520
msgid "TLS generation counter wrapped!  Please report this."
msgstr "TLS 產生計數器被轉換執行！ 請報告這個情況。"

#: elf/dl-open.c:542
msgid "cannot load any more object with static TLS"
msgstr "無法以靜態 TLS 再載入任何物件"

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

#: elf/dl-open.c:616
msgid "no more namespaces available for dlmopen()"
msgstr "無更多命名空間可見於 dlmopen ()"

#: elf/dl-open.c:634
msgid "invalid target namespace in dlmopen()"
msgstr "dlmopen() 中的無效目標命名空間"

#: elf/dl-reloc.c:120
msgid "cannot allocate memory in static TLS block"
msgstr "無法在靜態 TLS 區塊中配置記憶體"

#: elf/dl-reloc.c:212
msgid "cannot make segment writable for relocation"
msgstr "在重新定址以後無法將區段設為可寫入狀態"

#: elf/dl-reloc.c:275
#, c-format
msgid "%s: no PLTREL found in object %s\n"
msgstr "%s: 在目的檔 %s 中沒有找到 PLTREL\n"

#: elf/dl-reloc.c:286
#, c-format
msgid "%s: out of memory to store relocation results for %s\n"
msgstr "%s: 記憶體不足以儲存重定址結果用於 %s\n"

#: elf/dl-reloc.c:302
msgid "cannot restore segment prot after reloc"
msgstr "在 reloc 之後無法復原 segment prot"

#: elf/dl-reloc.c:331
msgid "cannot apply additional memory protection after relocation"
msgstr "重定址之後無法套用額外記憶體保護"

#: elf/dl-sym.c:153
msgid "RTLD_NEXT used in code not dynamically loaded"
msgstr "程式碼所使用的 RTLD_NEXT 沒有動態載入"

#: elf/dl-tls.c:875
msgid "cannot create TLS data structures"
msgstr "無法建立 TLS 資料結構"

#: elf/dl-version.c:166
msgid "version lookup error"
msgstr "版本查找錯誤"

#: elf/dl-version.c:296
msgid "cannot allocate version reference table"
msgstr "無法配置版本參照表"

#: elf/ldconfig.c:141
msgid "Print cache"
msgstr "印出快取"

#: elf/ldconfig.c:142
msgid "Generate verbose messages"
msgstr "產生更多的訊息"

#: elf/ldconfig.c:143
msgid "Don't build cache"
msgstr "不建立快取"

#: elf/ldconfig.c:144
msgid "Don't generate links"
msgstr "不產生連結"

#: elf/ldconfig.c:145
msgid "Change to and use ROOT as root directory"
msgstr "變換到 ROOT 目錄並以它做為根目錄"

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

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

#: elf/ldconfig.c:146
msgid "Use CACHE as cache file"
msgstr "使用 CACHE 當作快取檔案"

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

#: elf/ldconfig.c:147
msgid "Use CONF as configuration file"
msgstr "使用 CONF 當作設定檔"

#: elf/ldconfig.c:148
msgid "Only process directories specified on the command line.  Don't build cache."
msgstr "只處理在命令列引數中有指定的目錄，不建立快取檔案。"

#: elf/ldconfig.c:149
msgid "Manually link individual libraries."
msgstr "手動個別連結函式庫"

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

#: elf/ldconfig.c:150
msgid "Format to use: new, old or compat (default)"
msgstr "將使用格式: 新、舊或相容 (預設)"

#: elf/ldconfig.c:151
msgid "Ignore auxiliary cache file"
msgstr "忽略輔助設備快取檔案"

#: elf/ldconfig.c:159
msgid "Configure Dynamic Linker Run Time Bindings."
msgstr "設定執行時期動態連接"

#: elf/ldconfig.c:346
#, c-format
msgid "Path `%s' given more than once"
msgstr "路徑 `%s' 使用超過一次"

#: elf/ldconfig.c:386
#, c-format
msgid "%s is not a known library type"
msgstr "%s 不是一個已知的函式庫型態"

#: elf/ldconfig.c:414
#, c-format
msgid "Can't stat %s"
msgstr "無法 stat %s"

#: elf/ldconfig.c:488
#, c-format
msgid "Can't stat %s\n"
msgstr "無法 stat %s\n"

#: elf/ldconfig.c:498
#, c-format
msgid "%s is not a symbolic link\n"
msgstr "%s 不是一個符號連接檔\n"

#: elf/ldconfig.c:517
#, c-format
msgid "Can't unlink %s"
msgstr "無法取消連結 %s"

#: elf/ldconfig.c:523
#, c-format
msgid "Can't link %s to %s"
msgstr "無法從 %s 連結到 %s"

#: elf/ldconfig.c:529
msgid " (changed)\n"
msgstr " (已改變)\n"

#: elf/ldconfig.c:531
msgid " (SKIPPED)\n"
msgstr " (已忽略)\n"

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

#: elf/ldconfig.c:602 elf/ldconfig.c:775 elf/ldconfig.c:834 elf/ldconfig.c:868
#, c-format
msgid "Cannot lstat %s"
msgstr "無法 lstat %s"

#: elf/ldconfig.c:609
#, c-format
msgid "Ignored file %s since it is not a regular file."
msgstr "忽略檔案 %s 因為它不是一個正常的檔案。"

#: elf/ldconfig.c:618
#, c-format
msgid "No link created since soname could not be found for %s"
msgstr "由於找不到 %s 的共用目的檔名稱，連結並未被建立"

#: elf/ldconfig.c:701
#, c-format
msgid "Can't open directory %s"
msgstr "無法開啟目錄 %s"

#: elf/ldconfig.c:793 elf/ldconfig.c:855 elf/readlib.c:90
#, c-format
msgid "Input file %s not found.\n"
msgstr "輸入檔 %s 找不到。\n"

#: elf/ldconfig.c:800
#, c-format
msgid "Cannot stat %s"
msgstr "無法顯示狀態 %s"

#: elf/ldconfig.c:929
#, c-format
msgid "libc5 library %s in wrong directory"
msgstr "libc5 函式庫 %s 擺錯目錄了"

#: elf/ldconfig.c:932
#, c-format
msgid "libc6 library %s in wrong directory"
msgstr "libc6 函式庫 %s 擺錯目錄了"

#: elf/ldconfig.c:935
#, c-format
msgid "libc4 library %s in wrong directory"
msgstr "libc4 函式庫 %s 擺錯目錄了"

#: elf/ldconfig.c:963
#, c-format
msgid "libraries %s and %s in directory %s have same soname but different type."
msgstr "函式庫 %s 跟 %s (在目錄 %s 底下) 有共同的共用函式庫名稱，不過其格式卻不同"

#: elf/ldconfig.c:1072
#, c-format
msgid "Warning: ignoring configuration file that cannot be opened: %s"
msgstr "警告：正在忽略無法開啟的組態檔案：%s"

#: elf/ldconfig.c:1138
#, c-format
msgid "%s:%u: bad syntax in hwcap line"
msgstr "%s:%u: 在 hwcap 列中有不當的語法"

#: elf/ldconfig.c:1144
#, c-format
msgid "%s:%u: hwcap index %lu above maximum %u"
msgstr "%s:%u: hwcap 索引 %lu 以上的最大值 %u"

#: elf/ldconfig.c:1151 elf/ldconfig.c:1159
#, c-format
msgid "%s:%u: hwcap index %lu already defined as %s"
msgstr "%s:%u: hwcap 索引 %lu 已經被定義為 %s"

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

#: elf/ldconfig.c:1184
#, c-format
msgid "need absolute file name for configuration file when using -r"
msgstr "需要絕對檔案名稱用於組態檔案時正在使用 -r"

#: elf/ldconfig.c:1191 locale/programs/xmalloc.c:64 malloc/obstack.c:432
#: malloc/obstack.c:434 posix/getconf.c:1076 posix/getconf.c:1296
#, c-format
msgid "memory exhausted"
msgstr "記憶體耗盡"

#: elf/ldconfig.c:1223
#, c-format
msgid "%s:%u: cannot read directory %s"
msgstr "%s:%u: 無法讀取目錄 %s"

#: elf/ldconfig.c:1267
#, c-format
msgid "relative path `%s' used to build cache"
msgstr "用來建置快取的相對路徑 `%s'"

#: elf/ldconfig.c:1297
#, c-format
msgid "Can't chdir to /"
msgstr "無法變更目錄到 /"

#: elf/ldconfig.c:1338
#, c-format
msgid "Can't open cache file directory %s\n"
msgstr "無法開啟快取檔案目錄 %s\n"

#: elf/ldd.bash.in:42
msgid "Written by %s and %s.\n"
msgstr "由 %s 和 %s 編寫。\n"

#: elf/ldd.bash.in:47
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"
msgstr ""
"用法：ldd [選項]… 檔案…\n"
"      --help              印出這份說明然後離開\n"
"      --version           印出版本資訊然後離開\n"
"  -d, --data-relocs       行程資料重定址\n"
"  -r, --function-relocs   行程資料和函式重定址\n"
"  -u, --unused            印出未使用的直接相依性\n"
"  -v, --verbose           印出所有資訊\n"

#: 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:488
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/pldd-xx.c:105
#, c-format
msgid "cannot find program header of process"
msgstr "找不到行程的程式標頭"

#: elf/pldd-xx.c:110
#, c-format
msgid "cannot read program header"
msgstr "無法讀取程式標頭"

#: elf/pldd-xx.c:135
#, c-format
msgid "cannot read dynamic section"
msgstr "無法讀取動態區段"

#: elf/pldd-xx.c:147
#, c-format
msgid "cannot read r_debug"
msgstr "無法讀取 r_debug"

#: elf/pldd-xx.c:167
#, c-format
msgid "cannot read program interpreter"
msgstr "無法讀取程式解譯器"

#: elf/pldd-xx.c:196
#, c-format
msgid "cannot read link map"
msgstr "無法讀取鏈結映射"

#: elf/pldd-xx.c:207
#, c-format
msgid "cannot read object name"
msgstr "無法讀取物件名稱"

#: elf/pldd.c:62
msgid "List dynamic shared objects loaded into process."
msgstr "列出已載入行程中的動態共用物件。"

#: elf/pldd.c:66
msgid "PID"
msgstr "行程識別號"

#: elf/pldd.c:97
#, c-format
msgid "Exactly one parameter with process ID required.\n"
msgstr "需要剛好一個附有行程識別號的參數。\n"

#: elf/pldd.c:109
#, c-format
msgid "invalid process ID '%s'"
msgstr "無效的行程識別號 %s"

#: elf/pldd.c:117
#, c-format
msgid "cannot open %s"
msgstr "無法開啟 %s"

#: elf/pldd.c:142
#, c-format
msgid "cannot open %s/task"
msgstr "無法開啟 %s/任務"

#: elf/pldd.c:145
#, c-format
msgid "cannot prepare reading %s/task"
msgstr "無法準備讀取 %s/任務"

#: elf/pldd.c:158
#, c-format
msgid "invalid thread ID '%s'"
msgstr "無效的執行緒識別號 %s"

#: elf/pldd.c:169
#, c-format
msgid "cannot attach to process %lu"
msgstr "無法附加到行程 %lu"

#: elf/pldd.c:261
#, c-format
msgid "cannot get information about process %lu"
msgstr "無法獲得行程 %lu 的相關資訊"

#: elf/pldd.c:274
#, c-format
msgid "process %lu is no ELF program"
msgstr "行程 %lu 並非 ELF 程式"

#: elf/readelflib.c:34
#, c-format
msgid "file %s is truncated\n"
msgstr "檔案 %s 已截短\n"

#: elf/readelflib.c:66
#, c-format
msgid "%s is a 32 bit ELF file.\n"
msgstr "%s 是一個 32 位元的 ELF 檔案。\n"

#: elf/readelflib.c:68
#, c-format
msgid "%s is a 64 bit ELF file.\n"
msgstr "%s 是一個 64 位元的 ELF 檔案。\n"

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

#: elf/readelflib.c:77
#, c-format
msgid "%s is not a shared object file (Type: %d).\n"
msgstr "%s 不是一個共用目的檔 (型態: %d)。\n"

#: elf/readelflib.c:108
#, c-format
msgid "more than one dynamic segment\n"
msgstr "超過一個的動態區段\n"

#: elf/readlib.c:96
#, c-format
msgid "Cannot fstat file %s.\n"
msgstr "無法 fstat 檔案 %s。\n"

#: elf/readlib.c:107
#, c-format
msgid "File %s is empty, not checked."
msgstr "檔案 %s 為空，不做檢查。"

#: elf/readlib.c:113
#, c-format
msgid "File %s is too small, not checked."
msgstr "檔案 %s 太小，不做檢查。"

#: elf/readlib.c:123
#, c-format
msgid "Cannot mmap file %s.\n"
msgstr "無法 mmap 檔案 %s。\n"

#: elf/readlib.c:161
#, c-format
msgid "%s is not an ELF file - it has the wrong magic bytes at the start.\n"
msgstr "%s 不是一個 ELF 檔 - 其開頭的魔術位元組是錯的。\n"

#: elf/sln.c:84
#, c-format
msgid ""
"Usage: sln src dest|file\n"
"\n"
msgstr ""
"用法：sln 原始碼 目的|檔案\n"
"\n"

#: elf/sln.c:109
#, c-format
msgid "%s: file open error: %m\n"
msgstr "%s：檔案開啟錯誤：%m\n"

#: elf/sln.c:146
#, c-format
msgid "No target in line %d\n"
msgstr "沒有目標於第 %d 列\n"

#: elf/sln.c:178
#, c-format
msgid "%s: destination must not be a directory\n"
msgstr "%s：目的必須不是目錄\n"

#: elf/sln.c:184
#, c-format
msgid "%s: failed to remove the old destination\n"
msgstr "%s：無法移除舊的目的\n"

#: elf/sln.c:192
#, c-format
msgid "%s: invalid destination: %s\n"
msgstr "%s：無效的目的：%s\n"

#: elf/sln.c:207 elf/sln.c:216
#, c-format
msgid "Invalid link from \"%s\" to \"%s\": %s\n"
msgstr "從「%s」到「%s」的鏈結無效：%s\n"

#: elf/sotruss.ksh:32
#, sh-format
msgid ""
"Usage: sotruss [OPTION...] [--] EXECUTABLE [EXECUTABLE-OPTION...]\n"
"  -F, --from FROMLIST     Trace calls from objects on FROMLIST\n"
"  -T, --to TOLIST         Trace calls to objects on TOLIST\n"
"\n"
"  -e, --exit              Also show exits from the function calls\n"
"  -f, --follow            Trace child processes\n"
"  -o, --output FILENAME   Write output to FILENAME (or FILENAME.$PID in case\n"
"\t\t\t  -f is also used) instead of standard error\n"
"\n"
"  -?, --help              Give this help list\n"
"      --usage             Give a short usage message\n"
"      --version           Print program version"
msgstr ""
"用法：sotruss [選項…] [--] 可執行檔案 [EXECUTABLE-OPTION...]\n"
"  -F, --from FROMLIST     追蹤來自 FROMLIST 上物件的呼叫\n"
"  -T, --to TOLIST         追蹤來自 TOLIST 上物件的呼叫\n"
"\n"
"  -e, --exit              也顯示來自函式的離開呼叫\n"
"  -f, --follow            追蹤子行程\n"
"  -o, --output 檔名       將輸出寫入 FILENAME (當同時使用 -f 時\n"
"\t\t\t  則使用 FILENAME.$PID) 以代替標準錯誤\n"
"\n"
"  -?, --help              給出這份說明清單\n"
"      --usage             給出簡短用法訊息\n"
"      --version           印出程式版本"

#: elf/sotruss.ksh:46
msgid "Mandatory arguments to long options are also mandatory for any corresponding\\nshort options.\\n"
msgstr "長選項的必要引數同樣也是相對應短選項的必要引數。"

#: elf/sotruss.ksh:55
msgid "%s: option requires an argument -- '%s'\\n"
msgstr "%s：選項需要一個引數 --『%s』\\n"

#: elf/sotruss.ksh:61
msgid "%s: option is ambiguous; possibilities:"
msgstr "%s：選項是模稜兩可的；可能是："

#: elf/sotruss.ksh:79
msgid "Written by %s.\\n"
msgstr "作者 %s。\\n"

#: elf/sotruss.ksh:86
msgid ""
"Usage: %s [-ef] [-F FROMLIST] [-o FILENAME] [-T TOLIST] [--exit]\n"
"\t    [--follow] [--from FROMLIST] [--output FILENAME] [--to TOLIST]\n"
"\t    [--help] [--usage] [--version] [--]\n"
"\t    EXECUTABLE [EXECUTABLE-OPTION...]\\n"
msgstr ""
"用法：%s [-ef] [-F FROMLIST] [-o FILENAME] [-T TOLIST] [--exit]\n"
"\t    [--follow] [--from FROMLIST] [--output 檔名] [--to TOLIST]\n"
"\t    [--help] [--usage] [--version] [--]\n"
"\t    可執行檔案 [EXECUTABLE-OPTION...]\\n"

#: elf/sotruss.ksh:134
msgid "%s: unrecognized option '%c%s'\\n"
msgstr "%s：無法辨識的選項『%c%s』\\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."
msgstr "讀取和顯示共用物件規範資料。"

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

#: elf/sprof.c:433
#, c-format
msgid "failed to load shared object `%s'"
msgstr "開啟共用目的檔 `%s' 失敗"

#: elf/sprof.c:442
#, c-format
msgid "cannot create internal descriptors"
msgstr "無法建立內部敘述項"

#: elf/sprof.c:554
#, c-format
msgid "Reopening shared object `%s' failed"
msgstr "重新開啟共用目的檔 %s 失敗"

#: elf/sprof.c:561 elf/sprof.c:656
#, c-format
msgid "reading of section headers failed"
msgstr "讀取小節標頭時失敗"

#: elf/sprof.c:569 elf/sprof.c:664
#, c-format
msgid "reading of section header string table failed"
msgstr "讀取小節標頭字串表格時失敗"

#: elf/sprof.c:595
#, c-format
msgid "*** Cannot read debuginfo file name: %m\n"
msgstr "*** 無法讀取除錯資訊檔案名稱：%m\n"

#: elf/sprof.c:616
#, c-format
msgid "cannot determine file name"
msgstr "無法決定檔案名稱"

#: elf/sprof.c:649
#, c-format
msgid "reading of ELF header failed"
msgstr "讀取 ELF 標頭時失敗"

#: elf/sprof.c:685
#, c-format
msgid "*** The file `%s' is stripped: no detailed analysis possible\n"
msgstr "*** 檔案 `%s' 被裁剪了: 無法做詳細的分析\n"

#: elf/sprof.c:715
#, c-format
msgid "failed to load symbol data"
msgstr "載入函式符號資料失敗"

#: elf/sprof.c:780
#, c-format
msgid "cannot load profiling data"
msgstr "無法載入測試資料"

#: elf/sprof.c:789
#, c-format
msgid "while stat'ing profiling data file"
msgstr "在對測試資料檔案進行統計的時候"

#: elf/sprof.c:797
#, c-format
msgid "profiling data file `%s' does not match shared object `%s'"
msgstr "測試資料檔 `%s' 與共用目的檔 `%s' 不符合"

#: elf/sprof.c:808
#, c-format
msgid "failed to mmap the profiling data file"
msgstr "測試資料檔案 mmap 失敗"

#: elf/sprof.c:816
#, c-format
msgid "error while closing the profiling data file"
msgstr "正在關閉測試資料檔案時發生錯誤"

#: elf/sprof.c:825 elf/sprof.c:923
#, c-format
msgid "cannot create internal descriptor"
msgstr "無法建立內部敘述項"

#: elf/sprof.c:899
#, c-format
msgid "`%s' is no correct profile data file for `%s'"
msgstr "`%s' 不是 `%s' 中正確的測速評估資料檔"

#: elf/sprof.c:1080 elf/sprof.c:1138
#, c-format
msgid "cannot allocate symbol data"
msgstr "無法配置函式符號資料"

#: iconv/iconv_charmap.c:141 iconv/iconv_prog.c:448
#, c-format
msgid "cannot open output file"
msgstr "無法開啟輸出檔"

#: iconv/iconv_charmap.c:187 iconv/iconv_prog.c:311
#, c-format
msgid "error while closing input `%s'"
msgstr "正在關閉輸入 `%s' 的時候發生錯誤"

#: iconv/iconv_charmap.c:461
#, c-format
msgid "illegal input sequence at position %Zd"
msgstr "位置 %Zd 有不合法的輸入序列"

#: iconv/iconv_charmap.c:480 iconv/iconv_prog.c:539
#, c-format
msgid "incomplete character or shift sequence at end of buffer"
msgstr "緩衝區結尾有不完全的字元或 shift sequence"

#: iconv/iconv_charmap.c:525 iconv/iconv_charmap.c:561 iconv/iconv_prog.c:582
#: iconv/iconv_prog.c:618
#, c-format
msgid "error while reading the input"
msgstr "正在讀入資料的時候發生錯誤"

#: iconv/iconv_charmap.c:543 iconv/iconv_prog.c:600
#, c-format
msgid "unable to allocate buffer for input"
msgstr "無法配置輸入用的緩衝區"

#: iconv/iconv_prog.c:59
msgid "Input/Output format specification:"
msgstr "輸入/輸出格式設定:"

#: iconv/iconv_prog.c:60
msgid "encoding of original text"
msgstr "原始文字的編碼"

#: iconv/iconv_prog.c:61
msgid "encoding for output"
msgstr "用來輸出的編碼"

#: iconv/iconv_prog.c:62
msgid "Information:"
msgstr "資料:"

#: iconv/iconv_prog.c:63
msgid "list all known coded character sets"
msgstr "列出所有已知的編碼字元集"

#: iconv/iconv_prog.c:64 locale/programs/localedef.c:127
msgid "Output control:"
msgstr "輸出控制:"

#: iconv/iconv_prog.c:65
msgid "omit invalid characters from output"
msgstr "省略無效字元的輸出"

#: iconv/iconv_prog.c:66 iconv/iconvconfig.c:128
#: locale/programs/localedef.c:120 locale/programs/localedef.c:122
#: locale/programs/localedef.c:124 locale/programs/localedef.c:145
#: malloc/memusagestat.c:56
msgid "FILE"
msgstr "檔案"

#: iconv/iconv_prog.c:66
msgid "output file"
msgstr "輸出檔案"

#: iconv/iconv_prog.c:67
msgid "suppress warnings"
msgstr "停止輸出警告訊息"

#: iconv/iconv_prog.c:68
msgid "print progress information"
msgstr "印出程序相關資訊"

#: iconv/iconv_prog.c:73
msgid "Convert encoding of given files from one encoding to another."
msgstr "從給定的檔案的字元編碼轉換到另一個"

#: iconv/iconv_prog.c:77
msgid "[FILE...]"
msgstr "[FILE…]"

#: iconv/iconv_prog.c:233
#, c-format
msgid "conversions from `%s' and to `%s' are not supported"
msgstr "不支援從 `%s' 以及到 `%s' 的轉換"

#: iconv/iconv_prog.c:238
#, c-format
msgid "conversion from `%s' is not supported"
msgstr "不支援從 `%s' 的轉換"

#: iconv/iconv_prog.c:245
#, c-format
msgid "conversion to `%s' is not supported"
msgstr "不支援到 `%s' 的轉換"

#: iconv/iconv_prog.c:249
#, c-format
msgid "conversion from `%s' to `%s' is not supported"
msgstr "不支援從 `%s' 到 `%s' 的轉換"

#: iconv/iconv_prog.c:259
#, c-format
msgid "failed to start conversion processing"
msgstr "開始轉換程序失敗"

#: iconv/iconv_prog.c:357
#, c-format
msgid "error while closing output file"
msgstr "正在關閉輸出檔案的時候發生錯誤"

#: iconv/iconv_prog.c:458
#, c-format
msgid "conversion stopped due to problem in writing the output"
msgstr "因寫入輸出時發生錯誤而導致轉換停止"

#: iconv/iconv_prog.c:535
#, c-format
msgid "illegal input sequence at position %ld"
msgstr "位置 %ld 有不合法的輸入序列"

#: iconv/iconv_prog.c:543
#, c-format
msgid "internal error (illegal descriptor)"
msgstr "內部錯誤 (不合法的敘述項)"

#: iconv/iconv_prog.c:546
#, c-format
msgid "unknown iconv() error %d"
msgstr "不明的 iconv() 錯誤 %d"

#: iconv/iconv_prog.c:791
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 ""
"以下的列表包含所有已知的編碼字集，但這不代表所有的字集名稱組合皆可用於\n"
"命令列的 \"來源\" 以及 \"目的\" 引數。一個編碼字集可以用幾個不同的名稱\n"
"來表示 (即 \"匿名\")。\n"
"\n"
"  "

#: iconv/iconvconfig.c:109
msgid "Create fastloading iconv module configuration file."
msgstr "建立快速載入 iconv 模組的設定檔案。"

#: iconv/iconvconfig.c:113
msgid "[DIR...]"
msgstr "[目錄…]"

#: iconv/iconvconfig.c:126 locale/programs/localedef.c:131
msgid "PATH"
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 "在 FILE 中置放輸出以代替已安裝的位置 (--prefix 不套用到 FILE)"

#: iconv/iconvconfig.c:132
msgid "Do not search standard directories, only those on the command line"
msgstr "不搜尋標準目錄，只有那些在之上命令列"

#: iconv/iconvconfig.c:299
#, c-format
msgid "Directory arguments required when using --nostdlib"
msgstr "目錄引數必要項時正在使用 --nostdlib"

#: iconv/iconvconfig.c:341 locale/programs/localedef.c:288
#, c-format
msgid "no output file produced because warnings were issued"
msgstr "因為發出過警告訊息，所以沒有製造任何輸出檔"

#: iconv/iconvconfig.c:430
#, c-format
msgid "while inserting in search tree"
msgstr "當插入於搜尋樹之中"

#: iconv/iconvconfig.c:1239
#, c-format
msgid "cannot generate output file"
msgstr "無法產生輸出檔"

#: inet/rcmd.c:163
msgid "rcmd: Cannot allocate memory\n"
msgstr "rcmd: 無法配置記憶體\n"

#: inet/rcmd.c:178
msgid "rcmd: socket: All ports in use\n"
msgstr "rcmd: socket: 所有的埠都在使用中\n"

#: inet/rcmd.c:206
#, c-format
msgid "connect to address %s: "
msgstr "連接到位址 %s: "

#: inet/rcmd.c:219
#, c-format
msgid "Trying %s...\n"
msgstr "嘗試 %s…\n"

#: inet/rcmd.c:255
#, c-format
msgid "rcmd: write (setting up stderr): %m\n"
msgstr "rcmd: write (正在設定標準錯誤輸出): %m\n"

#: inet/rcmd.c:271
#, c-format
msgid "rcmd: poll (setting up stderr): %m\n"
msgstr "rcmd: poll (正在設定標準錯誤輸出): %m\n"

#: inet/rcmd.c:274
msgid "poll: protocol failure in circuit setup\n"
msgstr "poll: 通訊協定在設定線路時失效\n"

#: inet/rcmd.c:306
msgid "socket: protocol failure in circuit setup\n"
msgstr "socket: 通訊協定在設定線路時失效\n"

#: inet/rcmd.c:330
#, c-format
msgid "rcmd: %s: short read"
msgstr "rcmd: %s: 讀入資料過短"

#: inet/rcmd.c:486
msgid "lstat failed"
msgstr "lstat 失敗"

#: inet/rcmd.c:493
msgid "cannot open"
msgstr "無法開啟"

#: inet/rcmd.c:495
msgid "fstat failed"
msgstr "fstat 失敗"

#: inet/rcmd.c:497
msgid "bad owner"
msgstr "錯誤的擁有者"

#: inet/rcmd.c:499
msgid "writeable by other than owner"
msgstr "使用者以外的人亦可寫入"

#: inet/rcmd.c:501
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 "移除密碼或讓他人無法讀取檔案"

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

#: libidn/nfkc.c:463
msgid "Character out of range for UTF-8"
msgstr "字元超出 UTF-8 範圍"

#: locale/programs/charmap-dir.c:57
#, 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 "字元對應 `%s' 不是 ASCII 相容碼，區域化資料庫不符合 ISO C\n"

#: 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 "prolog 中有語法錯誤: %s"

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

#: locale/programs/charmap.c:375 locale/programs/locfile.c:125
#: locale/programs/locfile.c:152 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 "不支援使用 locking 狀態的字元集"

#: 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:602
#: locale/programs/ld-collate.c:2767 locale/programs/ld-collate.c:3925
#: locale/programs/ld-ctype.c:2256 locale/programs/ld-ctype.c:3007
#: locale/programs/ld-identification.c:452
#: locale/programs/ld-measurement.c:238 locale/programs/ld-messages.c:332
#: locale/programs/ld-monetary.c:942 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 "只有 WIDTH 定義才能直接寫在 CHARMAP 定義之後"

#: 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:618
#: locale/programs/ld-collate.c:2764 locale/programs/ld-collate.c:4118
#: locale/programs/ld-ctype.c:2253 locale/programs/ld-ctype.c:3024
#: locale/programs/ld-identification.c:468
#: locale/programs/ld-measurement.c:254 locale/programs/ld-messages.c:348
#: locale/programs/ld-monetary.c:958 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:825 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 "在範圍起始與結束的位元組序列中，位元組的數目並不一致: %d vs %d"

#: locale/programs/charmap.c:993 locale/programs/ld-collate.c:3044
#: 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:135 locale/programs/ld-collate.c:1558
#: locale/programs/ld-ctype.c:421 locale/programs/ld-identification.c:133
#: locale/programs/ld-measurement.c:94 locale/programs/ld-messages.c:97
#: locale/programs/ld-monetary.c:193 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 "找不到 %s 類別的定義"

#: locale/programs/ld-address.c:146 locale/programs/ld-address.c:184
#: locale/programs/ld-address.c:202 locale/programs/ld-address.c:231
#: locale/programs/ld-address.c:303 locale/programs/ld-address.c:322
#: locale/programs/ld-address.c:335 locale/programs/ld-identification.c:146
#: locale/programs/ld-measurement.c:105 locale/programs/ld-monetary.c:205
#: locale/programs/ld-monetary.c:249 locale/programs/ld-monetary.c:265
#: locale/programs/ld-monetary.c:277 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:158 locale/programs/ld-address.c:210
#: locale/programs/ld-address.c:240 locale/programs/ld-address.c:278
#: 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:170
#, c-format
msgid "%s: invalid escape `%%%c' sequence in field `%s'"
msgstr "%s: 不適用的跳脫序列 `%%%c', 在欄位 `%s' 中"

#: locale/programs/ld-address.c:221
#, c-format
msgid "%s: terminology language code `%s' not defined"
msgstr "%s: 術語語言編碼 `%s' 未定義"

#: locale/programs/ld-address.c:246
#, c-format
msgid "%s: field `%s' must not be defined"
msgstr "%s: 欄位「%s」必須未被定義"

#: locale/programs/ld-address.c:260 locale/programs/ld-address.c:289
#, c-format
msgid "%s: language abbreviation `%s' not defined"
msgstr "%s: 語言縮寫 `%s' 沒有定義"

#: locale/programs/ld-address.c:267 locale/programs/ld-address.c:295
#: locale/programs/ld-address.c:329 locale/programs/ld-address.c:341
#, c-format
msgid "%s: `%s' value does not match `%s' value"
msgstr "%s: `%s' 值與 `%s' 值不符合"

#: locale/programs/ld-address.c:314
#, c-format
msgid "%s: numeric country code `%d' not valid"
msgstr "%s: 國家數字代碼 `%d' 錯誤"

#: locale/programs/ld-address.c:510 locale/programs/ld-address.c:547
#: locale/programs/ld-address.c:585 locale/programs/ld-ctype.c:2631
#: locale/programs/ld-identification.c:364
#: locale/programs/ld-measurement.c:221 locale/programs/ld-messages.c:301
#: locale/programs/ld-monetary.c:700 locale/programs/ld-monetary.c:735
#: locale/programs/ld-monetary.c:776 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:514 locale/programs/ld-address.c:552
#: locale/programs/ld-identification.c:368 locale/programs/ld-messages.c:311
#: locale/programs/ld-monetary.c:704 locale/programs/ld-monetary.c:739
#: 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:599 locale/programs/ld-collate.c:3923
#: locale/programs/ld-ctype.c:3004 locale/programs/ld-identification.c:449
#: locale/programs/ld-measurement.c:235 locale/programs/ld-messages.c:330
#: locale/programs/ld-monetary.c:940 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:609 locale/programs/ld-collate.c:544
#: locale/programs/ld-collate.c:596 locale/programs/ld-collate.c:892
#: locale/programs/ld-collate.c:905 locale/programs/ld-collate.c:2733
#: locale/programs/ld-collate.c:2754 locale/programs/ld-collate.c:4108
#: locale/programs/ld-ctype.c:1985 locale/programs/ld-ctype.c:2243
#: locale/programs/ld-ctype.c:2829 locale/programs/ld-ctype.c:3015
#: locale/programs/ld-identification.c:459
#: locale/programs/ld-measurement.c:245 locale/programs/ld-messages.c:339
#: locale/programs/ld-monetary.c:949 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:419
#, c-format
msgid "`%.*s' already defined in charmap"
msgstr "`%.*s' 在字集對照表中已經定義過了"

#: locale/programs/ld-collate.c:428
#, c-format
msgid "`%.*s' already defined in repertoire"
msgstr "`%.*s' 在編碼對映檔中已經被定義過了"

#: locale/programs/ld-collate.c:435
#, c-format
msgid "`%.*s' already defined as collating symbol"
msgstr "`%.*s' 已被定義為對照符號"

#: locale/programs/ld-collate.c:442
#, c-format
msgid "`%.*s' already defined as collating element"
msgstr "`%.*s' 已被定義為對照元素"

#: locale/programs/ld-collate.c:473 locale/programs/ld-collate.c:499
#, c-format
msgid "%s: `forward' and `backward' are mutually excluding each other"
msgstr "%s: `forward' 以及 `backward' 彼此互相排斥"

#: locale/programs/ld-collate.c:483 locale/programs/ld-collate.c:509
#: locale/programs/ld-collate.c:525
#, c-format
msgid "%s: `%s' mentioned more than once in definition of weight %d"
msgstr "%s: `%s' 不只一次地在權重 %d 中被提到"

#: locale/programs/ld-collate.c:581
#, c-format
msgid "%s: too many rules; first entry only had %d"
msgstr "%s: 太多規則；第一個項目只包含 %d"

#: locale/programs/ld-collate.c:617
#, c-format
msgid "%s: not enough sorting rules"
msgstr "%s: 排序規則不足"

#: locale/programs/ld-collate.c:782
#, c-format
msgid "%s: empty weight string not allowed"
msgstr "%s: 空白的權重字串是不允許的"

#: locale/programs/ld-collate.c:877
#, c-format
msgid "%s: weights must use the same ellipsis symbol as the name"
msgstr "%s: 權重必須使用與名稱相同的省略符號"

#: locale/programs/ld-collate.c:933
#, c-format
msgid "%s: too many values"
msgstr "%s: 太多變數值"

#: locale/programs/ld-collate.c:1053 locale/programs/ld-collate.c:1228
#, c-format
msgid "order for `%.*s' already defined at %s:%Zu"
msgstr "`%.*s' 的順序已經在 %s:%Zu 裡面定義了"

#: locale/programs/ld-collate.c:1103
#, c-format
msgid "%s: the start and the end symbol of a range must stand for characters"
msgstr "%s: 啟始與結束符號範圍必須代表字元"

#: locale/programs/ld-collate.c:1130
#, c-format
msgid "%s: byte sequences of first and last character must have the same length"
msgstr "%s: 第一個與最後一個字元的位元組序列必須有相同的長度"

#: locale/programs/ld-collate.c:1172
#, 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:1297
#, c-format
msgid "%s: symbolic range ellipsis must not directly follow `order_start'"
msgstr "%s: 符號範圍的省略不可以直接在 `order_start' 之後"

#: locale/programs/ld-collate.c:1301
#, c-format
msgid "%s: symbolic range ellipsis must not be directly followed by `order_end'"
msgstr "%s: 符號範圍的省略不可以直接在 `order_end' 之前"

#: locale/programs/ld-collate.c:1321 locale/programs/ld-ctype.c:1502
#, c-format
msgid "`%s' and `%.*s' are not valid names for symbolic range"
msgstr "`%s' 和 `%.*s' 皆非符號範圍中適用的名稱"

#: locale/programs/ld-collate.c:1371 locale/programs/ld-collate.c:3859
#, c-format
msgid "%s: order for `%.*s' already defined at %s:%Zu"
msgstr "%s: `%.*s' 的順序已在 %s:%Zu 中定義"

#: locale/programs/ld-collate.c:1380
#, c-format
msgid "%s: `%s' must be a character"
msgstr "%s: `%s' 必須是一個字元"

#: locale/programs/ld-collate.c:1575
#, c-format
msgid "%s: `position' must be used for a specific level in all sections or none"
msgstr "%s: `position' 必須在所有區塊裡特定的等級中使用，否則不能使用"

#: locale/programs/ld-collate.c:1600
#, c-format
msgid "symbol `%s' not defined"
msgstr "並未定義 `%s' 符號"

#: locale/programs/ld-collate.c:1676 locale/programs/ld-collate.c:1782
#, c-format
msgid "symbol `%s' has the same encoding as"
msgstr "跟符號 `%s' 有相同的編碼: "

#: locale/programs/ld-collate.c:1680 locale/programs/ld-collate.c:1786
#, c-format
msgid "symbol `%s'"
msgstr "符號 `%s'"

#: locale/programs/ld-collate.c:1828
#, c-format
msgid "no definition of `UNDEFINED'"
msgstr "沒有找到 `UNDEFINED' 的定義"

#: locale/programs/ld-collate.c:1857
#, c-format
msgid "too many errors; giving up"
msgstr "發生太多錯誤；放棄中"

#: locale/programs/ld-collate.c:2659 locale/programs/ld-collate.c:4047
#, 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:3024
#, c-format
msgid "%s: unknown character in collating symbol name"
msgstr "%s: 未知的字元在對照符號名稱中"

#: locale/programs/ld-collate.c:3153
#, c-format
msgid "%s: unknown character in equivalent definition name"
msgstr "%s: 未知的字元在同義定義名稱中"

#: locale/programs/ld-collate.c:3164
#, c-format
msgid "%s: unknown character in equivalent definition value"
msgstr "%s: 未知的字元在同義定義值中"

#: locale/programs/ld-collate.c:3174
#, c-format
msgid "%s: unknown symbol `%s' in equivalent definition"
msgstr "%s: 未知的符號 `%s' 在同義定義中"

#: locale/programs/ld-collate.c:3183
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:3408 locale/programs/ld-collate.c:3538
#: locale/programs/ld-collate.c:3901
#, c-format
msgid "%s: missing `order_end' keyword"
msgstr "%s: 缺少 `order_end' 關鍵字"

#: locale/programs/ld-collate.c:3471
#, c-format
msgid "%s: order for collating symbol %.*s not yet defined"
msgstr "%s: 對照符號 %.*s 的順序尚未定義"

#: locale/programs/ld-collate.c:3489
#, c-format
msgid "%s: order for collating element %.*s not yet defined"
msgstr "%s: 對照元素 %.*s 的順序尚未定義"

#: locale/programs/ld-collate.c:3500
#, c-format
msgid "%s: cannot reorder after %.*s: symbol not known"
msgstr "%s: 無法重新排列在 %.*s 之後: 未知的符號"

#: locale/programs/ld-collate.c:3552 locale/programs/ld-collate.c:3913
#, c-format
msgid "%s: missing `reorder-end' keyword"
msgstr "%s: 缺少 `reorder-end' 關鍵字"

#: locale/programs/ld-collate.c:3586 locale/programs/ld-collate.c:3784
#, c-format
msgid "%s: section `%.*s' not known"
msgstr "%s: 未知的區塊 `%.*s'"

#: locale/programs/ld-collate.c:3651
#, c-format
msgid "%s: bad symbol <%.*s>"
msgstr "%s: 不當的符號 <%.*s>"

#: locale/programs/ld-collate.c:3847
#, c-format
msgid "%s: cannot have `%s' as end of ellipsis range"
msgstr "%s: 無法用 `%s' 做為省略區段的結尾"

#: locale/programs/ld-collate.c:3897
#, c-format
msgid "%s: empty category description not allowed"
msgstr "%s: 空白的類別描述是不允許的"

#: locale/programs/ld-collate.c:3916
#, c-format
msgid "%s: missing `reorder-sections-end' keyword"
msgstr "%s: 缺少 `reorder-sections-end' 關鍵字"

#: locale/programs/ld-collate.c:4080
#, c-format
msgid "%s: '%s' without matching 'ifdef' or 'ifndef'"
msgstr "%s:「%s」而不需吻合中「ifdef」或「ifndef」"

#: locale/programs/ld-collate.c:4098
#, c-format
msgid "%s: 'endif' without matching 'ifdef' or 'ifndef'"
msgstr "%s:「endif」而不需吻合中「ifdef」或「ifndef」"

#: locale/programs/ld-ctype.c:440
#, c-format
msgid "No character set name specified in charmap"
msgstr "在字元對應 (charmap) 中沒有設定字集名稱"

#: locale/programs/ld-ctype.c:469
#, c-format
msgid "character L'\\u%0*x' in class `%s' must be in class `%s'"
msgstr "character L'\\u%0*x' (放在類別 `%s' 之中) 必須在類別 `%s' 裡面"

#: locale/programs/ld-ctype.c:484
#, c-format
msgid "character L'\\u%0*x' in class `%s' must not be in class `%s'"
msgstr "character L'\\u%0*x' (放在類別 `%s' 之中) 不能在類別 `%s' 裡面"

#: locale/programs/ld-ctype.c:498 locale/programs/ld-ctype.c:556
#, c-format
msgid "internal error in %s, line %u"
msgstr "%s 的第 %u 列發生內部錯誤"

#: locale/programs/ld-ctype.c:527
#, c-format
msgid "character '%s' in class `%s' must be in class `%s'"
msgstr "字元 '%s' (放在類別 `%s' 之中) 必須在類別 `%s' 裡面"

#: locale/programs/ld-ctype.c:543
#, c-format
msgid "character '%s' in class `%s' must not be in class `%s'"
msgstr "字元 '%s' (放在類別 `%s' 之中) 不能在類別 `%s' 裡面"

#: locale/programs/ld-ctype.c:573 locale/programs/ld-ctype.c:611
#, c-format
msgid "<SP> character not in class `%s'"
msgstr "<SP> 字元不在類別 `%s' 中"

#: locale/programs/ld-ctype.c:585 locale/programs/ld-ctype.c:622
#, c-format
msgid "<SP> character must not be in class `%s'"
msgstr "<SP> 字元不可以在類別 `%s' 中"

#: locale/programs/ld-ctype.c:600
#, c-format
msgid "character <SP> not defined in character map"
msgstr "字元 <SP> 在字集對照檔中沒有定義"

#: locale/programs/ld-ctype.c:736
#, c-format
msgid "`digit' category has not entries in groups of ten"
msgstr "`digit' 類別在群組 \"十\" 中沒有項目"

#: locale/programs/ld-ctype.c:785
#, c-format
msgid "no input digits defined and none of the standard names in the charmap"
msgstr "沒有定義輸入數字，在字集對照檔中也找不到相符的標準名稱"

#: locale/programs/ld-ctype.c:850
#, c-format
msgid "not all characters used in `outdigit' are available in the charmap"
msgstr "在字集對照表中無法找到某些在 `outdigit' 中用到的字元"

#: locale/programs/ld-ctype.c:867
#, c-format
msgid "not all characters used in `outdigit' are available in the repertoire"
msgstr "在編碼對映檔中無法找到某些在 `outdigit' 中用到的字元"

#: locale/programs/ld-ctype.c:1270
#, c-format
msgid "character class `%s' already defined"
msgstr "字元類別 `%s' 已經定義過了"

#: locale/programs/ld-ctype.c:1276
#, c-format
msgid "implementation limit: no more than %Zd character classes allowed"
msgstr "程式實作的限制: 不能使用超過 %Zd 個字集類別"

#: locale/programs/ld-ctype.c:1302
#, c-format
msgid "character map `%s' already defined"
msgstr "字集對照檔 `%s' 已經定義過了"

#: locale/programs/ld-ctype.c:1308
#, c-format
msgid "implementation limit: no more than %d character maps allowed"
msgstr "程式實作的限制: 不能使用超過 %d 個字集對照檔"

#: locale/programs/ld-ctype.c:1573 locale/programs/ld-ctype.c:1698
#: locale/programs/ld-ctype.c:1804 locale/programs/ld-ctype.c:2494
#: locale/programs/ld-ctype.c:3490
#, c-format
msgid "%s: field `%s' does not contain exactly ten entries"
msgstr "%s: `%s' 欄位沒有精確包含十個項目"

#: locale/programs/ld-ctype.c:1601 locale/programs/ld-ctype.c:2175
#, c-format
msgid "to-value <U%0*X> of range is smaller than from-value <U%0*X>"
msgstr "區域定義的結尾值 <U%0*X> 比起始值 <U%0*X> 還要小"

#: locale/programs/ld-ctype.c:1728
msgid "start and end character sequence of range must have the same length"
msgstr "從起始到結束之間的字元序列長度跟編碼範圍必須相同"

#: locale/programs/ld-ctype.c:1735
msgid "to-value character sequence is smaller than from-value sequence"
msgstr "字元序列定義的結尾值比起始值還要小"

#: locale/programs/ld-ctype.c:2095 locale/programs/ld-ctype.c:2146
msgid "premature end of `translit_ignore' definition"
msgstr "`translit_ignore' 定義沒有按時結束"

#: locale/programs/ld-ctype.c:2101 locale/programs/ld-ctype.c:2152
#: locale/programs/ld-ctype.c:2194
msgid "syntax error"
msgstr "語法錯誤"

#: locale/programs/ld-ctype.c:2327
#, c-format
msgid "%s: syntax error in definition of new character class"
msgstr "%s: 在定義新字元類別時語法錯誤"

#: locale/programs/ld-ctype.c:2342
#, c-format
msgid "%s: syntax error in definition of new character map"
msgstr "%s: 在定義新字元對應時語法錯誤"

#: locale/programs/ld-ctype.c:2516
msgid "ellipsis range must be marked by two operands of same type"
msgstr "省略區域必須用兩個型別相同的運算元標示出來"

#: locale/programs/ld-ctype.c:2525
msgid "with symbolic name range values the absolute ellipsis `...' must not be used"
msgstr "用符號名稱來指定字元編碼範圍時不可以用絕對位置的省略符號 `…'"

#: locale/programs/ld-ctype.c:2540
msgid "with UCS range values one must use the hexadecimal symbolic ellipsis `..'"
msgstr "用來指定 UCS 值的範圍時得用十六進位表示的省略符號 `..'"

#: locale/programs/ld-ctype.c:2554
msgid "with character code range values one must use the absolute ellipsis `...'"
msgstr "用來指定字元編碼值的範圍時得用絕對位置的省略符號 `…'"

#: locale/programs/ld-ctype.c:2705
#, c-format
msgid "duplicated definition for mapping `%s'"
msgstr "對映 `%s' 的定義重複了"

#: locale/programs/ld-ctype.c:2791 locale/programs/ld-ctype.c:2935
#, c-format
msgid "%s: `translit_start' section does not end with `translit_end'"
msgstr "%s: `translit_start' 小節並沒有以 `translit_end' 做為結束"

#: locale/programs/ld-ctype.c:2886
#, c-format
msgid "%s: duplicate `default_missing' definition"
msgstr "%s: 重複的 `default_missing' 定義"

#: locale/programs/ld-ctype.c:2891
msgid "previous definition was here"
msgstr "先前的設定在此"

#: locale/programs/ld-ctype.c:2913
#, c-format
msgid "%s: no representable `default_missing' definition found"
msgstr "%s: 找不到可表示為 `default_missing' 的定義"

#: locale/programs/ld-ctype.c:3066 locale/programs/ld-ctype.c:3150
#: locale/programs/ld-ctype.c:3170 locale/programs/ld-ctype.c:3191
#: locale/programs/ld-ctype.c:3212 locale/programs/ld-ctype.c:3233
#: locale/programs/ld-ctype.c:3254 locale/programs/ld-ctype.c:3294
#: locale/programs/ld-ctype.c:3315 locale/programs/ld-ctype.c:3382
#: locale/programs/ld-ctype.c:3424 locale/programs/ld-ctype.c:3449
#, c-format
msgid "%s: character `%s' not defined while needed as default value"
msgstr "%s: 字元 `%s' 沒有定義，但它是必需的預設值"

#: locale/programs/ld-ctype.c:3071 locale/programs/ld-ctype.c:3155
#: locale/programs/ld-ctype.c:3175 locale/programs/ld-ctype.c:3196
#: locale/programs/ld-ctype.c:3217 locale/programs/ld-ctype.c:3238
#: locale/programs/ld-ctype.c:3259 locale/programs/ld-ctype.c:3299
#: locale/programs/ld-ctype.c:3320 locale/programs/ld-ctype.c:3387
#, c-format
msgid "%s: character `%s' in charmap not representable with one byte"
msgstr "%s: 字集對照表中的字元 `%s' 無法表示為單一位元組"

#: locale/programs/ld-ctype.c:3431 locale/programs/ld-ctype.c:3456
#, c-format
msgid "%s: character `%s' needed as default value not representable with one byte"
msgstr "%s: 做為預設值所需的字元 `%s' 無法表示為單一位元組"

#: locale/programs/ld-ctype.c:3512
#, c-format
msgid "no output digits defined and none of the standard names in the charmap"
msgstr "沒有定義輸出數字，在字集對照檔中也找不到相符的標準名稱"

#: locale/programs/ld-ctype.c:3803
#, c-format
msgid "%s: transliteration data from locale `%s' not available"
msgstr "%s: 語區資料`%s' 的音譯資料不存在"

#: locale/programs/ld-ctype.c:3904
#, c-format
msgid "%s: table for class \"%s\": %lu bytes\n"
msgstr "%s: 類別 \"%s\" 表格: %lu 位元組\n"

#: locale/programs/ld-ctype.c:3973
#, c-format
msgid "%s: table for map \"%s\": %lu bytes\n"
msgstr "%s: 對映表 \"%s\" 表格: %lu 位元組\n"

#: locale/programs/ld-ctype.c:4106
#, c-format
msgid "%s: table for width: %lu bytes\n"
msgstr "%s: 寬度表格: %lu 位元組\n"

#: locale/programs/ld-identification.c:170
#, c-format
msgid "%s: no identification for category `%s'"
msgstr "%s: 類別 `%s' 沒有認證"

#: locale/programs/ld-identification.c:435
#, c-format
msgid "%s: duplicate category version definition"
msgstr "%s: 重複的類別版本定義"

#: 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:255 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:223
#, c-format
msgid "%s: value of field `int_curr_symbol' has wrong length"
msgstr "%s: 欄位 `int_curr_symbol' 值的長度錯誤"

#: locale/programs/ld-monetary.c:236
#, 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:284 locale/programs/ld-monetary.c:314
#, c-format
msgid "%s: value for field `%s' must be in range %d...%d"
msgstr "%s: 欄位 `%s' 的值必須在範圍 %d…%d"

#: locale/programs/ld-monetary.c:746 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:843 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:865 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:908
msgid "conversion rate value cannot be zero"
msgstr "轉換率的值不可以是零"

#: 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 "%s: 在 `era' 欄位的字串 %Zd 中，方向旗標既不是 '+' 也不是 '-'"

#: locale/programs/ld-time.c:258
#, c-format
msgid "%s: direction flag in string %Zd in `era' field is not a single character"
msgstr "%s: 在 `era' 欄位的字串 %Zd 中，方向旗標不是一個單一字元"

#: locale/programs/ld-time.c:271
#, c-format
msgid "%s: invalid number for offset in string %Zd in `era' field"
msgstr "%s: 在 `era' 欄位、字串 %Zd 中的位移數字不適用"

#: locale/programs/ld-time.c:279
#, c-format
msgid "%s: garbage at end of offset value in string %Zd in `era' field"
msgstr "%s: 無用的資料，在 `era' 欄位、字串 %Zd 中末尾的位移值"

#: locale/programs/ld-time.c:330
#, c-format
msgid "%s: invalid starting date in string %Zd in `era' field"
msgstr "%s: 在 `era' 欄位、字串 %Zd 中的起始日期不適用"

#: locale/programs/ld-time.c:339
#, c-format
msgid "%s: garbage at end of starting date in string %Zd in `era' field "
msgstr "%s: 無用的資料，在 `era' 欄位、字串 %Zd 中末尾的起始日期"

#: locale/programs/ld-time.c:358
#, c-format
msgid "%s: starting date is invalid in string %Zd in `era' field"
msgstr "%s: 在 `era' 區域的字串 %Zd 中的啟始日期是不適用的"

#: locale/programs/ld-time.c:407 locale/programs/ld-time.c:435
#, c-format
msgid "%s: invalid stopping date in string %Zd in `era' field"
msgstr "%s: 在 `era' 欄位、字串 %Zd 中的結束日期不適用"

#: locale/programs/ld-time.c:416
#, c-format
msgid "%s: garbage at end of stopping date in string %Zd in `era' field"
msgstr "%s: 無用的資料，在 `era' 區域、字串 %Zd 中末尾的結束日期"

#: locale/programs/ld-time.c:444
#, c-format
msgid "%s: missing era name in string %Zd in `era' field"
msgstr "%s: 缺少 era 名稱，在 `era' 欄位、字串 %Zd 中"

#: locale/programs/ld-time.c:456
#, c-format
msgid "%s: missing era format in string %Zd in `era' field"
msgstr "%s: 缺少 era 格式，在 `era' 欄位、字串 %Zd 中"

#: locale/programs/ld-time.c:497
#, c-format
msgid "%s: third operand for value of field `%s' must not be larger than %d"
msgstr "%s: 欄位 `%s' 值的第三個運算元不可以比 %d 大"

#: 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 "符號 `%.*s' 並不在字集對照表中"

#: locale/programs/linereader.c:837
#, c-format
msgid "symbol `%.*s' not in repertoire map"
msgstr "符號 `%.*s' 並不在編碼對映檔中"

#: locale/programs/locale-spec.c:130
#, c-format
msgid "unknown name \"%s\""
msgstr "不明名稱「%s」"

#: locale/programs/locale.c:72
msgid "System information:"
msgstr "系統相關資訊:"

#: locale/programs/locale.c:74
msgid "Write names of available locales"
msgstr "寫出存在的語區資料名稱"

#: locale/programs/locale.c:76
msgid "Write names of available charmaps"
msgstr "寫出存在的字集對照表名稱"

#: locale/programs/locale.c:77
msgid "Modify output format:"
msgstr "修改輸出格式:"

#: locale/programs/locale.c:78
msgid "Write names of selected categories"
msgstr "寫出選取的類別名稱"

#: locale/programs/locale.c:79
msgid "Write names of selected keywords"
msgstr "寫出選取的關鍵字名稱"

#: locale/programs/locale.c:80
msgid "Print more information"
msgstr "印出更多的資訊"

#: locale/programs/locale.c:85
msgid "Get locale-specific information."
msgstr "取得語區資料特定的資訊"

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

#: locale/programs/locale.c:192
#, c-format
msgid "Cannot set LC_CTYPE to default locale"
msgstr "無法將 LC_CTYPE 設置為預設的語區"

#: locale/programs/locale.c:194
#, c-format
msgid "Cannot set LC_MESSAGES to default locale"
msgstr "無法將 LC_MESSAGES 設置為預設的語區"

#: locale/programs/locale.c:207
#, c-format
msgid "Cannot set LC_COLLATE to default locale"
msgstr "無法將 LC_COLLATE 設置為預設的語區"

#: locale/programs/locale.c:223
#, c-format
msgid "Cannot set LC_ALL to default locale"
msgstr "無法將 LC_ALL 設置為預設的語區"

#: locale/programs/locale.c:519
#, c-format
msgid "while preparing output"
msgstr "在準備輸出時"

#: locale/programs/localedef.c:119
msgid "Input Files:"
msgstr "輸入檔:"

#: locale/programs/localedef.c:121
msgid "Symbolic character names defined in FILE"
msgstr "符號字元的名稱定義在檔案 FILE 中"

#: 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 "檔案 FILE 內含符號名與 UCS4 編碼之間的對映"

#: 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 "Strictly conform to POSIX"
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 ""
"NAME\n"
"[--add-to-archive|--delete-from-archive] 檔案...\n"
"--list-archive [檔案]"

#: locale/programs/localedef.c:229
#, c-format
msgid "cannot create directory for output files"
msgstr "無法為輸出檔建立目錄"

#: locale/programs/localedef.c:240
#, c-format
msgid "FATAL: system does not define `_POSIX2_LOCALEDEF'"
msgstr "嚴重錯誤: 系統沒有定義 `_POSIX2_LOCALEDEF'"

#: locale/programs/localedef.c:254 locale/programs/localedef.c:270
#: locale/programs/localedef.c:602 locale/programs/localedef.c:622
#, c-format
msgid "cannot open locale definition file `%s'"
msgstr "無法開啟語區資料定義檔 `%s'"

#: locale/programs/localedef.c:282
#, c-format
msgid "cannot write output files to `%s'"
msgstr "無法將輸出檔案寫入 `%s'"

#: locale/programs/localedef.c:368
#, c-format
msgid ""
"System's directory for character maps : %s\n"
"\t\t       repertoire maps: %s\n"
"\t\t       locale path    : %s\n"
"%s"
msgstr ""
"系統的字元對應目錄：%s\n"
"\t\t      編碼對應：%s\n"
"\t\t      語區路徑   ：%s\n"
"%s"

#: locale/programs/localedef.c:570
#, c-format
msgid "circular dependencies between locale definitions"
msgstr "有語區資料在定義時發生循環相關的情況"

#: locale/programs/localedef.c:576
#, c-format
msgid "cannot add already read locale `%s' a second time"
msgstr " `%s' 語區資料已經用過，不能重複加入"

#: locale/programs/locarchive.c:125 locale/programs/locarchive.c:367
#, c-format
msgid "cannot create temporary file: %s"
msgstr "無法產生暫時檔：%s"

#: locale/programs/locarchive.c:155 locale/programs/locarchive.c:413
#, c-format
msgid "cannot initialize archive file"
msgstr "無法起始保存檔"

#: locale/programs/locarchive.c:162 locale/programs/locarchive.c:420
#, c-format
msgid "cannot resize archive file"
msgstr "無法改變保存檔大小"

#: locale/programs/locarchive.c:177 locale/programs/locarchive.c:435
#: locale/programs/locarchive.c:645
#, c-format
msgid "cannot map archive header"
msgstr "無法註記保存檔表頭"

#: locale/programs/locarchive.c:199
#, c-format
msgid "failed to create new locale archive"
msgstr "無法建立新的語區保存檔"

#: locale/programs/locarchive.c:211
#, c-format
msgid "cannot change mode of new locale archive"
msgstr "無法改變新的語區資料保存檔狀態"

#: locale/programs/locarchive.c:311
#, c-format
msgid "cannot read data from locale archive"
msgstr "無法從語區歸檔讀取資料"

#: locale/programs/locarchive.c:342
#, c-format
msgid "cannot map locale archive file"
msgstr "無法映射語區資料保存檔"

#: locale/programs/locarchive.c:443
#, c-format
msgid "cannot lock new archive"
msgstr "無法鎖定新的保存檔"

#: locale/programs/locarchive.c:509
#, c-format
msgid "cannot extend locale archive file"
msgstr "無法延展語區資料保存檔"

#: locale/programs/locarchive.c:518
#, c-format
msgid "cannot change mode of resized locale archive"
msgstr "無法改變已變更大小的語區資料保存檔狀態"

#: locale/programs/locarchive.c:526
#, c-format
msgid "cannot rename new archive"
msgstr "無法更改新保存檔名稱"

#: locale/programs/locarchive.c:579
#, c-format
msgid "cannot open locale archive \"%s\""
msgstr "無法開啟語區資料保存檔 \"%s\""

#: locale/programs/locarchive.c:584
#, c-format
msgid "cannot stat locale archive \"%s\""
msgstr "無法統計語區資料保存檔 \"%s\""

#: locale/programs/locarchive.c:603
#, c-format
msgid "cannot lock locale archive \"%s\""
msgstr "無法鎖定語區資料保存檔 \"%s\""

#: locale/programs/locarchive.c:626
#, c-format
msgid "cannot read archive header"
msgstr "無法讀取保存檔表頭資料"

#: locale/programs/locarchive.c:697
#, c-format
msgid "locale '%s' already exists"
msgstr "語區資料 `%s' 已經存在"

#: locale/programs/locarchive.c:959 locale/programs/locarchive.c:974
#: locale/programs/locarchive.c:986 locale/programs/locarchive.c:998
#: locale/programs/locfile.c:343
#, c-format
msgid "cannot add to locale archive"
msgstr "無法加入語區資料保存檔"

#: locale/programs/locarchive.c:1156
#, c-format
msgid "locale alias file `%s' not found"
msgstr "找不到語區資料別名檔 `%s'"

#: locale/programs/locarchive.c:1306
#, c-format
msgid "Adding %s\n"
msgstr "加入 %s 中\n"

#: locale/programs/locarchive.c:1312
#, c-format
msgid "stat of \"%s\" failed: %s: ignored"
msgstr "取得 \"%s\" 的資訊時失敗: %s: 已忽略"

#: locale/programs/locarchive.c:1318
#, c-format
msgid "\"%s\" is no directory; ignored"
msgstr "\"%s\" 並非目錄; 已忽略"

#: locale/programs/locarchive.c:1325
#, c-format
msgid "cannot open directory \"%s\": %s: ignored"
msgstr "無法開啟目錄 \"%s\": %s: 已忽略"

#: locale/programs/locarchive.c:1397
#, c-format
msgid "incomplete set of locale files in \"%s\""
msgstr "不完整的一組語區資料檔案存在於 \"%s\" 之中"

#: locale/programs/locarchive.c:1461
#, c-format
msgid "cannot read all files in \"%s\": ignored"
msgstr "無法讀取 \"%s\" 中的所有檔案: 已忽略"

#: locale/programs/locarchive.c:1531
#, c-format
msgid "locale \"%s\" not in archive"
msgstr "語區資料 \"%s\" 不在保存檔中"

#: locale/programs/locfile.c:131
#, c-format
msgid "argument to `%s' must be a single character"
msgstr "給 `%s' 的引數必須是一個單字元"

#: locale/programs/locfile.c:251
msgid "syntax error: not inside a locale definition section"
msgstr "語法錯誤: 不能在語區資料定義區塊裡面使用"

#: locale/programs/locfile.c:625
#, c-format
msgid "cannot open output file `%s' for category `%s'"
msgstr "無法開啟輸出檔 `%s' 供類別 `%s' 使用"

#: locale/programs/locfile.c:649
#, c-format
msgid "failure while writing data for category `%s'"
msgstr "正在為類別 `%s' 寫入資料時發生錯誤"

#: locale/programs/locfile.c:745
#, c-format
msgid "cannot create output file `%s' for category `%s'"
msgstr "無法建立輸出檔 `%s' 供類別 `%s' 使用"

#: locale/programs/locfile.c:781
msgid "expecting string argument for `copy'"
msgstr "`copy' 的引數應該是字串才對"

#: locale/programs/locfile.c:785
msgid "locale name should consist only of portable characters"
msgstr "語區資料的名稱應該以常用字元組成"

#: locale/programs/locfile.c:804
msgid "no other keyword shall be specified when `copy' is used"
msgstr "使用 `copy' 的時候不應該再用到任何其他的關鍵字了"

#: locale/programs/locfile.c:818
#, 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 "編碼對映檔中的定義有語法錯誤: %s"

#: 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 "找不到編碼對映檔 `%s'"

#: login/programs/pt_chown.c:78
#, 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 "設定擁有者、群組和存取許可的從屬 pseudo 終端機相應到主 pseudo 終端機傳遞於檔案描述符號「%d」。 這是輔助程式程式用於「grantpt」函式。 它並未預想的為運行直接的地從命令列。\n"

#: login/programs/pt_chown.c:92
#, 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 ""
"擁有者為設定到目前使用者，群組為設定到「%s」，而存取許可為設定到「%o」。\n"
"\n"
"%s"

#: login/programs/pt_chown.c:198
#, c-format
msgid "too many arguments"
msgstr "太多引數"

#: login/programs/pt_chown.c:206
#, c-format
msgid "needs to be installed setuid `root'"
msgstr "需要是已安裝的 setuid「根」"

#: malloc/mcheck.c:347
msgid "memory is consistent, library is buggy\n"
msgstr "記憶體內容一致，函式庫有問題\n"

#: malloc/mcheck.c:350
msgid "memory clobbered before allocated block\n"
msgstr "記憶體在配置區塊之前就 clobbered 了\n"

#: malloc/mcheck.c:353
msgid "memory clobbered past end of allocated block\n"
msgstr "記憶體在經過配置的區塊尾部時 clobbered 了\n"

#: malloc/mcheck.c:356
msgid "block freed twice\n"
msgstr "此區塊被用 free 指令釋放了兩次\n"

#: malloc/mcheck.c:359
msgid "bogus mcheck_status, library is buggy\n"
msgstr "記憶體檢查狀態 (mcheck_ststus) 有誤，您所用的函式庫有問題\n"

#: malloc/memusage.sh:32
msgid "%s: option '%s' requires an argument\\n"
msgstr "%s：選項『%s』需要一個引數\\n"

#: malloc/memusage.sh:38
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"
msgstr ""
"用法：memusage [選項]… 程式 [PROGRAMOPTION]…\n"
"側寫檔記憶體用法的程式。\n"
"\n"
"   -n,--progname=名稱     做為側寫的程式檔案名稱\n"
"   -p,--png=檔案          產生 PNG 圖形並儲存它於檔案\n"
"   -d,--data=檔案         產生二進位資料檔案並儲存它於檔案\n"
"   -u,--unbuffered        不要將輸出緩衝\n"
"   -b,--buffer=大小       於寫出它們之前收集大小項目\n"
"      --no-timer          不透過計時器收集附加資訊\n"
"   -m,--mmap              同時追蹤 mmap 和相關者\n"
"\n"
"   -?,--help              印出這個說明然後離開\n"
"      --usage             給出短用法訊息\n"
"   -V,--version           印出版本資訊然後離開\n"
"\n"
"下列的選項只有套用時產生圖形輸出：\n"
"   -t,--time-based        及時定製圖形線性\n"
"   -T,--total             同時繪製記憶體使用總計圖形\n"
"      --title=字串        使用字串做為圖形的標題\n"
"   -x,--x-size=大小       定製圖形大小像素寬度\n"
"   -y,--y-size=大小       定製圖形大小像素高度\n"
"\n"
"長選項的必要引數同樣也是相對應短選項的必要引數。\n"
"\n"

#: malloc/memusage.sh:99
msgid ""
"Syntax: memusage [--data=FILE] [--progname=NAME] [--png=FILE] [--unbuffered]\n"
"\t    [--buffer=SIZE] [--no-timer] [--time-based] [--total]\n"
"\t    [--title=STRING] [--x-size=SIZE] [--y-size=SIZE]\n"
"\t    PROGRAM [PROGRAMOPTION]..."
msgstr ""
"語法：memusage [--data=檔案] [--progname=名稱] [--png=檔案] [--unbuffered]\n"
"\t   [--buffer=大小] [--no-timer] [--time-based] [--total]\n"
"\t   [--title=字串] [--x-size=大小] [--y-size=大小]\n"
"\t   程式 [PROGRAMOPTION]…"

#: 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:56
msgid "Name output file"
msgstr "名稱輸出檔"

#: malloc/memusagestat.c:57
msgid "STRING"
msgstr "字串"

#: malloc/memusagestat.c:57
msgid "Title string used in output graphic"
msgstr "在輸出的圖像中使用有標頭的字串"

#: malloc/memusagestat.c:58
msgid "Generate output linear to time (default is linear to number of function calls)"
msgstr "產生輸出與時間呈線性關係 (預設是與函式呼叫數目呈線性關係)"

#: malloc/memusagestat.c:62
msgid "Also draw graph for total memory consumption"
msgstr "同時對總記憶體用量作圖"

#: malloc/memusagestat.c:63
msgid "VALUE"
msgstr "像素值"

#: malloc/memusagestat.c:64
msgid "Make output graphic VALUE pixels wide"
msgstr "定製輸出圖形的寬度像素值"

#: malloc/memusagestat.c:65
msgid "Make output graphic VALUE pixels high"
msgstr "定製輸出圖形的高度像素值"

#: malloc/memusagestat.c:70
msgid "Generate graphic from memory profiling data"
msgstr "從記憶體性能測試資料產生圖像"

#: malloc/memusagestat.c:73
msgid "DATAFILE [OUTFILE]"
msgstr "資料檔 [輸出檔]"

#: misc/error.c:117
msgid "Unknown system error"
msgstr "未知的系統錯誤"

#: nis/nis_callback.c:188
msgid "unable to free arguments"
msgstr "無法釋放參數"

#: nis/nis_error.h:1 nis/ypclnt.c:831 nis/ypclnt.c:919 posix/regcomp.c:133
#: 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:876 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 "無法建立回叫資料 (callback)"

#: 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 "在與 callback proc 通訊時錯誤"

#: nis/nis_error.h:33
msgid "Non NIS+ namespace encountered"
msgstr "遭遇違反 NIS+ 命名規則的名稱"

#: 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 "目錄的 resync 請求已滿"

#: 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 "是的，42 就是存在的意義"

#: 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:121
#, c-format
msgid "LOCAL entry for UID %d in directory %s not unique\n"
msgstr "UID 為 %d 的項目在本地端中並不是唯一的 (在 %s 目錄裡面)\n"

#: nis/nis_print.c:51
msgid "UNKNOWN"
msgstr "不明"

#: nis/nis_print.c:109
msgid "BOGUS OBJECT\n"
msgstr "假的物件\n"

#: 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 "複製 :\n"

#: 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 "Diffie-Hellmann (%d 位元)\n"

#: 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 "Kerberos.\n"

#: 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 "\t絕對位址 (%u)\n"

#: 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 "行             :\n"

#: 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 "\t型別為 %s 的項目資料\n"

#: 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 "物件型別   : "

#: 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:116
#, c-format
msgid "Group entry for \"%s.%s\" group:\n"
msgstr "群組 \"%s.%s\" 群組項目:\n"

#: nis/nis_print_group_entry.c:124
msgid "    Explicit members:\n"
msgstr "    明確的成員:\n"

#: nis/nis_print_group_entry.c:129
msgid "    No explicit members\n"
msgstr "    沒有明確的成員\n"

#: nis/nis_print_group_entry.c:132
msgid "    Implicit members:\n"
msgstr "    不明確的成員:\n"

#: nis/nis_print_group_entry.c:137
msgid "    No implicit members\n"
msgstr "    沒有不明確的成員\n"

#: nis/nis_print_group_entry.c:140
msgid "    Recursive members:\n"
msgstr "    遞迴的成員:\n"

#: nis/nis_print_group_entry.c:145
msgid "    No recursive members\n"
msgstr "    沒有遞迴的成員\n"

#: nis/nis_print_group_entry.c:148
msgid "    Explicit nonmembers:\n"
msgstr "    明確的非成員:\n"

#: nis/nis_print_group_entry.c:153
msgid "    No explicit nonmembers\n"
msgstr "    沒有明確的非成員\n"

#: nis/nis_print_group_entry.c:156
msgid "    Implicit nonmembers:\n"
msgstr "    不明確的非成員:\n"

#: nis/nis_print_group_entry.c:161
msgid "    No implicit nonmembers\n"
msgstr "    沒有不明確的非成員\n"

#: nis/nis_print_group_entry.c:164
msgid "    Recursive nonmembers:\n"
msgstr "    遞迴的非成員：\n"

#: nis/nis_print_group_entry.c:169
msgid "    No recursive nonmembers\n"
msgstr "    沒有遞迴的非成員\n"

#: nis/nss_nisplus/nisplus-publickey.c:100
#: nis/nss_nisplus/nisplus-publickey.c:182
#, c-format
msgid "DES entry for netname %s not unique\n"
msgstr "netname %s 的 DES 項目並不唯一\n"

#: nis/nss_nisplus/nisplus-publickey.c:219
#, c-format
msgid "netname2user: missing group id list in `%s'"
msgstr "netname2user：在「%s」中缺少群組識別號清單"

#: nis/nss_nisplus/nisplus-publickey.c:301
#: nis/nss_nisplus/nisplus-publickey.c:307
#: nis/nss_nisplus/nisplus-publickey.c:372
#: nis/nss_nisplus/nisplus-publickey.c:381
#, c-format
msgid "netname2user: (nis+ lookup): %s\n"
msgstr "netname2user: (nis+ 搜尋): %s\n"

#: nis/nss_nisplus/nisplus-publickey.c:320
#, c-format
msgid "netname2user: DES entry for %s in directory %s not unique"
msgstr "netname2user: %s 的 DES 項目在 %s 目錄下並不是唯一的"

#: nis/nss_nisplus/nisplus-publickey.c:338
#, c-format
msgid "netname2user: principal name `%s' too long"
msgstr "netname2user: 主要名稱 `%s' 太長了"

#: nis/nss_nisplus/nisplus-publickey.c:394
#, c-format
msgid "netname2user: LOCAL entry for %s in directory %s not unique"
msgstr "netname2user: %s 的本地端項目在 %s 目錄下並不是唯一的"

#: nis/nss_nisplus/nisplus-publickey.c:401
msgid "netname2user: should not have uid 0"
msgstr "netname2user: 不能有使用者 id 為 0 的情況"

#: nis/ypclnt.c:834
msgid "Request arguments bad"
msgstr "必須引數有錯誤"

#: nis/ypclnt.c:837
msgid "RPC failure on NIS operation"
msgstr "NIS 運作 RPC 失敗"

#: nis/ypclnt.c:840
msgid "Can't bind to server which serves this domain"
msgstr "無法與服務於此網域的伺服器聯繫"

#: nis/ypclnt.c:843
msgid "No such map in server's domain"
msgstr "在伺服器的領域資料中找不到此一對映表"

#: nis/ypclnt.c:846
msgid "No such key in map"
msgstr "在對映表中沒有此一鍵值"

#: nis/ypclnt.c:849
msgid "Internal NIS error"
msgstr "內部 NIS 錯誤"

#: nis/ypclnt.c:852
msgid "Local resource allocation failure"
msgstr "區域資源配置失敗"

#: nis/ypclnt.c:855
msgid "No more records in map database"
msgstr "在對映表資料庫中沒有其他紀錄了"

#: nis/ypclnt.c:858
msgid "Can't communicate with portmapper"
msgstr "無法與 portmapper 通訊"

#: nis/ypclnt.c:861
msgid "Can't communicate with ypbind"
msgstr "無法與 ypbind 通訊"

#: nis/ypclnt.c:864
msgid "Can't communicate with ypserv"
msgstr "無法與 ypserv 通訊"

#: nis/ypclnt.c:867
msgid "Local domain name not set"
msgstr "區域網域名稱沒有設定"

#: nis/ypclnt.c:870
msgid "NIS map database is bad"
msgstr "NIS 對映資料庫是壞的"

#: nis/ypclnt.c:873
msgid "NIS client/server version mismatch - can't supply service"
msgstr "NIS 請求端/伺服端版本不符合 - 無法提供服務"

#: nis/ypclnt.c:879
msgid "Database is busy"
msgstr "資料庫正在忙碌"

#: nis/ypclnt.c:882
msgid "Unknown NIS error code"
msgstr "未知的 NIS 錯誤碼"

#: nis/ypclnt.c:922
msgid "Internal ypbind error"
msgstr "內部 ypbind 錯誤"

#: nis/ypclnt.c:925
msgid "Domain not bound"
msgstr "網域找不到"

#: nis/ypclnt.c:928
msgid "System resource allocation failure"
msgstr "系統資源配置失敗"

#: nis/ypclnt.c:931
msgid "Unknown ypbind error"
msgstr "未知的 ypbind 錯誤"

#: nis/ypclnt.c:972
msgid "yp_update: cannot convert host to netname\n"
msgstr "yp_update: 無法轉換主機的網路名稱\n"

#: nis/ypclnt.c:990
msgid "yp_update: cannot get server address\n"
msgstr "yp_update: 無法取得伺服器位址\n"

#: nscd/aicache.c:82 nscd/hstcache.c:494
#, c-format
msgid "Haven't found \"%s\" in hosts cache!"
msgstr "尚未在 hosts 快取中找到 \"%s\"!"

#: nscd/aicache.c:84 nscd/hstcache.c:496
#, c-format
msgid "Reloading \"%s\" in hosts cache!"
msgstr "重新載入「%s」於主機快取！"

#: nscd/cache.c:151
#, c-format
msgid "add new entry \"%s\" of type %s for %s to cache%s"
msgstr "加入新的項目「%s」的型態 %s 用於 %s 到 cache%s"

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

#: nscd/cache.c:285 nscd/connections.c:1019
#, c-format
msgid "cannot stat() file `%s': %s"
msgstr "無法 stat() 檔案 `%s': %s"

#: nscd/cache.c:331
#, c-format
msgid "pruning %s cache; time %ld"
msgstr "pruning %s 快取；時間 %ld"

#: nscd/cache.c:360
#, c-format
msgid "considering %s entry \"%s\", timeout %<PRIu64>"
msgstr "認為中 %s 項目「%s」，逾時 %<PRIu64>"

#: nscd/connections.c:571
#, c-format
msgid "invalid persistent database file \"%s\": %s"
msgstr "無效的永久性的資料庫檔案「%s」：%s"

#: nscd/connections.c:579
msgid "uninitialized header"
msgstr "未起始的標頭"

#: nscd/connections.c:584
msgid "header size does not match"
msgstr "頁首大小不吻合"

#: nscd/connections.c:594
msgid "file size does not match"
msgstr "檔案大小不吻合"

#: nscd/connections.c:611
msgid "verification failed"
msgstr "查核失敗"

#: nscd/connections.c:625
#, c-format
msgid "suggested size of table for database %s larger than the persistent database's table"
msgstr "用於資料庫 %s 的建議表格大小大於永久性的資料庫表格"

#: nscd/connections.c:636 nscd/connections.c:721
#, c-format
msgid "cannot create read-only descriptor for \"%s\"; no mmap"
msgstr "無法建立用於「%s」的唯讀描述元；無 mmap"

#: nscd/connections.c:652
#, c-format
msgid "cannot access '%s'"
msgstr "無法存取『%s』"

#: nscd/connections.c:700
#, c-format
msgid "database for %s corrupted or simultaneously used; remove %s manually if necessary and restart"
msgstr "資料庫用於 %s 已損壞或同步地使用；移除 %s 手動地如果必要的話和重新啟動"

#: nscd/connections.c:707
#, c-format
msgid "cannot create %s; no persistent database used"
msgstr "無法建立 %s; 未使用永久性的資料庫"

#: nscd/connections.c:710
#, c-format
msgid "cannot create %s; no sharing possible"
msgstr "無法建立 %s; 不可能共享"

#: nscd/connections.c:781
#, c-format
msgid "cannot write to database file %s: %s"
msgstr "無法寫入資料庫檔案 %s: %s"

#: nscd/connections.c:820
#, c-format
msgid "cannot set socket to close on exec: %s; disabling paranoia mode"
msgstr "無法設定通訊端到關閉於 exec：%s; 停用 paranoia 模式"

#: nscd/connections.c:869
#, c-format
msgid "cannot open socket: %s"
msgstr "無法開啟 socket: %s"

#: nscd/connections.c:889 nscd/connections.c:953
#, c-format
msgid "cannot change socket to nonblocking mode: %s"
msgstr "無法變更通訊端為非區塊模式：%s"

#: nscd/connections.c:897 nscd/connections.c:963
#, c-format
msgid "cannot set socket to close on exec: %s"
msgstr "無法設定通訊端於 exec：%s 時關閉"

#: nscd/connections.c:910
#, c-format
msgid "cannot enable socket to accept connections: %s"
msgstr "無法開啟 socket 來接受連線: %s"

#: nscd/connections.c:1003
#, c-format
msgid "register trace file %s for database %s"
msgstr "註冊追蹤檔案 %s 用於資料庫 %s"

#: nscd/connections.c:1133
#, c-format
msgid "provide access to FD %d, for %s"
msgstr "提供存取到 FD %d, 用於 %s"

#: nscd/connections.c:1145
#, c-format
msgid "cannot handle old request version %d; current version is %d"
msgstr "不能處理舊 %d 版的請求；目前使用的版本是 %d"

#: nscd/connections.c:1167
#, c-format
msgid "request from %ld not handled due to missing permission"
msgstr "由於缺少權限而無法處理來自 %ld 的要求"

#: nscd/connections.c:1172
#, c-format
msgid "request from '%s' [%ld] not handled due to missing permission"
msgstr "由於缺少權限而無法處理來自 '%s' [%ld] 的要求"

#: nscd/connections.c:1177
msgid "request not handled due to missing permission"
msgstr "要求無法控柄的由於缺少權限"

#: nscd/connections.c:1215 nscd/connections.c:1268
#, c-format
msgid "cannot write result: %s"
msgstr "無法寫入結果: %s"

#: nscd/connections.c:1359
#, c-format
msgid "error getting caller's id: %s"
msgstr "取得呼叫程式識別碼時發生錯誤: %s"

#: nscd/connections.c:1419
#, c-format
msgid "cannot open /proc/self/cmdline: %s; disabling paranoia mode"
msgstr "無法開啟/proc/self/cmdline：%s; 停用 paranoia 模式"

#: nscd/connections.c:1433
#, c-format
msgid "cannot read /proc/self/cmdline: %s; disabling paranoia mode"
msgstr "無法讀取/proc/self/cmdline：%s; 停用 paranoia 模式"

#: nscd/connections.c:1473
#, c-format
msgid "cannot change to old UID: %s; disabling paranoia mode"
msgstr "無法變更為舊的 UID：%s; 停用 paranoia 模式"

#: nscd/connections.c:1483
#, c-format
msgid "cannot change to old GID: %s; disabling paranoia mode"
msgstr "無法變更為舊的 GID：%s; 停用 paranoia 模式"

#: nscd/connections.c:1496
#, c-format
msgid "cannot change to old working directory: %s; disabling paranoia mode"
msgstr "無法變更為舊的工作目錄：%s; 停用 paranoia 模式"

#: nscd/connections.c:1542
#, c-format
msgid "re-exec failed: %s; disabling paranoia mode"
msgstr "re-exec 失敗：%s; 停用 paranoia 模式"

#: nscd/connections.c:1551
#, c-format
msgid "cannot change current working directory to \"/\": %s"
msgstr "無法變更目前的工作目錄到「/」：%s"

#: nscd/connections.c:1744
#, c-format
msgid "short read while reading request: %s"
msgstr "讀取請求時發現輸入值過短: %s"

#: nscd/connections.c:1777
#, c-format
msgid "key length in request too long: %d"
msgstr "在此請求中使用的鍵值太長了: %d"

#: nscd/connections.c:1790
#, c-format
msgid "short read while reading request key: %s"
msgstr "讀取請求的鍵值時發現輸入值過短: %s"

#: nscd/connections.c:1800
#, c-format
msgid "handle_request: request received (Version = %d) from PID %ld"
msgstr "handle_request: 請求已被接受 (版本為 %d) 來自於 PID %ld"

#: nscd/connections.c:1805
#, c-format
msgid "handle_request: request received (Version = %d)"
msgstr "handle_request: 請求已被接受 (版本為 %d)"

#: nscd/connections.c:2069 nscd/connections.c:2271
#, c-format
msgid "disabled inotify after read error %d"
msgstr "讀取 %d 錯誤之後已停用 inotify"

#: nscd/connections.c:2394
msgid "could not initialize conditional variable"
msgstr "無法初始化條件變數"

#: nscd/connections.c:2402
msgid "could not start clean-up thread; terminating"
msgstr "無法開始清理執行緒；終止中"

#: nscd/connections.c:2416
msgid "could not start any worker thread; terminating"
msgstr "無法開始任何背景工作執行緒；終止中"

#: nscd/connections.c:2467 nscd/connections.c:2468 nscd/connections.c:2485
#: nscd/connections.c:2494 nscd/connections.c:2512 nscd/connections.c:2523
#: nscd/connections.c:2534
#, c-format
msgid "Failed to run nscd as user '%s'"
msgstr "以使用者 '%s' 的身分執行 nscd 失敗"

#: nscd/connections.c:2486
#, c-format
msgid "initial getgrouplist failed"
msgstr "初始 getgrouplist 失敗"

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

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

#: nscd/grpcache.c:413 nscd/hstcache.c:441 nscd/initgrcache.c:419
#: nscd/pwdcache.c:391 nscd/servicescache.c:346
#, c-format
msgid "short write in %s: %s"
msgstr "寫入 %s 的資料過短: %s"

#: nscd/grpcache.c:458 nscd/initgrcache.c:77
#, c-format
msgid "Haven't found \"%s\" in group cache!"
msgstr "尚未在群組快取中找到 \"%s\"!"

#: nscd/grpcache.c:460 nscd/initgrcache.c:79
#, c-format
msgid "Reloading \"%s\" in group cache!"
msgstr "重新載入「%s」於群組快取！"

#: nscd/grpcache.c:539
#, c-format
msgid "Invalid numeric gid \"%s\"!"
msgstr "無效的 gid 數值 \"%s\"!"

#: nscd/mem.c:425
#, c-format
msgid "freed %zu bytes in %s cache"
msgstr "在 %2$s 快取中 %1$zu 位元組可用"

#: nscd/mem.c:568
#, c-format
msgid "no more memory for database '%s'"
msgstr "無記憶體可用於資料庫「%s」"

#: nscd/netgroupcache.c:77
#, c-format
msgid "Haven't found \"%s\" in netgroup cache!"
msgstr "尚未在網路群組快取中找到「%s」！"

#: nscd/netgroupcache.c:79
#, c-format
msgid "Reloading \"%s\" in netgroup cache!"
msgstr "重新在網路群組快取中載入「%s」！"

#: nscd/netgroupcache.c:475
#, c-format
msgid "Haven't found \"%s (%s,%s,%s)\" in netgroup cache!"
msgstr "尚未在網路群組快取中找到「%s (%s,%s,%s)」！"

#: nscd/netgroupcache.c:478
#, c-format
msgid "Reloading \"%s (%s,%s,%s)\" in netgroup cache!"
msgstr "重新在網路群組快取中載入「%s (%s,%s,%s)」！"

#: nscd/nscd.c:116
msgid "Read configuration data from NAME"
msgstr "自名稱中讀取設定資料"

#: nscd/nscd.c:118
msgid "Do not fork and display messages on the current tty"
msgstr "不在目前的 tty 產生子行程 (fork) 以及顯示訊息"

#: nscd/nscd.c:120
msgid "Do not fork, but otherwise behave like a daemon"
msgstr "不衍生，但是否則 behave 如同守護程式"

#: nscd/nscd.c:121
msgid "NUMBER"
msgstr "號碼"

#: nscd/nscd.c:121
msgid "Start NUMBER threads"
msgstr "啟動執行緒"

#: nscd/nscd.c:122
msgid "Shut the server down"
msgstr "將伺服器關閉"

#: nscd/nscd.c:123
msgid "Print current configuration statistics"
msgstr "印出目前組態統計"

#: nscd/nscd.c:124
msgid "TABLE"
msgstr "表格"

#: nscd/nscd.c:125
msgid "Invalidate the specified cache"
msgstr "使選定的快取無效"

#: nscd/nscd.c:126
msgid "TABLE,yes"
msgstr "要製作表格"

#: nscd/nscd.c:127
msgid "Use separate cache for each user"
msgstr "對不同使用者使用不同的快取檔案"

#: nscd/nscd.c:132
msgid "Name Service Cache Daemon."
msgstr "網域名稱快取精靈"

#: nscd/nscd.c:164 nss/getent.c:999 nss/makedb.c:206
#, c-format
msgid "wrong number of arguments"
msgstr "參數數目不對"

#: nscd/nscd.c:174
#, c-format
msgid "failure while reading configuration file; this is fatal"
msgstr "讀取組態檔案時失敗；這是一個嚴重錯誤"

#: nscd/nscd.c:183
#, c-format
msgid "already running"
msgstr "已在執行"

#: nscd/nscd.c:201
#, c-format
msgid "cannot fork"
msgstr "無法衍生"

#: nscd/nscd.c:259
#, c-format
msgid "cannot change current working directory to \"/\""
msgstr "無法變更目前的工作目錄到「/」"

#: nscd/nscd.c:267
msgid "Could not create log file"
msgstr "無法建立記錄檔"

#: nscd/nscd.c:339 nscd/nscd.c:364 nscd/nscd_stat.c:173
#, c-format
msgid "Only root is allowed to use this option!"
msgstr "只有 root 才可以使用此一選項!"

#: nscd/nscd.c:379
#, c-format
msgid "'%s' is not a known database"
msgstr "『%s』並非一已知資料庫"

#: nscd/nscd.c:404 nscd/nscd_stat.c:192
#, c-format
msgid "write incomplete"
msgstr "寫入不完全"

#: nscd/nscd.c:415
#, c-format
msgid "cannot read invalidate ACK"
msgstr "無法讀取設為無效的 ACK"

#: nscd/nscd.c:421
#, c-format
msgid "invalidation failed"
msgstr "無效化失敗"

#: nscd/nscd.c:431
#, 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:194
#, c-format
msgid "Must specify user name for server-user option"
msgstr "必須為伺服器使用者選項指定使用者名稱"

#: nscd/nscd_conf.c:201
#, c-format
msgid "Must specify user name for stat-user option"
msgstr "必須為 stat 使用者選項指定使用者名稱"

#: nscd/nscd_conf.c:258
#, c-format
msgid "Must specify value for restart-interval option"
msgstr "必須指定用於 restart-interval 選項的值"

#: nscd/nscd_conf.c:272
#, c-format
msgid "Unknown option: %s %s %s"
msgstr "未知的選項: %s %s %s"

#: nscd/nscd_conf.c:285
#, c-format
msgid "cannot get current working directory: %s; disabling paranoia mode"
msgstr "無法取得目前的工作目錄：%s; 停用 paranoia 模式"

#: nscd/nscd_conf.c:305
#, c-format
msgid "maximum file size for %s database too small"
msgstr "最大值檔案大小用於 %s 資料庫太小"

#: nscd/nscd_stat.c:142
#, c-format
msgid "cannot write statistics: %s"
msgstr "無法寫入統計資料: %s"

#: nscd/nscd_stat.c:157
msgid "yes"
msgstr "是"

#: nscd/nscd_stat.c:158
msgid "no"
msgstr "無"

#: nscd/nscd_stat.c:169
#, c-format
msgid "Only root or %s is allowed to use this option!"
msgstr "只有 root 或 %s 才允許使用此一選項!"

#: nscd/nscd_stat.c:180
#, c-format
msgid "nscd not running!\n"
msgstr "nscd 並沒有在執行!\n"

#: nscd/nscd_stat.c:204
#, c-format
msgid "cannot read statistics data"
msgstr "無法讀取統計資料"

#: nscd/nscd_stat.c:207
#, c-format
msgid ""
"nscd configuration:\n"
"\n"
"%15d  server debug level\n"
msgstr ""
"nscd 設定:\n"
"\n"
"%15d  伺服程式錯誤訊息報告等級\n"

#: nscd/nscd_stat.c:231
#, c-format
msgid "%3ud %2uh %2um %2lus  server runtime\n"
msgstr "%3ud %2uh %2um %2lus  伺服器 執行時期\n"

#: nscd/nscd_stat.c:234
#, c-format
msgid "    %2uh %2um %2lus  server runtime\n"
msgstr "    %2uh %2um %2lus  伺服器 執行時期\n"

#: nscd/nscd_stat.c:236
#, c-format
msgid "        %2um %2lus  server runtime\n"
msgstr "        %2um %2lus  伺服器 執行時期\n"

#: nscd/nscd_stat.c:238
#, c-format
msgid "            %2lus  server runtime\n"
msgstr "            %2lus  伺服器 執行時期\n"

#: nscd/nscd_stat.c:240
#, 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"
"%15u  reload count\n"
msgstr ""
"%15d  目前執行緒數量\n"
"%15d  最大執行緒數量\n"
"%15lu  客戶端必須等待的次數\n"
"%15s  paranoia 模式已啟用\n"
"%15lu  內部重新啟動\n"
"%15u  重新載入計數\n"

#: nscd/nscd_stat.c:275
#, 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 ""
"\n"
"%s 快取：\n"
"\n"
"%15s  快取已啟用\n"
"%15s  快取為持續的\n"
"%15s  快取為共享\n"
"%15zu  建議的大小\n"
"%15zu  總計資料儲存池大小\n"
"%15zu  使用的資料儲存池大小\n"
"%15lu  正項目的存在時間(秒)\n"
"%15lu  負項目的存在時間(秒)\n"
"%15<PRIuMAX> 正項目中找到快取數\n"
"%15<PRIuMAX> 負項目中找到快取數\n"
"%15<PRIuMAX> 正項目中遺漏的快取數\n"
"%15<PRIuMAX> 負項目中遺漏的快取數\n"
"%15lu%% 快取找到的比例\n"
"%15zu  目前快取的數量值\n"
"%15zu  最大值快取數量值\n"
"%15zu  已搜尋最大值鏈接長度\n"
"%15<PRIuMAX> rdlock 延遲數量\n"
"%15<PRIuMAX> wrlock 延遲數量\n"
"%15<PRIuMAX> 記憶體配置失敗\n"
"%15s  檢查 /etc/%s 的變更\n"

#: nscd/pwdcache.c:436
#, c-format
msgid "Haven't found \"%s\" in password cache!"
msgstr "尚未在密碼快取中找到 \"%s\"!"

#: nscd/pwdcache.c:438
#, c-format
msgid "Reloading \"%s\" in password cache!"
msgstr "重新載入「%s」於密碼快取！"

#: nscd/pwdcache.c:519
#, c-format
msgid "Invalid numeric uid \"%s\"!"
msgstr "無效的 uid 數值 \"%s\"!"

#: nscd/selinux.c:160
#, c-format
msgid "Failed opening connection to the audit subsystem: %m"
msgstr "失敗的開啟連線到稽核子系統：%m"

#: nscd/selinux.c:181
msgid "Failed to set keep-capabilities"
msgstr "設定功能保持時失敗"

#: nscd/selinux.c:182 nscd/selinux.c:245
#, c-format
msgid "prctl(KEEPCAPS) failed"
msgstr "prctl(KEEPCAPS) 失敗"

#: nscd/selinux.c:196
msgid "Failed to initialize drop of capabilities"
msgstr "初始化功能放棄時失敗"

#: nscd/selinux.c:197
#, c-format
msgid "cap_init failed"
msgstr "cap_init 失敗"

#: nscd/selinux.c:218 nscd/selinux.c:235
msgid "Failed to drop capabilities"
msgstr "放棄功能時失敗"

#: nscd/selinux.c:219 nscd/selinux.c:236
#, c-format
msgid "cap_set_proc failed"
msgstr "cap_set_proc 失敗"

#: nscd/selinux.c:244
msgid "Failed to unset keep-capabilities"
msgstr "解除設定功能保持時失敗"

#: nscd/selinux.c:260
msgid "Failed to determine if kernel supports SELinux"
msgstr "決定如果內核支援 SELinux 時失敗"

#: nscd/selinux.c:275
#, c-format
msgid "Failed to start AVC thread"
msgstr "開始 AVC 執行緒時失敗"

#: nscd/selinux.c:297
#, c-format
msgid "Failed to create AVC lock"
msgstr "建立 AVC 鎖定時失敗"

#: nscd/selinux.c:337
#, c-format
msgid "Failed to start AVC"
msgstr "啟始 AVC 時失敗"

#: nscd/selinux.c:339
msgid "Access Vector Cache (AVC) started"
msgstr "存取向量快取 (AVC) 開始"

#: nscd/selinux.c:360
msgid "Error getting context of socket peer"
msgstr "取得對等通訊端的狀態組合時發生錯誤"

#: nscd/selinux.c:365
msgid "Error getting context of nscd"
msgstr "取得 nscd 的狀態組合時發生錯誤"

#: nscd/selinux.c:371
msgid "Error getting sid from context"
msgstr "從狀態組合取得 sid 時發生錯誤"

#: nscd/selinux.c:378
msgid "compile-time support for database policy missing"
msgstr "compile-time 支援用於資料庫策略缺少"

#: nscd/selinux.c:411
#, 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 ""
"\n"
"SELinux AVC 統計：\n"
"\n"
"%15u  項目查找\n"
"%15u  項目符合項目\n"
"%15u  項目缺少\n"
"%15u  項目捨棄\n"
"%15u  CAV 查找\n"
"%15u  CAV 符合項目\n"
"%15u  CAV 探查\n"
"%15u  CAV 缺少\n"

#: nscd/servicescache.c:395
#, c-format
msgid "Haven't found \"%s\" in services cache!"
msgstr "尚未在服務快取中找到「%s」!"

#: nscd/servicescache.c:397
#, c-format
msgid "Reloading \"%s\" in services cache!"
msgstr "重新載入「%s」於服務快取！"

#: nss/getent.c:53
msgid "database [key ...]"
msgstr "資料庫 [鍵值…]"

#: nss/getent.c:58
msgid "CONFIG"
msgstr "組態"

#: nss/getent.c:58
msgid "Service configuration to be used"
msgstr "將要使用的服務組態"

#: nss/getent.c:59
msgid "disable IDN encoding"
msgstr "停用 IDN 編碼"

#: nss/getent.c:64
msgid "Get entries from administrative database."
msgstr "從管理資料庫取得條目。"

#: nss/getent.c:148 nss/getent.c:477 nss/getent.c:522
#, c-format
msgid "Enumeration not supported on %s\n"
msgstr "此項目在 %s 中不被支援\n"

#: nss/getent.c:913
#, c-format
msgid "Unknown database name"
msgstr "不明的資料庫名稱"

#: nss/getent.c:943
msgid "Supported databases:\n"
msgstr "支援的資料庫：\n"

#: nss/getent.c:1009
#, c-format
msgid "Unknown database: %s\n"
msgstr "未知的資料庫: %s\n"

#: nss/makedb.c:119
msgid "Convert key to lower case"
msgstr "轉換鍵轉換為小寫"

#: nss/makedb.c:122
msgid "Do not print messages while building database"
msgstr "不印出訊息當建立資料庫"

#: nss/makedb.c:124
msgid "Print content of database file, one entry a line"
msgstr "印出內容的資料庫檔案，一個項目列"

#: nss/makedb.c:125
msgid "CHAR"
msgstr "字元"

#: nss/makedb.c:126
msgid "Generated line not part of iteration"
msgstr "產生的列並非迭代的部分"

#: nss/makedb.c:131
msgid "Create simple database from textual input."
msgstr "從文字輸入建立簡單的資料庫。"

#: nss/makedb.c:134
msgid ""
"INPUT-FILE OUTPUT-FILE\n"
"-o OUTPUT-FILE INPUT-FILE\n"
"-u INPUT-FILE"
msgstr ""
"輸入檔案名稱 輸出檔案名稱\n"
"-o 輸出檔案名稱 輸入檔案名稱\n"
"-u 輸入檔案名稱"

#: nss/makedb.c:227
#, c-format
msgid "cannot open database file `%s'"
msgstr "無法開啟資料庫檔案 %s"

#: nss/makedb.c:272
#, c-format
msgid "no entries to be processed"
msgstr "沒有條目可供處理"

#: nss/makedb.c:282
#, c-format
msgid "cannot create temporary file name"
msgstr "無法建立暫存檔案名稱"

#: nss/makedb.c:288
#, c-format
msgid "cannot create temporary file"
msgstr "無法產生暫時檔"

#: nss/makedb.c:304
#, c-format
msgid "cannot stat newly created file"
msgstr "無法取得新建立檔案的狀態"

#: nss/makedb.c:315
#, c-format
msgid "cannot rename temporary file"
msgstr "無法重新命名暫存檔案"

#: nss/makedb.c:531 nss/makedb.c:554
#, c-format
msgid "cannot create search tree"
msgstr "無法建立搜尋樹"

#: nss/makedb.c:560
msgid "duplicate key"
msgstr "重複鍵值"

#: nss/makedb.c:572
#, c-format
msgid "problems while reading `%s'"
msgstr "讀取「%s」時發生問題"

#: nss/makedb.c:799
#, c-format
msgid "failed to write new database file"
msgstr "寫入新資料庫檔案時失敗"

#: nss/makedb.c:812
#, c-format
msgid "cannot stat database file"
msgstr "無法取得資料庫檔案的狀態"

#: nss/makedb.c:817
#, c-format
msgid "cannot map database file"
msgstr "無法映射資料庫檔案"

#: nss/makedb.c:820
#, c-format
msgid "file not a database file"
msgstr "檔案不是資料庫檔案"

#: nss/makedb.c:871
#, c-format
msgid "cannot set file creation context for `%s'"
msgstr "無法為 %s 設定檔案建立語境"

#: ports/sysdeps/unix/sysv/linux/ia64/makecontext.c:58
#, c-format
msgid "makecontext: does not know how to handle more than 8 arguments\n"
msgstr "makecontext: 不知要如何處理超過八個引數\n"

#: posix/getconf.c:1035
#, c-format
msgid "Usage: %s [-v specification] variable_name [pathname]\n"
msgstr "用法: %s [-v 規格] 變數名稱 [路徑名稱]\n"

#: posix/getconf.c:1038
#, c-format
msgid "       %s -a [pathname]\n"
msgstr "       %s -a [路徑名稱]\n"

#: posix/getconf.c:1114
#, c-format
msgid ""
"Usage: getconf [-v SPEC] VAR\n"
"  or:  getconf [-v SPEC] PATH_VAR PATH\n"
"\n"
"Get the configuration value for variable VAR, or for variable PATH_VAR\n"
"for path PATH.  If SPEC is given, give values for compilation\n"
"environment SPEC.\n"
"\n"
msgstr ""
"用法：getconf [-v SPEC] VAR\n"
" 或： getconf [-v SPEC] PATH_VAR 路徑\n"
"\n"
"取得變數 VAR 的組態值，或是變數 PATH_VAR\n"
"用於路徑 PATH。 如果已提供 SPEC，就給出用於編譯的\n"
"環境 SPEC 值。\n"
"\n"

#: posix/getconf.c:1172
#, c-format
msgid "unknown specification \"%s\""
msgstr "不明的規格 \"%s\""

#: posix/getconf.c:1224
#, c-format
msgid "Couldn't execute %s"
msgstr "無法執行 %s"

#: posix/getconf.c:1268 posix/getconf.c:1284
msgid "undefined"
msgstr "未定義"

#: posix/getconf.c:1306
#, c-format
msgid "Unrecognized variable `%s'"
msgstr "無法識別的變數 `%s'"

#: posix/getopt.c:592 posix/getopt.c:621
#, c-format
msgid "%s: option '%s' is ambiguous; possibilities:"
msgstr "%s：選項『%s』是模稜兩可的；可能是："

#: posix/getopt.c:662 posix/getopt.c:666
#, c-format
msgid "%s: option '--%s' doesn't allow an argument\n"
msgstr "%s: 選項 `--%s' 不允許附加引數\n"

#: posix/getopt.c:675 posix/getopt.c:680
#, c-format
msgid "%s: option '%c%s' doesn't allow an argument\n"
msgstr "%s: 選項 `%c%s' 不允許附加引數\n"

#: posix/getopt.c:723 posix/getopt.c:742
#, c-format
msgid "%s: option '--%s' requires an argument\n"
msgstr "%s：選項『--%s』需要一個引數\n"

#: posix/getopt.c:780 posix/getopt.c:783
#, c-format
msgid "%s: unrecognized option '--%s'\n"
msgstr "%s: 未知的選項 `--%s'\n"

#: posix/getopt.c:791 posix/getopt.c:794
#, c-format
msgid "%s: unrecognized option '%c%s'\n"
msgstr "%s: 未知的選項 `%c%s'\n"

#: posix/getopt.c:843 posix/getopt.c:846
#, c-format
msgid "%s: invalid option -- '%c'\n"
msgstr "%s: 不適用的選項 -- %c\n"

#: posix/getopt.c:899 posix/getopt.c:916 posix/getopt.c:1126
#: posix/getopt.c:1144
#, c-format
msgid "%s: option requires an argument -- '%c'\n"
msgstr "%s: 選項需要一個引數 -- %c\n"

#: posix/getopt.c:972 posix/getopt.c:988
#, c-format
msgid "%s: option '-W %s' is ambiguous\n"
msgstr "%s: 選項 `-W %s' 含義不清\n"

#: posix/getopt.c:1012 posix/getopt.c:1030
#, c-format
msgid "%s: option '-W %s' doesn't allow an argument\n"
msgstr "%s: 選項 `-W %s' 不允許附加引數\n"

#: posix/getopt.c:1051 posix/getopt.c:1069
#, c-format
msgid "%s: option '-W %s' requires an argument\n"
msgstr "%s：選項『-W %s』需要一個引數\n"

#: posix/regcomp.c:136
msgid "No match"
msgstr "沒有符合的項目"

#: posix/regcomp.c:139
msgid "Invalid regular expression"
msgstr "不適用的常規表示式"

#: posix/regcomp.c:142
msgid "Invalid collation character"
msgstr "不適用的對照字元"

#: posix/regcomp.c:145
msgid "Invalid character class name"
msgstr "不適用的字元類別名"

#: posix/regcomp.c:148
msgid "Trailing backslash"
msgstr "尾端的反斜線"

#: posix/regcomp.c:151
msgid "Invalid back reference"
msgstr "不適用的後部索引"

#: posix/regcomp.c:154
msgid "Unmatched [ or [^"
msgstr "[ 或 [^ 不能匹配"

#: posix/regcomp.c:157
msgid "Unmatched ( or \\("
msgstr "( 或 \\( 不能匹配"

#: posix/regcomp.c:160
msgid "Unmatched \\{"
msgstr "\\{ 不能匹配"

#: posix/regcomp.c:163
msgid "Invalid content of \\{\\}"
msgstr "不適用的 \\{\\} 內容"

#: posix/regcomp.c:166
msgid "Invalid range end"
msgstr "不適用的範圍結束"

#: posix/regcomp.c:169
msgid "Memory exhausted"
msgstr "記憶體用完了"

#: posix/regcomp.c:172
msgid "Invalid preceding regular expression"
msgstr "不適用的前置常規表示式"

#: posix/regcomp.c:175
msgid "Premature end of regular expression"
msgstr "常規表示式太早結束了"

#: posix/regcomp.c:178
msgid "Regular expression too big"
msgstr "正規表示式太長了"

#: posix/regcomp.c:181
msgid "Unmatched ) or \\)"
msgstr ") 或 \\) 不能匹配"

#: posix/regcomp.c:681
msgid "No previous regular expression"
msgstr "先前並未使用過常規表示式"

#: posix/wordexp.c:1840
msgid "parameter null or not set"
msgstr "參數為空字元或是未設置"

#: 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:121
#, c-format
msgid "%s: line %d: cannot specify more than %d trim domains"
msgstr "%s: 第 %d 列: 無法指定超過 %d 個修剪範圍"

#: resolv/res_hconf.c:142
#, c-format
msgid "%s: line %d: list delimiter not followed by domain"
msgstr "%s: 第 %d 列: 範圍不可跟在表列分隔字元之後"

#: resolv/res_hconf.c:201
#, c-format
msgid "%s: line %d: expected `on' or `off', found `%s'\n"
msgstr "%s: 第 %d 列: 預期為 `on' 或 `off'，卻發現 `%s'\n"

#: resolv/res_hconf.c:244
#, c-format
msgid "%s: line %d: bad command `%s'\n"
msgstr "%s: 第 %d 列: 不當的命令 `%s'\n"

#: resolv/res_hconf.c:279
#, c-format
msgid "%s: line %d: ignoring trailing garbage `%s'\n"
msgstr "%s: 第 %d 列: 正在忽略尾端的無用資料 `%s'\n"

#: stdio-common/psiginfo-data.h:2
msgid "Illegal opcode"
msgstr "不合法的 opcode"

#: stdio-common/psiginfo-data.h:3
msgid "Illegal operand"
msgstr "不合法的運算元"

#: stdio-common/psiginfo-data.h:4
msgid "Illegal addressing mode"
msgstr "不合法的定址模式"

#: stdio-common/psiginfo-data.h:5
msgid "Illegal trap"
msgstr "不合法的陷阱"

#: stdio-common/psiginfo-data.h:6
msgid "Privileged opcode"
msgstr "需要權限的 opcode"

#: stdio-common/psiginfo-data.h:7
msgid "Privileged register"
msgstr "需要權限的暫存器"

#: stdio-common/psiginfo-data.h:8
msgid "Coprocessor error"
msgstr "輔助處理器錯誤"

#: stdio-common/psiginfo-data.h:9
msgid "Internal stack error"
msgstr "內部堆疊錯誤"

#: stdio-common/psiginfo-data.h:12
msgid "Integer divide by zero"
msgstr "整數被零除"

#: stdio-common/psiginfo-data.h:13
msgid "Integer overflow"
msgstr "整數溢位"

#: stdio-common/psiginfo-data.h:14
msgid "Floating-point divide by zero"
msgstr "浮點數被零除"

#: stdio-common/psiginfo-data.h:15
msgid "Floating-point overflow"
msgstr "浮點數溢位"

#: stdio-common/psiginfo-data.h:16
msgid "Floating-point underflow"
msgstr "浮點數下限溢位"

#: stdio-common/psiginfo-data.h:17
msgid "Floating-poing inexact result"
msgstr "不精確的浮點數結果"

#: stdio-common/psiginfo-data.h:18
msgid "Invalid floating-point operation"
msgstr "無效的浮點數操作"

#: stdio-common/psiginfo-data.h:19
msgid "Subscript out of range"
msgstr "註標超出範圍"

#: stdio-common/psiginfo-data.h:22
msgid "Address not mapped to object"
msgstr "位址沒有映射到物件"

#: stdio-common/psiginfo-data.h:23
msgid "Invalid permissions for mapped object"
msgstr "對於映射物件的權限無效"

#: stdio-common/psiginfo-data.h:26
msgid "Invalid address alignment"
msgstr "無效的位址對齊"

#: stdio-common/psiginfo-data.h:27
msgid "Nonexisting physical address"
msgstr "不存在的實體位址"

#: stdio-common/psiginfo-data.h:28
msgid "Object-specific hardware error"
msgstr "物件特定的硬體錯誤"

#: stdio-common/psiginfo-data.h:31
msgid "Process breakpoint"
msgstr "行程中斷點"

#: stdio-common/psiginfo-data.h:32
msgid "Process trace trap"
msgstr "行程追蹤陷阱"

#: stdio-common/psiginfo-data.h:35
msgid "Child has exited"
msgstr "子行程已結束"

#: stdio-common/psiginfo-data.h:36
msgid "Child has terminated abnormally and did not create a core file"
msgstr "子行程已異常終止且未建立記憶體檔案"

#: stdio-common/psiginfo-data.h:37
msgid "Child hat terminated abnormally and created a core file"
msgstr "子行程已異常終止並已建立了記憶體檔案"

#: stdio-common/psiginfo-data.h:38
msgid "Traced child has trapped"
msgstr "追蹤的子行程已落入陷阱"

#: stdio-common/psiginfo-data.h:39
msgid "Child has stopped"
msgstr "子行程已停止"

#: stdio-common/psiginfo-data.h:40
msgid "Stopped child has continued"
msgstr "停止的子行程已繼續"

#: stdio-common/psiginfo-data.h:43
msgid "Data input available"
msgstr "資料輸入可用"

#: stdio-common/psiginfo-data.h:44
msgid "Output buffers available"
msgstr "輸出緩衝區可用"

#: stdio-common/psiginfo-data.h:45
msgid "Input message available"
msgstr "輸入訊息可用"

#: stdio-common/psiginfo-data.h:46
msgid "I/O error"
msgstr "I/O 錯誤"

#: stdio-common/psiginfo-data.h:47
msgid "High priority input available"
msgstr "高優先權輸入可用"

#: stdio-common/psiginfo-data.h:48
msgid "Device disconnected"
msgstr "裝置已經結束連線"

#: stdio-common/psiginfo.c:139
msgid "Signal sent by kill()"
msgstr "kill() 已發送信號"

#: stdio-common/psiginfo.c:142
msgid "Signal sent by sigqueue()"
msgstr "sigqueue() 已發送信號"

#: stdio-common/psiginfo.c:145
msgid "Signal generated by the expiration of a timer"
msgstr "計時器的逾期已產生信號"

#: stdio-common/psiginfo.c:148
msgid "Signal generated by the completion of an asynchronous I/O request"
msgstr "非同步 I/O 要求的完成已產生信號"

#: stdio-common/psiginfo.c:152
msgid "Signal generated by the arrival of a message on an empty message queue"
msgstr "空訊息佇列中到達的訊息已產生信號"

#: stdio-common/psiginfo.c:157
msgid "Signal sent by tkill()"
msgstr "tkill() 已發送信號"

#: stdio-common/psiginfo.c:162
msgid "Signal generated by the completion of an asynchronous name lookup request"
msgstr "非同步名稱查找要求的完成已產生信號"

#: stdio-common/psiginfo.c:168
msgid "Signal generated by the completion of an I/O request"
msgstr "I/O 要求的完成已產生信號"

#: stdio-common/psiginfo.c:174
msgid "Signal sent by the kernel"
msgstr "內核已發送信號"

#: stdio-common/psiginfo.c:198
#, c-format
msgid "Unknown signal %d\n"
msgstr "不明信號 %d\n"

#: stdio-common/psignal.c:43
#, c-format
msgid "%s%sUnknown signal %d\n"
msgstr "%s%s未知的信號 %d\n"

#: stdio-common/psignal.c:44
msgid "Unknown signal"
msgstr "不明的信號"

#: string/_strerror.c:45 sysdeps/mach/_strerror.c:86
msgid "Unknown error "
msgstr "未知的錯誤 "

#: string/strerror.c:42
msgid "Unknown error"
msgstr "未知的錯誤"

#: string/strsignal.c:60
#, c-format
msgid "Real-time signal %d"
msgstr "即時的信號 %d"

#: string/strsignal.c:64
#, c-format
msgid "Unknown signal %d"
msgstr "未知的信號 %d"

#: sunrpc/auth_unix.c:111 sunrpc/clnt_tcp.c:123 sunrpc/clnt_udp.c:135
#: sunrpc/clnt_unix.c:124 sunrpc/svc_tcp.c:188 sunrpc/svc_tcp.c:233
#: sunrpc/svc_udp.c:162 sunrpc/svc_unix.c:188 sunrpc/svc_unix.c:229
#: sunrpc/xdr.c:631 sunrpc/xdr.c:791 sunrpc/xdr_array.c:97
#: sunrpc/xdr_rec.c:152 sunrpc/xdr_ref.c:76
msgid "out of memory\n"
msgstr "記憶體不足\n"

#: sunrpc/auth_unix.c:349
msgid "auth_unix.c: Fatal marshalling problem"
msgstr "auth_unix.c: 嚴重的編組問題"

#: sunrpc/clnt_perr.c:95 sunrpc/clnt_perr.c:111
#, c-format
msgid "%s: %s; low version = %lu, high version = %lu"
msgstr "%s: %s; 低版本 = %lu，高版本 = %lu"

#: sunrpc/clnt_perr.c:102
#, c-format
msgid "%s: %s; why = %s\n"
msgstr "%s: %s; 原因 = %s\n"

#: sunrpc/clnt_perr.c:104
#, c-format
msgid "%s: %s; why = (unknown authentication error - %d)\n"
msgstr "%s: %s; 原因 = (不明的認證錯誤 - %d)\n"

#: sunrpc/clnt_perr.c:153
msgid "RPC: Success"
msgstr "RPC: 成功"

#: sunrpc/clnt_perr.c:156
msgid "RPC: Can't encode arguments"
msgstr "RPC: 無法將引數編碼"

#: sunrpc/clnt_perr.c:160
msgid "RPC: Can't decode result"
msgstr "RPC: 無法解碼得出結果"

#: sunrpc/clnt_perr.c:164
msgid "RPC: Unable to send"
msgstr "RPC: 無法傳送"

#: sunrpc/clnt_perr.c:168
msgid "RPC: Unable to receive"
msgstr "RPC: 無法接收"

#: sunrpc/clnt_perr.c:172
msgid "RPC: Timed out"
msgstr "RPC: 超過時間上限"

#: sunrpc/clnt_perr.c:176
msgid "RPC: Incompatible versions of RPC"
msgstr "RPC: RPC 版本不相容"

#: sunrpc/clnt_perr.c:180
msgid "RPC: Authentication error"
msgstr "RPC: 認證錯誤"

#: sunrpc/clnt_perr.c:184
msgid "RPC: Program unavailable"
msgstr "RPC: 程式不存在"

#: sunrpc/clnt_perr.c:188
msgid "RPC: Program/version mismatch"
msgstr "RPC: 程式/版本不符"

#: sunrpc/clnt_perr.c:192
msgid "RPC: Procedure unavailable"
msgstr "RPC: 無法取得程序"

#: sunrpc/clnt_perr.c:196
msgid "RPC: Server can't decode arguments"
msgstr "RPC: 伺服器無法將引數解碼"

#: sunrpc/clnt_perr.c:200
msgid "RPC: Remote system error"
msgstr "RPC: 遠端程式錯誤"

#: sunrpc/clnt_perr.c:204
msgid "RPC: Unknown host"
msgstr "RPC: 未知的遠端位址"

#: sunrpc/clnt_perr.c:208
msgid "RPC: Unknown protocol"
msgstr "RPC: 未知的協定"

#: sunrpc/clnt_perr.c:212
msgid "RPC: Port mapper failure"
msgstr "RPC: 通訊阜對映錯誤"

#: sunrpc/clnt_perr.c:216
msgid "RPC: Program not registered"
msgstr "RPC: 程式沒有註冊"

#: sunrpc/clnt_perr.c:220
msgid "RPC: Failed (unspecified error)"
msgstr "RPC: 失敗 (非特定的錯誤)"

#: sunrpc/clnt_perr.c:261
msgid "RPC: (unknown error code)"
msgstr "RPC: (未知的錯誤碼)"

#: sunrpc/clnt_perr.c:333
msgid "Authentication OK"
msgstr "鑑定完成"

#: sunrpc/clnt_perr.c:336
msgid "Invalid client credential"
msgstr "不適用的請求端身分認證"

#: sunrpc/clnt_perr.c:340
msgid "Server rejected credential"
msgstr "伺服器拒絕身分證明"

#: sunrpc/clnt_perr.c:344
msgid "Invalid client verifier"
msgstr "不適用的請求端認證"

#: sunrpc/clnt_perr.c:348
msgid "Server rejected verifier"
msgstr "伺服器拒絕認證"

#: sunrpc/clnt_perr.c:352
msgid "Client credential too weak"
msgstr "用戶端背景太弱"

#: sunrpc/clnt_perr.c:356
msgid "Invalid server verifier"
msgstr "不適用的服務認證"

#: sunrpc/clnt_perr.c:360
msgid "Failed (unspecified error)"
msgstr "失敗 (無特定的錯誤)"

#: sunrpc/clnt_raw.c:115
msgid "clnt_raw.c: fatal header serialization error"
msgstr "clnt_raw.c: 嚴重的標頭序列化錯誤"

#: sunrpc/pm_getmaps.c:77
msgid "pmap_getmaps.c: rpc problem"
msgstr "pmap_getmaps.c: 遠端程序呼叫問題"

#: sunrpc/pmap_clnt.c:127
msgid "Cannot register service"
msgstr "無法註冊服務"

#: sunrpc/pmap_rmt.c:243
msgid "Cannot create socket for broadcast rpc"
msgstr "無法為廣播式遠端程序呼叫 (broadcast rpc) 產生 socket"

#: sunrpc/pmap_rmt.c:250
msgid "Cannot set socket option SO_BROADCAST"
msgstr "無法設定 socket 選項 SO_BROADCAST"

#: sunrpc/pmap_rmt.c:302
msgid "Cannot send broadcast packet"
msgstr "無法傳送廣播封包"

#: sunrpc/pmap_rmt.c:327
msgid "Broadcast poll problem"
msgstr "Broadcast 調查有問題"

#: sunrpc/pmap_rmt.c:340
msgid "Cannot receive reply to broadcast"
msgstr "無法接受廣播後的回應"

#: sunrpc/rpc_main.c:281
#, c-format
msgid "%s: output would overwrite %s\n"
msgstr "%s: 輸出將會覆蓋 %s\n"

#: sunrpc/rpc_main.c:288
#, c-format
msgid "%s: unable to open %s: %m\n"
msgstr "%s: 無法開啟 %s: %m\n"

#: sunrpc/rpc_main.c:300
#, c-format
msgid "%s: while writing output %s: %m"
msgstr "%s: 當在寫出輸出 %s 時: %m"

#: sunrpc/rpc_main.c:336 sunrpc/rpc_main.c:375
#, c-format
msgid "cannot find C preprocessor: %s\n"
msgstr "找不到 C 前置處理器：%s\n"

#: sunrpc/rpc_main.c:411
#, c-format
msgid "%s: C preprocessor failed with signal %d\n"
msgstr "%s: C 前置處理器失效，其訊號值為 %d\n"

#: sunrpc/rpc_main.c:414
#, c-format
msgid "%s: C preprocessor failed with exit code %d\n"
msgstr "%s: C 前置處理器失效，其結束碼為 %d\n"

#: sunrpc/rpc_main.c:454
#, c-format
msgid "illegal nettype: `%s'\n"
msgstr "不合法的 nettype：「%s」\n"

#: sunrpc/rpc_main.c:1089
#, c-format
msgid "rpcgen: too many defines\n"
msgstr "rpcgen: 太多 define 了\n"

#: sunrpc/rpc_main.c:1101
#, c-format
msgid "rpcgen: arglist coding error\n"
msgstr "rpcgen: arglist 編碼錯誤\n"

#. TRANS: the file will not be removed; this is an
#. TRANS: informative message.
#: sunrpc/rpc_main.c:1134
#, c-format
msgid "file `%s' already exists and may be overwritten\n"
msgstr "檔案 `%s' 已經存在並有可能會被覆蓋掉\n"

#: sunrpc/rpc_main.c:1179
#, c-format
msgid "Cannot specify more than one input file!\n"
msgstr "無法指定超過一個輸入檔!\n"

#: sunrpc/rpc_main.c:1349
#, c-format
msgid "This implementation doesn't support newstyle or MT-safe code!\n"
msgstr "此實作方式不支援新的形式或多安全執行序的程式!\n"

#: sunrpc/rpc_main.c:1358
#, c-format
msgid "Cannot use netid flag with inetd flag!\n"
msgstr "無法將 netid 旗標與 inetd 旗標一起使用!\n"

#: sunrpc/rpc_main.c:1367
#, c-format
msgid "Cannot use netid flag without TIRPC!\n"
msgstr "無法在沒有 TIRPC 時使用 netid 旗標!\n"

#: sunrpc/rpc_main.c:1374
#, c-format
msgid "Cannot use table flags with newstyle!\n"
msgstr "無法將表格旗標與 newstyle 一起使用!\n"

#: sunrpc/rpc_main.c:1393
#, c-format
msgid "\"infile\" is required for template generation flags.\n"
msgstr "\"infile\" 是樣版產生旗標所需的\n"

#: sunrpc/rpc_main.c:1398
#, c-format
msgid "Cannot have more than one file generation flag!\n"
msgstr "無法使用超過一個的檔案產生旗標!\n"

#: sunrpc/rpc_main.c:1407
#, c-format
msgid "usage: %s infile\n"
msgstr "用法: %s infile\n"

#: sunrpc/rpc_main.c:1408
#, 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:1410
#, 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:1412
#, c-format
msgid "\t%s [-s nettype]* [-o outfile] [infile]\n"
msgstr "\t%s [-s 網路型態]* [-o 輸出檔案] [輸入檔案]\n"

#: sunrpc/rpc_main.c:1413
#, c-format
msgid "\t%s [-n netid]* [-o outfile] [infile]\n"
msgstr "\t%s [-n 網路識別符號]* [-o 輸出檔案] [輸入檔案]\n"

#: sunrpc/rpc_main.c:1421
#, c-format
msgid "options:\n"
msgstr "選項：\n"

#: sunrpc/rpc_main.c:1422
#, c-format
msgid "-a\t\tgenerate all files, including samples\n"
msgstr "-a\t\t產生所有檔案，包含樣本\n"

#: sunrpc/rpc_main.c:1423
#, c-format
msgid "-b\t\tbackward compatibility mode (generates code for SunOS 4.1)\n"
msgstr "-b\t\t回溯相容模式 (產生用於 SunOS 4.1 的編碼)\n"

#: sunrpc/rpc_main.c:1424
#, c-format
msgid "-c\t\tgenerate XDR routines\n"
msgstr "-c\t\t產生 XDR 常式\n"

#: sunrpc/rpc_main.c:1425
#, c-format
msgid "-C\t\tANSI C mode\n"
msgstr "-C\t\tANSI C 模式\n"

#: sunrpc/rpc_main.c:1426
#, c-format
msgid "-Dname[=value]\tdefine a symbol (same as #define)\n"
msgstr "-D名稱[=值]\t定義一個符號 (如同 #define)\n"

#: sunrpc/rpc_main.c:1427
#, c-format
msgid "-h\t\tgenerate header file\n"
msgstr "-h\t\t產生標頭檔\n"

#: sunrpc/rpc_main.c:1428
#, c-format
msgid "-i size\t\tsize at which to start generating inline code\n"
msgstr "-i 大小\t\t啟始產生內聯編碼的大小\n"

#: sunrpc/rpc_main.c:1429
#, c-format
msgid "-I\t\tgenerate code for inetd support in server (for SunOS 4.1)\n"
msgstr "-I\t\t產生在伺服器中支援的 inetd 編碼 (用於 SunOS 4.1)\n"

#: sunrpc/rpc_main.c:1430
#, c-format
msgid "-K seconds\tserver exits after K seconds of inactivity\n"
msgstr "-K 秒\t不作用 K 秒之後離開伺服器\n"

#: sunrpc/rpc_main.c:1431
#, c-format
msgid "-l\t\tgenerate client side stubs\n"
msgstr "-l\t\t產生客戶端殘餘\n"

#: sunrpc/rpc_main.c:1432
#, c-format
msgid "-L\t\tserver errors will be printed to syslog\n"
msgstr "-L\t\t伺服器錯誤將被列印到 syslog\n"

#: sunrpc/rpc_main.c:1433
#, c-format
msgid "-m\t\tgenerate server side stubs\n"
msgstr "-m\t\t產生伺服器端殘餘\n"

#: sunrpc/rpc_main.c:1434
#, c-format
msgid "-M\t\tgenerate MT-safe code\n"
msgstr "-M\t\t產生 MT-safe 編碼\n"

#: sunrpc/rpc_main.c:1435
#, c-format
msgid "-n netid\tgenerate server code that supports named netid\n"
msgstr "-n netid\t產生支援具名 netid 的伺服器編碼\n"

#: sunrpc/rpc_main.c:1436
#, c-format
msgid "-N\t\tsupports multiple arguments and call-by-value\n"
msgstr "-N\t\t支援多重引數和傳值呼叫\n"

#: sunrpc/rpc_main.c:1437
#, c-format
msgid "-o outfile\tname of the output file\n"
msgstr "-o 輸出檔\t輸出檔案的名稱\n"

#: sunrpc/rpc_main.c:1438
#, c-format
msgid "-s nettype\tgenerate server code that supports named nettype\n"
msgstr "-s nettype\t產生支援具名 nettype 的伺服器編碼\n"

#: sunrpc/rpc_main.c:1439
#, c-format
msgid "-Sc\t\tgenerate sample client code that uses remote procedures\n"
msgstr "-Sc\t\t產生使用遠端程序的範例客戶端編碼\n"

#: sunrpc/rpc_main.c:1440
#, c-format
msgid "-Ss\t\tgenerate sample server code that defines remote procedures\n"
msgstr "-Ss\t\t產生定義遠端程序的範例伺服器編碼\n"

#: sunrpc/rpc_main.c:1441
#, c-format
msgid "-Sm \t\tgenerate makefile template \n"
msgstr "-Sm\t\t產生 makefile 模板\n"

#: sunrpc/rpc_main.c:1442
#, c-format
msgid "-t\t\tgenerate RPC dispatch table\n"
msgstr "-t\t\t產生 RPC 派送表\n"

#: sunrpc/rpc_main.c:1443
#, c-format
msgid "-T\t\tgenerate code to support RPC dispatch tables\n"
msgstr "-T\t\t產生支援 RPC 派送表的編碼\n"

#: sunrpc/rpc_main.c:1444
#, c-format
msgid "-Y path\t\tdirectory name to find C preprocessor (cpp)\n"
msgstr "-Y 路徑\t\t要尋找 C 前置處理器 (cpp) 的目錄名稱\n"

#: sunrpc/rpc_main.c:1446
#, c-format
msgid ""
"\n"
"For bug reporting instructions, please see:\n"
"%s.\n"
msgstr ""
"\n"
"要知道錯誤報告指令，請參看：\n"
"%s。\n"

#: sunrpc/rpc_scan.c:112
msgid "constant or identifier expected"
msgstr "應該要有常數或識別符號才對"

#: sunrpc/rpc_scan.c:308
msgid "illegal character in file: "
msgstr "檔案中有不合法的字元: "

#: sunrpc/rpc_scan.c:347 sunrpc/rpc_scan.c:373
msgid "unterminated string constant"
msgstr "沒有結尾的字串常數"

#: sunrpc/rpc_scan.c:379
msgid "empty char string"
msgstr "空的字元字串"

#: sunrpc/rpc_scan.c:521 sunrpc/rpc_scan.c:531
msgid "preprocessor error"
msgstr "前置處理器錯誤"

#: sunrpc/rpcinfo.c:246 sunrpc/rpcinfo.c:392
#, c-format
msgid "program %lu is not available\n"
msgstr "程式 %lu 不存在\n"

#: sunrpc/rpcinfo.c:273 sunrpc/rpcinfo.c:319 sunrpc/rpcinfo.c:342
#: sunrpc/rpcinfo.c:416 sunrpc/rpcinfo.c:462 sunrpc/rpcinfo.c:485
#: sunrpc/rpcinfo.c:519
#, c-format
msgid "program %lu version %lu is not available\n"
msgstr "程式 %lu 的第 %lu 版並不存在\n"

#: sunrpc/rpcinfo.c:524
#, c-format
msgid "program %lu version %lu ready and waiting\n"
msgstr "程式 %lu 的第 %lu 版已經就緒並等待服務中\n"

#: sunrpc/rpcinfo.c:565 sunrpc/rpcinfo.c:572
msgid "rpcinfo: can't contact portmapper"
msgstr "rpcinfo: 無法建立跟 portmapper 之間的連線"

#: sunrpc/rpcinfo.c:579
msgid "No remote programs registered.\n"
msgstr "沒有註冊過的遠端應用程式\n"

#: sunrpc/rpcinfo.c:583
msgid "   program vers proto   port\n"
msgstr "   程式採用的協定連接阜\n"

#: sunrpc/rpcinfo.c:622
msgid "(unknown)"
msgstr "(未知)"

#: sunrpc/rpcinfo.c:646
#, c-format
msgid "rpcinfo: broadcast failed: %s\n"
msgstr "rpcinfo: 廣播失敗: %s\n"

#: sunrpc/rpcinfo.c:667
msgid "Sorry. You are not root\n"
msgstr "不好意思，你並不是 root 使用者\n"

#: sunrpc/rpcinfo.c:674
#, c-format
msgid "rpcinfo: Could not delete registration for prog %s version %s\n"
msgstr "rpcinfo: 無法刪除程式 %s (第 %s 版) 的註冊資料\n"

#: sunrpc/rpcinfo.c:683
msgid "Usage: rpcinfo [ -n portnum ] -u host prognum [ versnum ]\n"
msgstr "使用方式: rpcinfo [ -n portnum ] -u host prognum [ versnum ]\n"

#: sunrpc/rpcinfo.c:685
msgid "       rpcinfo [ -n portnum ] -t host prognum [ versnum ]\n"
msgstr "       rpcinfo [ -n portnum ] -t host prognum [ versnum ]\n"

#: sunrpc/rpcinfo.c:687
msgid "       rpcinfo -p [ host ]\n"
msgstr "       rpcinfo -p [ host ]\n"

#: sunrpc/rpcinfo.c:688
msgid "       rpcinfo -b prognum versnum\n"
msgstr "       rpcinfo -b prognum versnum\n"

#: sunrpc/rpcinfo.c:689
msgid "       rpcinfo -d prognum versnum\n"
msgstr "       rpcinfo -d prognum versnum\n"

#: sunrpc/rpcinfo.c:714
#, c-format
msgid "rpcinfo: %s is unknown service\n"
msgstr "rpcinfo: %s 是不明的服務\n"

#: sunrpc/rpcinfo.c:751
#, c-format
msgid "rpcinfo: %s is unknown host\n"
msgstr "rpcinfo: %s 是不明的主機\n"

#: sunrpc/svc_run.c:71
msgid "svc_run: - out of memory"
msgstr "svc_run：- 記憶體不足"

#: sunrpc/svc_run.c:91
msgid "svc_run: - poll failed"
msgstr "svc_run: - poll 失敗"

#: sunrpc/svc_simple.c:80
#, c-format
msgid "can't reassign procedure number %ld\n"
msgstr "不能重複指定程序號碼 %ld\n"

#: sunrpc/svc_simple.c:90
msgid "couldn't create an rpc server\n"
msgstr "不能產生遠端程序呼叫伺服程式\n"

#: sunrpc/svc_simple.c:98
#, c-format
msgid "couldn't register prog %ld vers %ld\n"
msgstr "不能將程式 %ld 註冊到 %ld\n"

#: sunrpc/svc_simple.c:106
msgid "registerrpc: out of memory\n"
msgstr "registerrpc: 記憶體不足\n"

#: sunrpc/svc_simple.c:169
#, c-format
msgid "trouble replying to prog %d\n"
msgstr "回應程式 %d 時發生困難\n"

#: sunrpc/svc_simple.c:178
#, c-format
msgid "never registered prog %d\n"
msgstr "千萬不要註冊程式 %d\n"

#: sunrpc/svc_tcp.c:164
msgid "svc_tcp.c - tcp socket creation problem"
msgstr "svc_tcp.c - tcp socket 建立發生問題"

#: sunrpc/svc_tcp.c:179
msgid "svc_tcp.c - cannot getsockname or listen"
msgstr "svc_tcp.c - 無法 getsockname 或 listen"

#: sunrpc/svc_udp.c:137
msgid "svcudp_create: socket creation problem"
msgstr "svcudp_create: socket 建立有問題"

#: sunrpc/svc_udp.c:151
msgid "svcudp_create - cannot getsockname"
msgstr "svcudp_create - 無法 getsockname"

#: sunrpc/svc_udp.c:183
msgid "svcudp_create: xp_pad is too small for IP_PKTINFO\n"
msgstr "svcudp_create: xp_pad 太小以致於無法 IP_PKTINFO\n"

#: sunrpc/svc_udp.c:495
msgid "enablecache: cache already enabled"
msgstr "enablecache: 快取已經開啟"

#: sunrpc/svc_udp.c:501
msgid "enablecache: could not allocate cache"
msgstr "enablecache: 無法配置快取"

#: sunrpc/svc_udp.c:510
msgid "enablecache: could not allocate cache data"
msgstr "enablecache: 無法配置快取資料"

#: sunrpc/svc_udp.c:518
msgid "enablecache: could not allocate cache fifo"
msgstr "enablecache: 無法配置快取 fifo 管線"

#: sunrpc/svc_udp.c:554
msgid "cache_set: victim not found"
msgstr "cache_set: 找不到 victim"

#: sunrpc/svc_udp.c:565
msgid "cache_set: victim alloc failed"
msgstr "cache_set: victim 配置失敗"

#: sunrpc/svc_udp.c:572
msgid "cache_set: could not allocate new rpc_buffer"
msgstr "cache_set: 無法配置新的遠端程序呼叫緩衝區 (rpc_buffer)"

#: sunrpc/svc_unix.c:162
msgid "svc_unix.c - AF_UNIX socket creation problem"
msgstr "svc_unix.c - AF_UNIX socket 建立有問題"

#: sunrpc/svc_unix.c:178
msgid "svc_unix.c - cannot getsockname or listen"
msgstr "svc_unix.c - 無法 getsockname 或 listen"

#: sysdeps/generic/siglist.h:28
msgid "Hangup"
msgstr "掛斷"

#: sysdeps/generic/siglist.h:29
msgid "Interrupt"
msgstr "中斷"

#: sysdeps/generic/siglist.h:30
msgid "Quit"
msgstr "離開"

#: sysdeps/generic/siglist.h:31
msgid "Illegal instruction"
msgstr "不合法的命令"

#: sysdeps/generic/siglist.h:32
msgid "Trace/breakpoint trap"
msgstr "追蹤與中斷點陷阱"

#: sysdeps/generic/siglist.h:33
msgid "Aborted"
msgstr "已經終止"

#: sysdeps/generic/siglist.h:34
msgid "Floating point exception"
msgstr "浮點數出錯"

#: sysdeps/generic/siglist.h:35
msgid "Killed"
msgstr "已砍掉"

#: sysdeps/generic/siglist.h:36
msgid "Bus error"
msgstr "匯流排錯誤"

#: sysdeps/generic/siglist.h: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:38 sysdeps/gnu/errlist.c:359
msgid "Broken pipe"
msgstr "中斷的管線"

#: sysdeps/generic/siglist.h:39
msgid "Alarm clock"
msgstr "鬧鐘"

#: sysdeps/generic/siglist.h:40
msgid "Terminated"
msgstr "終止"

#: sysdeps/generic/siglist.h:41
msgid "Urgent I/O condition"
msgstr "緊急的輸出入狀態"

#: sysdeps/generic/siglist.h:42
msgid "Stopped (signal)"
msgstr "停止 (信號)"

#: sysdeps/generic/siglist.h:43
msgid "Stopped"
msgstr "停止"

#: sysdeps/generic/siglist.h:44
msgid "Continued"
msgstr "繼續"

#: sysdeps/generic/siglist.h:45
msgid "Child exited"
msgstr "子行程結束"

#: sysdeps/generic/siglist.h:46
msgid "Stopped (tty input)"
msgstr "停止 (tty 輸入)"

#: sysdeps/generic/siglist.h:47
msgid "Stopped (tty output)"
msgstr "停止 (tty 輸出)"

#: sysdeps/generic/siglist.h:48
msgid "I/O possible"
msgstr "I/O 可行"

#: sysdeps/generic/siglist.h:49
msgid "CPU time limit exceeded"
msgstr "CPU 時間上限超過了"

#: sysdeps/generic/siglist.h:50
msgid "File size limit exceeded"
msgstr "檔案大小超過上限"

#: sysdeps/generic/siglist.h:51
msgid "Virtual timer expired"
msgstr "虛擬計時器已過時取消了"

#: sysdeps/generic/siglist.h:52
msgid "Profiling timer expired"
msgstr "測速評估用的計時器已過時取消了"

#: sysdeps/generic/siglist.h:53
msgid "User defined signal 1"
msgstr "使用者定義的訊號 1"

#: sysdeps/generic/siglist.h:54
msgid "User defined signal 2"
msgstr "使用者定義的訊號 2"

#: sysdeps/generic/siglist.h:58
msgid "EMT trap"
msgstr "EMT 陷阱"

#: sysdeps/generic/siglist.h:61
msgid "Bad system call"
msgstr "錯誤的系統呼叫"

#: sysdeps/generic/siglist.h:64
msgid "Stack fault"
msgstr "堆疊錯誤"

#: sysdeps/generic/siglist.h:67
msgid "Information request"
msgstr "需要資料"

#: sysdeps/generic/siglist.h:69
msgid "Power failure"
msgstr "電源嚴重錯誤"

#: sysdeps/generic/siglist.h:72
msgid "Resource lost"
msgstr "資源漏失"

#: sysdeps/generic/siglist.h:75
msgid "Window changed"
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 on
#. TRANS @gnuhurdsystems{}.
#: 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 On @gnuhurdsystems{}, 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 "必須是區塊裝置 (Block device)"

#. 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 on @gnuhurdsystems{}.
#: 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 on @gnuhurdsystems{}; 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 "不合法的搜尋"

#. 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 @theglibc{}.
#. 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 @theglibc{}, 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 "Socket 在非 socket 上運作"

#. 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 "通訊端的協定錯誤型態"

#. 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.  On @gnuhurdsystems{}, 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 file handle.  This indicates an internal confusion in the
#. TRANS file system which is due to file system rearrangements on the server host
#. TRANS for NFS file systems or corruption in other file systems.
#. TRANS Repairing this condition usually requires unmounting, possibly repairing
#. TRANS and remounting the file system.
#: sysdeps/gnu/errlist.c:788
msgid "Stale 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 @gnuhurdsystems{}, making this error code impossible.)
#: sysdeps/gnu/errlist.c:800
msgid "Object is remote"
msgstr "目標檔案位於遠端"

#. TRANS ???
#: sysdeps/gnu/errlist.c:809
msgid "RPC struct is bad"
msgstr "RPC 結構是壞的"

#. TRANS ???
#: sysdeps/gnu/errlist.c:818
msgid "RPC version wrong"
msgstr "RPC 版本錯誤"

#. TRANS ???
#: sysdeps/gnu/errlist.c:827
msgid "RPC program not available"
msgstr "RPC 程式不存在"

#. TRANS ???
#: sysdeps/gnu/errlist.c:836
msgid "RPC program version wrong"
msgstr "RPC 程式版本錯誤"

#. TRANS ???
#: sysdeps/gnu/errlist.c:845
msgid "RPC bad procedure for program"
msgstr "程式的 RPC 程序錯誤"

#. TRANS No locks available.  This is used by the file locking facilities; see
#. TRANS @ref{File Locks}.  This error is never generated by @gnuhurdsystems{}, but
#. TRANS it can result from an operation to an NFS server running another
#. TRANS operating system.
#: sysdeps/gnu/errlist.c:857
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:870
msgid "Inappropriate file type or format"
msgstr "不希望的檔案型態或格式"

#. TRANS ???
#: sysdeps/gnu/errlist.c:879
msgid "Authentication error"
msgstr "鑑定錯誤"

#. TRANS ???
#: sysdeps/gnu/errlist.c:888
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:901
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:921
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:931
msgid "Invalid or incomplete multibyte or wide character"
msgstr "不適用或不完整的多位元組字元或寬字元"

#. TRANS On @gnuhurdsystems{}, 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:945
msgid "Inappropriate operation for background process"
msgstr "不希望的背景行程運作"

#. TRANS On @gnuhurdsystems{}, 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:956
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:967
msgid "?"
msgstr "?"

#. TRANS You did @strong{what}?
#: sysdeps/gnu/errlist.c:976
msgid "You really blew it this time"
msgstr "這次真的被您打敗了"

# This is error EIEIO, errno 104
#
# - Macro: int EIEIO
#     Go home and have a glass of warm, dairy-fresh milk.
#
# The following messages were copied & pasted
# from es.po by Santiago Vila Doncel <sanvila@unex.es>.
#
# <es.po>
#  穌u diablos es esto?, esperemos a tener las fuentes
#  estupendo, este error parece mostrarse en dos ocasiones
# - Macro: int EIEIO
#     Go home and have a glass of warm, dairy-fresh milk.
#  Jochen tambien lo traduce as.  em
#
# Okay.  Since you are dying to know, I'll tell you.
# This is a joke, obviously.  There is a children's song which begins,
# "Old McDonald had a farm, e-i-e-i-o."  Every time I see the (real)
# errno macro EIO, I think about that song.  Probably most of my
# compatriots who program on Unix do, too.  One of them must have stayed
# up a little too late one night and decided to add it to Hurd or Glibc.
# Whoever did it should be castigated, but it made me laugh.
#  --jtobey@channel1.com
#
# "bought the farm" means "died".  -jtobey
#
# Bueno, pues despu廥 de pensarlo mucho, he seguido el ejemplo de la
# traducci鏮 francesa (traducci鏮 libre). sv
# </es.po>
#
# 簡單的說，兒歌 "唐老先生有塊地..."，然後呢?? ;-p
#
#. TRANS Go home and have a glass of warm, dairy-fresh milk.
#: sysdeps/gnu/errlist.c:985
msgid "Computer bought the farm"
msgstr "這臺電腦買了一塊地囉"

#. TRANS This error code has no purpose.
#: sysdeps/gnu/errlist.c:994
msgid "Gratuitous error"
msgstr "無故的錯誤"

#: sysdeps/gnu/errlist.c:1002
msgid "Bad message"
msgstr "錯誤的訊息"

#: sysdeps/gnu/errlist.c:1010
msgid "Identifier removed"
msgstr "識別符號移除"

#: sysdeps/gnu/errlist.c:1018
msgid "Multihop attempted"
msgstr "嘗試 Multihop"

#: sysdeps/gnu/errlist.c:1026
msgid "No data available"
msgstr "沒有可用的資料"

#: sysdeps/gnu/errlist.c:1034
msgid "Link has been severed"
msgstr "連結已有服務"

#: sysdeps/gnu/errlist.c:1042
msgid "No message of desired type"
msgstr "沒有符合需求格式的訊息"

#: sysdeps/gnu/errlist.c:1050
msgid "Out of streams resources"
msgstr "所有資料流的資源都已用盡"

#: sysdeps/gnu/errlist.c:1058
msgid "Device not a stream"
msgstr "裝置不是資料流"

#: sysdeps/gnu/errlist.c:1066
msgid "Value too large for defined data type"
msgstr "有定義的資料型別值太大"

#: sysdeps/gnu/errlist.c:1074
msgid "Protocol error"
msgstr "協定錯誤"

#: sysdeps/gnu/errlist.c:1082
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:1094
msgid "Operation canceled"
msgstr "操作已被取消"

#: sysdeps/gnu/errlist.c:1102
msgid "Interrupted system call should be restarted"
msgstr "中斷的系統呼叫必須重新啟動"

#: sysdeps/gnu/errlist.c:1110
msgid "Channel number out of range"
msgstr "通道號碼超出範圍"

#: sysdeps/gnu/errlist.c:1118
msgid "Level 2 not synchronized"
msgstr "層級 2 沒有同步"

#: sysdeps/gnu/errlist.c:1126
msgid "Level 3 halted"
msgstr "層級 3 停止"

#: sysdeps/gnu/errlist.c:1134
msgid "Level 3 reset"
msgstr "層級 3 重設"

#: sysdeps/gnu/errlist.c:1142
msgid "Link number out of range"
msgstr "連結數目超過範圍"

#: sysdeps/gnu/errlist.c:1150
msgid "Protocol driver not attached"
msgstr "協定的驅動程式未連接"

#: sysdeps/gnu/errlist.c:1158
msgid "No CSI structure available"
msgstr "沒有可用的 CSI 結構了"

#: sysdeps/gnu/errlist.c:1166
msgid "Level 2 halted"
msgstr "層級 2 停止"

#: sysdeps/gnu/errlist.c:1174
msgid "Invalid exchange"
msgstr "不適用的交換"

#: sysdeps/gnu/errlist.c:1182
msgid "Invalid request descriptor"
msgstr "不適用的請求敘述項"

#: sysdeps/gnu/errlist.c:1190
msgid "Exchange full"
msgstr "交換已滿"

#: sysdeps/gnu/errlist.c:1198
msgid "No anode"
msgstr "沒有 anode"

#: sysdeps/gnu/errlist.c:1206
msgid "Invalid request code"
msgstr "不適用的請求碼"

#: sysdeps/gnu/errlist.c:1214
msgid "Invalid slot"
msgstr "不適用的 slot"

#: sysdeps/gnu/errlist.c:1222
msgid "File locking deadlock error"
msgstr "檔案鎖定停頓錯誤"

#: sysdeps/gnu/errlist.c:1230
msgid "Bad font file format"
msgstr "錯誤的字型檔格式"

#: sysdeps/gnu/errlist.c:1238
msgid "Machine is not on the network"
msgstr "機器不在網路中"

#: sysdeps/gnu/errlist.c:1246
msgid "Package not installed"
msgstr "套件並未安裝"

#: sysdeps/gnu/errlist.c:1254
msgid "Advertise error"
msgstr "通知錯誤"

#: sysdeps/gnu/errlist.c:1262
msgid "Srmount error"
msgstr "Srmount 錯誤"

#: sysdeps/gnu/errlist.c:1270
msgid "Communication error on send"
msgstr "在傳送時通訊錯誤"

#: sysdeps/gnu/errlist.c:1278
msgid "RFS specific error"
msgstr "RFS 特定錯誤"

#: sysdeps/gnu/errlist.c:1286
msgid "Name not unique on network"
msgstr "網路上的名稱不是唯一的"

#: sysdeps/gnu/errlist.c:1294
msgid "File descriptor in bad state"
msgstr "檔案敘述項處於錯誤狀態"

#: sysdeps/gnu/errlist.c:1302
msgid "Remote address changed"
msgstr "遠端位址改變了"

#: sysdeps/gnu/errlist.c:1310
msgid "Can not access a needed shared library"
msgstr "無法存取所需的分享函式庫"

#: sysdeps/gnu/errlist.c:1318
msgid "Accessing a corrupted shared library"
msgstr "存取一個毀掉的分享函式庫"

#: sysdeps/gnu/errlist.c:1326
msgid ".lib section in a.out corrupted"
msgstr "a.out 中 .lib 區段毀掉了"

#: sysdeps/gnu/errlist.c:1334
msgid "Attempting to link in too many shared libraries"
msgstr "嘗試去連結太多的分享資料庫"

#: sysdeps/gnu/errlist.c:1342
msgid "Cannot exec a shared library directly"
msgstr "不能直接執行一個分享函式庫"

#: sysdeps/gnu/errlist.c:1350
msgid "Streams pipe error"
msgstr "資料流管線錯誤"

#: sysdeps/gnu/errlist.c:1358
msgid "Structure needs cleaning"
msgstr "結構需要清理"

#: sysdeps/gnu/errlist.c:1366
msgid "Not a XENIX named type file"
msgstr "並非 XENIX 命名格式的檔案"

#: sysdeps/gnu/errlist.c:1374
msgid "No XENIX semaphores available"
msgstr "沒有可用的 XENIX 信號標誌了"

#: sysdeps/gnu/errlist.c:1382
msgid "Is a named type file"
msgstr "是個具名的型態檔案"

#: sysdeps/gnu/errlist.c:1390
msgid "Remote I/O error"
msgstr "遠端輸出入錯誤"

#: sysdeps/gnu/errlist.c:1398
msgid "No medium found"
msgstr "找不到媒體"

#: sysdeps/gnu/errlist.c:1406
msgid "Wrong medium type"
msgstr "錯誤的媒體型態"

#: sysdeps/gnu/errlist.c:1414
msgid "Required key not available"
msgstr "必要鍵值無法使用"

#: sysdeps/gnu/errlist.c:1422
msgid "Key has expired"
msgstr "鍵值已過期"

#: sysdeps/gnu/errlist.c:1430
msgid "Key has been revoked"
msgstr "鍵值已取消"

#: sysdeps/gnu/errlist.c:1438
msgid "Key was rejected by service"
msgstr "鍵值被服務所拒絕"

#: sysdeps/gnu/errlist.c:1446
msgid "Owner died"
msgstr "擁有者已消逝"

#: sysdeps/gnu/errlist.c:1454
msgid "State not recoverable"
msgstr "狀態無法回復"

#: sysdeps/gnu/errlist.c:1462
msgid "Operation not possible due to RF-kill"
msgstr "由於 RF-kill 而無法操作"

#: sysdeps/gnu/errlist.c:1470
msgid "Memory page has hardware error"
msgstr "記憶體分頁有硬體錯誤"

#: sysdeps/mach/_strerror.c:56
msgid "Error in unknown error system: "
msgstr "未知系統錯誤: "

#: sysdeps/posix/gai_strerror-strs.h:1
msgid "Address family for hostname not supported"
msgstr "hostname 的位址族群不支援"

#: 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 "不支援 ai_socktype 的伺服名稱"

#: 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/sysv/linux/i386/readelflib.c:65
#, c-format
msgid "%s is for unknown machine %d.\n"
msgstr "%s 是給未知的機器 %d。\n"

#: sysdeps/unix/sysv/linux/lddlibc4.c:60
#, c-format
msgid ""
"Usage: lddlibc4 FILE\n"
"\n"
msgstr ""
"用法：lddlibc4 檔案\n"
"\n"

#: sysdeps/unix/sysv/linux/lddlibc4.c:81
#, c-format
msgid "cannot open `%s'"
msgstr "無法開啟 `%s'"

#: sysdeps/unix/sysv/linux/lddlibc4.c:85
#, c-format
msgid "cannot read header from `%s'"
msgstr "無法從 `%s' 讀取標頭資料"

#: timezone/zdump.c:246
msgid "lacks alphabetic at start"
msgstr "lacks 字母順序於開始"

#: timezone/zdump.c:248
msgid "has fewer than 3 alphabetics"
msgstr "有更少的比 3 字母順序"

#: timezone/zdump.c:250
msgid "has more than 6 alphabetics"
msgstr "有超過 6 字母順序"

#: timezone/zdump.c:258
msgid "differs from POSIX standard"
msgstr "differs 從 POSIX 標準"

#: timezone/zdump.c:264
#, c-format
msgid "%s: warning: zone \"%s\" abbreviation \"%s\" %s\n"
msgstr "%s: 警告：區域「%s」縮寫「%s」%s\n"

#: timezone/zdump.c:273
#, c-format
msgid ""
"%s: usage is %s [ --version ] [ --help ] [ -v ] [ -c [loyear,]hiyear ] zonename ...\n"
"\n"
"Report bugs to %s.\n"
msgstr ""
"%s：用法為 %s [--version] [--help] [-v] [-c [低年分,]高年分 ] 區域名稱 ...\n"
"\n"
"將錯誤通報給 %s。\n"

#: timezone/zdump.c:340
#, c-format
msgid "%s: wild -c argument %s\n"
msgstr "%s: wild -c 引數 %s\n"

#: timezone/zdump.c:426
msgid "Error writing to standard output"
msgstr "寫入標準輸出時錯誤"

#: timezone/zdump.c:439
#, c-format
msgid "%s: use of -v on system with floating time_t other than float or double\n"
msgstr "%s: 使用 -v 於具備浮點數 time_t 的系統而非浮點數或雙倍精度\n"

#: timezone/zic.c:361
#, c-format
msgid "%s: Memory exhausted: %s\n"
msgstr "%s: 記憶體已用完: %s\n"

#: timezone/zic.c:401
#, c-format
msgid "\"%s\", line %d: %s"
msgstr "\"%s\", 第 %d 列: %s"

#: timezone/zic.c:404
#, c-format
msgid " (rule from \"%s\", line %d)"
msgstr " (規則來自 \"%s\", 第 %d 列)"

#: timezone/zic.c:415
msgid "warning: "
msgstr "警告: "

#: timezone/zic.c:425
#, c-format
msgid ""
"%s: usage is %s [ --version ] [ --help ] [ -v ] [ -l localtime ] [ -p posixrules ] \\\n"
"\t[ -d directory ] [ -L leapseconds ] [ -y yearistype ] [ filename ... ]\n"
"\n"
"Report bugs to %s.\n"
msgstr ""
"%s：用法為 %s [ --version ] [ --help ] [ -v ] [ -l 本地時間 ] [ -p POSIX規則 ] \\\n"
"\t[ -d 目錄 ] [ -L 跳躍秒數 ] [ -y 年分類型 ] [ 檔名 ... ]\n"
"\n"
"將錯誤通報給 %s。\n"

#: timezone/zic.c:460
msgid "wild compilation-time specification of zic_t"
msgstr "zic_t 的萬用編譯時間規格"

#: timezone/zic.c:479
#, c-format
msgid "%s: More than one -d option specified\n"
msgstr "%s: 您使用了超過一個 -d 選項\n"

#: timezone/zic.c:489
#, c-format
msgid "%s: More than one -l option specified\n"
msgstr "%s: 您使用了超過一個 -l 選項\n"

#: timezone/zic.c:499
#, c-format
msgid "%s: More than one -p option specified\n"
msgstr "%s: 您使用了超過一個 -p 選項\n"

#: timezone/zic.c:509
#, c-format
msgid "%s: More than one -y option specified\n"
msgstr "%s: 您使用了超過一個 -y 選項\n"

#: timezone/zic.c:519
#, c-format
msgid "%s: More than one -L option specified\n"
msgstr "%s: 您使用了超過一個 -L 選項\n"

#: timezone/zic.c:566
msgid "link to link"
msgstr "連結到連結"

#: timezone/zic.c:629
msgid "hard link failed, symbolic link used"
msgstr "實體連結失敗，使用符號連結代替"

#: timezone/zic.c:637
#, c-format
msgid "%s: Can't link from %s to %s: %s\n"
msgstr "%s: 無法從 %s 連結到 %s: %s\n"

#: timezone/zic.c:697 timezone/zic.c:699
msgid "same rule name in multiple files"
msgstr "在多個檔案裡面有相同的規則名稱"

#: timezone/zic.c:740
msgid "unruly zone"
msgstr "沒有規則的時區"

#: timezone/zic.c:747
#, c-format
msgid "%s in ruleless zone"
msgstr "%s 在沒有規則的區段"

#: timezone/zic.c:767
msgid "standard input"
msgstr "標準輸入"

#: timezone/zic.c:772
#, c-format
msgid "%s: Can't open %s: %s\n"
msgstr "%s: 無法開啟 %s: %s\n"

#: timezone/zic.c:783
msgid "line too long"
msgstr "列的長度過長"

#: timezone/zic.c:803
msgid "input line of unknown type"
msgstr "不明型別的輸入列"

#: timezone/zic.c:819
#, c-format
msgid "%s: Leap line in non leap seconds file %s\n"
msgstr "%s: 閏時設定列出現在不含閏秒的設定檔 %s 中\n"

#: timezone/zic.c:826 timezone/zic.c:1243 timezone/zic.c:1265
#, c-format
msgid "%s: panic: Invalid l_value %d\n"
msgstr "%s: 嚴重錯誤: 錯誤的 l_value %d\n"

#: timezone/zic.c:834
#, c-format
msgid "%s: Error reading %s\n"
msgstr "%s: 讀取錯誤 %s\n"

#: timezone/zic.c:841
#, c-format
msgid "%s: Error closing %s: %s\n"
msgstr "%s: 關閉錯誤 %s: %s\n"

#: timezone/zic.c:846
msgid "expected continuation line not found"
msgstr "找不到預期的接續列"

#: timezone/zic.c:887 timezone/zic.c:2413 timezone/zic.c:2427
msgid "time overflow"
msgstr "時間溢位"

#: timezone/zic.c:891
msgid "24:00 not handled by pre-1998 versions of zic"
msgstr "24:00 無法由早於 1998 的 zic 版本所處理"

#: timezone/zic.c:894
msgid "values over 24 hours not handled by pre-2007 versions of zic"
msgstr "24 小時以上的值無法由早於 2007 的 zic 版本所處理"

#: timezone/zic.c:905
msgid "wrong number of fields on Rule line"
msgstr "規則設定列的欄位數目錯誤"

#: timezone/zic.c:909
msgid "nameless rule"
msgstr "沒有名稱的規則"

#: timezone/zic.c:914
msgid "invalid saved time"
msgstr "無效的節約時間"

#: timezone/zic.c:932
msgid "wrong number of fields on Zone line"
msgstr "時區設定列的欄位數目錯誤"

#: timezone/zic.c:938
#, c-format
msgid "\"Zone %s\" line and -l option are mutually exclusive"
msgstr "\"區段 %s\" 列和 -l 選項是互斥的"

#: timezone/zic.c:946
#, c-format
msgid "\"Zone %s\" line and -p option are mutually exclusive"
msgstr "\"區段 %s\" 列和 -p 選項是互斥的"

#: timezone/zic.c:958
#, c-format
msgid "duplicate zone name %s (file \"%s\", line %d)"
msgstr "複製時區名稱 %s (檔案 \"%s\", 第 %d 列)"

#: timezone/zic.c:972
msgid "wrong number of fields on Zone continuation line"
msgstr "時區接續列的欄位數目不對"

#: timezone/zic.c:1009
msgid "invalid UTC offset"
msgstr "無效的 UTC 位移值"

#: timezone/zic.c:1012
msgid "invalid abbreviation format"
msgstr "無效的縮寫格式"

#: timezone/zic.c:1041
msgid "Zone continuation line end time is not after end time of previous line"
msgstr "時區接續列的結束時間不在上一列的結束時間之後"

#: timezone/zic.c:1066
msgid "wrong number of fields on Leap line"
msgstr "閏時設定列的欄位數目錯誤"

#: timezone/zic.c:1075
msgid "invalid leaping year"
msgstr "無效的閏年"

#: timezone/zic.c:1095 timezone/zic.c:1197
msgid "invalid month name"
msgstr "無效的月分名稱"

#: timezone/zic.c:1108 timezone/zic.c:1310 timezone/zic.c:1324
msgid "invalid day of month"
msgstr "無效的日期數字"

#: timezone/zic.c:1113
msgid "time before zero"
msgstr "在零之前的時間"

#: timezone/zic.c:1117
msgid "time too small"
msgstr "時間太小"

#: timezone/zic.c:1121
msgid "time too large"
msgstr "時間太大"

#: timezone/zic.c:1125 timezone/zic.c:1226
msgid "invalid time of day"
msgstr "無效的時間數字"

#: timezone/zic.c:1144
msgid "illegal CORRECTION field on Leap line"
msgstr "在閏時設定列中有不合法的 CORRECTION 欄位"

#: timezone/zic.c:1149
msgid "illegal Rolling/Stationary field on Leap line"
msgstr "在閏時設定列中有不合法的 Rolling/Stationary 欄位"

#: timezone/zic.c:1163
msgid "wrong number of fields on Link line"
msgstr "連結設定列的欄位數目錯誤"

#: timezone/zic.c:1167
msgid "blank FROM field on Link line"
msgstr "連結列中空白的 FROM 欄位"

#: timezone/zic.c:1171
msgid "blank TO field on Link line"
msgstr "連結列中空白的 TO 欄位"

#: timezone/zic.c:1247
msgid "invalid starting year"
msgstr "無效的起始年分"

#: timezone/zic.c:1269
msgid "invalid ending year"
msgstr "無效的結束年分"

#: timezone/zic.c:1273
msgid "starting year greater than ending year"
msgstr "起始年分比結束年分還要大"

#: timezone/zic.c:1280
msgid "typed single year"
msgstr "輸入的年分是同一年"

#: timezone/zic.c:1315
msgid "invalid weekday name"
msgstr "無效的工作日名稱"

#: timezone/zic.c:1481
#, c-format
msgid "%s: Can't remove %s: %s\n"
msgstr "%s: 無法移除 %s: %s\n"

#: timezone/zic.c:1491
#, c-format
msgid "%s: Can't create %s: %s\n"
msgstr "%s: 無法產生 %s: %s\n"

#: timezone/zic.c:1683
#, c-format
msgid "%s: Error writing %s\n"
msgstr "%s: 寫入錯誤 %s\n"

#: timezone/zic.c:1966
msgid "no POSIX environment variable for zone"
msgstr "無 POSIX 環境變數用於區"

#: timezone/zic.c:2133
msgid "can't determine time zone abbreviation to use just after until time"
msgstr "無法決定在結束時間以後該使用的時區簡寫"

#: timezone/zic.c:2177
msgid "too many transitions?!"
msgstr "太多時間轉換了?!"

#: timezone/zic.c:2192
msgid "internal error - addtype called with bad isdst"
msgstr "內部錯誤 - 用錯誤的 isdst 呼叫 addtype 函式"

#: timezone/zic.c:2196
msgid "internal error - addtype called with bad ttisstd"
msgstr "內部錯誤 - 用錯誤的 ttisstd 呼叫 addtype 函式"

#: timezone/zic.c:2200
msgid "internal error - addtype called with bad ttisgmt"
msgstr "內部錯誤 - 用錯誤的 ttisgmt 呼叫 addtype 函式"

#: timezone/zic.c:2219
msgid "too many local time types"
msgstr "太多本地時間格式"

#: timezone/zic.c:2223
msgid "UTC offset out of range"
msgstr "UTC 偏移超出範圍"

#: timezone/zic.c:2247
msgid "too many leap seconds"
msgstr "太多閏秒"

#: timezone/zic.c:2253
msgid "repeated leap second moment"
msgstr "重複的閏秒設定"

#: timezone/zic.c:2303
msgid "Wild result from command execution"
msgstr "命令執行導致奇怪的結果"

#: timezone/zic.c:2304
#, c-format
msgid "%s: command was '%s', result was %d\n"
msgstr "%s: 輸入命令為 '%s', 結果為 %d\n"

#: timezone/zic.c:2395
msgid "Odd number of quotation marks"
msgstr "引號數目為奇數"

#: timezone/zic.c:2472
msgid "use of 2/29 in non leap-year"
msgstr "在非閏年時用到 2/29 日"

#: timezone/zic.c:2507
msgid "rule goes past start/end of month--will not work with pre-2004 versions of zic"
msgstr "規則超過開始/結束月分--將無法適用早於 2004 的 zic 版本"

#: timezone/zic.c:2538
msgid "time zone abbreviation lacks alphabetic at start"
msgstr "時區縮寫開頭缺少字母"

#: timezone/zic.c:2540
msgid "time zone abbreviation has fewer than 3 alphabetics"
msgstr "時間區縮寫少於 3 個字母"

#: timezone/zic.c:2542
msgid "time zone abbreviation has too many alphabetics"
msgstr "時區縮寫太多字母"

#: timezone/zic.c:2552
msgid "time zone abbreviation differs from POSIX standard"
msgstr "時區縮寫與 POSIX 標準不同"

#: timezone/zic.c:2564
msgid "too many, or too long, time zone abbreviations"
msgstr "時區縮寫太多或者太長"

#: timezone/zic.c:2604
#, c-format
msgid "%s: Can't create directory %s: %s\n"
msgstr "%s: 無法建立目錄 %s: %s\n"

#: timezone/zic.c:2625
#, c-format
msgid "%s: %d did not sign extend correctly\n"
msgstr "%s: %d 無法正確地延展訊號\n"
