# Traditional Chinese Messages for libc
# Copyright (C) 2000, 05 Free Software Foundation, Inc.
# Tung-Han Hsieh <thhsieh@linux.org.tw>, 2000
# Yuan-Chung Cheng <platin@ch.ntu.edu.tw>, 2000
# Wei-Lun Chao <chaoweilun@pcmail.com.tw>, 2005
#
msgid ""
msgstr ""
"Project-Id-Version: libc 2.3.3\n"
"POT-Creation-Date: 2004-08-05 09:16+0200\n"
"PO-Revision-Date: 2005-07-26 11:27+0800\n"
"Last-Translator: Wei-Lun Chao <chaoweilun@pcmail.com.tw>\n"
"Language-Team: Chinese (traditional) <zh-l10n@linux.org.tw>\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"

#: sysdeps/generic/siglist.h:29 stdio-common/../sysdeps/unix/siglist.c:27
msgid "Hangup"
msgstr "掛斷"

#: sysdeps/generic/siglist.h:30 stdio-common/../sysdeps/unix/siglist.c:28
msgid "Interrupt"
msgstr "中斷"

#: sysdeps/generic/siglist.h:31 stdio-common/../sysdeps/unix/siglist.c:29
msgid "Quit"
msgstr "離開"

#: sysdeps/generic/siglist.h:32 stdio-common/../sysdeps/unix/siglist.c:30
msgid "Illegal instruction"
msgstr "不合法的命令"

#: sysdeps/generic/siglist.h:33 stdio-common/../sysdeps/unix/siglist.c:31
msgid "Trace/breakpoint trap"
msgstr "追蹤與中斷點陷阱"

#: sysdeps/generic/siglist.h:34
msgid "Aborted"
msgstr "已經終止"

#: sysdeps/generic/siglist.h:35 stdio-common/../sysdeps/unix/siglist.c:34
msgid "Floating point exception"
msgstr "浮點數出錯"

#: sysdeps/generic/siglist.h:36 stdio-common/../sysdeps/unix/siglist.c:35
msgid "Killed"
msgstr "已砍掉"

#: sysdeps/generic/siglist.h:37 stdio-common/../sysdeps/unix/siglist.c:36
msgid "Bus error"
msgstr "匯流排錯誤 (Bus error)"

#: sysdeps/generic/siglist.h:38 stdio-common/../sysdeps/unix/siglist.c:37
msgid "Segmentation fault"
msgstr "程式記憶體區段錯誤"

#. TRANS Broken pipe; there is no process reading from the other end of a pipe.
#. TRANS Every library function that returns this error code also generates a
#. TRANS @code{SIGPIPE} signal; this signal terminates the program if not handled
#. TRANS or blocked.  Thus, your program will never actually see @code{EPIPE}
#. TRANS unless it has handled or blocked @code{SIGPIPE}.
#: sysdeps/generic/siglist.h:39 stdio-common/../sysdeps/gnu/errlist.c:351
#: stdio-common/../sysdeps/unix/siglist.c:39
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:62
msgid "Broken pipe"
msgstr "中斷的 pipe"

#: sysdeps/generic/siglist.h:40 stdio-common/../sysdeps/unix/siglist.c:40
msgid "Alarm clock"
msgstr "鬧鐘"

#: sysdeps/generic/siglist.h:41 stdio-common/../sysdeps/unix/siglist.c:41
msgid "Terminated"
msgstr "終止"

#: sysdeps/generic/siglist.h:42 stdio-common/../sysdeps/unix/siglist.c:42
msgid "Urgent I/O condition"
msgstr "緊急的輸出入狀態"

#: sysdeps/generic/siglist.h:43 stdio-common/../sysdeps/unix/siglist.c:43
msgid "Stopped (signal)"
msgstr "停止 (信號)"

#: sysdeps/generic/siglist.h:44 stdio-common/../sysdeps/unix/siglist.c:44
msgid "Stopped"
msgstr "停止"

#: sysdeps/generic/siglist.h:45 stdio-common/../sysdeps/unix/siglist.c:45
msgid "Continued"
msgstr "繼續"

#: sysdeps/generic/siglist.h:46 stdio-common/../sysdeps/unix/siglist.c:46
msgid "Child exited"
msgstr "子行程結束"

#: sysdeps/generic/siglist.h:47 stdio-common/../sysdeps/unix/siglist.c:47
msgid "Stopped (tty input)"
msgstr "停止 (tty 輸入)"

#: sysdeps/generic/siglist.h:48 stdio-common/../sysdeps/unix/siglist.c:48
msgid "Stopped (tty output)"
msgstr "停止 (tty 輸出)"

#: sysdeps/generic/siglist.h:49 stdio-common/../sysdeps/unix/siglist.c:49
msgid "I/O possible"
msgstr "I/O 可行"

#: sysdeps/generic/siglist.h:50 stdio-common/../sysdeps/unix/siglist.c:50
msgid "CPU time limit exceeded"
msgstr "CPU 時間上限超過了"

#: sysdeps/generic/siglist.h:51 stdio-common/../sysdeps/unix/siglist.c:51
msgid "File size limit exceeded"
msgstr "檔案大小超過上限"

#: sysdeps/generic/siglist.h:52 stdio-common/../sysdeps/unix/siglist.c:52
msgid "Virtual timer expired"
msgstr "虛擬計時器已過時取消了"

#: sysdeps/generic/siglist.h:53 stdio-common/../sysdeps/unix/siglist.c:53
msgid "Profiling timer expired"
msgstr "測速評估用的計時器已過時取消了"

#: sysdeps/generic/siglist.h:54 stdio-common/../sysdeps/unix/siglist.c:54
msgid "Window changed"
msgstr "範圍改變了"

#: sysdeps/generic/siglist.h:55 stdio-common/../sysdeps/unix/siglist.c:56
msgid "User defined signal 1"
msgstr "使用者定義的訊號 1"

#: sysdeps/generic/siglist.h:56 stdio-common/../sysdeps/unix/siglist.c:57
msgid "User defined signal 2"
msgstr "使用者定義的訊號 2"

#: sysdeps/generic/siglist.h:60 stdio-common/../sysdeps/unix/siglist.c:33
msgid "EMT trap"
msgstr "EMT 陷阱"

#: sysdeps/generic/siglist.h:63 stdio-common/../sysdeps/unix/siglist.c:38
msgid "Bad system call"
msgstr "錯誤的系統呼叫"

#: sysdeps/generic/siglist.h:66
msgid "Stack fault"
msgstr "堆疊錯誤"

#: sysdeps/generic/siglist.h:69
msgid "Information request"
msgstr "需要資料"

#: sysdeps/generic/siglist.h:71
msgid "Power failure"
msgstr "電源嚴重錯誤"

#: sysdeps/generic/siglist.h:74 stdio-common/../sysdeps/unix/siglist.c:55
msgid "Resource lost"
msgstr "資源漏失"

#: sysdeps/mach/hurd/mips/dl-machine.c:68
#: string/../sysdeps/mach/_strerror.c:57
msgid "Error in unknown error system: "
msgstr "未知問題系統錯誤: "

#: sysdeps/mach/hurd/mips/dl-machine.c:83
#: string/../sysdeps/generic/_strerror.c:44
#: string/../sysdeps/mach/_strerror.c:87
msgid "Unknown error "
msgstr "未知的錯誤 "

#: sysdeps/unix/sysv/linux/lddlibc4.c:64
#, c-format
msgid "cannot open `%s'"
msgstr "無法開啟 `%s'"

#: sysdeps/unix/sysv/linux/lddlibc4.c:68
#, c-format
msgid "cannot read header from `%s'"
msgstr "無法從 `%s' 讀取標頭資料"

#: iconv/iconv_charmap.c:159 iconv/iconv_prog.c:295 catgets/gencat.c:288
#, c-format
msgid "cannot open input file `%s'"
msgstr "無法開啟輸入檔 `%s'"

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

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

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

#: iconv/iconv_charmap.c:507 iconv/iconv_charmap.c:543 iconv/iconv_prog.c:549
#: iconv/iconv_prog.c:585
msgid "error while reading the input"
msgstr "正在讀入資料的時候發生錯誤"

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

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

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

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

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

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

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

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

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

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

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

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

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

#: iconv/iconv_prog.c:201
msgid "cannot open output file"
msgstr "無法開啟輸出檔"

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

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

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

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

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

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

#: iconv/iconv_prog.c:409 iconv/iconvconfig.c:357 locale/programs/locale.c:279
#: locale/programs/localedef.c:372 catgets/gencat.c:233
#: malloc/memusagestat.c:602 debug/pcprofiledump.c:199
msgid "Report bugs using the `glibcbug' script to <bugs@gnu.org>.\n"
msgstr "請使用 `glibcbug' 命令稿將問題回報至 <bugs@gnu.org>。\n"

#: iconv/iconv_prog.c:423 iconv/iconvconfig.c:371 locale/programs/locale.c:292
#: locale/programs/localedef.c:386 catgets/gencat.c:246 posix/getconf.c:913
#: nss/getent.c:74 nscd/nscd.c:355 nscd/nscd_nischeck.c:90 elf/ldconfig.c:274
#: elf/sprof.c:349
#, 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"

#: iconv/iconv_prog.c:428 iconv/iconvconfig.c:376 locale/programs/locale.c:297
#: locale/programs/localedef.c:391 catgets/gencat.c:251 posix/getconf.c:918
#: nss/getent.c:79 nscd/nscd.c:360 nscd/nscd_nischeck.c:95 elf/ldconfig.c:279
#: elf/sprof.c:355
#, c-format
msgid "Written by %s.\n"
msgstr "作者 %s。\n"

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

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

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

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

#: iconv/iconv_prog.c:756
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:110
msgid "Create fastloading iconv module configuration file."
msgstr "建立快速載入 iconv 模組的設定檔案。"

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

#: iconv/iconvconfig.c:126
msgid "Prefix used for all file accesses"
msgstr "使用於所有檔案存取時的前置文字"

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

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

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

#: locale/programs/charmap-dir.c:59
#, c-format
msgid "cannot read character map directory `%s'"
msgstr "無法讀取字集對照檔目錄 `%s'"

#: locale/programs/charmap.c:136
#, c-format
msgid "character map file `%s' not found"
msgstr "找不到字集對照檔 `%s'"

#: locale/programs/charmap.c:194
#, c-format
msgid "default character map file `%s' not found"
msgstr "找不到預設的字集對照檔 `%s'"

#: locale/programs/charmap.c:257
#, 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:336
#, 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:356 locale/programs/charmap.c:373
#: locale/programs/repertoire.c:175
#, c-format
msgid "syntax error in prolog: %s"
msgstr "prolog 中有語法錯誤: %s"

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

#: locale/programs/charmap.c:374 locale/programs/locfile.c:126
#: locale/programs/locfile.c:153 locale/programs/repertoire.c:176
msgid "bad argument"
msgstr "錯誤的引數"

#: locale/programs/charmap.c:402
#, c-format
msgid "duplicate definition of <%s>"
msgstr "<%s> 的定義重複了"

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

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

#: locale/programs/charmap.c:444 locale/programs/repertoire.c:184
#, c-format
msgid "argument to <%s> must be a single character"
msgstr "給 <%s> 的引數必須是一個單字元"

#: locale/programs/charmap.c:470
msgid "character sets with locking states are not supported"
msgstr "不支援使用 locking 狀態的字元集"

#: locale/programs/charmap.c:497 locale/programs/charmap.c:551
#: locale/programs/charmap.c:583 locale/programs/charmap.c:677
#: locale/programs/charmap.c:732 locale/programs/charmap.c:773
#: locale/programs/charmap.c:814
#, c-format
msgid "syntax error in %s definition: %s"
msgstr "定義 %s 的語法錯誤: %s"

#: locale/programs/charmap.c:498 locale/programs/charmap.c:678
#: locale/programs/charmap.c:774 locale/programs/repertoire.c:231
msgid "no symbolic name given"
msgstr "沒有給予符號名稱"

#: locale/programs/charmap.c:552
msgid "invalid encoding given"
msgstr "給予的編碼是無效的"

#: locale/programs/charmap.c:561
msgid "too few bytes in character encoding"
msgstr "字元定義中的位元組太少了"

#: locale/programs/charmap.c:563
msgid "too many bytes in character encoding"
msgstr "字元定義中的位元組太多了"

#: locale/programs/charmap.c:585 locale/programs/charmap.c:733
#: locale/programs/charmap.c:816 locale/programs/repertoire.c:297
msgid "no symbolic name given for end of range"
msgstr "沒有給此區的最後一個字元符號名稱"

#: locale/programs/charmap.c:609 locale/programs/locfile.c:818
#: locale/programs/repertoire.c:314
#, c-format
msgid "`%1$s' definition does not end with `END %1$s'"
msgstr "`%1$s' 定義沒有以 `END %1$s' 結束"

#: locale/programs/charmap.c:642
msgid "only WIDTH definitions are allowed to follow the CHARMAP definition"
msgstr "只有 WIDTH 定義才能直接寫在 CHARMAP 定義之後"

#: locale/programs/charmap.c:650 locale/programs/charmap.c:713
#, c-format
msgid "value for %s must be an integer"
msgstr "%s 的值必須是整數才行"

#: locale/programs/charmap.c:841
#, c-format
msgid "%s: error in state machine"
msgstr "%s: 狀態機錯誤"

#: locale/programs/charmap.c:849 locale/programs/ld-address.c:605
#: locale/programs/ld-collate.c:2650 locale/programs/ld-collate.c:3818
#: locale/programs/ld-ctype.c:2225 locale/programs/ld-ctype.c:2994
#: locale/programs/ld-identification.c:469
#: locale/programs/ld-measurement.c:255 locale/programs/ld-messages.c:349
#: locale/programs/ld-monetary.c:958 locale/programs/ld-name.c:324
#: locale/programs/ld-numeric.c:392 locale/programs/ld-paper.c:258
#: locale/programs/ld-telephone.c:330 locale/programs/ld-time.c:1219
#: locale/programs/locfile.c:825 locale/programs/repertoire.c:325
#, c-format
msgid "%s: premature end of file"
msgstr "%s: 未完成已達檔案的末尾"

#: locale/programs/charmap.c:868 locale/programs/charmap.c:879
#, c-format
msgid "unknown character `%s'"
msgstr "不明的字元 `%s'"

#: locale/programs/charmap.c:887
#, 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:991 locale/programs/ld-collate.c:2930
#: locale/programs/repertoire.c:420
msgid "invalid names for character range"
msgstr "無效的字元範圍名稱"

#: locale/programs/charmap.c:1003 locale/programs/repertoire.c:432
msgid "hexadecimal range format should use only capital characters"
msgstr "在表示十六進位的範圍時只能用大寫的英文字母表示"

#: locale/programs/charmap.c:1021
#, c-format
msgid "<%s> and <%s> are illegal names for range"
msgstr "<%s> 以及 <%s> 是不合法的範圍名稱"

#: locale/programs/charmap.c:1027
msgid "upper limit in range is not higher then lower limit"
msgstr "區域定義中的最大值沒有比最小值還要大"

#: locale/programs/charmap.c:1085
msgid "resulting bytes for range not representable."
msgstr "用來定義範圍的位元組無法被表述出來"

#: locale/programs/ld-address.c:134 locale/programs/ld-collate.c:1534
#: locale/programs/ld-ctype.c:421 locale/programs/ld-identification.c:134
#: locale/programs/ld-measurement.c:95 locale/programs/ld-messages.c:98
#: locale/programs/ld-monetary.c:194 locale/programs/ld-name.c:95
#: locale/programs/ld-numeric.c:99 locale/programs/ld-paper.c:92
#: locale/programs/ld-telephone.c:95 locale/programs/ld-time.c:160
#, c-format
msgid "No definition for %s category found"
msgstr "找不到 %s 類別的定義"

