gcc 4.8.0 - en to zh_TW translation catalogue (3730 entries)

en: 
    For bug reporting instructions, please see:
zh_TW: 
    報告程式缺陷的步驟請參見：

en: 
    For bug reporting instructions, please see:
    %s.
zh_TW: 
    提交錯誤報告的具體步驟請參見：
    %s。

en: 
    Go ahead? (y or n)
zh_TW: 
    繼續？(y 或 n)

en: 
    Options starting with -g, -f, -m, -O, -W, or --param are automatically
     passed on to the various sub-processes invoked by %s.  In order to pass
     other options on to these processes the -W<letter> options must be used.
zh_TW: 
    以 -g、-f、-m、-O、-W 或 --param 開頭的選項將由 %s 自動傳遞給其呼叫的
     不同子處理序。若要向這些處理序傳遞其它選項，必須使用 -W<字母> 選項。

en: 
    ldd output with constructors/destructors.
zh_TW: 
    ldd 輸出帶有建構/解構函式。

en: 
    write_c_file - output name is %s, prefix is %s
zh_TW: 
    write_c_file - 輸出名為 %s，字首為 %s

en:    in pointer to member conversion
zh_TW:   在成員指標轉換中

en:    in pointer to member function conversion
zh_TW:   在成員函式指標轉換中

en:   %q+#D declared here
zh_TW:   %q+#D 已在此宣告過

en:   (Use '-v --help' to display command line options of sub-processes)
zh_TW:   (使用「-v --help」顯示子處理序的命令列參數)

en:   -###                     Like -v but options quoted and commands not executed
zh_TW:   -###                     與 -v 類似，但選項被引號括住，並且不執行命令

en:   --bootclasspath PATH    Override built-in class path
zh_TW:   --bootclasspath PATH    覆寫內建的類別路徑

en:   --classpath PATH        Set path to find .class files
zh_TW:   --classpath 路徑        設定尋找 .class 檔案的路徑

en:   --extdirs PATH          Set extensions directory path
zh_TW:   --extdirs 路徑          設定擴充目錄

en:   --help                   Display this information
zh_TW:   --help                   顯示此輔助說明

en:   --help                  Print this help, then exit
zh_TW:   --help                  列印此輔助並離開

en:   --javap                 Generate output in 'javap' format
zh_TW:   --javap                 產生「javap」格式的輸出

en:   --target-help            Display target specific command line options
zh_TW:   --target-help            顯示目標平臺器特定的命令列選項

en:   --version               Print version number, then exit
zh_TW:   --version               列印版本號並離開

en:   -B <directory>           Add <directory> to the compiler's search paths
zh_TW:   -B <目錄>                將 <目錄> 加入到編譯器的搜尋路徑中

en:   -E                       Preprocess only; do not compile, assemble or link
zh_TW:   -E                       僅作預先處理，不進行編譯、組譯和連結

en:   -IDIR                   Append directory to class path
zh_TW:   -I目錄                  將目錄加入到類別路徑

en:   -S                       Compile only; do not assemble or link
zh_TW:   -S                       編譯到組合語言，不進行組譯和連結

en:   -Wa,<options>            Pass comma-separated <options> on to the assembler
zh_TW:   -Wa,<選項>               將逗號分隔的 <選項> 傳遞給組譯器

en:   -Wl,<options>            Pass comma-separated <options> on to the linker
zh_TW:   -Wl,<選項>               將逗號分隔的 <選項> 傳遞給連結器

en:   -Wp,<options>            Pass comma-separated <options> on to the preprocessor
zh_TW:   -Wp,<選項>               將逗號分隔的 <選項> 傳遞給前處理器

en:   -Xassembler <arg>        Pass <arg> on to the assembler
zh_TW:   -Xassembler <參數>       將 <參數> 傳遞給組譯器

en:   -Xlinker <arg>           Pass <arg> on to the linker
zh_TW:   -Xlinker <參數>          將 <參數> 傳遞給連結器

en:   -Xpreprocessor <arg>     Pass <arg> on to the preprocessor
zh_TW:   -Xpreprocessor <參數>    將 <參數> 傳遞給前處理器

en:   -a, --all-blocks                Show information for every basic block
zh_TW:   -a, --all-blocks                顯示每個基本區塊的資訊

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

en:   -c                       Compile and assemble, but do not link
zh_TW:   -c                       編譯、組譯到目的程式碼，不進行連結

en:   -c                      Disassemble method bodies
zh_TW:   -c                      反組譯方法體

en:   -c, --branch-counts             Given counts of branches taken
                                        rather than percentages
zh_TW:   -c, --branch-counts             給出跳轉的分支數，而不是百分比

en:   -dumpmachine             Display the compiler's target processor
zh_TW:   -dumpmachine             顯示編譯器的目的處理器

en:   -dumpspecs               Display all of the built in spec strings
zh_TW:   -dumpspecs               顯示所有內建 spec 字串

en:   -dumpversion             Display the version of the compiler
zh_TW:   -dumpversion             顯示編譯器的版本號

en:   -f, --function-summaries        Output summaries for each function
zh_TW:   -f, --function-summaries        輸出每個函式的小結資訊

en:   -h, --help                      Print this help, then exit
zh_TW:   -h, --help                      列印此輔助並離開

en:   -l, --long-file-names           Use long output file names for included
                                        source files
zh_TW:   -l, --long-file-names           為包含進來的來源檔案使用長輸出檔案名稱

en:   -n, --no-output                 Do not create an output file
zh_TW:   -n, --no-output                 不建立輸出檔案

en:   -o <file>                Place the output into <file>
zh_TW:   -o <檔案>                輸出到 <檔案>

en:   -o FILE                 Set output file name
zh_TW:   -o 檔案                 設定輸出檔案名稱

en:   -o, --object-directory DIR|FILE Search for object files in DIR or called FILE
zh_TW:   -o, --object-directory DIR|FILE 在 DIR 中搜尋目的檔案，或搜尋名為 FILE 的目的檔案

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

en:   -pass-exit-codes         Exit with highest error code from a phase
zh_TW:   -pass-exit-codes         在某一階段離開時回傳最高的錯誤碼

en:   -pipe                    Use pipes rather than intermediate files
zh_TW:   -pipe                    使用管道代替暫時檔案

en:   -print-file-name=<lib>   Display the full path to library <lib>
zh_TW:   -print-file-name=<函式庫>    顯示 <函式庫> 的完整路徑

en:   -print-libgcc-file-name  Display the name of the compiler's companion library
zh_TW:   -print-libgcc-file-name  顯示編譯器伴隨函式庫的名稱

en:   -print-multi-directory   Display the root directory for versions of libgcc
zh_TW:   -print-multi-directory   顯示不同版本 libgcc 的根目錄

en:   -print-multi-lib         Display the mapping between command line options and
                               multiple library search directories
zh_TW:   -print-multi-lib         顯示命令列選項和多個版本函式庫搜尋路徑間的對應

en:   -print-multi-os-directory Display the relative path to OS libraries
zh_TW:   -print-multi-os-directory 顯示作業系統函式庫的相對路徑

en:   -print-prog-name=<prog>  Display the full path to compiler component <prog>
zh_TW:   -print-prog-name=<程式>  顯示編譯器元件 <程式> 的完整路徑

en:   -print-search-dirs       Display the directories in the compiler's search path
zh_TW:   -print-search-dirs       顯示編譯器的搜尋路徑

en:   -save-temps              Do not delete intermediate files
zh_TW:   -save-temps              不要刪除中間檔案

en:   -specs=<file>            Override built-in specs with the contents of <file>
zh_TW:   -specs=<檔案>            用 <檔案> 的內容覆寫內建的 specs 檔案

en:   -std=<standard>          Assume that the input sources are for <standard>
zh_TW:   -std=<標準>              指定輸入來源檔案遵循的標準

en:   -time                    Time the execution of each subprocess
zh_TW:   -time                    為每個子處理序計時

en:   -u, --unconditional-branches    Show unconditional branch counts too
zh_TW:   -u, --unconditional-branches    同時顯示無條件跳轉數

en:   -v                       Display the programs invoked by the compiler
zh_TW:   -v                       顯示編譯器呼叫的程式

en:   -v, --verbose           Print extra information while running
zh_TW:   -v, --verbose           執行時列印附加資訊

en:   -v, --version                   Print version number, then exit
zh_TW:   -v, --version                    列印版本號並離開

en:   -x <language>            Specify the language of the following input files
                               Permissible languages include: c c++ assembler none
                               'none' means revert to the default behavior of
                               guessing the language based on the file's extension
zh_TW:   -x <語言>                指定其後輸入檔案的語言
                               允許的語言包括：c c++ assembler none
                               「none」意味著恢復預設行為，即根據檔案的副檔名猜測
                               來源檔案的語言

en:   a qualified-id is required
zh_TW:   需要一個限定的識別碼

en:   as it is a non-system directory that duplicates a system directory
zh_TW:   因為它是一個重複了系統目錄的非系統目錄

en:   base %qT
zh_TW:   基礎類別 %qT

en:   because conversion sequence for the argument is better
zh_TW:   因為前者的引數類型轉換序列更好

en:   because of local member %q+#D with same name
zh_TW:  因為局部成員 %q+#D 與之同名

en:   because of local method %q+#D with same name
zh_TW:  因為局部方法 %q+#D 與之同名

en:   but %d required
zh_TW:   但實際需要 %d 個

en:   but does not override %<%T(const %T&)%>
zh_TW:   但沒有多載 %<%T(const %T&)%>

en:   but does not override %<operator=(const %T&)%>
zh_TW:   也沒有多載 %<operator=(const %T&)%>

en:   by %q+D
zh_TW:   為 %q+D

en:   candidate conversions include %qD and %qD
zh_TW:   備選轉換包括 %qD 和 %qD

en:   cannot use obsolete binding at %q+D because it has a destructor
zh_TW:   不能在 %q+D 使用過時的繫結，因為它有解構函式

en:   crosses initialization of %q+#D
zh_TW:   略過 %q+#D 的初始化

en:   enters catch block
zh_TW:   進入 catch 區塊

en:   enters try block
zh_TW:   進入 try 區塊

en:   expected a class template, got %qE
zh_TW:   需要一個類別範本，卻給出了 %qE

en:   expected a class template, got %qT
zh_TW:   需要一個類別範本，卻給出了 %qT

en:   expected a constant of type %qT, got %qT
zh_TW:   需要一個 %qT 類型的常數，卻給出了 %qT

en:   expected a type, got %qE
zh_TW:   需要一個類型，卻給出了 %qE

en:   expected a type, got %qT
zh_TW:   需要一個類型，卻給出了 %qT

en:   for conversion from %qT to %qT
zh_TW:   當從 %qT 轉換為 %qT 時

en:   from definition of %q+#D
zh_TW:   從 %q+#D 的定義

en:   from here
zh_TW:   從這裡

en:   in call to %qD
zh_TW:   在呼叫 %qD 時

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

en:   in instantiation of template %qT
zh_TW:   在範本 %qT 的實體化中

en:   in thrown expression
zh_TW:   在拋出的運算式中

en:   initializing argument %P of %qD
zh_TW:   初始化引數 %P，屬於 %qD

en:   matches this %q+D under ISO standard rules
zh_TW:   在 ISO 標準規則下匹配此 %q+D

en:   matches this %q+D under old rules
zh_TW:   在舊規則下匹配此 %q+D

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

en:   overriding %q+#D
zh_TW:   覆寫了 %q+#D

en:   overriding %q+#F
zh_TW:   覆寫了 %q+#F

en:   since %q+#D declared in base class
zh_TW:   因為 %q+#D 已在基礎類別中宣告過

en:   skips initialization of %q+#D
zh_TW:   略過 %q+#D 的初始化

en:   trying to instantiate %qD
zh_TW:   試圖實體化 %qD

en:   using obsolete binding at %q+D
zh_TW:   在 %q+D 使用過時的繫結

en:  conflicting code gen style switches are used
zh_TW:  衝突的程式碼產生選項

en:  shadows template parm %q+#D
zh_TW:  隱藏了模版參數 %q+#D

en: #include "..." search starts here:
zh_TW: #include "..." 搜尋從這裡開始：

en: #include <...> search starts here:
zh_TW: #include <...> 搜尋從這裡開始：

en: #pragma GCC memregs must precede any function decls
zh_TW: #pragma GCC memregs 必須出現在所有函式宣告之前

en: #pragma GCC memregs takes a number [0..16]
zh_TW: #pragma GCC memregs 需要 [0..16] 範圍內的數

en: #pragma GCC visibility must be followed by push or pop
zh_TW: #pragma GCC visibility 後面必須跟 push 或 pop

en: #pragma GCC visibility push() must specify default, internal, hidden or protected
zh_TW: #pragma GCC visibility push() 必須指定 default、internal、hidden 或 protected

en: #pragma GHS endXXX does not match previous startXXX
zh_TW: #pragma GHS endXXX 與先前的 startXXX 不匹配

en: #pragma GHS endXXXX found without previous startXXX
zh_TW: #pragma GHS endXXXX 前沒有 startXXX

en: #pragma implementation for %qs appears after file is included
zh_TW: 檔案在 %qs 的 #pragma implementation 出現前已被包含

en: #pragma pack (pop) encountered without matching #pragma pack (push)
zh_TW: #pragma pack (pop) 沒有相匹配的 #pragma pack (push)

en: #pragma pack has no effect with -fpack-struct - ignored
zh_TW: 指定了 -fpack-struct 時 #pragma pack 無效  - 已忽略

en: #pragma redefine_extname ignored due to conflict with __asm__ declaration
zh_TW: #pragma redefine_extname 因與 __asm__ declaration 衝突而被忽略

en: #pragma redefine_extname ignored due to conflict with previous #pragma redefine_extname
zh_TW: #pragma redefine_extname 因與先前的 #pragma redefine_extname 衝突而被忽略

en: #pragma redefine_extname ignored due to conflict with previous rename
zh_TW: #pragma redefine_extname 因與先前的 rename 衝突而被忽略

en: #pragma vtable no longer supported
zh_TW: #pragma vtable 不再受支援

en: $ operand number used after format without operand number
zh_TW: $ 運算元號在不使用運算元號的格式後被使用

en: %+D causes a section type conflict
zh_TW: %+D 導致一個區段類型衝突

en: %<#pragma%> is not allowed here
zh_TW: 在這裡不允許使用 %<#pragma%>

en: %<%%%> constraint used with last operand
zh_TW: %<%%%> 約束用於最後一個運算元

en: %<%%%c%> yields only last 2 digits of year
zh_TW: %<%%%c%> 只給出 2 位表示的年分

en: %<%%%c%> yields only last 2 digits of year in some locales
zh_TW: %<%%%c%> 在某些區域設定下只給出 2 位表示的年分

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

en: %<%T::%D%> names constructor in %qT
zh_TW: %<%T::%D%> 在 %qT 內指定了建構式

en: %<%T::%D%> names destructor
zh_TW: %<%T::%D%> 指定了解構函式

en: %<%s %E%> declared inside parameter list
zh_TW: %<%s %E%> 在參數表內部宣告

en: %<&%> constraint used with no register class
zh_TW: %<&%> 約束未與暫存器類型一起使用

en: %<-gnat%> misspelled as %<-gant%>
zh_TW: %<-gnat%> 被錯誤地拼寫為 %<-gant%>

en: %<...%> as arguments.)
zh_TW: %<...%> 做為引數。)

en: %<...%> has invalid operand number
zh_TW: %<...%> 運算元號不正確

en: %<::%D%> has not been declared
zh_TW: %<::%D%> 尚未宣告

en: %<::main%> must return %<int%>
zh_TW: %<::main%> 必須回傳 %<int%>

en: %<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>
zh_TW: %<<:%> 是 %<[%> 的另一種拼法。請在 %<<%> 和 %<::%> 間加上空格

en: %<<::%> cannot begin a template-argument list
zh_TW: 不能以 %<<::%> 開始一個範本引數清單

en: %<@encode%> must specify a type as an argument
zh_TW: %<@encode%> 必須指定一個類型做為引數

en: %<@end%> missing in implementation context
zh_TW: 實作上下文中缺少 %<@end%>

en: %<@end%> must appear in an @implementation context
zh_TW: %<@end%> 必須出現在 @implementation 上下文中

en: %<@throw%> (rethrow) used outside of a @catch block
zh_TW: 在 @catch 區塊外使用 %<@throw%> (rethrow)

en: %<@try%> without %<@catch%> or %<@finally%>
zh_TW: %<@try%> 缺少對應的 %<@catch%> 或 %<@finally%>

en: %<__BELOW100__%> attribute only applies to variables
zh_TW: 屬性 %<__BELOW100__%> 只對變數類型起作用

en: %<__alignof%> applied to a bit-field
zh_TW: 將 %<__alignof%> 用於位元段

en: %<__builtin_longjmp%> second argument must be 1
zh_TW: %<__builtin_longjmp%> 的第二個引數必須是 1

en: %<__builtin_next_arg%> called without an argument
zh_TW: 呼叫 %<__builtin_next_arg%> 時沒有給定引數

en: %<__gcc_host_wide_int__%> is not defined as %<long%> or %<long long%>
zh_TW: %<__gcc_host_wide_int__%> 未被定義為 %<long%> 或 %<long long%>

en: %<__gcc_host_wide_int__%> is not defined as a type
zh_TW: %<__gcc_host_wide_int__%> 未被定義為一個類型

en: %<__thread%> before %<extern%>
zh_TW: %<__thread%> 出現在 %<extern%> 之前

en: %<__thread%> before %<static%>
zh_TW: %<__thread%> 出現在 %<static%> 之前

en: %<__thread%> used with %<auto%>
zh_TW: %<__thread%> 與 %<auto%> 一起使用

en: %<__thread%> used with %<register%>
zh_TW: %<__thread%> 與 %<register%> 一起使用

en: %<__thread%> used with %<typedef%>
zh_TW: %<__thread%> 與 %<typedef%> 一起使用

en: %<__thread%> used with %qE
zh_TW: %<__thread%> 與 %qE 一起使用

en: %<and%> of mutually exclusive equal-tests is always 0
zh_TW: 對兩個互斥的相等比較取 %<and%> 的結果永遠是 0

en: %<asm%> operand constraint incompatible with operand size
zh_TW: %<asm%> 運算元的約束與運算元大小不相容

en: %<asm%> operand requires impossible reload
zh_TW: %<asm%> 要求不可能的重新載入

en: %<asm%> specifiers are not permitted on non-static data members
zh_TW: %<asm%> 指定不允許用於非靜態資料成員

en: %<auto%> in file-scope empty declaration
zh_TW: 檔案作用欄位中出現 %<auto%> 空宣告

en: %<default%> label not within a switch statement
zh_TW: %<default%> 標籤未出現在 switch 敘述內

en: %<enum %E%> declared in %<for%> loop initial declaration
zh_TW: %<enum %E%> 宣告於 %<for%> 循環初始宣告中

en: %<explicit%> can only be specified for constructors
zh_TW: 只能為建構式指定 %<explicit%>

en: %<friend%> can only be specified inside a class
zh_TW: %<friend%> 只能在類別中指定

en: %<inline%> in empty declaration
zh_TW: %<inline%> 用於空宣告中

en: %<inline%> is not allowed in declaration of friend template specialization %qD
zh_TW: %<inline%> 不允許用於夥伴範本特例化 %qD 的宣告

en: %<inline%> specified for friend class declaration
zh_TW: 夥伴函式宣告中出現了 %<inline%>

en: %<inline%> specifier invalid for function %qs declared out of global scope
zh_TW: 在全域作用欄位外為函式 %qs 指定 %<inline%> 無效

en: %<location_t%> is not defined as a type
zh_TW: %<location_t%> 未被定義為一個類型

en: %<locus%> is not defined as a type
zh_TW: %<locus%> 未被定義為一個類型

en: %<long long long%> is too long for GCC
zh_TW: %<long long long%> 對 GCC 來說太長了

en: %<long%> switch expression not converted to %<int%> in ISO C
zh_TW: 在 ISO C 中，%<long%> 開關運算式不被轉換為 %<int%>

en: %<operator delete%> must return type %qT
zh_TW: %<operator delete%> 必須回傳 %qT

en: %<operator delete%> takes type %qT as first parameter
zh_TW: %<operator delete%> 的第一個參數類型為 %qT

en: %<operator new%> must not return NULL unless it is declared %<throw()%> (or -fcheck-new is in effect)
zh_TW: %<operator new%> 不能回傳 NULL，除非它被宣告為 %<throw()%> (或 -fcheck-new 起作用)

en: %<operator new%> must return type %qT
zh_TW: %<operator new%> 必須回傳 %qT

en: %<operator new%> takes type %<size_t%> (%qT) as first parameter
zh_TW: %<operator new%> 的第一個參數類型為 %<size_t%> (%qT)

en: %<operator=%> should return a reference to %<*this%>
zh_TW: %<operator=%> 應當回傳一個對 %<*this%> 的參照

en: %<or%> of unmatched not-equal tests is always 1
zh_TW: 對兩個不匹配的不等比較取 %<or%> 的結果總為 1

en: %<register%> in file-scope empty declaration
zh_TW: 檔案作用欄位中出現 %<register%> 空宣告

en: %<return%> with a value, in function returning void
zh_TW: 在無回傳值的函式中，%<return%> 帶回傳值

en: %<return%> with no value, in function returning non-void
zh_TW: 在有回傳值的的函式中，%<return%> 不帶回傳值

en: %<sizeof%> applied to a bit-field
zh_TW: 對位元段使用 %<sizeof%>

en: %<static%> may not be used when defining (as opposed to declaring) a static data member
zh_TW: 與宣告不同，定義靜態資料成員時不能使用 %<static%>

en: %<static%> specified invalid for function %qs declared out of global scope
zh_TW: 在全域作用欄位外為函式 %qs 指定 %<static%> 無效

en: %<struct %E%> declared in %<for%> loop initial declaration
zh_TW: %<struct %E%> 宣告於 %<for%> 循環初始宣告中

en: %<this%> is unavailable for static member functions
zh_TW: 靜態成員函式中不能使用 %<this%>

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

en: %<tree%> is not defined as a pointer type
zh_TW: %<tree%> 未被定義為一個指標類型

en: %<tree%> is not defined as a type
zh_TW: %<tree%> 未被定義為一個類型

en: %<typeof%> applied to a bit-field
zh_TW: 為位元段使用 %<typeof%>

en: %<union %E%> declared in %<for%> loop initial declaration
zh_TW: %<union %E%> 宣告於 %<for%> 循環初始宣告中

en: %<va_start%> used in function with fixed args
zh_TW: 在定參數的函式中使用了 %<va_start%>

en: %<void%> as only parameter may not be qualified
zh_TW: %<void%> 做為僅有的參數時不能被限定

en: %<void%> must be the only parameter
zh_TW: %<void%> 必須是僅有的參數

en: %E qualifier ignored on asm
zh_TW: %E 限定在 asm 上被忽略

en: %i-bit mode not compiled in
zh_TW: 未編譯入對 %i 位模式的支援

en: %q#D conflicts with previous using declaration %q#D
zh_TW: %q#D 與先前的 using 宣告 %q#D 衝突

en: %q#D hides constructor for %q#T
zh_TW: %q#D 隱藏了 %q#T 的建構式

en: %q#D is a static data member; it can only be initialized at its definition
zh_TW: %q#D 是一個靜態資料成員；它只能在定義時被初始化

en: %q#D is not a non-static data member of %qT
zh_TW: %q#D 不是 %qT 的非靜態資料成員

en: %q#D is not a static member of %q#T
zh_TW: %q#D 不是 %q#T 的靜態成員

en: %q#D redeclared as different kind of symbol
zh_TW: %q#D 被重新宣告為不同意義的符號

en: %q#T has pointer data members
zh_TW: %q#T 有指標資料成員

en: %q#T is not a template
zh_TW: %q#T 不是一個範本

en: %q#T only defines a private destructor and has no friends
zh_TW: %q#T 僅定義了一個私有解構函式且沒有夥伴

en: %q#T only defines private constructors and has no friends
zh_TW: %q#T 僅定義了一個私有建構式且沒有夥伴

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

en: %q#T used where a floating point value was expected
zh_TW: 需要浮點數值時使用了 %q#T

en: %q+#D cannot be declared
zh_TW: 無法宣告 %q+#D

en: %q+#D cannot be overloaded
zh_TW: %q+#D 無法被多載

en: %q+#D does not refer to the unqualified type, so it is not used for linkage
zh_TW: %q+#D 未指明非限定類型，所以它不做為外部連結

en: %q+#D invalid; an anonymous union can only have non-static data members
zh_TW: %q+#D 無效；匿名聯合只能有非靜態的資料成員

en: %q+#D is inaccessible
zh_TW: %q+#D 無法存取

en: %q+#D is private
zh_TW: %q+#D 是私有的

en: %q+#D is protected
zh_TW: %q+#D 是保護的

en: %q+#D previously declared here
zh_TW: %q+#D 已在此宣告過

en: %q+#D previously defined here
zh_TW: %q+#D 已在此定義過

en: %q+D already declared with dllexport attribute: dllimport ignored
zh_TW: %q+D 已被宣告為具有 dllexport 屬性：忽略 dllimport

en: %q+D causes a section type conflict
zh_TW: %q+D 導致一個區段類型衝突

en: %q+D contains empty classes which may cause base classes to be placed at different locations in a future version of GCC
zh_TW: %q+D 包含一個空類別，基礎類別的位置在 GCC 的未來版本可能會有變化

en: %q+D declared as a friend
zh_TW: %q+D 宣告為夥伴

en: %q+D declared here
zh_TW: %q+D 已在此宣告過

en: %q+D declared with an exception specification
zh_TW: %q+D 宣告時有異常指定

en: %q+D defined but not used
zh_TW: %q+D 定義後未使用

en: %q+D has a previous declaration as %q#D
zh_TW: %q+D 早先被宣告為 %q#D

en: %q+D invalid in %q#T
zh_TW: %q+D 無效，在 %q#T 中

en: %q+D is too small to hold all values of %q#T
zh_TW: %q+D 太小而不能存放 %q#T 的所有可能值

en: %q+D is usually a function
zh_TW: %q+D 一般是一個函式

en: %q+D may not be static because it is a member of a union
zh_TW: %q+D 不能是靜態的，因為它是聯合的成員

en: %q+D may not have reference type %qT because it is a member of a union
zh_TW: %q+D 不能有參照類型 %qT，因為它是聯合的成員

en: %q+D redeclared as different kind of symbol
zh_TW: %q+D 被重新宣告為不同意義的符號

en: %q+D redeclared without dllimport attribute after being referenced with dll linkage
zh_TW: %q+D 重宣告時沒有 dllimport 屬性，但已被做為 dllimport 連結參照過

en: %q+D redeclared without dllimport attribute: previous dllimport ignored
zh_TW: %q+D 重宣告時沒有 dllimport 屬性：忽略先前的 dllimport

en: %q+D takes only zero or two arguments
zh_TW: %q+D 只帶零或兩個參數

en: %q+D used prior to declaration
zh_TW: %q+D 在宣告前使用

en: %q+D was hidden
zh_TW: %q+D 被隱藏

en: %q+D will be initialized after
zh_TW: %q+D 將隨後被初始化

en: %q+D: visibility attribute ignored because it
zh_TW: %q+D：可見性屬性被忽略，因為它

en: %q+F declared %<static%> but never defined
zh_TW: %q+F 宣告為 %<static%> 卻從未定義過

en: %q+F used but never defined
zh_TW: %q+F 使用過但從未定義

en: %q+T has a previous declaration here
zh_TW: %q+T 先前在此處有過宣告

en: %qD attribute directive ignored
zh_TW: 指定 %qD 屬性被忽略

en: %qD cannot appear in a constant-expression
zh_TW: %qD 不能出現在常數運算式中

en: %qD cannot be declared virtual, since it is always static
zh_TW: %qD 不能宣告為虛函式，因為它總是靜態的

en: %qD cannot be initialized by a non-constant expression when being declared
zh_TW: %qD 不能由一個宣告時非常數的運算式初始化

en: %qD cannot have default arguments
zh_TW: %qD 不能有預設參數

en: %qD declared as reference but not initialized
zh_TW: %qD 宣告為參照卻未被初始化

en: %qD has an incomplete type
zh_TW: %qD 類型不完全

en: %qD has no member named %qE
zh_TW: %qD 沒具名為 %qE 的成員

en: %qD has the same name as the class in which it is declared
zh_TW: %qD 與其宣告所在的類別同名

en: %qD is a namespace
zh_TW: %qD 是一個命名空間

en: %qD is already a friend of %qT
zh_TW: %qD 已經是 %qT 的夥伴

en: %qD is already a friend of class %qT
zh_TW: %qD 已經是類別 %qT 的夥伴

en: %qD is already declared in this scope
zh_TW: %qD 已在此作用欄位中宣告過

en: %qD is already defined in %qT
zh_TW: %qD 已在 %qT 中定義過

en: %qD is already defined in class %qT
zh_TW: %qD 已在類別 %qT 中定義過

en: %qD is already defined in the class %qT
zh_TW: %qD 已在類別 %qT 中定義過

en: %qD is both a direct base and an indirect virtual base
zh_TW: %qD 既是一個直接基礎類別又是一個間接虛基礎類別

en: %qD is not a class or namespace
zh_TW: %qD 既不是類別也不是命名空間

en: %qD is not a function template
zh_TW: %qD 不是一個函式範本

en: %qD is not a member of %qD
zh_TW: %qD 不是 %qD 的成員

en: %qD is not a member of %qT
zh_TW: %qD 不是 %qT 的成員

en: %qD is not a member template function
zh_TW: %qD 不是一個成員範本函式

en: %qD is not a namespace-name
zh_TW: %qD 不是一個命名空間

en: %qD is not a template
zh_TW: %qD 不是一個範本

en: %qD is not a template function
zh_TW: %qD 不是一個範本函式

en: %qD is not defined outside of function scope
zh_TW: %qD 在函式作用欄位外未被定義

en: %qD may not be declared as static
zh_TW: %qD 不能被宣告為靜態的

en: %qD may not be declared within a namespace
zh_TW: %qD 不能在命名空間宣告

en: %qD must be a nonstatic member function
zh_TW: %qD 必須是一個非靜態的成員函式

en: %qD must be either a non-static member function or a non-member function
zh_TW: %qD 必須是一個非靜態成員函式或非成員函式

en: %qD must have an argument of class or enumerated type
zh_TW: %qD 的引數必須有類別或列舉類型

en: %qD must take %<void%>
zh_TW: %qD 必須有 %<void%> 類型

en: %qD must take either one or two arguments
zh_TW: %qD 必須帶 1 或 2 個引數

en: %qD must take either zero or one argument
zh_TW: %qD 必須帶 0 或 1 個引數

en: %qD must take exactly one argument
zh_TW: %qD 帶且僅帶 1 個引數

en: %qD must take exactly two arguments
zh_TW: %qD 帶且僅帶 2 個引數

en: %qD not declared
zh_TW: %qD 未宣告

en: %qD not defined
zh_TW: %qD 未定義

en: %qD redeclared with different access
zh_TW: %qD 重宣告時有不同的可存取性

en: %qD should have been declared inside %qD
zh_TW: %qD 應當已在 %qD 內部宣告過

en: %qD should never be overloaded
zh_TW: %qD 永遠不應該被多載

en: %qD should return by value
zh_TW: %qD 應當回傳值而非參照

en: %qD used without template parameters
zh_TW: %qD 使用時未帶範本參數

en: %qD was declared %<extern%> and later %<static%>
zh_TW: %qD 先被宣告為 %<extern%> 後又被宣告為 %<static%>

en: %qD was not declared in this scope
zh_TW: %qD 在此作用欄位中尚未宣告

en: %qE attribute can only be applied to Java class definitions
zh_TW: 只能為 Java 類別定義套用 %qE 屬性

en: %qE attribute can only be applied to class definitions
zh_TW: 只能為類別定義套用 %qE 屬性

en: %qE attribute have effect only on public objects
zh_TW: %qE 屬性只能套用到公共物件上

en: %qE attribute ignored
zh_TW: %qE 屬性被忽略

en: %qE attribute ignored for %qE
zh_TW: %qE 屬性為 %qE 所忽略

en: %qE attribute ignored for field of type %qT
zh_TW: %qE 屬性為 %qT 型態的欄位所忽略

en: %qE attribute ignored on non-class types
zh_TW: %qE 屬性在不是類別的類型上被忽略

en: %qE attribute ignored on types
zh_TW: %qE 屬性在類型上被忽略

en: %qE attribute is not supported on this platform
zh_TW: %qE 屬性在此平臺上不受支援

en: %qE attribute only applies to variadic functions
zh_TW: %qE 屬性只能用於帶可變參數函式

en: %qE attribute requires prototypes with named arguments
zh_TW: %qE 屬性需要帶具名引數的原型

en: %qE cannot be used as a function
zh_TW: %qE 不能做為函式

en: %qE cannot be used as a member pointer, since it is of type %qT
zh_TW: %qE 不能做為成員指標，因為它的類型為 %qT

en: %qE does not have class type
zh_TW: %qE 不是一個類別

en: %qE does not name a type
zh_TW: %qE 沒有命名一個類型

en: %qE fails to be a typedef or built in type
zh_TW: %qE 不是一個 typedef 類型，也不是一個內建類型

en: %qE in namespace %qE does not name a type
zh_TW: %qE 在命名空間 %qE 中沒有命名一個類型

en: %qE is an unrecognized format function type
zh_TW: %qE 是一個無法辨識的格式字串函式類型

en: %qE is neither function nor member function; cannot be declared friend
zh_TW: %qE 既不是函式也不是成員函式；不能宣告為夥伴

en: %qE is not a template
zh_TW: %qE 不是一個範本

en: %qE is not a valid template argument for type %qT because it is a pointer
zh_TW: %qE 不是類型 %qT 的有效範本引數，因為它是一個指標

en: %qE is not a valid template argument for type %qT because it is of type %qT
zh_TW: %qE 不是類型 %qT 的有效範本引數，因為它的類型是 %qT

en: %qE is not a valid template argument for type %qT because object %qD has not external linkage
zh_TW: %qE 不是類型 %qT 的有效範本引數，因為物件 %qD 沒有外部連結

en: %qE is not a valid template argument for type %qT because of conflicts in cv-qualification
zh_TW: %qE 不是類型 %qT 的有效範本引數，因為 cv 限定衝突

en: %qE is not a valid template argument for type %qT because string literals can never be used in this context
zh_TW: %qE 不是類型 %qT 的有效範本引數，因為字面字串不能用在此上下文中

en: %qE is not at beginning of declaration
zh_TW: %qE 沒有出現在宣告的開頭

en: %qE is not of type %qT
zh_TW: %qE 的類型不是 %qT

en: %qE is obsolete; g++ vtables are now COM-compatible by default
zh_TW: %qE 已過時：g++ 的虛函式表現在預設與 COM 相容

en: %qT has no member named %qE
zh_TW: %qT 沒具名為 %qE 的成員

en: %qT has no non-static data member named %qD
zh_TW: %qT 沒具名為 %qD 的非靜態資料成員

en: %qT is a variably modified type
zh_TW: %qT 是一個可變類型

en: %qT is already a friend of %qT
zh_TW: %qT 已經是 %qT 的夥伴

en: %qT is an ambiguous base of %qT
zh_TW: %qT 是 %qT 的有歧義的基礎類別

en: %qT is an inaccessible base of %qT
zh_TW: %qT 是 %qT 不可存取的基礎類別

en: %qT is not a base of %qT
zh_TW: %qT 不是 %qT 的基礎類別

en: %qT is not a class or namespace
zh_TW: %qT 既不是類別也不是命名空間

en: %qT is not a class, struct, or union type
zh_TW: %qT 不是類別、結構或聯合類型

en: %qT is not a member class template of %qT
zh_TW: %qT 不是 %qT 的成員類別範本

en: %qT is not a member of %qT
zh_TW: %qT 不是 %qT 的成員

en: %qT is not a namespace
zh_TW: %qT 不是一個命名空間

en: %qT is not a nested class of %qT
zh_TW: %qT 不是 %qT 的巢狀類別

en: %qT is not a pointer-to-object type
zh_TW: %qT 不是一個參照物件的類型

en: %qT is not a template
zh_TW: %qT 不是一個範本

en: %qT is not a template type
zh_TW: %qT 不是一個範本類型

en: %qT is not an accessible base of %qT
zh_TW: %qT 是 %qT 的一個不可存取的基礎類別

en: %qT is promoted to %qT when passed through %<...%>
zh_TW: 透過 %<...%> 傳遞時 %qT 被提升為 %qT

en: %qT is/uses anonymous type
zh_TW: %qT 是/使用了匿名類型

en: %qT referred to as %qs
zh_TW: %qT 做為 %qs 被參照

en: %qT referred to as enum
zh_TW: %qT 做為列舉被參照

en: %qT resolves to %qT, which is is not a class type
zh_TW: %qT 被解析到非類別類型 %qT

en: %qT resolves to %qT, which is not an enumeration type
zh_TW: %qT 被解析到非列舉類型 %qT

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

en: %qs attribute ignored
zh_TW: 忽略 %qs 屬性

en: %qs attribute only applies to functions
zh_TW: %qs 屬性只能套用於函式

en: %qs can only be specified for functions
zh_TW: 只能為函式指定 %qs

en: %qs declared as function returning a function
zh_TW: %qs 宣告為回傳一個函式的函式

en: %qs declared as function returning an array
zh_TW: %qs 宣告為回傳一個陣列的函式

en: %qs expects a constant argument
zh_TW: %qs 需要一個常數引數

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

en: %qs has overflowed
zh_TW: %qs 已溢出

en: %qs initialized and declared %<extern%>
zh_TW: %qs 已初始化，卻又被宣告為 %<extern%>

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

en: %qs is not a gcov data file
zh_TW: %qs 不是一個 gcov 資料檔案

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

en: %qs tag used in naming %q#T
zh_TW: 使用了 %qs 標記，在命名 %q#T 時

en: %qs uses dynamic stack allocation
zh_TW: %qs 使用動態堆疊指派

en: %s '%s'
zh_TW: %s「%s」

en: %s at %L must be INTEGER
zh_TW: %s (%L 處)必須是 INTEGER

en: %s at %L must be a scalar
zh_TW: %s (%L 處)必須是一個標量

en: %s attribute conflicts with %s attribute at %L
zh_TW: %s 屬性與 %s 屬性在 %L 處衝突

en: %s attribute conflicts with %s attribute in '%s' at %L
zh_TW: %s 屬性與 %s 屬性衝突，在「%s」中，位於 %L

en: %s attribute not allowed in BLOCK DATA program unit at %L
zh_TW: %s 屬性在 %L 處不允許出現在 BLOCAK DATA 程式單元中

en: %s cannot be used in asm here
zh_TW: %s 不能在這裡用於 asm

en: %s does not support %%n$ operand number formats
zh_TW: %s 不支援 %%n$ 運算元號格式字串

en: %s does not support %s
zh_TW: %s 不支援 %s

en: %s does not support %s with the %<%%%c%> %s format
zh_TW: %s 不支援 %s 出現在 %<%%%c%> %s 格式字串中

en: %s does not support block_ends_with_call_p
zh_TW: %s 不支援 block_ends_with_call_p

en: %s does not support block_ends_with_condjump_p
zh_TW: %s 不支援 block_ends_with_condjump_p

en: %s does not support can_duplicate_block_p
zh_TW: %s 不支援 can_duplicate_block_p

en: %s does not support can_merge_blocks_p
zh_TW: %s 不支援 can_merge_blocks_p

en: %s does not support create_basic_block
zh_TW: %s 不支援 create_basic_block

en: %s does not support delete_basic_block
zh_TW: %s 不支援 delete_basic_block

en: %s does not support duplicate_block
zh_TW: %s 不支援 duplicate_block

en: %s does not support flow_call_edges_add
zh_TW: %s 不支援 flow_call_edges_add

en: %s does not support make_forwarder_block
zh_TW: %s 不支援 make_forwarder_block

en: %s does not support merge_blocks
zh_TW: %s 不支援 merge_blocks

en: %s does not support move_block_after
zh_TW: %s 不支援t move_block_after

en: %s does not support predict_edge
zh_TW: %s 不支援 predict_edge

en: %s does not support predicted_by_p
zh_TW: %s 不支援 predicted_by_p

en: %s does not support redirect_edge_and_branch
zh_TW: %s 不支援 redirect_edge_and_branch

en: %s does not support redirect_edge_and_branch_force
zh_TW: %s 不支援 redirect_edge_and_branch_force

en: %s does not support split_block
zh_TW: %s 不支援 split_block

en: %s does not support split_edge
zh_TW: %s 不支援 split_edge

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

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

en: %s does not support the %qs %s length modifier
zh_TW: %s 不支援 %qs %s 長度修飾符

en: %s expression list treated as compound expression
zh_TW: %s 運算式清單被看作複合運算式

en: %s ignored with %s and %<%%%c%> %s format
zh_TW: %s 與 %s 和  %<%%%c%> %s 格式字串合用時被忽略

en: %s ignored with %s in %s format
zh_TW: %s 和 %s 出現在 %s 格式字串中時被忽略

en: %s is not supported by this configuration
zh_TW: %s 不為這個配置所支援

en: %s returned %d exit status
zh_TW: %s 以回傳值 %d 離開

en: %s statement at %C cannot follow %s statement at %L
zh_TW: %s 敘述在 %C 處不能跟隨 %s 敘述在 %L 處

en: %s statement expected at %L
zh_TW: 需要 %s 敘述在 %L 處

en: %s statement must appear in a MODULE
zh_TW: %s 敘述必須出現在 MODULE 中

en: %s tag at %L must be of type %s
zh_TW: %s 標記在 %L 處必須具有類型 %s

en: %s tag at %L must be scalar
zh_TW: %s 標記在 %L 處必須是標量

en: %s terminated with signal %d [%s]%s
zh_TW: %s 以信號 %d [%s]%s 離開。

en: %s used with %<%%%c%> %s format
zh_TW: %s 與 %<%%%c%> %s 格式並用

en: %s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d
zh_TW: %s%sGGC 準則：--param ggc-min-expand=%d --param ggc-min-heapsize=%d

en: %s-%s is an empty range
zh_TW: %s-%s 是一個空的範圍

en: %s: %d basic blocks and %d registers
zh_TW: %s：%d 個基本區塊和 %d 個暫存器

en: %s: %s
zh_TW: %s：%s

en: %s: %s compiler not installed on this system
zh_TW: %s：此系統未安裝 %s 編譯器

en: %s: --param arguments should be of the form NAME=VALUE
zh_TW: %s：--param 引數的形式應該為「名稱=值」

en: %s: Cannot open output file: %s
zh_TW: %s：無法開啟輸出檔案：%s

en: %s: Failed to close output file %s
zh_TW: %s：無法關閉輸出檔案 %s

en: %s: PCH file was invalid
zh_TW: %s：PCH 檔案無效

en: %s: cannot open as COFF file
zh_TW: %s：無法開啟 COFF 檔案

en: %s: couldn%'t open PCH file: %m
zh_TW: %s：無法開啟 PCH 檔案：%m

en: %s: linker input file unused because linking not done
zh_TW: %s：未使用連結器輸入檔案，因為連結尚未完成

en: %s: not a COFF file
zh_TW: %s：不是一個 COFF 檔案

en: %s:%d: Illegal preprocessor directive
zh_TW: %s:%d：無效的預包含指示

en: %s:%d: confused by earlier errors, bailing out
zh_TW: %s：%d：不能從先前的錯誤中恢復，離開

en: %s:%d: file %s left but not entered
zh_TW: %s:%d: 檔案 %s 被留下但未進入

en: %s:'%s' has arcs from exit block
zh_TW: %s：「%s」有來自出口區塊的弧

en: %s:'%s' has arcs to entry block
zh_TW: %s：「%s」有去往入口塊的弧

en: %s:'%s' lacks entry and/or exit blocks
zh_TW: %s：「%s」缺少入口/出口塊

en: %s:already seen blocks for '%s'
zh_TW: %s:已經看到「%s」的區塊

en: %s:corrupted
zh_TW: %s：已損壞

en: %s:graph is unsolvable for '%s'
zh_TW: %s：圖為「%s」不可解

en: %s:no functions found
zh_TW: %s：找不到函式

en: %s:no lines for '%s'
zh_TW: %s：「%s」沒有列

en: %s:not a gcov data file
zh_TW: %s：不是一個 gcov 資料檔案

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

en: %s:profile mismatch for '%s'
zh_TW: %s：樣本檔案與「%s」不匹配

en: %s:unknown function '%u'
zh_TW: %s：不明函式「%u」

en: %s:version '%.4s', prefer '%.4s'
zh_TW: %s：版本「%.4s」，偏好「%.4s」

en: %s:version '%.4s', prefer version '%.4s'
zh_TW: %s：版本「%.4s」，偏好版本「%.4s」

en: '
zh_TW: 」

en: ' ' flag
zh_TW: 「 」旗標

en: '!' flag
zh_TW: 「!」旗標

en: '#' flag
zh_TW: 「#」旗標

en: '%%l' operand isn't a label
zh_TW: 「%%l」運算元不是一個標籤

en: '%s' and '%s' arguments of '%s' intrinsic at %L must have the same type
zh_TW: 「%s」和「%s」引數(屬於「%s」內建函式)在 %L 處類型必須相同

en: '%s' argument of '%s' intrinsic at %L cannot be INTENT(IN)
zh_TW: 「%s」引數(屬於內建函式「%s」)在 %L 處不能是 INTENT(IN)

en: '%s' argument of '%s' intrinsic at %L must be %s
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須是 %s

en: '%s' argument of '%s' intrinsic at %L must be ALLOCATABLE
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須為 ALLOCATABLE

en: '%s' argument of '%s' intrinsic at %L must be INTEGER or LOGICAL
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須為 INTEGER 或 LOGICAL

en: '%s' argument of '%s' intrinsic at %L must be INTEGER or PROCEDURE
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須為 INTEGER 或 PROCEDURE

en: '%s' argument of '%s' intrinsic at %L must be INTEGER or REAL
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須為整數型或實數型

en: '%s' argument of '%s' intrinsic at %L must be REAL or COMPLEX
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須為實數型或複數型

en: '%s' argument of '%s' intrinsic at %L must be a POINTER
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須是一個 POINTER

en: '%s' argument of '%s' intrinsic at %L must be a POINTER or a TARGET
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須是一個 POINTER 或 TARGET

en: '%s' argument of '%s' intrinsic at %L must be a constant
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須是一個常數

en: '%s' argument of '%s' intrinsic at %L must be a logical array
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須是一個邏輯陣列

en: '%s' argument of '%s' intrinsic at %L must be a non-derived type
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)不能是衍生類型

en: '%s' argument of '%s' intrinsic at %L must be a numeric type
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須具有數字類型

en: '%s' argument of '%s' intrinsic at %L must be a scalar
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須是一個標量

en: '%s' argument of '%s' intrinsic at %L must be a variable
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須是一個變數

en: '%s' argument of '%s' intrinsic at %L must be an array
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須是一個陣列

en: '%s' argument of '%s' intrinsic at %L must be double precision
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須為雙精度

en: '%s' argument of '%s' intrinsic at %L must be less than rank %d
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)秩必須小於 %d

en: '%s' argument of '%s' intrinsic at %L must be numeric or LOGICAL
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須為數字或 LOGICAL 型

en: '%s' argument of '%s' intrinsic at %L must be of a dummy variable
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須是一個啞元變數

en: '%s' argument of '%s' intrinsic at %L must be of an OPTIONAL dummy variable
zh_TW: 「%s」引數(屬於「%s」內建函式，位於 %L)必須是一個 OPTIONAL 啞變數

en: '%s' argument of '%s' intrinsic at %L must be of kind %d
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須具有種別 %d

en: '%s' argument of '%s' intrinsic at %L must be of rank %d
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)的秩必須為 %d

en: '%s' argument of '%s' intrinsic at %L must be of rank 1 or 2
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)的秩必須為 1 或 2

en: '%s' argument of '%s' intrinsic at %L must be the same kind as '%s'
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須具有與「%s」一樣的種別

en: '%s' argument of '%s' intrinsic at %L must be the same type and kind as '%s'
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)必須具有與「%s」一樣的類型和種別

en: '%s' argument of '%s' intrinsic at %L must not be OPTIONAL
zh_TW: 引數「%s」(屬於內建函式「%s」，位於 %L)不能為可選的

en: '%s' argument of '%s' intrinsic at %L must not be present if 'x' is COMPLEX
zh_TW: 當「x」是 COMPLEX 時「%s」引數(屬於「%s」內建函式，在 %L 處)不能存在

en: '%s' at %C is not a member of the '%s' structure
zh_TW: 「%s」在 %C 處不是「%s」結構的成員

en: '%s' was assigned to '%s', but was not defined during recompilation, or vice versa
zh_TW: 「%s」被指派給「%s」，但在重新編譯的程序中未定義，或相反

en: ''' flag
zh_TW: 「'」旗標

en: '(' flag
zh_TW: 「(」旗標

en: '+' flag
zh_TW: 「+」旗標

en: '-' flag
zh_TW: 「-」旗標

en: '0' flag
zh_TW: 「0」旗標

en: 'B' operand has multiple bits set
zh_TW: 「B」運算元設定了多個位

en: 'B' operand is not constant
zh_TW: 「B」運算元不是一個常數

en: 'E' modifier
zh_TW: 「E」修飾符

en: 'I' flag
zh_TW: 「I」旗標

en: 'O' modifier
zh_TW: 「O」修飾符

en: '^' flag
zh_TW: 「^」旗標

en: '_' flag
zh_TW: 「_」旗標

en: 'a' flag
zh_TW: 「a」旗標

en: 'dim' argument of '%s' intrinsic at %L is not a valid dimension index
zh_TW: 「%s」內建函式的「dim」引數(於 %L 處)不是一個有效的維數索引

en: 'o' operand is not constant
zh_TW: 「o」運算元不是一個常數

en: 'q' flag
zh_TW: 「q」旗標

en: 'shape' argument of 'reshape' intrinsic at %L has more than %d elements
zh_TW: 「reshape」內建函式的「shape」引數在 %L 處有多於 %d 個的元素

en: 'shape' argument of 'reshape' intrinsic at %L must be an array of constant size
zh_TW: 「reshape」內建函式的「shape」引數在 %L 處必須是大小為常數的陣列

en: 'source' argument of 'shape' intrinsic at %L must not be an assumed size array
zh_TW: 「shape」內建函式的「source」引數在 %L 處不能是假定大小的陣列

en: (Messages without a matching method signature
zh_TW: (訊息缺少匹配的方法簽名

en: (a pointer to member can only be formed with %<&%E%>)
zh_TW: (成員指標只能用 %<&%E%> 構成)

en: (an out of class initialization is required)
zh_TW: (需要一個類別外的初始化)

en: (if you use %<-fpermissive%>, G++ will accept your code, but allowing the use of an undeclared name is deprecated)
zh_TW: (如果您使用 %<-fpermissive%>，G++ 會接受您的程式碼，但是允許使用未定義的名稱是過時的風格)

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

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

en: (perhaps a semicolon is missing after the definition of %qT)
zh_TW: (%qT 的定義末尾可能缺少一個分號)

en: (perhaps the %<offsetof%> macro was used incorrectly)
zh_TW: (可能錯誤使用了 %<offsetof%> 巨集)

en: (so you should pass %qT not %qT to %<va_arg%>)
zh_TW: (因此您應該向 %<va_arg%> 傳遞 %qT 而不是 %qT)

en: --param inline-unit-growth limit reached
zh_TW: 到達 --param inline-unit-growth 給定的極值

en: --param large-function-growth limit reached
zh_TW: 到達 --param large-function-growth 給定的極值

en: --param max-inline-insns-auto limit reached
zh_TW: 到達 --param max-inline-insns-single 給定的極值

en: --param max-inline-insns-single limit reached
zh_TW: 到達 --param max-inline-insns-single 給定的極值

en: --resource requires -o
zh_TW: --resource 需要 -o

en: -E or -x required when input is from standard input
zh_TW: 當輸入來自標準輸入裝置時，需要 -E 或 -x

en: -I- specified twice
zh_TW: -I- 指定了兩次

en: -Wformat-extra-args ignored without -Wformat
zh_TW: -Wformat-extra-args 未與 -Wformat 一起使用，已忽略

en: -Wformat-nonliteral ignored without -Wformat
zh_TW: -Wformat-nonliteral 未與 -Wformat 一起使用，已忽略

en: -Wformat-security ignored without -Wformat
zh_TW: -Wformat-security 未與 -Wformat 一起使用，已忽略

en: -Wformat-y2k ignored without -Wformat
zh_TW: -Wformat-y2k 未與 -Wformat 一起使用，已忽略

en: -Wformat-zero-length ignored without -Wformat
zh_TW: -Wformat-zero-length 未與 -Wformat 一起使用，已忽略

en: -Xbind-now and -Xbind-lazy are incompatible
zh_TW: -Xbind-now 與 -Xbind-lazy 不相容

en: -bundle not allowed with -dynamiclib
zh_TW: -bundle 不允許與 -dynamiclib 一起使用

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

en: -c or -S required for Ada
zh_TW: Ada 需要 -c 或是 -S

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

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

en: -f%s and -msdata=%s are incompatible
zh_TW: -f%s 和 -msdata=%s 互不相容

en: -f%s ignored for target (all code is position independent)
zh_TW: -f%s 在目標平臺上被忽略(所有程式碼都是與位置無關的)

en: -f%s is not supported with CONST16 instructions
zh_TW: CONST16 指令不支援 -f%s

en: -f%s not supported: ignored
zh_TW: -f%s 不受支援：已忽略

en: -f%sleading-underscore not supported on this target machine
zh_TW: -f%sleading-underscore 在此目標平臺上不受支援

en: -fPIC and -fpic are not supported in this configuration
zh_TW: -fPIC 和 -fpic 在此配置下不受支援

en: -fPIC and -mcall-%s are incompatible
zh_TW: -fPIC 與 -mcall-%s 互不相容

en: -fdata-sections not supported for this target
zh_TW: -fdata-sections 在此目標平臺上不受支援

en: -femit-class-file should used along with -fsyntax-only
zh_TW: -femit-class-file 應當與 -fsyntax-only 一起使用

en: -ffunction-sections not supported for this target
zh_TW: -ffunction-sections 在此目標平臺上不受支援

en: -fhandle-exceptions has been renamed -fexceptions (and is now on by default)
zh_TW: -fhandle-exceptions 已被重新命名為 -fexceptions (並且現在預設為開)

en: -fjni and -femit-class-file are incompatible
zh_TW: -fjni 與 -femit-class-file 不相容

en: -fjni and -femit-class-files are incompatible
zh_TW: -fjni 和 -femit-class-files 互不相容

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

en: -fpic and -mapcs-reent are incompatible
zh_TW: -fpic 和 -mapcs-reent 互不相容

en: -fprefetch-loop-arrays is not supported with -Os
zh_TW: -fprefetch-loop-arrays 不支援與 -Os 並用

en: -fprefetch-loop-arrays not supported for this target
zh_TW: -fprefetch-loop-arrays 在此目標平臺上不受支援

en: -fprefetch-loop-arrays not supported for this target (try -march switches)
zh_TW: -fprefetch-loop-arrays 在此目標平臺上不受支援(嘗試 -march 開關)

en: -freorder-blocks-and-partition does not work on this architecture
zh_TW: -freorder-blocks-and-partition 不能在此架構下工作

en: -frepo must be used with -c
zh_TW: -frepo 必須與 -c 一起使用

en: -fstack-protector not supported for this target
zh_TW: -fstack-protector 在此目標平臺上不受支援

en: -g is only supported when using GAS on this processor,
zh_TW: 此處理器只有使用 GAS 時才支援 -g

en: -g option disabled
zh_TW: -g 選項已被停用

en: -g with -mno-apcs-frame may not give sensible debugging
zh_TW: -g 與 -mno-apcs-frame 並用可能不能給出有意義的除錯資訊

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

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

en: -m%s not supported in this configuration
zh_TW: -m%s 在此配置下不受支援

en: -m64 requires PowerPC64 architecture, enabling
zh_TW: -m64 需要 PowerPC64 架構，正在啟用

en: -m64 requires a PowerPC64 cpu
zh_TW: -m64 需要 PowerPC64 CPU

en: -maix64 required: 64-bit computation with 32-bit addressing not yet supported
zh_TW: 需要 -maix64：目前尚不支援 64 位元計算和 32 位元定址混用

en: -maix64 requires PowerPC64 architecture remain enabled
zh_TW: -maix64 需要 PowerPC64 架構被啟用

en: -malign-functions is obsolete, use -falign-functions
zh_TW: -malign-functions 已過時，請使用 -falign-functions

en: -malign-jumps is obsolete, use -falign-jumps
zh_TW: -malign-jumps 已經過時，請使用 -falign-jumps

en: -malign-loops is obsolete, use -falign-loops
zh_TW: -malign-loops 已經過時，請使用 -falign-loops

en: -malign-loops=%d is not between 0 and %d
zh_TW: -malign-loops=%d 不在 0 和 %d 之間

en: -malign-power is not supported for 64-bit Darwin; it is incompatible with the installed C and C++ libraries
zh_TW: -malign-power 在 64 位元 Darwin 下不受支援；它與已安裝的 C 和 C++ 函式庫不相容

en: -mapcs-stack-check incompatible with -mno-apcs-frame
zh_TW: -mapcs-stack-check 和 -mno-apcs-frame 互不相容

en: -max-stackframe=%d is not usable, not between 0 and %d
zh_TW: -max-stackframe=%d 無法使用，不在 0 和 %d 之間

en: -mbackchain -mpacked-stack -mhard-float are not supported in combination
zh_TW: -mbackchain -mpacked-stack -mhard-float 一起使用不受支援

en: -mbig-endian and -mlittle-endian may not be used together
zh_TW: -mbig-endian 和 -mlittle-endian 不能一起使用

en: -mbnu210 is ignored (option is obsolete)
zh_TW: -mbnu210 被忽略(選項已過時)

en: -mbranch-cost=%d is not between 0 and 5
zh_TW: -mbranch-cost=%d 不在 0 和 5 之間

en: -mcall-aixdesc must be big endian
zh_TW: -mcall-aixdesc 必須是高位位元組在前

en: -mcmodel= is not supported on 32 bit systems
zh_TW: 32 位元系統不支援 -mcmodel=

en: -mfloat-abi=hard and VFP
zh_TW: -mfloat-abi=hard 和 VFP

en: -mhard-float not supported
zh_TW: 不支援 -mhard-float

en: -mlong-double-64 not allowed with -m64
zh_TW: -mlong-double-64 不允許與 -m64 一起使用

en: -mmultiple is not supported on little endian systems
zh_TW: -mmultiple 在低位位元組在前的系統上不受支援

en: -mpic-register= is useless without -fpic
zh_TW: -mpic-register= 不與 -fpic 並用時不起作用

en: -mregparm=%d is not between 0 and %d
zh_TW: -mregparm=%d 不在 0 和 %d 之間

en: -mrelocatable and -mcall-%s are incompatible
zh_TW: -mrelocatable 與 -mcall-%s 互不相容

en: -mrelocatable and -mno-minimal-toc are incompatible
zh_TW: -mrelocatable 和 -mno-minimal-toc 互不相容

en: -mrelocatable and -msdata=%s are incompatible
zh_TW: -mrelocatable 與 -msdata=%s 互不相容

en: -ms2600 is used without -ms
zh_TW: -ms2600 未與 -ms 一起使用

en: -msdata=%s and -mcall-%s are incompatible
zh_TW: -msdata=%s 與 -mcall-%s 互不相容

en: -msecure-plt not supported by your assembler
zh_TW: -msecure-plt 不為您的組譯器所支援

en: -mshared-library-id= specified without -mid-shared-library
zh_TW: 指定了 -mshared-library-id= 卻沒有使用 -mid-shared-library

en: -mshared-library-id=%s is not between 0 and %d
zh_TW: -mshared-library-id=%s 不在 0 和 %d 之間

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

en: -mstack-guard implies use of -mstack-size
zh_TW: -mstack-guard 意味著使用 -mstack-size

en: -mstring is not supported on little endian systems
zh_TW: -mstring 在低位位元組在前的系統上不受支援

en: -munix=98 option required for C89 Amendment 1 features.
zh_TW: 使用 C89 修訂版 1 的特性必須指定 -munix=98 選項。

en: -pg and -fomit-frame-pointer are incompatible
zh_TW: -pg 和 -fomit-frame-pointer 互不相容

en: -pipe not supported
zh_TW: 不支援 -pipe

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

en: .NOT. operator in expression at %L must have a LOGICAL operand
zh_TW: %L 處的運算式中的 .NOT. 運算子必須帶 LOGICAL 運算元

en: 128-bit long double not supported for VAX floats
zh_TW: 128 位 long double 在 VAX 上不受支援

en: 31 bit ABI
zh_TW: 31 位元 ABI

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

en: 64 bit ABI
zh_TW: 64 位元 ABI

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

en: <During initialization>
zh_TW: <在初始化程序中>

en: @catch parameter is not a known Objective-C class type
zh_TW: @catch 參數不是一個已知的 Objective-C 類別類型

en: A synonym for -std=c89 (for C) or -std=c++98 (for C++)
zh_TW: -std=c89 (對 C 來說) 或 -std=c++98 (對 C++ 來說)的同義詞

en: APCS reentrant code not supported.  Ignored
zh_TW: 不支援 APCS 重入程式碼。已忽略

en: AUX pointer initialized for edge %d->%d
zh_TW: 為邊 %d->%d 初始化 AUX 指標

en: Accept extensions to support legacy code
zh_TW: 接受一定的擴充以支援傳統的程式碼

en: Actual argument for '%s' must be a pointer at %L
zh_TW: 「%s」的引數在 %L 處必須是一個指標

en: Add a common subexpression elimination pass after loop optimizations
zh_TW: 在循環最佳化結束後增加一趟公因式消去

en: Add extra commentary to assembler output
zh_TW: 為組譯輸出加入額外註釋

en: Additional debug prints
zh_TW: 額外除錯輸出

en: Alias for -femit-class-file
zh_TW: -fmit-class-file 的別名

en: Align all labels
zh_TW: 對齊所有的標籤

en: Align all loops to 32 byte boundary
zh_TW: 所有循環對齊到 32 位元組邊界上

en: Align code and data to 32 bits
zh_TW: 將程式碼和資料對齊到 32 位元邊界上

en: Align destination of the string operations
zh_TW: 對齊字串作業的目的

en: Align doubles at 64-bit boundaries
zh_TW: 在 64 位元邊界上對齊雙精度變數

en: Align labels which are only reached by jumping
zh_TW: 對齊只能為跳轉所到達的標籤

en: Align some doubles on dword boundary
zh_TW: 一些雙精度浮點數在雙字邊界上對齊

en: Align the start of functions
zh_TW: 對齊函式入口

en: Align the start of loops
zh_TW: 對齊循環入口

en: Align to the base type of the bit-field
zh_TW: 對齊到位元段的基礎類別型

en: Align variables on a 32-bit boundary
zh_TW: 在 32 位元邊界上對齊變數

en: Allocatable '%s' at %L cannot have an initializer
zh_TW: 可指派的「%s」在 %L 處不能有初始值設定

en: Allow arbitrary character line width in fixed mode
zh_TW: 在固定模式下允許任意的字元列寬

en: Allow arbitrary character line width in free mode
zh_TW: 在自由模式下允許任意的字元列寬

en: Allow dollar signs in entity names
zh_TW: 允許在實體名中使用美元符號

en: Allow fast jumps to the message dispatcher
zh_TW: 允許快速跳轉至訊息分發者

en: Allow function addresses to be held in registers
zh_TW: 允許將函式位址儲存在暫存器中

en: Allow loop optimizations to assume that the loops behave in normal way
zh_TW: 允許假定循環以「正常」方式動作的循環最佳化

en: Allow math optimizations that may violate IEEE or ISO standards
zh_TW: 允許可能違反 IEEE 或 ISO 標準的最佳化

en: Allow speculative motion of more loads
zh_TW: 允許更多載入的預測移動

en: Allow speculative motion of non-loads
zh_TW: 允許非載入的預測移動

en: Allow speculative motion of some loads
zh_TW: 允許一些載入的預測移動

en: Allow the arguments of the '?' operator to have different types
zh_TW: 允許「?」運算子的參數有不同的類型

en: Allow two instructions to be issued per cycle
zh_TW: 允許每週期發出兩條指令

en: Alternate RETURN statement at %C is only allowed within a SUBROUTINE
zh_TW: %C 處的替代 RETURN 敘述只允許出現在 SUBROUTINE 中

en: Alternate calling convention
zh_TW: 變更呼叫約定

en: AltiVec argument passed to unprototyped function
zh_TW: 傳遞 AltiVec 引數給無原型的函式

en: Always check for non gcj generated classes archives
zh_TW: 總是檢查非 gcj 產生的類別文件

en: Always generate long calls
zh_TW: 總是產生遠呼叫

en: Always treat bitfields as int-sized
zh_TW: 總認為位元段長與 int 相同

en: Ambiguous interfaces '%s' and '%s' in %s at %L
zh_TW: 有歧義的介面「%s」和「%s」在 %s 中，位於 %L

en: An alternate return at %L without a * dummy argument
zh_TW: %L 不帶 * 啞引數的替代回傳

en: Append a second underscore if the name already contains an underscore
zh_TW: 當名稱已經包含一個底線時加入第二個底線

en: Append underscores to externally visible names
zh_TW: 為外部可見的名稱加入底線

en: Apply variable expansion when loops are unrolled
zh_TW: 展開循環時也展開變數

en: Argument '%s' of elemental procedure at %L must be scalar
zh_TW: 元素程序的引數「%s」在 %L 處必須是標量

en: Argument '%s' of statement function at %L must be scalar
zh_TW: 敘述函式的引數「%s」在 %L 處必須是標量

en: Argument dim at %L must be of INTEGER type
zh_TW: %L 處引數維數必須具有 INTEGER 類型

en: Argument dim at %L must be scalar
zh_TW: %L 引數維數必須是標量

en: Argument of %s at %L must be of length one
zh_TW: %s 的參數(位於 %L)長度必須為 1

en: Argument of ACOS at %L must be between -1 and 1
zh_TW: %L 處 ACOS 的參數必須在 -1 和 1 之間

en: Argument of ACOSH at %L must not be less than 1
zh_TW: %L 處 ACOSH 的參數必須不小於 1

en: Argument of ASIN at %L must be between -1 and 1
zh_TW: %L 處 ASIN 的參數必須在 -1 和 1 之間

en: Argument of ATANH at %L must be inside the range -1 to 1
zh_TW: %L 處 ATANH 的參數必須在 -1 和 1 之間

en: Argument of IACHAR at %L must be of length one
zh_TW: %L 處 IACHAR 的參數長度必須為 1

en: Argument of ICHAR at %L must be of length one
zh_TW: %L 處 ICHAR 的參數長度必須為 1

en: Argument of SELECT statement at %L cannot be %s
zh_TW: %L 處 SELECT 敘述的引數不能是 %s

en: Argument of SQRT at %L has a negative value
zh_TW: %L 處 SQRT 的參數為負

en: Argument to -ffpe-trap is not valid: %s
zh_TW: -ffpe-trap 的參數無效：%s

en: Arithmetic NaN at %L
zh_TW: %L 處算術 NaN

en: Arithmetic OK at %L
zh_TW: %L 處算術正常

en: Arithmetic OK converting %s to %s at %L
zh_TW: 從 %s 轉換到 %s，在 %L 處：算術正常

en: Arithmetic overflow at %L
zh_TW: %L 處算術向上溢位

en: Arithmetic underflow at %L
zh_TW: %L 處算術向下溢位

en: Array '%s' at %L cannot have a deferred shape
zh_TW: 陣列「%s」在 %L 處不能有延遲的外形

en: Array index at %L is an array of rank %d
zh_TW: %L 處陣列索引是一個秩為 %d 的陣列

en: Array index at %L must be scalar
zh_TW: %L 處陣列索引必須是標量

en: Array operands are incommensurate at %L
zh_TW: %L 處陣列運算元無法被使用

en: Array reference at %C cannot have more than %d dimensions
zh_TW: %C 處的任何參照都不能多於 %d 維

en: Array reference out of bounds
zh_TW: 對陣列的參照超出範圍

en: Array section with a vector subscript at %L shall not be the target of a pointer
zh_TW: %L 處由向量下標選擇的部分陣列不應是指標的目的

en: Array specification at %C has more than %d dimensions
zh_TW: %C 處陣列指定了多於 %d 的維數

en: Array specification must be deferred at %L
zh_TW: %L 處陣列指定必須延遲

en: Assigned label is not a target label
zh_TW: 賦值標籤不是目的標籤

en: Assignment to a FORALL index variable at %L
zh_TW: %L 處向 FORALL 索引變數賦值

en: Assume a large TLS segment
zh_TW: 假定大的執行緒局部存儲段

en: Assume all symbols have 32-bit values
zh_TW: 假定所有號都有 32 位元值

en: Assume code will be assembled by GAS
zh_TW: 假定程式碼將由 GAS 組譯

en: Assume code will be linked by GNU ld
zh_TW: 假定程式碼將由 GNU ld 連結

en: Assume code will be linked by HP ld
zh_TW: 假定程式碼將由 HP ld 連結

en: Assume floating-point operations can trap
zh_TW: 假定浮點運算可能引發陷阱

en: Assume native functions are implemented using JNI
zh_TW: 假定本地函式使用 JNI 實作

en: Assume no NaNs or infinities are generated
zh_TW: 假定結果不會是 NaN 或無限大浮點數

en: Assume normal C execution environment
zh_TW: 假定一般的 C 執行環境

en: Assume possible double misalignment
zh_TW: 假定可能的兩不正確齊

en: Assume signed arithmetic overflow wraps around
zh_TW: 假定有號運算溢出時回繞

en: Assume small address space
zh_TW: 假定小位址空間

en: Assume strict aliasing rules apply
zh_TW: 假定套用強重疊規則

en: Assume symbols might be invalid
zh_TW: 假定符號可能無效

en: Assume target CPU is configured as big endian
zh_TW: 假定目的 CPU 被配置為高位位元組在前

en: Assume target CPU is configured as little endian
zh_TW: 假定目的 CPU 被配置為低位位元組在前

en: Assume that receivers of Objective-C messages may be nil
zh_TW: 假定 Objective-C 訊息的接受者可能是 nil

en: Assume that the source file is fixed form
zh_TW: 假定來源檔案是固定格式的

en: Assume that the source file is free form
zh_TW: 假定來源檔案是自由格式

en: Assume the VxWorks RTP environment
zh_TW: 假定 VxWorks RTP 環境

en: Assume the VxWorks vThreads environment
zh_TW: 假定 VxWorks vThreads 環境

en: Assume the runtime uses a hash table to map an object to its synchronization structure
zh_TW: 假定執行時使用一張雜湊表完成從物件到其同步結構的對應

en: Assumed shape array at %L must be a dummy argument
zh_TW: 假定外形的陣列在 %L 處必須是啞引數

en: Assumed size array at %L must be a dummy argument
zh_TW: 假定大小的陣列在 %L 處必須是啞引數

en: At top level:
zh_TW: 在頂層：

en: Attempt to fill delay slots of branch instructions
zh_TW: 試圖利用延遲轉移指令後

en: Attempt to keep stack aligned to this power of 2
zh_TW: 試圖讓堆疊保持對齊到 2 的此次方上

en: Attempt to merge identical constants across compilation units
zh_TW: 試圖合併不同編譯單元中的相同常數

en: Attempt to merge identical constants and constant variables
zh_TW: 試圖合併相同的常數和常變數

en: Automatic array '%s' at %L cannot have an initializer
zh_TW: 自動陣列「%s」在 %L 處不能有初始值設定

en: Avoid generating pc-relative calls; use indirection
zh_TW: 避免產生相對 PC 的呼叫；使用間接呼叫

en: BYTE type used at %C is not available on the target machine
zh_TW: %C 使用到的 BYTE 類型在目標平臺上不可

en: Bad INTENT specification at %C
zh_TW: %C 處錯誤地指定 INTENT

en: Bad IO basetype (%d)
zh_TW: 錯誤的 IO 基礎類別型(%d)

en: Bad array reference at %L
zh_TW: %L 處陣列參照錯誤

en: Bad byte codes.
zh_TW: 錯誤的位元組碼。

en: Bad continuation line at %C
zh_TW: %C 處錯誤的續列

en: Bad kind for logical constant at %C
zh_TW: %C 處邏輯常數的種別錯誤

en: Bad name
zh_TW: 錯誤的名稱

en: Bad operator
zh_TW: 錯誤的運算子

en: Bad type in constant expression
zh_TW: 常數運算式中類型錯誤

en: Branches are this expensive (1-5, arbitrary units)
zh_TW: 指定分支的代價(1-5，任意單位)

en: Branches executed:%s of %d
zh_TW: 執行的分支：%s (共有 %d 個)

en: C++ constructors and destructors will not be invoked for Objective-C fields
zh_TW: 不會為 Objective-C 欄位呼叫 C++ 建構和解構函式

en: CHARACTER(*) function '%s' at %L cannot be array-valued
zh_TW: CHARACTER(*) 函式「%s」(位於 %L)不能以陣列賦值

en: CHARACTER(*) function '%s' at %L cannot be pointer-valued
zh_TW: CHARACTER(*) 函式「%s」(位於 %L)不能以指標賦值

en: CHARACTER(*) function '%s' at %L cannot be pure
zh_TW: CHARACTER(*) 函式「%s」(位於 %L)不能是純量

en: CLOSE statement not allowed in PURE procedure at %C
zh_TW: CLOSE 敘述不允許出現在 %C 處的 PURE 程序中

en: COMPLEX quantities cannot be compared at %L
zh_TW: %L 處複數不能比較大小

en: CPU you selected does not support x86-64 instruction set
zh_TW: 您選擇的 CPU 不支援 x86-64 指令集

en: CRIS-port assertion failed:
zh_TW: CRIS-port 判定語錯誤：

en: Call a library routine to do integer divisions
zh_TW: 呼叫一個函式庫子程式來完成整數除法

en: Calls executed:%s of %d
zh_TW: 執行的呼叫：%s(共 %d)

en: Can't convert %s to %s at %L
zh_TW: 不能將 %s 轉換為 %s，於 %L

en: Can't open file '%s'
zh_TW: 無法開啟檔案「%s」

en: Can't open module file '%s' for reading at %C: %s
zh_TW: 無法開啟模組檔案「%s」讀取，在 %C 處：%s

en: Can't open module file '%s' for writing at %C: %s
zh_TW: 無法開啟模組檔案「%s」寫入，在 %C 處：%s

en: Cannot open '%s' for output.
zh_TW: 不能為輸出開啟「%s」。

en: Change only the low 8 bits of the stack pointer
zh_TW: 只變更堆疊指標的低 8 位

en: Change the ABI to allow double word insns
zh_TW: 變更 ABI 以允許雙字指令

en: Change the maximum length of conditionally-executed sequences
zh_TW: 變更條件執行序列的最大長度

en: Check for syntax errors, then stop
zh_TW: 檢查語法錯誤，然後停止

en: Check the return value of new
zh_TW: 檢查 new 的回傳值

en: Code size: small, medium or large
zh_TW: 程式碼大小：小、中或大

en: Compile for 32-bit pointers
zh_TW: 為 32 位元指標編譯

en: Compile for 64-bit pointers
zh_TW: 為 64 位元指標編譯

en: Compile for ETRAX 100 (CRIS v8)
zh_TW: 為 ETRAX 100 (CRIS v8) 編譯

en: Compile for ETRAX 4 (CRIS v3)
zh_TW: 為 ETRAX 4 (CRIS v3) 編譯

en: Compile for V8+ ABI
zh_TW: 為 V8+ ABI 編譯

en: Compile for the m32r
zh_TW: 為 m32r 編譯

en: Compile for the m32r2
zh_TW: 為 m32r2 編譯

en: Compile for the m32rx
zh_TW: 為 m32rx 編譯

en: Compile for the v850 processor
zh_TW: 為 v850 處理器編譯

en: Compile for the v850e processor
zh_TW: 為 v850e 處理器編譯

en: Compile for the v850e1 processor
zh_TW: 為 v850e1 處理器編譯

en: Compile whole compilation unit at a time
zh_TW: 一次編譯一整個編譯單元

en: Component '%s' at %C already declared at %L
zh_TW: 元件「%s」在 %C 處已經於 %L 處被宣告

en: Component '%s' at %C is a PRIVATE component of '%s'
zh_TW: 元件「%s」在 %C 處是「%s」的 PRIVATE 元件

en: Component at %C must have the POINTER attribute
zh_TW: %C 處的元件必須有 POINTER 屬性

en: Concat operator at %L must concatenate strings of the same kind
zh_TW: %L 處的粘貼運算子必須粘貼同一種別的字串

en: Configured with: %s
zh_TW: 配置為：%s

en: Conform more closely to IBM XLC semantics
zh_TW: 盡量接近 IBM XLC 語義

en: Conform to the ISO 1990 C standard
zh_TW: 遵循 ISO 1990 C 標準

en: Conform to the ISO 1990 C standard as amended in 1994
zh_TW: 遵循 ISO 1990 C 標準於 1994 年修訂的版本

en: Conform to the ISO 1990 C standard with GNU extensions
zh_TW: 遵循 ISO 1990 C 標準，也支援 GNU 擴充

en: Conform to the ISO 1999 C standard
zh_TW: 遵循 ISO 1999 C 標準

en: Conform to the ISO 1999 C standard with GNU extensions
zh_TW: 遵循 ISO 1999 C 標準，也支援 GNU 擴充

en: Conform to the ISO Fortran 2003 standard
zh_TW: 遵循 ISO Fortran 2003 標準

en: Conform to the ISO Fortran 95 standard
zh_TW: 遵循 ISO Fortran 95 標準

en: Consider type 'int' to be 16 bits wide
zh_TW: 認為「int」類別有 16 位寬

en: Consider type 'int' to be 32 bits wide
zh_TW: 認為「int」類別有 32 位元寬

en: Constant expression required at %C
zh_TW: %C 處需要常數運算式

en: ConstantValue attribute of field '%s' has wrong type
zh_TW: 欄位「%s」的 ConstantValue 屬性類型錯誤

en: Control the IEEE trap mode
zh_TW: 控制 IEEE 陷阱模式

en: Control the generated fp rounding mode
zh_TW: 控制產生的浮點捨入模式

en: Control the precision given to fp exceptions
zh_TW: 控制浮點異常的精度

en: Conversion from %s to %s at %L
zh_TW: 從 %s 轉換到 %s，位於 %L

en: Convert floating point constants to single precision constants
zh_TW: 將浮點常數轉換為單精度常數

en: Create GUI application
zh_TW: 建立圖形介面程式

en: Create canonical induction variables in loops
zh_TW: 在循環中產生正規的歸納變數

en: Create console application
zh_TW: 建立命令列程式

en: Create data files needed by "gcov"
zh_TW: 產生「gcov」需要的資料檔案

en: DATA statement at %C is not allowed in a PURE procedure
zh_TW: DATA 敘述不允許出現在 %C 處的 PURE 程序中

en: DIM argument at %L is out of bounds
zh_TW: %L 處的 DIM 參數越界

en: DO-iterator '%s' at %L is inside iterator of the same name
zh_TW: DO 游標「%s」在 %L 處出現在另一個同名游標作用欄位內

en: Data greater than given threshold will go into .ldata section in x86-64 medium model
zh_TW: 在 x86-64 中等模式下大於指定閾值的資料將被存放在 .ldata 區段中

en: Defer popping functions args from stack until later
zh_TW: 延遲將函式引數彈堆疊

en: Delete useless null pointer checks
zh_TW: 刪除無用的空指標檢查

en: Deprecated in favor of -std=c99
zh_TW: 已過時，請使用 -std=c99

en: Deprecated in favor of -std=gnu99
zh_TW: 已過時，請使用 -std=gnu99

en: Deprecated in favor of -std=iso9899:1999
zh_TW: 已過時，為 -std=iso9899:1999 所取代

en: Deprecated.  This switch has no effect
zh_TW: 已過時。此開關不起作用。

en: Different ranks in pointer assignment at %L
zh_TW: %L 處指標賦值時秩不同

en: Disable FP regs
zh_TW: 停用浮點暫存器

en: Disable indexed addressing
zh_TW: 停用變址定址

en: Disable optimizations observable by IEEE signaling NaNs
zh_TW: 停用為 IEEE 訊息 NaN 可見的最佳化

en: Disable optimizations that assume default FP rounding behavior
zh_TW: 停用假定預設浮點捨入行為的最佳化

en: Disable space regs
zh_TW: 停用空間暫存器

en: Disallow direct calls to global functions
zh_TW: 不允許直接呼叫全域函式

en: Discover pure and const functions
zh_TW: 發現純函式和常函式

en: Discover readonly and non addressable static variables
zh_TW: 發現唯讀和不可定址靜態變數

en: Display compile time statistics
zh_TW: 顯示編譯時間統計

en: Display statistics accumulated during compilation
zh_TW: 顯示編譯程序中累計的統計數字

en: Display the code tree after parsing
zh_TW: 解析後顯示程式碼樹

en: Display the compiler's version
zh_TW: 顯示編譯器版本

en: Display this information
zh_TW: 顯示此資訊

en: Division by zero at %L
zh_TW: %L 處被零除

en: Division by zero converting %s to %s at %L
zh_TW: 從 %s 轉換到 %s 時被零除，於 %L 處

en: Do not assume a large TLS segment
zh_TW: 不假定大的 TLS 段

en: Do not assume that standard C libraries and "main" exist
zh_TW: 不假定標準 C 函式庫和「main」存在

en: Do not disable space regs
zh_TW: 不停用空間暫存器

en: Do not discard comments
zh_TW: 不丟棄註釋

en: Do not discard comments in macro expansions
zh_TW: 展開巨集時不丟棄註釋

en: Do not display functions compiled or elapsed time
zh_TW: 不顯示編譯的函式或逝去的時間

en: Do not emit complex integer constants to read-only memory
zh_TW: 不將複整常數存至唯讀記憶體

en: Do not emit function prologue or epilogue
zh_TW: 不產生函式前言和尾聲

en: Do not generate #line directives
zh_TW: 不產生 #line 指令

en: Do not generate .size directives
zh_TW: 不產生 .size 指令

en: Do not generate a single exit point for each function
zh_TW: 不為每個函式產生單一的離開點

en: Do not inline integer division
zh_TW: 不內聯整數除法

en: Do not inline square root
zh_TW: 不內聯平方根函式

en: Do not load the PIC register in function prologues
zh_TW: 不在函式前言中載入 PIC 暫存器

en: Do not place floating point constants in TOC
zh_TW: 不在 TOC 中存放浮點常數

en: Do not place symbol+offset constants in TOC
zh_TW: 不在 TOC 中存放符號+偏移量常數

en: Do not predefine system-specific and GCC-specific macros
zh_TW: 不預定義系統或 GCC 特定的巨集

en: Do not provide a default start-address 0x100 of the program
zh_TW: 不為程式提供預設的起始位址 0x100

en: Do not put uninitialized globals in the common section
zh_TW: 不將未初始化的全域資料放在公共區段中

en: Do not search standard system include directories (those specified with -isystem will still be used)
zh_TW: 不搜尋標準系統標頭檔案目錄(但仍將使用由 -isystem 指定的目錄)

en: Do not search standard system include directories for C++
zh_TW: 不搜尋 C++ 標準系統標頭檔案目錄

en: Do not suppress warnings from system headers
zh_TW: 不抑制系統標頭檔案中的警告

en: Do not tune code and read-only data alignment
zh_TW: 不調整程式碼和唯讀資料對齊

en: Do not tune stack alignment
zh_TW: 不調整堆疊對齊

en: Do not tune writable data alignment
zh_TW: 不調整可寫資料對齊

en: Do not use MIPS-3D instructions
zh_TW: 不使用 MIPS-3D 指令

en: Do not use VAX fp
zh_TW: 不使用 VAX 浮點單元

en: Do not use addresses that allocate global registers
zh_TW: 不使用指派全域暫存器的位址

en: Do not use hardware FP
zh_TW: 不使用硬體浮點單元

en: Do not use hardware floating point
zh_TW: 不使用硬體浮點單元

en: Do not use hardware fp
zh_TW: 不使用硬體浮點單元

en: Do not use hardware quad fp instructions
zh_TW: 不使用硬體四浮點指令

en: Do not use the bit-field instructions
zh_TW: 不使用位元段指令

en: Do not use unaligned memory references
zh_TW: 不使用未對齊的記憶體參照

en: Do not warn about using "long long" when -pedantic
zh_TW: 當使用 -pedantic 時不正確「long long」給出警告

en: Do the full register move optimization pass
zh_TW: 進行全暫存器傳送最佳化

en: Don't allocate floats and doubles in extended-precision registers
zh_TW: 不將單精度和雙精度浮點數指派到擴充精度的暫存器中

en: Don't call any cache flush functions
zh_TW: 不呼叫任何清空快取的函式

en: Don't call any cache flush trap
zh_TW: 不呼叫任何清空快取的陷阱

en: Don't optimize block moves
zh_TW: 不最佳化塊移動

en: Don't use P-mnemonics for branches
zh_TW: 不為分支使用 P 助憶符號

en: Don't warn about uses of Microsoft extensions
zh_TW: 使用微軟擴充時不給出警告

en: Downgrade conformance errors to warnings
zh_TW: 將相容性錯誤降格為警告

en: Driving:
zh_TW: 驅動：

en: Dummy '%s' at %L cannot have an initializer
zh_TW: 啞元「%s」在 %L 處不能有初始值設定

en: Dummy argument '%s' at %L cannot be INTENT(OUT)
zh_TW: 「%s」啞元引數在 %L 處不能是 INTENT(OUT)

en: Dummy argument '%s' at %L cannot be OPTIONAL
zh_TW: 啞元「%s」(位於 %L)不能是 OPTIONAL

en: Dump declarations to a .decl file
zh_TW: 將宣告傾印到一個 .decl 檔案中

en: Duplicate %s attribute at %L
zh_TW: 重複的 %s 屬性，位於 %L

en: Duplicate %s attribute specified at %L
zh_TW: 重複的 %s 屬性在 %L 處被指定

en: Duplicate %s label specification at %C
zh_TW: 重複的 %s 標籤指定，位於 %C

en: Duplicate %s specification at %C
zh_TW: 重複 %s 指定，於 %C

en: Duplicate ELSE statements at %L and %C
zh_TW: %L 和 %C 處重複的 ELSE 敘述

en: Duplicate IMPLICIT NONE statement at %C
zh_TW: %C 處 IMPLICIT NONE 敘述重複

en: Duplicate NML specification at %C
zh_TW: %C 處重複的 NML 指定

en: Duplicate PRIVATE statement at %C
zh_TW: %C 處重複的 PRIVATE 敘述

en: Duplicate SAVE attribute specified at %L
zh_TW: %L 指定了重複的 SAVE 屬性

en: Duplicate SEQUENCE statement at %C
zh_TW: %C 處重複的 SEQUENCE 敘述

en: Duplicate UNIT specification at %C
zh_TW: %C 處重複的 UNIT 指定

en: Duplicate construct label '%s' at %C
zh_TW: 重複的建構標籤「%s」出現在 %C 處

en: Duplicate format specification at %C
zh_TW: %C 處重複的格式指定

en: Duplicate statement label %d at %L and %L
zh_TW: 重複的敘述標籤 %d 出現在 %L 和 %L 處

en: Duplicate symbol '%s' in formal argument list at %C
zh_TW: 符號「%s」在 %C 處的參數清單中重複出現

en: Dynamically allocate cc registers
zh_TW: 動態指派 cc 暫存器

en: ELEMENTAL non-INTRINSIC procedure '%s' is not allowed as an actual argument at %L
zh_TW: ELEMENTAL non-INTRINSIC 程序「%s」在 %L 處不允許做為實際引數

en: ELSE IF statement at %C cannot follow ELSE statement at %L
zh_TW: %C 處的 ELSE IF 敘述不能出現在 %L 處的 ELSE 敘述之後

en: END tag at %C not allowed in output statement
zh_TW: %C 處的 END 標記不允許出現在輸出敘述中

en: END tag label %d at %L not defined
zh_TW: END 標記標籤 %d 在 %L 處未定義

en: ENTRY '%s' at %L has no IMPLICIT type
zh_TW: ENTRY「%s」在 %L 處沒有 IMPLICIT 類型

en: ENTRY statement at %C cannot appear in a contained procedure
zh_TW: %C 處 ENTRY 敘述不能出現在被包含的程序中

en: ENTRY statement at %C cannot appear within a BLOCK DATA
zh_TW: %C 處的 ENTRY 敘述不能出現在 BLOCK DATA 中

en: ENTRY statement at %C cannot appear within a DERIVED TYPE block
zh_TW: %C 處的 ENTRY 敘述不能出現在 DERIVED TYPE 區塊中

en: ENTRY statement at %C cannot appear within a DO block
zh_TW: %C 處的 ENTRY 敘述不能出現在 DO 中

en: ENTRY statement at %C cannot appear within a FORALL block
zh_TW: %C 處的 ENTRY 敘述不能出現在 FORALL 區塊中

en: ENTRY statement at %C cannot appear within a MODULE
zh_TW: %C 處的 ENTRY 敘述不能出現在 MODULE 中

en: ENTRY statement at %C cannot appear within a PROGRAM
zh_TW: %C 處的 ENTRY 敘述不能出現在 PROGRAM 中

en: ENTRY statement at %C cannot appear within a SELECT block
zh_TW: %C 處的 ENTRY 敘述不能出現在 SELECT 區塊中

en: ENTRY statement at %C cannot appear within a WHERE block
zh_TW: %C 處的 ENTRY 敘述不能出現在 WHERE 區塊中

en: ENTRY statement at %C cannot appear within a contained subprogram
zh_TW: %C 處的 ENTRY 敘述不能出現在巢狀的子程式中

en: ENTRY statement at %C cannot appear within an IF-THEN block
zh_TW: %C 處的 ENTRY 敘述不能出現在 IF-THEN 區塊中

en: ENTRY statement at %C cannot appear within an INTERFACE
zh_TW: %C 處的 ENTRY 敘述不能出現在 INTERFACE 中

en: EOR tag label %d at %L not defined
zh_TW: EOR 標記標籤 %d 在 %L 處未定義

en: ERR tag label %d at %L not defined
zh_TW: ERR 標記標籤 %d 在 %L 處未定義

en: ESA/390 architecture
zh_TW: ESA/390 結構

en: Element in %s array constructor at %L is %s
zh_TW: %s 陣列建構中的元素在 %L 處是 %s

en: Emit 16-bit relocations to the small data areas
zh_TW: 為小資料區域產生 16 位重定位資訊

en: Emit 32-bit relocations to the small data areas
zh_TW: 為小資料區域產生 32 位元重定位資訊

en: Emit IEEE-conformant code, without inexact exceptions
zh_TW: 產生符合 IEEE 的程式碼，不產生不精確的異常

en: Emit call graph information
zh_TW: 產生呼叫圖資訊

en: Emit code for the byte/word ISA extension
zh_TW: 為位元組/字指令架構擴充產生程式碼

en: Emit code for the counting ISA extension
zh_TW: 為計數指令架構擴充產生程式碼

en: Emit code for the fp move and sqrt ISA extension
zh_TW: 為浮點轉移和平方根指令架構擴充產生程式碼

en: Emit code for the motion video ISA extension
zh_TW: 為動態影像指令架構擴充產生程式碼

en: Emit common-like symbols as weak symbols
zh_TW: 將公共符號視作弱符號

en: Emit direct branches to local functions
zh_TW: 為局部函式產生直接分支

en: Emit extra code in the function prologue in order to trap if the stack size exceeds the given limit
zh_TW: 在函式前言中產生額外程式碼以獲取堆疊大小越限

en: Emit implicit instantiations of inline templates
zh_TW: 允許內聯範本隱含實體化

en: Emit implicit instantiations of templates
zh_TW: 允許範本隱含實體化

en: Emit indirect branches to local functions
zh_TW: 為局部函式產生間接分支

en: Emit long load/store sequences
zh_TW: 產生長讀/寫序列

en: Emit static const variables even if they are not used
zh_TW: 保留未用到的靜態常數

en: Emit stop bits before and after volatile extended asms
zh_TW: 在 volatile 擴充組譯塊前後加上停止位

en: Emit verbose debug information in assembly code
zh_TW: 在組譯程式碼中產生詳細的除錯資訊

en: Empty IMPLICIT statement at %C
zh_TW: %C IMPLICIT 敘述為空

en: Empty array constructor at %C is not allowed
zh_TW: %C 處的空陣列建構不被允許

en: Empty set of digits in BOZ constant at %C
zh_TW: %C 處 BOZ 常數中的數字集合為空

en: Enable Dwarf 2 line debug info via GNU as
zh_TW: 啟用經由 GNU as 的 Dwarf 2 列除錯資訊

en: Enable Full Redundancy Elimination (FRE) on trees
zh_TW: 啟用樹上的完全冗餘消除(FRE)

en: Enable Function Descriptor PIC mode
zh_TW: 啟用函式描述符號 PIC 模式

en: Enable ID based shared library
zh_TW: 啟用基於 ID 的共享函式庫

en: Enable Objective-C exception and synchronization syntax
zh_TW: 啟用 Objective-C 異常和同步語法

en: Enable Objective-C setjmp exception handling runtime
zh_TW: 啟用 Objective-C setjmp 異常處理執行時

en: Enable PIC support for building libraries
zh_TW: 啟用對函式庫的 PIC 支援

en: Enable SSA code sinking on trees
zh_TW: 啟用樹上的 SSA 程式碼下沉最佳化

en: Enable SSA dead code elimination optimization on trees
zh_TW: 啟用樹上的 SSA 死程式碼消除最佳化

en: Enable SSA-CCP optimization on trees
zh_TW: 啟用樹上的 SSA-CCP 最佳化

en: Enable SSA-PRE optimization on trees
zh_TW: 啟用樹上的 SSA-PRE 最佳化

en: Enable TPF-OS tracing code
zh_TW: 啟用 TPF-OS 追蹤碼

en: Enable all -Wunused- warnings
zh_TW: 啟用所有關於「XX未使用」的警告

en: Enable an RTL peephole pass before sched2
zh_TW: 在 sched2 前進行一趟 RTL 窺孔最佳化

en: Enable automatic template instantiation
zh_TW: 啟用範本自動實體化

en: Enable backend debugging
zh_TW: 啟用後端程式除錯

en: Enable basic program profiling code
zh_TW: 啟用基本程式取樣程式碼

en: Enable common options for generating profile info for profile feedback directed optimizations
zh_TW: 啟用一些公共選項來產生樣本檔案，以便進行基於取樣的最佳化

en: Enable common options for performing profile feedback directed optimizations
zh_TW: 啟用一些公共選項以進行基於取樣的最佳化

en: Enable conditional execution other than moves/scc
zh_TW: 啟用條件執行而非 moves/scc

en: Enable conditional moves
zh_TW: 啟用條件轉移

en: Enable copy propagation on trees
zh_TW: 在樹層級進行複寫傳遞

en: Enable dead store elimination
zh_TW: 刪除死存儲

en: Enable debug output
zh_TW: 啟用除錯輸出

en: Enable dominator optimizations
zh_TW: 啟用主導最佳化

en: Enable earlier placing stop bits for better scheduling
zh_TW: 及早放置停止位，以取得更好的調度效果

en: Enable exception handling
zh_TW: 啟用異常處理

en: Enable function profiling
zh_TW: 啟用函式取樣

en: Enable garbage collection (GC) in Objective-C/Objective-C++ programs
zh_TW: 在 Objective-C/Objective-C++ 程式中啟用無用收集

en: Enable guessing of branch probabilities
zh_TW: 啟用分支概率猜測

en: Enable inlining of PLT in function calls
zh_TW: 為函式呼叫啟用 PLT 的內聯

en: Enable label alignment optimizations
zh_TW: 啟用標籤對齊最佳化

en: Enable linker optimizations
zh_TW: 啟用連結器最佳化

en: Enable linker relaxations
zh_TW: 啟用連結器鬆弛

en: Enable linker relaxing
zh_TW: 啟用連結器鬆弛

en: Enable loop header copying on trees
zh_TW: 啟用樹上的循環不變量轉移

en: Enable loop invariant motion on trees
zh_TW: 啟用樹上的循環不變量轉移

en: Enable loop optimizations on tree level
zh_TW: 在樹層級進行循環最佳化

en: Enable loop vectorization on trees
zh_TW: 在樹上進行循環向量化

en: Enable loop versioning when doing loop vectorization on trees
zh_TW: 在樹上進行循環向量化時啟用多版本循環

en: Enable machine specific peephole optimizations
zh_TW: 啟用機器相關的窺孔最佳化

en: Enable most warning messages
zh_TW: 啟用大部分警告資訊

en: Enable nested conditional execution optimizations
zh_TW: 啟用對巢狀條件執行的最佳化

en: Enable optimization of static class initialization code
zh_TW: 啟用靜態類別初始程式碼最佳化

en: Enable optimizing &&/|| in conditional execution
zh_TW: 啟用對條件執行 && 或 || 的最佳化

en: Enable scheduling across basic blocks
zh_TW: 啟用基本區塊間的調度

en: Enable separate data segment
zh_TW: 啟用分離的資料段

en: Enable stack probing
zh_TW: 啟用堆疊偵測

en: Enable the normal mode
zh_TW: 啟用正常模式

en: Enable the use of the short load instructions
zh_TW: 啟用對短載入指令的使用

en: Enable traditional preprocessing
zh_TW: 啟用傳統預先處理

en: Enable use of sdata/scommon/sbss
zh_TW: 啟用 sdata/scommon/sbss

en: Enable verbose output
zh_TW: 啟用詳細輸出

en: Enable/Disable the traditional scheduling in loops that already passed modulo scheduling
zh_TW: 啟用/停用已經透過模調度的循環中的傳統調度

en: Enabled ID based shared library
zh_TW: 啟用基於 ID 的共享函式庫

en: Enables a register move optimization
zh_TW: 啟用暫存器傳送最佳化

en: End of search list.
zh_TW: 搜尋清單結束。

en: Enforce class member access control semantics
zh_TW: 執行類別成員存取控制語義

en: Enumerator exceeds the C integer type at %C
zh_TW: %C 處：列舉量超過 C 整數類型

en: Error converting integer
zh_TW: 轉換整數時發生錯誤

en: Error writing module file '%s' for writing: %s
zh_TW: 寫入模組檔案「%s」時發生錯誤：%s

en: Error writing modules file: %s
zh_TW: 寫入模組檔案時發生錯誤：%s

en: Error:
zh_TW: 錯誤：

en: Exit on the first error occurred
zh_TW: 發現第一個錯誤時即離開

en: Expected ")" at %C
zh_TW: 在 %C 處需要「)」

en: Expected "," at %C
zh_TW: 在 %C 處需要「,」

en: Expected "," or end of statement at %C
zh_TW: 在 %C 處需要「,」或敘述尾

en: Expected '(' at %C
zh_TW: 在 %C 處需要「(」

en: Expected 'END INTERFACE ASSIGNMENT (=)' at %C
zh_TW: %C 處需要「END INTERFACE ASSIGNMENT (=)」或敘述尾

en: Expected :: in TYPE definition at %C
zh_TW: %C 在 TYPE 定義中需要 ::

en: Expected = sign in PARAMETER statement at %C
zh_TW: %C 在 PARAMETER 敘述中需要 = 符號

en: Expected P edit descriptor
zh_TW: 需要 P 編譯描述符號

en: Expected a nameless interface at %C
zh_TW: %C 需要一個無名介面

en: Expected a right parenthesis in expression at %C
zh_TW: %C 處運算式中需要右括號

en: Expected alternate return label at %C
zh_TW: %C 處需要替代的回傳標籤

en: Expected an initialization expression at %C
zh_TW: %C 處需要一個初始化運算式

en: Expected another dimension in array declaration at %C
zh_TW: %C 處陣列宣告需要另外一維

en: Expected array subscript at %C
zh_TW: %C 處需要陣列下標

en: Expected array subscript stride at %C
zh_TW: %C 需要陣列下標間隔

en: Expected attribute bit name
zh_TW: 需要屬性位名

en: Expected block name of '%s' in %s statement at %C
zh_TW: 需要塊名「%s」在「%s」運算式中，於 %C

en: Expected comma in I/O list at %C
zh_TW: %C 處 I/O 清單中需要逗號

en: Expected exponent in expression at %C
zh_TW: %C 處運算式中需要指數部分

en: Expected expression at %C in PARAMETER statement
zh_TW: %C 在 PARAMETER 敘述中需要運算式

en: Expected expression in %s statement at %C
zh_TW: 需要 %s 敘述，於 %C 處

en: Expected expression in array specification at %C
zh_TW: %C 處指定陣列時需要運算式

en: Expected expression type
zh_TW: 需要運算式類型

en: Expected initialization expression at %C
zh_TW: %C 處需要初始化運算式

en: Expected initialization expression in CASE at %C
zh_TW: %C 處 CASE 中需要初始化運算式

en: Expected integer
zh_TW: 需要整數

en: Expected integer string
zh_TW: 需要整數字串

en: Expected label '%s' for %s statement at %C
zh_TW: 需要標籤「%s」，為 %s 敘述，於 %C

en: Expected left parenthesis
zh_TW: 需要左圓括號

en: Expected name
zh_TW: 需要名稱

en: Expected real string
zh_TW: 需要實數字串

en: Expected right parenthesis
zh_TW: 需要右圓括號

en: Expected scalar initialization expression at %C
zh_TW: %C 處需要標量初始化運算式

en: Expected string
zh_TW: 需要字串

en: Expected structure component name at %C
zh_TW: %C 處需要結構元件名

en: Expected terminating name at %C
zh_TW: %C 處需要結束名

en: Expected variable in READ statement at %C
zh_TW: %C READ 敘述需要變數

en: Expected variable name at %C
zh_TW: 在 %C 處需要變數名

en: Expecting %s statement at %C
zh_TW: 需要 %s 敘述，於 %C

en: Expecting 'END INTERFACE %s' at %C
zh_TW: 需要「END INTERFACE %s」於 %C 處

en: Expecting 'END INTERFACE OPERATOR (.%s.)' at %C
zh_TW: 需要「END INTERFACE ASSIGNMENT (.%s.)」在 %C 處

en: Export functions even if they can be inlined
zh_TW: 導出被內聯的函式

en: Expression at %L must be scalar
zh_TW: %L 處的運算式必須具有標量類型

en: Expression in CASE statement at %L must be of type %s
zh_TW: %L 處 CASE 敘述中的運算式必須具有 %s 類型

en: Expression in CASE statement at %L must be scalar
zh_TW: %L 處 CASE 敘述中的運算式必須為標量

en: Extension: Conversion from %s to %s at %L
zh_TW: 擴充：從 %s 到 %s，位於 %L

en: External '%s' at %L cannot have an initializer
zh_TW: 外部「%s」在 %L 處不能有初始值設定

en: External IO UNIT cannot be an array at %L
zh_TW: %L 處外部 IO UNIT 不能是陣列

en: External object '%s' at %L may not have an initializer
zh_TW: 外部物件「%s」在 %L 處不能有初始值設定

en: FORALL end expression at %L must be a scalar INTEGER
zh_TW: %L 處的 FORALL 結束敘述必須是 INTEGER 標量

en: FORALL index-name at %L must be a scalar INTEGER
zh_TW: %L 處 FORALL 索引名稱必須是 INTEGER 標量

en: FORALL start expression at %L must be a scalar INTEGER
zh_TW: %L 處的 FORALL 啟始敘述必須是 INTEGER 標量

en: FORALL stride expression at %L cannot be zero
zh_TW: %L 處的 FORALL 步幅敘述不能為零

en: FORALL stride expression at %L must be a scalar %s
zh_TW: %L 處的 FORALL 步幅敘述必須是 %s 標量

en: FORMAT label %d at %L not defined
zh_TW: FORMAT 標籤 %d 在 %L 處未定義

en: FORMAT statement at %L does not have a statement label
zh_TW: %L 處 FORMAT 敘述沒有敘述標籤

en: FP exceptions are enabled
zh_TW: FP 異常已啟用

en: Fatal Error:
zh_TW: 嚴重錯誤：

en: First argument of operator interface at %L must be INTENT(IN)
zh_TW: %L 處運算子介面的第一個參數必須是 INTENT(IN)

en: Fixed line length must be at least seven.
zh_TW: 固定格式的列長至少為七。

en: Follow Renesas (formerly Hitachi) / SuperH calling conventions
zh_TW: 遒循 Renesas(先前被稱作 Hitachi)/SuperH 呼叫約定

en: For bug reporting instructions, please see:
    %s.
zh_TW: 報告程式缺陷的步驟請參見：
    %s。

en: For intrinsics library: pass all parameters in registers
zh_TW: 為內建函式庫：所有參數在暫存器中傳遞

en: Force functions to be aligned to a 4 byte boundary
zh_TW: 將函式強行對齊到 4 位元組邊界上

en: Force the underlying type for "wchar_t" to be "unsigned short"
zh_TW: 強制指定「wchar_t」的內在類型為「unsigned short」

en: Function '%s' at %L has no IMPLICIT type
zh_TW: 函式「%s」在 %L 處沒有 IMPLICIT 類型

en: Function '%s' requires an argument list at %C
zh_TW: 函式「%s」在 %C 需要參數清單

en: Function name '%s' not allowed at %C
zh_TW: 函式名「%s」不允許出現在 %C 處

en: Function result '%s' at %L cannot have an initializer
zh_TW: 函式結果「%s」在 %L 處不能有初始值設定

en: Function starts are aligned to this power of 2
zh_TW: 函式入口對齊在 2 的此次方上

en: GCC supports only %u nested scopes
zh_TW: GCC 只支援 %u 個巢狀的作用欄位

en: GCC vector passed by reference: non-standard ABI extension with no compatibility guarantee
zh_TW: GCC 傳遞向量參照：非標準的 ABI 擴充，不保證相容性

en: GCC vector returned by reference: non-standard ABI extension with no compatibility guarantee
zh_TW: GCC 回傳向量參照：非標準的 ABI 擴充，不保證相容性

en: GCSE disabled
zh_TW: GCSE 被停用

en: GNU Fortran comes with NO WARRANTY, to the extent permitted by law.
    You may redistribute copies of GNU Fortran
    under the terms of the GNU General Public License.
    For more information about these matters, see the file named COPYING
zh_TW: GNU Fortran 在法律允許的範圍內沒有任何擔保。
    您可以在遵循 GNU 通用公共許可證的前提下分發 GNU Fortran 的副本。
    有關事宜的詳情請參考名為 COPYING 的檔案

en: Generate 32-bit FPU-less SHmedia code
zh_TW: 產生 32 位元不帶 FPU 的 SHmedia 程式碼

en: Generate 32-bit SHmedia code
zh_TW: 產生 32 位元 SHmedia 程式碼

en: Generate 32-bit code
zh_TW: 產生 32 位元程式碼

en: Generate 32-bit offsets in switch tables
zh_TW: 在分支表中使用 32 位元偏移量

en: Generate 32bit i386 code
zh_TW: 產生 32 位元 i386 程式碼

en: Generate 64-bit FPU-less SHmedia code
zh_TW: 產生 64 位元不帶 FPU 的 SHmedia 程式碼

en: Generate 64-bit SHmedia code
zh_TW: 產生 64 位元 SHmedia 程式碼

en: Generate 64-bit code
zh_TW: 產生 64 位元程式碼

en: Generate 64bit x86-64 code
zh_TW: 產生 64 位元 x86-64 程式碼

en: Generate APCS conformant stack frames
zh_TW: 產生與 APCS 相容的堆疊框架

en: Generate C header of platform-specific features
zh_TW: 產生有平臺相關特性的 C 標頭檔案

en: Generate FPU-less SHcompact code
zh_TW: 產生不帶 FPU 的 SHcompact 程式碼

en: Generate GFLOAT double precision code
zh_TW: 產生 GFLOAT 雙精度程式碼

en: Generate H8/300H code
zh_TW: 產生 H8/300H 程式碼

en: Generate H8S code
zh_TW: 產生 H8S 程式碼

en: Generate H8S/2600 code
zh_TW: 產生 H8S/2600 程式碼

en: Generate H8SX code
zh_TW: 產生 H8SX 程式碼

en: Generate ILP32 code
zh_TW: 產生 ILP32 程式碼

en: Generate LP64 code
zh_TW: 產生 LP64 程式碼

en: Generate PA1.0 code
zh_TW: 產生 PA1.0 程式碼

en: Generate PA1.1 code
zh_TW: 產生 PA1.1 程式碼

en: Generate PA2.0 code (requires binutils 2.10 or later)
zh_TW: 產生 PA2.0 程式碼(需要 binutils 2.10 或更新版本)

en: Generate SH1 code
zh_TW: 產生 SH1 程式碼

en: Generate SH2 code
zh_TW: 產生 SH2 程式碼

en: Generate SH2a FPU-less code
zh_TW: 產生不帶 FPU 的 SH2a 程式碼

en: Generate SH2e code
zh_TW: 產生 SH2e 程式碼

en: Generate SH3 code
zh_TW: 產生 SH3 程式碼

en: Generate SH3e code
zh_TW: 產生 SH3e 程式碼

en: Generate SH4 FPU-less code
zh_TW: 產生不帶 FPU 的 SH4 程式碼

en: Generate SH4 code
zh_TW: 產生 SH4 程式碼

en: Generate SH4a FPU-less code
zh_TW: 產生不帶 FPU 的 SH4a 程式碼

en: Generate SH4a code
zh_TW: 產生 SH4a 程式碼

en: Generate SH4al-dsp code
zh_TW: 產生 SH4al-dsp 程式碼

en: Generate SHcompact code
zh_TW: 產生 SHcompact 程式碼

en: Generate SPE SIMD instructions on E500
zh_TW: 在 E500 上產生 SPE SIMD 指令

en: Generate VRSAVE instructions when generating AltiVec code
zh_TW: 產生 AltiVec 程式碼時產生 VRSAVE 指令

en: Generate a call to abort if a noreturn function returns
zh_TW: 當 noreturn 函式回傳時呼叫 abort

en: Generate a single exit point for each function
zh_TW: 為每個函式產生單一的離開點

en: Generate big endian code
zh_TW: 產生高位位元組在前的程式碼

en: Generate big-endian code
zh_TW: 產生高位位元組在前的程式碼

en: Generate checks for references to NULL
zh_TW: 檢查參照 NULL 的參照

en: Generate code for GNU as
zh_TW: 為 GNU as 產生程式碼

en: Generate code for GNU assembler (gas)
zh_TW: 為 GNU 組譯器(gas)產生程式碼

en: Generate code for GNU ld
zh_TW: 為 GNU ld 產生程式碼

en: Generate code for GNU runtime environment
zh_TW: 為 GNU 執行時環境產生程式碼

en: Generate code for NeXT (Apple Mac OS X) runtime environment
zh_TW: 為 NeXT (蘋果 Mac OS X) 執行時環境產生程式碼

en: Generate code for UNIX assembler
zh_TW: 為 UNIX 組譯器產生程式碼

en: Generate code for a 5206e
zh_TW: 為 5206e 產生程式碼

en: Generate code for a 520X
zh_TW: 為 520X 產生程式碼

en: Generate code for a 528x
zh_TW: 為 528x 產生程式碼

en: Generate code for a 5307
zh_TW: 為 5307 產生程式碼

en: Generate code for a 5407
zh_TW: 為 5407 產生程式碼

en: Generate code for a 68000
zh_TW: 為 68000 產生程式碼

en: Generate code for a 68020
zh_TW: 為 68020 產生程式碼

en: Generate code for a 68030
zh_TW: 為 68030 產生程式碼

en: Generate code for a 68040
zh_TW: 為 68040 產生程式碼

en: Generate code for a 68040, without any new instructions
zh_TW: 為 68040 產生程式碼，不使用新指令

en: Generate code for a 68060
zh_TW: 為 68060 產生程式碼

en: Generate code for a 68060, without any new instructions
zh_TW: 為 68060 產生程式碼，不使用新指令

en: Generate code for a 68302
zh_TW: 為 68302 產生程式碼

en: Generate code for a 68332
zh_TW: 為 68332 產生程式碼

en: Generate code for a 68851
zh_TW: 為 68851 產生程式碼

en: Generate code for a DLL
zh_TW: 產生動態連結程式庫的程式碼

en: Generate code for a cpu32
zh_TW: 為 cpu32 產生程式碼

en: Generate code for an 11/10
zh_TW: 為 11/10 產生程式碼

en: Generate code for an 11/40
zh_TW: 為 11/40 產生程式碼

en: Generate code for an 11/45
zh_TW: 為 11/45 產生附加程式碼

en: Generate code for functions even if they are fully inlined
zh_TW: 為完全內聯的函式產生程式碼

en: Generate code for given CPU
zh_TW: 為給定的 CPU 產生程式碼

en: Generate code for huge switch statements
zh_TW: 為巨型的 switch 敘述產生程式碼

en: Generate code for old exec BSS PLT
zh_TW: 為舊的可執行 BSS PLT 產生程式碼

en: Generate code for the Boehm GC
zh_TW: 為 Boehm 產生程式碼

en: Generate code for the M*Core M210
zh_TW: 為 M*Core M210 產生程式碼

en: Generate code for the M*Core M340
zh_TW: 為 M*Core M340 產生程式碼

en: Generate code in big endian mode
zh_TW: 產生高位位元組在前的程式碼

en: Generate code in little endian mode
zh_TW: 產生低位位元組在前的程式碼

en: Generate code suitable for executables (NOT shared libs)
zh_TW: 產生的程式碼適合於可執行檔案(而不是共享函式庫)

en: Generate code that conforms to the given ABI
zh_TW: 產生遵循給定 ABI 的程式碼

en: Generate code that uses 68881 floating-point instructions
zh_TW: 產生使用 68881 浮點指令的程式碼

en: Generate code to check bounds before indexing arrays
zh_TW: 產生檢查陣列存取是否越界的程式碼

en: Generate code to check exception specifications
zh_TW: 產生檢查異一般範的程式碼

en: Generate code to use a non-exec PLT and GOT
zh_TW: 產生的程式碼使用不可執行 PLT 和 GOT

en: Generate code without GP reg
zh_TW: 產生不使用 GP 暫存器的程式碼

en: Generate cpp defines for server IO
zh_TW: 為伺服器 IO 產生 cpp 定義

en: Generate cpp defines for workstation IO
zh_TW: 為工作站 IO 產生 cpp 定義

en: Generate debug information in COFF format
zh_TW: 產生 COFF 格式的除錯資訊

en: Generate debug information in STABS format
zh_TW: 產生 STABS 格式的除錯資訊

en: Generate debug information in VMS format
zh_TW: 產生 VMS 格式的除錯資訊

en: Generate debug information in XCOFF format
zh_TW: 產生 XCOFF 格式的除錯資訊

en: Generate debug information in default extended format
zh_TW: 產生預設擴充格式的除錯資訊

en: Generate debug information in default format
zh_TW: 產生預設格式的除錯資訊

en: Generate debug information in extended STABS format
zh_TW: 產生擴充 STABS 格式的除錯資訊

en: Generate debug information in extended XCOFF format
zh_TW: 產生 XCOFF 擴充格式的除錯資訊

en: Generate default single-precision SH4 code
zh_TW: 產生預設的單精度 SH4 程式碼

en: Generate default single-precision SH4a code
zh_TW: 產生預設的單精度 SH4a 程式碼

en: Generate divide results with reminder having the same sign as the divisor (not the dividend)
zh_TW: 產生的除法結果中餘數符號將與除數而不是被除數相同

en: Generate fast indirect calls
zh_TW: 產生快速間接呼叫

en: Generate floating point mathematics using given instruction set
zh_TW: 為指定的指令集產生浮點數學程式碼

en: Generate floating-point multiply-add instructions
zh_TW: 產生浮點乘加指令

en: Generate inline floating point division, optimize for latency
zh_TW: 產生內聯浮點除法，為最小延遲最佳化

en: Generate inline floating point division, optimize for throughput
zh_TW: 產生內聯浮點除法，為最大吞吐量最佳化

en: Generate inline integer division, optimize for latency
zh_TW: 產生內聯的整數除法，為最小延遲最佳化

en: Generate inline integer division, optimize for throughput
zh_TW: 產生內聯的整數除法，為最大吞吐量最佳化

en: Generate inline square root, optimize for latency
zh_TW: 產生內聯的平方根，為最小延遲最佳化

en: Generate inline square root, optimize for throughput
zh_TW: 產生內聯的平方根，為最大吞吐量最佳化

en: Generate isel instructions
zh_TW: 產生 isel 指令

en: Generate little endian code
zh_TW: 產生低位位元組在前的程式碼

en: Generate little-endian code
zh_TW: 產生低位位元組在前的程式碼

en: Generate make dependencies
zh_TW: 產生 make 依賴項

en: Generate make dependencies and compile
zh_TW: 產生 make 依賴規則並編譯

en: Generate normal-mode code
zh_TW: 產生普通模式的程式碼

en: Generate only single-precision SH4 code
zh_TW: 只產生單精度 SH4 程式碼

en: Generate only single-precision SH4a code
zh_TW: 只產生單精度 SH4a 程式碼

en: Generate pc-relative code
zh_TW: 產生相對 pc 的程式碼

en: Generate phony targets for all headers
zh_TW: 為所有標頭產生假的目的

en: Generate position-independent code for executables if possible (large mode)
zh_TW: 為可執行檔案盡可能產生與位置無關的程式碼(大模式)

en: Generate position-independent code for executables if possible (small mode)
zh_TW: 為可執行檔案盡可能產生與位置無關的程式碼(小模式)

en: Generate position-independent code if possible (large mode)
zh_TW: 盡可能產生與位置無關的程式碼(大模式)

en: Generate position-independent code if possible (small mode)
zh_TW: 盡可能產生與位置無關的程式碼(小模式)

en: Generate prefetch instructions, if available, for arrays in loops
zh_TW: 如果可用，為循環中的陣列產生預取指令

en: Generate re-entrant, PIC code
zh_TW: 產生可重入的 PIC 程式碼

en: Generate run time type descriptor information
zh_TW: 產生執行時類型描述資訊

en: Generate self-relocatable code
zh_TW: 產生自身重定位程式碼

en: Generate sin, cos, sqrt for FPU
zh_TW: 為 FPU 產生 sin、cos 和 sqrt 指令

en: Generate special Objective-C methods to initialize/destroy non-POD C++ ivars, if needed
zh_TW: 如果需要，產生特殊的 Objective-C 方法來初始化/解構非簡單舊資料 C++ 變數

en: Generate unwind tables that are exact at each instruction boundary
zh_TW: 產生精確到每條指令邊界的堆疊展開表

en: Give branches their default cost
zh_TW: 為分支指定預設代價

en: Give external symbols a leading underscore
zh_TW: 給外部符號加入起始的底線

en: ICE: emit_insn used where emit_jump_insn needed:
zh_TW: ICE：需要 emit_jump_insn 時使用了 emit_insn used where：

en: ID of shared library to build
zh_TW: 將要建立的共享函式庫的 ID

en: INQUIRE statement at %L requires either FILE or UNIT specifier
zh_TW: %L 處的 INQUIRE 敘述需要 FILE 或 UNIT 限定符

en: INQUIRE statement not allowed in PURE procedure at %C
zh_TW: INQUIRE 敘述不允許出現在 %C 處的 PURE 程序中

en: INTENT (%s) conflicts with INTENT(%s) at %L
zh_TW: INTENT (%s) 與 INTENT(%s) 在 %L 衝突

en: ISO C does not allow extra %<;%> outside of a function
zh_TW: ISO C 不支援在函式外使用多餘的 %<;%>

en: ISO C does not support %<++%> and %<--%> on complex types
zh_TW: ISO C 不支援對複數類型進行 %<++%> 或 %<--%> 作業

en: ISO C does not support %<~%> for complex conjugation
zh_TW: ISO C 不支援用 ~ 求共軛複數

en: ISO C does not support complex integer types
zh_TW: ISO C 不支援複整數

en: ISO C does not support plain %<complex%> meaning %<double complex%>
zh_TW: ISO C 不支援單獨用 %<complex%> 表示 %<double complex%>

en: ISO C forbids %<goto *expr;%>
zh_TW: ISO C++ 不允許 %<goto *expr;%>

en: ISO C forbids assignment between function pointer and %<void *%>
zh_TW: ISO C 不允許在函式指標和 %<void *%> 間賦值

en: ISO C forbids braced-groups within expressions
zh_TW: ISO C 不允許在運算式中使用大括號組

en: ISO C forbids casting nonscalar to the same type
zh_TW: ISO C 不允許將非標量轉換為其自身類型

en: ISO C forbids casts to union type
zh_TW: ISO C 不允許轉換為聯合類型

en: ISO C forbids comparison of %<void *%> with function pointer
zh_TW: ISO C 不允許在 %<void *%> 和函式指標間比較

en: ISO C forbids conditional expr between %<void *%> and function pointer
zh_TW: ISO C 不允許在條件運算式中同時使用 %<void *%> 和函式指標

en: ISO C forbids conditional expr with only one void side
zh_TW: ISO C 不允許條件運算式僅有一邊為空

en: ISO C forbids const or volatile function types
zh_TW: ISO C 不允許使用 const 或 volatile 限定函式類型

en: ISO C forbids conversion of function pointer to object pointer type
zh_TW: ISO C 不允許將一個函式指標轉換為一個物件指標

en: ISO C forbids conversion of object pointer to function pointer type
zh_TW: ISO C 不允許將一個物件指標轉換為一個函式指標

en: ISO C forbids empty initializer braces
zh_TW: ISO C 不允許用初始值設定中有空的大括號對

en: ISO C forbids forward parameter declarations
zh_TW: ISO C 不允許前向參數宣告

en: ISO C forbids forward references to %<enum%> types
zh_TW: ISO C 不允許 %<enum%> 類型的前向參照

en: ISO C forbids initialization between function pointer and %<void *%>
zh_TW: ISO C 不允許在函式指標和 %<void *%> 間初始化

en: ISO C forbids label declarations
zh_TW: ISO C 不允許標籤宣告

en: ISO C forbids member declarations with no members
zh_TW: ISO C 不允許不含成員的成員宣告

en: ISO C forbids nested functions
zh_TW: ISO C++ 不允許巢狀函式

en: ISO C forbids omitting the middle term of a ?: expression
zh_TW: ISO C 不允許省略 ?: 運算式中的第二項

en: ISO C forbids ordered comparisons of pointers to functions
zh_TW: ISO C 不允許函式指標間比較大小

en: ISO C forbids passing argument %d of %qE between function pointer and %<void *%>
zh_TW: ISO C 不允許將引數 %d(屬於 %qE)在函式指標和 %<void *%> 間傳遞

en: ISO C forbids qualified function types
zh_TW: ISO C 不允許使用 const 或 volatile 限定函式類型

en: ISO C forbids return between function pointer and %<void *%>
zh_TW: ISO C 不允許在函式指標和 %<void *%> 間回傳

en: ISO C forbids specifying range of elements to initialize
zh_TW: ISO C 不允許在初始化指定元素的範圍

en: ISO C forbids subscripting %<register%> array
zh_TW: ISO C 不允許按下標存取 %<register%> 陣列

en: ISO C prohibits argument conversion to union type
zh_TW: ISO C 不允許將引數轉換為聯合

en: ISO C requires a named argument before %<...%>
zh_TW: ISO C 要求在 %<...%> 前有一個具名參數

en: ISO C restricts enumerator values to range of %<int%>
zh_TW: ISO C 將列舉值限制在 %<int%> 範圍內

en: ISO C++ does not allow designated initializers
zh_TW: ISO C++ 不允許指定元素初始值設定

en: ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>
zh_TW: ISO C++ 不允許將 %<%T::%D%> 定義為 %<%T::%D%>

en: ISO C++ forbids braced-groups within expressions
zh_TW: ISO C++ 不允許在運算式中使用大括號組

en: ISO C++ forbids calling %<::main%> from within program
zh_TW: ISO C++ 不允許在程式裡呼叫 %<::main%>

en: ISO C++ forbids casting between pointer-to-function and pointer-to-object
zh_TW: ISO C++ 不允許在函式指標和物件指標間進行轉換

en: ISO C++ forbids casting to an array type %qT
zh_TW: ISO C++ 不允許轉換為陣列類型 %qT

en: ISO C++ forbids comparison between pointer and integer
zh_TW: ISO C++ 不允許比較指標和整數的值

en: ISO C++ forbids compound-literals
zh_TW: ISO C++ 不允許複合字面值

en: ISO C++ forbids computed gotos
zh_TW: ISO C++ 不允許執行時可知的 goto 目的

en: ISO C++ forbids declaration of %qs with no type
zh_TW: ISO C++ 不允許宣告無類型的 %qs

en: ISO C++ forbids in-class initialization of non-const static member %qD
zh_TW: ISO C++ 不允許在類別內初始化非常數靜態成員 %qD

en: ISO C++ forbids initialization of member constant %qD of non-integral type %qT
zh_TW: ISO C++ 不允許初始化成員常數 %qD，因為它有非整數的類型 %qT

en: ISO C++ forbids nested type %qD with same name as enclosing class
zh_TW: ISO C++ 不允許嵌類別的類型 %qD 與其所屬的類別同名

en: ISO C++ forbids omitting the middle term of a ?: expression
zh_TW: ISO C 不允許省略 ?: 運算式中的第二項

en: ISO C++ forbids subscripting non-lvalue array
zh_TW: ISO C++ 不允許按下標存取非左值的陣列

en: ISO C++ forbids taking address of function %<::main%>
zh_TW: ISO C++ 不允許取函式 %<::main%> 的位址

en: ISO C++ forbids taking the address of a bound member function to form a pointer to member function.  Say %<&%T::%D%>
zh_TW: ISO C++ 不允許透過取已繫結的成員函式的位址來建構成員函式指標。請改用 %<&%T::%D%>

en: ISO C++ forbids taking the address of a cast to a non-lvalue expression
zh_TW: ISO C++ 不允許取轉換到非左值運算式的位址

en: ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to member function.  Say %<&%T::%D%>
zh_TW: ISO C++ 不允許透過提取一個未限定的或帶括號的非靜態成員函式的位址來形成一個成員函式指標。請使用 %<&%T::%D%>

en: ISO C++ forbids the use of %qE on explicit instantiations
zh_TW: ISO C++ 不允許在明確實體化時使用 %qE

en: ISO C++ forbids using pointer of type %<void *%> in subtraction
zh_TW: ISO C++ 不允許在減法中使用類型為 %<void *%> 的指標

en: ISO C++ forbids using pointer to a function in subtraction
zh_TW: ISO C++ 不允許在減法中使用函式指標

en: ISO C++ forbids using pointer to a method in subtraction
zh_TW: ISO C++ 不允許在減法中使用參照方法的指標

en: ISO C++ forbids zero-size array
zh_TW: ISO C++ 不允許大小為 0 的陣列

en: ISO C++ forbids zero-size array %qD
zh_TW: ISO C 不允許大小為 0 的陣列 %qD

en: ISO C++ prohibits anonymous structs
zh_TW: ISO C++ 不允許匿名結構

en: ISO C++ prohibits overloading operator ?:
zh_TW: ISO C++ 不允許多載 ?: 運算子

en: ISO C++ says that these are ambiguous, even though the worst conversion for the first is better than the worst conversion for the second:
zh_TW: ISO C++ 認為有歧義，盡管第一個備選的最差類型轉換要好於第二個備選的最差類型轉換

en: ISO C90 does not support %<[*]%> array declarators
zh_TW: ISO C90 不支援 %<[*]%> 陣列宣告

en: ISO C90 does not support %<long long%>
zh_TW: ISO C90 不支援 %<long long%>

en: ISO C90 does not support %<static%> or type qualifiers in parameter array declarators
zh_TW: ISO C90 不支援在參數陣列宣告中使用 %<static%> 或類型限定符

en: ISO C90 does not support complex types
zh_TW: ISO C90 不支援複數類型

en: ISO C90 does not support flexible array members
zh_TW: ISO C90 不允許彈性陣列成員

en: ISO C90 forbids compound literals
zh_TW: ISO C90 不允許複合字面值

en: ISO C90 forbids specifying subobject to initialize
zh_TW: ISO C90 不允許指定子物件的初始值

en: ISO C90 forbids subscripting non-lvalue array
zh_TW: ISO C90 不允許非左值的陣列做為下標運算的左運算元

en: If -fvariable-expansion-in-unroller is used, the maximum number of times that an individual variable will be expanded during loop unrolling
zh_TW: 如果使用了 -fvariable-expansion-in-unroller，即指單一變數在循環展開時可以同時被展開的次數

en: If first argument of ATAN2 %L is zero, then the second argument must not be zero
zh_TW: 如果 ATAN2 %L 的第一個參數為 0，第二個參數必須不為 0

en: Ignore 'D' in column one in fixed form
zh_TW: 在固定格式中忽略第一列的「D」

en: Ignore dllimport for functions
zh_TW: 忽略函式的 dllimport 屬性

en: Ignored (obsolete)
zh_TW: 忽略(已過時)

en: Illegal character in BOZ constant at %C
zh_TW: %C 處 BOZ 常數中有無效字元

en: Illegal stride of zero at %L
zh_TW: %L 零間隔無效

en: In %+D: overlapped variable and exception ranges at %d
zh_TW: 在 %+D 中：重疊的變數和異常範圍，在 %d

en: Incompatible ranks %d and %d in assignment at %L
zh_TW: 賦值中有不相容的秩 %d 和 %d，位於 %L

en: Incorrect function return value
zh_TW: 不正確的函式回傳值

en: Initialization at %C is not allowed in a PURE procedure
zh_TW: 初始化不允許出現在 %C 處的 PURE 程序中

en: Initialization at %C isn't for a pointer variable
zh_TW: %C 的初始化不是為指標變數準備的

en: Initialization of pointer at %C is not allowed in a PURE procedure
zh_TW: %C 處對指標的初始化不允許出現在 PURE 程序中

en: Initialization of variable at %C is not allowed in a PURE procedure
zh_TW: %C 處對變數的初始化不允許出現在 PURE 程序中

en: Initializer not allowed for PARAMETER '%s' at %C
zh_TW: PARAMETER「%s」在 %C 處不允許有初始值設定

en: Inject friend functions into enclosing namespace
zh_TW: 將夥伴函式宣告視作包含它的命名空間中的有效宣告

en: Inline all known string operations
zh_TW: 內聯所有已知的字串作業

en: Inline constants if it can be done in 2 insns or less
zh_TW: 當常數可以為兩個以下的指令產生時內聯常數

en: Inline recursively only when the probability of call being executed exceeds the parameter
zh_TW: 僅當被執行的呼叫的概率超過此參數時方進行遞迴地內聯

en: Input file is a file with a list of filenames to compile
zh_TW: 輸入檔案是一個檔案名稱清單，指定了需要編譯的檔案

en: Insert code to profile values of expressions
zh_TW: 為取樣運算式的值插入相關程式碼

en: Integer expression required at %C
zh_TW: %C 處需要整數運算式

en: Integer kind %d at %C not available
zh_TW: 整數種別 %d 在 %C 處無法使用

en: Integer outside symmetric range implied by Standard Fortran at %L
zh_TW: %L 處整數超出標準 Fortran 隱含的對稱範圍

en: Integer overflow
zh_TW: 整數溢出

en: Integer too big for integer kind %i at %C
zh_TW: 整數對其種別 %i 來說太大，於 %C 處

en: Integer too large at %C
zh_TW: %C 處整數太大

en: Integer value too large in expression at %C
zh_TW: %C 處運算式中整數值太大

en: Internal Error at (1):
zh_TW: (1)中的內部錯誤：

en: Internal compiler error: Error reporting routines re-entered.
zh_TW: 內部編譯器錯誤：重入錯誤報告程式。

en: Intrinsic '%s' at %L cannot have an initializer
zh_TW: 內建函式「%s」在 %L 處不能有初始值設定

en: Intrinsic '%s' at %L must have at least two arguments
zh_TW: 內建函式「%s」 於 %L 處必須有至少兩個引數

en: Intrinsic function %s(%d) not recognized
zh_TW: 內部函式 %s(%d) 無法識別

en: Invalid Hollerith constant: %L must contain at least one character
zh_TW: 無效的荷勒瑞斯常數：%L 必須包含至少一個字元

en: Invalid KIND parameter of %s at %L
zh_TW: %s 位於 %L 的 KIND 參數無效

en: Invalid form of PROGRAM statement at %C
zh_TW: %C 處 PROGRAM 敘述格式無效

en: Invalid form of array reference at %C
zh_TW: %C 處陣列參照形式無效

en: Invalid kind %d for CHARACTER constant at %C
zh_TW: CHARACTER 常數的種別 %d 無效，在 %C 處

en: Invalid kind for %s at %L
zh_TW: %s 種別無效，於 %L 處

en: Invalid real kind %d at %C
zh_TW: 無效的實型種別 %d，在 %C 處

en: Issue warnings needed for strict compliance to the standard
zh_TW: 給出標準指定的所有警告資訊

en: Iterator step at %L cannot be zero
zh_TW: %L 迭代次數不能為零

en: Java class %qT cannot have a destructor
zh_TW: Java 類別 %qT 不能有解構函式

en: Java class %qT cannot have an implicit non-trivial destructor
zh_TW: Java 類別 %qT 不能有隱含的非平凡的解構函式

en: Java class %qT cannot have multiple bases
zh_TW: Java 類別 %qT 不能有多個基礎類別

en: Java class %qT cannot have virtual bases
zh_TW: Java 類別 %qT 不能有虛基礎類別

en: Java method %qD has non-Java parameter type %qT
zh_TW: Java 方法 %qD 有非 Java 類型參數 %qT

en: Java method %qD has non-Java return type %qT
zh_TW: Java 方法 %qD 回傳非 Java 類型 %qT

en: Jump targets are aligned to this power of 2
zh_TW: 跳轉目的對齊在 2 的此次方上

en: Just generate unwind tables for exception handling
zh_TW: 僅為異常處理產生堆疊展開表

en: Just use icc0/fcc0
zh_TW: 只使用 icc0/fcc0

en: KIND parameter of %s at %L must be an initialization expression
zh_TW: KIND 參數 %s 在 %L 處必須是初始化運算式

en: L%d cache latency unknown for %s
zh_TW: L%d 快取延遲不明，對 %s 來說

en: LOGICAL operands are required in expression at %L
zh_TW: %L 處的運算式需要 LOGICAL 運算元

en: Label %d at %L defined but cannot be used
zh_TW: 標籤 %d 於 %L 經定義但無法被使用

en: Label %d at %L defined but not used
zh_TW: 標籤 %d 於 %L 經定義但未被使用

en: Label %d referenced at %L is never defined
zh_TW: 標籤 %d(參照自 %L)從未被定義

en: Label name '%s' at %C is ambiguous
zh_TW: 標籤名「%s」在 %C 處有歧義

en: Letter %c already has an IMPLICIT type at %C
zh_TW: 字母 %c 在 %C 處已經有了一個 IMPLICIT 類型

en: Letters must be in alphabetic order in IMPLICIT statement at %C
zh_TW: %C 處 IMPLICIT 敘述中的字母必須按序排列

en: Lift restrictions on GOT size
zh_TW: 消除 GOT 大小限制

en: Like -M but ignore system header files
zh_TW: 與 -M 類似但是忽略系統標頭檔案

en: Like -MD but ignore system header files
zh_TW: 與 -MD 類似但是忽略系統標頭檔案

en: Like -pedantic but issue them as errors
zh_TW: 與 -pedantic 類似，但將它們視作錯誤

en: Lines executed:%s of %d
zh_TW: 已執行的列數：%s (共 %d 列)

en: Link to emit program in ELF format (rather than mmo)
zh_TW: 連結產生 ELF 而非 mmo 格式的程式

en: Link with libads.a, libc.a and crt0.o
zh_TW: 與 libads.a，libc.a 和 crt0.o 連結

en: Link with libmvme.a, libc.a and crt0.o
zh_TW: 與 libmvme.a，libc.a 和 crt0.o 連結

en: Link with libsim.a, libc.a and sim-crt0.o
zh_TW: 與 libsim.a，libc.a 和 sim-crt0.o 連結

en: Link with libyk.a, libc.a and crt0.o
zh_TW: 與 libyk.a，libc.a 和 crt0.o 連結

en: Logicals at %%L must be compared with %s instead of %s
zh_TW: %%L 處邏輯值必須與 %s 比較，而不是 %s

en: Look for and use PCH files even when preprocessing
zh_TW: 即使在預先處理時也搜尋並使用 PCH 檔案

en: Loop code aligned to this power of 2
zh_TW: 循環程式碼對齊到 2 的此次方上

en: MCU %qs supported for assembler only
zh_TW: MCU %qs 只支援組譯器

en: MMIX Internal: %s is not a shiftable int
zh_TW: MMIX 內部錯誤：%s 不是一個可移位的整數

en: MMIX Internal: Bad register: %d
zh_TW: MMIX 內部錯誤：錯誤的暫存器：%d

en: MMIX Internal: Bad value for 'm', not a CONST_INT
zh_TW: MMIX 內部錯誤：「m」值錯誤，不是一個 CONST_INT

en: MMIX Internal: Cannot decode this operand
zh_TW: MMIX 內部錯誤：無法解碼此運算元

en: MMIX Internal: Expected a CONST_INT, not this
zh_TW: MMIX 內部錯誤：預期的是 CONST_INT，不是這個

en: MMIX Internal: Expected a constant, not this
zh_TW: MMIX 內部錯誤：需要一個常數，不是這個

en: MMIX Internal: Expected a register, not this
zh_TW: MMIX 內部錯誤：需要一個暫存器，不是這個

en: MMIX Internal: Last named vararg would not fit in a register
zh_TW: MMIX 內部錯誤：最後一個具名的不定參數無法放入暫存器中

en: MMIX Internal: Missing %qc case in mmix_print_operand
zh_TW: MMIX 內部錯誤：mmix_print_operand 缺少 %qc 類型

en: MMIX Internal: This is not a constant:
zh_TW: MMIX 內部錯誤：這不是一個常數：

en: MMIX Internal: This is not a recognized address
zh_TW: MMIX 內部錯誤：這不是一個可辨識的位址

en: MMIX Internal: Trying to output invalidly reversed condition:
zh_TW: MMIX 內部錯誤：試圖輸出無效地反轉的條件：

en: MMIX Internal: What is the CC of this?
zh_TW: MMIX 內部錯誤：它的比較條件是什麼？

en: MMIX Internal: What's the CC of this?
zh_TW: MMIX 內部錯誤：它的比較條件是什麼？

en: MMX vector argument without MMX enabled changes the ABI
zh_TW: 沒有啟用 MMX，卻出現了 MMX 向量引數，這變更了 ABI

en: MMX vector return without MMX enabled changes the ABI
zh_TW: 沒有啟用 MMX卻回傳 MMX 向量，這變更了 ABI

en: Maintain backchain pointer
zh_TW: 維護反鏈指標

en: Make "char" signed by default
zh_TW: 使「char」類型預設為有號

en: Make "char" unsigned by default
zh_TW: 使「char」類型預設為無號

en: Make integers 32 bits wide
zh_TW: 讓整數有 32 位元寬

en: Mark MAC register as call-clobbered
zh_TW: 將 MAC 暫存器標記為呼叫篡改的

en: Maximal growth due to inlining of large function (in percent)
zh_TW: 內聯大函式造成的程式碼膨脹的上限(以百分數的形式給出)

en: Maximum number of fields in a structure before pointer analysis treats the structure as a single variable
zh_TW: 在指標分析之前的結構變數中欄位的最大數目，將該結構視為單一變數

en: Minimum heap expansion to trigger garbage collection, as a percentage of the total size of the heap
zh_TW: 引發無用收集的堆展開的最小值，以占堆總大小的百分比給出

en: Minimum heap size before we start collecting garbage, in kilobytes
zh_TW: 開始無用回收時最小的堆大小，以千位元組表示

en: Missing actual argument '%s' in call to '%s' at %L
zh_TW: 缺少引數「%s」，在呼叫「%s」時，位於 %L

en: Missing actual argument for argument '%s' at %L
zh_TW: 參數「%s」在 %L 處缺少引數

en: Missing argument list in function '%s' at %C
zh_TW: 函式「%s」在 %C 處缺少參數清單

en: Missing dimension specification at %C
zh_TW: %C 處沒有指定維數

en: Missing exponent in real number at %C
zh_TW: %C 處實數缺少指數部分

en: Missing format label at %C
zh_TW: %C 處缺少格式標籤

en: Missing kind-parameter at %C
zh_TW: %C 處缺少種別參數

en: Missing leading left parenthesis
zh_TW: 缺少前導左括號

en: Module %s at line %d column %d: %s
zh_TW: 模組 %s 位於列 %d 行 %d：%s

en: Move loop invariant computations out of loops
zh_TW: 將每次循環中不變的計算外提

en: NOTE_INSN_BASIC_BLOCK %d in middle of basic block %d
zh_TW: NOTE_INSN_BASIC_BLOCK %d 在基本區塊 %d 中間

en: NOTE_INSN_BASIC_BLOCK is missing for block %d
zh_TW: 區塊 %d 缺少 NOTE_INSN_BASIC_BLOCK

en: NULL appears on right-hand side in assignment at %L
zh_TW: %L 處賦值右手邊出現 NULL

en: NULL pointer at %L is not permitted as actual argument of '%s' intrinsic function
zh_TW: %L 的 NULL 指標不能做為內建函式「%s」的引數

en: NULL used in arithmetic
zh_TW: 算術運算式中使用了 NULL

en: NULL() initialization at %C is ambiguous
zh_TW: %C 處的 NULL() 初始化有歧義

en: Name '%s' at %C is the name of the procedure
zh_TW: 名稱「%s」(位於 %C)是一個程序的名稱

en: Name at %C is too long
zh_TW: %C 的名稱太長

en: Name too long
zh_TW: 名稱太長

en: No branches
zh_TW: 沒有跳轉

en: No calls
zh_TW: 沒有呼叫

en: No default crt0.o
zh_TW: 沒有預設的 crt0.o

en: No executable lines
zh_TW: 沒有可執行列

en: Nonnegative width required
zh_TW: 需要非負的寬度

en: Not a valid Java .class file.
zh_TW: 不是一個有效的 Java .class 檔案。

en: Number of registers used to pass integer arguments
zh_TW: 用以傳遞整數參數的暫存器個數

en: Numeric operands are required in expression at %L
zh_TW: %L 處的運算式需要數字運算元

en: OPEN statement not allowed in PURE procedure at %C
zh_TW: OPEN 敘述不允許出現在 %C 處的 PURE 程序中

en: Objective-C declarations may only appear in global scope
zh_TW: Objective-C 宣告只能出現在全域作用欄位中

en: Old-style type declaration %s*%d not supported at %C
zh_TW: 舊式的型態宣告 %s*%d 在 %C 處不被支援

en: Omit frame pointer for leaf functions
zh_TW: 為葉函式(不呼叫其它函式的函式)忽略框架指標

en: Omit range reduction step when performing complex division
zh_TW: 當進行複數除法時省略縮減範圍的步驟

en: Omit the frame pointer in leaf functions
zh_TW: 為葉函式(不呼叫其它函式的函式)忽略框架指標

en: Only intrinsic operators can be used in expression at %L
zh_TW: %L 處只有內建運算子才能用於運算式中

en: Only issue one instruction per cycle
zh_TW: 每週期只發出一條指令

en: Only use 32 FPRs
zh_TW: 只使用 32 個浮點暫存器

en: Only use 32 GPRs
zh_TW: 只使用 32 個通用暫存器

en: Operand of unary numeric operator '%s' at %%L is %s
zh_TW: 單位元數值運算子「%s」(位於 %%L)的運算元為 %s

en: Operand of user operator '%s' at %%L is %s
zh_TW: 使用者運算子「%s」(位於 %%L)的運算元為 %s

en: Operands of binary numeric operator '%s' at %%L are %s/%s
zh_TW: 二元數值運算子「%s」(位於 %%L)的運算元為 %s/%s

en: Operands of comparison operator '%s' at %%L are %s/%s
zh_TW: 比較運算子「%s」(位於 %%L)的運算元為 %s/%s

en: Operands of logical operator '%s' at %%L are %s/%s
zh_TW: 邏輯運算子「%s」(位於 %%L)的運算元為 %s/%s

en: Operands of string concatenation operator at %%L are %s/%s
zh_TW: 字串粘貼運算子(位於 %%L)的運算元為 %s/%s

en: Operands of user operator '%s' at %%L are %s/%s
zh_TW: 使用者運算子「%s」(位於 %%L)的運算元為 %s/%s

en: Optimize for space rather than speed
zh_TW: 為最小空間而不是最大速度最佳化

en: Optimize induction variables on trees
zh_TW: 在樹上最佳化歸納變數

en: Optimize lui/addiu address loads
zh_TW: 最佳化 lui/addiu 記憶體載入

en: Optimize sibling and tail recursive calls
zh_TW: 最佳化同級遞迴和尾遞迴

en: Optimize tail call instructions in assembler and linker
zh_TW: 在組譯器和連結器中最佳化尾呼叫指令

en: Options:
zh_TW: 選項：

en: Out of stack space.
zh_TW: 堆疊溢出。

en: Output a class file
zh_TW: 輸出一個 class 檔案

en: Override -mbest-lib-options
zh_TW: 覆寫 -mbest-lib-options

en: PARAMETER at %L is missing an initializer
zh_TW: %L 處 PARAMETER 缺少初始值設定

en: PHI argument is missing for edge %d->%d
zh_TW: 邊 %d->%d 缺少 PHI 參數

en: PIC code generation is not compatible with fast indirect calls
zh_TW: PIC 程式碼產生與快速間接呼叫不相容

en: PIC code generation is not supported in the portable runtime model
zh_TW: PIC 程式碼產生在可移植執行時模型中不受支援

en: PIC is required but not supported with CONST16 instructions
zh_TW: 需要 PIC，但 CONST16 指令不支援

en: PIC register isn't set up
zh_TW: 尚未設定好 PIC 暫存器

en: PRINT namelist at %C is an extension
zh_TW: %C 處的 PRINT 名稱清單是一個擴充

en: PRINT statement at %C not allowed within PURE procedure
zh_TW: %C 處的 PRINT 敘述不允許出現在 PURE 程序中

en: PRINT_OPERAND null pointer
zh_TW: PRINT_OPERAND 空指標

en: PRINT_OPERAND, invalid insn for %%C
zh_TW: PRINT_OPERAND，%%C 的指令無效

en: PRINT_OPERAND, invalid insn for %%N
zh_TW: PRINT_OPERAND，%%N 的指令無效

en: PRINT_OPERAND: Unknown punctuation '%c'
zh_TW: PRINT_OPERAND：不明的標點「%c」

en: PRINT_OPERAND_ADDRESS, null pointer
zh_TW: PRINT_OPERAND_ADDRESS，空指標

en: Pack VLIW instructions
zh_TW: 打封包 VLIW 指令

en: Pack structure members together without holes
zh_TW: 將結構成員不帶間隔地緊實存放

en: Pass FP arguments in FP registers
zh_TW: 在浮點暫存器中傳遞浮點參數

en: Perform DWARF2 duplicate elimination
zh_TW: 進行 DWARF2 冗餘消除

en: Perform Interprocedural constant propagation
zh_TW: 進行處理序間的複寫傳遞

en: Perform SMS based modulo scheduling before the first scheduling pass
zh_TW: 在首趟調度前進行基於 SMS 的模調度

en: Perform VR4130-specific alignment optimizations
zh_TW: 進行 VR4130 特定的對齊最佳化

en: Perform Value Range Propagation on trees
zh_TW: 進行樹上的值欄位傳遞

en: Perform a number of minor, expensive optimizations
zh_TW: 進行一些細微的、代價高昂的最佳化

en: Perform a register copy-propagation optimization pass
zh_TW: 進行一趟暫存器副本傳遞最佳化

en: Perform a register renaming optimization pass
zh_TW: 進行暫存器重新命名最佳化

en: Perform branch target load optimization after prologue / epilogue threading
zh_TW: 在開始/結末執行緒後進行分支目的載入最佳化

en: Perform branch target load optimization before prologue / epilogue threading
zh_TW: 在開始/結末執行緒前進行分支目的載入最佳化

en: Perform conversion of conditional jumps to branchless equivalents
zh_TW: 將條件跳轉替換為沒有跳轉的等值表示

en: Perform conversion of conditional jumps to conditional execution
zh_TW: 將條件跳轉替換為條件執行

en: Perform cross-jumping optimization
zh_TW: 進行跨跳轉最佳化

en: Perform early inlining
zh_TW: 進行早內聯

en: Perform enhanced load motion during global common subexpression elimination
zh_TW: 在全域公因式消去中進行增強的讀轉移最佳化

en: Perform global common subexpression elimination
zh_TW: 進行全域公因式消去

en: Perform global common subexpression elimination after register allocation
zh_TW: 在指派暫存器後進行全域公因式消去

en: Perform jump threading optimizations
zh_TW: 進行跳轉執行緒最佳化

en: Perform loop peeling
zh_TW: 進行循環剝離

en: Perform loop unrolling for all loops
zh_TW: 展開所有循環

en: Perform loop unrolling when iteration count is known
zh_TW: 展開所有迭代次數已知的循環

en: Perform loop unswitching
zh_TW: 外提循環內的測試敘述

en: Perform redundant load after store elimination in global common subexpression
zh_TW: 在全域公因式消去中進行冗餘的寫後讀消除

en: Perform scalar replacement of aggregates
zh_TW: 為聚合類型進行標量替換

en: Perform store motion after global common subexpression elimination
zh_TW: 在全域公因式消去後進行存儲轉移

en: Perform unused type elimination in debug info
zh_TW: 在除錯資訊中進行無用類型消除

en: Perform variable tracking
zh_TW: 進行變數追蹤

en: Perform whole program optimizations
zh_TW: 進行全程式最佳化

en: Permit '$' as an identifier character
zh_TW: 允許「$」做為識別碼的一部分

en: Permit scheduling of a function's prologue sequence
zh_TW: 允許調度函式前言序列

en: Permit the use of the assert keyword
zh_TW: 允許使用 assert 關鍵字

en: Permit universal character names (\u and \U) in identifiers
zh_TW: 允許識別碼中出現 Unicode 字元名(\u 和 \U)

en: Place data items into their own section
zh_TW: 將每個資料項分別放在它們各自的區段中

en: Place each function into its own section
zh_TW: 將每個函式分別放在它們各自的區段中

en: Place floating point constants in TOC
zh_TW: 在 TOC 中存放浮點常數

en: Place symbol+offset constants in TOC
zh_TW: 在 TOC 中存放符號+偏移量常數

en: Pointer initialization at %C requires '=>', not '='
zh_TW: 在 %C 處的指標初始化需要「=>」，而不是「=」

en: Pointers are 32-bit
zh_TW: 指標是 32 位元

en: Pointers are 64-bit
zh_TW: 指標是 64 位元

en: Positive exponent width required
zh_TW: 需要正的指數寬度

en: Positive width required
zh_TW: 需要正的寬度

en: Prefer branches over conditional execution
zh_TW: 優先使用分支而不是條件執行

en: Prefer word accesses over byte accesses
zh_TW: 盡量按字存取而不是按位元組存取

en: Prepend global symbols with ":" (for use with PREFIX)
zh_TW: 在全域符號前加入「:」(為與 PREFIX 協作)

en: Pretend that branches are expensive
zh_TW: 假定分支代價很高昂

en: Prevent the use of all hardware floating-point instructions
zh_TW: 不允許使用任何硬體浮點指令

en: Print code coverage information.
zh_TW: 顯示程式碼覆寫資訊。

en: Print extra (possibly unwanted) warnings
zh_TW: 列印額外(可能您並不想要)的警告跾資訊

en: Print the name of header files as they are used
zh_TW: 列印使用到的標頭檔案名

en: Procedure '%s' at %C has an explicit interface and must not have attributes declared at %L
zh_TW: 程序「%s」在 %C 處具有顯式介面，而且必須在 %L 處不具有已宣告的屬性

en: Procedure '%s' at %C is already defined at %L
zh_TW: 程序「%s」在 %C 處已經於 %L 處被宣告

en: Procedure '%s' called with an implicit interface at %L
zh_TW: 呼叫程序「%s」帶隱含介面，位於 %L

en: Procedure '%s' in %s at %L is neither function nor subroutine
zh_TW: 程序「%s」(在 %s 中，位於 %L) 既不是函式也不是子處理序

en: Process #ident directives
zh_TW: 處理 #ident 指令

en: Produce big endian code
zh_TW: 產生高位位元組在前的程式碼

en: Produce code relocatable at runtime
zh_TW: 產生執行時可重定位的程式碼

en: Produce little endian code
zh_TW: 產生低位位元組在前的程式碼

en: Program is entirely located in low 64k of memory
zh_TW: 程式完全位於記憶體的低 64K

en: Prohibit PC relative function calls
zh_TW: 禁止相對 PC 的函式呼叫

en: Provide libraries for the simulator
zh_TW: 為模擬器提供函式庫

en: Put jumps in call delay slots
zh_TW: 將跳轉放置在延遲呼叫槽內

en: Put uninitialized constants in ROM (needs -membedded-data)
zh_TW: 將未初始化的常數放在 ROM 中(需要 -membedded-data)

en: Put zero initialized data in the bss section
zh_TW: 將初始化為零的資料存放在 bss 區段中

en: RESULT variable at %C must be different than function name
zh_TW: %C 處 RESULT 變數不能與函式同名

en: RETURN_ADDRESS_OFFSET not supported
zh_TW: RETURN_ADDRESS_OFFSET 不受支援

en: RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d
zh_TW: RTL 檢查：需要程式碼「%s」或「%s」，卻得到「%s」在 %s，於 %s:%d

en: RTL check: expected code '%s', have '%s' in %s, at %s:%d
zh_TW: RTL 檢查：需要程式碼「%s」，卻得到「%s」在 %s，於 %s:%d

en: Rank mismatch in array reference at %L (%d/%d)
zh_TW: %L 處陣列參照中秩不匹配(%d/%d)

en: Reading module %s at line %d column %d: %s
zh_TW: 讀出模組 %s，於列 %d 行 %d：%s

en: Reading specs from %s
zh_TW: 從 %s 讀取 specs

en: Real constant overflows its kind at %C
zh_TW: %C 處實常數向上溢位其種別

en: Real constant underflows its kind at %C
zh_TW: %C 處實常數向下溢位其種別

en: Recognize GNU-defined keywords
zh_TW: 識別 GNU 定義的關鍵字

en: Recognize built-in functions
zh_TW: 識別內建函式

en: Recognize the "asm" keyword
zh_TW: 識別「asm」關鍵字

en: Remove redundant membars
zh_TW: 刪除冗餘成員

en: Reorder basic blocks to improve code placement
zh_TW: 基本區塊重新排序以改善程式碼版面設置

en: Reorder functions to improve code placement
zh_TW: 函式重新排序以改善程式碼版面設置

en: Replace add, compare, branch with branch on count register
zh_TW: 將加/減法、比較、跳轉指令序列替換為根據計數暫存器跳轉指令

en: Report on permanent memory allocation
zh_TW: 報告永久性記憶體指派

en: Report the time taken by each compiler pass
zh_TW: 報告每趟組譯的耗時

en: Request IEEE-conformant math library routines (OSF/1)
zh_TW: 請求與 IEEE 相容的數學函式庫處理序(OSF/1)

en: Reschedule instructions after register allocation
zh_TW: 指派暫存器後重新調度指令

en: Reschedule instructions before register allocation
zh_TW: 指派暫存器前重新調度指令

en: Reserve space for outgoing arguments in the function prologue
zh_TW: 在函式序言中為輸出引數預留空間

en: Result of %s overflows its kind at %L
zh_TW: %s 的結果在 %L 處向上溢位其種別

en: Result of SCALE overflows its kind at %L
zh_TW: %L 處 SCALE 的結果向上溢位其種別

en: Return all structures in memory (AIX default)
zh_TW: 所有結構在記憶體中回傳 (AIX 預設)

en: Return floating-point results in ac0 (fr0 in Unix assembler syntax)
zh_TW: 在 ac0(Unix 組譯語法中的 fr0)中回傳浮點結果

en: Return pointers in both a0 and d0
zh_TW: 在 a0 和 d0 中回傳指標

en: Return small aggregates in memory, not registers
zh_TW: 在記憶體而不是暫存器中回傳小聚合

en: Return small aggregates in registers
zh_TW: 在暫存器中回傳小聚合

en: Return small structures in registers (SVR4 default)
zh_TW: 小結構在暫存器中回傳 (SVR4 預設)

en: Return values of functions in FPU registers
zh_TW: 在 FPU 暫存器中存放函式回傳值

en: Reuse r30 on a per function basis
zh_TW: 為每個函式重用 r30

en: SAVE attribute at %L cannot be specified in a PURE procedure
zh_TW: %L 處 PURE 程序不能指定 SAVE 屬性

en: SAVE statement at %C follows blanket SAVE statement
zh_TW: %C 處 SAVE 敘述跟隨空白 SAVE 敘述

en: SH2a does not support little-endian
zh_TW: SH2a 不支援低位位元組在前

en: SSA corruption
zh_TW: SSA 損壞

en: SSA_NAME_DEF_STMT is wrong
zh_TW: SSA_NAME_DEF_STMT 不正確

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

en: SSE register argument with SSE disabled
zh_TW: 已停用 SSE 卻在 SSE 暫存器中傳遞參數

en: SSE register return with SSE disabled
zh_TW: 已停用 SSE 卻在 SSE 暫存器中回傳

en: SSE vector argument without SSE enabled changes the ABI
zh_TW: 沒有啟用 SSE，卻出現了 SSE 向量引數，這變更了 ABI

en: SSE vector return without SSE enabled changes the ABI
zh_TW: 沒有啟用 SSE，卻有 SSE 向量回傳值，這變更了 ABI

en: Same as: -mep -mprolog-function
zh_TW: 與 -mep -mprolog-function 相同

en: Save registers around function calls
zh_TW: 函式呼叫前後儲存/恢復暫存器值

en: Schedule code for given CPU
zh_TW: 為指定的 CPU 最佳化程式碼

en: Schedule given CPU
zh_TW: 為指定的 CPU 最佳化程式碼

en: Schedule the start and end of the procedure
zh_TW: 調度程序的起始與終止

en: Scope of for-init-statement variables is local to the loop
zh_TW: for 循環初始化中定義的變數作用欄位局限於循環內

en: Second argument MOD at %L is zero
zh_TW: %L 處 MOD 的第二個參數為 0

en: Second argument of MOD at %L is zero
zh_TW: %L 處 MOD 的第二個參數為 0

en: Second argument of MODULO at %L is zero
zh_TW: %L 處 MODULO 的第二個參數為 0

en: Second argument of defined assignment at %L must be INTENT(IN)
zh_TW: %L 處定義賦值的第二個參數必須是 INTENT(IN)

en: Second argument of operator interface at %L must be INTENT(IN)
zh_TW: %L 處運算子介面的第二個參數必須是 INTENT(IN)

en: Segmentation Fault
zh_TW: 段錯誤

en: Segmentation Fault (code)
zh_TW: 段錯誤 (程式碼)

en: Select ABI calling convention
zh_TW: 選擇 ABI 呼叫約定

en: Set Windows defines
zh_TW: 設定 Windows 定義

en: Set errno after built-in math functions
zh_TW: 執行內建數學函式後設定 errno

en: Set sizeof(bool) to 1
zh_TW: 設定 sizeof(bool) 為 1

en: Set start-address of data
zh_TW: 設定資料的起始位址

en: Set start-address of the program
zh_TW: 設定程式的起始位址

en: Set the PPC_EMB bit in the ELF flags header
zh_TW: 在 ELF 旗標頭中指定 PPC_EMB 位

en: Set the cost of branches
zh_TW: 設定分支的代價

en: Set the default double precision kind to an 8 byte wide type
zh_TW: 將預設雙精度種別設為 8 位元組寬

en: Set the default integer kind to an 8 byte wide type
zh_TW: 將預設整數種別設為 8 位元組寬

en: Set the default real kind to an 8 byte wide type
zh_TW: 將預設實型種別設為 8 位元組寬

en: Set the target CPU type
zh_TW: 指定目的 CPU 的類型

en: Setting spec %s to '%s'
zh_TW: 將 spec %s 設為「%s」

en: Shapes for operands at %L and %L are not conformable
zh_TW: %L 和 %L 處的運算元外形不相容

en: Specification function '%s' at %L cannot be RECURSIVE
zh_TW: 指定函式「%s」(位於 %L)不能是 RECURSIVE

en: Specification function '%s' at %L cannot be a statement function
zh_TW: 指定函式「%s」(位於 %L)不能是一個敘述函式

en: Specification function '%s' at %L cannot be an internal function
zh_TW: 指定函式「%s」(位於 %L)不能是一個內部函式

en: Specification function '%s' at %L must be PURE
zh_TW: 指定函式「%s」(位於 %L)必須為 PURE

en: Specify CPU for code generation purposes
zh_TW: 為程式碼產生指定目的 CPU

en: Specify CPU for scheduling purposes
zh_TW: 為調度指定目的 CPU

en: Specify CPU for scheduling purposes.  Valid arguments are 700, 7100, 7100LC, 7200, 7300, and 8000
zh_TW: 指定調度最佳化的目的 CPU。有效的選項是 700，7100，7100LC，7200，7300，和 8000

en: Specify UNIX standard for predefines and linking
zh_TW: 指定用於預定義和連結的 UNIX 標準

en: Specify an ABI
zh_TW: 指定一個 ABI

en: Specify bit size of immediate TLS offsets
zh_TW: 指定執行緒局部存儲偏移量立即數值的位大小

en: Specify cache flush function
zh_TW: 指定清空快取的函式

en: Specify cache flush trap number
zh_TW: 指定清空快取的陷阱號

en: Specify how to access the thread pointer
zh_TW: 指定如何存取執行緒指標

en: Specify if floating point hardware should be used
zh_TW: 指定是否應當使用硬體浮點

en: Specify main object for TPF-OS
zh_TW: 指定 TPF-OS 主要物件

en: Specify that no implicit typing is allowed, unless overridden by explicit IMPLICIT statements
zh_TW: 不允許使用隱含類型，除非明確地使用了 IMPLICIT 敘述

en: Specify the name of the target CPU
zh_TW: 指定目的 CPU 的名稱

en: Specify the name of the target architecture
zh_TW: 指定目的架構的名稱

en: Specify the name of the target floating point hardware/format
zh_TW: 指定目的浮點硬體/格式的名稱

en: Specify the register to be used for PIC addressing
zh_TW: 指定用於 PIC 定址的暫存器

en: Split lifetimes of induction variables when loops are unrolled
zh_TW: 展開循環時分離歸納變數的生存期

en: Statement function '%s' at %L is not allowed as an actual argument
zh_TW: 敘述函式「%s」在 %L 處不允許做為實際引數

en: Statement function '%s' requires argument list at %C
zh_TW: 敘述函式「%s」在 %C 處缺少參數清單

en: Statement function at %L is recursive
zh_TW: %L 處的敘述函式是遞迴的

en: Statement label at %C is zero
zh_TW: %C 處敘述標籤為零

en: Step expression in DO loop at %L cannot be zero
zh_TW: 步進敘述於 %L 處的 DO 迴圈中不可為零

en: Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is available
zh_TW: 當最優邊的概率小於此限值(以百分數表示)時，停止前向增長。當取樣反饋可用時使用。

en: Stop forward growth if the probability of best edge is less than this threshold (in percent). Used when profile feedback is not available
zh_TW: 當最優邊的概率小於此限值(以百分數表示)時，停止前向增長。當取樣反饋無法使用時使用。

en: Stop reverse growth if the reverse probability of best edge is less than this threshold (in percent)
zh_TW: 當最優邊的反向概率小於此閾值(以百分數表示)時停止反向增長

en: Store function names in object code
zh_TW: 在目的檔案中存儲函式名

en: Substring at %L has length zero
zh_TW: %L 的子字串長度為零

en: Substring end index at %L must be of type INTEGER
zh_TW: %L 處的子字串終止索引類型必須為 INTEGER

en: Substring end index at %L must be scalar
zh_TW: %L 處的子字串終止索引必須是標量

en: Substring start index at %L is less than one
zh_TW: %L 處的子字串起始索引小於 1

en: Substring start index at %L must be of type INTEGER
zh_TW: %L 處的子字串起始索引類型必須為 INTEGER

en: Substring start index at %L must be scalar
zh_TW: %L 處的子字串起始索引必須是標量

en: Support 3DNow! built-in functions
zh_TW: 支援 3DNow! 內建函式

en: Support MMX and SSE built-in functions and code generation
zh_TW: 支援 MMX 和 SSE 內建函式及程式碼產生

en: Support MMX built-in functions
zh_TW: 支援 MMX 內建函式

en: Support MMX, SSE and SSE2 built-in functions and code generation
zh_TW: 支援 MMX、SSE 和 SSE2 內建函式及程式碼產生

en: Support MMX, SSE, SSE2 and SSE3 built-in functions and code generation
zh_TW: 支援 MMX、SSE、SSE2 和 SSE3 內建函式及程式碼產生

en: Support legacy multi-threading
zh_TW: 支援傳統多執行緒

en: Support multi-threading
zh_TW: 支援多執行緒

en: Support multiply accumulate instructions
zh_TW: 支援乘加指令

en: Support synchronous non-call exceptions
zh_TW: 支援同步非呼叫異常

en: Suppress warnings
zh_TW: 不顯示警告

en: Swap endianness for unformatted files
zh_TW: 切換位元組格式於未格式的檔案

en: Symbol '%s' at %C is already an external symbol that is not COMMON
zh_TW: 符號「%s」在 %C 處已經是外部而非 COMMON 符號

en: Symbol '%s' at %C is ambiguous
zh_TW: 符號「%s」在 %C 處有歧義

en: Symbol '%s' at %L already has an explicit interface
zh_TW: 符號「%s」在 %L 處已經有了明確介面

en: Symbol '%s' at %L already has basic type of %s
zh_TW: 符號「%s」在 %L 處已經有了基本類型 %s

en: Symbol '%s' at %L cannot have a type
zh_TW: 符號「%s」於 %L 處不能有類型

en: Symbol '%s' at %L has no IMPLICIT type
zh_TW: 符號「%s」(位於 %L)沒有 IMPLICIT 類型

en: Symbol '%s' at %L is ambiguous
zh_TW: 符號「%s」(位於 %L)有歧義

en: Symbol '%s' in namelist '%s' is INTENT(IN) at %C
zh_TW: 符號「%s」在名稱清單「%s」是 INTENT(IN)，位於 %C

en: Symbol '%s' must be a PARAMETER in DATA statement at %C
zh_TW: DATA 敘述中符號「%s」必須是一個 PARAMETER，在 %C 處

en: Symbol at %C is not appropriate for an expression
zh_TW: %C 處的符號不適用於運算式

en: Symbol at %L is not a DUMMY variable
zh_TW: %L 處的符號不是一個 DUMMY 變數

en: Synonym for -Wcomment
zh_TW: -Wcomment 的同義詞

en: Syntax error in %s statement at %C
zh_TW: %s 敘述在 %C 處語法錯誤

en: Syntax error in CHARACTER declaration at %C
zh_TW: %C 的 CHARACTER 宣告語法錯誤

en: Syntax error in COMPLEX constant at %C
zh_TW: %C 處的複常數語法錯誤

en: Syntax error in ENUMERATOR definition at %C
zh_TW: %C 處 ENUMERATOR 定義中語法錯誤

en: Syntax error in EQUIVALENCE statement at %L
zh_TW: %L 處 EQUIVALENCE 敘述語法錯誤

en: Syntax error in FORALL iterator at %C
zh_TW: %C 處 FORALL 迭代語法錯誤

en: Syntax error in I/O iterator at %C
zh_TW: %C 處 I/O 迭代語法錯誤

en: Syntax error in IF-clause at %C
zh_TW: %C 處 IF 敘述語法錯誤

en: Syntax error in IF-expression at %C
zh_TW: %C 處 IF 運算式語法錯誤

en: Syntax error in SAVE statement at %C
zh_TW: %C SAVE 敘述語法錯誤

en: Syntax error in SUBSTRING specification at %C
zh_TW: %C SUBSTRING 指定語法錯誤

en: Syntax error in argument list at %C
zh_TW: %C 處的參數清單語法錯誤

en: Syntax error in array constructor at %C
zh_TW: %C 陣列建構語法錯誤

en: Syntax error in character length specification at %C
zh_TW: %C 處指定字元長度時語法錯誤

en: Syntax error in common block name at %C
zh_TW: %C 處公共塊名語法錯誤

en: Syntax error in data declaration at %C
zh_TW: %C 處資料宣告語法錯誤

en: Syntax error in expression at %C
zh_TW: %C 運算式語法錯誤

en: Syntax error in generic specification at %C
zh_TW: %C 一般指定語法錯誤

en: Syntax error in iterator at %C
zh_TW: %C 處迭代語法錯誤

en: Taken at least once:%s of %d
zh_TW: 至少執行一次的跳轉：%s(總數為 %d)

en: Target DFLOAT double precision code
zh_TW: 產生 DFLOAT 雙精度程式碼

en: Target has split I&D
zh_TW: 目標平臺有分離的指令、資料空間

en: Target the AM33 processor
zh_TW: 目的為 AM33 處理器

en: Target the AM33/2.0 processor
zh_TW: 目的為 AM33/2.0 處理器

en: Target: %s
zh_TW: 目的：%s

en: The Hollerith constant at %L is too long to convert to %s
zh_TW: %L 的荷勒瑞斯常數太長，無法被轉換為 %s

en: The earliest MacOS X version on which this program will run
zh_TW: 這個程式可能在其上執行的最早的 MacOS X 版本

en: The maximum amount of memory to be allocated by GCSE
zh_TW: GCSE 可指派的最大記憶體量

en: The maximum depth of recursive inlining for inline functions
zh_TW: 內聯函式中巢狀內聯的最大深度

en: The maximum depth of recursive inlining for non-inline functions
zh_TW: 非內聯函式中巢狀內聯的最大深度

en: The maximum expansion factor when copying basic blocks
zh_TW: 複製基本區塊時最大的展開因子

en: The maximum length of path considered in cse
zh_TW: 公因式消去時考慮的最大路徑長度

en: The maximum length of scheduling's pending operations list
zh_TW: 調度候選作業清單的最大長度

en: The maximum memory locations recorded by cselib
zh_TW: cselib 可指派的最大記憶體量

en: The maximum number of blocks in a region to be considered for interblock scheduling
zh_TW: 一個區域中考慮進行塊間調度的最大塊數

en: The maximum number of incoming edges to consider for crossjumping
zh_TW: 考慮進行交叉跳轉的最大入邊數量

en: The maximum number of insns in a region to be considered for interblock scheduling
zh_TW: 一個區域中考慮進行塊間調度的最大指令數

en: The maximum number of insns of a completely peeled loop
zh_TW: 一個完全剝離的循環所能有的最大指令數

en: The maximum number of insns of a peeled loop
zh_TW: 剝離後的循環所能有的最大指令數

en: The maximum number of insns of a peeled loop that rolls only once
zh_TW: 被剝離後只捲繞一次的循環包含的最多指令數

en: The maximum number of insns of an unswitched loop
zh_TW: 去開關後的循環所能有的最大指令數

en: The maximum number of instructions in a single function eligible for inlining
zh_TW: 單一可內聯的函式體最多能包含的指令數

en: The maximum number of instructions inline function can grow to via recursive inlining
zh_TW: 由於巢狀內聯造成的內聯函式程式碼膨脹的上限值(指令數)

en: The maximum number of instructions non-inline function can grow to via recursive inlining
zh_TW: 由於巢狀內聯造成的非內聯函式程式碼膨脹的上限值(指令數)

en: The maximum number of instructions to consider to fill a delay slot
zh_TW: 考慮填充入延遲槽中的最大指令數

en: The maximum number of instructions to consider to find accurate live register information
zh_TW: 用以發現準確的作用中暫存器資訊的最大指令數量

en: The maximum number of instructions to consider to unroll in a loop
zh_TW: 單一循環中考慮展開的最大指令數

en: The maximum number of instructions to consider to unroll in a loop on average
zh_TW: 單一循環中考慮展開的平均最大指令數

en: The maximum number of instructions to search backward when looking for equivalent reload
zh_TW: 後向搜尋以尋找等價多載入時要搜尋的最大指令數量

en: The maximum number of instructions when automatically inlining
zh_TW: 自動內聯時指令的最大數量

en: The maximum number of loop iterations we predict statically
zh_TW: 靜態預測時的最多循環次數

en: The maximum number of peelings of a single loop
zh_TW: 單一循環最大的剝離數

en: The maximum number of peelings of a single loop that is peeled completely
zh_TW: 一個完全剝離的單一循環最大的剝離數

en: The maximum number of unrollings of a single loop
zh_TW: 單一循環最多可以被展開的次數

en: The maximum number of unswitchings in a single loop
zh_TW: 單一循環中考慮去開關的最大指令數

en: The minimum number of matching instructions to consider for crossjumping
zh_TW: 考慮進行交叉跳轉的最小匹配指令數量

en: The minimum probability of reaching a source block for interblock speculative scheduling
zh_TW: 區塊間預測調度時到達一個來源塊的最小概率

en: The module or main program array '%s' at %L must have constant shape
zh_TW: 模組或主程式陣列「%s」在 %L 處必須有常態的外形

en: The name '%s' cannot be used as a defined operator at %C
zh_TW: 名稱「%s」在 %C 處不能做為已定義的運算子

en: The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is available
zh_TW: 必須被蹤跡形成所覆寫的函式百分比，以執行頻率加權。當取樣反饋可用時使用

en: The percentage of function, weighted by execution frequency, that must be covered by trace formation. Used when profile feedback is not available
zh_TW: 必須被蹤跡形成所覆寫的函式百分比，以執行頻率加權。當取樣反饋無法使用時使用

en: The size of function body to be considered large
zh_TW: 超過這個大小的函式體被認為是大的

en: The size of translation unit to be considered large
zh_TW: 超過這個大小的翻譯單元被認為是大的

en: The threshold ratio for performing partial redundancy elimination after reload
zh_TW: 重新載入後進行部分冗餘消除的比例閾值

en: The threshold ratio of critical edges execution count that permit performing redundancy elimination after reload
zh_TW: 重新載入後允許進行冗餘消除的關鍵邊執行次數的比例閾值

en: The upper bound for sharing integer constants
zh_TW: 共享整型常數的上界

en: This is free software; see the source for copying conditions.
    There is NO warranty; not even for MERCHANTABILITY or 
    FITNESS FOR A PARTICULAR PURPOSE.
zh_TW: 本程式是自由軟體；請參看來源程式碼的版權宣告。本軟體沒有任何擔保；
    包括沒有適銷性和某一專用目的下的適用性擔保。

en: This is free software; see the source for copying conditions.  There is NO
    warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
zh_TW: 本程式是自由軟體；請參看來源程式碼的版權宣告。本軟體沒有任何擔保；
    包括沒有適銷性和某一專用目的下的適用性擔保。

en: This switch is deprecated; use -Wextra instead
zh_TW: 此開關已過時；請改用 -Wextra

en: This switch lacks documentation
zh_TW: 此開關缺少可用文件

en: Thread model: %s
zh_TW: 執行緒模型：%s

en: Thumb: Generate (leaf) stack frames even if not needed
zh_TW: Thumb：即使不需要也產生(葉)堆疊框架

en: Thumb: Generate (non-leaf) stack frames even if not needed
zh_TW: Thumb：即使不需要也產生(非葉)堆疊框架

en: Too many arguments in call to '%s' at %L
zh_TW: 對「%s」的呼叫給出的參數太多，於 %L 處

en: Too many arguments to %s at %L
zh_TW: 給予函式 %s 的參數太多，於 %L

en: Too many digits in statement label at %C
zh_TW: %C 處的敘述標籤太多位數

en: Trap on integer divide by zero
zh_TW: 整數被零除時進入陷阱

en: Treat all warnings as errors
zh_TW: 所有的警告都當作是錯誤

en: Treat lines with 'D' in column one as comments
zh_TW: 將第一列為「D」的列視作註釋

en: Treat missing header files as generated files
zh_TW: 將缺失的標頭檔案看作產生的檔案

en: Treat the input file as already preprocessed
zh_TW: 將輸入檔案當作已經預先處理過的

en: Try 'jcf-dump --help' for more information.
zh_TW: 試用「jcf-dump --help」以獲取更多資訊。

en: Try running '%s' in the shell to raise its limit.
zh_TW: 嘗試在命令解譯器中執行「%s」以提升它的極值。

en: Tune code for the given processor
zh_TW: 為指定的處理器最佳化程式碼

en: Tune expected memory latency
zh_TW: 調整預期記憶體延遲

en: Two main PROGRAMs at %L and %C
zh_TW: %L 和 %C 處有兩個主 PROGRAM

en: Type name '%s' at %C cannot be the same as an intrinsic type
zh_TW: 類型「%s」(位於 %C)不能與內建類型同名

en: Type name '%s' at %C is ambiguous
zh_TW: 類型名「%s」(於 %C 處)有歧義

en: UNIT specification at %L must be an INTEGER expression or a CHARACTER variable
zh_TW: %L 處指定的 UNIT 必須是 INTEGER 運算式或一個 CHARACTER 變數

en: Unclassifiable statement at %C
zh_TW: %C 敘述無法歸類別

en: Unclassifiable statement in IF-clause at %C
zh_TW: %C 處 IF 子句中有無法歸類別的敘述

en: Unexpected %s statement at %C
zh_TW: 非預期的 %s 敘述於 %C 處

en: Unexpected %s statement at %C in INTERFACE body
zh_TW: 非預期的 %s 敘述出現在 %C 處的 INTERFACE 體中

en: Unexpected %s statement in BLOCK DATA at %C
zh_TW: 非預期的 %s 敘述出現在 %C 處的 DATA 區塊中

en: Unexpected %s statement in CONTAINS section at %C
zh_TW: 非預期的 %s 敘述出現在 %C 處的 CONTAINS 段中

en: Unexpected %s statement in FORALL block at %C
zh_TW: 非預期的 %s 敘述出現在 %C 處的 FORALL 區塊中

en: Unexpected %s statement in INTERFACE block at %C
zh_TW: 非預期的 %s 敘述出現在 %C 處的 INTERFACE 區塊中

en: Unexpected %s statement in MODULE at %C
zh_TW: 非預期的 %s 敘述出現在 %C 處的 MODULE 中

en: Unexpected %s statement in WHERE block at %C
zh_TW: 非預期的 %s 敘述出現在 %C 處的 WHERE 區塊中

en: Unexpected CASE statement at %C
zh_TW: %C 處非預期的 CASE 敘述

en: Unexpected END statement at %C
zh_TW: %C 處非預期的 END 敘述

en: Unexpected EOF
zh_TW: 非預期的檔案結束

en: Unexpected character in variable list at %C
zh_TW: %C 處變數清單中有非預期的無用字元

en: Unexpected characters in PARAMETER statement at %C
zh_TW: %C 處 PARAMETER 敘述中有非預期的字元

en: Unexpected end of file in '%s'
zh_TW: 「%s」中非預期的檔案結尾

en: Unexpected end of format string
zh_TW: 非預期的格式字串結尾

en: Unexpected end of module
zh_TW: 非預期的模組結束

en: Unexpected junk after ELSE statement at %C
zh_TW: %C 處 ELSE 敘述後有非預期的無用字元

en: Unexpected junk after function declaration at %C
zh_TW: %C 處的函式宣告後有非預期的無用字元

en: Unexpected junk in formal argument list at %C
zh_TW: %C 處參數清單中有非預期的無用字元

en: Unexpected use of subroutine name '%s' at %C
zh_TW: 對子處理序名「%s」非預期的使用，在 %C 處

en: Unknown intrinsic op
zh_TW: 不明的內建作業

en: Unsupported statement inside WHERE at %L
zh_TW: %L 處在 WHERE 內不支援的敘述

en: Unterminated character constant beginning at %C
zh_TW: 開始於 %C 的未終結的字元常數

en: Usage: %s [OPTIONS]... CLASSNAMEmain [OUTFILE]
zh_TW: 用法：%s [選項]... main類別名 [輸出檔案]

en: Usage: %s [options] file...
zh_TW: 用法：%s [選項] 檔案...

en: Usage: jcf-dump [OPTION]... CLASS...
zh_TW: 用法：jcf-dump [選項]... 類別...

en: Use 128-bit long double
zh_TW: 使用 128 位 long double

en: Use 16 bit int
zh_TW: 使用 16 位整數

en: Use 32 bit float
zh_TW: 使用 32 位元浮點數

en: Use 32 bit int
zh_TW: 使用 32 位元整數

en: Use 32-bit ABI
zh_TW: 使用 32 位元 ABI

en: Use 32-bit floating-point registers
zh_TW: 使用 32 位元浮點暫存器

en: Use 32-bit general registers
zh_TW: 使用 32 位元通用暫存器

en: Use 4 byte entries in switch tables
zh_TW: 在分支表中使用 4 位元組長的條目

en: Use 4 media accumulators
zh_TW: 使用 4 個多媒體累加器

en: Use 64 FPRs
zh_TW: 使用 64 個浮點暫存器

en: Use 64 GPRs
zh_TW: 使用 64 個通用暫存器

en: Use 64 bit float
zh_TW: 使用 64 位元浮點數

en: Use 64-bit ABI
zh_TW: 使用 64 位元 ABI

en: Use 64-bit floating-point registers
zh_TW: 使用 64 位元浮點暫存器

en: Use 64-bit general registers
zh_TW: 使用 64 位元通用暫存器

en: Use 64-bit long double
zh_TW: 使用 64 位元 long double

en: Use 8 media accumulators
zh_TW: 使用 8 個多媒體累加器

en: Use ABI reserved registers
zh_TW: 使用 ABI 保留的暫存器

en: Use AltiVec instructions
zh_TW: 使用 AltiVec 指令

en: Use CONST16 instruction to load constants
zh_TW: 使用 CONST16 指令載入常數

en: Use EABI
zh_TW: 使用 EABI

en: Use GP relative sdata/sbss sections
zh_TW: 使用相對 GP 的 sdata/sbss 區段

en: Use H8/300 alignment rules
zh_TW: 使用 H8/300 對齊規則

en: Use IEEE math for fp comparisons
zh_TW: 浮點數間的比較嚴格遵循 IEEE 標準

en: Use MIPS-3D instructions
zh_TW: 使用 MIPS-3D 指令

en: Use MIPS-DSP instructions
zh_TW: 使用 MIPS-DSP 指令

en: Use Mingw-specific thread support
zh_TW: 使用 Mingw 特定的執行緒支援

en: Use NewABI-style %reloc() assembly operators
zh_TW: 使用 NewABI 風格的 %reloc() 組譯運算子

en: Use P-mnemonics for branches statically predicted as taken
zh_TW: 為靜態預測為必要進行的跳轉使用 P 助憶符號

en: Use PMC-style 'mad' instructions
zh_TW: 使用 PMC 風格的「mad」指令

en: Use PowerPC General Purpose group optional instructions
zh_TW: 使用 PowerPC 通用組可選指令

en: Use PowerPC Graphics group optional instructions
zh_TW: 使用 PowerPC 圖像組可選指令

en: Use PowerPC V2.01 single field mfcr instruction
zh_TW: 使用 PowerPC V2.01 單欄位 mfcr 指令

en: Use PowerPC V2.02 floating point rounding instructions
zh_TW: 使用 PowerPC V2.02 浮點捨入指令

en: Use PowerPC V2.02 popcntb instruction
zh_TW: 使用 PowerPC V2.02 popcntb 指令

en: Use PowerPC-64 instruction set
zh_TW: 使用 PowerPC-64 指令集

en: Use ROM instead of RAM
zh_TW: 使用 ROM 而不是 RAM

en: Use SSE register passing conventions for SF and DF mode
zh_TW: 在 SF 和 DF 模式下使用 SSE 暫存器呼叫約定

en: Use UNIX assembler syntax
zh_TW: 使用 UNIX 組譯風格

en: Use VAX fp
zh_TW: 使用 VAX 浮點單元

en: Use VAXC structure conventions
zh_TW: 使用 VAXC 結構約定

en: Use __cxa_atexit to register destructors
zh_TW: 將 __cxa_atexit 而非 atexit 登記為解構函式

en: Use a 32-bit long type
zh_TW: 使用 32 位元 long 類型

en: Use a 64-bit long type
zh_TW: 使用 64 位元 long 類型

en: Use addresses that allocate global registers
zh_TW: 使用指派全域暫存器的位址

en: Use alternate register names
zh_TW: 使用另一套暫存器名

en: Use an 8-bit 'int' type
zh_TW: 使用 8 位「int」類型

en: Use arbitrary sized immediates in bit operations
zh_TW: 在位作業中使用任意大小的立即數值

en: Use big-endian byte order
zh_TW: 令高位位元組在前

en: Use big-endian format for unformatted files
zh_TW: 使用低位位元組格式於未格式的檔案

en: Use branch-and-break sequences to check for integer divide by zero
zh_TW: 使用分支-插斷序列來偵測整數零除

en: Use call-clobbered registers for parameters and return value
zh_TW: 將呼叫篡改的暫存器用於參數和回傳值

en: Use different calling convention using 'rtd'
zh_TW: 啟用使用「rtd」的不同的呼叫約定

en: Use direct references against %gs when accessing tls data
zh_TW: 當存取執行緒局部資料時直接參照 %gs

en: Use epsilon-respecting floating point compare instructions
zh_TW: 使用在意無窮小的浮點比較指令

en: Use expression value profiles in optimizations
zh_TW: 在最佳化中使用運算式值樣本提供的資訊

en: Use f2c calling convention
zh_TW: 使用 f2c 呼叫約定

en: Use features of and schedule code for given CPU
zh_TW: 使用指定 CPU 的特性和調度程式碼

en: Use features of and schedule given CPU
zh_TW: 使用指定 CPU 的特性並為其調度程式碼

en: Use fp double instructions
zh_TW: 使用浮點雙精度指令

en: Use fp registers
zh_TW: 使用浮點暫存器

en: Use given SPARC-V9 code model
zh_TW: 使用給定的 SPARC-V9 程式碼模型

en: Use given assembler dialect
zh_TW: 使用給定的組譯風格

en: Use given thread-local storage dialect
zh_TW: 使用給定的執行緒局部存儲模式

en: Use given x86-64 code model
zh_TW: 使用給定的 x86-64 程式碼模式

en: Use hardware FP
zh_TW: 使用硬體浮點單元

en: Use hardware floating point
zh_TW: 使用硬體浮點單元

en: Use hardware fp
zh_TW: 使用硬體浮點單元

en: Use hardware quad FP instructions
zh_TW: 使用硬體四浮點指令

en: Use in/loc/out register names
zh_TW: 使用 in/loc/out 暫存器名

en: Use indirect calls
zh_TW: 使用間接呼叫

en: Use jump tables for sufficiently large switch statements
zh_TW: 為足夠大的 switch 敘述使用跳轉表

en: Use little-endian byte order
zh_TW: 令低位位元組在前

en: Use little-endian format for unformatted files
zh_TW: 使用低位位元組格式於未格式的檔案

en: Use media instructions
zh_TW: 使用多媒體指令

en: Use multiply add/subtract instructions
zh_TW: 使用乘加/減指令

en: Use native (MS) bitfield layout
zh_TW: 使用本地 (MS) 位元段存儲方式

en: Use native format for unformatted files
zh_TW: 使用原生格式於未格式的檔案

en: Use normal calling convention
zh_TW: 使用一般的呼叫約定

en: Use of -fdefault-double-8 requires -fdefault-real-8
zh_TW: 使用 -fdefault-double-8 時需要 -fdefault-real-8

en: Use offset tables for virtual method calls
zh_TW: 為虛方法呼叫使用偏移表

en: Use only one TOC entry per procedure
zh_TW: 為每個程序只使用一個 TOC 條目

en: Use packed stack layout
zh_TW: 使用緊實的堆疊版面設置

en: Use paired-single floating-point instructions
zh_TW: 使用配對的單精度浮點指令

en: Use portable calling conventions
zh_TW: 使用一般的呼叫約定

en: Use profiling information for branch probabilities
zh_TW: 為分支概率使用取樣資訊

en: Use push instructions to save outgoing arguments
zh_TW: 使用 push 指令儲存參數

en: Use red-zone in the x86-64 code
zh_TW: 在 x86-64 程式碼中使用紅區

en: Use register stack for parameters and return value
zh_TW: 使用暫存器堆疊傳遞參數和回傳值

en: Use registers for argument passing
zh_TW: 使用暫存器傳遞參數

en: Use registers r2 and r5
zh_TW: 使用暫存器 r2 和 r5

en: Use shared libraries
zh_TW: 使用共享函式庫

en: Use simulator runtime
zh_TW: 使用模擬器執行時

en: Use software floating point
zh_TW: 使用軟體浮點單元

en: Use stack bias
zh_TW: 使用堆疊偏移

en: Use stubs for function prologues
zh_TW: 使用占位程式完成函式前言/尾聲

en: Use subroutines for function prologues and epilogues
zh_TW: 使用子程式完成函式前言/尾聲

en: Use the Cray Pointer extension
zh_TW: 使用 Cray 指標擴充

en: Use the DEC assembler syntax
zh_TW: 使用 DEC 組譯風格

en: Use the bit-field instructions
zh_TW: 使用位元段指令

en: Use the divide instruction
zh_TW: 使用除法指令

en: Use the narrowest integer type possible for enumeration types
zh_TW: 為列舉類型使用盡可能窄的整數類型

en: Use the same size for double as for float
zh_TW: 令 double 使用 float 的大小

en: Use trap instructions to check for integer divide by zero
zh_TW: 使用陷阱指令偵測整數零除

en: Use zero-extending memory loads, not sign-extending ones
zh_TW: 使用零擴充而不是符號擴充的記憶體載入

en: Used in Fix-and-Continue mode to indicate that object files may be swapped in at runtime
zh_TW: 指定物件檔案可能在執行時被換入以允許「修復並繼續」除錯模式

en: Using built-in specs.
zh_TW: 使用內建 specs。

en: VOIDmode on an output
zh_TW: 輸出有 VOIDmode

en: Variable '%s' at %L has not been assigned a format label
zh_TW: 變數「%s」在 %L 尚未指派到格式標籤

en: Variable '%s' at %L in this context must be constant
zh_TW: 變數「%s」在 %L 處上下文中必須是常數

en: Variable '%s' cannot appear in the expression at %L
zh_TW: 變數「%s」不能出現在 %L 處的運算式中

en: Variable '%s' has not been assigned a target label at %L
zh_TW: 變數「%s」在 %L 尚未指派到目標標籤

en: Variable type is UNKNOWN in assignment at %L
zh_TW: %L 處賦值中的變數類型是 UNKNOWN

en: WHERE/ELSEWHERE clause at %L requires a LOGICAL array
zh_TW: %L 處的 WHERE/ELSEWHERE 子句需要一個 LOGICAL 陣列

en: Warn about "extern" declarations not at file scope
zh_TW: 當「extern」宣告不在檔案作用欄位時給出警告

en: Warn about "suspicious" constructs
zh_TW: 對「可疑」的建構給出警告

en: Warn about @selector()s without previously declared methods
zh_TW: 當使用 @selector() 卻不作事先宣告時給出警告

en: Warn about C constructs that are not in the common subset of C and C++
zh_TW: 當在 C 語言中使用了 C 與 C++ 交集以外的建構時給出警告

en: Warn about NULL being passed to argument slots marked as requiring non-NULL
zh_TW: 當將 NULL 傳遞給需要非 NULL 的參數的函式時給出警告

en: Warn about PCH files that are found but not used
zh_TW: 在找到了 PCH 檔案但未使用的情況給出警告

en: Warn about all enumerated switches missing a specific case
zh_TW: 當使用列舉類型做為開關變數但又缺少某個 case 時給出警告

en: Warn about calls with implicit interface
zh_TW: 對帶有隱含介面的呼叫給出警告

en: Warn about casting functions to incompatible types
zh_TW: 當把函式轉換為不相容類型時給出警告

en: Warn about casts which discard qualifiers
zh_TW: 當類型轉換丟失限定資訊時給出警告

en: Warn about code which might break strict aliasing rules
zh_TW: 當程式碼可能破壞強重疊規則時給出警告

en: Warn about compile-time integer division by zero
zh_TW: 對編譯時發現的零除給出警告

en: Warn about deprecated 'vector long ...' AltiVec type usage
zh_TW: 使用過時的「vector long ...」AltiVec 類型時給出警告

en: Warn about enumerated switches missing a "default:" statement
zh_TW: 當使用列舉類型做為開關變數，但沒有提供「default」分支時給出警告

en: Warn about enumerated switches, with no default, missing a case
zh_TW: 當使用列舉類型做為開關變數，沒有提供 default 分支，但又缺少某個 case 時給出警告

en: Warn about features not present in traditional C
zh_TW: 使用了傳統 C 不支援的特性時給出警告

en: Warn about format strings that are not literals
zh_TW: 當格式字串不是字面值時給出警告

en: Warn about function pointer arithmetic
zh_TW: 當在算術運算式中使用函式指標時給出警告

en: Warn about functions which might be candidates for __attribute__((noreturn))
zh_TW: 當函式可能是 __attribute__((noreturn)) 的備選時給出警告

en: Warn about functions which might be candidates for format attributes
zh_TW: 當函式可能是 format 屬性的備選時給出警告

en: Warn about global functions without previous declarations
zh_TW: 當全域函式沒有前向宣告時給出警告

en: Warn about global functions without prototypes
zh_TW: 全域函式沒有原型時給出警告

en: Warn about implicit function declarations
zh_TW: 對隱含函式宣告給出警告

en: Warn about inappropriate attribute usage
zh_TW: 當對屬性的使用不合適時給出警告

en: Warn about invalid uses of the "offsetof" macro
zh_TW: 對「offsetof」巨集無效的使用給出警告

en: Warn about macros defined in the main file that are not used
zh_TW: 當定義在主檔案中的巨集未被使用時給出警告

en: Warn about missing fields in struct initializers
zh_TW: 若結構初始值設定項中缺少欄位則給出警告

en: Warn about misuses of pragmas
zh_TW: 對錯誤使用的 pragma 加以警告

en: Warn about multiple declarations of the same object
zh_TW: 對同一個物件多次宣告時給出警告

en: Warn about non-virtual destructors
zh_TW: 當解構函式不是虛函式時給出警告

en: Warn about overloaded virtual function names
zh_TW: 多載虛函式名時給出警告

en: Warn about pointer casts which increase alignment
zh_TW: 當轉換指標類型導致對齊邊界增長時給出警告

en: Warn about possible security problems with format functions
zh_TW: 當使用格式字串的函式可能導致安全問題時給出警告

en: Warn about possible violations of sequence point rules
zh_TW: 當可能違反定序點規則時給出警告

en: Warn about possibly missing braces around initializers
zh_TW: 若初始值設定項中可能缺少大括號則給出警告

en: Warn about possibly missing parentheses
zh_TW: 可能缺少括號的情況下給出警告

en: Warn about possibly nested block comments, and C++ comments spanning more than one physical line
zh_TW: 對可能巢狀的註釋和長度超過一個物理列長的 C++ 註釋給出警告

en: Warn about printf/scanf/strftime/strfmon format string anomalies
zh_TW: 對 printf/scanf/strftime/strfmon 中的格式字串異常給出警告

en: Warn about returning structures, unions or arrays
zh_TW: 當回傳結構、聯合或陣列時給出警告

en: Warn about signed-unsigned comparisons
zh_TW: 在有號和無號數間進行比較時給出警告

en: Warn about stray tokens after #elif and #endif
zh_TW: 當 #elif 和 #endif 後面跟有其它識別碼時給出警告

en: Warn about strftime formats yielding 2-digit years
zh_TW: 當 strftime 格式給出 2 位記年時給出警告

en: Warn about subscripts whose type is "char"
zh_TW: 當下標類型為「char」時給出警告

en: Warn about suspicious declarations of "main"
zh_TW: 對可疑的「main」宣告給出警告

en: Warn about things that will change when compiling with an ABI-compliant compiler
zh_TW: 當結果與 ABI 相容的編譯器的編譯結果不同時給出警告

en: Warn about truncated source lines
zh_TW: 對被截斷的來源檔案列給出警告

en: Warn about uncasted NULL used as sentinel
zh_TW: 將未作轉換的 NULL 做為哨兵時給出警告

en: Warn about underflow of numerical constant expressions
zh_TW: 數字常數運算式向下溢位時警告

en: Warn about uninitialized automatic variables
zh_TW: 自動變數未初始化時警告

en: Warn about unprototyped function declarations
zh_TW: 使用了非原型的函式宣告時給出莥警告

en: Warn about unrecognized pragmas
zh_TW: 對無法辨識的 pragma 加以警告

en: Warn about use of multi-character character constants
zh_TW: 使用多位元組字元集的字元常數時給出警告

en: Warn about user-specified include directories that do not exist
zh_TW: 當使用者給定的包含目錄不存在時給出警告

en: Warn about uses of __attribute__((deprecated)) declarations
zh_TW: 對 __attribute__((deprecated)) 宣告給出警告

en: Warn about variables which are initialized to themselves
zh_TW: 對初始化為自身的變數給出警告。

en: Warn about violations of Effective C++ style rules
zh_TW: 對不遵循 Effetive C++ 的風格給出警告

en: Warn about zero-length formats
zh_TW: 對長度為 0 的格式字串給出警告

en: Warn if .class files are out of date
zh_TW: 當 .class 檔案已過時時給出警告

en: Warn if a C-style cast is used in a program
zh_TW: 程式使用 C 風格的類型轉換時給出警告

en: Warn if a deprecated compiler feature, class, method, or field is used
zh_TW: 當使用過時的編譯器特性，類別，方法或欄位時給出警告

en: Warn if a function uses alloca or creates an array with dynamic size
zh_TW: 當函式使用 alloca 來建立彈性陣列時給出警告

en: Warn if a selector has multiple methods
zh_TW: 當選擇子有多個方法時給出警告

en: Warn if a single function's framesize exceeds the given framesize
zh_TW: 當單一函式的圖框大小超過給定值時給出警告

en: Warn if an old-style parameter definition is used
zh_TW: 使用舊式參數定義時給出警告

en: Warn if an undefined macro is used in an #if directive
zh_TW: 當 #if 指令中用到未定義的巨集時給出警告

en: Warn if deprecated empty statements are found
zh_TW: 發現過時的空敘述時給出警告

en: Warn if inherited methods are unimplemented
zh_TW: 當繼承來的方法未被實作時給出警告

en: Warn if modifiers are specified when not necessary
zh_TW: 當指定了不必須的修飾符時給出警告

en: Warn if passing too many arguments to a function for its format string
zh_TW: 當傳遞給格式字串的引數太多時給出警告

en: Warn if testing floating point numbers for equality
zh_TW: 當比較浮點數是否相等時給出警告

en: Warn if the loop cannot be optimized due to nontrivial assumptions.
zh_TW: 當循環因為不平凡的假定而不能被最佳化時給出警告

en: Warn if trigraphs are encountered that might affect the meaning of the program
zh_TW: 當三字母序列可能影響程式意義時給出警告

en: Warn if type signatures of candidate methods do not match exactly
zh_TW: 當備選方法的類型簽字不完全匹配時給出警告

en: Warn when a declaration does not specify a type
zh_TW: 當宣告未指定類型時給出警告

en: Warn when a declaration is found after a statement
zh_TW: 當宣告出現在敘述後時給出警告

en: Warn when a function is unused
zh_TW: 有未使用的函式時警告

en: Warn when a function parameter is unused
zh_TW: 發現未使用的函式指標時給出警告

en: Warn when a label is unused
zh_TW: 有未使用的標籤時警告

en: Warn when a pointer differs in signedness in an assignment
zh_TW: 當賦值時指標有/無號不一致時給出警告

en: Warn when a pointer is cast to an integer of a different size
zh_TW: 當將一個指標轉換為大小不同的整數時給出警告

en: Warn when a register variable is declared volatile
zh_TW: 當一個暫存器變數被宣告為 volatile 時給出警告

en: Warn when a variable is unused
zh_TW: 有未使用的變數時警告

en: Warn when all constructors and destructors are private
zh_TW: 當所有建構式和解構函式都是私有時給出警告

en: Warn when an expression value is unused
zh_TW: 當一個運算式的值未被使用時給出警告

en: Warn when an inlined function cannot be inlined
zh_TW: 當內聯函式無法被內聯時給出警告

en: Warn when an optimization pass is disabled
zh_TW: 當某趟最佳化被停用時給出警告

en: Warn when converting the type of pointers to member functions
zh_TW: 當變更成員函式指標的類型時給出警告

en: Warn when non-templatized friend functions are declared within a template
zh_TW: 在範本內宣告未範本化的夥伴函式時給出警告

en: Warn when one local variable shadows another
zh_TW: 當一個局部變數掩蓋了另一個局部變數時給出警告

en: Warn when overload promotes from unsigned to signed
zh_TW: 當多載將無號數提升為有號數時給出警告

en: Warn when padding is required to align structure members
zh_TW: 當需要填補才能對齊結構成員時給出警告

en: Warn when the compiler reorders code
zh_TW: 編譯器將程式碼重新排序時給出警告

en: Warn when the packed attribute has no effect on struct layout
zh_TW: 當 packed 屬性對結構版面設置不起作用時給出警告

en: Warn when there is a cast to a pointer from an integer of a different size
zh_TW: 當將一個大小不同的整數轉換為指標時給出警告

en: Warn whenever a function's return type defaults to "int" (C), or about inconsistent return types (C++)
zh_TW: 當 C 函式的回傳值預設為「int」，或是 C++ 函式的回傳類型不一致時給出警告

en: Warn whenever an Objective-C assignment is being intercepted by the garbage collector
zh_TW: 當 Objective-C 賦值可能為無用回收所介入時給出警告

en: Warning:
zh_TW: 警告：

en: When "signed" or "unsigned" is not given make the bitfield signed
zh_TW: 沒有給定「signed」或「unsigned」時將位元段視作有號的

en: When "signed" or "unsigned" is not given make the bitfield unsigned
zh_TW: 未指定「signed」或「unsigned」時預設位元段為無號的

en: When possible do not generate stack frames
zh_TW: 盡可能不產生堆疊框架

en: When running CSE, follow jumps to their targets
zh_TW: 進行 CSE 時，跟隨跳轉至目的

en: While setting up signal handler: %m
zh_TW: 當設定信號處理者時：%m

en: While setting up signal stack: %m
zh_TW: 當設定信號堆疊時：%m

en: Work around VR4130 mflo/mfhi errata
zh_TW: 為 VR4130 mflo/mfhi 缺陷提供變通

en: Work around an early 4300 hardware bug
zh_TW: 為早期 4300 的硬體缺陷提供變通

en: Work around bug in multiplication instruction
zh_TW: 為乘法指令中的缺陷提供變通

en: Work around certain R4000 errata
zh_TW: 為某些 R4000 缺陷提供變通

en: Work around certain R4400 errata
zh_TW: 為某些 R4400 缺陷提供變通

en: Work around certain VR4120 errata
zh_TW: 為某些 VR4210 缺陷提供變通

en: Work around errata for early SB-1 revision 2 cores
zh_TW: 為早期 SB-1 rev 2 核心的缺陷提供變通

en: Work around hardware multiply bug
zh_TW: 為硬體乘法缺陷提供變通

en: Writing module %s at line %d column %d: %s
zh_TW: 讀入模組 %s，於列 %d 行 %d：%s

en: XXX entering pop_everything ()
zh_TW: XXX 進入 pop_everything ()

en: XXX leaving pop_everything ()
zh_TW: XXX 離開 pop_everything ()

en: Zero is not a valid statement label at %C
zh_TW: 零不是 %C 處的一個有效的敘述標籤

en: [Leaving %s]
zh_TW: [離開 %s]

en: [cannot find %s]
zh_TW: [找不到 %s]

en: [super ...] must appear in a method context
zh_TW: [super ...] 必須出現在方法上下文中

en: __BELOW100__ attribute not allowed with auto storage class
zh_TW: __BELOW100__ 屬性不允許用於自動存儲類別

en: __builtin_eh_return not supported on this target
zh_TW: __builtin_eh_return 在此目標平臺上不受支援

en: __builtin_saveregs not supported by this subtarget
zh_TW: __builtin_saveregs 在此子目的上不受支援

en: __builtin_saveregs not supported by this target
zh_TW: __builtin_saveregs 不為此目的所支援

en: `
zh_TW: 「

en: a parameter list with an ellipsis can%'t match an empty parameter name list declaration
zh_TW: 帶有省略號的參數清單無法與空參數名清單宣告匹配

en: a storage class can only be specified for objects and functions
zh_TW: 只能為物件和函式指定存儲類別

en: a template-id may not appear in a using-declaration
zh_TW: 範本識別碼不允許出現在 using 宣告中

en: a using-declaration cannot specify a template-id.  Try %<using %D%>
zh_TW: using 宣告不能指定一個範本識別碼。請嘗試 %<using %D%>

en: abort in %s, at %s:%d
zh_TW: 在 %s 中放棄，於 %s:%d

en: abstract declarator %qT used as declaration
zh_TW: 抽象宣告 %qT 做為宣告

en: accumulator is not a constant integer
zh_TW: 累加數不是一個整常數

en: accumulator number is out of bounds
zh_TW: 累加器個數越界

en: address area of %q+D conflicts with previous declaration
zh_TW: %q+D 的資料區域與先前的宣告衝突

en: address of explicit register variable %qD requested
zh_TW: 要求明確暫存器變數 %qD 的位址。

en: address of global register variable %qD requested
zh_TW: 要求全域暫存器變數 %qD 的位址

en: address of local variable %q+D returned
zh_TW: 回傳了局部變數的 %q+D 的位址

en: address of register variable %qD requested
zh_TW: 要求暫存器變數 %qD 的位址。

en: address offset not a constant
zh_TW: 位址偏移量不是一個常數

en: address requested for %qD, which is declared %<register%>
zh_TW: 請求宣告為 %<register%> 的 %qD 的位址

en: after previous specification in %q+#D
zh_TW: 但先前在 %q+#D 中已有指定

en: aggregate %q#D has incomplete type and cannot be defined
zh_TW: 聚合 %q#D 類型不完全，無法被定義

en: aggregate value used where a complex was expected
zh_TW: 需要複數時使用了聚合值

en: aggregate value used where a float was expected
zh_TW: 需要浮點數時使用了聚合值

en: aggregate value used where an integer was expected
zh_TW: 需要整數時使用了聚合值

en: alignment may not be specified for %q+D
zh_TW: 不能為 %q+D 指定對齊

en: alignment must be a small power of two, not %d
zh_TW: 對齊邊界必須是 2 的較小次方，而不是 %d

en: alignment of %q+D is greater than maximum object file alignment.  Using %d
zh_TW: %q+D 的對齊要求大於目的檔案的最大對齊邊界。使用 %d

en: alignment of array elements is greater than element size
zh_TW: 陣列元素的對齊邊界比元素大小還要大

en: all member functions in class %qT are private
zh_TW: 類別 %qT 中所有成員函式都是私有的

en: ambiguates built-in declaration %q#D
zh_TW: 使內建宣告 %q#D 出現歧義

en: ambiguates old declaration %q+#D
zh_TW: 使舊的宣告 %q+#D 出現歧義

en: ambiguous class template instantiation for %q#T
zh_TW: %q#T 的類別範本實體化有歧義

en: ambiguous conversion for array subscript
zh_TW: 為陣列下標的轉換有歧義

en: ambiguous default type conversion from %qT
zh_TW: %qT 的預設類型轉換有歧義

en: ambiguous template specialization %qD for %q+D
zh_TW: 有歧義的範本特例化 %qD (為 %q+D)

en: an argument type that has a default promotion can%'t match an empty parameter name list declaration
zh_TW: 具有預設提升的引數類型不能匹配空參數名清單宣告

en: an asm-specification is not allowed on a function-definition
zh_TW: 函式定義中不允許出現 asm 指定

en: an explicit specialization must be preceded by %<template <>%>
zh_TW: 明確特例化前必須有 %<template <>%>

en: anachronism:
zh_TW: 時代錯誤：

en: anachronistic old-style base class initializer
zh_TW: 年代錯誤的舊式基礎類別初始值設定

en: anonymous %s declared inside parameter list
zh_TW: 在參數清單中宣告了匿名 %s

en: anonymous struct not inside named type
zh_TW: 匿名結構不在具名類型內

en: anonymous union with no members
zh_TW: 匿名聯合沒有成員

en: applying #pragma weak %q+D after first use results in unspecified behavior
zh_TW: 在第一次使用後套用 #pragma weak %q+D 導致不可預知的後果

en: args to be formatted is not %<...%>
zh_TW: 待格式化的引數不是 %<...%>

en: argument %d of %qE might be a candidate for a format attribute
zh_TW: 引數 %d(屬於 %qE)可能是 format 屬性的備選

en: argument %q+D might be clobbered by %<longjmp%> or %<vfork%>
zh_TW: 引數 %q+D 可能為 %<longjmp%> 或 %<vfork%> 所篡改

en: argument %qD doesn%'t match built-in prototype
zh_TW: 引數 %qD 與內建原型不符

en: argument %qD doesn%'t match prototype
zh_TW: 引數 %qD 與原型不符

en: argument %qd is not a constant
zh_TW: 引數 %qd 不是一個常數

en: argument %qs to %<-Wnormalized%> not recognized
zh_TW: 引數 %qs(給予 %<-Wnormalized%>)無法識別

en: argument 1 must be a 5-bit signed literal
zh_TW: 引數 1 必須是一個 5 位有號字面值

en: argument 1 of __builtin_altivec_predicate is out of range
zh_TW: __builtin_altivec_predicate 的第 1 個引數越界

en: argument 1 of __builtin_altivec_predicate must be a constant
zh_TW: __builtin_altivec_predicate 的第一個引數必須是常數

en: argument 1 of __builtin_spe_predicate is out of range
zh_TW: __builtin_spe_predicate 的第 1 個引數越界

en: argument 1 of __builtin_spe_predicate must be a constant
zh_TW: __builtin_spe_predicate 的第一個引數必須是常數

en: argument 2 must be a 5-bit unsigned literal
zh_TW: 引數 2 必須是一個 5 位無號字面值

en: argument 3 must be a 4-bit unsigned literal
zh_TW: 引數 3 必須是一個 4 位無號字面值

en: argument of %<__builtin_eh_return_regno%> must be constant
zh_TW: %<__builtin_eh_return_regno%> 的引數必須是常數

en: argument of function call might be a candidate for a format attribute
zh_TW: 函式的引數可能是 format 屬性的備選

en: argument to %qs must be a 2-bit unsigned literal
zh_TW: %qs 的引數必須是一個 2 位無號原文

en: argument to dss must be a 2-bit unsigned literal
zh_TW: dss 的引數必須是一個 2 位無號原文

en: arguments to destructor are not allowed
zh_TW: 解構函式不能有參數

en: arithmetic IF
zh_TW: 算術 IF

en: arithmetic on pointer to an incomplete type
zh_TW: 在參照不完全類型的指標上執行算術運算

en: array %q+D assumed to have one element
zh_TW: 假定陣列 %q+D 有一個元素

en: array %qD initialized by parenthesized string literal %qE
zh_TW: 陣列 %qD 被有括號的字面字串 %qE 所初始化

en: array bound forbidden after parenthesized type-id
zh_TW: 括起的類型識別碼後面不能出現陣列邊界

en: array bound is not an integer constant
zh_TW: 陣列邊界不是一個整數常數

en: array index in initializer exceeds array bounds
zh_TW: 初始化時陣列索引越界

en: array index in initializer not of integer type
zh_TW: 初始值設定中陣列索引不是整型

en: array index in non-array initializer
zh_TW: 在非陣列初始值設定項中出現陣列索引

en: array index range in initializer exceeds array bounds
zh_TW: 初始值設定中資料索引範圍超出陣列邊界

en: array initialized from non-constant array expression
zh_TW: 用非常數的陣列運算式初始化陣列

en: array initialized from parenthesized string constant
zh_TW: 用括號中的字串常數初始化陣列

en: array of inappropriate type initialized from string constant
zh_TW: 用字串常數初始化的陣列類型不合適

en: array size missing in %q+D
zh_TW: 在 %q+D 中缺少陣列大小

en: array size missing in %qD
zh_TW: %qD 缺少陣列大小

en: array subscript has type %<char%>
zh_TW: 陣列下標類型為 %<char%>

en: array subscript is not an integer
zh_TW: 陣列下標不是一個整數

en: array type has incomplete element type
zh_TW: 陣列元素的類型不完全

en: arrays of functions are not meaningful
zh_TW: 函式陣列是沒有意義的

en: as %qD
zh_TW: 做為 %qD

en: asm clobber conflict with input operand
zh_TW: 組譯篡改清單與輸入運算元衝突

en: asm clobber conflict with output operand
zh_TW: 組譯篡改清單與輸出運算元衝突

en: asm declaration ignored due to conflict with previous rename
zh_TW: asm 宣告因與先前的 rename 衝突而被忽略

en: asm operand %d probably doesn%'t match constraints
zh_TW: 組譯運算元 %d 與約束可能不匹配

en: assert: %s is assign compatible with %s
zh_TW: assert：%s 與 %s 賦值相容

en: assertion missing after %qs
zh_TW: %qs 後判定語

en: assignment
zh_TW: 賦值

en: assignment (not initialization) in declaration
zh_TW: 賦值(不是初始化)出現在宣告中

en: assignment from distinct Objective-C type
zh_TW: 從獨一無二的 Objective-C 類型賦值

en: assignment from incompatible pointer type
zh_TW: 永遠不相容的指標類型賦值

en: assignment left-hand side might be a candidate for a format attribute
zh_TW: 賦值的左手邊可能是 format 屬性的備選時

en: assignment makes integer from pointer without a cast
zh_TW: 賦值時將指標賦給整數，未作類型轉換

en: assignment makes pointer from integer without a cast
zh_TW: 賦值時將整數賦給指標，未作類型轉換

en: assignment of read-only member %qD
zh_TW: 向唯讀成員 %qD 賦值

en: assignment of read-only variable %qD
zh_TW: 向唯讀變數 %qD 賦值

en: assignment suppression
zh_TW: 取消賦值

en: assuming cast to type %qT from overloaded function
zh_TW: 假定從多載函式轉換到類型 %qT

en: assuming pointer to member %qD
zh_TW: 假定是成員指標 %qD

en: assuming that the loop counter does not overflow
zh_TW: 假定循環計數不會溢出

en: assuming that the loop is not infinite
zh_TW: 假定循環有窮

en: attempt to take address of bit-field structure member %qD
zh_TW: 試圖取位元段結構成員 %qD 的位址

en: attribute declaration
zh_TW: 屬性宣告

en: attribute interrupt_handler is not compatible with -m5-compact
zh_TW: 屬性 interrupt_handler 與 -m5-compact 不相容

en: attributes after parenthesized initializer ignored
zh_TW: 括起的初始值設定後出現的屬性被忽略

en: attributes are not allowed on a function-definition
zh_TW: 函式定義中不允許有屬性

en: attributes in parameter array declarator ignored
zh_TW: 出現在參數陣列宣告中的屬性被忽略

en: aux field set for edge %s->%s
zh_TW: 為邊 %s->%s 設定 AUX 欄位

en: backend decl for module variable %s already exists
zh_TW: 模組變數 %s 的後端程式宣告已存在

en: bad PC range for debug info for local %q+D
zh_TW: 局部變數 %q+D 的呼叫資訊中 PC 範圍錯誤

en: bad address
zh_TW: 錯誤位址

en: bad address, not (reg+disp):
zh_TW: 位址錯誤，不是(reg+disp)：

en: bad address, not post_inc or pre_dec:
zh_TW: 錯誤的位址，不是 post_inc 或 pre_dec:

en: bad array initializer
zh_TW: 錯誤的陣列初始值設定

en: bad builtin fcode
zh_TW: 錯誤的內建 fcode

en: bad condition code
zh_TW: 錯誤的條件碼

en: bad format of .zip/.jar archive
zh_TW: .zip/.jar 檔案格式錯誤

en: bad insn for 'A'
zh_TW: 「A」的指令錯誤

en: bad insn in frv_print_operand, 0 case
zh_TW: frv_print_operand 中不正確誤指令，0 case

en: bad insn in frv_print_operand, bad const_double
zh_TW: frv_print_operand 中不正確誤指令，錯誤的 const_double

en: bad insn in frv_print_operand, z case
zh_TW: frv_print_operand 中不正確誤指令，z case

en: bad insn to frv_print_operand, 'F' modifier:
zh_TW: 給 frv_print_operand 錯誤的指令，「F」修飾符：

en: bad insn to frv_print_operand, 'L' modifier:
zh_TW: 給 frv_print_operand 錯誤的指令，「L」修飾符：

en: bad insn to frv_print_operand, 'M/N' modifier:
zh_TW: 給 frv_print_operand 錯誤的指令，「M/N」修飾符：

en: bad insn to frv_print_operand, 'O' modifier:
zh_TW: 給 frv_print_operand 錯誤的指令，「O」修飾符：

en: bad insn to frv_print_operand, 'e' modifier:
zh_TW: 給 frv_print_operand 錯誤的指令，「e」修飾符：

en: bad insn to frv_print_operand, 'f' modifier:
zh_TW: 給 frv_print_operand 錯誤的指令，「f」修飾符：

en: bad insn to frv_print_operand, 'g' modifier:
zh_TW: 給 frv_print_operand 錯誤的指令，「g」修飾符：

en: bad insn to frv_print_operand, P modifier:
zh_TW: 給 frv_print_operand 錯誤的指令，P 修飾符：

en: bad insn to frv_print_operand_address:
zh_TW: 給 frv_print_operand_address 錯誤的指令：

en: bad insn to frv_print_operand_memory_reference:
zh_TW: 給 frv_print_operand_memory_reference 錯誤的指令：

en: bad method signature
zh_TW: 錯誤的方法簽名

en: bad output_condmove_single operand
zh_TW: 錯誤的 output_condmove_single 運算元

en: bad output_move_double operand
zh_TW: 錯誤的 output_move_double 運算元

en: bad output_move_single operand
zh_TW: 錯誤的 output_move_single 運算元

en: bad pc in exception_table
zh_TW: 異常_表中 PC 錯誤

en: bad register
zh_TW: 錯誤的暫存器名

en: bad register to frv_print_operand_memory_reference_reg:
zh_TW: 給 frv_print_operand_memory_reference_reg 錯誤的暫存器：

en: bad shift insn:
zh_TW: 錯誤的 shift 指令

en: bad string constant
zh_TW: 錯誤的字串常數

en: bad test
zh_TW: 錯誤的測試

en: bad type in parameter debug info
zh_TW: 參數除錯資訊中類型錯誤

en: bad value %<%s%> for -mtls-size= switch
zh_TW: -mtls-size= 開關的值 %<%s%> 無效

en: bad value %qs for -mcpu switch
zh_TW: -mcpu 開關的值 %qs 錯誤

en: bad value %qs for -mfp-rounding-mode switch
zh_TW: -mfp-rounding-mode 開關的值 %qs 不正確

en: bad value %qs for -mfp-trap-mode switch
zh_TW: -mfp-trap-mode 開關的值 %qs 不正確

en: bad value %qs for -mmemory-latency
zh_TW: -mmemory-latency 開關的值 %qs 錯誤

en: bad value %qs for -mtls-size switch
zh_TW: -mtls-size 開關的值 %qs 不正確

en: bad value %qs for -mtrap-precision switch
zh_TW: -mtrap-precision 開關的值 %qs 不正確

en: bad value (%s) for -march= switch
zh_TW: -march= 所帶參數(%s)不正確

en: bad value (%s) for -mcmodel= switch
zh_TW: -mcmodel= 值(%s)不正確

en: bad value (%s) for -mtune= switch
zh_TW: -mtune= 所帶參數(%s)不正確

en: bad value constant type %d, index %d
zh_TW: 常數值錯誤，類型 %d，索引 %d

en: bad value for -mcall-%s
zh_TW: -mcall-%s 值不正確

en: bad value for -msdata=%s
zh_TW: -msdata=%s 值不正確

en: bad zip/jar file %s
zh_TW: 損壞的 zip/jar 檔案 %s

en: badly nested C headers from preprocessor
zh_TW: 前處理器產生的巢狀 C 頭 錯誤

en: base %qT will be initialized after
zh_TW: 基礎類別 %qT 將在

en: base class %q#T has a non-virtual destructor
zh_TW: 基礎類別 %q#T 有一個非虛解構函式

en: base operand of %<->%> has non-pointer type %qT
zh_TW: %<->%> 的基運算元具有非指標類型 %qT

en: base operand of %<->%> is not a pointer
zh_TW: %<->%> 的左運算元不是一個指標

en: base type %qT fails to be a struct or class type
zh_TW: 基礎類別型 %qT 不是結構或類別

en: bb %d on wrong place
zh_TW: 基本區塊 %d 位置不正確

en: bit-field %q+#D with non-integral type
zh_TW: 位元段 %q+#D 有非整數的類型

en: bit-field %q+D width not an integer constant
zh_TW: 位元段 %q+D 的寬度不是一個整數常數

en: bit-field %qs has invalid type
zh_TW: 位元段 %qs 類型無效

en: bit-field %qs width not an integer constant
zh_TW: 位元段 %qs 的寬度不是一個整數常數

en: block IF
zh_TW: 區塊 IF

en: bogus DISPOSE construction: %d
zh_TW: 誤判的 DISPOSE 建構：%d

en: bogus JR construction: %d
zh_TW: 誤判的 JR 建構：%d

en: bogus PREPEARE construction: %d
zh_TW: 誤判的 PREPEARE 建構：%d

en: boolean registers required for the floating-point option
zh_TW: 浮點選項需要布林暫存器

en: braced-group within expression allowed only inside a function
zh_TW: 運算式中的大括號組只允許出現在函式中

en: braces around scalar initializer
zh_TW: 標量初始化帶大括號

en: braces around scalar initializer for type %qT
zh_TW: 類型 %qT 的標量初始化帶大括號

en: branch %2d never executed
zh_TW: branch %2d 從未被執行

en: branch %2d taken %s%s
zh_TW: branch %2d 被執行 %s%s

en: break statement not within loop or switch
zh_TW: break 敘述不在循環或開關敘述內

en: built-in function %q+D declared as non-function
zh_TW: 內建函式 %q+D 未被宣告為函式

en: call   %2d never executed
zh_TW: call   %2d 從未被執行

en: call   %2d returned %s
zh_TW: call   %2d 回傳了 %s

en: call of %<(%T) (%A)%> is ambiguous
zh_TW: 對 %<(%T) (%A)%> 的呼叫有歧義

en: call of overloaded %<%D(%A)%> is ambiguous
zh_TW: 呼叫多載的 %<%D(%A)%> 有歧義

en: call of overloaded %<%s(%A)%> is ambiguous
zh_TW: 對多載的 %<%s(%A)%> 的呼叫有歧義

en: call to Java %<catch%> or %<throw%> with %<jthrowable%> undefined
zh_TW: 呼叫 Java %<catch%> 或 %<throw%> 時 %<jthrowable%> 未定義

en: call to Java constructor with %qs undefined
zh_TW: 呼叫 Java 建構式，但沒有定義 %qs

en: call to Java constructor, while %<jclass%> undefined
zh_TW: 呼叫 Java 建構式，但沒有定義 %<jclass%>

en: call to function %qD which throws incomplete type %q#T
zh_TW: 呼叫的函式 %qD 會拋出不完全的類型 %q#T

en: call to function which throws incomplete type %q#T
zh_TW: 呼叫的函式會拋出不完全的類型 %q#T

en: call to non-function %qD
zh_TW: 呼叫非函式的 %qD

en: call-clobbered register used for global register variable
zh_TW: 呼叫篡改暫存器做為全域暫存器變數

en: called from here
zh_TW: 從此處呼叫

en: caller edge count is negative
zh_TW: 呼叫邊計數為負

en: can not use an object as parameter to a method
zh_TW: 不能將物件做為方法的參數

en: can only use %qE attribute on file-scope definitions of objects of class type
zh_TW: 只能將 %qE 屬性用於某個類別的物件的檔案作用欄位定義

en: can%'t create precompiled header %s: %m
zh_TW: 無法建立預先編譯頭 %s：%m

en: can%'t open %s for writing: %m
zh_TW: 無法開啟 %s 並寫入：%m

en: can%'t open %s: %m
zh_TW: 無法開啟%s：%m

en: can%'t read %s: %m
zh_TW: 無法讀取 %s：%m

en: can%'t write %s: %m
zh_TW: 無法寫入 %s：%m

en: can%'t write to %s: %m
zh_TW: 無法寫入 %s：%m

en: can't get program status
zh_TW: 無法獲取程式狀態

en: can't open %s: %m
zh_TW: 無法開啟 %s：%m

en: can't open input file: %s
zh_TW: 無法開啟輸入檔案：%s

en: candidate 1:
zh_TW: 備選 1：

en: candidate 2:
zh_TW: 備選 2：

en: candidate is: %+#D
zh_TW: 備選為：%+#D

en: candidates are:
zh_TW: 備選為：

en: candidates are: %+#D
zh_TW: 備選為：%+#D

en: cannot allocate an object of abstract type %qT
zh_TW: 無法為有抽象類型 %qT 的物件指派記憶體

en: cannot bind bitfield %qE to %qT
zh_TW: 無法將位元段 %qE 繫結到 %qT

en: cannot bind packed field %qE to %qT
zh_TW: 不能將緊實的欄位 %qE 繫結到 %qT

en: cannot bind rvalue %qE to %qT
zh_TW: 無法將右值 %qE 繫結到 %qT

en: cannot call member function %qD without object
zh_TW: 沒有物件無法呼叫成員函式 %qD

en: cannot convert %qE from type %qT to type %qT
zh_TW: 無法將 %qE 從類型 %qT 轉換到類型 %qT

en: cannot convert %qT to %qT for argument %qP to %qD
zh_TW: 不能從 %qT 轉換到 %qT，為引數 %qP(屬於 %qD)

en: cannot convert from base %qT to derived type %qT via virtual base %qT
zh_TW: 無法從基礎類別 %qT 轉換到衍生類別 %qT，透過虛基礎類別 %qT

en: cannot convert to a pointer type
zh_TW: 無法轉換為指標類型

en: cannot convert type %qT to type %qT
zh_TW: 不能將類型 %qT 轉換為類型 %qT

en: cannot create pointer to reference member %qD
zh_TW: 不能建立參照參照成員 %qD 的指標

en: cannot create temporary file
zh_TW: 無法建立暫時檔案

en: cannot declare %<::main%> to be a template
zh_TW: 不能將 %<::main%> 宣告為一個範本

en: cannot declare %<::main%> to be inline
zh_TW: 不能將 %<::main%> 宣告為 inline

en: cannot declare %<::main%> to be static
zh_TW: 不能將 %<::main%> 宣告為 static

en: cannot declare %qD to be a bit-field type
zh_TW: 不能將 %qD 宣告為位元段類型

en: cannot declare bit-field %qD with function type
zh_TW: 不能將位元段 %qD 宣告為函式類型

en: cannot declare field %q+D to be of abstract type %qT
zh_TW: 不能將欄位 %q+D 宣告為具有抽象類型 %qT

en: cannot declare member %<%T::%s%> within %qT
zh_TW: 無法宣告成員 %<%T::%s%> 於 %qT 之內

en: cannot declare member function %<%T::%s%> within %<%T%>
zh_TW: 無法宣告成員函式 %<%T::%s%> 於 %<%T%> 之內

en: cannot declare member function %qD to have static linkage
zh_TW: 不能將成員函式 %qD 宣告為有靜態連結

en: cannot declare parameter %q+D to be of abstract type %qT
zh_TW: 不能將參數 %q+D 宣告為具有抽象類型 %qT

en: cannot declare pointer to %q#T
zh_TW: 無法宣告參照 %q#T 的指標

en: cannot declare pointer to %q#T member
zh_TW: 無法宣告參照 %q#T 成員的指標

en: cannot declare reference to %q#T
zh_TW: 無法宣告對 %q#T 的參照

en: cannot declare static function inside another function
zh_TW: 不能在另一個函式中宣告一個靜態函式

en: cannot declare variable %q+D to be of abstract type %qT
zh_TW: 不能將變數 %q+D 宣告為具有抽象類型 %qT

en: cannot decompose address
zh_TW: 無法分解位址

en: cannot define member function %<%T::%s%> within %<%T%>
zh_TW: 無法定義成員函式 %<%T::%s%> 於 %<%T%> 之內

en: cannot delete a function.  Only pointer-to-objects are valid arguments to %<delete%>
zh_TW: 不能 delete 一個函式。只有參照物件的指標才是 %<delete%> 的有效參數

en: cannot disable built-in function %qs
zh_TW: 無法停用內建函式 %qs

en: cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)
zh_TW: 無法將 %qE 從類型 %qT 動態_轉換到類型 %q#T (%s)

en: cannot explicitly declare member %q#D to have extern linkage
zh_TW: 不能明確地將成員 %q#D 宣告為有外部連結

en: cannot find '%s'
zh_TW: 找不到「%s」

en: cannot find 'ldd'
zh_TW: 找不到「ldd」

en: cannot find 'nm'
zh_TW: 找不到 「nm」

en: cannot find file for class %s
zh_TW: 無法為類別 %s 找到檔案

en: cannot handle inconsistent calls to %qs
zh_TW: 無法處理對 %qs 不一致的呼叫

en: cannot initialize aggregate of type %qT with a compound literal
zh_TW: 不可使用複合原文初始化類型為 %qT 的聚集

en: cannot initialize arrays using this syntax
zh_TW: 不能用以語法初始化陣列

en: cannot initialize multi-dimensional array with initializer
zh_TW: 不能用初始值設定項來初始化多維陣列

en: cannot inline function %<main%>
zh_TW: 不能內聯 %<main%> 函式

en: cannot open %s
zh_TW: 無法開啟 %s

en: cannot optimize loop, the loop counter may overflow
zh_TW: 無法最佳化循環，循環變數可能溢出

en: cannot optimize possibly infinite loops
zh_TW: 無法最佳化可能無窮的循環

en: cannot pass argument in vector register because altivec instructions are disabled, use -maltivec to enable them
zh_TW: 不能在向量暫存器中傳遞參數，因為 altivec 指令集已被停用，使用 -maltivec 啟用

en: cannot pass rvalue to reference parameter
zh_TW: 不能將右值傳遞給參照參數

en: cannot put object with volatile field into register
zh_TW: 不能將帶有 volatile 欄位的物件放入暫存器

en: cannot reload integer constant operand in %<asm%>
zh_TW: 不能在 %<asm%> 中重新載入整數常數運算元

en: cannot resolve overloaded function %qD based on conversion to type %qT
zh_TW: 無法解析多載函式 %qD，基於向類型 %qT 的轉換

en: cannot return from a handler of a function-try-block of a constructor
zh_TW: 不能從建構式的異常處理中回傳

en: cannot return value in vector register because altivec instructions are disabled, use -maltivec to enable them
zh_TW: 不能在向量暫存器中回傳值，因為 altivec 指令集已被停用，使用 -maltivec 啟用

en: cannot set interrupt attribute: no current function
zh_TW: 無法設定插斷屬性：沒有目前函式

en: cannot set interrupt attribute: no such identifier
zh_TW: 無法設定插斷屬性：沒有這個識別碼

en: cannot specify both -C and -o
zh_TW: 不能同時指定 -C 和 -o

en: cannot specify both -msep-data and -mid-shared-library
zh_TW: 不能同時指定 -msep-data 和 -mid-shared-library

en: cannot take address of bit-field %qD
zh_TW: 無法取得位元段 %qD 的位址

en: cannot take the address of %<this%>, which is an rvalue expression
zh_TW: 無法取右值運算式 %<this%> 的位址

en: cannot use %<::%> in parameter declaration
zh_TW: 不能在參數宣告中使用 %<::%>

en: cannot use mode %qs for enumeral types
zh_TW: 無法為列舉類型使用模式 %qs

en: cannot use mshared and static together
zh_TW: 不能同時使用 mshared 和 static

en: cannot use mthreads and mlegacy-threads together
zh_TW: 不能同時使用 mthreads 和 mlegacy-threads

en: cannot use typeid with -fno-rtti
zh_TW: 在指定 -fno-rtti 的情況下不能使用 typeid

en: cannot use va_start in interrupt function
zh_TW: 不能為插斷函式使用 va_start

en: case label %qE not within a switch statement
zh_TW: case 標籤 %qE 未出現在 switch 敘述中

en: case label does not reduce to an integer constant
zh_TW: case 標籤不能還原為一個整常數

en: case label not within a switch statement
zh_TW: case 標籤出現在開關敘述外

en: case label value exceeds maximum value for type
zh_TW: case 標籤值比該類型的最大值還要大

en: case label value is less than minimum value for type
zh_TW: case 標籤值比該類型的最小值還要小

en: cast from %qT to %qT increases required alignment of target type
zh_TW: 從 %qT 到 %qT 的轉換增大了目的類型的對齊需求

en: cast from %qT to %qT loses precision
zh_TW: 從 %qT 到 %qT 的轉換損失精度

en: cast from function call of type %qT to non-matching type %qT
zh_TW: 從類型為 %qT 的函式呼叫轉換到不匹配的類型 %qT

en: cast from pointer to integer of different size
zh_TW: 當將一個指標轉換為大小不同的整數時給出警告

en: cast increases required alignment of target type
zh_TW: 類型轉換增大了目的類型的對齊需求

en: cast specifies array type
zh_TW: 類型轉換指定了陣列類型

en: cast specifies function type
zh_TW: 類型轉換指定了函式類型

en: cast to pointer from integer of different size
zh_TW: 當將一個指標轉換為大小不同的整數時給出警告

en: cast to union type from type not present in union
zh_TW: 類型轉換的來源類型未出現在聯合中

en: casting %qT to %qT does not dereference pointer
zh_TW: 從 %qT 轉換到 %qT 並未提領指標

en: changes meaning of %qD from %q+#D
zh_TW: 變更了 %qD 的原意 %q+#D

en: char-array initialized from wide string
zh_TW: 用寬字串初始化 char 陣列

en: choosing %qD over %qD
zh_TW: 選擇 %qD 而不是 %qD

en: circular pointer delegation detected
zh_TW: 偵測到循環指標代理

en: class %qT does not have any field named %qD
zh_TW: 類別 %qT 沒具名為 %qD 的欄位

en: class %qT is implicitly friends with itself
zh_TW: 類別 %qT 隱含地成為其自身的夥伴

en: class %qT will be considered nearly empty in a future version of GCC
zh_TW: 在 GCC 的未來版本中類別 %qT 將被看作幾乎為空

en: class '%s' has no method named '%s' matching signature '%s'
zh_TW: 類別「%s」沒具名為「%s」的方法能夠匹配簽字「%s」

en: class definition may not be declared a friend
zh_TW: 類別定義不能被宣告為夥伴

en: cleanup argument not a function
zh_TW: cleanup 引數不是一個函式

en: cleanup argument not an identifier
zh_TW: cleanup 引數不是一個識別碼

en: closing dependency file %s: %m
zh_TW: 關閉依賴檔案 %s：%m

en: code model %qs not supported in the %s bit mode
zh_TW: 程式碼模式 %qs 在 %s 位模式下不受支援

en: collect: reading %s
zh_TW: collect：讀入 %s

en: collect: recompiling %s
zh_TW: collect：重新編譯 %s

en: collect: relinking
zh_TW: collect：重新連結

en: collect: tweaking %s in %s
zh_TW: collect：調整 %s，於 %s

en: comma at end of enumerator list
zh_TW: 列舉表以逗號結尾

en: command line option %qs is not supported by this configuration
zh_TW: 此配置不支援命令列選項 %qs

en: comparing floating point with == or != is unsafe
zh_TW: 使用 == 或 != 比較浮點數是不安全的

en: comparison between %q#T and %q#T
zh_TW: 在 %q#T 和 %q#T 間比較

en: comparison between pointer and integer
zh_TW: 比較指標和整數

en: comparison between signed and unsigned integer expressions
zh_TW: 在有號和無號整數運算式間比較

en: comparison is always %d
zh_TW: 比較結果始終為 %d

en: comparison is always %d due to width of bit-field
zh_TW: 由於位元段寬度所限，比較結果永遠為 %d

en: comparison is always false due to limited range of data type
zh_TW: 由於資料類型範圍限制，比較結果永遠為假

en: comparison is always true due to limited range of data type
zh_TW: 由於資料類型範圍限制，比較結果永遠為真

en: comparison of complete and incomplete pointers
zh_TW: 在完全和不完全指標間比較

en: comparison of distinct Objective-C types lacks a cast
zh_TW: 比較獨一無二的 Objective-C 類型時缺少轉換

en: comparison of distinct pointer types lacks a cast
zh_TW: 比較不相關的指標時缺少類型轉換

en: comparison of promoted ~unsigned with constant
zh_TW: 比較常數和取反後又經提升的無號數

en: comparison of promoted ~unsigned with unsigned
zh_TW: 比較無號數和取反後又經提升的無號數

en: comparison of unsigned expression < 0 is always false
zh_TW: 無號運算式永遠不小於 0

en: comparison of unsigned expression >= 0 is always true
zh_TW: 無號運算式永遠大於或等於 0

en: compilation terminated due to -Wfatal-errors.
zh_TW: 編譯因為 -Wfatal-errors 而中止。

en: compilation terminated.
zh_TW: 編譯插斷。

en: complex invalid for %qs
zh_TW: 對 %qs 而言無效的複數

en: compound literal has variable size
zh_TW: 複合字面值有可變的大小

en: conflicting access specifications for field %qE, ignored
zh_TW: 欄位 %qE 的權限設定衝突，已忽略

en: conflicting access specifications for method %q+D, ignored
zh_TW: 方法 %q+D 的權限設定衝突，已忽略

en: conflicting declaration %q#D
zh_TW: 相互衝突的宣告 %q#D

en: conflicting return type specified for %q+#D
zh_TW: 為 %q+#D 指定了衝突的回傳類型

en: conflicting type qualifiers for %q+D
zh_TW: %q+D 的類型限定衝突

en: conflicting types for %q+D
zh_TW: 與 %q+D 類型衝突

en: conflicting types for built-in function %q+D
zh_TW: 與內建函式 %q+D 類型衝突

en: conflicts with built-in declaration %q#D
zh_TW: 與內建宣告 %q#D 衝突

en: conflicts with function declaration %q#D
zh_TW: 與函式宣告 %q#D 衝突

en: conflicts with new declaration with %qL linkage
zh_TW: 與帶有 %qL 連結的新宣告衝突

en: conflicts with previous declaration %q+#D
zh_TW: 與先前的宣告 %q+#D 衝突

en: const %qs cannot be declared %<mutable%>
zh_TW: 常數 %qs 不能被宣告為 %<mutable%>

en: const_double_split got a bad insn:
zh_TW: const_double_split 得到一個錯誤的指令：

en: constant argument out of range for %qs
zh_TW: 常數引數超過 %qs 的範圍

en: constructor cannot be static member function
zh_TW: 建構式不能是靜態成員函式

en: constructor for alien class %qT cannot be a member
zh_TW: 其它類別 %qT 的建構式不能做為成員

en: constructor syntax used, but no constructor declared for type %qT
zh_TW: 使用了建構式的語法，但沒有為類型 %qT 宣告建構式

en: constructors cannot be declared virtual
zh_TW: 建構式不能被宣告為虛函式

en: constructors may not be cv-qualified
zh_TW: 建構式不能帶 cv 限定

en: continue statement not within a loop
zh_TW: continue 敘述出現在循環以外

en: control flow in the middle of basic block %d
zh_TW: 基本區塊 %d 中出現流程控制

en: conversion from %q#T to %q#T
zh_TW: 從 %q#T 到 %q#T 的轉換

en: conversion from %qT to %qT discards qualifiers
zh_TW: 從 %qT 到 %qT 的轉換丟失了限定資訊

en: conversion from %qT to %qT is ambiguous
zh_TW: 從 %qT 到 %qT 的轉換有歧義

en: conversion from %qT to non-scalar type %qT requested
zh_TW: 請求從 %qT 轉換到非標量類型 %qT

en: conversion lacks type at end of format
zh_TW: 格式字串末尾的轉換缺少類型

en: conversion of %qE from %qT to %qT is ambiguous
zh_TW: 將 %qE 從 %qT 轉換到 %qT 有歧義

en: conversion to incomplete type
zh_TW: 轉換為不完全類型

en: conversion to non-scalar type requested
zh_TW: 請求轉換到非標量類型

en: converting NULL to non-pointer type
zh_TW: 將 NULL 轉換為非指標類型

en: converting from %qT to %qT
zh_TW: 從 %qT 轉換到 %qT

en: converting overloaded function %qD to type %q#T is ambiguous
zh_TW: 將多載函式 %qD 轉換為類型 %q#T 有歧義

en: converting to non-pointer type %qT from NULL
zh_TW: 將 NULL 轉換到非指標類型 %qT

en: corrupted profile info: edge from %i to %i exceeds maximal count
zh_TW: 損壞的樣本資訊：從 %i 到 %i 的邊超過最大計數

en: corrupted profile info: number of executions for edge %d-%d thought to be %i
zh_TW: 損壞的樣本資訊：邊 %d-%d 的執行次數被認為是 %i

en: corrupted profile info: number of iterations for basic block %d thought to be %i
zh_TW: 損壞的樣本資訊：基本區塊 %d 的迭代次數被認為是 %i

en: corrupted profile info: run_max * runs < sum_max
zh_TW: 損壞的樣本資訊：run_max * runs < sum_max

en: corrupted profile info: sum_all is smaller than sum_max
zh_TW: 損壞的樣本資訊：sum_all 小於 sum_max

en: could not convert template argument %qE to %qT
zh_TW: 不能將範本參數從 %qE 轉換到 %qT

en: could not find a spill register
zh_TW: 找不到可捨出的暫存器

en: could not find class$ field in java interface type %qT
zh_TW: 在 java 介面類型 %qT 中找不到 class$ 欄位

en: could not find specs file %s
zh_TW: 找不到 specs 檔案 %s

en: could not split insn
zh_TW: 無法分離指令

en: created and used with different ABIs
zh_TW: 建立和使用時使用了不同的 ABI

en: created and used with different architectures / ABIs
zh_TW: 建立和使用時使用了不同的架構/ABI

en: created and used with different endianness
zh_TW: 建立和使用時使用了不同的高/低位位元組在前設定

en: created and used with different settings of -fpic
zh_TW: 建立和使用時使用了不同的 -fpic 設定

en: created and used with different settings of -fpie
zh_TW: 建立和使用時使用了不同的 -fpie 設定

en: created and used with differing settings of '%s'
zh_TW: 建立和使用時使用了不同的「%s」設定

en: creating array of %qT
zh_TW: 產生 %qT 的陣列

en: creating array of %qT, which is an abstract class type
zh_TW: 產生抽象類型 %qT 的陣列

en: creating pointer to member function of non-class type %qT
zh_TW: 產生非類別類型 %qT 的成員函式指標

en: creating pointer to member of non-class type %qT
zh_TW: 產生非類別類型 %qT 的成員指標

en: creating pointer to member of type void
zh_TW: 建立參照 void 類型的成員指標

en: creating pointer to member reference type %qT
zh_TW: 產生參照類型 %qT 的成員指標

en: data area of %q+D conflicts with previous declaration
zh_TW: %q+D 的資料區域與先前的宣告衝突

en: data declaration
zh_TW: 資料宣告

en: data definition has no type or storage class
zh_TW: 資料定義時沒有類型或存儲類別

en: data member %qD cannot be a member template
zh_TW: 資料成員 %qD 不能是成員範本

en: data member may not have variably modified type %qT
zh_TW: 資料成員不能具有可變類型 %qT

en: data type of %q+D isn%'t suitable for a register
zh_TW: 為 %q+D 指定的暫存器不適合此資料類型

en: debug format "%s" conflicts with prior selection
zh_TW: 除錯格式「%s」與先前的選擇衝突

en: debug output level %s is too high
zh_TW: 除錯輸出層級 %s 太高

en: debug:
zh_TW: 除錯：

en: declaration does not declare anything
zh_TW: 沒有宣告任何東西

en: declaration of %<~%T%> as member of %qT
zh_TW: %<~%T%> 宣告為 %qT 的一個成員

en: declaration of %q#D
zh_TW: %q#D 的宣告

en: declaration of %q#D has %<extern%> and is initialized
zh_TW: %q#D 宣告有 %<extern%> 並被初始化

en: declaration of %q#D outside of class is not definition
zh_TW: 出現在類別外的 %q#D 的宣告不是定義

en: declaration of %q#D shadows a parameter
zh_TW: %q#D 的宣告隱藏了一個參數

en: declaration of %q+#D
zh_TW: %q+#D 的宣告

en: declaration of %q+D shadows a built-in function
zh_TW: %q+D 的宣告隱藏了一個內建函式

en: declaration of %q+D shadows a parameter
zh_TW: %q+D 的宣告隱藏了一個參數

en: declaration of %q+D shadows a previous local
zh_TW: %q+D 的宣告隱藏了先前的一個局部變數

en: declaration of %q+D shadows previous non-variable
zh_TW: %q+D 的宣告隱藏了先前的一個非變數宣告

en: declaration of %q+D with attribute noinline follows inline declaration
zh_TW: %q+D 帶有 noinline 屬性的宣告出現在其內聯宣告之後

en: declaration of %q+D with no linkage follows extern declaration
zh_TW: %q+D 宣告為沒有外部連結的，之前卻有外部宣告

en: declaration of %qD as member of %qT
zh_TW: %qD 宣告為 %qT 的一個成員

en: declaration of %qD as multidimensional array must have bounds for all dimensions except the first
zh_TW: 多維陣列 %qD 的宣告必須至少指定除第一維以外所有維的大小

en: declaration of %qD as non-function
zh_TW: %qD 沒有宣告為一個函式

en: declaration of %qD as non-member
zh_TW: %qD 未宣告為成員

en: declaration of %qD in %qD which does not enclose %qD
zh_TW: %qD 宣告出現在 %qD 中，而後者並不包含 %qD

en: declaration of %qD not in a namespace surrounding %qD
zh_TW: %qD 的宣告不在包含 %qD 的命名空間中

en: declaration of %qD shadows a global declaration
zh_TW: %qD 的宣告隱藏了一個全域宣告

en: declaration of %qD shadows a member of 'this'
zh_TW: %qD 的宣告隱藏了「this」的一個成員

en: declaration of %qD shadows a previous local
zh_TW: %qD 的宣告隱藏了先前的一個局部變數

en: declaration of C function %q#D conflicts with
zh_TW: C 函式 %q#D 的宣告

en: declaration of namespace %qD conflicts with
zh_TW: 命名空間 %qD 的宣告存在衝突，與

en: declaration of template %q#D
zh_TW: 範本宣告 %q#D

en: declarator-id missing; using reserved word %qD
zh_TW: 缺少宣告識別碼：使用了保留字 %qD

en: decrement of pointer to unknown structure
zh_TW: 自減參照不明結構的指標

en: decrement of read-only member %qD
zh_TW: 令唯讀成員 %qD 自減

en: decrement of read-only variable %qD
zh_TW: 令唯讀成員 %qD 自增

en: default argument %qE uses local variable %qD
zh_TW: 預設引數 %qE 使用了局部變數 %qD

en: default argument given for parameter %d of %q#D
zh_TW: 為參數 %d (屬於 %q#D)指定了預設引數

en: default argument missing for parameter %P of %q+#D
zh_TW: 參數 %P (屬於 %q+#D)缺少預設引數

en: default argument specified in explicit specialization
zh_TW: 明確特例化時指定了預設參數

en: default arguments are not allowed in declaration of friend template specialization %qD
zh_TW: 夥伴範本特例化 %qD 中不允許出現預設參數

en: default arguments are only permitted for function parameters
zh_TW: 預設參數只允許出現在函式參數中

en: defining explicit specialization %qD in friend declaration
zh_TW: 在夥伴宣告中定義明確特例化 %qD

en: definition of %q#T inside template parameter list
zh_TW: 在範本參數清單中定義了 %q#T

en: definition of %qD is not in namespace enclosing %qT
zh_TW: %qD 的定義不在包含 %qT 的命名空間中

en: definition of implicitly-declared %qD
zh_TW: 隱含宣告的 %qD 的定義

en: definition provided for explicit instantiation
zh_TW: 為明確實體化提供的定義

en: deleting %qT is undefined
zh_TW: 刪除 %qT 未定義

en: dependent-name %qE is parsed as a non-type, but instantiation yields a type
zh_TW: 依賴名 %qE 被解析為非類型，但實體化卻產生了一個類型

en: deprecated covariant return type for %q+#D
zh_TW: %q+#D 的協變回傳類型已過時

en: deprecated use of default argument for parameter of non-function
zh_TW: 為非函式指定預設參數的用法已過時

en: dereferencing %<void *%> pointer
zh_TW: 提領 %<void *%> 指標

en: dereferencing pointer to incomplete type
zh_TW: 提領參照不完全類型的指標

en: dereferencing type-punned pointer might break strict-aliasing rules
zh_TW: 提領類型雙關的指標可能破壞強重疊規則

en: dereferencing type-punned pointer will break strict-aliasing rules
zh_TW: 提領類型雙關的指標將破壞強重疊規則

en: derived type declaration
zh_TW: 衍生的類型宣告

en: derived union %qT invalid
zh_TW: 衍生聯合 %qT 無效

en: destructor %qD declared as member template
zh_TW: 解構函式 %qD 被宣告為一個成員範本

en: destructor cannot be static member function
zh_TW: 解構函式不能是靜態成員函式

en: destructor for alien class %qT cannot be a member
zh_TW: 其它類別 %qT 的解構函式不能做為成員

en: destructors may not be cv-qualified
zh_TW: 解構函式不能被 cv 限定

en: destructors may not have parameters
zh_TW: 解構函式不能有參數

en: direct base %qT inaccessible in %qT due to ambiguity
zh_TW: 由於存在歧義，直接基礎類別 %qT 在 %qT 中無法存取

en: distinct Objective-C type in return
zh_TW: 回傳獨一無二的 Objective-C 類型

en: division by zero
zh_TW: 被零除

en: does not support multilib
zh_TW: 不支援 multilib

en: dominator of %d should be %d, not %d
zh_TW: %d 的主導者應該為 %d，而不是 %d

en: dominator of %d status unknown
zh_TW: %d 的主導者狀態不明

en: duplicate %<const%>
zh_TW: 重複的 %<const%>

en: duplicate %<restrict%>
zh_TW: 重複的 %<restrict%>

en: duplicate %<volatile%>
zh_TW: 重複的 %<volatile%>

en: duplicate %qE
zh_TW: 重複的 %qE

en: duplicate %qs
zh_TW: 重複的 %qs

en: duplicate (or overlapping) case value
zh_TW: 重複 (或重疊) 的 case 值

en: duplicate ConstantValue attribute for field '%s'
zh_TW: 為欄位「%s」重複指定了 ConstantValue 屬性

en: duplicate asm operand name %qs
zh_TW: 重複的組譯運算元名 %qs

en: duplicate base type %qT invalid
zh_TW: 重複的基礎類別型 %qT 無效

en: duplicate case value
zh_TW: 重複的 case 常數

en: duplicate cv-qualifier
zh_TW: 重複的 cv 限定

en: duplicate explicit instantiation of %q#D
zh_TW: 對 %q#D 重複的明確實體化

en: duplicate explicit instantiation of %q#T
zh_TW: 對 %q#T 重複的明確實體化

en: duplicate initialization of %qD
zh_TW: ISO C++ 不允許成員 %qD 的初始化

en: duplicate label %qD
zh_TW: 重複的標籤 %qD

en: duplicate label declaration %qE
zh_TW: 重複的標籤定義 %qE

en: duplicate member %q+D
zh_TW: 重複的成員 %q+D

en: dynamic dependency %s not found
zh_TW: 找不到動態依賴項 %s

en: dynamic_cast of %q#D to %q#T can never succeed
zh_TW: 從 %q#D 到 %q#T 的動態_轉換永遠不會成功

en: edge points to wrong declaration:
zh_TW: 邊緣指到不對的宣告：

en: elements of array %q#D have incomplete type
zh_TW: 陣列 %q#D 的元素類型不完全

en: embedded %<\0%> in format
zh_TW: 格式字串嵌有 %<\0%>

en: empty declaration
zh_TW: 空宣告

en: empty declaration with storage class specifier does not redeclare tag
zh_TW: 帶有存儲類別的空宣告沒有重宣告標記

en: empty declaration with type qualifier does not redeclare tag
zh_TW: 帶有類型限定的空宣告沒有重宣告標記

en: empty index range in initializer
zh_TW: 初始值設定項中索引範圍為空

en: empty left precision in %s format
zh_TW: %s 格式字串中左精度為空

en: empty precision in %s format
zh_TW: %s 格式字串中精度為空

en: empty range specified
zh_TW: 指定範圍為空

en: empty scalar initializer
zh_TW: 空的標量初始值設定項

en: enclosing class templates are not explicitly specialized
zh_TW: 所包含的類別範本並未被明確特例化

en: enumeral and non-enumeral type in conditional expression
zh_TW: 列舉和非列舉類型一起出現在條件運算式中

en: enumeral mismatch in conditional expression: %qT vs %qT
zh_TW: 條件運算式中列舉不匹配：%qT 對 %qT

en: enumeration values exceed range of largest integer
zh_TW: 列舉值超過了最大整數類型可表示的範圍

en: enumerator value for %qE is not an integer constant
zh_TW: %qE 的列舉值不是一個整數常數

en: environment variable DJGPP not defined
zh_TW: 沒有定義 DJGPP 環境變數

en: environment variable DJGPP points to corrupt file '%s'
zh_TW: 環境變數 DJGPP 參照的檔案「%s」已損壞

en: environment variable DJGPP points to missing file '%s'
zh_TW: 環境變數 DJGPP 參照的檔案「%s」不存在

en: error closing %s: %m
zh_TW: 關閉 %s 時發生錯誤：%m

en: error in constant pool entry #%d
zh_TW: 常數池條目 #%d 發生錯誤

en: error while parsing constant pool
zh_TW: 解析常數池時發生錯誤

en: error while parsing constant pool
zh_TW: 解析常數池時發生錯誤

en: error while parsing fields
zh_TW: 解析欄位時發生錯誤

en: error while parsing fields
zh_TW: 解析欄位時發生錯誤

en: error while parsing final attributes
zh_TW: 解析 final 屬性時發生錯誤

en: error while parsing final attributes
zh_TW: 解析 final 屬性時發生錯誤

en: error while parsing methods
zh_TW: 解析方法時發生錯誤

en: error while parsing methods
zh_TW: 解析方法時發生錯誤

en: error while reading %s from zip file
zh_TW: 從 zip 檔案讀取 %s 時發生錯誤

en: error writing %qs
zh_TW: 寫入 %qs 時錯誤

en: error writing to %s: %m
zh_TW: 寫入 %s 時發生錯誤：%m

en: error:
zh_TW: 錯誤：

en: exception of type %<%T%> will be caught
zh_TW: 類型為 %<%T%> 的異常將被獲取

en: excess elements in array initializer
zh_TW: 陣列初始值設定項中有多餘的元素

en: excess elements in char array initializer
zh_TW: 字元陣列初始值設定項中有多餘元素

en: excess elements in scalar initializer
zh_TW: 標量初始值設定項中有多餘元素

en: excess elements in struct initializer
zh_TW: 結構初始值設定項中有多餘元素

en: excess elements in union initializer
zh_TW: 聯合初始值設定項中有多餘元素

en: excess elements in vector initializer
zh_TW: 向量初始值設定項中有多餘元素

en: expected %<,%> or %<;%>
zh_TW: 需要 %<,%> 或 %<;%>

en: expected %<,%> or %<}%>
zh_TW: 需要 %<,%> 或 %<}%>

en: expected %<,%>, %<;%> or %<}%>
zh_TW: 需要 %<,%>、%<;%> 或 %<}%>

en: expected %<:%> or %<...%>
zh_TW: 需要 %<:%> 或 %<...%>

en: expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%>
zh_TW: 需要 %<:%>，%<,%>，%<;%>，%<}%> 或 %<__attribute__%>

en: expected %<;%>
zh_TW: 需要 %<;%>

en: expected %<=%>
zh_TW: 需要 %<=%>

en: expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>
zh_TW: 需要 %<=%>，%<,%>，%<;%>，%<asm%> 或 %<__attribute__%>

en: expected %<{%>
zh_TW: 需要 %<{%>

en: expected %d levels of template parms for %q#D, got %d
zh_TW: 需要 %d 級的 %q#D 範本參數，卻給出了 %d 級

en: expected an SSA_NAME object
zh_TW: 需要一個 SSA_NAME 物件

en: expected class name
zh_TW: 需要類別名

en: expected declaration or statement
zh_TW: 需要宣告或敘述

en: expected declaration specifiers
zh_TW: 需要指定宣告

en: expected declaration specifiers or %<...%>
zh_TW: 需要指定宣告或 %<...%>

en: expected expression
zh_TW: 需要運算式

en: expected identifier
zh_TW: 需要識別碼

en: expected identifier or %<(%>
zh_TW: 需要識別碼或 %<(%>

en: expected identifier or %<*%>
zh_TW: 需要識別碼或 %<*%>

en: expected qualified name in friend declaration for destructor %qD
zh_TW: 在解構函式 %qD 中的夥伴宣告需要限定名

en: expected specifier-qualifier-list
zh_TW: 需要指定符-限制符清單

en: expected statement
zh_TW: 需要敘述

en: expected string literal
zh_TW: 需要字面字串

en: explicit goto at end of bb %d
zh_TW: 基本區塊 %d 末尾明確的 goto

en: explicit instantiation of %q#D
zh_TW: 對 %q#D 的明確實體化

en: explicit instantiation of %q#T before definition of template
zh_TW: %q#T 的明確實體化出現在範本定義之前

en: explicit instantiation of %qD but no definition available
zh_TW: 明確實體化 %qD 時沒有可用的定義

en: explicit instantiation of %qD in namespace %qD (which does not enclose namespace %qD)
zh_TW: %qD 的明確實體化出現在命名空間 %qD 中，而後者並不包含命名空間 %qD

en: explicit instantiation of non-template %q#D
zh_TW: 對非範本 %q#D 的明確實體化

en: explicit instantiation of non-template type %qT
zh_TW: 明確實體化非範本類型 %qT

en: explicit qualification in declaration of %qD
zh_TW: %qD 的宣告中有明確的限定

en: explicit specialization in non-namespace scope %qD
zh_TW: 明確特例化出現在非命名空間作用欄位 %qD 中

en: explicit specialization of %qD after first use
zh_TW: 在初次使用後明確特例化 %qD

en: explicit specialization of %qD must be introduced by %<template <>%>
zh_TW: %qD 的明確特例化必須由 %<template <>%> 引入

en: explicit specialization of non-template %qT
zh_TW: 明確特例化非範本 %qT

en: expression %qE of abstract class type %qT cannot be used in throw-expression
zh_TW: 運算式 %qE 具有抽象類別類型 %qT，不能用於 throw 運算式中

en: expression in new-declarator must have integral or enumeration type
zh_TW: new 宣告中的運算式必須具有整數或列舉類型

en: expression statement has incomplete type
zh_TW: 運算式敘述類型不完全

en: extended registers have no high halves
zh_TW: 擴充的暫存器沒有高半部分

en: extern declaration of %q+D follows declaration with no linkage
zh_TW: %q+D 宣告為沒有外部連結的，之前卻有外部宣告

en: extra %<;%>
zh_TW: 多餘的 %<;%>

en: extra brace group at end of initializer
zh_TW: 初始值設定項末尾有多餘的大括號組

en: extra elements in scalar initializer
zh_TW: 標量初始化設定中有多餘元素

en: extra outgoing edge %d->%d
zh_TW: 多餘的出邊 %d->%d

en: extra qualification %<%T::%> on member %qs
zh_TW: 有多餘的限定 %<%T::%> 於成員 %qs 上

en: extra semicolon in method definition specified
zh_TW: 為方法定義指定了多餘的分號

en: extra semicolon in struct or union specified
zh_TW: 為結合或結構指定了多餘的分號

en: extra type qualifiers in format argument (argument %d)
zh_TW: 格式字串引數 %d 有多餘的類型限定

en: failed to find class '%s'
zh_TW: 找不到類別「%s」

en: failed to reclaim unneeded function
zh_TW: 無法收回不需要的函式

en: fastcall and cdecl attributes are not compatible
zh_TW: fastcall 和 cdecl 屬性互不相容

en: fastcall and regparm attributes are not compatible
zh_TW: fastcall 和 regparm 屬性互不相容

en: fastcall and stdcall attributes are not compatible
zh_TW: fastcall 和 stdcall 屬性互不相容

en: fatal error:
zh_TW: 嚴重錯誤：

en: field %q+#D with same name as class
zh_TW: 欄位 %q+#D 與類別同名

en: field %q+D invalidly declared function type
zh_TW: 欄位 %q+D 無效地宣告為函式類型

en: field %q+D invalidly declared method type
zh_TW: 欄位 %q+D 無效地宣告為方法類型

en: field %qD has incomplete type
zh_TW: 欄位 %qD 類型不完全

en: field %qs not found
zh_TW: 找不到欄位 %qs。

en: field initializer is not constant
zh_TW: 欄位初始值設定不是一個常數

en: field name not in record or union initializer
zh_TW: 欄位名不在記錄或聯合初始化設定中

en: field width
zh_TW: 欄位寬

en: field width in printf format
zh_TW: printf 格式的欄位寬度

en: field width in scanf format
zh_TW: scanf 格式的欄位寬

en: field width in strfmon format
zh_TW: strfmon 格式的欄位寬度

en: field width in strftime format
zh_TW: strftime 格式的欄位寬度

en: file ends in default argument
zh_TW: 檔案在預設參數處結束

en: fill character
zh_TW: 填充字元

en: fill character in strfmon format
zh_TW: strfmon 格式的填充字元

en: find_enum(): Enum not found
zh_TW: find_enum()：找不到列舉

en: fini function found in object %s
zh_TW: 在物件 %s 中發現 fini 函式

en: first argument of %q+D should be %<int%>
zh_TW: %q+D 的第一個參數的類型應該是 %<int%>

en: first argument to %<__builtin_choose_expr%> not a constant
zh_TW: %<__builtin_choose_expr%> 的第一個引數不是一個常數

en: first argument to %<va_arg%> not of type %<va_list%>
zh_TW: 給 %<va_arg%> 的第一個參數的類型不是 %<va_list%>

en: floating constant misused
zh_TW: 錯誤地使用了浮點常數

en: floating point constant not a valid immediate operand
zh_TW: 浮點常數不是一個有效的立即數值運算元

en: floating point overflow in expression
zh_TW: 運算式中浮點溢出

en: flow control insn inside a basic block
zh_TW: 基本區塊內有流程控制指令

en: for template declaration %q+D
zh_TW: 對於範本宣告 %q+D

en: format argument %d unused before used argument %d in $-style format
zh_TW: 格式引數 %d 在被使用的 $ 風格的格式引數 %d 前未被使用

en: format argument %d used more than once in %s format
zh_TW: 格式引數 %d 在 %s 格式字串中使用不止一次

en: format is a wide character string
zh_TW: 格式字串是一個寬字串

en: format not a string literal and no format arguments
zh_TW: 格式字串不是一個字面字串而且沒有待格式化的引數

en: format not a string literal, argument types not checked
zh_TW: 格式字串不是一個字面字串，沒有進行引數類型檢查

en: format not a string literal, format string not checked
zh_TW: 格式字串不是一個字面字串，格式字串未被檢查

en: format string argument follows the args to be formatted
zh_TW: 格式字串出現在待格式化的引數之後

en: format string has invalid operand number
zh_TW: 格式字串的運算元號無效

en: forming reference to void
zh_TW: 形成對 void 的參照

en: found a real definition for a non-register
zh_TW: 找到非暫存器的真實定義

en: fr30_print_operand: invalid %%F code
zh_TW: fr30_print_operand：無效的 %%F 程式碼

en: fr30_print_operand: invalid %%x code
zh_TW: fr30_print_operand：無效的 %%x 程式碼

en: fr30_print_operand: invalid operand to %%A code
zh_TW: fr30_print_operand：%%A 程式碼運算元無效

en: fr30_print_operand: unhandled MEM
zh_TW: fr30_print_operand：未處理的 MEM

en: fr30_print_operand: unknown code
zh_TW: fr30_print_operand：不明程式碼

en: fr30_print_operand: unrecognized %%B code
zh_TW: fr30_print_operand：無法辨識的 %%B 程式碼

en: fr30_print_operand: unrecognized %%b code
zh_TW: fr30_print_operand：無法辨識的 %%b 程式碼

en: fr30_print_operand: unrecognized %%p code
zh_TW: fr30_print_operand：無法辨識的 %%p 程式碼

en: fr30_print_operand_address: unhandled address
zh_TW: fr30_print_operand：未處理的指標

en: frame size too large for reliable stack checking
zh_TW: 對可靠的堆疊檢查來說框架太大了

en: friend declaration %q#D declares a non-template function
zh_TW: 夥伴宣告 %q#D 宣告了一個非範本函式

en: friend declaration does not name a class or function
zh_TW: 夥伴宣告沒有指定類別或函式名

en: friend declaration not in class definition
zh_TW: 夥伴宣告不在類別定義內

en: friend declaration requires class-key, i.e. %<friend %#T%>
zh_TW: 夥伴宣告需要 class，即 %<friend %#T%>

en: friend declaration requires class-key, i.e. %<friend class %T::%D%>
zh_TW: 夥伴宣告需要 class，即 %<friend class %T::%D%>

en: from previous declaration %q+F
zh_TW: 從先前的宣告 %q+F

en: from this location
zh_TW: 從這個地方

en: frv_print_operand: unknown code
zh_TW: frv_print_operand：不明程式碼

en: function %q#D is initialized like a variable
zh_TW: 函式 %q#D 像變數一樣被初始化

en: function %q+D definition is marked dllimport
zh_TW: 函式 %q+D 的定義被標記為 dllimport

en: function %q+D redeclared as inline
zh_TW: 函式 %q+D 重宣告為內聯的

en: function %q+D redeclared with attribute noinline
zh_TW: 函式 %q+D 重宣告為帶有不可內聯屬性

en: function %q+F can never be inlined because it contains a computed goto
zh_TW: 函式 %q+F 無法被內聯，因為包含一個執行時 goto

en: function %q+F can never be inlined because it is suppressed using -fno-inline
zh_TW: 函式 %q+F 無法被內聯，因為使用了 -fno-inline

en: function %q+F can never be inlined because it uses __builtin_return or __builtin_apply_args
zh_TW: 函式 %q+F 無法被內聯，因為使用了 __builtin_return 或 __builtin_apply_args

en: function %q+F can never be inlined because it uses alloca (override using the always_inline attribute)
zh_TW: 函式 %q+F 無法被內聯，因為它使用了 alloca (使用 always_inline 屬性強制內聯)

en: function %q+F can never be inlined because it uses attributes conflicting with inlining
zh_TW: 函式 %q+F 無法被內聯，因為它使用了與內聯衝突的屬性

en: function %q+F can never be inlined because it uses non-local goto
zh_TW: 函式 %q+F 無法被內聯，因為使用了非區域性的 goto

en: function %q+F can never be inlined because it uses setjmp
zh_TW: 函式 %q+F 無法被內聯，因為它使用了 setjmp

en: function %q+F can never be inlined because it uses setjmp-longjmp exception handling
zh_TW: 函式 %q+F 無法被內聯，因為它使用了 setjmp-longjmp 異常處理

en: function %q+F can never be inlined because it uses variable argument lists
zh_TW: 函式 %q+F 無法被內聯，因為它使用了變長引數表

en: function %qD declared virtual inside a union
zh_TW: 聯合成員函式 %qD 被宣告為虛函式

en: function %qD is initialized like a variable
zh_TW: 函式 %qD 像變數一樣被初始化

en: function %qs cannot be declared %<mutable%>
zh_TW: 函式 %qs 不能被宣告為 %<mutable%>

en: function body not available
zh_TW: 函式體無法使用

en: function call has aggregate value
zh_TW: 函式呼叫有聚合類型

en: function called through a non-compatible type
zh_TW: 函式經由不相容的類型呼叫

en: function declaration isn%'t a prototype
zh_TW: 函式宣告不是一個原型

en: function declared %<noreturn%> has a %<return%> statement
zh_TW: 被宣告為 %<noreturn%> 的函式卻有 %<return%> 敘述

en: function definition declared %<__thread%>
zh_TW: 函式宣告定義為 %<__thread%>

en: function definition declared %<auto%>
zh_TW: 函式宣告定義為 %<auto%>

en: function definition declared %<register%>
zh_TW: 函式宣告定義為 %<register%>

en: function definition declared %<typedef%>
zh_TW: 函式宣告定義為 %<typedef%>

en: function definition has qualified void return type
zh_TW: 函式定義有限定的 void 回傳類型

en: function does not return string type
zh_TW: 函式不回傳字串類型

en: function might be possible candidate for %qs format attribute
zh_TW: 函式可能是 %qs format 屬性的備選

en: function not considered for inlining
zh_TW: 不考慮內聯函式

en: function not inlinable
zh_TW: 函式不能內聯

en: function return type cannot be function
zh_TW: 函式不能回傳函式

en: function return types not compatible due to %<volatile%>
zh_TW: 由於 %<volatile%>，函式回傳類型不相容

en: function returning a function
zh_TW: 函式回傳了一個函式

en: function returning an array
zh_TW: 函式回傳了一個陣列

en: function returns address of local variable
zh_TW: 函式回傳局部變數的位址

en: function returns an aggregate
zh_TW: 函式回傳一個聚合

en: function template partial specialization %qD is not allowed
zh_TW: 函式範本部分特例化 %qD 是不允許的

en: function types not truly compatible in ISO C
zh_TW: 函式類型與 ISO C 不完全相容

en: function-scope %qs implicitly auto and declared %<__thread%>
zh_TW: 函式作用欄位的 %qs 隱含為 auto，卻被宣告為 %<__thread%>

en: function_profiler support
zh_TW: function_profiler 支援

en: function_profiler support for MMIX
zh_TW: 對 MMIX 的 function_profiler 支援

en: generic thunk code fails for method %q#D which uses %<...%>
zh_TW: 通用的轉換層程式碼(thunk)對使用了 %<...%> 的方法 %q#D 失效

en: gfc_conv_constant_to_tree(): invalid type: %s
zh_TW: gfc_conv_constant_to_tree()：無效類型；%s

en: gfc_trans_code(): Bad statement code
zh_TW: gfc_trans_code()：錯誤的敘述程式碼

en: gimplification failed
zh_TW: gimplification 失敗

en: global constructors not supported on this target
zh_TW: 全域建構式在此目標平臺上不受支援

en: global declaration %q+#D
zh_TW: 全域宣告 %q+#D

en: global destructors not supported on this target
zh_TW: 全域解構函式在此目標平臺上不受支援

en: global register variable %qD used in nested function
zh_TW: 巢狀函式中使用了全域暫存器變數 %qD

en: global register variable follows a function definition
zh_TW: 全域暫存器變數出現在函式定義後

en: global register variable has initial value
zh_TW: 全域暫存器變數有初始值

en: global/static variable assignment has been intercepted
zh_TW: 全域/靜態變數賦值已被打斷

en: got %d template parameters for %q#D
zh_TW: 得到 %d 個範本參數，為 %q#D

en: got %d template parameters for %q#T
zh_TW: 得到 %d 個範本參數，為 %q#T

en: gp is constant (but save/restore gp on indirect calls)
zh_TW: gp 是常數(但當間接呼叫時儲存/恢復 gp)

en: had to relocate PCH
zh_TW: 必須重新定位 PCH

en: ia64_print_operand: unknown code
zh_TW: ia64_print_operand：不明程式碼

en: identifier expected after %<@protocol%>
zh_TW: %<@protocol%> 需要識別碼

en: if this code is reached, the program will abort
zh_TW: 如果執行到這段程式碼，程式將中止

en: ignoring %<#pragma align%> for explicitly aligned %q+D
zh_TW: 為明確對齊的 %q+D 忽略 %<#pragma align%>

en: ignoring -fschedule-insns because of exception handling bug
zh_TW: 忽略 -fschedule-insns 以繞開異常處理的缺陷

en: ignoring asm-specifier for non-static local variable %q+D
zh_TW: 為非靜態局部變數 %q+D 忽略了 asm 限定符

en: ignoring duplicate directory "%s"
zh_TW: 忽略重複的目錄「%s」

en: ignoring malformed #pragma longcall
zh_TW: 忽略格式錯誤的 #pragma longcall

en: ignoring nonexistent directory "%s"
zh_TW: 忽略不存在的目錄「%s」

en: illegal reference type specified for instance variable %qs
zh_TW: 為實體變數 %qs 指定了無效的參照類型

en: implicit declaration of function %qE
zh_TW: 隱含宣告函式 %qE

en: implied END DO
zh_TW: 暗示的 END DO

en: impossible constraint in %<asm%>
zh_TW: %<asm%> 中不可能的約束

en: impossible register constraint in %<asm%>
zh_TW: %<asm%> 中不可能的暫存器約束

en: in %s, at %s:%d
zh_TW: 在 %s 中，於 %s:%d

en: in basic block %d:
zh_TW: 在基本區塊 %d 中：

en: in declaration %q+D
zh_TW: 在宣告 %q+D 中

en: in passing argument %P of %q+D
zh_TW: 在傳遞引數 %P (屬於 %q+D)

en: inappropriate accumulator for %qs
zh_TW: %qs 的累加器不合適

en: incompatible implicit declaration of built-in function %qD
zh_TW: 隱含宣告與內建函式 %qD 不相容

en: incompatible implicit declaration of function %qD
zh_TW: 隱含宣告與函式 %qD 不相容

en: incompatible type for argument %d of %qE
zh_TW: 引數 %d(屬於 %qE)類型不相容

en: incompatible types in assignment of %qT to %qT
zh_TW: 將 %qT 賦值給 %qT 時類型不相容

en: incomplete type %qT does not have member %qD
zh_TW: 不完全類型 %qT 沒有成員 %qD

en: incomplete type %qT used in nested name specifier
zh_TW: 巢狀名指定中使用了不完全的類型 %qT

en: inconsistent instance variable specification
zh_TW: 不一致的實體變數指定

en: inconsistent operand constraints in an %<asm%>
zh_TW: 一句 %<asm%> 中運算元約束不一致

en: incorrect insn:
zh_TW: 錯誤指令：

en: incorrect sharing of tree nodes
zh_TW: 對樹結區段的共享不正確

en: increment of pointer to unknown structure
zh_TW: 自增參照不明結構的指標

en: increment of read-only member %qD
zh_TW: 令唯讀成員 %qD 自增

en: increment of read-only variable %qD
zh_TW: 令唯讀變數 %qD 自增

en: index value instead of field name in union initializer
zh_TW: 在聯合初始值設定中出現了索引值而不是欄位名

en: init function found in object %s
zh_TW: 在物件 %s 中發現 init 函式

en: initialization from distinct Objective-C type
zh_TW: 從獨一無二的 Objective-C 類型初始化

en: initialization from incompatible pointer type
zh_TW: 永遠不相容的指標類型初始化

en: initialization left-hand side might be a candidate for a format attribute
zh_TW: 初始化的左手邊可能是 format 屬性的備選時

en: initialization makes integer from pointer without a cast
zh_TW: 初始化將指標賦給整數，未作類型轉換

en: initialization makes pointer from integer without a cast
zh_TW: 初始化時將整數賦給指標，未作類型轉換

en: initialization of a flexible array member
zh_TW: 對彈性陣列成員的初始化

en: initialization of flexible array member in a nested context
zh_TW: 在巢狀的上下文中初始化彈性陣列成員

en: initialized field with side-effects overwritten
zh_TW: 帶副作用的欄位初始化設定被覆寫

en: initialized variable %q+D is marked dllimport
zh_TW: 經初始化的變數 %q+D 被標記為 dllimport

en: initializer element is not computable at load time
zh_TW: 初始值設定中的元素在載入時無法被計算出

en: initializer element is not constant
zh_TW: 初始值設定元素不是常數

en: initializer ends prematurely
zh_TW: 初始值設定在完成之前結束

en: initializer fails to determine size of %q+D
zh_TW: 初始值設定無法決定 %q+D 的大小

en: initializer fails to determine size of %qD
zh_TW: 初始值設定無法決定 %qD 的大小

en: initializer for %qT must be brace-enclosed
zh_TW: %qT 的初始化設定必須在大括號內

en: initializer for floating value is not a floating constant
zh_TW: 浮點值的初始值設定不是一個浮點常數

en: initializer invalid for static member with constructor
zh_TW: 建構式中對靜態成員的初始化無效

en: initializer specified for non-virtual method %q+D
zh_TW: 為非虛方法 %q+D 指定了初始值設定項

en: initializer specified for static member function %qD
zh_TW: 為靜態成員函式 %qD 指定了初始值

en: initializer-string for array of chars is too long
zh_TW: 用以初始化字元陣列的字串太長

en: inline declaration of %qD follows declaration with attribute noinline
zh_TW: %q+D 帶有 noinline 屬性的宣告出現在其內聯宣告之後

en: inline function %q+D declared as  dllimport: attribute ignored
zh_TW: 內聯函式 %q+D 宣告為 dllimport：忽略此屬性

en: inline function %q+D given attribute noinline
zh_TW: 為內聯函式 %q+D 給定了 noinline 屬性

en: inline function %q+D used but never defined
zh_TW: 使用了內聯函式 %q+D 但從未定義過

en: inlined_to pointer is wrong
zh_TW: inlined_to pointer 錯誤

en: inlined_to pointer refers to itself
zh_TW: inlined_to pointer 參照自身

en: inlined_to pointer set for noninline callers
zh_TW: 為非內聯的呼叫者設定了 inlined_to pointer

en: inlining failed in call to %q+F: %s
zh_TW: 呼叫 %q+F 時內聯失敗：%s

en: input operand constraint contains %qc
zh_TW: 輸入運算元約束包含 %qc

en: insn %d inside basic block %d but block_for_insn is %i
zh_TW: insn %d 在基本區塊 %d 之內，但是 BLOCK_FOR_INSN 是 %i

en: insn does not satisfy its constraints:
zh_TW: 指令不滿足其約束：

en: insn outside basic block
zh_TW: 基本區塊外出現指令

en: install: %s%s
zh_TW: 安裝：%s%s

en: instance variable %qs has unknown size
zh_TW: 實體變數 %qs 大小不明

en: instance variable %qs is declared private
zh_TW: 實體變數 %qs 被宣告為私有的

en: instance variable assignment has been intercepted
zh_TW: 實體變數的賦值被打斷

en: instantiation of %q+D as type %qT
zh_TW: %q+D 按類型 %qT 實體化

en: instruction scheduling not supported on this target machine
zh_TW: 指令調度在此目標平臺上不受支援

en: int-array initialized from non-wide string
zh_TW: int 型陣列由非寬字串初始化

en: integer overflow in expression
zh_TW: 整數溢出

en: integral expression %qE is not constant
zh_TW: 整型運算式 %qE 不是常數

en: inter-module optimizations not implemented for C++
zh_TW: 模組間最佳化淍未為 C++ 實作

en: internal compiler error.  Bad address:
zh_TW: 編譯器內部錯誤。錯誤的位址：

en: internal compiler error.  Incorrect shift:
zh_TW: 編譯器內部錯誤。不正確的移位量：

en: internal compiler error.  Unknown mode:
zh_TW: 編譯器內部錯誤。不明的模式：

en: internal compiler error:
zh_TW: 編譯器內部錯誤：

en: internal consistency failure
zh_TW: 內部一致性錯誤

en: internal error - invalid Utf8 name
zh_TW: 內部錯誤 - 無效的 utf8 名

en: internal error: bad register: %d
zh_TW: 內部錯誤：錯誤的暫存器：%dt

en: intrinsic variable which isn't a procedure
zh_TW: 內建函式變數不是一個程序

en: invalid #pragma %s
zh_TW: 無效的 #pragma %s

en: invalid %%-code
zh_TW: 無效的 %%-code

en: invalid %%A operand
zh_TW: 無效的 %%A 運算元

en: invalid %%B operand
zh_TW: 無效的 %%B 運算元

en: invalid %%C operand
zh_TW: 無效的 %%C 運算元

en: invalid %%C value
zh_TW: 無效 %%C 值

en: invalid %%D operand
zh_TW: 無效的 %%D 運算元

en: invalid %%D value
zh_TW: 無效的 %%D 值

en: invalid %%E value
zh_TW: 無效 %%E 值

en: invalid %%F value
zh_TW: 無效 %%F 值

en: invalid %%G value
zh_TW: 無效 %%G 值

en: invalid %%H value
zh_TW: 無效 %%H 值

en: invalid %%J code
zh_TW: 無效 %%J 程式碼

en: invalid %%J value
zh_TW: 無效 %%J 值

en: invalid %%K value
zh_TW: 無效 %%K 值

en: invalid %%L value
zh_TW: 無效 %%L 值

en: invalid %%M value
zh_TW: 無效 %%M 值

en: invalid %%N value
zh_TW: 無效 %%N 值

en: invalid %%O value
zh_TW: 無效 %%O 值

en: invalid %%P operand
zh_TW: 無效的 %%P 運算元

en: invalid %%P value
zh_TW: 無效 %%P 值

en: invalid %%R value
zh_TW: 無效 %%R 值

en: invalid %%S value
zh_TW: 無效 %%S 值

en: invalid %%T value
zh_TW: 無效 %%T 值

en: invalid %%U value
zh_TW: 無效 %%U 值

en: invalid %%Y operand
zh_TW: 無效的 %%Y 運算元

en: invalid %%c operand
zh_TW: 無效的 %%c 運算元

en: invalid %%d operand
zh_TW: 無效的 %%d 運算元

en: invalid %%d value
zh_TW: 無效的 %%d 值

en: invalid %%f operand
zh_TW: 無效的 %%f 運算元

en: invalid %%f value
zh_TW: 無效 %%f 值

en: invalid %%h value
zh_TW: 無效 %%h 值

en: invalid %%j code
zh_TW: 無效 %%j 程式碼

en: invalid %%j value
zh_TW: 無效的 %%j 值

en: invalid %%k value
zh_TW: 無效 %%k 值

en: invalid %%m value
zh_TW: 無效 %%m 值

en: invalid %%p value
zh_TW: 無效的 %%p 值

en: invalid %%q value
zh_TW: 無效 %%q 值

en: invalid %%r value
zh_TW: 無效 %%r 值

en: invalid %%s operand
zh_TW: 無效的 %%s 運算元

en: invalid %%s value
zh_TW: 無效 %%s 值

en: invalid %%t/%%b value
zh_TW: 無效的 %%t/%%b 值

en: invalid %%u value
zh_TW: 無效 %%u 值

en: invalid %%v value
zh_TW: 無效 %%v 值

en: invalid %%x value
zh_TW: 無效的 %%x 值

en: invalid %%xn code
zh_TW: 無效的 %%xn 程式碼

en: invalid 'asm':
zh_TW: 無效的「asm」：

en: invalid --param value %qs
zh_TW: 無效的 --param 值 %qs

en: invalid IACC argument
zh_TW: 無效的 IACC 引數

en: invalid Objective-C++ selector name
zh_TW: 無效的 Objective-C++ 選擇子名

en: invalid PC in line number table
zh_TW: 列號表中 PC 無效

en: invalid UNSPEC as operand
zh_TW: 無效的 UNSPEC 做為運算元

en: invalid abstract return type for function %q+#D
zh_TW: 函式 %q+#D 的抽象回傳類型無效

en: invalid abstract return type for member function %q+#D
zh_TW: 成員函式 %q+#D 的抽象回傳類型無效

en: invalid abstract type %qT for %qE
zh_TW: 抽象類型 %qT 無效，對於 %qE 無效

en: invalid abstract type for %q+D
zh_TW: %q+D 的抽象類型無效

en: invalid access to non-static data member %qD of NULL object
zh_TW: 對 NULL 物件非靜態資料成員 %qD 的存取無效

en: invalid address
zh_TW: 無效位址

en: invalid alignment for %<#pragma align%>, ignoring
zh_TW: %<#pragma align%> 指定的對齊邊界無效，忽略

en: invalid application of %<sizeof%> to a function type
zh_TW: %<sizeof%> 不能用於函式類型

en: invalid application of %qs to a member function
zh_TW: %qs 用於成員函式無效

en: invalid application of %qs to a void type
zh_TW: %qs 不能用於 void 類型

en: invalid argument of %qs attribute
zh_TW: 屬性 %qs 的參數無效

en: invalid argument to %<__builtin_frame_address%>
zh_TW: %<__builtin_frame_address%> 的引數無效

en: invalid argument to %<__builtin_return_address%>
zh_TW: %<__builtin_return_address%> 的引數無效

en: invalid base-class specification
zh_TW: 無效的基礎類別

en: invalid cast from type %qT to type %qT
zh_TW: 從類型 %qT 到類型 %qT 的轉換無效

en: invalid cast of an rvalue expression of type %qT to type %qT
zh_TW: 從具有類型 %qT 的右值運算式到類型 %qT 中的轉換無效

en: invalid cast to function type %qT
zh_TW: 向函式類型 %qT 的轉換無效

en: invalid class name in declaration of %qD
zh_TW: %qD 的宣告中類別名無效

en: invalid conditional operand
zh_TW: 無效的條件運算元

en: invalid const_cast from type %qT to type %qT
zh_TW: 從類型 %qT 到類型 %qT 中的 const_cast 無效

en: invalid const_cast of an rvalue of type %qT to type %qT
zh_TW: 從類型 %qT 到類型 %qT 中的 const_cast 無效

en: invalid const_double operand
zh_TW: 無效的 const_double 運算元

en: invalid constraints for operand
zh_TW: 運算元的約束無效

en: invalid constructor; you probably meant %<%T (const %T&)%>
zh_TW: 無效的建構式：您要的可能是 %<%T (const %T&)%>

en: invalid conversion from %<__fpreg%>
zh_TW: 從 %<__fpreg%> 的轉換無效

en: invalid conversion from %qT to %qT
zh_TW: 從類型 %qT 到類型 %qT 的轉換無效

en: invalid conversion to %<__fpreg%>
zh_TW: 向 %<__fpreg%> 的轉換無效

en: invalid conversion to type %qT from type %qT
zh_TW: 到類型 %qT 的轉換無效，從類型 %qT

en: invalid covariant return type for %q+#D
zh_TW: %q+#D 的協變回傳類型無效

en: invalid default argument for a template template parameter
zh_TW: 範本的範本參數的預設引數無效

en: invalid definition of qualified type %qT
zh_TW: 對限定類型 %qT 的定義無效

en: invalid expression as operand
zh_TW: 無效的運算式做為運算元

en: invalid function declaration
zh_TW: 無效的函式宣告

en: invalid in-class initialization of static data member of non-integral type %qT
zh_TW: 類別中對具有非整數類型 %qT 的靜態資料成員的初始化無效

en: invalid initialization of reference of type %qT from expression of type %qT
zh_TW: 將類型為 %qT 的參照初始化為類型為 %qT 的運算式無效

en: invalid initializer
zh_TW: 無效的初始值設定

en: invalid insn:
zh_TW: 無效指令：

en: invalid lvalue in asm output %d
zh_TW: 組譯輸出 %d 中左值無效

en: invalid mask
zh_TW: 無效遮罩

en: invalid member function declaration
zh_TW: 無效的成員函式宣告

en: invalid member template declaration %qD
zh_TW: 無效的成員範本宣告 %qD

en: invalid operand code '%c'
zh_TW: 無效的運算元程式碼「%c」

en: invalid operand for 'A' modifier
zh_TW: 「A」修飾符的運算元無效

en: invalid operand for 'D' modifier
zh_TW: 「D」修飾符的運算元無效

en: invalid operand for 'H' modifier
zh_TW: 「H」修飾符的運算元無效

en: invalid operand for 'O' modifier
zh_TW: 「O」修飾符的運算元無效

en: invalid operand for 'T' modifier
zh_TW: 「T」修飾符的運算元無效

en: invalid operand for 'b' modifier
zh_TW: 「b」修飾符的運算元無效

en: invalid operand for 'e' modifier
zh_TW: 「e」修飾符的運算元無效

en: invalid operand for 'm' modifier
zh_TW: 「m」修飾符的運算元無效

en: invalid operand for 'o' modifier
zh_TW: 「o」修飾符的運算元無效

en: invalid operand for 'p' modifier
zh_TW: 「p」修飾符的運算元無效

en: invalid operand for 'z' modifier
zh_TW: 「z」修飾符的運算元無效

en: invalid operand for code '%c'
zh_TW: 程式碼「%c」的運算元無效

en: invalid operand modifier letter
zh_TW: 無效的運算元修飾符字母

en: invalid operand output code
zh_TW: 無效的運算元輸出程式碼

en: invalid operand to %%H/%%L code
zh_TW: %%H/%%L 程式碼的運算元無效

en: invalid operand to %%N code
zh_TW: %%N 程式碼的運算元無效

en: invalid operand to %%R
zh_TW: %%R 的運算元無效

en: invalid operand to %%R code
zh_TW: %%R 程式碼的運算元無效

en: invalid operand to %%S
zh_TW: %%S 的運算元無效

en: invalid operand to %%T/%%B code
zh_TW: %%T/%%B 程式碼的運算元無效

en: invalid operand to %%U code
zh_TW: %%U 程式碼的運算元無效

en: invalid operand to %%p code
zh_TW: %%p 程式碼的運算元無效

en: invalid operand to %%s code
zh_TW: %%s 程式碼的運算元無效

en: invalid operands of types %qT and %qT to binary %qO
zh_TW: 運算元類型 %qT 和 %qT 對二進位 %qO 而言無效

en: invalid operation on %<__fpreg%>
zh_TW: 對 %<__fpreg%> 的作業無效

en: invalid parameter %qs
zh_TW: 無效的參數 %qs

en: invalid parameter combination for AltiVec intrinsic
zh_TW: 對 AltiVec 內建函式來說無效的參陣列合

en: invalid parameter type %qT
zh_TW: 無效的參數類型 %qT

en: invalid pointer mode %qs
zh_TW: 無效的指標模式 %qs

en: invalid pointer to bit-field %qD
zh_TW: 參照位元段 %qD 指標無效

en: invalid punctuation %qc in constraint
zh_TW: 約束中出現無效的標點 %qc

en: invalid qualifiers on non-member function type
zh_TW: 非成員函式類型上的限定符無效

en: invalid qualifying scope in pseudo-destructor name
zh_TW: 偽解構函式名的限定作用欄位無效

en: invalid receiver type %qs
zh_TW: 無效的接收者類型 %qs

en: invalid redeclaration of %q+D
zh_TW: 對 %q+#D 無效的重宣告

en: invalid reference prefix
zh_TW: 無效的參照字首

en: invalid register name for %q+D
zh_TW: %q+D 的暫存器名無效

en: invalid rtl sharing found in the insn
zh_TW: 在 insn 中找到無效的 rtl 分享

en: invalid second argument to %<__builtin_prefetch%>; using zero
zh_TW: %<__builtin_prefetch%> 的第二個引數無效；使用 0

en: invalid static_cast from type %qT to type %qT
zh_TW: 從類型 %qT 到類型 %qT 中的 static_cast 無效

en: invalid target memregs value '%d'
zh_TW: 無效的目的 memregs 值「%d」

en: invalid template declaration of %qD
zh_TW: %qD 範本宣告無效

en: invalid template-id
zh_TW: 無效的範本 ID

en: invalid third argument to %<__builtin_prefetch%>; using zero
zh_TW: %<__builtin_prefetch%> 的第三個引數無效；使用 0

en: invalid type %<void%> for new
zh_TW: 對 new 而言類型 %<void%> 無效

en: invalid type %qT as initializer for a vector of type %qT
zh_TW: 無效類型 %qT 做為類型為 %qT 的向量的初始化設定

en: invalid type %qT declared %<friend%>
zh_TW: 無效的類型 %qT 宣告為 %<friend%>

en: invalid types %<%T[%T]%> for array subscript
zh_TW: %<%T[%T]%> 做為陣列下標類型無效

en: invalid use of %%d, %%x, or %%X
zh_TW: 對 %%d、%%x 或 %%X 的無效使用

en: invalid use of %<::%>
zh_TW: 錯誤地使用了 %<::%>

en: invalid use of %<restrict%>
zh_TW: 錯誤地使用了 %<restrict%>

en: invalid use of %<this%> at top level
zh_TW: 在頂層使用 %<this%> 無效

en: invalid use of %<this%> in non-member function
zh_TW: 在非成員函式中使用 %<this%> 無效

en: invalid use of %qD
zh_TW: 錯誤地使用了 %qD

en: invalid use of %qE to form a pointer-to-member-function
zh_TW: 用 %qE 形成成員函式指標的用法無效。

en: invalid use of ':' modifier
zh_TW: 錯誤地使用了「:」修飾符

en: invalid use of a pointer to an incomplete type in pointer arithmetic
zh_TW: 在指標算術中使用參照不完全類型的指標無效

en: invalid use of array with unspecified bounds
zh_TW: 對未指定邊界的陣列的無效使用

en: invalid use of const_cast with type %qT, which is a pointer or reference to a function type
zh_TW: 在類型 %qT 上使用 const_cast 無效，因為它是一個指標函式類型的指標或參照

en: invalid use of const_cast with type %qT, which is not a pointer, reference, nor a pointer-to-data-member type
zh_TW: 在類型 %qT 上使用 const_cast 無效，因為它既不是指標，也不是參照，也不是資料成員指標

en: invalid use of constructor as a template
zh_TW: 將建構式做為範本用法無效

en: invalid use of flexible array member
zh_TW: 對彈性陣列成員無效的使用

en: invalid use of incomplete typedef %qD
zh_TW: 對不完全的 typedef %qD 的無效使用

en: invalid use of member %q+D in static member function
zh_TW: 在靜態成員函式中使用成員 %q+D 無效

en: invalid use of non-lvalue array
zh_TW: 對非左值陣列的無效使用

en: invalid use of non-static data member %q+D
zh_TW: 對非靜態資料成員 %q+D 的無效使用

en: invalid use of non-static data member %qD
zh_TW: 對非靜態資料成員 %qD 的無效使用

en: invalid use of non-static member function
zh_TW: 對非靜態成員函式的使用無效

en: invalid use of non-static member function %qD
zh_TW: 對非靜態成員函式 %qD 的使用無效

en: invalid use of nonstatic data member %qE
zh_TW: 對非靜態資料成員 %qE 的使用無效

en: invalid use of structure with flexible array member
zh_TW: 對包含彈性陣列成員的結構的無效使用

en: invalid use of template-id %qD in declaration of primary template
zh_TW: 在基本範本的宣告中對範本識別碼 %qD 的使用無效

en: invalid use of template-name %qE without an argument list
zh_TW: 使用範本名 %qE 時不帶引數表無效

en: invalid use of type %qT as a default value for a template template-parameter
zh_TW: 將類型 %qT 做為範本的範本參數的預設值無效

en: invalid use of undefined type %<%s %E%>
zh_TW: 對未定義類型 %<%s %E%> 的使用無效

en: invalid use of void expression
zh_TW: 對 void 運算式的無效使用

en: invalid vector type for attribute %qE
zh_TW: 屬性 %qE 的向量類型無效

en: invoke[non-static] on static method
zh_TW: 非靜態地呼叫靜態方法

en: invokestatic on abstract method
zh_TW: 為抽象方法呼叫 invokestatic

en: invokestatic on non static method
zh_TW: 靜態呼叫非靜態方法

en: its dest_idx should be %d, not %d
zh_TW: 它的 dest_idx 應當是 %d 而不是 %d

en: its scope is only this definition or declaration, which is probably not what you want
zh_TW: 它的作用欄位僅限於此定義或宣告，這可能並不是您想要的

en: iwmmxt abi requires an iwmmxt capable cpu
zh_TW: iwmmxt abi 需要相應 CPU 的支援

en: jcf-dump: no classes specified
zh_TW: jcf-dump：未指定類別

en: jump into scope of identifier with variably modified type
zh_TW: 跳至具有可變類型的識別碼的作用欄位中

en: jump into statement expression
zh_TW: 跳轉至敘述運算式中

en: jump to case label
zh_TW: 跳轉至 case 標籤

en: jump to label %q+D
zh_TW: 跳轉至標籤 %q+D

en: jump to label %qD
zh_TW: 跳轉至標籤 %qD

en: junk at end of #pragma %s
zh_TW: #pragma %s 末尾有無用字元

en: junk at end of #pragma GCC java_exceptions
zh_TW: #pragma GCC java_exceptions 末尾有無用字元

en: junk at end of #pragma GCC memregs [0..16]
zh_TW: #pragma GCC memregs [0..16] 末尾有無用字元

en: junk at end of #pragma ghs endsda
zh_TW: #pragma ghs endsda 末尾有無用字元

en: junk at end of #pragma ghs endtda
zh_TW: #pragma ghs endtda 末尾有無用字元

en: junk at end of #pragma ghs endzda
zh_TW: #pragma ghs endzda 末尾有無用字元

en: junk at end of #pragma ghs interrupt
zh_TW: #pragma ghs interrupt 末尾有無用字元

en: junk at end of #pragma ghs section
zh_TW: #pragma ghs section 末尾有無用字元

en: junk at end of #pragma ghs startsda
zh_TW: #pragma ghs startsda 末尾有無用字元

en: junk at end of #pragma ghs starttda
zh_TW: #pragma ghs starttda 末尾有無用字元

en: junk at end of #pragma ghs startzda
zh_TW: #pragma ghs startzda 末尾有無用字元

en: junk at end of #pragma longcall
zh_TW: #pragma longcall 末尾有無用字元

en: junk at end of %<#pragma GCC visibility%>
zh_TW: %<#pragma GCC visibility%> 末尾有無用字元

en: junk at end of %<#pragma align%>
zh_TW: %<#pragma align%> 末尾有無用字元

en: junk at end of %<#pragma fini%>
zh_TW: %<#pragma fini%> 末尾有無用字元

en: junk at end of %<#pragma init%>
zh_TW: %<#pragma init%> 末尾有無用字元

en: junk at end of %<#pragma pack%>
zh_TW: %<#pragma pack%> 末尾有無用字元

en: junk at end of '#pragma options'
zh_TW: 「#pragma options」末尾有無用字元

en: junk at end of '#pragma unused'
zh_TW: 「#pragma unused」末尾有無用字元

en: junk at end of signature string
zh_TW: 簽名稱符串末尾有無用字元

en: keyword %<export%> not implemented, and will be ignored
zh_TW: 關鍵字 %<export%> 未實作，將被忽略

en: keyword %<typename%> not allowed in this context (a qualified member initializer is implicitly a type)
zh_TW: 關鍵字 %<typename%> 不允許用在此上下文中(限定的初始值設定隱含地是一個類型)

en: keyword %<typename%> not allowed in this context (the base class is implicitly a type)
zh_TW: 關鍵字 %<typename%> 不允許用在此上下文中(基礎類別隱含地是一個類型)

en: keyword %<typename%> not allowed outside of templates
zh_TW: 關鍵字 %<typename%> 不能在範本以外使用

en: label %q+D declared but not defined
zh_TW: 標籤 %q+D 宣告後未定義

en: label %q+D defined but not used
zh_TW: 標籤 %q+D 定義後未使用

en: label %q+D used but not defined
zh_TW: 標籤 %q+D 使用前未定義

en: label %qE referenced outside of any function
zh_TW: 標籤 %qE 在所有函式外被參照

en: label at end of compound statement
zh_TW: 標籤位於複合敘述末尾

en: label named wchar_t
zh_TW: 標籤名為 wchar_t

en: lang_* check: failed in %s, at %s:%d
zh_TW: lang_* check：在 %s 中失敗，於 %s:%d

en: language %s not recognized
zh_TW: 語言 %s 未能被識別

en: language string %<"%E"%> not recognized
zh_TW: 語言字串 %<"%E"%> 不可識別

en: large integer implicitly truncated to unsigned type
zh_TW: 大整數隱含截斷為無號類型

en: layout of classes derived from empty class %qT may change in a future version of GCC
zh_TW: 空類別 %qT 的衍生類別的版面設置在 GCC 的未來版本中可能會起變化

en: ld returned %d exit status
zh_TW: ld 回傳 %d

en: left precision
zh_TW: 左精度

en: left precision in strfmon format
zh_TW: strfmon 格式的左精度

en: left shift count >= width of type
zh_TW: 左移次數大於或等於類型寬度

en: left shift count is negative
zh_TW: 左移次數為負

en: left-hand operand of comma expression has no effect
zh_TW: 逗號運算式的左運算元不起作用

en: length modifier
zh_TW: 長度修飾符

en: length modifier in printf format
zh_TW: printf 格式的長度修飾符

en: length modifier in scanf format
zh_TW: scanf 格式的長度修飾符

en: length modifier in strfmon format
zh_TW: strfmon 格式的長度修飾符

en: libraries: %s
zh_TW: 函式庫：%s

en: library function %q#D redeclared as non-function %q#D
zh_TW: 函式庫函式 %q#D 重宣告為非函式 %q#D

en: library lib%s not found
zh_TW: 找不到函式庫 lib%s

en: lo_sum not of register
zh_TW: lo_sum 不是暫存器

en: local class %q#T shall not have static data member %q#D
zh_TW: 局部類別 %q#T 不應當擁有靜態資料成員 %q#D

en: local variable %qD may not appear in this context
zh_TW: 局部變數 %qD 不應出現在此上下文中

en: local variable memory requirements exceed capacity
zh_TW: 局部變數記憶體需求超過容量限制

en: long long constant not a valid immediate operand
zh_TW: long long 常數不是一個有效的立即數值運算元

en: long, short, signed or unsigned used invalidly for %qs
zh_TW: 為 %qs 使用 long、short、signed 或 unsigned 無效

en: looser throw specifier for %q+#F
zh_TW: 放鬆 %q+#F 的 throw 限定

en: lower value in case label range less than minimum value for type
zh_TW: case 標籤範圍的下限值比該類型的最小值還要小

en: macro name missing after %qs
zh_TW: %qs 後缺少巨集名

en: malformed #pragma GCC visibility push
zh_TW: #pragma GCC visibility push 格式錯誤

en: malformed #pragma builtin
zh_TW: #pragma builtin 格式錯誤

en: malformed #pragma ghs section
zh_TW: 格式錯誤的 #pragma ghs section

en: malformed #pragma redefine_extname, ignored
zh_TW: #pragma redefine_extname 格式錯誤，已忽略

en: malformed #pragma weak, ignored
zh_TW: #pragma weak 格式錯誤，已忽略

en: malformed %<#pragma align%>
zh_TW: %<#pragma align%> 格式錯誤

en: malformed %<#pragma align%>, ignoring
zh_TW: %<#pragma align%> 格式錯誤 - 已忽略

en: malformed %<#pragma fini%>
zh_TW: %<#pragma fini%> 格式錯誤

en: malformed %<#pragma fini%>, ignoring
zh_TW: %<#pragma fini%> 格式錯誤 - 已忽略

en: malformed %<#pragma init%>
zh_TW: %<#pragma init%> 格式錯誤

en: malformed %<#pragma init%>, ignoring
zh_TW: %<#pragma init%> 格式錯誤 - 已忽略

en: malformed %<#pragma pack%> - ignored
zh_TW: %<#pragma pack%> 格式錯誤 - 已忽略

en: malformed %<#pragma pack(pop[, id])%> - ignored
zh_TW: %<#pragma pack(pop[, id])%> 格式錯誤 - 已忽略

en: malformed %<#pragma pack(push[, id][, <n>])%> - ignored
zh_TW: %<#pragma pack(push[, id][, <n>])%> 格式錯誤 - 已忽略

en: malformed '#pragma options', ignoring
zh_TW: 「#pragma options」格式錯誤 - 已忽略

en: malformed spec function arguments
zh_TW: spec 函式引數格式錯誤

en: malformed spec function name
zh_TW: spec 函式名格式錯誤

en: mask must be an immediate
zh_TW: 遮罩必須是一個立即數值

en: matching constraint does not allow a register
zh_TW: 匹配的約束不允許使用暫存器

en: matching constraint not valid in output operand
zh_TW: 匹配的約束在輸出運算元中無效

en: matching constraint references invalid operand number
zh_TW: 匹配的約束參照了無效的運算元號

en: maximum value of parameter %qs is %u
zh_TW: 參數 %qs 的最大值是 %u

en: may not use both -EB and -EL
zh_TW: 不能同時使用 -EB 和 -EL

en: may not use both -m32 and -m64
zh_TW: 不能同時使用 -m32 和 -m64

en: media functions are not available unless -mmedia is used
zh_TW: 多媒體函式只在使用-mmedia 的情況下可用

en: member %q+#D with constructor not allowed in anonymous aggregate
zh_TW: 有建構式的成員 %q+#D 不允許在匿名聚合中出現

en: member %q+#D with constructor not allowed in union
zh_TW: 有建構式的成員 %q+#D 不能用在聯合中

en: member %q+#D with copy assignment operator not allowed in anonymous aggregate
zh_TW: 有複製賦值運算子的成員 %q+#D 不能用在聯合中

en: member %q+#D with copy assignment operator not allowed in union
zh_TW: 有複製賦值運算子的成員 %q+#D 不能用在聯合中

en: member %q+#D with destructor not allowed in anonymous aggregate
zh_TW: 有構構函式的成員 %q+#D 不允許在匿名聚合中出現

en: member %q+#D with destructor not allowed in union
zh_TW: 有解構函式的成員 %q+#D 不能用在聯合中

en: member %qD cannot be declared both virtual and static
zh_TW: 成員 %qD 不能既被宣告為虛函式，又被宣告為靜態函式

en: member %qD conflicts with virtual function table field name
zh_TW: 成員 %qD 與虛函式表的欄位名衝突

en: member %qD declared as friend before type %qT defined
zh_TW: 成員 %qD 在類型 %qT 被定義之前宣告為夥伴

en: member %qD is uninitialized reference
zh_TW: 成員 %qD 是未初始化的參照

en: member %qD with uninitialized const fields
zh_TW: 成員 %qD 有未初始化的常數欄位

en: member functions are implicitly friends of their class
zh_TW: 成員函式隱含地成為所屬類別的夥伴

en: memory input %d is not directly addressable
zh_TW: 記憶體輸入 %d 不可直接定址

en: method '%s' not found in class
zh_TW: 在類別中找不到方法「%s」

en: method declaration not in @interface context
zh_TW: 方法宣告不在@interface 上下文中

en: method definition not in @implementation context
zh_TW: 方法定義不在 @implementation 上下文中

en: method possibly missing a [super dealloc] call
zh_TW: 方法可能缺少一個 [super dealloc] 呼叫

en: minimum value of parameter %qs is %u
zh_TW: 參數 %qs 的最小值為 %u

en: mips16 function profiling
zh_TW: mips16 函式取樣

en: mismatching signature for field '%s' in '%s'
zh_TW: 不匹配的欄位簽名「%s」(在 「%s」中)

en: misplaced %<@%D%> Objective-C++ construct
zh_TW: 位置錯誤的 %<@%D%> Objective-C++ 建構

en: misplaced ConstantValue attribute (not in any field)
zh_TW: ConstantValue 屬性位置錯誤(不在任何欄位內)

en: missing $ operand number in format
zh_TW: 格式字串缺少 $ 運算元號

en: missing %<(%> after %<#pragma GCC visibility push%> - ignored
zh_TW: %<#pragma GCC visibility push%> 缺少 %<(%> — 已忽略

en: missing %<(%> after %<#pragma pack%> - ignored
zh_TW: %<#pragma pack%> 後缺少 %<(%>，忽略

en: missing '(' after '#pragma unused', ignoring
zh_TW: 「#pragma unused」後面缺少「(」，忽略

en: missing ')' after '#pragma unused', ignoring
zh_TW: 「#pragma unused」後面缺少「)」，忽略

en: missing Code attribute
zh_TW: 缺少 Code 屬性

en: missing barrier after block %i
zh_TW: 在區塊 %i 之後缺少邊界

en: missing braces around initializer
zh_TW: 初始值設定周圍缺少大括號

en: missing braces around initializer for %qT
zh_TW: %qT 的初始值設定周圍缺少大括號

en: missing close brace for named operand
zh_TW: 具名運算元後缺少右大括號

en: missing close paren
zh_TW: 缺少右括號

en: missing definition
zh_TW: 定義缺失

en: missing edge %i->%i
zh_TW: 缺少邊 %i->%i

en: missing field '%s' in '%s'
zh_TW: 缺少欄位「%s」，在「%s」中

en: missing filename after %qs
zh_TW: %qs 後缺少檔案名稱

en: missing fill character at end of strfmon format
zh_TW: strfmon 格式字串末尾缺少填充字元

en: missing initializer for member %qD
zh_TW: 成員 %qD 缺少初始值設定

en: missing makefile target after %qs
zh_TW: %qs 後缺少 makefile 目的

en: missing number
zh_TW: 缺少數字

en: missing open paren
zh_TW: 缺少左括號

en: missing operand
zh_TW: 缺少運算元

en: missing path after %qs
zh_TW: %qs 後缺少路徑

en: missing sentinel in function call
zh_TW: 函式呼叫中缺少哨兵

en: missing terminating %c character
zh_TW: 缺少結尾的 %c 字元

en: missing type-name in typedef-declaration
zh_TW: typedef 宣告中缺少類型名

en: mixing C++ and Java catches in a single translation unit
zh_TW: 在同一個翻譯單元中混合使用 C++ 和 Java 異常獲取

en: mixing declarations and function-definitions is forbidden
zh_TW: 不能混合宣告和函式定義

en: mode %qs applied to inappropriate type
zh_TW: 對不合適的類型套用模式 %qs

en: more than %d operands in %<asm%>
zh_TW: %<asm%> 中的運算元超過 %d 個

en: mudflap: this language is not supported
zh_TW: mudflap：這個語言不受支援

en: multidimensional array must have bounds for all dimensions except the first
zh_TW: 宣告多維陣列必須至少指定除第一維以外所有維的大小

en: multiple default labels in one switch
zh_TW: 單一 switch 敘述中出現了多個 default 標籤

en: multiple definition of %q#T
zh_TW: %q#T 多次定義

en: multiple fields in union %qT initialized
zh_TW: 初始化了聯合 %qT 中的多個欄位

en: multiple function type attributes specified
zh_TW: 指定了多個函式類型屬性

en: multiple inline callers
zh_TW: 多個內聯呼叫者

en: multiple storage classes in declaration of %qs
zh_TW: %qs 的宣告指定了多個存儲類別

en: multiple storage classes in declaration specifiers
zh_TW: 宣告指定了多個存儲類別

en: multiple types in one declaration
zh_TW: 一個宣告指定了多個類型

en: must #include <typeinfo> before using typeid
zh_TW: 在使用 typeid 之前必須先 #include <typeinfo>

en: mvcle use
zh_TW: 使用 mvcle

en: mysterious repository information in %s
zh_TW: %s 的存儲資訊很詭異

en: name %qD used in a GNU-style designated initializer for an array
zh_TW: 名稱 %qD 用在 GNU 風格的陣列指定元素初始值設定中

en: name %qT has incomplete type
zh_TW: 名稱 %qT 類型不完全

en: name lookup of %qD changed
zh_TW: %qD 的名稱查閱已變更

en: name missing for member function
zh_TW: 成員函式沒具名字

en: named return values are no longer supported
zh_TW: 具名回傳值不再被支援

en: namespace %qD not allowed in using-declaration
zh_TW: 不允許在 using 宣告中使用命名空間 %qD

en: namespace alias %qD not allowed here, assuming %qD
zh_TW: 這裡不允許命名空間別名 %qD，假定為 %qD

en: namespace-scope anonymous aggregates must be static
zh_TW: 命名空間欄位的匿名聚合必須是靜態的

en: need to insert runtime check for %s
zh_TW: 需要為 %s 加入執行時檢查

en: negative insn length
zh_TW: 指令長度為負

en: negative integer implicitly converted to unsigned type
zh_TW: 負整數隱含轉換為無號類型

en: negative width in bit-field %q+D
zh_TW: 位元段 %q+D 寬度為負

en: negative width in bit-field %qs
zh_TW: 位元段 %qs 寬度為負

en: nested assembly dialect alternatives
zh_TW: 巢狀的組譯風格指示

en: nested extern declaration of %qD
zh_TW: 對 %qD 的巢狀的外部宣告

en: nested function %q+D declared but never defined
zh_TW: 巢狀函式 %q+D 宣告過但從未定義

en: nested function %qs declared %<extern%>
zh_TW: 巢狀函式 %qs 被宣告為 %<extern%>

en: nested redefinition of %<enum %E%>
zh_TW: 巢狀的 %<enum %E%> 重定義

en: nested redefinition of %<struct %E%>
zh_TW: 巢狀的 %<struct %E%> 重定義

en: nested redefinition of %<union %E%>
zh_TW: 巢狀的 %<union %E%> 重定義

en: new cannot be applied to a function type
zh_TW: new 不能用於函式類型

en: new cannot be applied to a reference type
zh_TW: new 不能用於參照類型

en: new declaration %q#D
zh_TW: 對 %q#D 的新宣告

en: new types may not be defined in a return type
zh_TW: 不能在回傳類型中定義新類型

en: no %<%D(int)%> declared for postfix %qs, trying prefix operator instead
zh_TW: %<%D(int)%> 沒有出現在字尾 %qs 中，嘗試使用字首運算子

en: no %q#D member function declared in class %qT
zh_TW: 成員函式 %q#D 未在類別 %qT 中宣告

en: no FUNCTION_PROFILER for CRIS
zh_TW: CRIS 沒有 FUNCTION_PROFILER

en: no arguments
zh_TW: 沒有參數

en: no arguments for spec function
zh_TW: spec 函式沒有引數

en: no class name specified with %qs
zh_TW: %qs 沒有指定類別名

en: no class template named %q#T in %q#T
zh_TW: 沒具名為 %q#T 的類別範本，在%q#T 中

en: no closing %<]%> for %<%%[%> format
zh_TW: %<%%[%> 格式沒有相對的 %<]%>

en: no data type for mode %qs
zh_TW: 沒有模式為 %qs 的資料類型

en: no default argument for %qD
zh_TW: %qD 沒有預設參數

en: no description yet
zh_TW: 尚未描述

en: no field %qD found in union being initialized
zh_TW: 在初始化的聯合中找不到欄位 %qD

en: no immediate_use list
zh_TW: 沒有 immediate_use 清單

en: no input file specified
zh_TW: 沒有指定輸入檔案

en: no input files
zh_TW: 沒有輸入檔案

en: no integral type can represent all of the enumerator values for %qT
zh_TW: 沒有一個整數類型可以表示 %qT 的所有列舉值

en: no low registers available for popping high registers
zh_TW: 高暫存器彈堆疊時沒有可用的低暫存器

en: no match for call to %<(%T) (%A)%>
zh_TW: 對 %<(%T) (%A)%> 的呼叫沒有匹配

en: no matches converting function %qD to type %q#T
zh_TW: 沒有可將函式 %qD 轉換到類型 %q#T 的匹配項

en: no matching function for call to %<%D(%A)%>
zh_TW: 對 %<%D(%A)%> 的呼叫沒有匹配的函式

en: no matching function for call to %<%T::%s(%A)%#V%>
zh_TW: 對 %<%T::%s(%A)%#V%> 的呼叫沒有匹配的函式

en: no matching push for %<#pragma GCC visibility pop%>
zh_TW: 沒有與 %<#pragma GCC visibility pop%> 對應的 push

en: no matching template for %qD found
zh_TW: 沒有找到與 %qD 匹配的範本

en: no member function %qD declared in %qT
zh_TW: 成員函式 %qD 未在 %qT 中宣告

en: no members matching %<%T::%D%> in %q#T
zh_TW: 沒有與 %<%T::%D%> 匹配的成員，在 %q#T 中

en: no previous declaration for %q+D
zh_TW: %q+D 先前沒有宣告過

en: no profiling of 64-bit code for this ABI
zh_TW: 此 ABI 不支援取樣 64 位元程式碼

en: no register in address
zh_TW: 位址中無暫存器

en: no return statement in function returning non-void
zh_TW: 在有回傳值的函式中未發現 return 敘述

en: no semicolon at end of struct or union
zh_TW: 結構或聯合後沒有分號

en: no suitable %<operator %s%> for %qT
zh_TW: 沒有合適的 %<operator %s%> 給 %qT

en: no suitable %qD found in class %qT
zh_TW: 找不到合適的 %qD，在類別 %qT 中

en: no type named %q#T in %q#T
zh_TW: 沒具名為 %q#T 的類型，在%q#T 中

en: no unique final overrider for %qD in %qT
zh_TW: %qD 的最終多載在 %qT 中不唯一

en: non-lvalue array in conditional expression
zh_TW: 非左值陣列出現在條件運算式中

en: non-member %qs cannot be declared %<mutable%>
zh_TW: 非成員 %qs 不能被宣告為 %<mutable%>

en: non-object member %qs cannot be declared %<mutable%>
zh_TW: 非物件成員 %qs 不能被宣告為 %<mutable%>

en: non-static const member %q+#D in class without a constructor
zh_TW: 類別中有非靜態常數成員 %q+#D 卻沒有建構式

en: non-static declaration of %q+D follows static declaration
zh_TW: 對 %q+D 的靜態宣告出現在非靜態宣告之後

en: non-static initialization of a flexible array member
zh_TW: 對彈性陣列成員非靜態地初始化

en: non-static method %q+D overrides static method
zh_TW: 非靜態方法 %q+D 覆寫了靜態方法

en: non-static reference %q+#D in class without a constructor
zh_TW: 類別中有非靜態參照 %q+#D，卻沒有提供建構式

en: non-template %qD used as template
zh_TW: 非範本 %qD 做為範本

en: non-template type %qT used as a template
zh_TW: 非範本類型 %qT 做為範本

en: non-thread-local declaration of %q+D follows thread-local declaration
zh_TW: %q+D 的執行緒局部宣告跟在其非執行緒局部宣告之後

en: non-trivial designated initializers not supported
zh_TW: 不平凡的代理初始值設定不受支援

en: nonconstant array index in initializer
zh_TW: 初始值設定中陣列索引不是常數

en: nonnull argument has invalid operand number (argument %lu)
zh_TW: 非空的引數 %lu 運算元號不正確

en: nonnull argument references non-pointer operand (argument %lu, operand %lu)
zh_TW: 非空的引數 %lu 參照了非指標運算元 %lu

en: nonnull argument with out-of-range operand number (argument %lu, operand %lu)
zh_TW: 非空的引數運算元號越界(引數 %lu，運算元 %lu)

en: nonnull attribute without arguments on a non-prototype
zh_TW: 非空的屬性在非原型中沒有引數

en: not a valid Java .class file
zh_TW: 不是一個有效的 Java .class 檔案。

en: not enough type information
zh_TW: 類型資訊不充分

en: not enough variable arguments to fit a sentinel
zh_TW: 變數引數太少，不足以填滿一個哨兵

en: note:
zh_TW: 附註：

en: null argument where non-null required (argument %lu)
zh_TW: 引數為 NULL，需要非 NULL 值(引數 %lu)

en: number must be 0 or 1
zh_TW: 數字必須是 0 或 1

en: number of arguments doesn%'t match built-in prototype
zh_TW: 引數個數與內建原型不符

en: number of arguments doesn%'t match prototype
zh_TW: 引數數目與原型不符

en: number of components of the vector not a power of two
zh_TW: 向量中分量數不是 2 的某次方

en: number of counters is %d instead of %d
zh_TW: 計數器的數量是 %d 而不是 %d

en: object missing in use of %qE
zh_TW: 使用 %qE 時缺少物件

en: obsolete option -I- used, please use -iquote instead
zh_TW: 使用了過時的選項 -I-，請改用 -iquote

en: obsolete use of designated initializer with %<:%>
zh_TW: 使用 %<:%> 來指定元素初始值的作法已過時

en: obsolete use of designated initializer without %<=%>
zh_TW: 過時的用法，應使用 %<=%> 來指定元素初始值

en: offset of %q+D is not ABI-compliant and may change in a future version of GCC
zh_TW: %q+D 的偏移量與 ABI 不相容，並且在 GCC 的未來版本中可能會有變化

en: offset of empty base %qT may not be ABI-compliant and maychange in a future version of GCC
zh_TW: 空基礎類別 %qT 的偏移量可能與 ABI 不相容，並且可能在 GCC 的未來版本中變更

en: offset of virtual base %qT is not ABI-compliant and may change in a future version of GCC
zh_TW: 虛基礎類別 %qT 的偏移量與 ABI 不相容，並且可能在 GCC 的未來版本中變更

en: offset outside bounds of constant string
zh_TW: 偏移量超過字串常數界

en: omitted middle operand to %<?:%> operand cannot be mangled
zh_TW: 省略的 %<?:%> 中運算元不能被修飾

en: only declarations of constructors can be %<explicit%>
zh_TW: 只有建構式才能被宣告為 %<explicit%>

en: only uninitialized variables can be placed in a .bss section
zh_TW: 只有未初始化的變數才能放在 .bss 區段中

en: only uninitialized variables can be placed in the .noinit section
zh_TW: 只有未初始化的變數才能放在 .noinit 區段中

en: only weak aliases are supported in this configuration
zh_TW: 此配置下只支援弱別名

en: opaque vector types cannot be initialized
zh_TW: 不透明的向量類型不能被初始化

en: open /dev/zero: %m
zh_TW: 開啟 /dev/zero：%m

en: opening dependency file %s: %m
zh_TW: 開啟依賴檔案 %s：%m

en: opening output file %s: %m
zh_TW: 開啟輸出檔案 %s：%m

en: operand number missing after %%-letter
zh_TW: %% 字母後缺少運算元號

en: operand number out of range
zh_TW: 運算元號超出範圍

en: operand number out of range in format
zh_TW: 格式字元中運算元號越界

en: operand number specified for format taking no argument
zh_TW: 為格式字串指定的運算元號不帶參數

en: operand number specified with suppressed assignment
zh_TW: 為格式字串指定的運算元號取消了賦值

en: operation on %qE may be undefined
zh_TW: %qE 上的運算結果可能是未定義的

en: optimization may eliminate reads and/or writes to register variables
zh_TW: 最佳化可能會去除對暫存器變數的讀寫

en: options enabled:
zh_TW: 啟用的選項：

en: options passed:
zh_TW: 傳遞的選項：

en: ordered comparison of pointer with integer zero
zh_TW: 指標與整數 0 比較大小

en: originally indirect function call not considered for inlining
zh_TW: 原本間接的函式呼叫不被考慮內聯

en: out of memory
zh_TW: 記憶體不足

en: output constraint %d cannot be specified together with "%s" clobber
zh_TW: 輸出約束 %d 不能在指定「%s」篡改時被指定

en: output constraint %d must specify a single register
zh_TW: 輸出約束 %d 必須指定單一暫存器

en: output constraint %qc for operand %d is not at the beginning
zh_TW: 輸出約束 %qc(對運算元 %d)沒有出現在開頭

en: output filename specified twice
zh_TW: 輸出檔案名稱指定了兩次

en: output number %d not directly addressable
zh_TW: 輸出數 %d 不可直接定址

en: output operand %d must use %<&%> constraint
zh_TW: 輸出運算元 %d 必須使用 %<&%> 約束

en: output operand constraint lacks %<=%>
zh_TW: 輸出運算元約束缺少 %<=%>

en: output operand is constant in %<asm%>
zh_TW: %<asm%> 的輸出運算元是常數

en: output_move_single:
zh_TW: output_move_single：

en: overflow in array dimension
zh_TW: 陣列維數溢出

en: overflow in constant expression
zh_TW: 常數運算式溢出

en: overflow in enumeration values
zh_TW: 列舉值溢出

en: overflow in enumeration values at %qD
zh_TW: %qD 處列舉值溢出

en: overflow in implicit constant conversion
zh_TW: 隱含常數轉換溢出

en: packed attribute causes inefficient alignment
zh_TW: packed 屬性導致低效率的對齊

en: packed attribute causes inefficient alignment for %q+D
zh_TW: packed 屬性導致 %q+D 低效率的對齊

en: packed attribute is unnecessary
zh_TW: 不需要 packed 屬性

en: packed attribute is unnecessary for %q+D
zh_TW: packed 屬性對 %q+D 來說是不需要的

en: padding struct size to alignment boundary
zh_TW: 將結構大小填補到對齊邊界上

en: padding struct to align %q+D
zh_TW: 填補結構以對齊 %q+D

en: parameter %P has incomplete type %qT
zh_TW: 參數 %P 的類型 %qT 不完全

en: parameter %P of %qD has incomplete type %qT
zh_TW: 參數 %P (屬於 %qD)的類型 %qT 不完全

en: parameter %q+D declared %<inline%>
zh_TW: 參數 %q+D 宣告為 %<inline%>

en: parameter %q+D has just a forward declaration
zh_TW: 參數 %q+D 有一個前向宣告

en: parameter %qD declared void
zh_TW: 參數 %qD 被宣告為 void

en: parameter %qD invalidly declared method type
zh_TW: 參數 %qD 被無效地被宣告為具有方法類型

en: parameter %qD is initialized
zh_TW: 參數 %qD 已初始化

en: parameter %u (%q+D) has incomplete type
zh_TW: 參數 %u (%q+D) 的類型不完全

en: parameter %u (%q+D) has void type
zh_TW: 參數 %u (%q+D)類型為 void

en: parameter may not have variably modified type %qT
zh_TW: 參數不能具有可變類型 %qT

en: parameter names (without types) in function declaration
zh_TW: 函式宣告中出現參數名卻未指定類型

en: parse error in template argument list
zh_TW: 範本引數表語法錯誤

en: partial specialization %qT declared %<friend%>
zh_TW: 部分特例化範本 %qT 宣告為 %<friend%>

en: partial specialization %qT does not specialize any template arguments
zh_TW: 部分特例化 %qT 並未特例化任何範本參數

en: passing %qT as %<this%> argument of %q#D discards qualifiers
zh_TW: 將 %qT 做為 %q#D 的 %<this%> 引數時丟棄了類型限定

en: passing %qT chooses %qT over %qT
zh_TW: 傳遞 %qT 時選擇 %qT 而不是 %qT

en: passing NULL to non-pointer argument %P of %qD
zh_TW: 將 NULL 做為非指標引數 %P 傳遞給 %qD

en: passing arg %d of %qE discards qualifiers frompointer target type
zh_TW: 傳遞參數 %d (屬於 %qE)時丟棄了指標目的類型的類型限定

en: passing argument %d of %qE as %<float%> rather than %<double%> due to prototype
zh_TW: 根據原型，引數 %d (%qE) 將做為 %<float%> 而不是 %<double%> 傳遞

en: passing argument %d of %qE as complex rather than floating due to prototype
zh_TW: 根據原型，引數 %d (%qE) 將做為複數而不是浮點數傳遞

en: passing argument %d of %qE as complex rather than integer due to prototype
zh_TW: 根據原型，引數 %d (%qE) 將做為複數而不是整數傳遞

en: passing argument %d of %qE as floating rather than complex due to prototype
zh_TW: 根據原型，引數 %d (%qE) 將做為浮點數而不是複數傳遞

en: passing argument %d of %qE as floating rather than integer due to prototype
zh_TW: 根據原型，引數 %d (%qE) 將做為浮點數而不是整數傳遞

en: passing argument %d of %qE as integer rather than complex due to prototype
zh_TW: 根據原型，引數 %d (%qE) 將做為整數而不是複數傳遞

en: passing argument %d of %qE as integer rather than floating due to prototype
zh_TW: 根據原型，引數 %d (%qE) 將做為整數而不是浮點數傳遞

en: passing argument %d of %qE as signed due to prototype
zh_TW: 根據原型，引數 %d (%qE) 將做為有號數傳遞

en: passing argument %d of %qE as unsigned due to prototype
zh_TW: 根據原型，引數 %d (%qE) 將作用無號數傳遞

en: passing argument %d of %qE from distinct Objective-C type
zh_TW: 永遠不同的 Objective-C 類型傳遞參數 %d (屬於 %qE)

en: passing argument %d of %qE from incompatible pointer type
zh_TW: 傳遞參數 %d (屬於 %qE)時在不相容的指標類型間轉換

en: passing argument %d of %qE makes integer from pointer without a cast
zh_TW: 傳遞參數 %d (屬於 %qE)時將指標賦給整數，未作類型轉換

en: passing argument %d of %qE makes pointer from integer without a cast
zh_TW: 傳遞參數 %d (屬於 %qE)時將整數賦給指標，未作類型轉換

en: passing argument %d of %qE with different width due to prototype
zh_TW: 根據原型，引數 %d (%qE) 將以不同的寬度傳遞

en: passing floating point arguments in fp regs not yet supported
zh_TW: 尚不支援在浮點暫存器中傳遞浮點參數

en: pch_preprocess pragma should only be used with -fpreprocessed
zh_TW: pch_preprocess pragma 只應與 -fpreprocessed 並用

en: pex_init failed
zh_TW: pex_init 失敗

en: pointer arithmetic for garbage-collected objects not allowed
zh_TW: 不允許在被無用收集的物件上進行指標算術運算

en: pointer assignment
zh_TW: 指標賦值

en: pointer of type %<void *%> used in arithmetic
zh_TW: %<void *%> 型指標用在了算術運算式中

en: pointer of type %<void *%> used in subtraction
zh_TW: 在減法中使用類型為 %<void *%> 的指標

en: pointer targets in assignment differ in signedness
zh_TW: 對指標賦值時目的與指標有/無號不一致

en: pointer targets in initialization differ in signedness
zh_TW: 初始化指標時目的與指標有/無號不一致

en: pointer targets in passing argument %d of %qE differ in signedness
zh_TW: 傳遞參數 %d (屬於 %qE) 給指標時目的與指標有/無號不一致

en: pointer targets in return differ in signedness
zh_TW: 回傳指標時目的與指標有/無號不一致

en: pointer to a function used in arithmetic
zh_TW: 在算術運算式中使用了函式指標

en: pointer to a function used in subtraction
zh_TW: 函式指標不能相減

en: pointer to member conversion via virtual base %qT
zh_TW: 成員指標轉換經由虛基礎類別 %qT

en: pointer to member function used in arithmetic
zh_TW: 在算術運算式中使用了成員指標

en: pointer to member type %qT incompatible with object type %qT
zh_TW: 成員指標類型 %qT 與物件類型 %qT 不相容

en: pointer type mismatch in conditional expression
zh_TW: 條件運算式指標類型不匹配

en: pointer value used where a complex was expected
zh_TW: 需要複數時使用了指標值

en: pointer value used where a floating point value was expected
zh_TW: 需要浮點數值時使用了指標值

en: pointer-to-member function %E cannot be called without an object; consider using .* or ->*
zh_TW: 沒有物件不能呼叫成員函式指標 %E，考慮使用 .* 或 ->*

en: pointer/integer type mismatch in conditional expression
zh_TW: 條件運算式中指標/整數類型不匹配

en: pointers are not permitted as case values
zh_TW: 指標不能做為 case 常數

en: possible problem detected in invocation of delete operator:
zh_TW: 偵測到呼叫 delete 運算子時可能出現的問題：

en: post-increment address is not a register
zh_TW: 後自增位址不是一個暫存器

en: postfix %qD must take %<int%> as its argument
zh_TW: 字尾 %qD 必須使用 %<int%> 做為它的參數

en: postfix %qD must take %<int%> as its second argument
zh_TW: 字尾 %qD 必須使用 %<int%> 做為它的第二個參數

en: postfix %qD should return %qT
zh_TW: 字尾 %qD 應當回傳 %qT

en: pre-decrement address is not a register
zh_TW: 前自減位址不是一個暫存器

en: pre-increment address is not a register
zh_TW: 前自增位址不是一個暫存器

en: precision
zh_TW: 精度

en: precision in printf format
zh_TW: printf 格式的精度

en: predicated Thumb instruction
zh_TW: 預測到的 Thumb 指令

en: predicated instruction in conditional sequence
zh_TW: 在條件序列中預測到的指令

en: prefix %qD should return %qT
zh_TW: 字首 %qD 應當回傳 %qT

en: prev_bb of %d should be %d, not %d
zh_TW: %d 的 prev_bb 應該為 %d，而不是 %d

en: previous declaration %q+#D here
zh_TW: 與此處早先的宣告 %q+#D 衝突

en: previous declaration %q+D
zh_TW: 先前的宣告 %q+D

en: previous declaration of %q+#D
zh_TW: %q+#D 的前一個宣告

en: previous declaration of %q+#D with %qL linkage
zh_TW: %q+#D 的早先宣告有 %qL 連結

en: previous declaration of %q+D
zh_TW: %q+D 的前一個宣告

en: previous declaration of %q+D was here
zh_TW: %q+D 的上一個宣告在此

en: previous declaration of %q+D was inline
zh_TW: %q+D 先前被宣告為內聯的

en: previous declaration of %q+D with attribute noinline
zh_TW: 先前 %q+D 的宣告帶有 noinline 屬性

en: previous declaration of namespace %q+D here
zh_TW: 命名空間 %q+D 早先的宣告在這裡

en: previous definition of %q+#T
zh_TW: %q+#T 的上一個定義

en: previous definition of %q+D was here
zh_TW: %q+D 的上一個定義在此

en: previous external decl of %q+#D
zh_TW: 先前 %q+#D 的外部宣告

en: previous implicit declaration of %q+D was here
zh_TW: %q+D 的上一個隱含宣告在此

en: previous non-function declaration %q+#D
zh_TW: 先前對於 %q+#D 的非函式宣告

en: private member %q+#D in anonymous union
zh_TW: 匿名聯合中出現私有成員 %q+#D

en: profiler support for VxWorks
zh_TW: 對 VxWorks 的取樣支援

en: programs: %s
zh_TW: 程式：%s

en: promoted argument %qD doesn%'t match built-in prototype
zh_TW: 提升後的引數 %qD 與內建原型不符

en: promoted argument %qD doesn%'t match prototype
zh_TW: 提升後的引數 %qD 與原型不符

en: protected member %q+#D in anonymous union
zh_TW: 匿名聯合中出現保護成員 %q+#D

en: prototype for %q#D does not match any in class %qT
zh_TW: %q#D 的原型不匹配類別 %qT 中的任何一個

en: prototype for %q+#D
zh_TW: %q+#D 的原型

en: prototype for %q+D declares argument %d with incompatible type
zh_TW: %q+D 的原型對引數 %d 宣告類型不相容

en: prototype for %q+D declares fewer arguments than previous old-style definition
zh_TW: %q+D 的原型宣告的參數少於先前舊式的定義

en: prototype for %q+D declares more arguments than previous old-style definition
zh_TW: %q+D 的原型宣告的參數多於先前舊式的定義

en: prototype for %q+D follows non-prototype definition
zh_TW: %q+D 的原型出現在非原型定義之後

en: provided for %q+D
zh_TW: 提供給 %q+D

en: pseudo-destructor is not called
zh_TW: 偽解構函式未被呼叫

en: pure-specifier on function-definition
zh_TW: 函式定義上有 pure 指定

en: qualified type %qT does not match destructor name ~%qT
zh_TW: 限定的類型 %qT 不匹配解構函式名 ~%qT

en: qualifiers are not allowed on declaration of %<operator %T%>
zh_TW: %<operator %T%> 的宣告中不能使用限定符

en: qualifiers can only be specified for objects and functions
zh_TW: 只能為物件和函式指定類型限定

en: r0 needs to be available as a call-clobbered register
zh_TW: r0 需要做為呼叫篡改的暫存器

en: range expressions in switch statements are non-standard
zh_TW: 在 switch 敘述中使用範圍運算式不符合標準

en: read-only member %qD used as %<asm%> output
zh_TW: 唯讀成員 %qD 做為 %<asm%> 的輸出

en: read-only variable %qD used as %<asm%> output
zh_TW: 唯讀變數 %qD 做為 %<asm%> 的輸出

en: reading class %s for the second time from %s
zh_TW: 第二次讀取類別 %s，從 %s

en: reading through null pointer (argument %d)
zh_TW: 對空指標參照內容的讀作業(引數 %d)

en: recursive inlining
zh_TW: 遞迴內聯

en: recursive type %qT undefined
zh_TW: 遞迴的類型 %qT 未定義

en: redeclaration of %<enum %E%>
zh_TW: %<enum %E%> 重宣告

en: redeclaration of %<wchar_t%> as %qT
zh_TW: %<wchar_t%> 重宣告為 %qT

en: redeclaration of %q+D with different visibility (old visibility preserved)
zh_TW: 對 %q+D 的再次宣告中指定了不同的可見性 (保留原有的可見性)

en: redeclaration of %q+D with no linkage
zh_TW: %q+D 重宣告為沒有外部連結

en: redeclaration of %qT as a non-template
zh_TW: %qT 重宣告為非範本

en: redeclaration of C++ built-in type %qT
zh_TW: 對 C++ 內建類型 %qT 的重宣告

en: redeclaration of enumerator %q+D
zh_TW: 列舉 %q+D 重宣告

en: redeclared here as %q#D
zh_TW: 在這裡又被宣告為 %q#D

en: redefined extern inline functions are not considered for inlining
zh_TW: 不考慮內聯重定義的外部內聯函式

en: redefinition of %<struct %E%>
zh_TW: %<struct %E%> 重定義

en: redefinition of %<union %E%>
zh_TW: %<union %E%> 重定義

en: redefinition of %q#T
zh_TW: %q#T 重定義

en: redefinition of %q+D
zh_TW: %q+D 重定義

en: redefinition of default argument for %q#D
zh_TW: 重定義 %q#D 的預設參數

en: redefinition of parameter %q+D
zh_TW: 參數 %q+D 重定義

en: redefinition of typedef %q+D
zh_TW: %q+D 重定義

en: redundant redeclaration of %q+D
zh_TW: 對 %q+D 冗餘的重宣告

en: redundant redeclaration of %qD in same scope
zh_TW: 同一作用欄位中 %qD 冗餘的重宣告

en: reference %qs is ambiguous: appears in interface %qs and interface %qs
zh_TW: 參照 %qs 有歧義：出現在介面 %qs 和介面 %qs 中

en: reference to %<%T::%D%> is ambiguous
zh_TW: 對 %<%T::%D%> 的參照有歧義

en: reference to %qD is ambiguous
zh_TW: 對 %qD 的參照有歧義

en: reference to local variable %q+D returned
zh_TW: 回傳了對局部變數的 %q+D 的參照

en: reference to non-lvalue returned
zh_TW: 回傳了一個非左值的參照

en: register name given for non-register variable %q+D
zh_TW: 為非暫存器變數 %q+D 給定了暫存器名

en: register name not specified for %q+D
zh_TW: %q+D 的暫存器名無效

en: register specified for %q+D isn%'t suitable for data type
zh_TW: 為 %q+D 指定的暫存器不適合此資料類型

en: register variable %qD used in nested function
zh_TW: 巢狀函式中使用了暫存器變數 %qD

en: rename spec %s to %s
zh_TW: 將 spec %s 重新命名為 %s

en: repeated %s in format
zh_TW: 格式字串中有重複的 %s

en: request for implicit conversion from %qT to %qT not permitted in C++
zh_TW: C++ 中不允許從 %qT 到 %qT 的隱含轉換

en: request for member %qD in %qE, which is of non-class type %qT
zh_TW: 對成員 %qD 的請求出現在 %qE 中，而後者具有非類別類型 %qT

en: request for member %qD is ambiguous
zh_TW: 對成員 %qD 的請求有歧義

en: request for member %qD is ambiguous in multiple inheritance lattice
zh_TW: 在多繼承網格中對 %qD 的存取有歧義

en: request for member %qE in something not a structure or union
zh_TW: 在非結構或聯合中請求成員 %qE

en: requested alignment for %q+D is greater than implemented alignment of %wu
zh_TW: %q+D 需要的對齊邊界大於實作的對齊邊界 %wu

en: requested alignment is not a power of 2
zh_TW: 要求的對齊邊界不是 2 的某次方

en: requested alignment is too large
zh_TW: 要求的對齊邊界太大

en: requested init_priority is not an integer constant
zh_TW: 請求的 init_priority 不是一個整數常數

en: requested init_priority is out of range
zh_TW: 請求的 init_priority 越界

en: requested init_priority is reserved for internal use
zh_TW: 請求的 init_priority 保留為內部使用

en: requested position is less than zero
zh_TW: 要求的位置小於 0

en: requested position is not an integer constant
zh_TW: 要求的位置不是一個整數常數

en: result of %<operator->()%> yields non-pointer result
zh_TW: %<operator->()%> 的結果給出了非指標的結果

en: return from incompatible pointer type
zh_TW: 回傳了不相容的指標類型

en: return makes integer from pointer without a cast
zh_TW: 回傳時將指標賦給整數，未作類型轉換

en: return makes pointer from integer without a cast
zh_TW: 回傳時將整數賦給指標，未作類型轉換

en: return not followed by barrier
zh_TW: 界線之後沒有 return

en: return type %q#T is incomplete
zh_TW: 回傳值類型 %q#T 為不完全

en: return type defaults to %<int%>
zh_TW: 回傳類型預設為 %<int%>

en: return type is an incomplete type
zh_TW: 回傳不完全的類型

en: return type might be a candidate for a format attribute
zh_TW: 回傳類型可能是 format 屬性的備選

en: return type specification for constructor invalid
zh_TW: 為建構式指定回傳值無效

en: return type specification for destructor invalid
zh_TW: 指定解構函式的回傳類型無效

en: return type specified for %<operator %T%>
zh_TW: 為 %<operator %T%> 指定了回傳值

en: return-statement with a value, in function returning 'void'
zh_TW: 在回傳「void」的函式中，回傳敘述帶回傳值

en: return-statement with no value, in function returning %qT
zh_TW: 在回傳 %qT 的函式中，回傳敘述不帶回傳值

en: returning a value from a constructor
zh_TW: 建構式回傳值

en: returning a value from a destructor
zh_TW: 解構函式回傳值

en: returning reference to temporary
zh_TW: 回傳臨時變數的參照

en: right precision
zh_TW: 右精度

en: right precision in strfmon format
zh_TW: strfmon 格式的右精度

en: right shift count >= width of type
zh_TW: 右移次數大於或等於類型寬度

en: right shift count is negative
zh_TW: 右移次數為負

en: rounding mode not supported for VAX floats
zh_TW: 捨入模式不為 VAX 浮點數所支援

en: say %<typename %E%> if a type is meant
zh_TW: 如果您想指定類型，請使用 %<typename %E%>

en: second argument of %q+D should be %<char **%>
zh_TW: %q+D 的第二個參數類型應該是 %<char **%>

en: second argument to %<__builtin_prefetch%> must be a constant
zh_TW: %<__builtin_prefetch%> 的第二個引數必須是一個常數

en: second parameter of %<va_start%> not last named argument
zh_TW: %<va_start%> 的第二個參數不是最後一個具名參數

en: section attribute not allowed for %q+D
zh_TW: %q+D 不能有 section 屬性

en: section of %q+D conflicts with previous declaration
zh_TW: %q+D 的區段與早先的宣告衝突

en: selector must be an immediate
zh_TW: 選擇子必須是立即數值

en: selector must be an integer constant in the range 0..%wi
zh_TW: 選擇子必須是 0 到 %wi 間的整常數

en: shadowing previous type declaration of %q#D
zh_TW: 隱藏了早先的類型宣告 %q#D

en: shared and mdll are not compatible
zh_TW: shared 和 mdll 互不相容

en: shared call_stmt:
zh_TW: 共享的 call_stmt：

en: shared rtx
zh_TW: 共享的 rtx

en: simple IF
zh_TW: 簡單的 IF

en: size assigned to %qT may not be ABI-compliant and may change in a future version of GCC
zh_TW: 賦於 %qT 的大小可能與 ABI 不相容，並且可能在 GCC 的未來版本中變更

en: size in array new must have integral type
zh_TW: 陣列 new 的大小必須有整數類型

en: size of %q+D is %d bytes
zh_TW: %q+D 的大小為 %d 位元組

en: size of %q+D is larger than %wd bytes
zh_TW: %q+D 的大小超過 %wd 位元組

en: size of array %qD has non-integral type %qT
zh_TW: 陣列 %qD 的大小具有非整數類型 %qT

en: size of array %qD is negative
zh_TW: 陣列 %qD 的大小為負

en: size of array %qD is not an integral constant-expression
zh_TW: 陣列 %qD 的大小不是一個整數常運算式

en: size of array %qs is too large
zh_TW: 陣列 %qs 太大

en: size of array has non-integral type %qT
zh_TW: 陣列 %qT 的大小的類型不是整數

en: size of array is negative
zh_TW: 陣列大小為負數

en: size of array is not an integral constant-expression
zh_TW: 陣列大小不是一個整數常運算式

en: size of loop %d should be %d, not %d
zh_TW: 循環 %d 的大小應該為 %d，而不是%d

en: size of return value of %q+D is %u bytes
zh_TW: %q+D 回傳值的大小為 %u 位元組

en: size of return value of %q+D is larger than %wd bytes
zh_TW: %q+D 回傳值的大小為 %wd 位元組

en: size of variable %q+D is too large
zh_TW: 變數 %q+D 的大小太大

en: sizeof(long double) is 12
zh_TW: sizeof(long double) 等於 12

en: sizeof(long double) is 16
zh_TW: sizeof(long double) 等於 16

en: soft-float and long-double-128 are incompatible
zh_TW: soft-float 與 long-double-128 互不相容

en: sorry, unimplemented:
zh_TW: 對不起，尚未實作：

en: spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC
zh_TW: spec 失敗：SYSROOT_HEADERS_SUFFIX_SPEC 參數多於一個

en: spec failure: more than one arg to SYSROOT_SUFFIX_SPEC
zh_TW: spec 失敗：SYSROOT_SUFFIX_SPEC 參數多於一個

en: spec file has no spec for linking
zh_TW: spec 檔案沒有對連結的設定

en: spec is '%s'
zh_TW: spec 是「%s」

en: specialization %qT after instantiation %qT
zh_TW: %qT 的實體化在 %qT 的特例化之後

en: specialization of %qD after instantiation
zh_TW: %qD 的特例化在實體化之後

en: specialization of %qD in different namespace
zh_TW: 在不同命名空間內對 %qD 的特例化

en: specialization of %qT after instantiation
zh_TW: %qT 的實體化在特例化之後

en: specialization of implicitly-declared special member function
zh_TW: 特例化了隱含宣告的特殊成員函式

en: specializing %q#T in different namespace
zh_TW: 在不同命名空間中特例化 %q#T

en: specified mode too small for enumeral values
zh_TW: 指定的模式對列舉值來說太小

en: specifying vector types with __attribute__ ((mode)) is deprecated
zh_TW: 指定向量類型時使用 __attribute__ ((mode)) 已過時

en: specs %%include syntax malformed after %ld characters
zh_TW: specs %%include 在 %ld 字元後語法格式錯誤

en: specs %%rename syntax malformed after %ld characters
zh_TW: specs %%rename 在 %ld 字元後語法格式錯誤

en: specs %s spec was not found to be renamed
zh_TW: specs 找不到 %s spec 或已被重新命名

en: specs file malformed after %ld characters
zh_TW: specs 在 %ld 字元後檔案格式錯誤

en: specs unknown %% command after %ld characters
zh_TW: specs 在 %ld 字元後出現不明的 %% 命令

en: spurious %<>>%>, use %<>%> to terminate a template argument list
zh_TW: 可疑的 %<>>%>，使用 %<>%> 來結束範本引數清單

en: spurious trailing %<%%%> in format
zh_TW: 格式字串尾有可疑的 %<%%%>

en: stack frame not a multiple of 8 bytes: %wd
zh_TW: 堆疊框架大小不是 8 位元組的倍數：%wd

en: stack frame not a multiple of octabyte: %wd
zh_TW: 堆疊框架大小不是 8 位元組的倍數：%wd

en: stack frame too large
zh_TW: 堆疊框架太大

en: stack guard value must be an exact power of 2
zh_TW: 堆疊防護值必須是 2 的整數次方

en: stack limit expression is not supported
zh_TW: 不支援堆疊限制運算式

en: stack limits not supported on this target
zh_TW: 堆疊限制在此目標平臺上不受支援

en: stack size must be an exact power of 2
zh_TW: 堆疊大小必須剛好是 2 的某次方

en: stack size must be greater than the stack guard value
zh_TW: 堆疊大小必須大於堆疊防護值

en: stack size must not be greater than 64k
zh_TW: 堆疊大小不能大於 64K

en: stack underflow - dup* operation
zh_TW: 堆疊向下溢位 - dup* 作業

en: stackframe too big: %d bytes
zh_TW: 堆疊框架太大：%d 位元組

en: standard conversions are not allowed in this context
zh_TW: 此上下文中不允許標準轉換

en: statement with no effect
zh_TW: 敘述不起作用

en: static %qs cannot be declared %<mutable%>
zh_TW: 靜態 %qs 不能被宣告為 %<mutable%>

en: static declaration of %q+D follows non-static declaration
zh_TW: 對 %qD 的靜態宣告出現在非靜態宣告之後

en: static is not supported on TPF-OS
zh_TW: TPF-OS 不支援 static

en: static member %qD cannot be a bit-field
zh_TW: 靜態成員 %qD 不能是位元段

en: static member %qD declared %<register%>
zh_TW: 靜態成員 %qD 宣告為 %<register%>

en: static member function %q#D declared with type qualifiers
zh_TW: 靜態成員函式 %q#D 的宣告帶有類型限定符

en: static or type qualifiers in non-parameter array declarator
zh_TW: static 或類型限定符出現在非參數陣列宣告中

en: stdcall and cdecl attributes are not compatible
zh_TW: stdcall 和 cdecl 屬性互不相容

en: stdcall and fastcall attributes are not compatible
zh_TW: stdcall 和 fastcall 屬性互不相容

en: storage class %<__thread%> invalid for function %qs
zh_TW: 函式 %qs 的存儲類別 %<__thread%> 無效

en: storage class %<auto%> invalid for function %qs
zh_TW: 函式 %qs 的存儲類別 %<auto%> 無效

en: storage class %<register%> invalid for function %qs
zh_TW: 函式 %qs 的存儲類別 %<register%> 無效

en: storage class %qD applied to template instantiation
zh_TW: 為範本實體化化套用了存儲類型 %qD

en: storage class specified for %qs
zh_TW: 為 %qs 指定了存儲類別

en: storage class specified for parameter %qs
zh_TW: 為參數 %qs 指定了存儲類別

en: storage class specified for typename
zh_TW: 為類型名指定了存儲類別

en: storage class specifiers invalid in friend function declarations
zh_TW: 為夥伴函式宣告指定了無效的存儲類別

en: storage class specifiers invalid in parameter declarations
zh_TW: 為參數宣告指定了無效的存儲類別

en: storage size of %q+D isn%'t constant
zh_TW: %q+D 的存儲大小不是常數

en: storage size of %q+D isn%'t known
zh_TW: %q+D 的存儲大小不明

en: stray %<\%o%> in program
zh_TW: 程式中有游離的 %<\%o%>

en: stray %qc in program
zh_TW: 程式中有游離的 %qc

en: stray %qs in program
zh_TW: 程式中有游離的 %qs

en: strftime formats cannot format arguments
zh_TW: strftime 格式字串無法格式化引數

en: string length %qd is greater than the length %qd ISO C%d compilers are required to support
zh_TW: 字串長 %qd 比 %qd (ISO C%d 被要求支援的最大長度) 還要長

en: strong using only meaningful at namespace scope
zh_TW: 強 using 只在命名空間作用欄位有意義

en: strong-cast assignment has been intercepted
zh_TW: 強轉換的賦值被打斷

en: strong-cast may possibly be needed
zh_TW: 可能需要強類型轉換

en: struct has no members
zh_TW: 結構體沒有成員

en: struct has no named members
zh_TW: 結構不包含任何具名成員

en: structure alignment must be a small power of two, not %d
zh_TW: 結構的對齊必須是 2 的較小次方，而不是 %d

en: subscript missing in array reference
zh_TW: 陣列參照缺少下標

en: subscripted value is neither array nor pointer
zh_TW: 下標運算的左運算元既非陣列也非指標

en: subscripted value is pointer to function
zh_TW: 下標運算的左運算元是函式指標

en: subscripting array declared %<register%>
zh_TW: 按下標存取宣告為 %<register%> 的陣列

en: suggest parentheses around assignment used as truth value
zh_TW: 建議在做為真值的賦值敘述前後加上括號

en: support for mode %qs
zh_TW: 支援 %qs 模式

en: switch %qs is no longer supported
zh_TW: 開關 %qs 不再被支援

en: switch quantity not an integer
zh_TW: switch 敘述中的值不是一個整數

en: switch statement of size %lu entries too large
zh_TW: switch 敘述太大(%lu 個條目)

en: taking address of temporary
zh_TW: 取臨時變數的位址

en: taking the address of a label is non-standard
zh_TW: 取標籤的位址不符合標準

en: target CPU does not support THUMB instructions
zh_TW: 目的 CPU 不支援 THUMB 指令

en: target CPU does not support interworking
zh_TW: 目的 CPU 不支援交互工作

en: target format does not support infinity
zh_TW: 目的格式不支援無限大浮點數

en: target system does not support debug output
zh_TW: 目的系統不支援除錯輸出

en: target system does not support the "%s" debug format
zh_TW: 目的系統不支援「%s」除錯格式

en: template argument %d is invalid
zh_TW: 範本參數 %d 無效

en: template argument %qE involves template parameter(s)
zh_TW: 範本引數 %qE 混雜了範本參數

en: template argument required for %<%s %T%>
zh_TW: %<%s %T%> 需要範本參數

en: template class without a name
zh_TW: 範本類別沒具名字

en: template declaration of %q#D
zh_TW: %q#D 宣告為範本

en: template definition of non-template %q#D
zh_TW: 對非範本 %q#D 的範本定義

en: template parameter %q+#D
zh_TW: 範本參數 %q+#D

en: template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type
zh_TW: 範本參數 %qD(類型為 %qT)不允許出現在整數運算式中，因為它的類型不是整數或列舉

en: template parameter list used in explicit instantiation
zh_TW: 明確初始化中出現了範本參數清單

en: template parameter type %qT declared %<friend%>
zh_TW: 範本參數類型 %qT 宣告為 %<friend%>

en: template parameters cannot be friends
zh_TW: 範本參數不能是夥伴

en: template parameters do not match template
zh_TW: 範本參數與範本不符

en: template parameters not used in partial specialization:
zh_TW: 部分特例化中未用到範本參數：

en: template specialization with C linkage
zh_TW: 特例化範本有 C 連結

en: template specifiers not specified in declaration of %qD
zh_TW: %qD 的宣告中沒有 template 限定

en: template type parameters must use the keyword %<class%> or %<typename%>
zh_TW: 範本參數必須使用 %<class%> 或 %<typename%> 關鍵字

en: template with C linkage
zh_TW: C 連結的範本

en: template-id %qD for %q+D does not match any template declaration
zh_TW: 範本識別碼 %qD(屬於 %q+D)不匹配任何範本宣告

en: template-id %qD in declaration of primary template
zh_TW: 範本識別碼 %qD 出現在基本範本的宣告中

en: template-id %qD used as a declarator
zh_TW: 範本識別碼 %qD 做為宣告

en: the ' ' printf flag
zh_TW: 「 」printf 旗標

en: the '!' strfmon flag
zh_TW: 「!」strfmon 旗標

en: the '#' printf flag
zh_TW: 「#」printf 旗標

en: the '#' strftime flag
zh_TW: 「#」strftime 旗標

en: the ''' printf flag
zh_TW: 「'」printf 旗標

en: the ''' scanf flag
zh_TW: 「'」scanf 旗標

en: the '(' strfmon flag
zh_TW: 「(」strfmon 旗標

en: the '+' printf flag
zh_TW: 「+」printf 旗標

en: the '+' strfmon flag
zh_TW: 「+」strfmon 旗標

en: the '-' printf flag
zh_TW: 「-」printf 旗標

en: the '-' strfmon flag
zh_TW: 「-」strfmon 旗標

en: the '-' strftime flag
zh_TW: 「-」strftime 旗標

en: the '0' printf flag
zh_TW: 「0」printf 旗標

en: the '0' strftime flag
zh_TW: 「0」strftime 旗標

en: the 'E' strftime modifier
zh_TW: 「E」strftime 修飾符

en: the 'I' printf flag
zh_TW: 「I」printf 旗標

en: the 'I' scanf flag
zh_TW: 「I」scanf 旗標

en: the 'O' modifier
zh_TW: 「O」修飾符

en: the 'O' strftime modifier
zh_TW: 「O」strftime 修飾符

en: the '^' strfmon flag
zh_TW: 「^」strfmon 旗標

en: the '^' strftime flag
zh_TW: 「^」strftime 旗標

en: the '_' strftime flag
zh_TW: 「_」strftime 旗標

en: the 'a' scanf flag
zh_TW: 「a」scanf 旗標

en: the 'q' diagnostic flag
zh_TW: 「q」診斷旗標

en: the -shared option is not currently supported for VAX ELF
zh_TW: -shared 選項目前在 VAX ELF 下不受支援

en: the assignment suppression scanf feature
zh_TW: scanf 的取消賦值特性

en: the m210 does not have little endian support
zh_TW: m210 不支援低位位元組在前

en: the mangled name of %qD will change in a future version of GCC
zh_TW: %qD 修飾後的名稱將在 GCC 的未來版本中有變化

en: the offset of %qD may not be ABI-compliant and may change in a future version of GCC
zh_TW: %qD 的偏移量可能與 ABI 不相容，並且可能在 GCC 的未來版本中變更

en: the type being destroyed is %qT, but the destructor refers to %qT
zh_TW: 被解構的類型是 %qT，但解構函式卻使用了 %qT

en: there are no arguments to %qD that depend on a template parameter, so a declaration of %qD must be available
zh_TW: %qD 的引數不依賴範本參數，所以 %qD 的宣告必須可用

en: third argument of %q+D should probably be %<char **%>
zh_TW: %q+D 如果有第三個參數，類型應該是 %<char **%>

en: third argument to %<__builtin_prefetch%> must be a constant
zh_TW: %<__builtin_prefetch%> 的第三個引數必須是一個常數

en: this builtin function is only available on the fr405 and fr450
zh_TW: 此內建函式只在 fr405 和 fr450 上可用

en: this builtin function is only available on the fr450
zh_TW: 此內建函式只在 fr450 上可用

en: this builtin function is only available on the fr500 and fr550
zh_TW: 此內建函式只在 fr500 和 fr550 上可用

en: this decimal constant is unsigned only in ISO C90
zh_TW: 這個小數常數僅 ISO C90 中是無號的

en: this decimal constant would be unsigned in ISO C90
zh_TW: 這個小數常數在 ISO C90 中將是無號的

en: this is the insn:
zh_TW: 這是指令：

en: this media function is only available on the fr400 and fr550
zh_TW: 此多媒體函式只在 fr400 和 fr550 上可用

en: this media function is only available on the fr500
zh_TW: 此多媒體函式只在 fr500 上可用

en: this target machine does not have delayed branches
zh_TW: 此目標平臺沒有延遲轉移指令

en: thread-local COMMON data not implemented
zh_TW: 執行緒區域性的 COMMON 資料沒有實作

en: thread-local declaration of %q+D follows non-thread-local declaration
zh_TW: %q+D 的執行緒局部宣告跟在其非執行緒局部宣告之後

en: throwing NULL, which has integral, not pointer type
zh_TW: 拋出 NULL，它的類型是整數而不是指標

en: tls_model argument must be one of "local-exec", "initial-exec", "local-dynamic" or "global-dynamic"
zh_TW: tls_model 的引數必須是「local-exec」、「initial-exec」、「local-dynamic」或「global-dynamic」其中之一

en: tls_model argument not a string
zh_TW: tls_model 的引數不是一個字串

en: to generate dependencies you must specify either -M or -MM
zh_TW: 要產生依賴項，您必須指定 -M 或 -MM

en: to refer to a type member of a template parameter, use %<typename %E%>
zh_TW: 需要使用某個範本參數的類型成員時，請使用 %<typename %E%>

en: too few arguments to %%:version-compare
zh_TW: %%：version-compare 的引數太少

en: too few arguments to function
zh_TW: 給予函式的引數太少

en: too few arguments to function %<va_start%>
zh_TW: 給函式 %<va_start%> 的參數太少

en: too few arguments to function %qE
zh_TW: 提供給函式 %qE 的引數太少

en: too few template parameter lists in declaration of %qD
zh_TW: %qD 宣告時範本參數表太少

en: too few template-parameter-lists
zh_TW: 範本參數表太少

en: too late for # directive to set debug directory
zh_TW: 使用 # 指示設定除錯目錄太遲

en: too many alternatives in %<asm%>
zh_TW: %<asm%> 中太多變數

en: too many arguments for format
zh_TW: 提供給格式字串的引數太多

en: too many arguments to %%:version-compare
zh_TW: %%：version-compare 的引數太多

en: too many arguments to function
zh_TW: 給予函式的引數太多

en: too many arguments to function %qE
zh_TW: 提供給函式 %qE 的引數太多

en: too many filenames given.  Type %s --help for usage
zh_TW: 給定了太多檔案名稱。試用 %s --help 以了解用法

en: too many initializers for %qT
zh_TW: %qT 的初始值設定項太多

en: too many input files
zh_TW: 輸入檔案太多

en: too many template parameter lists in declaration of %qD
zh_TW: %qD 宣告時範本參數表太多

en: too many template-parameter-lists
zh_TW: 範本參數表太多

en: too much stack space to dispose of: %d
zh_TW: 要捨棄太多的堆疊空間：%d

en: too much stack space to prepare: %d
zh_TW: 要準備太多的堆疊空間：%d

en: top-level declaration of %qs specifies %<auto%>
zh_TW: 在頂層將 %qs 宣告為 %<auto%>

en: total size of local variables exceeds architecture limit
zh_TW: 局部變數大小總和超過架構極值。

en: traditional C rejects automatic aggregate initialization
zh_TW: 傳統 C 不接受自動的聚合初始化

en: traditional C rejects initialization of unions
zh_TW: 傳統 C 不接受對聯合的初始化

en: traditional C rejects string constant concatenation
zh_TW: 傳統 C 不接受字串常數粘貼

en: traditional C rejects the unary plus operator
zh_TW: 傳統 C 不接受單位元 + 運算子

en: trap mode not supported for VAX floats
zh_TW: 陷阱模式不為 VAX 浮點數所支援

en: tree check: %s, have %s in %s, at %s:%d
zh_TW: 樹檢查：%s，得到 %s 在 %s，於 %s:%d

en: tree check: expected class %qs, have %qs (%s) in %s, at %s:%d
zh_TW: 樹檢查：需要類別 %qs，得到 %qs(%s) 在 %s，於 %s:%d

en: tree check: expected none of %s, have %s in %s, at %s:%d
zh_TW: 樹檢查：不需要 %s，得到 %s 在 %s，於 %s:%d

en: try reducing the number of local variables
zh_TW: 試圖減少局部變數的數量

en: try removing the parentheses around the type-id
zh_TW: 請嘗試刪除類型識別碼兩邊的括號

en: try using %qE instead
zh_TW: 嘗試使用 %qE 代替

en: trying to finish struct, but kicked out due to previous parse errors
zh_TW: 試圖完成結構，但為先前的解析錯誤所插斷

en: trying to make class %qT a friend of global scope
zh_TW: 試圖讓 %qT 成為全域欄位的夥伴

en: two or more data types in declaration of %qs
zh_TW: %qs 的宣告指定了兩個以上的資料類型

en: two or more data types in declaration specifiers
zh_TW: 宣告指定了兩個以上的資料類型

en: type %q#T argument given to %<delete%>, expected pointer
zh_TW: %<delete%> 的參數類型應為指標而非 %q#T

en: type %qT is disallowed in Java %<throw%> or %<catch%>
zh_TW: 在 Java %<throw%> 或 %<catch%> 中不能使用類型 %qT

en: type %qT is not a base type for type %qT
zh_TW: 類型 %qT 不是類型 %qT 的基礎類別

en: type %qT is not a direct base of %qT
zh_TW: 類型 %qT 不是 %qT 的直接基礎類別

en: type %qT is not a direct or virtual base of %qT
zh_TW: 類型 %qT 不是 %qT 的直接或虛基礎類別

en: type %qT is not derived from %<java::lang::Throwable%>
zh_TW: 類型 %qT 不是從 %<java::lang::Throwable%> 衍生來的

en: type %qT is not derived from type %qT
zh_TW: 類型 %qT 不是由類型 %qT 衍生的

en: type is deprecated
zh_TW: 類型已過時

en: type is deprecated (declared at %s:%d)
zh_TW: 類型已過時(於 %s:%d 宣告)

en: type mismatch in conditional expression
zh_TW: 條件運算式中類型不匹配

en: type mismatch with previous external decl of %q#D
zh_TW: 類型與先前的 %q#D 的外部宣告不匹配

en: type of %qE is unknown
zh_TW: %qE 的類型不明

en: type of array %q+D completed incompatibly with implicit initialization
zh_TW: 陣列 %q+D 類型與隱含初始化不相容

en: type of asm operand %qE could not be determined
zh_TW: 無法確定 asm 運算元 %qE 的類型

en: type of bit-field %qs is a GCC extension
zh_TW: 位元段類型 %qs 是一個 GCC 擴充

en: type of formal parameter %d is incomplete
zh_TW: 引數 %d 的類型不完全

en: type qualifiers ignored on function return type
zh_TW: 忽略函式回傳類型的類型限定

en: type qualifiers specified for friend class declaration
zh_TW: 為夥伴類別宣告指定了類型限定

en: type to vector delete is neither pointer or array type
zh_TW: 向量 delete 的引數類型既非指標也非陣列

en: type-punning to incomplete type might break strict-aliasing rules
zh_TW: 類型雙關作用在不完全類型上可能破壞強重疊規則

en: type/value mismatch at argument %d in template parameter list for %qD
zh_TW: 引數 %d 的類型/值不匹配，在 %qD 的範本參數清單中

en: typedef %q+D declared %<inline%>
zh_TW: typedef %q+D 宣告為 %<inline%>

en: typedef %qD is initialized (use __typeof__ instead)
zh_TW: typedef %qD 被初始化(改用 __typeof__)

en: typedef declaration invalid in parameter declaration
zh_TW: 參數宣告中出現的 typedef 宣告無效

en: typedef-name %qD used as destructor declarator
zh_TW: typedef 名 %qD 用於解構函式宣告

en: types are not quite compatible
zh_TW: 類型不完全相容

en: unable to emulate %qs
zh_TW: 無法列舉 %qs

en: unable to find a register to spill in class %qs
zh_TW: 在類別 %qs 中找不到可捨出的暫存器

en: unable to generate reloads for:
zh_TW: 無法產生重新載入，為：

en: unable to open dynamic dependency '%s'
zh_TW: 無法開啟動態依賴項「%s」

en: unable to use '%s' for PIC register
zh_TW: 「%s」不能做為 PIC 暫存器

en: unconditional %2d never executed
zh_TW: 無條件 %2d 從未執行

en: unconditional %2d taken %s
zh_TW: unconditional %2d 被執行 %s

en: undefined named operand %qs
zh_TW: 未定義的具名運算元 %qs

en: unexpected base-type in cris_print_base
zh_TW: cris_print_base 中有非預期的基礎類別型

en: unexpected index-type in cris_print_index
zh_TW: cris_print_index 中有非預期的索引類型

en: unexpected multiplicative operand
zh_TW: 無效的乘性運算元

en: unexpected operand
zh_TW: 非預期的運算元

en: unexpected side-effects in address
zh_TW: 位址中有非預期的副作用

en: unimplemented functionality
zh_TW: 未實作的功能

en: unimplemented-shmedia profiling
zh_TW: 未實作 - shmedia 取樣

en: uninitialized const %qD
zh_TW: 未初始化的常數 %qD

en: uninitialized const in %<new%> of %q#T
zh_TW: %<new%> %q#T 時常數未初始化

en: uninitialized const member %qD
zh_TW: 未初始化的常數成員 %qD

en: union cannot be made transparent
zh_TW: 聯合不能成為透明的

en: union has no members
zh_TW: 聯合體沒有成員

en: union has no named members
zh_TW: 聯合包含無名成員

en: unknown -mdebug-%s switch
zh_TW: 不明的 -mdebug-%s 開關

en: unknown CRIS cpu version specification in -mtune= : %s
zh_TW: -mtune= 中不明的 CRIS CPU 版本設定：%s

en: unknown CRIS version specification in -march= or -mcpu= : %s
zh_TW: -march= 或 -mcpu= 中不明的 CRIS CPU 版本設定：%s

en: unknown array size in delete
zh_TW: delete 時陣列大小不明

en: unknown cc_attr value
zh_TW: 不明的 cc_attr 值

en: unknown conversion type character %qc in format
zh_TW: 格式字串中出現無效的類型轉換字元 %qc

en: unknown conversion type character 0x%x in format
zh_TW: 格式字串中出現無效的類型轉換字元 0x%x

en: unknown demangling style '%s'
zh_TW: 不明的解修飾風格「%s」

en: unknown field %qE specified in initializer
zh_TW: 初始值設定項裡有不明的欄位 %qE

en: unknown insn mode
zh_TW: 不明的指令模式

en: unknown move insn:
zh_TW: 無效的 move 指令：

en: unknown register name %qs in %<asm%>
zh_TW: %<asm%> 中出現不明的暫存器名 %qs

en: unknown register name: %s
zh_TW: 不明的暫存器名：%s

en: unknown relocation unspec
zh_TW: 不明的不可預期重定位

en: unnamed initializer for %qT, which has no base classes
zh_TW: 對沒有基礎類別的 %qT 的無名初始化

en: unnamed initializer for %qT, which uses multiple inheritance
zh_TW: 對使用了多繼承的 %qT 的無名初始化

en: unnamed struct/union that defines no instances
zh_TW: 未定義任何實體的無名結構/聯合

en: unnamed variable or field declared void
zh_TW: 無名變數或欄位宣告為 void

en: unordered comparison on non-floating point argument
zh_TW: 非浮點引數間的無效比較

en: unreachable bytecode from %d to before %d
zh_TW: 不會執行到的位元組碼，從 %d 到 %d 之前

en: unreachable bytecode from %d to the end of the method
zh_TW: 不會執行到的位元組碼，從 %d 直到方法末尾

en: unrecognised debug output level "%s"
zh_TW: 無法辨識的除錯輸出層級「%s」

en: unrecognizable insn:
zh_TW: 無法辨識的指令：

en: unrecognized address
zh_TW: 無法辨識的位址

en: unrecognized command line option "%s"
zh_TW: 無法辨識的命令列選項「%s」

en: unrecognized format specifier
zh_TW: 無法辨識的格式限定符

en: unrecognized gcc debugging option: %c
zh_TW: 無法辨識的 gcc 除錯選項：%c

en: unrecognized supposed constant
zh_TW: 預期的常數無法識別

en: unrecoverable error
zh_TW: 不可恢復錯誤

en: unsupported argument to %<__builtin_frame_address%>
zh_TW: %<__builtin_frame_address%> 的引數不受支援

en: unsupported argument to %<__builtin_return_address%>
zh_TW: %<__builtin_return_address%> 的引數不受支援

en: unsupported combination: %s
zh_TW: 不支援的組合：%s

en: unsupported operand size for extended register
zh_TW: 擴充的暫存器不支援的運算元大小

en: unterminated assembly dialect alternative
zh_TW: 未結束的組譯風格指示

en: unterminated format string
zh_TW: 未終止的格式字串

en: unused arguments in $-style format
zh_TW: $ 風格的格式字串中有未使用的引數

en: unused parameter %q+D
zh_TW: 未使用的參數 %q+D

en: unused variable %q+D
zh_TW: 未使用的變數 %q+D

en: unwind tables currently require either a frame pointer or -maccumulate-outgoing-args for correctness
zh_TW: 解捲表目前需要框架指標或 -maccumulate-outgoing-args 來保證正確性

en: upper value in case label range exceeds maximum value for type
zh_TW: case 標籤範圍的上限值比該類型的最大值還要大

en: use #include instead
zh_TW: 改用 #include

en: use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name
zh_TW: 使用 %<%T::%D%> 而不是 %<%T::%D%> 來以限定名指定建構式

en: use %<%T::template %D%> to indicate that it is a template
zh_TW: 使用 %<%T::template %D%> 來表示這是一個範本

en: use -Winvalid-pch for more information
zh_TW: 使用 -Winvalid-pch 以獲得更多資訊

en: use __attribute__ ((vector_size)) instead
zh_TW: 改用 __attribute__ ((vector_size))

en: use of %<complex%> in AltiVec types is invalid
zh_TW: 在 AltiVec 類型中使用 %<complex%> 無效

en: use of %<long double%> in AltiVec types is invalid
zh_TW: 在 AltiVec 類型中使用 %<long double%> 無效

en: use of %<long%> in AltiVec types is deprecated; use %<int%>
zh_TW: 在 AltiVec 類型中使用 %<long%> 已過時；請改用 %<int%>

en: use of %qs in template
zh_TW: 在範本中使用 %qs

en: use of %qs length modifier with %qc type character
zh_TW: 將 %qs 長度修飾符和%qc 類型字元一起使用

en: use of %s and %s together in %s format
zh_TW: 同時使用 %s 和 %s，在 %s 格式字串中

en: use of %s and %s together with %<%%%c%> %s format
zh_TW: 同時使用 %s 和 %s，在 %<%%%c%> %s 格式字串中

en: use of boolean types in AltiVec types is invalid
zh_TW: 在 AltiVec 類型中使用布林類型無效

en: use of class template %qT as expression
zh_TW: 將類別範本 %qT 做為運算式

en: use of enum %q#D without previous declaration
zh_TW: 使用列舉 %q#D 前沒有給出宣告

en: use of namespace %qD as expression
zh_TW: 命名空間 %qD 做為運算式

en: use of old-style cast
zh_TW: 使用舊式的類型轉換

en: use of parameter from containing function
zh_TW: 在包含函式中使用參數

en: used array that cannot be converted to pointer where scalar is required
zh_TW: 需要標量時使用了不能被轉換為指標的陣列

en: used struct type value where scalar is required
zh_TW: 需要標量時使用了結構類型

en: used union type value where scalar is required
zh_TW: 需要標量時使用了聯合類型

en: useless %<__thread%> in empty declaration
zh_TW: 空宣告中 %<__thread%> 無用

en: useless storage class specifier in empty declaration
zh_TW: 空宣告中指定存儲類別無用

en: useless type name in empty declaration
zh_TW: 空宣告中類型名無用

en: useless type qualifier in empty declaration
zh_TW: 空宣告中類型限定無用

en: user-defined %qD always evaluates both arguments
zh_TW: 使用者定義的 %qD 總是計算所有兩個參數

en: using invalid field %qD
zh_TW: 使用無效欄位 %qD

en: using template type parameter %qT after %qs
zh_TW: 使用範本類型參數 %qT，在 %qs 後

en: using typedef-name %qD after %qs
zh_TW: 使用 typedef 名 %qD，在 %qs 後

en: using-declaration for non-member at class scope
zh_TW: 在類別作用欄位使用非成員的 using 宣告

en: value computed is not used
zh_TW: 計算出的值未被使用

en: value of -mfixed-range must have form REG1-REG2
zh_TW: -mfixed-range 值必須有「暫存器1-暫存器2」的形式

en: variable %q#D has initializer but incomplete type
zh_TW: 變數 %q#D 有初始值設定，但是類型不完全

en: variable %q+D declared %<inline%>
zh_TW: 變數 %q+D 宣告為 %<inline%>

en: variable %q+D definition is marked dllimport
zh_TW: 變數 %q+D 的定義被標記為 dllimport

en: variable %q+D might be clobbered by %<longjmp%> or %<vfork%>
zh_TW: 變數 %q+D 能為 %<longjmp%> 或 %<vfork%> 所篡改

en: variable %qD has initializer but incomplete type
zh_TW: 變數 %qD 有初始值設定但類型不完全

en: variable or field %qE declared void
zh_TW: 變數或欄位 %qE 宣告為 void

en: variable or field declared void
zh_TW: 變數或欄位宣告為 void

en: variable previously declared %<static%> redeclared %<extern%>
zh_TW: 先前被宣告為 %<static%> 的變數重宣告為 %<extern%>

en: variable-sized object %qD may not be initialized
zh_TW: 可變大小的物件 %qD 不能被初始化

en: variable-sized object may not be initialized
zh_TW: 可變大小的物件不能被初始化

en: vector overflow in expression
zh_TW: 向量浮點溢出

en: verification failed at PC=%d: %s
zh_TW: PC=%d 處校驗錯：%s

en: verification failed: %s
zh_TW: 驗證失敗：%s

en: verify_cgraph_node failed
zh_TW: verify_cgraph_node 失敗

en: verify_eh_tree failed
zh_TW: verify_eh_tree 失敗

en: verify_flow_info failed
zh_TW: verify_flow_info 失敗

en: verify_flow_info: Duplicate edge %i->%i
zh_TW: verify_flow_info：重複的邊 %i->%i

en: verify_flow_info: Incorrect blocks for fallthru %i->%i
zh_TW: verify_flow_info：不正確的區塊直通 %i->%i

en: verify_flow_info: Incorrect fallthru %i->%i
zh_TW: verify_flow_info：不正確的直通 %i->%i

en: verify_flow_info: REG_BR_PROB does not match cfg %wi %i
zh_TW: verify_flow_info：REG_BR_PROB 不匹配 cfg %wi %i

en: verify_flow_info: Wrong count of block %i %i
zh_TW: verify_flow_info：塊 %i %i 計數錯

en: verify_flow_info: Wrong count of edge %i->%i %i
zh_TW: verify_flow_info：邊 %i->%i %i 計數錯

en: verify_flow_info: Wrong frequency of block %i %i
zh_TW: verify_flow_info：塊 %i %i 頻率錯

en: verify_flow_info: Wrong probability of edge %i->%i %i
zh_TW: verify_flow_info：邊 %i->%i %i 概率錯

en: verify_ssa failed
zh_TW: verify_ssa 失敗

en: virtual base %qT inaccessible in %qT due to ambiguity
zh_TW: 由於存在歧義，虛基礎類別 %qT 在 %qT 中無法存取

en: virtual functions cannot be friends
zh_TW: 虛函式不能是夥伴

en: virtual non-class function %qs
zh_TW: 虛函式 %qs 不是類別成員

en: visibility argument must be one of "default", "hidden", "protected" or "internal"
zh_TW: visibility  的引數必須是「default」、「hidden」、「protected」或「internal」其中之一

en: visibility argument not a string
zh_TW: visibility 的引數不是一個字串

en: visibility attribute not supported in this configuration; ignored
zh_TW: 可見性屬性在此配置下不受支援；已忽略

en: void value not ignored as it ought to be
zh_TW: void 值未如預期地被忽略

en: vtable layout for class %qT may not be ABI-compliantand may change in a future version of GCC due to implicit virtual destructor
zh_TW: 由於隱含的虛解構函式，類別 %qT 的 vtable 版面設置可能與 ABI 不相容，並且可能在 GCC 的未來版本中變更

en: warning:
zh_TW: 警告：

en: weak declaration of %q+D must be public
zh_TW: %q+D 的弱宣告必須是公共的

en: weak declaration of %q+D not supported
zh_TW: 不支援 %q+D 的弱宣告

en: weakref %q+D ultimately targets itself
zh_TW: weakref %q+D 最終參照其自身

en: when writing output to %s: %m
zh_TW: 當寫入輸出到 %s 時：%m

en: wide string literal in %<asm%>
zh_TW: %<asm%> 中出現寬字面字串

en: width of %q+D exceeds its type
zh_TW: %q+D 的寬度超過了它的類型

en: width of %qs exceeds its type
zh_TW: %qs 的寬度超過它自身的類型

en: will be assumed to return %<id%> and accept
zh_TW: 將被假定為回傳 %<id%> 並接受

en: with %q+#D
zh_TW: 與 %q+#D

en: within this context
zh_TW: 在此上下文中

en: writing into constant object (argument %d)
zh_TW: 對常數物件的寫作業(引數 %d)

en: writing through null pointer (argument %d)
zh_TW: 對空指標參照內容的寫作業(引數 %d)

en: wrong amount of branch edges after unconditional jump %i
zh_TW: 非條件跳轉 %i 之後的分支邊數不正確

en: wrong edge %d->%d for PHI argument
zh_TW: PHI 參數邊 %d->%d 錯誤

en: wrong immediate use list
zh_TW: 錯誤的 immediate use 清單

en: wrong insn in the fallthru edge
zh_TW: 直通邊上的錯誤指令

en: wrong number of template arguments (%d, should be %d)
zh_TW: 範本參數數目不正確(不應是 %d 個而應是 %d 個)

en: wrong type argument to abs
zh_TW: 不能對該類型的引數求絕對值

en: wrong type argument to bit-complement
zh_TW: 按位取反的引數類型錯誤

en: wrong type argument to conjugation
zh_TW: 不能對該類型的引數求共軛

en: wrong type argument to decrement
zh_TW: 該類型的引數不能自減

en: wrong type argument to increment
zh_TW: 該類型的引數不能自增

en: wrong type argument to unary exclamation mark
zh_TW: 單位元 ! 的引數類型無效

en: wrong type argument to unary minus
zh_TW: 單位元減的運算元類型錯誤

en: wrong type argument to unary plus
zh_TW: 單位元加的運算元類型錯誤

en: xstormy16_print_operand: unknown code
zh_TW: xstormy16_print_operand：不明程式碼

en: z/Architecture mode not supported on %s
zh_TW: z/Architecture 模式在 %s 上不受支援

en: zero or negative size array %q+D
zh_TW: 陣列 %q+D 大小為 0 或負

en: zero width for bit-field %q+D
zh_TW: 位元段 %q+D 寬度為 0

en: zero width for bit-field %qs
zh_TW: 位元段 %qs 寬度為 0

en: zero width in %s format
zh_TW: %s 格式字串中欄位寬為 0

en: zero-length %s format string
zh_TW: 格式字串 %s 長度為 0

en: zero-size array %qD
zh_TW: 大小為 0 的陣列 %qD