#: locale/programs/ld-address.c:145 locale/programs/ld-address.c:183
#: locale/programs/ld-address.c:201 locale/programs/ld-address.c:228
#: locale/programs/ld-address.c:290 locale/programs/ld-address.c:309
#: locale/programs/ld-address.c:322 locale/programs/ld-identification.c:147
#: locale/programs/ld-measurement.c:106 locale/programs/ld-monetary.c:206
#: locale/programs/ld-monetary.c:250 locale/programs/ld-monetary.c:266
#: locale/programs/ld-monetary.c:278 locale/programs/ld-name.c:106
#: locale/programs/ld-name.c:143 locale/programs/ld-numeric.c:113
#: locale/programs/ld-numeric.c:127 locale/programs/ld-paper.c:103
#: locale/programs/ld-paper.c:112 locale/programs/ld-telephone.c:106
#: locale/programs/ld-telephone.c:163 locale/programs/ld-time.c:176
#: locale/programs/ld-time.c:197
#, c-format
msgid "%s: field `%s' not defined"
msgstr "%s: 欄位 `%s' 沒有定義"

#: locale/programs/ld-address.c:157 locale/programs/ld-address.c:209
#: locale/programs/ld-address.c:235 locale/programs/ld-address.c:265
#: locale/programs/ld-name.c:118 locale/programs/ld-telephone.c:118
#, c-format
msgid "%s: field `%s' must not be empty"
msgstr "%s: 欄位 `%s' 不可以空白"

#: locale/programs/ld-address.c:169
#, c-format
msgid "%s: invalid escape `%%%c' sequence in field `%s'"
msgstr "%s: 不適用的跳脫序列 `%%%c', 在欄位 `%s' 中"

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

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

#: locale/programs/ld-address.c:254 locale/programs/ld-address.c:282
#: locale/programs/ld-address.c:316 locale/programs/ld-address.c:328
#, c-format
msgid "%s: `%s' value does not match `%s' value"
msgstr "%s: `%s' 值與 `%s' 值不符合"

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

#: locale/programs/ld-address.c:497 locale/programs/ld-address.c:534
#: locale/programs/ld-address.c:572 locale/programs/ld-ctype.c:2601
#: locale/programs/ld-identification.c:365
#: locale/programs/ld-measurement.c:222 locale/programs/ld-messages.c:302
#: locale/programs/ld-monetary.c:700 locale/programs/ld-monetary.c:735
#: locale/programs/ld-monetary.c:776 locale/programs/ld-name.c:281
#: locale/programs/ld-numeric.c:264 locale/programs/ld-paper.c:225
#: locale/programs/ld-telephone.c:289 locale/programs/ld-time.c:1108
#: locale/programs/ld-time.c:1150
#, c-format
msgid "%s: field `%s' declared more than once"
msgstr "%s: `%s' 欄位不只一次地宣告"

#: locale/programs/ld-address.c:501 locale/programs/ld-address.c:539
#: locale/programs/ld-identification.c:369 locale/programs/ld-messages.c:312
#: locale/programs/ld-monetary.c:704 locale/programs/ld-monetary.c:739
#: locale/programs/ld-name.c:285 locale/programs/ld-numeric.c:268
#: locale/programs/ld-telephone.c:293 locale/programs/ld-time.c:1002
#: locale/programs/ld-time.c:1071 locale/programs/ld-time.c:1113
#, c-format
msgid "%s: unknown character in field `%s'"
msgstr "%s: 未知的字元在欄位 `%s' 中"

#: locale/programs/ld-address.c:586 locale/programs/ld-collate.c:3800
#: locale/programs/ld-ctype.c:2974 locale/programs/ld-identification.c:450
#: locale/programs/ld-measurement.c:236 locale/programs/ld-messages.c:331
#: locale/programs/ld-monetary.c:940 locale/programs/ld-name.c:306
#: locale/programs/ld-numeric.c:374 locale/programs/ld-paper.c:240
#: locale/programs/ld-telephone.c:312 locale/programs/ld-time.c:1201
#, c-format
msgid "%s: incomplete `END' line"
msgstr "%s: 不完整的 `END' 行"

#: locale/programs/ld-address.c:589 locale/programs/ld-collate.c:2653
#: locale/programs/ld-collate.c:3802 locale/programs/ld-ctype.c:2228
#: locale/programs/ld-ctype.c:2977 locale/programs/ld-identification.c:453
#: locale/programs/ld-measurement.c:239 locale/programs/ld-messages.c:333
#: locale/programs/ld-monetary.c:942 locale/programs/ld-name.c:308
#: locale/programs/ld-numeric.c:376 locale/programs/ld-paper.c:242
#: locale/programs/ld-telephone.c:314 locale/programs/ld-time.c:1203
#, c-format
msgid "%1$s: definition does not end with `END %1$s'"
msgstr "%1$s: 定義並沒有以 `END %1$s' 做為結束"

#: locale/programs/ld-address.c:596 locale/programs/ld-collate.c:523
#: locale/programs/ld-collate.c:575 locale/programs/ld-collate.c:871
#: locale/programs/ld-collate.c:884 locale/programs/ld-collate.c:2640
#: locale/programs/ld-collate.c:3809 locale/programs/ld-ctype.c:1956
#: locale/programs/ld-ctype.c:2215 locale/programs/ld-ctype.c:2799
#: locale/programs/ld-ctype.c:2985 locale/programs/ld-identification.c:460
#: locale/programs/ld-measurement.c:246 locale/programs/ld-messages.c:340
#: locale/programs/ld-monetary.c:949 locale/programs/ld-name.c:315
#: locale/programs/ld-numeric.c:383 locale/programs/ld-paper.c:249
#: locale/programs/ld-telephone.c:321 locale/programs/ld-time.c:1210
#, c-format
msgid "%s: syntax error"
msgstr "%s: 語法錯誤"

#: locale/programs/ld-collate.c:398
#, c-format
msgid "`%.*s' already defined in charmap"
msgstr "`%.*s' 在字集對照表中已經定義過了"

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

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

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

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

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

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

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

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

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

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

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

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

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

#: locale/programs/ld-collate.c:1150
#, c-format
msgid "%s: byte sequence of first character of sequence is not lower than that of the last character"
msgstr "%s: 第一個字元序列的位元組序列並沒有低於最後一個字元的位元組序列"

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

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

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

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

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

#: locale/programs/ld-collate.c:1550
#, 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:1575
#, c-format
msgid "symbol `%s' not defined"
msgstr "並未定義 `%s' 符號"

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

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

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

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

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

#: locale/programs/ld-collate.c:2771
#, c-format
msgid "%s: duplicate declaration of section `%s'"
msgstr "%s: 重複的 `%s' 區塊宣告"

#: locale/programs/ld-collate.c:2910
#, c-format
msgid "%s: unknown character in collating symbol name"
msgstr "%s: 未知的字元在對照符號名稱中"

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

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

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

#: locale/programs/ld-collate.c:3074
msgid "error while adding equivalent collating symbol"
msgstr "正在加入同義對照符號時發生錯誤"

#: locale/programs/ld-collate.c:3104
#, c-format
msgid "duplicate definition of script `%s'"
msgstr "敘述 `%s' 的定義重複了"

#: locale/programs/ld-collate.c:3152
#, c-format
msgid "%s: unknown section name `%s'"
msgstr "%s: 未知的區塊名稱 `%s'"

#: locale/programs/ld-collate.c:3180
#, c-format
msgid "%s: multiple order definitions for section `%s'"
msgstr "%s: `%s' 區塊中有多個順序定義"

#: locale/programs/ld-collate.c:3205
#, c-format
msgid "%s: invalid number of sorting rules"
msgstr "%s: 不適用的排序規則數目"

#: locale/programs/ld-collate.c:3232
#, c-format
msgid "%s: multiple order definitions for unnamed section"
msgstr "%s: 未命名的區塊中有多個順序定義"

#: locale/programs/ld-collate.c:3286 locale/programs/ld-collate.c:3414
#: locale/programs/ld-collate.c:3778
#, c-format
msgid "%s: missing `order_end' keyword"
msgstr "%s: 缺少 `order_end' 關鍵字"

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

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

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

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

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

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

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

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

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

#: locale/programs/ld-ctype.c:440
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
msgid "character <SP> not defined in character map"
msgstr "字元 <SP> 在字集對照檔中沒有定義"

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

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

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

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

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

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

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

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

#: locale/programs/ld-ctype.c:1547 locale/programs/ld-ctype.c:1672
#: locale/programs/ld-ctype.c:1778 locale/programs/ld-ctype.c:2464
#: locale/programs/ld-ctype.c:3460
#, c-format
msgid "%s: field `%s' does not contain exactly ten entries"
msgstr "%s: `%s' 欄位沒有精確包含十個項目"

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

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

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

#: locale/programs/ld-ctype.c:2072 locale/programs/ld-ctype.c:2123
#: locale/programs/ld-ctype.c:2165
msgid "syntax error"
msgstr "語法錯誤"

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

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

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

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

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

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

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

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

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

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

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

#: locale/programs/ld-ctype.c:3036
#, c-format
msgid "%s: character `%s' not defined in charmap while needed as default value"
msgstr "%s: 字元 `%s' 在字集對照表中沒有定義，但它是必需的預設值"

#: locale/programs/ld-ctype.c:3041 locale/programs/ld-ctype.c:3125
#: locale/programs/ld-ctype.c:3145 locale/programs/ld-ctype.c:3166
#: locale/programs/ld-ctype.c:3187 locale/programs/ld-ctype.c:3208
#: locale/programs/ld-ctype.c:3229 locale/programs/ld-ctype.c:3269
#: locale/programs/ld-ctype.c:3290 locale/programs/ld-ctype.c:3357
#, c-format
msgid "%s: character `%s' in charmap not representable with one byte"
msgstr "%s: 字集對照表中的字元 `%s' 無法表示為單一位元組"

#: locale/programs/ld-ctype.c:3120 locale/programs/ld-ctype.c:3140
#: locale/programs/ld-ctype.c:3182 locale/programs/ld-ctype.c:3203
#: locale/programs/ld-ctype.c:3224 locale/programs/ld-ctype.c:3264
#: locale/programs/ld-ctype.c:3285 locale/programs/ld-ctype.c:3352
#: locale/programs/ld-ctype.c:3394 locale/programs/ld-ctype.c:3419
#, c-format
msgid "%s: character `%s' not defined while needed as default value"
msgstr "%s: 字元 `%s' 沒有定義，但它是必需的預設值"

#: locale/programs/ld-ctype.c:3161
#, c-format
msgid "character `%s' not defined while needed as default value"
msgstr "必須用來作為預設值的字元 `%s' 沒有被定義到"

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

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

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

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

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

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

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

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

#: locale/programs/ld-measurement.c:114
#, c-format
msgid "%s: invalid value for field `%s'"
msgstr "%s: 在欄位 `%s' 中的值不適用"

#: locale/programs/ld-messages.c:115 locale/programs/ld-messages.c:149
#, c-format
msgid "%s: field `%s' undefined"
msgstr "%s: 欄位 `%s' 沒有定義"

#: locale/programs/ld-messages.c:122 locale/programs/ld-messages.c:156
#, c-format
msgid "%s: value for field `%s' must not be an empty string"
msgstr "%s: 欄位 `%s' 值不可以是空字串"

#: locale/programs/ld-messages.c:138 locale/programs/ld-messages.c:172
#, c-format
msgid "%s: no correct regular expression for field `%s': %s"
msgstr "%s: 沒有給欄位 `%s' 正確的常規表示式： %s"

#: locale/programs/ld-monetary.c:224
#, c-format
msgid "%s: value of field `int_curr_symbol' has wrong length"
msgstr "%s: 欄位 `int_curr_symbol' 值的長度錯誤"

#: locale/programs/ld-monetary.c:237
#, c-format
msgid "%s: value of field `int_curr_symbol' does not correspond to a valid name in ISO 4217"
msgstr "%s: 欄位 `int_curr_symbol' 值並不是 ISO 4217 中合法的名稱"

#: locale/programs/ld-monetary.c:256 locale/programs/ld-numeric.c:119
#, c-format
msgid "%s: value for field `%s' must not be the empty string"
msgstr "%s: 欄位 `%s' 值不可以是空字串"

#: 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:275
#, 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:319
#, 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:340
#, 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:130 locale/programs/ld-telephone.c:127
#: locale/programs/ld-telephone.c:150
#, c-format
msgid "%s: invalid escape sequence in field `%s'"
msgstr "%s: 在欄位 `%s' 中的跳脫序列不適用"

#: locale/programs/ld-time.c:248
#, c-format
msgid "%s: direction flag in string %Zd in `era' field is not '+' nor '-'"
msgstr "%s: 在 `era' 欄位的字串 %Zd 中，方向旗標既不是 '+' 也不是 '-'"

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

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

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

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

#: locale/programs/ld-time.c:417
#, 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:436
#, c-format
msgid "%s: stopping date is invalid in string %Zd in `era' field"
msgstr "%s: 在 `era' 區域的字串 %Zd 中的結束日期是不適用的"

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

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

#: locale/programs/ld-time.c:486
#, 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:494 locale/programs/ld-time.c:502
#, c-format
msgid "%s: values of field `%s' must not be larger than %d"
msgstr "%s: 欄位 `%s' 的值不可以大於 %d"

#: locale/programs/ld-time.c:510
#, c-format
msgid "%s: values for field `%s' must not be larger than %d"
msgstr "%s: 欄位 `%s' 的值不可以大於 %d"

#: locale/programs/ld-time.c:986
#, c-format
msgid "%s: too few values for field `%s'"
msgstr "%s: 欄位 `%s' 中的值太少"

#: locale/programs/ld-time.c:1031
msgid "extra trailing semicolon"
msgstr "多出的尾端分號"

#: locale/programs/ld-time.c:1034
#, 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:304
msgid "garbage at end of number"
msgstr "號碼結束位置的無用資料"

#: locale/programs/linereader.c:416
msgid "garbage at end of character code specification"
msgstr "字元編碼設定結束位置的無用資料"

#: locale/programs/linereader.c:502
msgid "unterminated symbolic name"
msgstr "沒有結尾的符號名稱"

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

#: locale/programs/linereader.c:629
msgid "illegal escape sequence at end of string"
msgstr "字串結尾有不合法的跳脫序列"

#: locale/programs/linereader.c:633 locale/programs/linereader.c:861
msgid "unterminated string"
msgstr "沒有結尾的字串"

#: locale/programs/linereader.c:675
msgid "non-symbolic character value should not be used"
msgstr "非符號性的字元值不應該被使用才對"

#: locale/programs/linereader.c:822
#, c-format
msgid "symbol `%.*s' not in charmap"
msgstr "符號 `%.*s' 並不在字集對照表中"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: locale/programs/locale.c:517
msgid "while preparing output"
msgstr "在準備輸出時"

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

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

#: locale/programs/localedef.c:124
msgid "Source definitions are found in FILE"
msgstr "原始資料定義在檔案 FILE 中"

#: locale/programs/localedef.c:126
msgid "FILE contains mapping from symbolic names to UCS4 values"
msgstr "檔案 FILE 內含符號名與 UCS4 編碼之間的對映"

#: locale/programs/localedef.c:130
msgid "Create output even if warning messages were issued"
msgstr "產生輸出即使是有警告訊息"

#: locale/programs/localedef.c:131
msgid "Create old-style tables"
msgstr "產生舊格式的表格"

#: locale/programs/localedef.c:132
msgid "Optional output file prefix"
msgstr "可有可無的輸出檔路徑"

#: locale/programs/localedef.c:133
msgid "Be strictly POSIX conform"
msgstr "嚴格遵從 POSIX"

#: locale/programs/localedef.c:135
msgid "Suppress warnings and information messages"
msgstr "忽略警告與提示訊息"

#: locale/programs/localedef.c:136
msgid "Print more messages"
msgstr "印出更多的訊息"

#: locale/programs/localedef.c:137
msgid "Archive control:"
msgstr "保存檔控制:"

#: locale/programs/localedef.c:139
msgid "Don't add new data to archive"
msgstr "不要加入新資料到保存檔"

#: locale/programs/localedef.c:141
msgid "Add locales named by parameters to archive"
msgstr "藉由參數加入語區名稱到保存檔"

#: locale/programs/localedef.c:142
msgid "Replace existing archive content"
msgstr "替換已有的保存檔內容"

#: locale/programs/localedef.c:144
msgid "Remove locales named by parameters from archive"
msgstr "藉由參數從保存檔中刪除語區名稱"

#: locale/programs/localedef.c:145
msgid "List content of archive"
msgstr "列出保存檔的內容"

#: locale/programs/localedef.c:147
msgid "locale.alias file to consult when making archive"
msgstr "製作保存檔時查閱 locale.alias 檔案"

#: locale/programs/localedef.c:152
msgid "Compile locale specification"
msgstr "編譯語區資料規格"

#: locale/programs/localedef.c:155
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:233
msgid "cannot create directory for output files"
msgstr "無法為輸出檔建立目錄"

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

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

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

#: locale/programs/localedef.c:367
#, c-format
msgid ""
"System's directory for character maps : %s\n"
"                       repertoire maps: %s\n"
"                       locale path    : %s\n"
"%s"
msgstr ""
"系統的字集對照檔 (character maps) 目錄   : %s\n"
"      編碼對映檔 (repertoire maps) 目錄  : %s\n"
"      語區資料路徑         : %s\n"
"%s"

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

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

#: locale/programs/locarchive.c:89 locale/programs/locarchive.c:259
msgid "cannot create temporary file"
msgstr "無法產生暫時檔"

#: locale/programs/locarchive.c:118 locale/programs/locarchive.c:305
msgid "cannot initialize archive file"
msgstr "無法起始保存檔"

#: locale/programs/locarchive.c:125 locale/programs/locarchive.c:312
msgid "cannot resize archive file"
msgstr "無法改變保存檔大小"

#: locale/programs/locarchive.c:134 locale/programs/locarchive.c:321
#: locale/programs/locarchive.c:511
msgid "cannot map archive header"
msgstr "無法註記保存檔表頭"

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

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

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

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

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

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

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

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

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

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

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

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

#: locale/programs/locarchive.c:788 locale/programs/locarchive.c:803
#: locale/programs/locarchive.c:815 locale/programs/locarchive.c:827
#: locale/programs/locfile.c:343
msgid "cannot add to locale archive"
msgstr "無法加入語區資料保存檔"

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

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

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

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

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

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

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

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

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

#: locale/programs/locfile.c: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 "expect string argument for `copy'"
msgstr "`copy' 的參數應該是字串才對"

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

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

#: locale/programs/repertoire.c:230 locale/programs/repertoire.c:271
#: locale/programs/repertoire.c:296
#, c-format
msgid "syntax error in repertoire map definition: %s"
msgstr "編碼對映檔中的定義有語法錯誤: %s"

#: locale/programs/repertoire.c:272
msgid "no <Uxxxx> or <Uxxxxxxxx> value given"
msgstr "沒有給定 <Uxxxx> 或 <Uxxxxxxxx> 的值"

#: locale/programs/repertoire.c:332
msgid "cannot save new repertoire map"
msgstr "無法儲存新的編碼對映檔"

#: locale/programs/repertoire.c:343
#, c-format
msgid "repertoire map file `%s' not found"
msgstr "找不到編碼對映檔 `%s'"

#: locale/programs/repertoire.c:450
#, c-format
msgid "<%s> and <%s> are invalid names for range"
msgstr "<%s> 以及 <%s> 是不適用的範圍名稱"

#: locale/programs/repertoire.c:457
msgid "upper limit in range is not smaller then lower limit"
msgstr "區域定義中的最大值沒有比最小值還要小"

#: locale/programs/xmalloc.c:70 malloc/obstack.c:505 malloc/obstack.c:508
#: posix/getconf.c:1007
msgid "memory exhausted"
msgstr "記憶體耗盡"

#: assert/assert-perr.c:57
#, c-format
msgid "%s%s%s:%u: %s%sUnexpected error: %s.\n"
msgstr "%s%s%s:%u: %s%s無法預料的錯誤: %s。\n"

#: assert/assert.c:56
#, c-format
msgid "%s%s%s:%u: %s%sAssertion `%s' failed.\n"
msgstr "%s%s%s:%u: %s%sAssertion `%s' 失敗。\n"

#: intl/tst-codeset.c:40 intl/tst-codeset.c:50
msgid "cheese"
msgstr "請微笑"

#: intl/tst-gettext2.c:37
msgid "First string for testing."
msgstr "第一個字串接受測試。"

#: intl/tst-gettext2.c:38
msgid "Another string for testing."
msgstr "另一個受測試的字串。"

#: catgets/gencat.c:111 catgets/gencat.c:115 nscd/nscd.c:88
msgid "NAME"
msgstr "名稱"

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

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

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

#: catgets/gencat.c:120
msgid ""
"Generate message catalog.If 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:125
msgid ""
"-o OUTPUT-FILE [INPUT-FILE]...\n"
"[OUTPUT-FILE [INPUT-FILE]...]"
msgstr ""
"-o 輸出檔案名稱 [輸入檔案名稱]...\n"
"[輸出檔案名稱 [輸入檔案名稱]...]"

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

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

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

#: catgets/gencat.c:446 catgets/gencat.c:623 catgets/gencat.c:677
msgid "this is the first definition"
msgstr "此為第一個定義"

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

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

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

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

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

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

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

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

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

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

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

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

#: catgets/gencat.c:1358
msgid "cannot determine escape character"
msgstr "無法決定跳脫 (escape) 字元"

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

#: stdio-common/../sysdeps/gnu/errlist.c:12 posix/regcomp.c:147
#: nis/nis_error.c:29 nis/ypclnt.c:778 nis/ypclnt.c:852
msgid "Success"
msgstr "成功"

#. TRANS Operation not permitted; only the owner of the file (or other resource)
#. TRANS or processes with special privileges can perform the operation.
#: stdio-common/../sysdeps/gnu/errlist.c:17
msgid "Operation not permitted"
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.
#: stdio-common/../sysdeps/gnu/errlist.c:28
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:32
msgid "No such file or directory"
msgstr "沒有此一檔案或目錄"

#. TRANS No process matches the specified process ID.
#: stdio-common/../sysdeps/gnu/errlist.c:37
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:33
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}.
#: stdio-common/../sysdeps/gnu/errlist.c:52
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:34
msgid "Interrupted system call"
msgstr "中斷的系統呼叫"

#. TRANS Input/output error; usually used for physical read or write errors.
#: stdio-common/../sysdeps/gnu/errlist.c:61
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.
#: stdio-common/../sysdeps/gnu/errlist.c:74
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:36
msgid "No such device or address"
msgstr "沒有此一裝置或位址"

#. TRANS Argument list too long; used when the arguments passed to a new program
#. TRANS being executed with one of the @code{exec} functions (@pxref{Executing a
#. TRANS File}) occupy too much memory space.  This condition never arises in the
#. TRANS GNU system.
#: stdio-common/../sysdeps/gnu/errlist.c:86
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}.
#: stdio-common/../sysdeps/gnu/errlist.c:96
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:38
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).
#: stdio-common/../sysdeps/gnu/errlist.c:107
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.
#: stdio-common/../sysdeps/gnu/errlist.c:118
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:40
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.
#: stdio-common/../sysdeps/gnu/errlist.c:130
msgid "Resource deadlock avoided"
msgstr "避開資源鎖定"

#. TRANS No memory available.  The system cannot allocate more virtual memory
#. TRANS because its capacity is full.
#: stdio-common/../sysdeps/gnu/errlist.c:140
msgid "Cannot allocate memory"
msgstr "無法配置記憶體"

#. TRANS Permission denied; the file permissions do not allow the attempted operation.
#: stdio-common/../sysdeps/gnu/errlist.c:149
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:43
#: nis/nis_error.c:39 nis/ypclnt.c:808
msgid "Permission denied"
msgstr "拒絕不符權限的操作"

#. TRANS Bad address; an invalid pointer was detected.
#. TRANS In the GNU system, this error never happens; you get a signal instead.
#: stdio-common/../sysdeps/gnu/errlist.c:159
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:44
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.
#: stdio-common/../sysdeps/gnu/errlist.c:170
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:45
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.
#: stdio-common/../sysdeps/gnu/errlist.c:181
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.
#: stdio-common/../sysdeps/gnu/errlist.c:191
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:47
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}).
#: stdio-common/../sysdeps/gnu/errlist.c:202
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.
#: stdio-common/../sysdeps/gnu/errlist.c:212
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:49
msgid "No such device"
msgstr "沒有此一裝置"

#. TRANS A file that isn't a directory was specified when a directory is required.
#: stdio-common/../sysdeps/gnu/errlist.c:221
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:50
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.
#: stdio-common/../sysdeps/gnu/errlist.c:231
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:51
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.
#: stdio-common/../sysdeps/gnu/errlist.c:241
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:52
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}.
#: stdio-common/../sysdeps/gnu/errlist.c:256
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:54
msgid "Too many open files"
msgstr "開啟太多檔案"

#. TRANS There are too many distinct file openings in the entire system.  Note
#. TRANS that any number of linked channels count as just one file opening; see
#. TRANS @ref{Linked Channels}.  This error never occurs in the GNU system.
#: stdio-common/../sysdeps/gnu/errlist.c:267
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.
#: stdio-common/../sysdeps/gnu/errlist.c:277
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:55
msgid "Inappropriate ioctl for device"
msgstr "不希望的裝置輸出入控制 (ioctl)"

#. TRANS An attempt to execute a file that is currently open for writing, or
#. TRANS write to a file that is currently being executed.  Often using a
#. TRANS debugger to run a program is considered having it open for writing and
#. TRANS will cause this error.  (The name stands for ``text file busy''.)  This
#. TRANS is not an error in the GNU system; the text is copied as necessary.
#: stdio-common/../sysdeps/gnu/errlist.c:290
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:56
msgid "Text file busy"
msgstr "文字檔忙錄中"

#. TRANS File too big; the size of a file would be larger than allowed by the system.
#: stdio-common/../sysdeps/gnu/errlist.c:299
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:57
msgid "File too large"
msgstr "檔案太大"

#. TRANS No space left on device; write operation on a file failed because the
#. TRANS disk is full.
#: stdio-common/../sysdeps/gnu/errlist.c:309
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:58
msgid "No space left on device"
msgstr "裝置上已無多餘空間"

#. TRANS Invalid seek operation (such as on a pipe).
#: stdio-common/../sysdeps/gnu/errlist.c:318
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:59
msgid "Illegal seek"
msgstr "不合法的搜尋"

#. TRANS An attempt was made to modify something on a read-only file system.
#: stdio-common/../sysdeps/gnu/errlist.c:327
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:60
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}).
#: stdio-common/../sysdeps/gnu/errlist.c:338
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:61
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.
#: stdio-common/../sysdeps/gnu/errlist.c:361
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.
#: stdio-common/../sysdeps/gnu/errlist.c:371
msgid "Numerical result out of range"
msgstr "數值運算結果超出範圍"

#. TRANS Resource temporarily unavailable; the call might work if you try again
#. TRANS later.  The macro @code{EWOULDBLOCK} is another name for @code{EAGAIN};
#. TRANS they are always the same in the GNU C library.
#. TRANS
#. TRANS This error can happen in a few different situations:
#. TRANS
#. TRANS @itemize @bullet
#. TRANS @item
#. TRANS An operation that would block was attempted on an object that has
#. TRANS non-blocking mode selected.  Trying the same operation again will block
#. TRANS until some external condition makes it possible to read, write, or
#. TRANS connect (whatever the operation).  You can use @code{select} to find out
#. TRANS when the operation will be possible; @pxref{Waiting for I/O}.
#. TRANS
#. TRANS @strong{Portability Note:} In many older Unix systems, this condition
#. TRANS was indicated by @code{EWOULDBLOCK}, which was a distinct error code
#. TRANS different from @code{EAGAIN}.  To make your program portable, you should
#. TRANS check for both codes and treat them the same.
#. TRANS
#. TRANS @item
#. TRANS A temporary resource shortage made an operation impossible.  @code{fork}
#. TRANS can return this error.  It indicates that the shortage is expected to
#. TRANS pass, so your program can try the call again later and it may succeed.
#. TRANS It is probably a good idea to delay for a few seconds before trying it
#. TRANS again, to allow time for other processes to release scarce resources.
#. TRANS Such shortages are usually fairly serious and affect the whole system,
#. TRANS so usually an interactive program should report the error to the user
#. TRANS and return to its command loop.
#. TRANS @end itemize
#: stdio-common/../sysdeps/gnu/errlist.c:408
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:41
msgid "Resource temporarily unavailable"
msgstr "資源暫時無法取得"

#. TRANS In the GNU C library, this is another name for @code{EAGAIN} (above).
#. TRANS The values are always the same, on every operating system.
#. TRANS
#. TRANS C libraries in many older Unix systems have @code{EWOULDBLOCK} as a
#. TRANS separate error code.
#: stdio-common/../sysdeps/gnu/errlist.c:421
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}.
#: stdio-common/../sysdeps/gnu/errlist.c:437
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:180
msgid "Operation now in progress"
msgstr "操作正在處理中"

#. TRANS An operation is already in progress on an object that has non-blocking
#. TRANS mode selected.
#: stdio-common/../sysdeps/gnu/errlist.c:447
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:179
msgid "Operation already in progress"
msgstr "此項操作已經在處理當中"

#. TRANS A file that isn't a socket was specified when a socket is required.
#: stdio-common/../sysdeps/gnu/errlist.c:456
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:125
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.
#: stdio-common/../sysdeps/gnu/errlist.c:466
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:127
msgid "Message too long"
msgstr "訊息太長"

#. TRANS The socket type does not support the requested communications protocol.
#: stdio-common/../sysdeps/gnu/errlist.c:475
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:128
msgid "Protocol wrong type for socket"
msgstr "socket 的協定錯誤型態"

#. TRANS You specified a socket option that doesn't make sense for the
#. TRANS particular protocol being used by the socket.  @xref{Socket Options}.
#: stdio-common/../sysdeps/gnu/errlist.c:485
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}.
#: stdio-common/../sysdeps/gnu/errlist.c:496
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:150
msgid "Protocol not supported"
msgstr "協定不支援"

#. TRANS The socket type is not supported.
#: stdio-common/../sysdeps/gnu/errlist.c:505
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:151
msgid "Socket type not supported"
msgstr "Socket 型別不支援"

#. TRANS The operation you requested is not supported.  Some socket functions
#. TRANS don't make sense for all types of sockets, and others may not be
#. TRANS implemented for all communications protocols.  In the GNU system, this
#. TRANS error can happen for many calls when the object does not support the
#. TRANS particular operation; it is a generic indication that the server knows
#. TRANS nothing to do for that call.
#: stdio-common/../sysdeps/gnu/errlist.c:519
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:78
msgid "Operation not supported"
msgstr "此項操作並不被支援"

#. TRANS The socket communications protocol family you requested is not supported.
#: stdio-common/../sysdeps/gnu/errlist.c:528
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:153
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}.
#: stdio-common/../sysdeps/gnu/errlist.c:538
msgid "Address family not supported by protocol"
msgstr "位址族群不被協定所支援"

#. TRANS The requested socket address is already in use.  @xref{Socket Addresses}.
#: stdio-common/../sysdeps/gnu/errlist.c:547
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:155
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}.
#: stdio-common/../sysdeps/gnu/errlist.c:558
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:156
msgid "Cannot assign requested address"
msgstr "無法指定所需的位址"

#. TRANS A socket operation failed because the network was down.
#: stdio-common/../sysdeps/gnu/errlist.c:567
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:157
msgid "Network is down"
msgstr "網路停擺"

#. TRANS A socket operation failed because the subnet containing the remote host
#. TRANS was unreachable.
#: stdio-common/../sysdeps/gnu/errlist.c:577
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:158
msgid "Network is unreachable"
msgstr "無法接觸網路"

#. TRANS A network connection was reset because the remote host crashed.
#: stdio-common/../sysdeps/gnu/errlist.c:586
msgid "Network dropped connection on reset"
msgstr "在重設時網路連線漏失"

#. TRANS A network connection was aborted locally.
#: stdio-common/../sysdeps/gnu/errlist.c:595
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:160
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.
#: stdio-common/../sysdeps/gnu/errlist.c:606
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:161
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.
#: stdio-common/../sysdeps/gnu/errlist.c:617
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:162
msgid "No buffer space available"
msgstr "沒有可用的緩衝空間了"

#. TRANS You tried to connect a socket that is already connected.
#. TRANS @xref{Connecting}.
#: stdio-common/../sysdeps/gnu/errlist.c:627
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:163
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.
#: stdio-common/../sysdeps/gnu/errlist.c:639
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:164
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}.
#: stdio-common/../sysdeps/gnu/errlist.c:650
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:126
msgid "Destination address required"
msgstr "需要目標位址"

#. TRANS The socket has already been shut down.
#: stdio-common/../sysdeps/gnu/errlist.c:659
msgid "Cannot send after transport endpoint shutdown"
msgstr "無法在輸送端點關閉後傳送"

#. TRANS ???
#: stdio-common/../sysdeps/gnu/errlist.c:668
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:174
msgid "Too many references: cannot splice"
msgstr "太多的參考指標: 無法連接"

#. TRANS A socket operation with a specified timeout received no response during
#. TRANS the timeout period.
#: stdio-common/../sysdeps/gnu/errlist.c:678
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:175
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).
#: stdio-common/../sysdeps/gnu/errlist.c:688
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:176
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.
#: stdio-common/../sysdeps/gnu/errlist.c:698
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}).
#: stdio-common/../sysdeps/gnu/errlist.c:709
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:108
msgid "File name too long"
msgstr "檔名太長"

#. TRANS The remote host for a requested network connection is down.
#: stdio-common/../sysdeps/gnu/errlist.c:718
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:177
msgid "Host is down"
msgstr "遠端系統已停機了"

#. TRANS The remote host for a requested network connection is not reachable.
#: stdio-common/../sysdeps/gnu/errlist.c:727
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:178
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.
#: stdio-common/../sysdeps/gnu/errlist.c:737
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:123
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.
#: stdio-common/../sysdeps/gnu/errlist.c:748
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.
#: stdio-common/../sysdeps/gnu/errlist.c:758
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:124
msgid "Too many users"
msgstr "太多使用者"

#. TRANS The user's disk quota was exceeded.
#: stdio-common/../sysdeps/gnu/errlist.c:767
msgid "Disk quota exceeded"
msgstr "硬碟 quota 滿了"

#. TRANS Stale NFS file handle.  This indicates an internal confusion in the NFS
#. TRANS system which is due to file system rearrangements on the server host.
#. TRANS Repairing this condition usually requires unmounting and remounting
#. TRANS the NFS file system on the local host.
#: stdio-common/../sysdeps/gnu/errlist.c:779
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:181
msgid "Stale NFS file handle"
msgstr "過舊的 NFS 檔案控制碼"

#. TRANS An attempt was made to NFS-mount a remote file system with a file name that
#. TRANS already specifies an NFS-mounted file.
#. TRANS (This is an error on some operating systems, but we expect it to work
#. TRANS properly on the GNU system, making this error code impossible.)
#: stdio-common/../sysdeps/gnu/errlist.c:791
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:96
msgid "Object is remote"
msgstr "目標檔案位於遠端"

#. TRANS ???
#: stdio-common/../sysdeps/gnu/errlist.c:800
msgid "RPC struct is bad"
msgstr "RPC 結構是壞的"

#. TRANS ???
#: stdio-common/../sysdeps/gnu/errlist.c:809
msgid "RPC version wrong"
msgstr "RPC 版本錯誤"

#. TRANS ???
#: stdio-common/../sysdeps/gnu/errlist.c:818
msgid "RPC program not available"
msgstr "RPC 程式不存在"

#. TRANS ???
#: stdio-common/../sysdeps/gnu/errlist.c:827
msgid "RPC program version wrong"
msgstr "RPC 程式版本錯誤"

#. TRANS ???
#: stdio-common/../sysdeps/gnu/errlist.c:836
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 the GNU system, but
#. TRANS it can result from an operation to an NFS server running another
#. TRANS operating system.
#: stdio-common/../sysdeps/gnu/errlist.c:848
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}.
#: stdio-common/../sysdeps/gnu/errlist.c:861
msgid "Inappropriate file type or format"
msgstr "不希望的檔案形態或格式"

#. TRANS ???
#: stdio-common/../sysdeps/gnu/errlist.c:870
msgid "Authentication error"
msgstr "鑑定錯誤"

#. TRANS ???
#: stdio-common/../sysdeps/gnu/errlist.c:879
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.
#: stdio-common/../sysdeps/gnu/errlist.c:892
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.
#: stdio-common/../sysdeps/gnu/errlist.c:912
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.
#: stdio-common/../sysdeps/gnu/errlist.c:922
msgid "Invalid or incomplete multibyte or wide character"
msgstr "不適用或不完整的多位元組字元或寬字元"

#. TRANS In the GNU system, servers supporting the @code{term} protocol return
#. TRANS this error for certain operations when the caller is not in the
#. TRANS foreground process group of the terminal.  Users do not usually see this
#. TRANS error because functions such as @code{read} and @code{write} translate
#. TRANS it into a @code{SIGTTIN} or @code{SIGTTOU} signal.  @xref{Job Control},
#. TRANS for information on process groups and these signals.
#: stdio-common/../sysdeps/gnu/errlist.c:936
msgid "Inappropriate operation for background process"
msgstr "不希望的背景行程運作"

#. TRANS In the GNU system, opening a file returns this error when the file is
#. TRANS translated by a program and the translator program dies while starting
#. TRANS up, before it has connected to the file.
#: stdio-common/../sysdeps/gnu/errlist.c:947
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.
#: stdio-common/../sysdeps/gnu/errlist.c:958
msgid "?"
msgstr "?"

#. TRANS You did @strong{what}?
#: stdio-common/../sysdeps/gnu/errlist.c:967
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.
#: stdio-common/../sysdeps/gnu/errlist.c:976
msgid "Computer bought the farm"
msgstr "這台電腦買了一塊地囉"

#. TRANS This error code has no purpose.
#: stdio-common/../sysdeps/gnu/errlist.c:985
msgid "Gratuitous error"
msgstr "無故的錯誤"

#: stdio-common/../sysdeps/gnu/errlist.c:993
msgid "Bad message"
msgstr "錯誤的訊息"

#: stdio-common/../sysdeps/gnu/errlist.c:1001
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:66
msgid "Identifier removed"
msgstr "識別符號移除"

#: stdio-common/../sysdeps/gnu/errlist.c:1009
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:104
msgid "Multihop attempted"
msgstr "嘗試 Multihop"

#: stdio-common/../sysdeps/gnu/errlist.c:1017
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:91
msgid "No data available"
msgstr "沒有可用的資料"

#: stdio-common/../sysdeps/gnu/errlist.c:1025
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:97
msgid "Link has been severed"
msgstr "連結已有服務"

#: stdio-common/../sysdeps/gnu/errlist.c:1033
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:65
msgid "No message of desired type"
msgstr "沒有符合需求格式的訊息"

#: stdio-common/../sysdeps/gnu/errlist.c:1041
msgid "Out of streams resources"
msgstr "所有資料流的資源都已用盡"

#: stdio-common/../sysdeps/gnu/errlist.c:1049
msgid "Device not a stream"
msgstr "裝置不是資料流"

#: stdio-common/../sysdeps/gnu/errlist.c:1057
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:109
msgid "Value too large for defined data type"
msgstr "有定義的資料型別值太大"

#: stdio-common/../sysdeps/gnu/errlist.c:1065
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:101
msgid "Protocol error"
msgstr "協定錯誤"

#: stdio-common/../sysdeps/gnu/errlist.c:1073
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:92
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}.
#: stdio-common/../sysdeps/gnu/errlist.c:1085
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:77
msgid "Operation canceled"
msgstr "操作已被取消"

#: stdio-common/../sysdeps/gnu/errlist.c:1093
msgid "Interrupted system call should be restarted"
msgstr "中斷的系統呼叫必須重新啟動"

#: stdio-common/../sysdeps/gnu/errlist.c:1101
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:67
msgid "Channel number out of range"
msgstr "通道號碼超出範圍"

#: stdio-common/../sysdeps/gnu/errlist.c:1109
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:68
msgid "Level 2 not synchronized"
msgstr "層級 2 沒有同步"

#: stdio-common/../sysdeps/gnu/errlist.c:1117
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:69
msgid "Level 3 halted"
msgstr "層級 3 停止"

#: stdio-common/../sysdeps/gnu/errlist.c:1125
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:70
msgid "Level 3 reset"
msgstr "層級 3 重設"

#: stdio-common/../sysdeps/gnu/errlist.c:1133
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:71
msgid "Link number out of range"
msgstr "連結數目超過範圍"

#: stdio-common/../sysdeps/gnu/errlist.c:1141
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:72
msgid "Protocol driver not attached"
msgstr "協定的驅動程式未連接"

#: stdio-common/../sysdeps/gnu/errlist.c:1149
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:73
msgid "No CSI structure available"
msgstr "沒有可用的 CSI 結構了"

#: stdio-common/../sysdeps/gnu/errlist.c:1157
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:74
msgid "Level 2 halted"
msgstr "層級 2 停止"

#: stdio-common/../sysdeps/gnu/errlist.c:1165
msgid "Invalid exchange"
msgstr "不適用的交換"

#: stdio-common/../sysdeps/gnu/errlist.c:1173
msgid "Invalid request descriptor"
msgstr "不適用的請求敘述項"

#: stdio-common/../sysdeps/gnu/errlist.c:1181
msgid "Exchange full"
msgstr "交換已充足"

#: stdio-common/../sysdeps/gnu/errlist.c:1189
msgid "No anode"
msgstr "沒有陽極"

#: stdio-common/../sysdeps/gnu/errlist.c:1197
msgid "Invalid request code"
msgstr "不適用的請求碼"

#: stdio-common/../sysdeps/gnu/errlist.c:1205
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:85
msgid "Invalid slot"
msgstr "不適用的 slot"

#: stdio-common/../sysdeps/gnu/errlist.c:1213
msgid "File locking deadlock error"
msgstr "檔案鎖定停頓錯誤"

#: stdio-common/../sysdeps/gnu/errlist.c:1221
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:87
msgid "Bad font file format"
msgstr "錯誤的字型檔格式"

#: stdio-common/../sysdeps/gnu/errlist.c:1229
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:94
msgid "Machine is not on the network"
msgstr "機器不在網路中"

#: stdio-common/../sysdeps/gnu/errlist.c:1237
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:95
msgid "Package not installed"
msgstr "套件並未安裝"

#: stdio-common/../sysdeps/gnu/errlist.c:1245
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:98
msgid "Advertise error"
msgstr "通知錯誤"

#: stdio-common/../sysdeps/gnu/errlist.c:1253
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:99
msgid "Srmount error"
msgstr "Srmount 錯誤"

#: stdio-common/../sysdeps/gnu/errlist.c:1261
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:100
msgid "Communication error on send"
msgstr "在傳送時通訊錯誤"

#: stdio-common/../sysdeps/gnu/errlist.c:1269
msgid "RFS specific error"
msgstr "RFS 特定錯誤"

#: stdio-common/../sysdeps/gnu/errlist.c:1277
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:110
msgid "Name not unique on network"
msgstr "網路上的名稱不是唯一的"

#: stdio-common/../sysdeps/gnu/errlist.c:1285
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:111
msgid "File descriptor in bad state"
msgstr "檔案敘述項處於錯誤狀態"

#: stdio-common/../sysdeps/gnu/errlist.c:1293
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:112
msgid "Remote address changed"
msgstr "遠端位址改變了"

#: stdio-common/../sysdeps/gnu/errlist.c:1301
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:113
msgid "Can not access a needed shared library"
msgstr "無法存取所需的分享函式庫"

#: stdio-common/../sysdeps/gnu/errlist.c:1309
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:114
msgid "Accessing a corrupted shared library"
msgstr "存取一個毀掉的分享函式庫"

#: stdio-common/../sysdeps/gnu/errlist.c:1317
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:115
msgid ".lib section in a.out corrupted"
msgstr "a.out 中 .lib 節區毀掉了"

#: stdio-common/../sysdeps/gnu/errlist.c:1325
msgid "Attempting to link in too many shared libraries"
msgstr "嘗試去連結太多的分享資料庫"

#: stdio-common/../sysdeps/gnu/errlist.c:1333
msgid "Cannot exec a shared library directly"
msgstr "不能直接執行一個分享函式庫"

#: stdio-common/../sysdeps/gnu/errlist.c:1341
msgid "Streams pipe error"
msgstr "資料流管線錯誤"

#: stdio-common/../sysdeps/gnu/errlist.c:1349
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:165
msgid "Structure needs cleaning"
msgstr "結構需要清理"

#: stdio-common/../sysdeps/gnu/errlist.c:1357
msgid "Not a XENIX named type file"
msgstr "並非 XENIX 命名格式的檔案"

#: stdio-common/../sysdeps/gnu/errlist.c:1365
msgid "No XENIX semaphores available"
msgstr "沒有可用的 XENIX 信號標誌了"

#: stdio-common/../sysdeps/gnu/errlist.c:1373
msgid "Is a named type file"
msgstr "是個有名字形態的檔案"

#: stdio-common/../sysdeps/gnu/errlist.c:1381
#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:170
msgid "Remote I/O error"
msgstr "遠端輸出入錯誤"

#: stdio-common/../sysdeps/gnu/errlist.c:1389
msgid "No medium found"
msgstr "找不到媒體"

#: stdio-common/../sysdeps/gnu/errlist.c:1397
msgid "Wrong medium type"
msgstr "錯誤的媒介形態"

#: stdio-common/../sysdeps/unix/siglist.c:26
msgid "Signal 0"
msgstr "訊號 0"

#: stdio-common/../sysdeps/unix/siglist.c:32
msgid "IOT trap"
msgstr "IOT 陷阱"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:30
msgid "Error 0"
msgstr "第 0 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:31
#: nis/nis_error.c:40
msgid "Not owner"
msgstr "並非擁有者"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:35
msgid "I/O error"
msgstr "I/O 錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:37
msgid "Arg list too long"
msgstr "Arg 串列太長"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:39
msgid "Bad file number"
msgstr "錯誤的檔案號碼"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:42
msgid "Not enough space"
msgstr "空間不足"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:46
msgid "Device busy"
msgstr "裝置忙碌中"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:48
msgid "Cross-device link"
msgstr "裝置之間的連接"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:53
msgid "File table overflow"
msgstr "檔案表已滿"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:63
msgid "Argument out of domain"
msgstr "引數超過範圍"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:64
msgid "Result too large"
msgstr "結果太大了"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:75
msgid "Deadlock situation detected/avoided"
msgstr "偵測/避免停頓狀態"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:76
msgid "No record locks available"
msgstr "沒有可用的紀錄鎖了"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:79
msgid "Disc quota exceeded"
msgstr "Disc quota 滿了"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:80
msgid "Bad exchange descriptor"
msgstr "錯誤的交換敘述項"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:81
msgid "Bad request descriptor"
msgstr "錯誤的請求敘述項"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:82
msgid "Message tables full"
msgstr "訊息表格已滿"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:83
msgid "Anode table overflow"
msgstr "Anode 表格溢出"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:84
msgid "Bad request code"
msgstr "錯誤的請求訊號編碼"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:86
msgid "File locking deadlock"
msgstr "檔案鎖定停頓"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:88
msgid "Error 58"
msgstr "第 58 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:89
msgid "Error 59"
msgstr "第 59 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:90
msgid "Not a stream device"
msgstr "並非資料流裝置"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:93
msgid "Out of stream resources"
msgstr "資料流資源用盡"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:102
msgid "Error 72"
msgstr "第 72 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:103
msgid "Error 73"
msgstr "第 73 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:105
msgid "Error 75"
msgstr "第 75 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:106
msgid "Error 76"
msgstr "第 76 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:107
msgid "Not a data message"
msgstr "並不是一個資料訊息"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:116
msgid "Attempting to link in more shared libraries than system limit"
msgstr "嘗試去連結超過系統上限的分享資料庫"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:117
msgid "Can not exec a shared library directly"
msgstr "無法直接執行分享函式庫"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:118
msgid "Illegal byte sequence"
msgstr "不合法的位元組序列"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:119
msgid "Operation not applicable"
msgstr "此項操作並不適當"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:120
msgid "Number of symbolic links encountered during path name traversal exceeds MAXSYMLINKS"
msgstr "尋找路徑名稱時遭遇的符號連結數目超過 MAXSYMLINKS 裡面定義的最大值"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:121
msgid "Error 91"
msgstr "第 91 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:122
msgid "Error 92"
msgstr "第 92 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:129
msgid "Option not supported by protocol"
msgstr "通訊協定並不支援此參數"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:130
msgid "Error 100"
msgstr "第 100 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:131
msgid "Error 101"
msgstr "第 101 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:132
msgid "Error 102"
msgstr "第 102 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:133
msgid "Error 103"
msgstr "第 103 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:134
msgid "Error 104"
msgstr "第 104 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:135
msgid "Error 105"
msgstr "第 105 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:136
msgid "Error 106"
msgstr "第 106 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:137
msgid "Error 107"
msgstr "第 107 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:138
msgid "Error 108"
msgstr "第 108 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:139
msgid "Error 109"
msgstr "第 109 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:140
msgid "Error 110"
msgstr "第 110 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:141
msgid "Error 111"
msgstr "第 111 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:142
msgid "Error 112"
msgstr "第 112 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:143
msgid "Error 113"
msgstr "第 113 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:144
msgid "Error 114"
msgstr "第 114 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:145
msgid "Error 115"
msgstr "第 115 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:146
msgid "Error 116"
msgstr "第 116 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:147
msgid "Error 117"
msgstr "第 117 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:148
msgid "Error 118"
msgstr "第 118 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:149
msgid "Error 119"
msgstr "第 119 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:152
msgid "Operation not supported on transport endpoint"
msgstr "此項操作在傳輸終點時並不被支援"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:154
msgid "Address family not supported by protocol family"
msgstr "位址族群不被協定族群所支援"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:159
msgid "Network dropped connection because of reset"
msgstr "網路連線漏失，因為重設"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:166
msgid "Error 136"
msgstr "第 136 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:167
msgid "Not a name file"
msgstr "並不是一個命名檔案"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:168
msgid "Not available"
msgstr "不存在"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:169
msgid "Is a name file"
msgstr "是個有名字的檔案"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:171
msgid "Reserved for future use"
msgstr "保留給將來使用"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:172
msgid "Error 142"
msgstr "第 142 號錯誤"

#: stdio-common/../sysdeps/unix/sysv/sysv4/solaris2/sparc/errlist.c:173
msgid "Cannot send after socket shutdown"
msgstr "無法在 socket 關閉後傳送"

#: stdio-common/psignal.c:63
#, c-format
msgid "%s%sUnknown signal %d\n"
msgstr "%s%s未知的訊號 %d\n"

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

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

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

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

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

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

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

#: malloc/memusagestat.c:53
msgid "Name output file"
msgstr "名稱輸出檔"

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

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

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

#: malloc/memusagestat.c:58
msgid "make output graphic VALUE pixel wide"
msgstr "設定輸出的圖形寬度為 VALUE 個像素"

#: malloc/memusagestat.c:59
msgid "make output graphic VALUE pixel high"
msgstr "設定輸出的圖形高度為 VALUE 個像素"

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

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

#: string/strerror.c:43 posix/../sysdeps/posix/gai_strerror.c:57
msgid "Unknown error"
msgstr "未知的錯誤"

#: string/strsignal.c:69
#, c-format
msgid "Real-time signal %d"
msgstr "即時的訊號 %d"

#: string/strsignal.c:73
#, c-format
msgid "Unknown signal %d"
msgstr "未知的訊號 %d"

#: timezone/zdump.c:176
#, c-format
msgid "%s: usage is %s [ --version ] [ -v ] [ -c cutoff ] zonename ...\n"
msgstr "%s: 用法是 %s [ --version ] [ -v ] [ -c 切斷 ] 地區名稱 ...\n"

#: timezone/zdump.c:269
msgid "Error writing to standard output"
msgstr "寫入標準輸出時錯誤"

#: timezone/zic.c:361
#, c-format
msgid "%s: Memory exhausted: %s\n"
msgstr "%s: 記憶體已用完: %s\n"

#: timezone/zic.c:386 misc/error.c:129 misc/error.c:157
msgid "Unknown system error"
msgstr "未知的系統錯誤"

#: timezone/zic.c:420
#, c-format
msgid "\"%s\", line %d: %s"
msgstr "\"%s\", 第 %d 行: %s"

#: timezone/zic.c:423
#, c-format
msgid " (rule from \"%s\", line %d)"
msgstr " (規則來自 \"%s\", 第 %d 行)"

#: timezone/zic.c:435
msgid "warning: "
msgstr "警告: "

#: timezone/zic.c:445
#, c-format
msgid ""
"%s: usage is %s [ --version ] [ -s ] [ -v ] [ -l localtime ] [ -p posixrules ] \\\n"
"\t[ -d directory ] [ -L leapseconds ] [ -y yearistype ] [ filename ... ]\n"
msgstr ""
"%s: 用法是 %s [ --version ] [ -s ] [ -v ] [ -l 當地時間 ] [ -p posix規則 ] \\\n"
"\t[ -d 目錄 ] [ -L 閏秒 ] [ -y 年份型態 ] [ 檔案名稱 ... ]\n"

#: timezone/zic.c:492
#, c-format
msgid "%s: More than one -d option specified\n"
msgstr "%s: 您使用了超過一個 -d 選項\n"

#: timezone/zic.c:502
#, c-format
msgid "%s: More than one -l option specified\n"
msgstr "%s: 您使用了超過一個 -l 選項\n"

#: timezone/zic.c:512
#, c-format
msgid "%s: More than one -p option specified\n"
msgstr "%s: 您使用了超過一個 -p 選項\n"

#: timezone/zic.c:522
#, c-format
msgid "%s: More than one -y option specified\n"
msgstr "%s: 您使用了超過一個 -y 選項\n"

#: timezone/zic.c:532
#, c-format
msgid "%s: More than one -L option specified\n"
msgstr "%s: 您使用了超過一個 -L 選項\n"

#: timezone/zic.c:639
#, c-format
msgid "%s: Can't unlink  %s: %s\n"
msgstr "%s: 無法取消連結 %s: %s\n"

#: timezone/zic.c:646
msgid "hard link failed, symbolic link used"
msgstr "實體連結失敗，使用符號連結代替"

#: timezone/zic.c:654
#, c-format
msgid "%s: Can't link from %s to %s: %s\n"
msgstr "%s: 無法從 %s 連結到 %s: %s\n"

#: timezone/zic.c:752 timezone/zic.c:754
msgid "same rule name in multiple files"
msgstr "在多個檔案裡面有相同的規則名稱"

#: timezone/zic.c:795
msgid "unruly zone"
msgstr "沒有規則的時區"

#: timezone/zic.c:802
#, c-format
msgid "%s in ruleless zone"
msgstr "%s 在沒有規則的區段"

#: timezone/zic.c:823
msgid "standard input"
msgstr "標準輸入"

#: timezone/zic.c:828
#, c-format
msgid "%s: Can't open %s: %s\n"
msgstr "%s: 無法開啟 %s: %s\n"

#: timezone/zic.c:839
msgid "line too long"
msgstr "行的長度過長"

#: timezone/zic.c:859
msgid "input line of unknown type"
msgstr "不明型別的輸入行"

#: timezone/zic.c:875
#, c-format
msgid "%s: Leap line in non leap seconds file %s\n"
msgstr "%s: 閏時設定行 (leap line) 出現在不含閏秒的設定檔 %s 中\n"

#: timezone/zic.c:882 timezone/zic.c:1297 timezone/zic.c:1322
#, c-format
msgid "%s: panic: Invalid l_value %d\n"
msgstr "%s: 嚴重錯誤: 錯誤的左值 (l_value) %d\n"

#: timezone/zic.c:890
#, c-format
msgid "%s: Error reading %s\n"
msgstr "%s: 讀取錯誤 %s\n"

#: timezone/zic.c:897
#, c-format
msgid "%s: Error closing %s: %s\n"
msgstr "%s: 關閉錯誤 %s: %s\n"

#: timezone/zic.c:902
msgid "expected continuation line not found"
msgstr "找不到預期的接續行"

#: timezone/zic.c:958
msgid "wrong number of fields on Rule line"
msgstr "規則設定行的欄位數目錯誤"

#: timezone/zic.c:962
msgid "nameless rule"
msgstr "規則沒有名稱"

#: timezone/zic.c:967
msgid "invalid saved time"
msgstr "無效的節約時間"

#: timezone/zic.c:986
msgid "wrong number of fields on Zone line"
msgstr "時區設定行的欄位數目錯誤"

#: timezone/zic.c:992
#, c-format
msgid "\"Zone %s\" line and -l option are mutually exclusive"
msgstr "\"區段 %s\" 行和 -l 選項是互斥的"

#: timezone/zic.c:1000
#, c-format
msgid "\"Zone %s\" line and -p option are mutually exclusive"
msgstr "\"區段 %s\" 行和 -p 選項是互斥的"

#: timezone/zic.c:1012
#, c-format
msgid "duplicate zone name %s (file \"%s\", line %d)"
msgstr "複製時區名稱 %s (檔案 \"%s\", 第 %d 行)"

#: timezone/zic.c:1028
msgid "wrong number of fields on Zone continuation line"
msgstr "時區接續行的欄位數目不對"

#: timezone/zic.c:1068
msgid "invalid UTC offset"
msgstr "無效的 UTC 位移值"

#: timezone/zic.c:1071
msgid "invalid abbreviation format"
msgstr "無效的縮寫格式"

#: timezone/zic.c:1097
msgid "Zone continuation line end time is not after end time of previous line"
msgstr "時區接續行的結束時間不在上一行的結束時間之後"

#: timezone/zic.c:1124
msgid "wrong number of fields on Leap line"
msgstr "閏時設定行的欄位數目錯誤"

#: timezone/zic.c:1133
msgid "invalid leaping year"
msgstr "無效的閏年"

#: timezone/zic.c:1148 timezone/zic.c:1252
msgid "invalid month name"
msgstr "無效的月份名稱"

#: timezone/zic.c:1161 timezone/zic.c:1374 timezone/zic.c:1388
msgid "invalid day of month"
msgstr "無效的日期數字"

#: timezone/zic.c:1166
msgid "time before zero"
msgstr "在零之前的時間"

#: timezone/zic.c:1170
msgid "time too small"
msgstr "時間太小"

#: timezone/zic.c:1174
msgid "time too large"
msgstr "時間太大"

#: timezone/zic.c:1178 timezone/zic.c:1281
msgid "invalid time of day"
msgstr "無效的時間數字"

#: timezone/zic.c:1197
msgid "illegal CORRECTION field on Leap line"
msgstr "在閏時設定行中有不合法的 CORRECTION 欄位"

#: timezone/zic.c:1201
msgid "illegal Rolling/Stationary field on Leap line"
msgstr "在閏時設定行中有不合法的 Rolling/Stationary 欄位"

#: timezone/zic.c:1216
msgid "wrong number of fields on Link line"
msgstr "連結設定行的欄位數目錯誤"

#: timezone/zic.c:1220
msgid "blank FROM field on Link line"
msgstr "Link 行中空白的 FROM 欄位"

#: timezone/zic.c:1224
msgid "blank TO field on Link line"
msgstr "Link 行中空白的 TO 欄位"

#: timezone/zic.c:1301
msgid "invalid starting year"
msgstr "無效的起始年份"

#: timezone/zic.c:1305
msgid "starting year too low to be represented"
msgstr "起始年份太低，無法表示"

#: timezone/zic.c:1307
msgid "starting year too high to be represented"
msgstr "起始年份太高，無法表示"

#: timezone/zic.c:1326
msgid "invalid ending year"
msgstr "無效的結束年份"

#: timezone/zic.c:1330
msgid "ending year too low to be represented"
msgstr "結束年份太低，無法表示"

#: timezone/zic.c:1332
msgid "ending year too high to be represented"
msgstr "結束年份太高，無法表示"

#: timezone/zic.c:1335
msgid "starting year greater than ending year"
msgstr "起始年份比結束年份還要大"

#: timezone/zic.c:1342
msgid "typed single year"
msgstr "輸入的年份是同一年"

#: timezone/zic.c:1379
msgid "invalid weekday name"
msgstr "無效的工作日 (weekday) 名稱"

#: timezone/zic.c:1494
#, c-format
msgid "%s: Can't remove %s: %s\n"
msgstr "%s: 無法移除 %s: %s\n"

#: timezone/zic.c:1504
#, c-format
msgid "%s: Can't create %s: %s\n"
msgstr "%s: 無法產生 %s: %s\n"

#: timezone/zic.c:1570
#, c-format
msgid "%s: Error writing %s\n"
msgstr "%s: 寫入錯誤 %s\n"

#: timezone/zic.c:1760
msgid "can't determine time zone abbreviation to use just after until time"
msgstr "無法決定在結束時間 (untiltime) 以後該使用的時區簡寫"

#: timezone/zic.c:1803
msgid "too many transitions?!"
msgstr "太多時間轉換了?!"

#: timezone/zic.c:1822
msgid "internal error - addtype called with bad isdst"
msgstr "內部錯誤 - 用錯誤的 isdst 呼叫 addtype 函式"

#: timezone/zic.c:1826
msgid "internal error - addtype called with bad ttisstd"
msgstr "內部錯誤 - 用錯誤的 ttisstd 呼叫 addtype 函式"

#: timezone/zic.c:1830
msgid "internal error - addtype called with bad ttisgmt"
msgstr "內部錯誤 - 用錯誤的 ttisgmt 呼叫 addtype 函式"

#: timezone/zic.c:1849
msgid "too many local time types"
msgstr "太多本地時間格式了"

#: timezone/zic.c:1877
msgid "too many leap seconds"
msgstr "太多閏秒了"

#: timezone/zic.c:1883
msgid "repeated leap second moment"
msgstr "重複的閏秒設定"

#: timezone/zic.c:1935
msgid "Wild result from command execution"
msgstr "命令執行導至奇怪的結果"

#: timezone/zic.c:1936
#, c-format
msgid "%s: command was '%s', result was %d\n"
msgstr "%s: 輸入命令為 '%s', 結果為 %d\n"

#: timezone/zic.c:2031
msgid "Odd number of quotation marks"
msgstr "引號數目為奇數"

#: timezone/zic.c:2051 timezone/zic.c:2070
msgid "time overflow"
msgstr "時間溢位"

#: timezone/zic.c:2117
msgid "use of 2/29 in non leap-year"
msgstr "在非閏年時用到 2/29 日"

#: timezone/zic.c:2151
msgid "no day in month matches rule"
msgstr "在月份資料中找不到符合規則的日數"

#: timezone/zic.c:2175
msgid "too many, or too long, time zone abbreviations"
msgstr "時區縮寫太多或者太長了"

#: timezone/zic.c:2216
#, c-format
msgid "%s: Can't create directory %s: %s\n"
msgstr "%s: 無法建立目錄 %s: %s\n"

#: timezone/zic.c:2238
#, c-format
msgid "%s: %d did not sign extend correctly\n"
msgstr "%s: %d 無法正確地延展訊號\n"

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

#: posix/../sysdeps/posix/gai_strerror.c:31
msgid "Address family for hostname not supported"
msgstr "hostname 的位址族群不支援"

#: posix/../sysdeps/posix/gai_strerror.c:32
msgid "Temporary failure in name resolution"
msgstr "解析名稱時發生暫時性的錯誤"

#: posix/../sysdeps/posix/gai_strerror.c:33
msgid "Bad value for ai_flags"
msgstr "錯誤的 ai_flags 值"

#: posix/../sysdeps/posix/gai_strerror.c:34
msgid "Non-recoverable failure in name resolution"
msgstr "在解析名稱時發生嚴重的錯誤"

#: posix/../sysdeps/posix/gai_strerror.c:35
msgid "ai_family not supported"
msgstr "ai_family 沒有支援"

#: posix/../sysdeps/posix/gai_strerror.c:36
msgid "Memory allocation failure"
msgstr "記憶體配置失敗"

#: posix/../sysdeps/posix/gai_strerror.c:37
msgid "No address associated with hostname"
msgstr "沒有此主機名稱所對應的位址"

#: posix/../sysdeps/posix/gai_strerror.c:38
msgid "Name or service not known"
msgstr "未知的名稱或服務"

#: posix/../sysdeps/posix/gai_strerror.c:39
msgid "Servname not supported for ai_socktype"
msgstr "不支援 ai_socktype 的伺服名稱"

#: posix/../sysdeps/posix/gai_strerror.c:40
msgid "ai_socktype not supported"
msgstr "ai_socktype 沒有支援"

#: posix/../sysdeps/posix/gai_strerror.c:41
msgid "System error"
msgstr "系統錯誤"

#: posix/../sysdeps/posix/gai_strerror.c:42
msgid "Processing request in progress"
msgstr "此項請求已經在處理當中"

#: posix/../sysdeps/posix/gai_strerror.c:43
msgid "Request canceled"
msgstr "請求已被取消"

#: posix/../sysdeps/posix/gai_strerror.c:44
msgid "Request not canceled"
msgstr "請求並未取消"

#: posix/../sysdeps/posix/gai_strerror.c:45
msgid "All requests done"
msgstr "所有請求已完成"

#: posix/../sysdeps/posix/gai_strerror.c:46
msgid "Interrupted by a signal"
msgstr "由訊號所中斷"

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

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

#: posix/getconf.c:979 posix/getconf.c:995
msgid "undefined"
msgstr "未定義"

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

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

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

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

#: posix/getopt.c:807 posix/getopt.c:829 posix/getopt.c:1159
#: posix/getopt.c:1181
#, c-format
msgid "%s: option '%s' requires an argument\n"
msgstr "%s: 選項 `%s' 需要一個引數\n"

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

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

#: posix/getopt.c:936 posix/getopt.c:939
#, c-format
msgid "%s: illegal option -- '%c'\n"
msgstr "%s: 不合法的選項 -- %c\n"

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

#: posix/getopt.c:1003 posix/getopt.c:1022 posix/getopt.c:1234
#: posix/getopt.c:1255
#, c-format
msgid "%s: option requires an argument -- '%c'\n"
msgstr "%s: 選項需要一個引數 -- %c\n"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: argp/argp-parse.c:119
msgid "Hang for SECS seconds (default 3600)"
msgstr "SECS 秒後掛斷 (預設是 3600)"

#: argp/argp-parse.c:180
msgid "Print program version"
msgstr "印出程式版本"

#: argp/argp-parse.c:196
msgid "(PROGRAM ERROR) No version known!?"
msgstr "(程式錯誤) 沒有認得的版本!?"

#: argp/argp-parse.c:672
#, c-format
msgid "%s: Too many arguments\n"
msgstr "%s: 太多的引數\n"

#: argp/argp-parse.c:813
msgid "(PROGRAM ERROR) Option should have been recognized!?"
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:108
msgid "Resolver internal error"
msgstr "內部解讀錯誤"

#: resolv/herror.c:111
msgid "Unknown resolver error"
msgstr "未知的解讀錯誤"

#: resolv/res_hconf.c:147
#, c-format
msgid "%s: line %d: expected service, found `%s'\n"
msgstr "%s: 第 %d 列: 期待一項服務，卻發現 `%s'\n"

#: resolv/res_hconf.c:165
#, c-format
msgid "%s: line %d: cannot specify more than %d services"
msgstr "%s: 第 %d 列: 無法指定超過 %d 個服務"

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

#: resolv/res_hconf.c:231
#, c-format
msgid "%s: line %d: cannot specify more than %d trim domains"
msgstr "%s: 第 %d 列: 無法指定超過 %d 個修剪範圍"

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

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

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

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

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

#: nss/getent.c:56
msgid "Service configuration to be used"
msgstr "將要使用的服務設定"

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

#: nss/getent.c:800
msgid "getent - get entries from administrative database."
msgstr "getent - 從管理資料庫中取得項目內容。"

#: nss/getent.c:801
msgid "Supported databases:"
msgstr "支援的資料庫:"

#: nss/getent.c:858 nscd/nscd.c:131 nscd/nscd_nischeck.c:64
msgid "wrong number of arguments"
msgstr "參數數目不對"

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

#: debug/pcprofiledump.c:52
msgid "Don't buffer output"
msgstr "不要將輸入存入緩衝區"

#: debug/pcprofiledump.c:57
msgid "Dump information generated by PC profiling."
msgstr "將產生於 PC 測速評估的資料傾卸出來"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: inet/rcmd.c:551
msgid "not regular file"
msgstr "並非正常的檔案"

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

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

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

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

#: inet/rcmd.c:564
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"

#: sunrpc/auth_unix.c:115 sunrpc/auth_unix.c:118
msgid "authunix_create: out of memory\n"
msgstr "authunix_create: 記憶體不足\n"

#: sunrpc/auth_unix.c:318
msgid "auth_none.c - Fatal marshalling problem"
msgstr "auth_none.c - 嚴重的排序問題"

#: sunrpc/clnt_perr.c:118 sunrpc/clnt_perr.c:139
#, c-format
msgid "; low version = %lu, high version = %lu"
msgstr "; 低版本 = %lu, 高版本 = %lu"

#: sunrpc/clnt_perr.c:125
msgid "; why = "
msgstr "; 原因 = "

#: sunrpc/clnt_perr.c:132
#, c-format
msgid "(unknown authentication error - %d)"
msgstr "(未知鑑定錯誤 - %d)"

#: sunrpc/clnt_perr.c:177
msgid "RPC: Success"
msgstr "RPC: 成功"

#: sunrpc/clnt_perr.c:180
msgid "RPC: Can't encode arguments"
msgstr "RPC: 無法將引數編碼"

#: sunrpc/clnt_perr.c:184
msgid "RPC: Can't decode result"
msgstr "RPC: 無法解碼得出結果"

#: sunrpc/clnt_perr.c:188
msgid "RPC: Unable to send"
msgstr "RPC: 無法傳送"

#: sunrpc/clnt_perr.c:192
msgid "RPC: Unable to receive"
msgstr "RPC: 無法接收"

#: sunrpc/clnt_perr.c:196
msgid "RPC: Timed out"
msgstr "RPC: 超過時間上限"

#: sunrpc/clnt_perr.c:200
msgid "RPC: Incompatible versions of RPC"
msgstr "RPC: RPC 版本不相容"

#: sunrpc/clnt_perr.c:204
msgid "RPC: Authentication error"
msgstr "RPC: 認證錯誤"

#: sunrpc/clnt_perr.c:208
msgid "RPC: Program unavailable"
msgstr "RPC: 程式不存在"

#: sunrpc/clnt_perr.c:212
msgid "RPC: Program/version mismatch"
msgstr "RPC: 程式/版本不符"

#: sunrpc/clnt_perr.c:216
msgid "RPC: Procedure unavailable"
msgstr "RPC: 無法取得程序"

#: sunrpc/clnt_perr.c:220
msgid "RPC: Server can't decode arguments"
msgstr "RPC: 伺服器無法將引數解碼"

#: sunrpc/clnt_perr.c:224
msgid "RPC: Remote system error"
msgstr "RPC: 遠端程式錯誤"

#: sunrpc/clnt_perr.c:228
msgid "RPC: Unknown host"
msgstr "RPC: 未知的遠端位址"

#: sunrpc/clnt_perr.c:232
msgid "RPC: Unknown protocol"
msgstr "RPC: 未知的協定"

#: sunrpc/clnt_perr.c:236
msgid "RPC: Port mapper failure"
msgstr "RPC: 通訊阜對映錯誤"

#: sunrpc/clnt_perr.c:240
msgid "RPC: Program not registered"
msgstr "RPC: 程式沒有註冊"

#: sunrpc/clnt_perr.c:244
msgid "RPC: Failed (unspecified error)"
msgstr "RPC: 失敗 (非特定的錯誤)"

#: sunrpc/clnt_perr.c:285
msgid "RPC: (unknown error code)"
msgstr "RPC: (未知的錯誤碼)"

#: sunrpc/clnt_perr.c:357
msgid "Authentication OK"
msgstr "鑑定完成"

#: sunrpc/clnt_perr.c:360
msgid "Invalid client credential"
msgstr "不適用的請求端身份認證"

#: sunrpc/clnt_perr.c:364
msgid "Server rejected credential"
msgstr "伺服器拒絕身份證明"

#: sunrpc/clnt_perr.c:368
msgid "Invalid client verifier"
msgstr "不適用的請求端認證"

#: sunrpc/clnt_perr.c:372
msgid "Server rejected verifier"
msgstr "伺服器拒絕認證"

#: sunrpc/clnt_perr.c:376
msgid "Client credential too weak"
msgstr "用戶端背景太弱"

#: sunrpc/clnt_perr.c:380
msgid "Invalid server verifier"
msgstr "不適用的服務認證"

#: sunrpc/clnt_perr.c:384
msgid "Failed (unspecified error)"
msgstr "失敗 (沒有指定的錯誤)"

#: sunrpc/clnt_raw.c:117
msgid "clnt_raw.c - Fatal header serialization error."
msgstr "clnt_raw.c - 嚴重的標頭序列化錯誤。"

#: sunrpc/clnt_tcp.c:134 sunrpc/clnt_tcp.c:137
msgid "clnttcp_create: out of memory\n"
msgstr "clnttcp_create: 記憶體不足\n"

#: sunrpc/clnt_udp.c:141 sunrpc/clnt_udp.c:144
msgid "clntudp_create: out of memory\n"
msgstr "clntudp_create: 記憶體不足\n"

#: sunrpc/clnt_unix.c:131 sunrpc/clnt_unix.c:134
msgid "clntunix_create: out of memory\n"
msgstr "clntunix_create: 記憶體不足\n"

#: sunrpc/get_myaddr.c:78
msgid "get_myaddress: ioctl (get interface configuration)"
msgstr "get_myaddress: ioctl (取得介面設定資料)"

#: sunrpc/pm_getmaps.c:74
msgid "pmap_getmaps rpc problem"
msgstr "pmap_getmaps 遠端程序呼叫問題"

#: sunrpc/pmap_clnt.c:72
msgid "__get_myaddress: ioctl (get interface configuration)"
msgstr "__get_myaddress: ioctl (取得介面組態)"

#: sunrpc/pmap_clnt.c:137
msgid "Cannot register service"
msgstr "無法註冊服務"

#: sunrpc/pmap_rmt.c:190
msgid "broadcast: ioctl (get interface configuration)"
msgstr "broadcast: ioctl (取得介面設定值)"

#: sunrpc/pmap_rmt.c:199
msgid "broadcast: ioctl (get interface flags)"
msgstr "broadcast: ioctl (取得介面旗標)"

#: sunrpc/pmap_rmt.c:269
msgid "Cannot create socket for broadcast rpc"
msgstr "無法為廣播式遠端程序呼叫 (broadcast rpc) 產生 socket"

#: sunrpc/pmap_rmt.c:276
msgid "Cannot set socket option SO_BROADCAST"
msgstr "無法設定 socket 選項 SO_BROADCAST"

#: sunrpc/pmap_rmt.c:328
msgid "Cannot send broadcast packet"
msgstr "無法傳送廣播封包"

#: sunrpc/pmap_rmt.c:353
msgid "Broadcast poll problem"
msgstr "Broadcast 調查有問題"

#: sunrpc/pmap_rmt.c:366
msgid "Cannot receive reply to broadcast"
msgstr "無法接受廣播後的回應"

#: sunrpc/rpc_main.c:288
#, c-format
msgid "%s: output would overwrite %s\n"
msgstr "%s: 輸出將會覆蓋 %s\n"

#: sunrpc/rpc_main.c:295
#, c-format
msgid "%s: unable to open %s: %m\n"
msgstr "%s: 無法開啟 %s: %m\n"

#: sunrpc/rpc_main.c:307
#, c-format
msgid "%s: while writing output %s: %m"
msgstr "%s: 當在寫出輸出 %s 時: %m"

#: sunrpc/rpc_main.c:342
#, c-format
msgid "cannot find C preprocessor: %s \n"
msgstr "找不到 C 前置處理器: %s \n"

#: sunrpc/rpc_main.c:350
msgid "cannot find any C preprocessor (cpp)\n"
msgstr "找不到任何 C 前置處理器 (cpp)\n"

#: sunrpc/rpc_main.c:419
#, c-format
msgid "%s: C preprocessor failed with signal %d\n"
msgstr "%s: C 前置處理器失效，其訊號值為 %d\n"

#: sunrpc/rpc_main.c:422
#, c-format
msgid "%s: C preprocessor failed with exit code %d\n"
msgstr "%s: C 前置處理器失效，其結束碼為 %d\n"

#: sunrpc/rpc_main.c:462
#, c-format
msgid "illegal nettype :`%s'\n"
msgstr "不合法的 nettype :`%s'\n"

#: sunrpc/rpc_main.c:1104
#, c-format
msgid "rpcgen: too many defines\n"
msgstr "rpcgen: 太多 define 了\n"

#: sunrpc/rpc_main.c:1116
#, 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:1149
#, c-format
msgid "file `%s' already exists and may be overwritten\n"
msgstr "檔案 `%s' 已經存在並有可能會被覆蓋掉\n"

#: sunrpc/rpc_main.c:1194
#, c-format
msgid "Cannot specify more than one input file!\n"
msgstr "無法指定超過一個輸入檔!\n"

#: sunrpc/rpc_main.c:1364
msgid "This implementation doesn't support newstyle or MT-safe code!\n"
msgstr "此實作方式不支援新的形式或多安全執行序的程式!\n"

#: sunrpc/rpc_main.c:1373
#, c-format
msgid "Cannot use netid flag with inetd flag!\n"
msgstr "無法將 netid 旗標與 inetd 旗標一起使用!\n"

#: sunrpc/rpc_main.c:1385
msgid "Cannot use netid flag without TIRPC!\n"
msgstr "無法在沒有 TIRPC 時使用 netid 旗標!\n"

#: sunrpc/rpc_main.c:1392
msgid "Cannot use table flags with newstyle!\n"
msgstr "無法將表格旗標與 newstyle 一起使用!\n"

#: sunrpc/rpc_main.c:1411
#, c-format
msgid "\"infile\" is required for template generation flags.\n"
msgstr "\"infile\" 是樣版產生旗標所需的\n"

#: sunrpc/rpc_main.c:1416
#, c-format
msgid "Cannot have more than one file generation flag!\n"
msgstr "無法使用超過一個的檔案產生旗標!\n"

#: sunrpc/rpc_main.c:1425
#, c-format
msgid "usage: %s infile\n"
msgstr "用法: %s infile\n"

#: sunrpc/rpc_main.c:1426
#, 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:1428
#, 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:1430
#, c-format
msgid "\t%s [-s nettype]* [-o outfile] [infile]\n"
msgstr "\t%s [-s 網路型態]* [-o 輸出檔案] [輸入檔案]\n"

#: sunrpc/rpc_main.c:1431
#, c-format
msgid "\t%s [-n netid]* [-o outfile] [infile]\n"
msgstr "\t%s [-n 網路識別符號]* [-o 輸出檔案] [輸入檔案]\n"

#: sunrpc/rpc_scan.c:116
msgid "constant or identifier expected"
msgstr "應該要有常數或識別符號才對"

#: sunrpc/rpc_scan.c:312
msgid "illegal character in file: "
msgstr "檔案中有不合法的字元: "

#: sunrpc/rpc_scan.c:351 sunrpc/rpc_scan.c:377
msgid "unterminated string constant"
msgstr "沒有結尾的字串常數"

#: sunrpc/rpc_scan.c:383
msgid "empty char string"
msgstr "空的字元字串"

#: sunrpc/rpc_scan.c:525 sunrpc/rpc_scan.c:535
msgid "preprocessor error"
msgstr "前置處理器錯誤"

#: sunrpc/rpcinfo.c:237 sunrpc/rpcinfo.c:383
#, c-format
msgid "program %lu is not available\n"
msgstr "程式 %lu 不存在\n"

#: sunrpc/rpcinfo.c:264 sunrpc/rpcinfo.c:310 sunrpc/rpcinfo.c:333
#: sunrpc/rpcinfo.c:407 sunrpc/rpcinfo.c:453 sunrpc/rpcinfo.c:476
#: sunrpc/rpcinfo.c:510
#, c-format
msgid "program %lu version %lu is not available\n"
msgstr "程式 %lu 的第 %lu 版並不存在\n"

#: sunrpc/rpcinfo.c:515
#, c-format
msgid "program %lu version %lu ready and waiting\n"
msgstr "程式 %lu 的第 %lu 版已經就緒並等待服務中\n"

#: sunrpc/rpcinfo.c:556 sunrpc/rpcinfo.c:563
msgid "rpcinfo: can't contact portmapper"
msgstr "rpcinfo: 無法建立跟 portmapper 之間的連線"

#: sunrpc/rpcinfo.c:570
msgid "No remote programs registered.\n"
msgstr "沒有註冊過的遠端應用程式\n"

#: sunrpc/rpcinfo.c:574
msgid "   program vers proto   port\n"
msgstr "   程式採用的協定連接阜\n"

#: sunrpc/rpcinfo.c:613
msgid "(unknown)"
msgstr "(未知)"

#: sunrpc/rpcinfo.c:637
#, c-format
msgid "rpcinfo: broadcast failed: %s\n"
msgstr "rpcinfo: 廣播失敗: %s\n"

#: sunrpc/rpcinfo.c:658
msgid "Sorry. You are not root\n"
msgstr "不好意思，你並不是 root 使用者\n"

#: sunrpc/rpcinfo.c:665
#, c-format
msgid "rpcinfo: Could not delete registration for prog %s version %s\n"
msgstr "rpcinfo: 無法刪除程式 %s (第 %s 版) 的註冊資料\n"

#: sunrpc/rpcinfo.c:674
msgid "Usage: rpcinfo [ -n portnum ] -u host prognum [ versnum ]\n"
msgstr "使用方式: rpcinfo [ -n portnum ] -u host prognum [ versnum ]\n"

#: sunrpc/rpcinfo.c:676
msgid "       rpcinfo [ -n portnum ] -t host prognum [ versnum ]\n"
msgstr "       rpcinfo [ -n portnum ] -t host prognum [ versnum ]\n"

#: sunrpc/rpcinfo.c:678
msgid "       rpcinfo -p [ host ]\n"
msgstr "       rpcinfo -p [ host ]\n"

#: sunrpc/rpcinfo.c:679
msgid "       rpcinfo -b prognum versnum\n"
msgstr "       rpcinfo -b prognum versnum\n"

#: sunrpc/rpcinfo.c:680
msgid "       rpcinfo -d prognum versnum\n"
msgstr "       rpcinfo -d prognum versnum\n"

#: sunrpc/rpcinfo.c:695
#, c-format
msgid "rpcinfo: %s is unknown service\n"
msgstr "rpcinfo: %s 是不明的服務\n"

#: sunrpc/rpcinfo.c:732
#, c-format
msgid "rpcinfo: %s is unknown host\n"
msgstr "rpcinfo: %s 是不明的主機\n"

#: sunrpc/svc_run.c:76
msgid "svc_run: - poll failed"
msgstr "svc_run: - poll 失敗"

#: sunrpc/svc_simple.c:87
#, c-format
msgid "can't reassign procedure number %ld\n"
msgstr "不能重複指定程序號碼 %ld\n"

#: sunrpc/svc_simple.c:96
msgid "couldn't create an rpc server\n"
msgstr "不能產生遠端程序呼叫伺服程式\n"

#: sunrpc/svc_simple.c:104
#, c-format
msgid "couldn't register prog %ld vers %ld\n"
msgstr "不能將程式 %ld 註冊到 %ld\n"

#: sunrpc/svc_simple.c:111
msgid "registerrpc: out of memory\n"
msgstr "registerrpc: 記憶體不足\n"

#: sunrpc/svc_simple.c:175
#, c-format
msgid "trouble replying to prog %d\n"
msgstr "回應程式 %d 時發生困難\n"

#: sunrpc/svc_simple.c:183
#, c-format
msgid "never registered prog %d\n"
msgstr "千萬不要註冊程式 %d\n"

#: sunrpc/svc_tcp.c:155
msgid "svc_tcp.c - tcp socket creation problem"
msgstr "svc_tcp.c - tcp socket 建立發生問題"

#: sunrpc/svc_tcp.c:170
msgid "svc_tcp.c - cannot getsockname or listen"
msgstr "svc_tcp.c - 無法 getsockname 或 listen"

#: sunrpc/svc_tcp.c:181 sunrpc/svc_tcp.c:184
msgid "svctcp_create: out of memory\n"
msgstr "svctcp_create: 記憶體不足\n"

#: sunrpc/svc_tcp.c:225 sunrpc/svc_tcp.c:228
msgid "svc_tcp: makefd_xprt: out of memory\n"
msgstr "svc_tcp: makefd_xprt: 記憶體不足\n"

#: sunrpc/svc_udp.c:128
msgid "svcudp_create: socket creation problem"
msgstr "svcudp_create: socket 建立有問題"

#: sunrpc/svc_udp.c:142
msgid "svcudp_create - cannot getsockname"
msgstr "svcudp_create - 無法 getsockname"

#: sunrpc/svc_udp.c:154 sunrpc/svc_udp.c:157
msgid "svcudp_create: out of memory\n"
msgstr "svcudp_create: 記憶體不足\n"

#: sunrpc/svc_udp.c:182 sunrpc/svc_udp.c:185
msgid "svcudp_create: xp_pad is too small for IP_PKTINFO\n"
msgstr "svcudp_create: xp_pad 太小以致於無法 IP_PKTINFO\n"

#: sunrpc/svc_udp.c:493
msgid "enablecache: cache already enabled"
msgstr "enablecache: 快取已經開啟"

#: sunrpc/svc_udp.c:499
msgid "enablecache: could not allocate cache"
msgstr "enablecache: 無法配置快取"

#: sunrpc/svc_udp.c:507
msgid "enablecache: could not allocate cache data"
msgstr "enablecache: 無法配置快取資料"

#: sunrpc/svc_udp.c:514
msgid "enablecache: could not allocate cache fifo"
msgstr "enablecache: 無法配置快取 fifo 管線"

#: sunrpc/svc_udp.c:550
msgid "cache_set: victim not found"
msgstr "cache_set: 找不到 victim"

#: sunrpc/svc_udp.c:561
msgid "cache_set: victim alloc failed"
msgstr "cache_set: victim 配置失敗"

#: sunrpc/svc_udp.c:567
msgid "cache_set: could not allocate new rpc_buffer"
msgstr "cache_set: 無法配置新的遠端程序呼叫緩衝區 (rpc_buffer)"

#: sunrpc/svc_unix.c:150
msgid "svc_unix.c - AF_UNIX socket creation problem"
msgstr "svc_unix.c - AF_UNIX socket 建立有問題"

#: sunrpc/svc_unix.c:166
msgid "svc_unix.c - cannot getsockname or listen"
msgstr "svc_unix.c - 無法 getsockname 或 listen"

#: sunrpc/svc_unix.c:178 sunrpc/svc_unix.c:181
msgid "svcunix_create: out of memory\n"
msgstr "svcunix_create: 記憶體不足\n"

#: sunrpc/svc_unix.c:222 sunrpc/svc_unix.c:225
msgid "svc_unix: makefd_xprt: out of memory\n"
msgstr "svc_unix: makefd_xprt: 記憶體不足\n"

#: sunrpc/xdr.c:570 sunrpc/xdr.c:573
msgid "xdr_bytes: out of memory\n"
msgstr "xdr_bytes: 記憶體不足\n"

#: sunrpc/xdr.c:728 sunrpc/xdr.c:731
msgid "xdr_string: out of memory\n"
msgstr "xdr_string: 記憶體不足\n"

#: sunrpc/xdr_array.c:111 sunrpc/xdr_array.c:114
msgid "xdr_array: out of memory\n"
msgstr "xdr_array: 記憶體不足\n"

#: sunrpc/xdr_rec.c:158 sunrpc/xdr_rec.c:161
msgid "xdrrec_create: out of memory\n"
msgstr "xdrrec_create: 記憶體不足\n"

#: sunrpc/xdr_ref.c:88 sunrpc/xdr_ref.c:91
msgid "xdr_reference: out of memory\n"
msgstr "xdr_reference: 記憶體不足\n"

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

#: nis/nis_error.c:30
msgid "Probable success"
msgstr "可能成功"

#: nis/nis_error.c:31
msgid "Not found"
msgstr "找不到"

#: nis/nis_error.c:32
msgid "Probably not found"
msgstr "可能找不到"

#: nis/nis_error.c:33
msgid "Cache expired"
msgstr "快取過時取消了"

#: nis/nis_error.c:34
msgid "NIS+ servers unreachable"
msgstr "NIS+ 伺服器無法連線"

#: nis/nis_error.c:35
msgid "Unknown object"
msgstr "未知的目的檔"

#: nis/nis_error.c:36
msgid "Server busy, try again"
msgstr "伺服器忙碌中，請再試一次"

#: nis/nis_error.c:37
msgid "Generic system error"
msgstr "一般系統錯誤"

#: nis/nis_error.c:38
msgid "First/next chain broken"
msgstr "第一個/下一個序列壞掉了"

#: nis/nis_error.c:41
msgid "Name not served by this server"
msgstr "網域名稱服務不是由此伺服器提供"

#: nis/nis_error.c:42
msgid "Server out of memory"
msgstr "伺服器記憶體已用完"

#: nis/nis_error.c:43
msgid "Object with same name exists"
msgstr "同名的目標已經存在"

#: nis/nis_error.c:44
msgid "Not master server for this domain"
msgstr "並非此一領域的主伺服器"

#: nis/nis_error.c:45
msgid "Invalid object for operation"
msgstr "不適用的運作物件"

#: nis/nis_error.c:46
msgid "Malformed name, or illegal name"
msgstr "奇怪的名字，或不合法的名字"

#: nis/nis_error.c:47
msgid "Unable to create callback"
msgstr "無法建立回叫資料 (callback)"

#: nis/nis_error.c:48
msgid "Results sent to callback proc"
msgstr "結果傳送給回傳程序"

#: nis/nis_error.c:49
msgid "Not found, no such name"
msgstr "找不到，沒有此一名稱"

#: nis/nis_error.c:50
msgid "Name/entry isn't unique"
msgstr "名稱/項目不是唯一的"

#: nis/nis_error.c:51
msgid "Modification failed"
msgstr "修改失敗"

#: nis/nis_error.c:52
msgid "Database for table does not exist"
msgstr "表格的資料庫不存在"

#: nis/nis_error.c:53
msgid "Entry/table type mismatch"
msgstr "項目/表格形態不符"

#: nis/nis_error.c:54
msgid "Link points to illegal name"
msgstr "連結指向不合法的名稱"

#: nis/nis_error.c:55
msgid "Partial success"
msgstr "部份成功"

#: nis/nis_error.c:56
msgid "Too many attributes"
msgstr "太多的屬性"

#: nis/nis_error.c:57
msgid "Error in RPC subsystem"
msgstr "RPC 子系統錯誤"

#: nis/nis_error.c:58
msgid "Missing or malformed attribute"
msgstr "缺少或奇怪的屬性"

#: nis/nis_error.c:59
msgid "Named object is not searchable"
msgstr "有名稱的物件無法搜尋"

#: nis/nis_error.c:60
msgid "Error while talking to callback proc"
msgstr "在與 callback proc 通訊時錯誤"

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

#: nis/nis_error.c:62
msgid "Illegal object type for operation"
msgstr "不合法的運作物件形態"

#: nis/nis_error.c:63
msgid "Passed object is not the same object on server"
msgstr "經過的物件與伺服器上的並不相同"

#: nis/nis_error.c:64
msgid "Modify operation failed"
msgstr "修改運作方式失敗"

#: nis/nis_error.c:65
msgid "Query illegal for named table"
msgstr "對記名表格的查詢並不合法"

#: nis/nis_error.c:66
msgid "Attempt to remove a non-empty table"
msgstr "嘗試刪除一個有內容的表格"

#: nis/nis_error.c:67
msgid "Error in accessing NIS+ cold start file.  Is NIS+ installed?"
msgstr "存取 NIS+ 原始啟動檔錯誤。有安裝 NIS+ 嗎？"

#: nis/nis_error.c:68
msgid "Full resync required for directory"
msgstr "目錄的 resync 請求已滿"

#: nis/nis_error.c:69
msgid "NIS+ operation failed"
msgstr "NIS+ 運作失敗"

#: nis/nis_error.c:70
msgid "NIS+ service is unavailable or not installed"
msgstr "NIS+ 服務無法取得或者尚未安裝"

#: nis/nis_error.c:71
msgid "Yes, 42 is the meaning of life"
msgstr "是的，42 就是存在的意義"

#: nis/nis_error.c:72
msgid "Unable to authenticate NIS+ server"
msgstr "無法對 NIS+ 的伺服端進行認證"

#: nis/nis_error.c:73
msgid "Unable to authenticate NIS+ client"
msgstr "無法對 NIS+ 的請求端進行認證"

#: nis/nis_error.c:74
msgid "No file space on server"
msgstr "伺服器上沒有檔案空間"

#: nis/nis_error.c:75
msgid "Unable to create process on server"
msgstr "無法在伺服器上建立執行程序"

#: nis/nis_error.c:76
msgid "Master server busy, full dump rescheduled."
msgstr "主要伺服器忙碌中，重新進行完整資料傾卸排程。"

#: nis/nis_local_names.c:126
#, 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:166
#, c-format
msgid "Name : `%s'\n"
msgstr "名稱 : `%s'\n"

#: nis/nis_print.c:167
#, c-format
msgid "Type : %s\n"
msgstr "格式 : %s\n"

#: nis/nis_print.c:172
msgid "Master Server :\n"
msgstr "主要伺服器 :\n"

#: nis/nis_print.c:174
msgid "Replicate :\n"
msgstr "複製 :\n"

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

#: nis/nis_print.c:176
msgid "\tPublic Key : "
msgstr "\t公共鑰匙 : "

#: nis/nis_print.c:180
msgid "None.\n"
msgstr "無\n"

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

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

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

#: nis/nis_print.c:194
#, c-format
msgid "Unknown (type = %d, bits = %d)\n"
msgstr "未知的 (形態 = %d，位元 = %d)\n"

#: nis/nis_print.c:205
#, c-format
msgid "\tUniversal addresses (%u)\n"
msgstr "\t絕對位址 (%u)\n"

#: nis/nis_print.c:227
msgid "Time to live : "
msgstr "存在時間 : "

#: nis/nis_print.c:229
msgid "Default Access rights :\n"
msgstr "預設的存取權限 :\n"

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

#: nis/nis_print.c:239
msgid "\tAccess rights: "
msgstr "\t存取權限: "

#: nis/nis_print.c:252
msgid "Group Flags :"
msgstr "群組旗標 :"

#: nis/nis_print.c:255
msgid ""
"\n"
"Group Members :\n"
msgstr ""
"\n"
"群組的成員 :\n"

#: nis/nis_print.c:266
#, c-format
msgid "Table Type          : %s\n"
msgstr "表格形式           : %s\n"

#: nis/nis_print.c:267
#, c-format
msgid "Number of Columns   : %d\n"
msgstr "欄位的數目 : %d\n"

#: nis/nis_print.c:268
#, c-format
msgid "Character Separator : %c\n"
msgstr "字元分隔號 : %c\n"

#: nis/nis_print.c:269
#, c-format
msgid "Search Path         : %s\n"
msgstr "搜尋路徑         : %s\n"

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

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

#: nis/nis_print.c:275
msgid "\t\tAttributes    : "
msgstr "\t\t屬性     : "

#: nis/nis_print.c:277
msgid "\t\tAccess Rights : "
msgstr "\t\t存取權限 : "

#: nis/nis_print.c:286
msgid "Linked Object Type : "
msgstr "連結的物件形態 : "

#: nis/nis_print.c:288
#, c-format
msgid "Linked to : %s\n"
msgstr "連結到 : %s\n"

#: nis/nis_print.c:297
#, c-format
msgid "\tEntry data of type %s\n"
msgstr "\t型別為 %s 的項目資料\n"

#: nis/nis_print.c:300
#, c-format
msgid "\t[%u] - [%u bytes] "
msgstr "\t[%u] - [%u 位元組] "

#: nis/nis_print.c:303
msgid "Encrypted data\n"
msgstr "編碼資料\n"

#: nis/nis_print.c:305
msgid "Binary data\n"
msgstr "二進位資料\n"

#: nis/nis_print.c:320
#, c-format
msgid "Object Name   : %s\n"
msgstr "物件名稱   : %s\n"

#: nis/nis_print.c:321
#, c-format
msgid "Directory     : %s\n"
msgstr "目錄     : %s\n"

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

#: nis/nis_print.c:323
#, c-format
msgid "Group         : %s\n"
msgstr "群組         : %s\n"

#: nis/nis_print.c:324
msgid "Access Rights : "
msgstr "存取權限 : "

#: nis/nis_print.c:326
#, c-format
msgid ""
"\n"
"Time to Live  : "
msgstr ""
"\n"
"存在的時間 : "

#: nis/nis_print.c:329
#, c-format
msgid "Creation Time : %s"
msgstr "產生時間 : %s"

#: nis/nis_print.c:331
#, c-format
msgid "Mod. Time     : %s"
msgstr "修改時間     : %s"

#: nis/nis_print.c:332
msgid "Object Type   : "
msgstr "物件型別   : "

#: nis/nis_print.c:352
#, c-format
msgid "    Data Length = %u\n"
msgstr "    資料長度 = %u\n"

#: nis/nis_print.c:365
#, c-format
msgid "Status            : %s\n"
msgstr "狀態              : %s\n"

#: nis/nis_print.c:366
#, c-format
msgid "Number of objects : %u\n"
msgstr "物件的數目 : %u\n"

#: nis/nis_print.c:370
#, c-format
msgid "Object #%d:\n"
msgstr "目的檔 #%d:\n"

#: nis/nis_print_group_entry.c:115
#, c-format
msgid "Group entry for \"%s.%s\" group:\n"
msgstr "群組 \"%s.%s\" 群組項目:\n"

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

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

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

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

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

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

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

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

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

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

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

#: nis/nss_nisplus/nisplus-publickey.c:101
#: 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:218
#, c-format
msgid "netname2user: missing group id list in `%s'."
msgstr "netname2user: `%s' 中缺少群組 id 列表。"

#: nis/nss_nisplus/nisplus-publickey.c:300
#: nis/nss_nisplus/nisplus-publickey.c:306
#: nis/nss_nisplus/nisplus-publickey.c:370
#: nis/nss_nisplus/nisplus-publickey.c:379
#, c-format
msgid "netname2user: (nis+ lookup): %s\n"
msgstr "netname2user: (nis+ 搜尋): %s\n"

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

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

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

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

#: nis/ypclnt.c:171
#, c-format
msgid "YPBINDPROC_DOMAIN: %s\n"
msgstr "YPBINDPROC_DOMAIN: %s\n"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: nscd/cache.c:94
msgid "while allocating hash table entry"
msgstr "在配置 hash 表格項目時"

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

#: nscd/connections.c:150
msgid "Cannot run nscd in secure mode as unprivileged user"
msgstr "無法以未獲授權的使用者身分在安全模式中執行 nscd"

#: nscd/connections.c:172
#, c-format
msgid "while allocating cache: %s"
msgstr "當配置快取項目: %s"

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

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

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

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

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

#: nscd/connections.c:485
#, c-format
msgid "while accepting connection: %s"
msgstr "在接受連線時: %s"

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

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

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

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

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

#: nscd/connections.c:635 nscd/connections.c:636 nscd/connections.c:655
#: nscd/connections.c:668 nscd/connections.c:674 nscd/connections.c:681
#, c-format
msgid "Failed to run nscd as user '%s'"
msgstr "以使用者 '%s' 的身分執行 nscd 失敗"

#: nscd/connections.c:656
msgid "getgrouplist failed"
msgstr "getgrouplist 失敗"

#: nscd/connections.c:669
msgid "setgroups failed"
msgstr "setgroups 失敗"

#: nscd/grpcache.c:103 nscd/hstcache.c:111 nscd/pwdcache.c:109
msgid "while allocating key copy"
msgstr "在配置鍵值副本時"

#: nscd/grpcache.c:153 nscd/hstcache.c:168 nscd/pwdcache.c:146
msgid "while allocating cache entry"
msgstr "在配置快取項目時"

#: nscd/grpcache.c:197 nscd/hstcache.c:283 nscd/pwdcache.c:193
#, c-format
msgid "short write in %s: %s"
msgstr "寫入 %s 的資料過短: %s"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: nscd/nscd.c:141
msgid "cannot read configuration file; this is fatal"
msgstr "無法讀取設定檔，這是一個嚴重錯誤"

#: nscd/nscd.c:152
msgid "already running"
msgstr "已在執行"

#: nscd/nscd.c:270 nscd/nscd.c:294 nscd/nscd_stat.c:132
msgid "Only root is allowed to use this option!"
msgstr "只有 root 才可以使用此一選項!"

#: nscd/nscd_conf.c:88
#, c-format
msgid "Parse error: %s"
msgstr "解析錯誤: %s"

#: nscd/nscd_conf.c:171
#, c-format
msgid "Could not create log file \"%s\""
msgstr "無法產生訊息檔 \"%s\""

#: nscd/nscd_conf.c:187
msgid "Must specify user name for server-user option"
msgstr "必須為伺服器使用者選項指定使用者名稱"

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

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

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

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

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

#: nscd/nscd_stat.c:150
msgid "write incomplete"
msgstr "寫入不完全"

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

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

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

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

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

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

#: nscd/nscd_stat.c:198
#, c-format
msgid "%15lu  number of times clients had to wait\n"
msgstr "%15lu  次數            須等待客戶端\n"

#: nscd/nscd_stat.c:213 nscd/nscd_stat.c:215
msgid "      no"
msgstr "      不"

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

#: nscd/nscd_stat.c:221
#, c-format
msgid ""
"\n"
"%s cache:\n"
"\n"
"%15s  cache is enabled\n"
"%15Zu  suggested size\n"
"%15lu  seconds time to live for positive entries\n"
"%15lu  seconds time to live for negative entries\n"
"%15lu  cache hits on positive entries\n"
"%15lu  cache hits on negative entries\n"
"%15lu  cache misses on positive entries\n"
"%15lu  cache misses on negative entries\n"
"%15lu%% cache hit rate\n"
"%15lu  current number of cached values\n"
"%15lu  maximum number of cached values\n"
"%15lu  maximum chain length searched\n"
"%15lu  number of delays on rdlock\n"
"%15lu  number of delays on wrlock\n"
"%15s  check /etc/%s for changes\n"
msgstr ""
"\n"
"%s 快取:\n"
"\n"
"%15s  快取已開啟\n"
"%15Zu  希望的大小\n"
"%15lu  正項目的存在時間 (秒)\n"
"%15lu  負項目的存在時間 (秒)\n"
"%15lu  正項目中找到快取數\n"
"%15lu  負項目中找到快取數\n"
"%15lu  正項目中遺漏的快取數\n"
"%15lu  負項目中遺漏的快取數\n"
"%15lu%% 快取找到的比例\n"
"%15lu  目前已快取數值量\n"
"%15lu  最大快取數值量\n"
"%15lu  最大已搜尋的鏈結長度\n"
"%15lu  在 rdlock 上的延遲數量\n"
"%15lu  在 wrlock 上的延遲數量\n"
"%15s  檢查 /etc/%s 的改變\n"

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

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

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

#: elf/../sysdeps/generic/dl-sysdep.c:422
msgid "cannot create capability list"
msgstr "無法建立 capability 列表"

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

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

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

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

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

#: elf/../sysdeps/generic/readelflib.c:109
msgid "more than one dynamic segment\n"
msgstr "超過一個的動態區段\n"

#: elf/../sysdeps/unix/sysv/linux/i386/readelflib.c:49
#, c-format
msgid "%s is for unknown machine %d.\n"
msgstr "%s 是給未知的機器 %d。\n"

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

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

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

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

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

#: elf/cache.c:158 elf/cache.c:168
msgid "File is not a cache file.\n"
msgstr "檔案並非快取檔。\n"

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

#: elf/cache.c:410
#, c-format
msgid "Can't remove old temporary cache file %s"
msgstr "無法刪除舊的暫時快取檔 %s"

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

#: elf/cache.c:425 elf/cache.c:434 elf/cache.c:438
msgid "Writing of cache data failed"
msgstr "寫入快取資料時發生錯誤"

#: elf/cache.c:442
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:128
msgid "shared object not open"
msgstr "共用目的檔案沒有開啟"

#: elf/dl-close.c:531 elf/dl-open.c:454
msgid "TLS generation counter wrapped!  Please send report with the 'glibcbug' script."
msgstr "TLS 產生計數器已被轉包! 請寄出以 'glibcbug' 命令稿所做的報告。"

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

#: elf/dl-deps.c:124
msgid "empty dynamics string token substitution"
msgstr "空的動態字串記號替換"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: elf/dl-load.c:1322
msgid "cannot create searchlist"
msgstr "無法建立搜尋列表"

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

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

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

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

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

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

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

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

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

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

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

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

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

#: elf/dl-lookup.c:265 elf/dl-lookup.c:443
msgid "relocation error"
msgstr "重定址錯誤"

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

#: elf/dl-open.c:214
msgid "empty dynamic string token substitution"
msgstr "空的動態字串記號替換"

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

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

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

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

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

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

#: elf/dl-reloc.c:289
#, c-format
msgid "%s: profiler out of memory shadowing PLTREL of %s\n"
msgstr "%s: 描述程式遮蔽 %s 的 PLTREL 時記憶體不足\n"

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

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

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

#: elf/ldconfig.c:122
msgid "Print cache"
msgstr "列印快取"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: elf/ldconfig.c:706 elf/ldconfig.c:753
#, c-format
msgid "Cannot lstat %s"
msgstr "無法 lstat %s"

#: elf/ldconfig.c:718
#, c-format
msgid "Cannot stat %s"
msgstr "無法 stat %s"

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

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

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

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

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

#: elf/ldconfig.c:962
#, c-format
msgid "Can't open configuration file %s"
msgstr "無法開啟設定檔 %s"

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

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

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

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

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

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

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

#: elf/sprof.c:72
msgid "Output selection:"
msgstr "輸出選擇:"

#: elf/sprof.c:74
msgid "print list of count paths and their number of use"
msgstr "列出計數的路徑以及它們使用的次數"

#: elf/sprof.c:76
msgid "generate flat profile with counts and ticks"
msgstr "從執行次數與經歷時間的資料中產生直接的測速結果"

#: elf/sprof.c:77
msgid "generate call graph"
msgstr "產生函式呼叫圖形"

#: elf/sprof.c:84
msgid "Read and display shared object profiling data"
msgstr "讀取並顯示共用函式的測速評估資料"

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

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

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

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

#: elf/sprof.c:534
msgid "mapping of section headers failed"
msgstr "映射結區標頭失敗"

#: elf/sprof.c:544
msgid "mapping of section header string table failed"
msgstr "映射結區的標頭字串表格失敗"

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

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

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

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

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

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

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

#: elf/sprof.c:709 elf/sprof.c:779
msgid "cannot create internal descriptor"
msgstr "無法建立內部敘述項"

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

#: elf/sprof.c:936 elf/sprof.c:988
msgid "cannot allocate symbol data"
msgstr "無法配置函式符號資料"
