## #error

`#error` 指令があります。指令中のほかのトークンが、メッセージの一部として 出力されます。 このメッセージを生成するコードの例を次に示します。

    #define ONE 2
    #if ONE != 1
    #error ONE != 1
    #endif

メッセージ ID: E_ERROR_PRAGMA

## 前のエラーから回復できません。

コンパイル中に発生したエラーが原因となって、プログラムの処理を継続できません。エラーを修正して、再度実行してください。

メッセージ ID: E_CANNOT_RECOVER

## 出力ファイルを閉じることができません。

コンパイラが標準出力を閉じようとした時に、ファイルシステムエラーが発生しました。 これは、ソースプログラムのエラーではありません。

メッセージ ID: E_FCLOSE_ERR

## .ll ファイルを閉じることができません。

コンパイラが lock_lint のデータベースファイル (.ll) を 閉じる時に、ファイルシステムエラーが発生しました。

メッセージ ID: E_FCLOSE_LL_ERR

## ファイルを開くことができません。別の名前でファイルが作成されました。

コンパイラが .ll ファイルを作成することができません。ファイルシステムエラー、あるいは、ディレクトリまたはファイルのパーミッションが正しくないことが原因と考えられます。

メッセージ ID: E_CANT_CREATE_LL_FILE

## ファイル名のためのメモリーを割り当てられません。

コンパイラが malloc() を内部で使用することができません。ほとんどの場合、スワップ領域が不足していることが原因です。

メッセージ ID: E_CANT_MALLOC_FILENAME

## メモリー不足

プログラムをコンパイルするのに必要なメモリーを確保することができません。ほとんどの場合、スワップ領域が不足していることが原因です。

メッセージ ID: E_OUT_OF_MEMORY

## 標準出力を /dev/null に freopen できません。

コンパイラが出力ファイルを /dev/null にリダイレクトしようとした時に、ファイルシステムエラーが発生しました。

メッセージ ID: E_CANT_FREOPEN_STDOUT

## 浮動小数点定数の演算によって例外が発生しました。

コンパイル中に、2 つの浮動小数点オペランド間で演算を行おうとした時に、オーバーフローが発生しました。演算によって浮動小数点例外が発生するため、コンパイルを停止します。

メッセージ ID: E_FP_CONST_CAUSE_EXCEPT

## ファイル名のためのメモリーを割り当てられません。

コンパイラが malloc() を内部で使用することができません。ほとんどの場合、スワップ領域が不足していることが原因です。

メッセージ ID: E_CANT_MALLOC_TMP_FILENAME

## ファイルを作成できません。

ファイルシステムエラーによって、コンパイラが .ll ファイルを 作成できません。 現在のディレクトリに書き込み権があることを確認してください。

メッセージ ID: E_CANT_OPEN_LL_FILE

## /dev/null に freopen できません。

コンパイラが、lock_lint のデータベースファイルを破棄できません。

メッセージ ID: E_CANT_FREOPEN_LL_DEV_NULL

## #include のあとの ">" が抜けています。

ヘッダー名が < で始まる `#include` 指令に、右括弧 > がありません このメッセージを生成するコードの例を次に示します。

    #include <stdio.h

メッセージ ID: E_INCLUDE_MISSING

## コメント内に /* があります。

このメッセージは、`-v` オプションを指定している場合に表示されます。コメント中に、/* が使用されています。 このメッセージを生成するコードの例を次に示します。

    /*	これはコメント中に
    	/* が使用されている
    	コメント例です。
    */

メッセージ ID: E_SLASH_STAR_IN_CMNT

## コメントの途中でファイルが終了しています。

コメントの読み取り中に、ファイルの終端 (EOF) に達しました。

メッセージ ID: E_EOF_IN_COMMENT

## 指令中に無効な空白文字があります。

プリプロセッサ (前処理系) 指令において使用できる空白文字は、スペースと水平タブだけです。ソースコード中で、用紙送り文字や垂直タブなどの空白文字が使用されています。コンパイラは、これらの文字をスペースと同様に扱います。

メッセージ ID: E_WHITE_SPACE_IN_DIRECTIVE

## 文字列リテラル中に改行文字があります。

文字列リテラルが二重引用符 " で囲まれていません (末尾の " がありません)。プリプロセッサ指令中で文字列リテラルを使用している場合は警告となり、コンパイラによって末尾に二重引用符 " が補われます。プリプロセッサ指令中以外で使用されている場合は、エラーになります。 このメッセージを生成するコードの例を次に示します。

    char *p = "abc
    ;

メッセージ ID: E_NEWLINE_IN_STR_LITERAL

## #line 指令として解釈されました。

このメッセージは、`-Xc` オプションを指定している場合に表示されます。ソース行中で、指令名を指定すべきところに番号が使用されています。このような行は、コンパイラの内部処理用として予約されていますが、`-Xc` オプション (完全準拠モード) を指定している場合には、警告が出力されます。 このメッセージを生成するコードの例を次に示します。

    # 9

メッセージ ID: E_INTERPRETED_AS_LINE_DIRECTIVE

## 無効な指令

プリプロセッサ指令行中の # のあとに続く識別子を認識できません。 このメッセージを生成するコードの例を次に示します。

    # unknown foo

メッセージ ID: E_INVALID_DIRECTIVE

## ".i" ファイル中に無効なコンパイラ制御行があります。

`cc -P` コマンドの実行結果として生成される `.i` ファイルは前処理とコンパイル処理の中間段階のファイルとして予約されています。`.i` ファイルを確認することによって、通常検出しにくいエラーを検出することができます。ただし、コンパイラが検出できるのは、内部処理で使用される特殊な指令に限られます。コンパイルされたソースファイル (`.i` ファイル) には、特殊な指令以外にプリプロセッサ指令が含まれています。

メッセージ ID: E_BAD_COMP_CNTRL_LINE

## 指令は上位互換性がある ANSI C の拡張機能です。

このメッセージは、`-Xc` オプションを指定している場合に表示されます。 ANSI C 標準以外の指令のうち、サポート対象となる指令を確認し、`-Xc` が指定されているかどうかをチェックします。 このメッセージを生成するコードの例を次に示します。

    #assert system( unix )

メッセージ ID: E_UP_COMPATIBLE_DIRECTIVE

## マクロ引数リスト中の指令は認識されません。

関数形式のマクロ呼び出しで、引数リストを区切る括弧 ( ) の間に指令があります。このようなコンテキストでは、以下の指令は使用できません。`#ident, #include, #line, #undef.` `if` 節中の偽のブロック中でこのメッセージが表示される場合は警告です。その他の場合はエラーです。 このメッセージを生成するコードの例を次に示します。

    #define flm(a) a+4
    int i = flm(
    #ifdef flm	/* 可 */
    	#undef flm	/* 不可:  エラー */
    	4
    #else	/* 可 */
    	#undef flm/* 不可:  警告 */
    	6
    #endif	/* 可 */
    );

メッセージ ID: E_DIRECTIVE_IN_MACRO_LIST

## #file のあとには文字列リテラルが必要です。

前処理とコンパイル処理との中間段階の内部処理に、#`file` 指令が使用されています。この指令は、コンパイルシステム用に予約されています。オペランドには文字列リテラルが必要です。

メッセージ ID: E_FILE_MISSING_LITERAL

## #ident のあとには文字列リテラルが必要です

#`ident` 指令のあとには、通常の (ワイド文字ではない) 文字列リテラルを続ける必要があります。 このメッセージを生成するコードの例を次に示します。

    #ident no-string

メッセージ ID: E_IDENT_MISSING_LITERAL

## 読み取りエラー

コンパイラが入力ファイルを読み取ることができません。ファイルシステムエラーが原因と考えられます。通常、このエラーはインクルードファイルに対して出力されます。

メッセージ ID: E_READ_ERROR

## エラーが多すぎます。

コンパイルエラーが多すぎて、以降の処理を継続できません。以降のエラーを出力せずに、コンパイルを停止します。

メッセージ ID: E_TOO_MANY_ERRS

## malloc() が失敗しました。

コンパイラ内部で malloc() 呼び出しが失敗しました。ほとんどの場合、スワップ領域が不足していることが原因です。

メッセージ ID: E_MALLOC_FAILS

## realloc() が失敗しました。

コンパイラ内部で realloc() 呼び出しが失敗しました。ほとんどの場合、スワップ領域が不足していることが原因です。

メッセージ ID: E_REALLOC_FAILS

## ファイルを開けません。

入力ファイルまたは出力ファイルを開くことができません。`cc` に指定した引数 (すなわちファイル名) が正しくないと考えられます。メッセージ中に、ファイルを開くことができない理由が示されます。 このメッセージを生成するコードの例を次に示します。

    cc badname.c -c x.c

メッセージ ID: E_CANNOT_OPEN

## マクロの再帰的呼び出し

このメッセージは、`-Xt` オプションを指定している場合に致命的エラーが発生すると表示されます。ソースコードでは、マクロが直接または間接のいずれかの形式で再帰的に呼び出されます。ANSI C の制限によって、マクロの再走査は続行されません。以前の C コンパイラでは、マクロの再走査が続行され、その結果致命的エラーが発生します。 ANSI C と従来の C コンパイラでは再走査の規則が異なります。ANSI C コンパイラで `-Xt` オプションを指定すると、従来の C コンパイラの動作がサポートされ、マクロが再帰的に呼び出された時には、このメッセージが出力されます。 このメッセージを生成するコードの例を次に示します。

    #define a(x) b(x)
    #define b(x) a(x)
    a(3)

メッセージ ID: E_MACRO_RECURSION

## 入力中に NULL 文字がある

NULL 文字 (文字コードがゼロの文字) があります。

メッセージ ID: E_NULL_CHAR_INPUT

## 3 文字表記シーケンスが置き換えられました。

このメッセージは、`-Xt` オプションを指定している場合に表示されます。ANSI C では、3 つの文字で 1 文字を表す 3 文字表記シーケンスがサポートされています。3 文字表記シーケンスはすべて、`??` で始まります。. 3 文字表記として解釈されるシーケンスは、既存のコードでも使用されている可能性があるので、K&R C コンパイラでは、移行措置としてメッセージが出力されます。 このメッセージを生成するコードの例を次に示します。

    char *surprise = "3 文字表記シーケンス ??!";

メッセージ ID: E_TRIGRAPH_REPLACED

## ファイルの最後に改行文字がありません。

空でないソースファイル、およびヘッダーは完全行で構成されている必要があります。 ファイルの最終行が改行文字で終わっていない場合に出力されるメッセージです。

メッセージ ID: E_NEWLINE_NOT_LAST

## マクロの引数リスト中に EOF があります。

関数形式のマクロを呼び出すために引数を読み取っている間に、ファイルの終わり (EOF) に達しました。 このメッセージを生成するコードの例を次に示します。

    #define mac(a)
    mac( arg1

メッセージ ID: E_EOF_IN_MACRO_ARG

## #error 指令中に無効なトークンがあります。

`#error` 指令中のトークンは、有効な C のトークンにする必要があります。 ソースプログラムに無効なトークンが含まれています。 このメッセージを生成するコードの例を次に示します。

    #error 038 - this is an invalid token

メッセージ ID: E_BAD_TOKEN_IN_ERROR_DIRECTIVE

## インクルードファイルを開けません (開いているファイルが多すぎます)。

すでに、多数の `include` ファイルが開いているので、新しい `include` ファイルを開くことができません。コンパ イラでは、最低 8 レベルでオペレーティングシステムで定義されている同時に開くことのできる最大ファイル数がサポートされます。このメッセージが出力される一般的な原因として、ある `include` ファイルの中にすでに取り込まれているファイルを、ある時点で再度取り込もうとしていると考えられます。

メッセージ ID: E_CANT_OPEN_INCLUDE_FILE

## インクルードファイルが見つかりません。

`#include` 指令で指定されたファイルが、検索パス上のディレクトリにありません。 このメッセージを生成するコードの例

    #include "where_is_it.h"

メッセージ ID: E_CANT_FIND_INCLUDE_FILE

## 無効なトークンがあります。

無効なトークンが含まれている文字列があります。前処理用の ## 演算子が無効なトークンの原因になっている可能性があります。無効なトークンは、メッセージ中に表示されます。無効なトークンが 21 文字以上である場合は、最初の 20 文字だけが出力され、以降は ". . ." と表示されます。なお、無効なトークンは無視されて処理されません。 このメッセージを生成するコードの例を次に示します。

    #define PASTE(l,r) l ## r
    double d1 = 1e;
    double d2 = PASTE(1,e);
    int i = 1veryverylongnontoken;

メッセージ ID: E_INVALID_TOKEN

## 無効な入力トークンがあります。

C 言語の有効なトークンとして認識できない文字列があります。 このメッセージを生成するコードの例を次に示します。

    int i = 1$;

メッセージ ID: E_INVALID_INPUT_TOKEN

## #define マクロのパラメータ中に無効なトークンがあります。

関数形式のマクロ定義に対する引数リストの処理中に、不適切なトークンがあります。 このメッセージを生成するコードの例を次に示します。

    #define mac(a,4) a b c

メッセージ ID: E_INVALID_TOKEN_IN_DEFINE_MACRO

## 指令中に無効なトークンがあります。

指令の最後の位置に、無効なトークンがあります。この無効なトークンがなければ有効な指令になります。 このメッセージを生成するコードの例を次に示します。

    #line 7 "file.c

メッセージ ID: E_INVALID_TOKEN_IN_DIRECTIVE

## トークンは指令では許可されません。

#`if` 指令、または #`elif` 指令において、定数式の演算子としても整数定数としても有効でないトークンが使用されています。 このメッセージを生成するコードの例を次に示します。

    #if 1 > "1"
    	int i = 1;
    #endif

メッセージ ID: E_TOKEN_ILLEGAL_IN_DIRECTIVE

## "defined" 演算子の使用法が正しくありません。

`#if` 指令、または `#elif` 指令中の defined 演算子の後には、識別子または括弧 ( ) で囲んだ識別子を続ける必要があります。ソースコードはこのような方法に従っていません。 このメッセージを生成するコードの例を次に示します。

    #if defined
    int i = 1;
    #endif

メッセージ ID: E_INVALID_USE_OF_DEFINE

## 引数の不一致

マクロに渡される引数の数が、マクロ定義中の個数と一致しません。 このメッセージを生成するコードの例を次に示します。

    #define twoarg(a,b) a+b
    int i = twoarg(4);

メッセージ ID: E_ARGUEMENT_MISMATCH

## マクロの引数にトークンがありません。

プリプロセッサマクロに対する実引数に、トークンが含まれていません。ANSI C 標準では、このような状態は未定義と認識されます。従来の C コンパイラでは、空のトークンリストを引数なしとして扱います。このメッセージは、 `-Xc` オプションを指定した場合にも表示されます。 このメッセージを生成するコードの例を次に示します。

    #define m(x) x+3
    int i = m();

メッセージ ID: E_TOKENLESS_MACRO

## 無効なターゲットファイル名

コンパイラの内部エラーです。

メッセージ ID: E_INVALID_TARGET_FILENAME

## #include 指令にファイル名が指定されていません。

`#include` 指令で、取り込むファイルが指定されていません。 このメッセージを生成するコードの例を次に示します。

    #include

メッセージ ID: E_INCLUDE_MISSING_FILENAME

## 展開後にファイル名がありません。

引数をマクロ展開できる、`#include` 指令を使用していますが、展開の結果、ファイル名として有効なトークンが得られません。 このメッセージを生成するコードの例を次に示します。

    #define EMPTY
    #include EMPTY

メッセージ ID: E_INCLUDE_EXPANSION_NO_FILE

## ファイル名が指定されていません。

`#include` 指令中にファイル名が指定されていません。 このメッセージを生成するコードの例を次に示します。

    #include <>

メッセージ ID: E_EMPTY_FILE_NAME

## ヘッダー名が指定されていません。

マクロ置換後のファイル名が指定されていません。 このメッセージを生成するコードの例を次に示します。

    #define NULLNAME  <>
    #include NULLNAME

メッセージ ID: E_EMPTY_HEADER_NAME

## 閉じる > がありません。

`#include` 指令に > がありません。 このメッセージを生成するコードの例を次に示します。

    #include " が必要 */

メッセージ ID: E_NO_CLOSING_GREATER_THAN

## ファイルの指定方法が正しくありません。

`#include` 指令中のファイル指示子が正しくありません。文字列リテラルまたは正しい書式のヘッダー名にする必要があります。 このメッセージを生成するコードの例を次に示します。

    #include stdio.h

メッセージ ID: E_BAD_FILE_SPEC

## # <番号> 指令では 0 は無効です。

行番号指令で指定する行番号 (コンパイラが内部処理で使用) は、ゼロ以外の正の数値にする必要があります。 このメッセージを生成するコードの例を次に示します。

    # 0 "foo.c"

メッセージ ID: E_ZERO_INVALID_IN_POUND_NUMBER

## #line 指令では 0 は無効です。

`#line` 指令で指定する行番号 (コンパイラが内部処理で使用) は、ゼロ以外の正の数値にする必要があります。 このメッセージを生成するコードの例を次に示します。

    #line 0

メッセージ ID: E_ZERO_INVALID_IN_POUND_LINE

## # <番号> 指令のあとには文字列リテラルが必要です。

文字列リテラルが # < number > 指令のあとに必要です。 このメッセージを生成するコードの例を次に示します。

    #15 notstring

メッセージ ID: E_STRING_EXPECTED_POUND_NO

## string literal expected after #line < number >

#`line` 指令のあとには、文字列リテラルを続ける必要があります。 このメッセージを生成するコードの例を次に示します。

    #line 12 int

メッセージ ID: E_STRING_EXPECTED_POUND_LINE_NO

## "#" のあとには識別子または 10 進数が必要です。

プリプロセッサ指令行の先頭にある # のあとに、無効なトークンまたは 10 進以外の数値が指定されています。 このメッセージを生成するコードの例を次に示します。

    #0x12

メッセージ ID: E_POUND_NUMBER_EXPECTED

## #line のあとには 10 進数が必要です。

`#line` のあとの行番号を表わす 10 進数を探しましたが、検出されたトークンが不適切であるか、または値がゼロの数になっています。 このメッセージを生成するコードの例を次に示します。

    #line 09a

メッセージ ID: E_POUND_LINE_NO_EXPECTED

## #line 指令にトークンがありません。

`#line` 指令の残りの部分が空白です。 行番号、およびオプションのファイル名が指定されていません。 このメッセージを生成するコードの例を次に示します。

    #line

メッセージ ID: E_NO_TOKENS_IN_POUND_LINE

## 展開後にトークンがありません。

`#line` 指令中の式をマクロ展開しましたが、行番号として解釈されるトークンがありません。 このメッセージを生成するコードの例を次に示します。

    #define EMPTY
    #line EMPTY

メッセージ ID: E_NO_TOKENS_AFTER_EXPANSION

## 仮引数の重複

関数形式のマクロ定義で、name が仮引数として複数回使用されています。 このメッセージを生成するコードの例を次に示します。

    #define add3(a,a,c) a + b + c

メッセージ ID: E_DUPLICATE_FORMAL_PARAM

## マクロが再定義されています。

ソースコードで、マクロが再定義されています。K&R C の以前のリリースでは、仮引数の順序とスペルを除いて、両方の定義が同じであれば、再定義することができました。ANSI C でマクロを正しく再定義するには、仮引数の順序とスペルも含めて、両方の定義が完全に一致している必要があります。このメッセージは、指定したオプションに関係なく、両方の定義が一致していない場合に出力されます。また `-Xc` オプションを使用している場合には、仮引数のスペルが一致しないだけでも、このメッセージが出力されます。 このメッセージを生成するコードの例を次に示します。

    #define TIMES(a,b) a * b
    #define TIMES(a,b) a - b

メッセージ ID: E_MACRO_REDEFINED

## 文字定数中に複数の文字があります。

文字定数の整数としての値は、その文字の文字コードから取得します。文字定数が複数の文字で構成される場合、余分な文字をどう扱うかはインプリメンテーションによって異なります。このメッセージは、本リリースの C コンパイラと旧リリースのコンパイラとでは、前処理において文字定数に適用される値の決定の方式が異なることを示しています。旧リリースでは、最初の文字だけが使用されます。実行可能コードにおける文字定数の値は変更されません。 このメッセージを生成するコードの例を次に示します。

    #if 'ab' != ('b' * 256 + 'a')
    #error unknown encoding
    #endif

メッセージ ID: E_MULTI_CHAR_CHAR_CONST

## オペランドが符号なしとして処理されました。

このメッセージは、`-Xt` オプションを指定している場合に表示されます。`#if` 指令、または `#elif` 指令で使用したオペランドの値が、`LONG_MAX` (2147483647) を超えていますが、`unsigned` (符号なし) の接尾辞 (U) が付いていません。K&R C の以前のリリースでは、このような定数は、`signed` (符号つき) として解釈されていました (このため、実際には負の数になります)。ANSI C では `unsigned` の long int として扱うので、式の解釈に影響がある場合があります。このメッセージは、リリースの移行措置として表示され、旧リリースとは異なる方法で値が扱われることに注意をうながします。 このメッセージを生成するコードの例を次に示します。

    #if 2147483648 > 0
    	char *mesg = "ANSI C 形式";
    #endif

メッセージ ID: E_OPERAND_TREATED_AS_UNSIGNED

## #include で /usr/include/... を指定すると、移植性がなくなる可能性があります。

ソースファイルがインクルードするファイル名の指定で、`/usr/include` ディレクトリが記述されています。 このようなインクルード方法は、インプリメンテーションに依存するので、移植することができません。ヘッダーファイルを検索するデフォルトの場所のリストに `/usr/include` ディレクトリが含まれないシステムもあります。この場合は、違うファイルがインクルードされる可能性があります。 このメッセージを生成するコードの例を次に示します。

    #include

メッセージ ID: E_INC_USR_INC_MAY_NOT_PORTABLE

## 指令に対応する #endif がありません。

コンパイラが、 `#if, #elif, #else, #ifdef`、または `#ifndef` 指令に対する、#endif に到達しないまま、ソースファイルの末尾に到達しました。 このメッセージを生成するコードの例を次に示します。

    #ifndef STUB
    	TranslationEntry* pageTable = NULL;
      /* ここ以降から、コンパイラは #endif を探す */
    #ifdef CHANGED
    	int newfuntion(int a);
    #endif  /* この #endif は、#ifdef に対応 */
      /* さらにコンパイラは #endif を探す */
      /* この行以降にも #endif はない */

メッセージ ID: E_NO_MATCHING_ENDIF

## #elif より前に #if がありません。

`#elif` 指令は、`#if` 指令で始まる前処理の `if` 節中になければなりません。該当するコードに、 `#if` 指令がありません。 このメッセージを生成するコードの例を次に示します。

    #elif defined(TWO)
    	int i = 2;
    #endif

メッセージ ID: E_ELIF_MISSING_IF

## #elif のあとには定数式が必要です。

`#elif` 指令のあとに式がありません。 このメッセージを生成するコードの例を次に示します。

    #if defined(ONE)
    	int i = 1;
    #elif
    	int i = 4;
    #endif

メッセージ ID: E_ELIF_REQUIRES_CONST_EXP

## #elif が # else のあとにあります。

前処理の `if` 節は、 `#if`、`#elifs` (省略可)、`#else` (省略可)、最後に `#endif` の順に構成する必要があります。 `#else` 指令のあとに `#elif` が使用されています。 このメッセージを生成するコードの例を次に示します。

    #if
    defined(ONE)
    	int i = 1;
    #elif defined(TWO)
    	int i = 2;
    #else
    	int i = 3;
    #elif defined(FOUR)
    	int i = 4;
    #endif

メッセージ ID: E_ELIF_FOLLOWS_ELSE

## #else より前に #if がありません。

前処理の `if` 節以外の位置に、`#else` 指令があります。 このメッセージを生成するコードの例を次に示します。

    #else
    	int i =7;
    #endif

メッセージ ID: E_ELSE_MISSING_IF

## #else が多すぎます

前処理の `if` 節中に、複数の #`else` 指令が使用されています。2 つ目以降の #else 指令は偽と評価されます。 このメッセージを生成するコードの例を次に示します。

    #ifdef ONE
    	int i = 1;
    #else
    	int i = 2;
    #else
    	int i = 3
    #endif

メッセージ ID: E_TOO_MANY_ELSES

## #endif より前に #if がありません。

前処理の `if` 節以外の位置に `#endif` 指令があります。 このメッセージを生成するコードの例を次に示します。

    	int i = 1;
    #endif

メッセージ ID: E_IFLESS_ENDIF

## #if のあとには定数式が必要です。

`#if` 指令のあとに式がありません。 このメッセージを生成するコードの例を次に示します。

    #if
    	int i = 4;
    #endif

メッセージ ID: E_IF_REQUIRES_CONST_EXP

## #ifdef のあとには識別子が必要です。

`#ifdef` プリプロセッサ指令のあとにマクロ名を続けて、定義されているかどうかを検査できるようにする必要があります。ソースコードで、識別子が指定されていません。`#ifdef` は、偽であるとして扱われます。 このメッセージを生成するコードの例を次に示します。

    #ifdef
    	int i = 1;
    #endif

メッセージ ID: E_IFDEF_REQUIRES_IDENTIFIER

## #ifndef のあとには識別子が必要です。

`#ifndef` 指令のあとに識別子を続けて、定義されているかどうかを検査できるようにする必要があります。 このメッセージを生成するコードの例を次に示します。

    #ifndef
    	int i = 5;
    #endif

メッセージ ID: E_IFNDEF_REQUIRES_IDENTIFIER

## .i ファイルの前処理中

-P オプションを使用している時に、.i ファイルを指定しています。 以下に例を示します。 cc -P tst.i

メッセージ ID: E_PREPROCESSING_DOT_I_FILE

## 標準出力 (stdout) の入出力エラー

コンパイラが標準出力 (stdout) にアクセスしている時に、ファイルシステムエラーが発生しました。

メッセージ ID: E_STDOUT_ERROR

## 標準エラー出力 (stderr) の入出力エラー

コンパイラが標準エラー (stderr) にアクセスしている時に、ファイルシステムエラーが発生しました。

メッセージ ID: E_STDERR_ERROR

## 空の #assert 指令

`#assert` 指令において、述語名が指定されていません。 このメッセージを生成するコードの例を次に示します。

    #assert

メッセージ ID: E_EMPTY_ASSERT_DIRECTIVE

## "#assert 識別子" が必要です。

`#assert` 指令において、指令のあとに続くトークンが述語名になっていません。 このメッセージを生成するコードの例を次に示します。

    #assert 5

メッセージ ID: E_ASSERT_IDENTIFIER_EXPECTED

## "#assert 識別子 (..." が必要です。

`#assert` 指令において、述語のあとに括弧 ( がありません。 このメッセージを生成するコードの例を次に示します。

    #assert system unix

メッセージ ID: E_ASSERT_ID_DOT_DOT_EXPECTED

## "#assert 名前 (" のあとにトークンがありません。

`#assert` 指令の書式が正しくありません。指令のあとに表明と右括弧 ) がありません。 このメッセージを生成するコードの例を次に示します。

    #assert system(

メッセージ ID: E_NO_TOKENS_AFTER_ASSERT_NAME

## 括弧の間にトークンがありません。

`#assert` 指令において、述語の括弧中に表明がありません。 このメッセージを生成するコードの例を次に示します。

    #assert system()

メッセージ ID: E_ASSERT_NO_TKNS_BETWEEN_PARENS

## "#assert" 指令に ")" がありません。

`#assert` 指令において、表明の指定に必要な右括弧 ) がありません。 このメッセージを生成するコードの例を次に示します。

    #assert system(unix

メッセージ ID: E_ASSERT_MISSING_PAREN

## -A- のあとのトークンは無視されます。

`cc` コマンドの -A- オプションで、オプションのあとに余分なトークンがあります。このトークンは無視されます。 このメッセージを生成するコードの例を次に示します。

    cc -A-extra -c x.c

メッセージ ID: E_TOKENS_AFTER_A_IGNORED

## -A のあとには識別子または "-" が必要です。

`cc` コマンド行の引数 `-A` のあとには、表明する述語名を指定するか、定義済みのすべてのマクロおよび述語を削除する場合には - を付ける必要があります。 `-A` のあとのトークンはこのどちらにも該当しません。 このメッセージを生成するコードの例を次に示します。

    cc -A3b2 -c x.c

メッセージ ID: E_IDENTIFIER_EXPECTED_AFTER_A

## "#" のあとには識別子が必要です。

条件付きコンパイル指令中の # のあとに、識別子または述語名のいずれも指定されていません。 このメッセージを生成するコードの例を次に示します。

    #if #system(unix) || #
    	char *os = "sys";
    #endif

メッセージ ID: E_IDENT_EXPECTED_AFTER_POUND

## "# 識別子" のあとには "(" が必要です。

`#if` または `#elif` 指令において、# 演算子を使用して、名前定義されたようなマクロではなく述語を選択するには、述語のあとに括弧で囲んだトークンのリストを続ける必要があります。 このメッセージを生成するコードの例を次に示します。

    #assert system(unix)
    #define system "unix"
    #if #system
    	char *systype = system;
    #endif

メッセージ ID: E_PAREN_EXPECTED_AFTER_ID_PND

## "# identifier (" のあとにはトークンが必要です。

#`if` または #`elif` 指令において、# 演算子を使用して、名前定義されたようなマクロの代わりに述語を選択する場合は、述語のあとに括弧で囲んだトークンのリストを続ける必要があります。 このメッセージを生成するコードの例を次に示します。

    #if #system(
    	char *system = "unix";
    #endif

メッセージ ID: E_TOKENS_EXPECTED_AFTER_ID_PND

## 括弧の間にはトークンが必要です。

テストする述語の表明で使用した名前が、#`if` 指令中または #`elif` 指令中にありません。 このメッセージを生成するコードの例を次に示します。

    #if #system()
    	char *sysname = "??";
    #endif

メッセージ ID: E_TKNS_EXPECTED_BETWEEN_PARENS

## ")" が必要です。

`#if` 指令または `#elif` 指令中の、# 演算子のあとに続く述語のテストにおいて、表明を囲む右括弧 `)` がありません。 このメッセージを生成するコードの例を次に示します。

    #if # system(unix
    char *system = "unix";
    #endif

メッセージ ID: E_MISSING_R_PAREN

## 空の #unassert 指令

`#unassert` 指令の中に、削除する述語名がありません。 このメッセージを生成するコードの例を次に示します。

    #unassert

メッセージ ID: E_EMPTY_UNASSERT_DIRECTIVE

## #unassert には識別子トークンが必要です。

`#unassert` 指令では、表明解除する述語を指定する必要があります。 このメッセージを生成するコードの例を次に示します。

    #unassert 5

メッセージ ID: E_UNASSERT_REQUIRES_IDENTIFIER

## "(" のあとにはトークンが必要です。

`#unassert` 指令において、述語のあとの表明と右括弧 ) がありません。 このメッセージを生成するコードの例を次に示します。

    #unassert system(

メッセージ ID: E_TOKENS_EXPECTED_AFTER_L_PAREN

## ")" がありません。

`#unassert` 指令では、削除する述語の表明を括弧で囲む必要があります。 このメッセージを生成するコードの例を次に示します。

    #unassert system(unix

メッセージ ID: E_R_PAREN_EXPECTED

## 述語の引数がありません。

`#unassert` 指令において、述語の表明を区切る括弧 ( ) に囲まれたトークン がありません。 このメッセージを生成するコードの例を次に示します。

    #unassert machine()

メッセージ ID: E_EMPTY_PREDICATE_ARGUMENT

## 最初の識別子のあとには "(" が必要です。

`#unassert` 指令では、削除する述語の表明は、括弧で囲む必要があります。 このメッセージを生成するコードの例を次に示します。

    #unassert system unix

メッセージ ID: E_L_PAREN_EXPECTED_AFT_FIRST_ID

## ANSI C の事前定義マクロは再定義できません。

ANSI C で定義されているマクロを、ソースコードで定義または再定義しようとしています。定義済みのマクロは変更されません。 このメッセージを生成するコードの例を次に示します。

    #define __FILE__ "xyz.c"
    #define __LINE__ "10"
    #define __DATE__ "Jan 21 1993"
    #define __TIME__ "10:20:04"

メッセージ ID: E_CANT_REDEFINE_ANSI_PREDEFINE

## "defined" は定義できません。

前処理演算子 "defined" を、マクロ名として定義することはできません。 このメッセージを生成するコードの例を次に示します。

    #define defined xyz

メッセージ ID: E_CANNOT_DEFINE_DEFINED

## __STDC__ の定義解除

ANSI C では、事前定義シンボル `__STDC__` の定義を解除することはできません。しかし ANSI C 環境と ANSI C 以外の環境の両方で動作するように記述した C コードをテストするような場合、この機能があると便利です。 たとえば、`__STDC__` の有無を調べて、定義されている場合は関数のプロト型宣言を行い、未定義の場合は旧式の関数宣言と定義を行う C コードがあるとします。C コンパイラは、`__STDC__` を事前定義するので、旧式のコードを検査するには、通常は別のコンパイラ (非 ANSI C コンパイラ) を使用する必要があります。しかし、Sun C コンパイラでは、(通常はコマンド行で) `__STDC__` の定義解除をすることによって、この検査を行うことができます。このメッセージは、ANSI C の制限事項に反した機能を使用していることを通知するものです。 このメッセージを生成するコードの例を次に示します。

    #undef __STDC__	/* 通常 cc のコマンド行で -U__STDC__ */

    #ifdef __STDC__
    int
    myfunc(const char *arg1, int arg2)
    #else	/* 非 ANSI C */
    int
    myfunc(arg1,arg2)
    char *arg1,	/* oops */
    int arg2;
    #endif
    {
    }

メッセージ ID: E_UNDEFINING__STDC__

## ANSI C の事前定義マクロの定義は解除できません。

ソースコードで、ANSI C ですでに定義されているマクロの定義を解除しようとしています。 このメッセージを生成するコードの例

    #undef __FILE__
    #undef __LINE__
    #undef __DATE__
    #undef __TIME__

メッセージ ID: E_CANT_UNDEFINE_ANSI_PREDEFINE

## "defined" の定義は解除できません。

前処理演算子 "defined" の定義を解除することはできません。 このメッセージを生成するコードの例を次に示します。

    #undef defined

メッセージ ID: E_CANT_UNDEFINE_DEFINED

## -D オプションの引数が識別子ではありません。

`cc -D` コマンド行オプションのあとには、識別子を続ける必要があります。 このメッセージを生成するコードの例を次に示します。

    cc -D3b2 -c x.c

メッセージ ID: E_D_OPT_ARG_NOT_AN_IDENTIFIER

## -D オプションのあとに、"=" がありません。

`cc` コマンドに対する `-D` オプションで指定された識別子のあとにトークンを続ける場合は、最初のトークンは = にする必要があります。 このメッセージを生成するコードの例を次に示します。

    cc -DTWO+2 -c x.c

メッセージ ID: E_D_OPT_NOT_FOLLOWED_BY_EQUAL

## -U オプションの引数が識別子ではありません。

`cc -U` コマンド行オプションのあとには、識別子を続ける必要があります。 このメッセージを生成するコードの例を次に示します。

    cc -U3b2 -c x.c

メッセージ ID: E_U_OPT_ARG_NOT_AN_IDENTIFIER

## "-U{identifier}" のあとのトークンは無視されます。

`-U` オプションを指定するコマンド行で、定義を解除するマクロ名のあとにトークンが指定されています。 このメッセージを生成するコードの例を次に示します。

    cc -Uunix,u3b2 -c x.c

メッセージ ID: E_TOKENS_IGNORED_AFTER_U_OPT

## #define 指令行が空

`#define` 指令に、定義するマクロまたはその他のトークンのいずれもありません。 このメッセージを生成するコードの例を次に示します。

    #define

メッセージ ID: E_EMPTY_POIND_DEFINE_DIRECTIVE

## #define にはマクロ名が必要です。

`#define` 指令のあとには、定義するマクロの名前を続ける必要があります。 このメッセージを生成するコードの例を次に示します。

    #define +3

メッセージ ID: E_PND_DEF_REQUIRES_MACRO_NAME

## #define マクロのパラメータリストが不完全

関数形式のパラメータ定義で、`#define` 指令と同じ論理行に ) 文字がありません。 このメッセージを生成するコードの例を次に示します。

    #define mac(a

メッセージ ID: E_INCOMPLETE_DEF_MACRO_PARAMS

## マクロパラメータの構文エラー

関数形式のマクロ定義におけるマクロパラメータリストの書式が正しくありません。各識別子をカンマで区切る必要があります。 このメッセージを生成するコードの例を次に示します。

    #define mac(a,b,) a b

メッセージ ID: E_SYNTAX_ERROR_IN_MACRO_PARAMS

## #define マクロの "#" または "##" の使用法に誤りがあります。

マクロ定義で、`#` または `##` の演算子のあとに、さらに別の `#` または `##` が続いています。 このメッセージを生成するコードの例を次に示します。

    #define bug(s) # # s
    #define bug2(s) # ## s

メッセージ ID: E_BAD_SHARP_OR_SHARPS_IN_MACRO

## マクロ置換を "##" で開始することはできません。

## 演算子は 2 項連結演算子なので、マクロ定義のマクロ置換リスト中で最初のトークンには使用できません。 このメッセージを生成するコードの例を次に示します。

    #define mac(s) ## s

メッセージ ID: E_CANT_BEGIN_MACRO_WITH_SHARP

## #define 中の "#" のあとに仮引数でない識別子があります。

マクロ定義で # 演算子のあとに続く識別子は、関数形式マクロの仮引数にする必要があります。 このメッセージを生成するコードの例を次に示します。

    #define mac(a) "abc" # b

メッセージ ID: E_NON_FORMAL_ID_FOLLOWS_SHARP

## コメントが "##" で置き換えられます

このメッセージは、`-Xt` オプションを指定している場合に表示されます。コンパイラが、見かけ上の連結を `##` 演算子と同様に扱うことを示します。この演算子を使用するようにソースコードを変更することをお勧めします。 このメッセージを生成するコードの例を次に示します。

    #define PASTE(a,b) a/*GLUE*/b
    int PASTE(prefix,suffix) = 1; /*  "prefixsuffix" を作成 */

メッセージ ID: E_COMMENT_REPLACED_BY_SHARPS

## コメントがトークンを連結していません。

このメッセージは、`-Xa` オプションまたは `-Xc` オプションを指定している場合に表示されます。K&R C の以前のリリースでは、2 つのトークンの間にコメントを入れてマクロ中に並置すると、2 つのトークンを連結することができます。ただしこの動作は、定義および保証されていません。ANSI C には、同じ用途に利用できる ## 演算子が定義されているので、これを使用するようにしてください。このメッセージは、旧バージョンの動作がサポートされていないことを示します。 このメッセージを生成するコードの例を次に示します。

    #define PASTE(a,b) a/*GLUE*/b
    int PASTE(prefix,suffix) = 1; /* "prefixsuffix" は生成されない */

メッセージ ID: E_COMMENT_DOSNT_CONCAT_TOKENS

## 文字列リテラル中のマクロ置換

K&R C の以前のリリースでは、マクロ定義の一部である文字列リテラル中の仮引数の値を置換することが可能でした。ANSI C では、この方法は使用できません。 ANSI C では、別の方法で同じ処理を行うことができます。文字列化を行う演算子 # によって、マクロ引数のトークンが文字列リテラルに変換され、隣接する文字列リテラルは連結されます。正しい書式は次のとおりです。

    #define HELLO(name) name
    char *hello_mindy = HELLO("Mindy");

このメッセージを生成するコードの例を次に示します。

    #define HELLO(name) "name"
    char *hello_mindy = HELLO(Mindy);

メッセージ ID: E_MACRO_REPLACEMENT_IN_STRING

## 文字定数中のマクロ置換

K&R C の以前のリリースでは、マクロ定義の一部である文字定数中の仮引数の値を置換することができます。ANSI C では、この方法は使用できません。 ANSI C で使用するこの構文は次のとおりです。

    #define CTRL(x) (x037)  /* 書式制御文字 */
    int ctrl_c = CTRL('c');

このメッセージを生成するコードの例を次に示します。

    #define CTRL(x) ('x'037)   /* 書式制御文字 */
    int ctrl_c = CTRL(c);

メッセージ ID: E_MACRO_REPLACEMENT_CHAR_CONST

## 文字列リテラル中ではマクロ置換は行われません。

このメッセージは、`-Xa` オプションまたは `-Xc` オプションを指定している場合に表示されます。-Xt モードで行われるマクロ置換が、`-Xa` モードまたは `-Xc` モードでは行われないことを示します。

メッセージ ID: E_NO_REPLACEMENT_IN_STRING

## 文字定数中のマクロ置換は行われません。

このメッセージは、`-Xa` オプションまたは `-Xc` オプションを指定している場合に表示されます。-Xt モードで行われるマクロ置換が、`-Xa` モード または `-Xc` モードでは行われないことを示します。

メッセージ ID: E_NO_REPLACEMENT_IN_CHAR_CONST

## #define では "#" のあとに仮識別子が必要です。

文字列化演算子 # のあとには、関数形式マクロの仮引数の名前を続ける必要があります。 このメッセージを生成するコードの例を次に示します。

    #define mac(a) # + a

メッセージ ID: E_ID_REQUIRED_FOR_POUND_DEFINE

## マクロ置換リストの最後に "#" または "##" があります。

# または ## 演算子は、マクロ定義のマクロ置換リスト中で最後のトークンとして使用することはできません。 このメッセージを生成するコードの例を次に示します。

    #define mac1(s) abc ## s ##
    #define mac2(s) s #

メッセージ ID: E_CANT_END_MACRO_WITH_SHARP

## #undef 指令が空です。識別子が必要です。

`#undef` 指令中に、定義解除するマクロ名がありません。 このメッセージを生成するコードの例を次に示します。

    #undef

メッセージ ID: E_EMPTY_UNDEF_DIRECTIVE

## #undef 指令のあとには識別子が必要です。

`#undef` のあとには、定義を解除するマクロの名前を続ける必要があります。この指令のあとにあるトークンが識別子ではありません。 このメッセージを生成するコードの例を次に示します。

    #undef 4

メッセージ ID: E_ID_EXPECTED_AFTER_UNDEF

## 指令行の末尾のトークンが無視されました。

指令の行に、余分なトークンが含まれています。そのトークンは無効です このメッセージを生成するコードの例を次に示します。

    #undef a b	/* 1 つだけ定義を解除できる */

メッセージ ID: E_TKNS_IGNORED_AT_END_OF_DIR

## 数値が必要です。

`#if` または `#elif` 指令中に必要な数値が見つかりません。 このメッセージを生成するコードの例を次に示します。

    #if 1 +
    	int i = 1;
    #endif

メッセージ ID: E_NUMBER_EXPECTED

## 演算子がありません。

前処理の条件付きコンパイル指令の定数式の書式が正しくありません。必要な演算子がありません。 このメッセージを生成するコードの例を次に示します。

    #if 1 4
    	int i = 1;
    #endif

メッセージ ID: E_MISSING_OPERATOR

## 不要な ")"

`#if` または `#elif` の指令中に、不要な右括弧 ) があります。 このメッセージを生成するコードの例を次に示します。

    #if ) 1
    	int i = 1;
    #endif

メッセージ ID: E_UNEXPECTED_R_PAREN

## 不要な "("

`#if` または `#elif` の指令中に、不要な左括弧 ( があります。 このメッセージを生成するコードの例を次に示します。

    #if 1 (
    int i = 1;
    #endif

メッセージ ID: E_UNEXPECTED_L_PAREN

## オペランドがありません。

前処理の条件付きコンパイル指令の定数式の書式が正しくありません。演算子に必要なオペランドがありません。 このメッセージを生成するコードの例を次に示します。

    #define EMPTY
    #if EMPTY / 4
    	int i = 1;
    #endif

メッセージ ID: E_MISSING_OPERAND

## 0 による除算

式中にゼロによる除算があります。この除算が `#if` または `#elif` 指令中にある場合、結果はゼロと解釈されます。実行可能コードにゼロ除算がある場合は、警告になります。大域的な初期設定子または `static` 初期設定子にゼロ除算がある場合は、エラーになります。 このメッセージを生成するコードの例を次に示します。

    f(void) {
    	int i = 1/0;
    }

メッセージ ID: E_DIVISION_BY_ZERO

## 0 による剰余演算

`%` 演算子の第 2 オペランドがゼロです。剰余演算子が `#if` または `#elif` 指令中にある場合、結果はゼロと解釈されます。 実行可能コードに剰余式がある場合は、警告になります。大域的な初期設定子または `static` 初期設定子に 剰余式がある場合は、エラーになります。 このメッセージを生成するコードの例を次に示します。

    #if 42 % 0
    	int i = 1;
    #endif

メッセージ ID: E_MODULUS_BY_ZERO

## 不適切なエスケープ: \c

文字列リテラルおよび文字定数で、\ のあとには特定の文字しか続けることができません。たとえば、`c` を続けることはできません。 ANSI C は \ を無視します。 このメッセージを生成するコードの例を次に示します。

     int i = '\c';

メッセージ ID: E_DUBIOUS_ESCAPE_CHAR

## 不適切なエスケープ

文字列リテラルおよび文字定数で、特定の出力されない文字のみを、\ のあとに続けることができます。メッセージ中で括弧に囲まれた値は、16 進数で表わした文字コードです。

メッセージ ID: E_DUBIOUS_ESCAPE_UNPRINTABLE

## \a は ANSI C の警告文字です。

このメッセージは、`-Xt` オプションを指定している場合に表示されます。 ほかの K&R C コンパイラでは、'\a' は 'a' と等価です。ただし、ANSI C では '\a' は警告文字として定義されています。対応する文字コードは 07 で、BEL 文字を表します。 このメッセージを生成するコードの例を次に示します。

    int c = '\a';

メッセージ ID: E_ESC_A_IS_ANSI_ALERT

## \x は ANSI C の 16 進エスケープです。

-Xs または -Xt のコンパイラモードを指定している時は、コンパイラは "\x" を "x" という文字列として解釈します。 ただし、ANSI C モード (-Xa および -Xc) の場合は、

      "\x<16 進数>"

によって、16 進エスケープシーケンスが指定されます。 このメッセージを生成するコードの例 (-Xs オプションでコンパイルした場合)

    char *cp = "254 の 16 進数エスケープシーケンス: \xfe";

メッセージ ID: E_ESC_X_IS_ANSI_HEX_ESCAPE

## \x のあとに 16 進数がありません。

このメッセージは、`-Xa` オプションまたは `-Xc` オプションを指定している場合に表示されます。文字定数、または文字列リテラルの中に \x エスケープがあると、16 進文字のエスケープが生成されます。\x のあとには、少なくとも 1 文字の 16 進数を続ける必要があります。 このメッセージを生成するコードの例を次に示します。

    char *cp = "&\xz";

メッセージ ID: E_NO_HEX_DIGITS_AFTER_ESCAPE_X

## 16 進エスケープのオーバーフロー

文字定数または文字列リテラルにある 16 進エスケープ (`\x`) で、エスケープの累積値が大き過ぎます。下位の 32 ビットだけが保持されます。 このメッセージを生成するコードの例を次に示します。

    int i = '\xabcdefedc';

メッセージ ID: E_OVERFLOW_IN_HEX_ESCAPE

## 空の文字定数

文字が含まれない文字定数が使用されました。 このメッセージを生成するコードの例を次に示します。

    f(void) {

    char c = '';    /* char c = ' ';  とする */
    }

メッセージ ID: E_EMPTY_CHAR_CONSTANT

## 文字定数が長すぎます。

文字定数中の文字数が多すぎて、1 つの整数に収まりません。通常の文字定数の場合は最初の 4 文字、ワイド文字定数の場合は最初の 1 文字だけが使用されます。2 文字以上の文字定数の使用には移植性がありません。 このメッセージを生成するコードの例を次に示します。

    int i = 'abcde';

メッセージ ID: E_CHAR_CONST_TOO_LONG

## 無効なマルチバイト文字

ご使用中のシステムでは、文字列リテラルまたは文字定数の中のマルチバイト文字を、1 文字のワイド文字に変換できません。また、別の場所で検出されたマルチバイトは無視されています。

メッセージ ID: E_INVALID_MULTIBYTE_CHAR

## 文字エスケープが char に収まりません。

文字定数または文字列リテラル中にある 16 進または 8 進のエスケープシーケンスによって、`unsigned char` よりもサイズが大きい値が生成されます。この値は余分な桁が切り捨てられます。 このメッセージを生成するコードの例を次に示します。

    char *p = "\x1ff\400";

メッセージ ID: E_CHAR_ESC_DOES_NO_FIT_IN_CHAR

## 無効な 8 進数

このメッセージは、`-Xt` オプションを指定している場合に表示されます。 0 で始まる整数定数に、8 進数でない数字が含まれています。 8 や 9 は無効な値ですが、それぞれ 8 および 9 の値として扱われます。 このメッセージを生成するコードの例を次に示します。

    int i = 08;

メッセージ ID: E_BAD_OCTAL_DIGIT

## 括弧の不一致

前処理条件付きコンパイル指令の中で、括弧が対になっていません。 このメッセージを生成するコードの例を次に示します。

    #if ((1)
    	int i = 1;
    #endif

メッセージ ID: E_MISMATCHED_PARENS

## "?" と ":" の不一致

`#if` または `#elif` 指令中にある、 `?~:` 式の書式が正しくありません。 このメッセージを生成するコードの例を次に示します。

    #if defined(foo) ? 5
    	int i;
    #endif

メッセージ ID: E_MISMATCHED_TERNARY_OP

## マクロ展開後の定数式が空です。

マクロ展開後に、`#if` または `#elif` 指令中の式にトークンが含まれていません。 このメッセージを生成するコードの例を次に示します。

    #define EMPTY
    #if EMPTY
    	char *mesg = "EMPTY が空ではない";
    #endif

メッセージ ID: E_EMPTY_CONST_EXP_AFTER_EXPAND

## プリプロセッサ:標準出力を複製できません。

コンパイラが標準出力 (stdout) にアクセスする時に、ファイルシステムエラーが発生しました。

メッセージ ID: E_CANT_DUP_STDOUT

## プリプロセッサ:別の標準出力を開けません。

コンパイラが標準出力 (stdout) にアクセスする時に、ファイルシステムエラーが発生しました。

メッセージ ID: E_CANT_OPEN_ALT_STDOUT

## プリプロセッサ: /dev/null を開けません。

コンパイラが /dev/null にアクセスする時に、ファイルシステムエラーが発生しました。

メッセージ ID: E_CANT_OPEN_DEV_NULL

## 一時ファイルの書き込みが失敗しました:ファイルシステムが満杯です。

中間ファイルの書き込み中に、ディスク領域が足りなくなりました。 一時ファイルを書き込むファイルシステムに十分な領域があることを確認してから、コンパイルを行なってください。`TMPDIR` 環境変数を使用すると、コンパイラが一時ファイルを書き込む位置を変更することができます。

メッセージ ID: E_TMPFILE_FILE_SYSTEM_FULL

## 型が未定義またはありません。

関数定義中で、無効な型によってパラメータが宣言されています。型が未定義であるか、型に対応しない識別子が使用されています。通常このメッセージは、構文エラーメッセージのあとに出力されます。 このメッセージを生成するコードの例を次に示します。

    int f1(what arg)
    {
    }

メッセージ ID: E_UNDEFINED_OR_MISSING_TYPE

## 構文エラーがあります。

このメッセージは、セミコロンがない、右の大括弧または中括弧がない、言語トークンが並置されている、などの構文エラーがある場合に出力されます。メッセージ中には、エラーが検出されたソースコードの行番号およびトークンが示されます。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int i = 3	/* セミコロンがない */
    }

    f(int i){
    	int j;

    	j = (i + 24;	/* 右の括弧がない */
    }

メッセージ ID: E_YACC_GENERIC_ERROR

## 構文エラーがあります。

このメッセージは、セミコロンがない、右の大括弧または中括弧がない、言語トークンが並置されている、などの構文エラーがある場合に出力されます。メッセージ中には、エラーが検出されたソースコードの行番号およびトークンが示されます。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int i = 3	/* セミコロンがない */
    }

    f(int i){
    	int j;

    	j = (i + 24;	/* 右の括弧がない */
    }

メッセージ ID: E_YACC_ERROR

## "void" ポインタを介したアクセスは無視されました。

`void` へのポインタを使用してオブジェクトにアクセスすることはできません。ソース中に、`void` への (おそらく修飾子のついた) ポインタを介して間接参照している式があります。 この間接参照は無視されます。ただし、式のその他の部分は有効です。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	volatile void *vp1, *vp2;
    	*(vp1 = vp2);/* 代入はうまく実行できます */
    }

メッセージ ID: E_ACCESS_VIA_VOID_PTR_IGNORED

## switch 内で case が重複しています

現在の `switch` 文に、同じ定数値を持つ case 文が 2 つ存在します。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	long long i = 5;
    	switch(i) {
    	case 4:
    	case 4:
    		    break;
    	}
    }

メッセージ ID: E_DUP_CASE_IN_SWITCH_L

## switch 内で case が重複しています

現在の `switch` 文に、同じ定数値を持つ case 文が 2 つ存在します。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int i = 5;
    	switch(i) {
    	case 4:
    	case 4:
    		    break;
    	}
    }

メッセージ ID: E_DUP_CASE_IN_SWITCH

## asm 文は関数の外で使用できません。

asm 文は、関数本体の中でのみ使用できます。外部宣言のレベルでは使用できません。 このメッセージを生成するコードの例を次に示します。

    asm("   .align  4               ");   /* 誤 */
    void f(void) {
            asm("   nop                     ");   /* 正 */

メッセージ ID: E_ASM_ILLEGAL_OUTSIDE_FUNC

## asm() 引数は標準の文字列リテラルでなければなりません。

旧バージョンの `asm()` に対する引数は、ワイド文字列リテラルではなく、標準の文字列リテラルにする必要があります。 このメッセージを生成するコードの例を次に示します。

    asm(L"wide string literal not allowed");

メッセージ ID: E_ASM_ARG_MUST_BE_STRING

## asm() では組み込みの NUL は許可されません。

旧バージョンの `asm()` で使用された文字列リテラルに、`NUL` (文字コード 0) が組み込まれています。 このメッセージを生成するコードの例を次に示します。

    asm("this is an old-style asm with embedded NUL:  \0");

メッセージ ID: E_EMBEDDED_NUL_ILLEGAL_IN_ASM

## asm() 文は関数中の最適化を無効にします。

このメッセージは、`-v`、`-O`、`-xO`[level] オプションを指定している場合に表示されます。関数中に `asm` 文があると、その関数の最適化は行なわれません。 このメッセージを生成するコードの例を次に示します。

    void foo(void)
    {
    asm(".volatile");
    asm("   st      %g0, [%sp+0x44]");
    asm("   ld      [%sp+0x44], %fsr");
    asm("   nop");
    asm(".nonvolatile");
    }

メッセージ ID: E_ASM_DISABLES_OPTIMIZATION

## 空の翻訳単位

前処理の完了後、ソースファイル中にトークンがありません。 ANSI C では、トークンのないファイルについては、メッセージが出力されます。 このメッセージを生成するコードの例を次に示します。

    #ifdef COMPILE
    	int token;
    #endif

メッセージ ID: E_EMPTY_TRANSLATION_UNIT

## lock_lint はロックへの単なるポインタを無視します。

ロックへのアクセスに、(実体を特定できない) 単なるポインタを使用しているので、どのロックが操作されているかを lock_lint が特定できません。 このメッセージを生成するコードの例を次に示します。

    struct G_Mutex {
    	mutex_t* amutex;
    	int global_data;
    };
    struct G_Mutex* global_mutex;

    int add_data() {
    	mutex_lock(global_mutex->amutex);   /* <=== 警告 */
    	global_mutex->global_data++;
    	mutex_unlock(global_mutex->amutex); /* <=== 警告 */
    	return global_mutex->global_data;
    }
    ==================
    /* lock_lint が処理できるコード例 */
    struct G_Mutex {
    	mutex_t amutex;			        /* <=== OK */
    	int global_data;
    };
    int add_data() {
    	mutex_lock(&global_mutex->amutex);      /* <=== OK */
    	global_mutex->global_data++;
    	mutex_unlock(&global_mutex->amutex);    /* <=== OK */
    	return global_mutex->global_data;
    }

メッセージ ID: E_LOCK_FUNC_IGNORES_PTR

## func 関数のロックパラメータを選択するために、?: が使用されています.

lock_lint でソースコードを静的に解析しても、関数呼び出しで `?:` 演算子が使用されているので、渡されているパラメータを特定することができません。 このメッセージを生成するコードの例を次に示します。

    mutex_t mutex1;
    mutex_t mutex2;

    mutex_lock((1==1)? &mutex1 : &mutex2);

メッセージ ID: E_CONDITIONAL_OP_LOCK_CHOICE

## 呼び出しがロックを獲得することができるとみなします。

lock_lint によるソースコードの静的解析で、指定された関数がロックを獲得することができたとみなされます。 このメッセージを生成するコードの例を次に示します。

    	mutex_t mutex1;
    	if (mutex_trylock(&mutex1))
    	  goto getlock;

メッセージ ID: E_ASSUME_SUCCESSFUL_LOCK

## func の条件変数パラメータを選択するために、?: 演算子が使用されています; lock_lint は条件変数が選択されたとみなします。

lock_lint でソースコードを静的解析しても、関数呼び出しで ?: 演算子が使用されているので渡されているパラメータを特定することができません。lock_lint によるソースコードの静的解析では、該当する条件変数が対応する関数にパラメータとして渡されているとみなされます。 このメッセージを生成するコードの例

    int waitWriter;
    f() {
      cond_t condt1, condt2;

      cond_wait((waitWriter == 0) ? condt1 : condt2);
    }

メッセージ ID: E_CONDITIONAL_OP_CONDVAR_CHOICE

## lock_lint は条件変数へのポインタを無視します。

lock_lint は、操作されているロックを特定することができないので、(実体を特定できない) 条件変数へのポインタは無視されます。 このメッセージを生成するコードの例を次に示します。

      cond_t* ptr;
      int count = 0;   /* 共有変数 */

      while (count == 0)
    	cond_wait(ptr);

    /* lock_lint が解析できる例 */
      cond_t p;
      while (count == 0)
    	cond_wait(&p);

メッセージ ID: E_CV_FUNC_IGNORES_SIMPLE_PTR

## 関数に 2 つの引数が必要です。

関数に 2 つの引数が必要ですが、2 番目の mutex 引数を指定していません。 このメッセージを生成するコードの例を次に示します。

    	kcondvar_t cvp;
    	cv_wait(&cvp);

    /*======================
    ** 正しい例:
    */
    	kcondvar_t cvp;
    	kmutex_t mp;
    	cv_wait(&cvp, &mp);

メッセージ ID: E_SECOND_MUTEX_MISSING

## オペランドは void 型にできません。

`void` 型のオペランドがあります。 このメッセージを生成するコードの例を次に示します。

    f(void){
    void v(void);
    int i = v();
    }

メッセージ ID: E_OPERAND_CANT_BE_VOID_TYPE

## 2 文字の代入演算子の間に空白があります。

-Xs オプションを使用すると、2 文字の代入演算子の間に空白を入れることができます。 2 文字の代入演算子には、次のようなものがあります。

    	+=, -=, *=, /=, &=, |=, ^=, %=

ただし、-Xs オプション以外のコンパイラモードでは、2 文字の代入演算子の間に空白を入れることはできません。 このメッセージを生成するコードの例を次に示します。

    	int i + = 1;        /* += 演算子  */	int k - = 1;

メッセージ ID: E_WHITESPACE_IN_CHAR_ASSIGN_OPS

## ANSI C は定数を unsigned 型として扱います

ANSI C と旧バージョンの K&R C では、型拡張の規則が多少異なります。現リリースでは、デフォルトでは以前の規則が適用されます。`コンパイラ`コマンドに `-Xa` オプションを指定すると、ANSI C の規則を適用することができます。 旧バージョンの K&R C の型拡張の規則では、`unsigned` 型のまま評価されます。式に `unsigned` 型のオペランドがある場合、オペランドが共通の `unsigned` 型に拡張されたあとに、演算が実行されます。 ANSI C では、値を保持したまま型を拡張する規則を使用します。`unsigned` 型は、その値がすべて `signed` 型で表現できる場合は `signed` 型に拡張されます。 また、ANSI C と旧バージョンの K&R C では、`符号`ビットを暗黙に設定する整数定数型に関する規則が異なります。 型拡張に関する規則が異なると、オペランドが "`unsigned`" であるかどうかに影響される、演算子の動作も異なる可能性があります。

    o 除算演算子:       /, /=, %, %=
    o 右シフト演算子:    >>, >>=
    o 関係演算子:     <, <=, >, >=

このメッセージは、プログラム中に、演算子の動作が将来変わる可能性のある式があることを示しています。式の中に明示的にキャストを挿入することによって、動作を確定することができます。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int i;
    	/* 定数が、K&R C の場合は int 、ANSI C の場合は unsigned */
    	i /= 0xf0000000;
    }

メッセージ ID: E_ANSI_CONST_UNSIGNED_OP

## ANSI C では演算子の意味が変わります。明示的なキャストを使用してください。

ANSI C と旧バージョンの K&R C では、型拡張の規則が多少異なります。現リリースでは、デフォルトでは以前の規則が適用されます。`cc` コマンドに `-Xa` オプションを指定すると、ANSI C の規則を適用することができます。 旧バージョンの K&R C の型拡張の規則では、`unsigned` 型のまま評価されます。式に `unsigned` 型のオペランドがある場合、オペランドが共通の `unsigned` 型に拡張されたあとに、演算が実行されます。 ANSI C では、値を保持したまま型を拡張する規則を使用します。`unsigned` 型は、その値がすべて `signed` 型で表現できる場合は `signed` 型に拡張されます。 型拡張に関する規則が異なると、オペランドが "`unsigned`" であるかどうかに影響される、演算子の動作も異なる可能性があります。

    o 除算演算子:       /, /=, %, %=
    o 右シフト演算子:    >>, >>=
    o 関係演算子:     <, <=, >, >=

このメッセージは、プログラム中に、演算子の動作が将来変わる可能性のある式があることを示しています。次のように、式の中に明示的にキャストを挿入することによって、動作を確定することができます。

    f(void){
    	unsigned char uc;
    	int i;
    	/* K&R C の場合は unsigned、ANSI C の場合は signed の除算 */
    	i /= (unsigned int) uc;
    }

このメッセージを生成するコードの例を次に示します。

    f(void){
    	unsigned char uc;
    	int i;
    	/* K&R C の場合は unsigned、ANSI C の場合は signed の除算 */
    	i /= uc;
    }

メッセージ ID: E_SEMANTICS_OF_OP_CHG_IN_ANSI_C

## 整数定数が大きすぎます。

整数定数が大きすぎて、`unsigned long` 型にできません。 このメッセージを生成するコードの例を次に示します。

    int i = 123456789012345678901;

メッセージ ID: E_INTEGRAL_CONSTANT_TOO_LARGE

## 定数が unsigned int に拡張されます。

接尾辞で指定された型に対して、定数の値が大きすぎるので、unsigned int 型に拡張されます。

メッセージ ID: E_CONST_PROMOTED_UNSIGNED_INT

## 定数が unsigned long に拡張されます。

接尾辞で指定された型に対して、定数の値が大きすぎるので、unsigned long 型に拡張されます。

メッセージ ID: E_CONST_PROMOTED_UNSIGNED_LONG

## 定数が unsigned long long に拡張されます。

このメッセージは、`-v` オプションを指定している場合に表示されます。接尾辞で指定された型に対して定数が大きすぎるので、`long long` 型または `unsigned long long` 型に拡張されます。 このメッセージを生成するコードの例を次に示します。

    if (9223372036854775807L > 0)  printf("符号拡張された\n");
    if (9223372036854775807UL > 0)  printf("符号拡張された\n");

メッセージ ID: E_CONST_PROMOTED_UNSIGNED_LL

## 定数が long に拡張されます。

接尾辞で指定された型に対して、定数の値が大きすぎるので、long 型に拡張されます。

メッセージ ID: E_CONST_PROMOTED_LONG

## 定数が long long に拡張されます。

このメッセージは、`-v` オプションを指定している場合に表示されます。接尾辞で指定された型に対して定数が大きすぎるので、`long long` 型または `unsigned long long` 型に拡張されます。 このメッセージを生成するコードの例を次に示します。

    if (9223372036854775807L > 0)  printf("符号拡張された\n");
    if (9223372036854775807UL > 0)  printf("符号拡張された\n");

メッセージ ID: E_CONST_PROMOTED_LONG_LONG

## 浮動小数点定数の float への変換が範囲を超えました。

浮動小数点定数が大きすぎて、float 型にできません。 このメッセージを生成するコードの例を次に示します。

    float f = 1e300f;

メッセージ ID: E_CONV_CONST_FP_FLOAT_OUT_RANGE

## 浮動小数点定数の long double への変換が範囲を超えました。

浮動小数点定数が大きすぎて、long double 型にできません。

メッセージ ID: E_CNV_CNST_FP_LONG_DBL_OUTRANGE

## 浮動小数点定数の double への変換が範囲を超えました。

浮動小数点定数が大きすぎて、double 型にできません。

メッセージ ID: E_CONV_CONST_FP_DBL_OUT_RANGE

## 構文エラー:""&..." が無効

このメッセージは、`-Xc` オプションを指定した場合にエラーが発生すると表示されます。プログラムには、&... が含まれているので、`-Xc` オプションを使用してコンパイルされます。 ANSI C では、&... は無効なので、明示的に使用しないでください。

メッセージ ID: E_AND_DOT_DOT_DOT_INVALID

## 整数定数式が必要です。

整数値を生成するために、コンパイル時に評価できる整数定数または式が必要です。コンパイル時に評価できない、整数以外の値、オブジェクトへの参照、演算子が、式中で使用されています。 このメッセージを生成するコードの例を次に示します。

    int ia[5.0];

メッセージ ID: E_INTEGRAL_CONST_EXP_EXPECTED

## メンバーの使用が不適切です。

プログラム中で、-> または . の演算子が使用されており、name が 演算子の左で参照される構造体または共用体のメンバーではなく、別の構造体または共用体のメンバーになっています。 メンバーが一意でない場合はエラーになります。一意のメンバーとは、複数の構造体または共用体の一部であり、すべての構造体および共用体において型とオフセットが同じであるメンバーのことです。 このメッセージを生成するコードの例を次に示します。

    struct s1 { int x,y;};
    struct s2 { int q,r;};
    f(void){
    	struct s1 *ps1;
    	ps1->r = 3;
    }

メッセージ ID: E_IMPROPER_MEMBER_USE

## 構造体 / 共用体のメンバーが未定義です。

プログラムが、いずれの構造体としても宣言されていない構造体または共用体のメンバーを参照しています。 このメッセージを生成するコードの例を次に示します。

    struct s { int x;};
    f(void){
    	struct s q;
    	q.y = 1;
    }

メッセージ ID: E_UNDEFINED_STRUCT_UNION_MEMBER

## 一意でないメンバーには構造体 / 共用体のポインタが必要です。

-> 演算子の左にあるオペランドが、構造体、共用体、またはそれらに対するポインタではありません。また、宣言されたすべての構造体および共用体の中で、メンバー name が一意になっていません。-> 演算子を、構造体または共用体だけに使用し、メンバーが、左のオペランドに対応する構造体または共用体に属している必要があります。

メッセージ ID: E_NON_UNIQUE_REQRS_S_U_PTR

## 一意でないメンバーには構造体 / 共用体のオブジェクトが必要です。

. 演算子の左にあるオペランドが、構造体、共用体、またはそれらに対するポインタではありません。また、宣言されたすべての構造体および共用体の中で、メンバー name が一意になっていません。. 演算子を、構造体または共用体だけに使用し、メンバーが、左のオペランドに対応する構造体または共用体に属している必要があります。 このメッセージを生成するコードの例を次に示します。

    struct s1 { int x,y;};
    struct s2 { int y,z;};
    f(void){
    	long *lp;
    	lp.y = 1;
    }

メッセージ ID: E_NON_UNIQUE_REQRS_S_U_OBJ

## int を返す関数を暗黙的に宣言しています。

このメッセージは、`-v` オプションを指定している場合に表示されます。 プログラム中で宣言されていない関数を呼び出しています。 関数が `int` の値を返すと仮定されることを示しています。 このメッセージを生成するコードの例を次に示します。

    void v(void){
    	g();
    }

メッセージ ID: E_IMPLICIT_DECL_FUNC_RETURN_INT

## 未定義のシンボル

スコープ内に宣言されていないシンボルが参照されています。 このメッセージを生成するコードの例を次に示します。

    f(void){
    g(i);
    }

メッセージ ID: E_UNDEFINED_SYMBOL

## スコープ外の宣言を使用しています。

有効でなくなったスコープ中でオブジェクトが宣言されています。ANSI C では、このようなオブジェクトを参照すると、エラーになります。このような関数の呼び出しは、戻り値が `int` となる 関数の呼び出しとして解釈されます。C コンパイラは、以前の宣言を記憶しているので、これを使用します。このメッセージによって、コンパイラが実行した内容を確認することができます。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	extern int i;
    	double sin(double);
    }
    g(void){
    	double d = sin(1.5);
    	i = 1;
    }

メッセージ ID: E_USING_OUT_OF_SCOPE_DECL

## 関数に対して sizeof を適用できません。

`sizeof` 演算子は、関数には適用できません。 このメッセージを生成するコードの例を次に示します。

    int f(void);
    int i = sizeof(f);

メッセージ ID: E_CANT_TAKE_SIZEOF_FUNC

## 関数に対して sizeof を適用できません。

`sizeof` 演算子は、関数には適用できません。 このメッセージを生成するコードの例を次に示します。

    int f(void);
    int i = sizeof(f);

メッセージ ID: E_CANT_TAKE_SIZEOF_FUNC_N

## void に対して sizeof を適用できません。

`sizeof` 演算子は、`void` 型には適用できません。 このメッセージを生成するコードの例を次に示します。

    void v(void);
    int i = sizeof(v());

メッセージ ID: E_CANT_TAKE_SIZEOF_VOID

## ビットフィールドに対して sizeof を適用できません。

`sizeof` 演算子は、ビットフィールドには適用できません。 このメッセージを生成するコードの例を次に示します。

    struct s { int x:3; } st;
    int i = sizeof(st.x);

メッセージ ID: E_CANT_TAKE_SIZEOF_BIT_FIELD

## オペランドの型に互換性がありません。

1 つのオペランドに対するその他のオペランドの型が、この演算子には不適切です。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	char *cp;
    	int *ip;
    	void *vp = ip + cp;
    }

メッセージ ID: E_OPERANDS_INCOMPATIBLE_TYPES

## "?:" 中の式の最初のオペランドはスカラー型である必要があります。

`?:` 式中の条件式は、スカラー型 (整数、浮動小数点、ポインタ) である必要があります。 このメッセージを生成するコードの例を次に示します。

    struct s { int x; } st;
    f(void){
    	int i = st ? 3 :  4;
    }

メッセージ ID: E_FIRST_OPERAND_SCALAR_TYPE

## このコンテキストでは "." の左側のオペランドは、構造体/共用体のオブジェクトである必要があります。

. 演算子は、構造体または共用体のオブジェクトのみに適用されます。. の左にあるオペランドが、 配列、ポインタ、関数呼び出し、列挙型の定数または変数、レジスタに割り当てられたレジスタ値、のいずれかである場合はエラーになります。その他の場合は、警告になります。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	struct s { short s;};
    	int i;
    	i.s = 4;
    }

メッセージ ID: E_DOT_L_OPERAND_NOT_STRUCT_U

## 構造体または共用体でないオブジェクトのメンバーにアクセスできません。

構造体または共用体のメンバーは、. 演算子の左のオペランドのメンバーである必要があります。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	struct s { int x;};
    	char c;
    	c.x = 1;
    }

メッセージ ID: E_CANT_ACCESS_MBR_NON_STRUCT_U

## "->" の左側のオペランドは、構造体 / 共用体へのポインタである必要があります。

-> 演算子の左にあるオペランドが、構造体または共用体へのポインタになっていません。オペランドがポインタである場合は、警告になります。その他の場合は、エラーになります。 このメッセージを生成するコードの例を次に示します。

    struct s { int x;};
    f(void){
    	long *lp;
    	lp->x = 1;
    }

    g(void) :
    	struct s newStr;
    	newS->x = 1;
      /* newStr は構造体だが、構造体へのポインタではない */
    }

メッセージ ID: E_LEFT_MUST_BE_PTR_TO_STRUCT_U

## オペランドは整数型である必要があります。

整数型 (`short, int, long` など) オペランド用の演算子に対して、整数型以外のオペランドが指定されています。 このメッセージを生成するコードの例を次に示します。

    	struct Astr b;
    	int a = 0x345 & b;

メッセージ ID: E_OPERAND_MUST_BE_INTEGRAL_TYPE

## オペランドは算術型である必要があります。

`-`、`+` などの単項演算子のオペランドは、算術型にする必要があります。 このメッセージを生成するコードの例を次に示します。

    struct Astr {
    	int a;
    	int b;
    }
    g(void) {
    	struct Astr l;
    	int k = l * 2;   /* l は構造体 Astr で、算術型ではない */
    	l = -l;		 /* l は単項演算子 "-" または "+" のオペランド */
    	l = +l;		 /* だが、算術型ではない  */
    }

メッセージ ID: E_OPERAND_MUST_BE_ARITH_TYPE

## オペランドはスカラー型である必要があります。

単項演算子 "!" のオペランドは、スカラー型にする必要があります。また、"++" および "--" 演算子を使用している場合も、スカラー型にする必要があります。 このメッセージを生成するコードの例を次に示します。

    struct aStr{
    	int a;
    	int b;
    };
    g(void) {
    	struct aStr newStr;
    	newStr++;               /* 単項型演算子 ++ のオペランドは、スカラー型の必要がある */
    	newStr.a++;             /* 正しい例 */
    }

メッセージ ID: E_OPERAND_MUST_BE_SCALAR_TYPE

## サイズ不明のオペランドにはポインタ演算を実行できません。

式の中に、サイズが不明のオブジェクトに対するポインタの演算が含まれています。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	struct s *ps;
    	g(ps+1);
    }

メッセージ ID: E_PTR_ARITH_MUST_KNOW_SIZE

## 不適切なポインタの減算

減算のオペランドが両方ともポインタになっていますが、参照先の型が一致していません。同じ配列を指す同じ型のポインタどうしのみ、減算を行うことができます。 ポインタが同じサイズのオブジェクトを指している場合は、警告になります。その他の場合は、エラーになります。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int *ip;
    	char *cp;
    	int i = ip - cp;
    }

メッセージ ID: E_BAD_POINTER_SUBTRACTION

## 関数指示子の型が関数の型と異なります。

関数呼び出しにおいて、関数または関数へのポインタの名前が正しくない式があります。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	char *p;
    	p();
    }

メッセージ ID: E_FUNC_DESIGNATOR_NOT_FUNC_TYPE

## プロト型の不一致:引数の数が不一致

スコープ内でプロト型宣言されている関数を呼び出しており、呼び出し時に渡される引数の数が、宣言中のパラメータ数と一致していません。 このメッセージを生成するコードの例を次に示します。

    int f(int);
    g(void){
    	f(1,2);
    }

メッセージ ID: E_PROTOTYPE_MISMATCH_ARGS

## プロト型の不一致:引数の数が不一致

スコープ内でプロト型宣言されている関数を呼び出しており、呼び出し時に渡される引数の数が、宣言中のパラメータ数と一致していません。

メッセージ ID: E_PROTOTYPE_MISMATCH_ARG

## 引数の不一致数が不一致

このメッセージは、`-v` オプションを指定している場合に表示されます。関数の呼び出し時に関数に渡す引数の数が、関数に関するほかの情報と一致していません。ほかの情報とは、旧式 (非プロト型) の関数定義、またはスコープ外ではあるが記録が残っている関数プロト型宣言からの情報です。 旧式の関数定義を使用し、関数に可変数の引数がある場合には、このメッセージは正しくないことがあります。 このメッセージを生成するコードの例を次に示します。

    extern int out_of_scope();
    int f()
    {			/* 関数に引数はない */
    	extern int out_of_scope(int);
    }

    int g()
    {
    	f(1);    /* f に引数はない */
    	out_of_scope();	 /* out_of_scope に 1 つの引数が必要 */
    }

メッセージ ID: E_ARGS_MISMATCH

## 引数の不一致数が不一致

このメッセージは、`-v` オプションを指定している場合に表示されます。関数の呼び出し時に関数に渡す引数の数が、関数に関するほかの情報と一致していません。ほかの情報とは、旧式 (非プロト型) の関数定義、またはスコープ外ではあるが記録が残っている関数プロト型宣言からの情報です。 旧式の関数定義を使用し、関数に可変数の引数がある場合には、このメッセージは正しくないことがあります。

メッセージ ID: E_ARG_MISMATCH

## 不完全な型を返すことはできません。

戻り値が構造体または共用体となる関数を呼び出す場合は、対応する構造体または共用体が完全に宣言されている必要があります。宣言されていない場合にこのメッセージが表示されます。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	struct s g();
    	g();
    }

メッセージ ID: E_CANT_RETURN_INCOMPLETE_TYPE

## void 型の式を引数にすることはできません。

関数呼び出し中に、式の型が `void` である引数があります。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	void v(void);
    	g(v());
    }

メッセージ ID: E_VOID_EXP_MAY_NOT_BE_ARGS

## 引数のサイズが不明です。

関数呼び出し中の引数には、完全な型が必要です。渡された `struct`、`union`、または `enum` オブジェクトの型が不完全です。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	struct s *st;
    	g(*st);
    }

メッセージ ID: E_ARG_CANT_BE_UNKNOWN_SIZE

## 引数がプロト型と整合していません。

関数の引数を、関数プロト型宣言されている型に変換できません。 このメッセージを生成するコードの例を次に示します。

    struct s {int x;} q;
    f(void){
    	int g(int,int);
    	g(3,q);
    }

メッセージ ID: E_ARG_INCOMPATIBLE_WITH_ARG

## 代入の型が一致していません。

代入演算のオペランドの型が不一致です。ポインタの型が一致していない場合は、警告になります。その他の場合は、エラーになります。 このメッセージを生成するコードの例を次に示します。

    struct s { int x; } st;
    f(void){
    	int i;
    	char *cp;
    	const char *ccp;
    	i = st;
    	cp = ccp;
    }

メッセージ ID: E_ASSIGNMENT_TYPE_MISMATCH

## 無効なキャスト式

キャストには適さないデータ型なので、式にキャストを適用することができません。キャストされる式の型とキャスト後の型の両方が、スカラー型である必要があります。ポインタは、整数型との間でのみキャストを行うことができます。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	struct s {int x;} st;
    	int i = (int) st;
    }

メッセージ ID: E_INVALID_CAST_EXPRESSION

## 戻り値の型が一致していません。

関数からの戻り値を、その関数の戻り値の型に変換できません。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	struct s { int x; } st;
    	return( st );
    }

メッセージ ID: E_RETURN_VALUE_TYPE_MISMATCH

## 初期値設定の型が一致していません。

一致しない型で変数が初期化されています。 たとえば、異なる型のオブジェクトを指すポインタを初期化しています。 このメッセージを生成するコードの例を次に示します。

    struct s { int x; int y;};
    const int i = 10;
    int *j = &i;               /* <====== 型が一致していません */
    struct s *foo = j;         /* <====== 型が一致していません */

メッセージ ID: E_INITIALIZATION_TYPE_MISMATCH

## switch 式の型が無効

`switch` 文の制御式を、`int` に変換できません。このメッセージは、`"switch 式は整数型にする必要があります"` のメッセージのあとに表示されます。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	struct s {int x;} sx;
    	switch(sx){
    	case 4:  ;
    	}
    }

メッセージ ID: E_INVALID_SWITCH_EXP_TYPE

## 引数の型が記憶されている型と整合していません。

このメッセージは、`-v` オプションを指定している場合に表示されます。関数の呼び出し時に関数に渡す引数の型が、関数に関するほかの情報と一致していません。ほかの情報とは、旧式 (非プロト型) の関数定義、またはスコープ外ではあるが記録が残っている関数プロト型宣言からの情報です。 問題の引数は、デフォルトの引数拡張規則に従って拡張されます。旧式の関数定義を使用し、関数に可変数の引数がある場合には、このメッセージは正しくないことがあります。 このメッセージを生成するコードの例を次に示します。

    void f(i)
    int i;
    { }

    void g(void)
    {
    	f("erroneous");
    }

メッセージ ID: E_ARG_NOT_MATCH_REMEMBERED_TYPE

## ビットフィールドのアドレスは取得できません。

構造体または共用体のビットフィールドメンバーのアドレスを取得することはできません。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	struct s { int x:3, y:4; } st;
    	int *ip = &st.y;
    }

メッセージ ID: E_CANT_TAKE_ADDRESS_BIT_FIELD

## レジスタのアドレスは取得できません。

レジスタ記憶クラスで宣言されたオブジェクトのアドレスを取得しようとしています。コンパイラが、実際にレジスタにオブジェクトを割り当てたかどうかにかかわらず、アドレスの取得はできません。配列を間接参照する時などは、暗黙のうちにオブジェクトのアドレスを使用しようとしている可能性があります。そのオブジェクトにレジスタが割り当てられている場合は、エラーです。その他の場合は、警告です。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	register int i;
    	register int ia[5];
    	int *ip = &i;
    	ia[2] = 1;
    }

メッセージ ID: E_CANT_TAKE_ADDRESS_REGISTER

## 単項演算子 & のオペランドが不適切

取得できないアドレスを取得しようとしています。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int *ip = &g();
    }

メッセージ ID: E_BAD_OPERAND_FOR_UNARY_AND

## 非ポインタ型を間接参照することはできません。

* 演算子 (ポインタによる間接参照) のオペランドは、ポインタにする必要があります。このメッセージは、配列以外の部分に配列参照を行なった場合にも出力されます。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int i;
    	*i = 4;
    	i[4] = 5;
    }

メッセージ ID: E_CANT_DEREF_NON_POINTER_TYPE

## 制御式はスカラー型にする必要があります。

`if`、`for`、`while`、または `do-while` の式は、整数、浮動小数点、またはポインタのいずれかの型にする必要があります。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	struct s {int x;} st;
    	while (st) {}
    }

メッセージ ID: E_CNTRL_EXP_MUST_BE_SCALAR_TYPE

## キャストは左辺値を生成しません。

代入演算によって変更されるオブジェクトを構成するオペランドに、キャストを適用することはできません。オペランドの型のサイズと、キャスト後の型のサイズが同じである場合は、警告になります。その他の場合は、エラーになります。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int i;
    	(long) i = 5;
    	(short) i = 4;
    }

メッセージ ID: E_CAST_DOESNT_YIELD_LVALUE

## オペランドは変更可能な左辺値でなければなりません。

演算子のオペランドが、変更可能な`左辺値`になっていません。 このメッセージを生成するコードの例を次に示します。

    f(void){
    int i = --3;
    }

メッセージ ID: E_OPERAND_NOT_MODIFIABLE_LVALUE

## 左側のオペランドは変更可能な左辺値でなければなりません。

演算子の左にあるオペランドが、変更可能な`左辺値`になっていません。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int i = 1;
    	+i -= 1;
    }

メッセージ ID: E_L_OPERAND_NOT_MODIFIABLE_LVAL

## void 式の不適切なキャスト

`void` 型の式を `void` 以外にキャストすることはできません。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	void v(void);
    	int i = (int) v();
    }

メッセージ ID: E_BAD_CAST_OF_VOID_EXP

## 列挙型の不一致: 引数

このメッセージは、`-v` オプションを指定している場合に表示されます。スコープ内にプロト型宣言がある関数に、列挙定数またはオブジェクトが渡されています。渡される引数の列挙型が、関数プロト型中の型と異なっています。 このメッセージを生成するコードの例を次に示します。

    enum e1 { ec11 } ev1;
    enum e2 { ec21 } ev2;
    void ef(enum e1);

    void v(void){
    	ef(ec21);
    }

メッセージ ID: E_ENUM_TYPE_MISMATCH_ARG

## 列挙型の不一致: 演算子

演算子の両側の各オペランドの片方が列挙オブジェクトで、もう片方が異なる列挙型のオブジェクトまたは定数です。 このメッセージを生成するコードの例を次に示します。

    enum e1 { ec11, ec12 } ev1;
    enum e2 { ec21, ec22 } ev2;
    void v(void){
    	if (ev1 > ec22)
    		;
    }

メッセージ ID: E_ENUM_TYPE_MISMATCH_OP

## void 関数は値を返すことはできません。

`return` 文に式が含まれていますが、宣言されている関数の型が `void` 型になっています。 このメッセージを生成するコードの例を次に示します。

    void v(void){
    return 3;
    }

メッセージ ID: E_VOID_CANT_RETURN_VALUE

## ND1 ツリーのためのメモリーを割り当てられません。

コンパイラが malloc() を内部で使用しようとしましたが、失敗しました。通常、スワップ領域が不足していることが原因です。

メッセージ ID: E_CANT_MALLOC_ND1_TREE

## オペランドのサイズが不明です。

サイズが未知のオペランドに対して、++、--、または = の演算子を適用しています。オペランドは通常、メンバーが宣言されていない構造体または共用体へのポインタです。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	struct s *sp;
    	sp++;
    }

メッセージ ID: E_UNKNOWN_OPERAND_SIZE

## 列挙型定数の型が異なっています。

このメッセージは、`-v` オプションを指定している場合に表示されます。関係演算子を使用して、列挙型が異なる 2 つの列挙定数を比較しており、 これがエラーの原因となっています。列挙定数の値はコンパイル時に確定するので、比較の意味もその時にわかります。 このメッセージを生成するコードの例を次に示します。

    enum e1 { ec11, ec12 } ev1;
    enum e2 { ec21, ec22 } ev2;
    void v(void){
    	if (ec11 > ec22)
    		;
    }

メッセージ ID: E_ENUM_CONSTS_HAVE_DIFF_TYPES

## オペランドのポインタ型に互換性がありません。

異なる型を指すポインタに対して、演算子を使用しています。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	char *cp;
    	int *ip;
    	if (ip < cp)
    		;
    }

メッセージ ID: E_OPERANDS_INCOMPAT_PTR_TYPES

## ポインタ / 整数の組み合わせは不適切です。

演算子の一方のオペランドがポインタで、もう一方のオペランドが整数になっています。この組み合わせは不適切です。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int i = "abc";
    	int j = i ? 4 :"def";
    }

メッセージ ID: E_BAD_PTR_INT_COMBINATION

## ポインタ / 整数の組み合わせは不適切です。

スコープ内に関数プロト型宣言がある関数を呼び出すときに、ポインタが必要な箇所で整数が渡されています。または、整数が必要な箇所でポインタが渡されています。 このメッセージを生成するコードの例を次に示します。

    int f(char *);
    g(void){
    	f(5);
    }

メッセージ ID: E_BAD_PTR_INT_COMB_ARG

## -Xc モードでは long long は許可されません。

データ型 long long int および unsigned long long int は ANSI C 標準ではないので、-Xc オプションを指定している場合には使用できません。

メッセージ ID: E_LONG_LONG_NOT_ALLOWED_XC

## 型の組み合わせが不適切です。

宣言の中で使用されている型識別子の組み合わせが不適切です。 このメッセージを生成するコードの例を次に示します。

    short float f;

メッセージ ID: E_INVALID_TYPE_COMBINATION

## 型のあとの記憶クラスは廃止予定です。

このメッセージは、`-v` オプションを指定している場合に表示されます。 ANSI C 標準では、記憶クラス指示子を最初に記述して宣言を行う必要があります。 このメッセージを生成するコードの例を次に示します。

    int static i;

メッセージ ID: E_TYP_STORAGE_CLASS_OBSOLESCENT

## 許可される記憶クラスは 1 つだけです

宣言中に複数の記憶クラスが指定されています。 このメッセージを生成するコードの例を次に示します。

    f(void){
    register auto i;
    }

メッセージ ID: E_ONLY_ONE_STORAGE_CLASS_ALLOWD

## auto/register はここでは不適切です。

関数の外に置かれた宣言で、`auto` または `register` の 記憶クラスが使用されています。 このメッセージを生成するコードの例を次に示します。

    auto int i;
    f(void){
    }

メッセージ ID: E_AUTO_REG_INAPPROPRIATE_HERE

## 仮引数の記憶クラスとして有効なのは register だけです。

関数プロト型宣言で、記憶クラス指示子を指定することができますが、指定できるのは `register` だけです。 このメッセージを生成するコードの例を次に示します。

    int f(
    	register int x,
    	auto int y
    );

メッセージ ID: E_ONLY_REG_VALID_FORMAL_PARAM

## typedef の変更は無視されました。

ANSI C では、型修飾子で `typedef` による定義を変更します。 このメッセージを生成するコードの例を次に示します。

    typedef int INT;
    unsigned INT i

メッセージ ID: E_MODIFY_TYPEDEF_IGNORED

## typedef によってすでに修飾されています。

型識別子に、`typedef` によって定義された型と明示的な型修飾子が含まれています。`typedef` による宣言時に、すでに修飾子が指定されています。 このメッセージを生成するコードの例を次に示します。

    typedef volatile int VOL;
    volatile VOL v;

メッセージ ID: E_TYPE_DEF_ALREADY_QUALIFIED

## typedef によって定義された型への参照が明確ではありません。

関数のプロト型宣言が、`typedef` によって `union`、`struct`、または `enum` として定義された名前で参照しています。その `struct`、`union`、または `enum` による定義は関数内で宣言されているため、プロト型宣言されている関数を定義する時にはスコープ外になります。したがって、プロト型宣言と関数定義が一致しなくなります。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	struct s { int x;};
    	typedef struct s ST;
    	extern int g(ST, struct s);
    }

メッセージ ID: E_DUBIOUS_REF_TYPEDEF

## long float ではなく double を使用してください。

オブジェクトまたは関数が `double` と同義の `long float` として宣言されています。`long float` は、C コンパイラでは移行措置として使用できますが、ANSI C では認められていません。 このメッセージを生成するコードの例を次に示します。

    long float f = 1.0;

メッセージ ID: E_USE_DOUBLE_INSTEAD_LONG_FLOAT

## * のあとに許可されるのは修飾子だけです。

宣言中で、* のあとには、`const` または `volatile` の型修飾子のみを指定することができます。 このメッセージを生成するコードの例を次に示します。

    int * const p;
    int * unsigned q;

メッセージ ID: E_ONLY_QUALS_ALLOWED_AFTER_STAR

## 添字がゼロまたは負です。

配列のサイズが、ゼロまたは負の数に宣言されています。 このメッセージを生成するコードの例を次に示します。

    int ia[-5];
    int ib[0];

メッセージ ID: E_ZERO_OR_NEGATIVE_SUBSCRIPT

## 配列の次元が大きすぎます。

配列の宣言における次元の組み合わせによって、対象マシンには大き過ぎるオブジェクトが宣言されています。 このメッセージを生成するコードの例を次に示します。

    int bigarray[2000000000];

メッセージ ID: E_ARRAY_DIMENSION_TOO_BIG

## パラメータの再宣言

関数定義中で、パラメータ名として同じ名前が複数回使用されています。 このメッセージを生成するコードの例を次に示します。

    int f(int i, int i) { }
    int g(i,j)
    int i;
    int i;
    { }

メッセージ ID: E_PARAM_REDECLARED

## パラメータで "$" が使用されています。

-Xt オプションを使用している場合に、パラメータの識別子中に "$" を 使用しています。これは、-Xa オプションまたは -Xc オプションを使用した場合には、構文エラーとなります。 このメッセージを生成するコードの例

    int f(int i$j ){ };

メッセージ ID: E_DOLLAR_USED_IN_PARAMETER

## 識別子で "$" が使用されています。

-Xt オプションを使用している場合に、識別子中に "$" を使用しています。これは、-Xa オプションまたは -Xc オプションを使用した場合には、構文エラーとなります。 このメッセージを生成するコードの例を次に示します。

    int a$b;

メッセージ ID: E_DOLLAR_USED_IN_IDENTIFIER

## ANSI C では "..." の前に仮引数が必要です。

このメッセージは、`-Xc` および `-v` オプションを指定している場合に表示されます。K&R C では、可変数の引数を指定して固定の引数を 1 つも使用せずに、関数を定義することができます。ANSI C では、少なくとも 1 つの固定引数が必要です。 このメッセージを生成するコードの例を次に示します。

    f(...){}

メッセージ ID: E_ANSI_REQS_FRML_PARM_BFORE_DOT

## "void" は唯一の引数でなければなりません。

関数プロト型宣言中で、最初で 1 つのパラメータだけが `void` 型を使用できます。 このメッセージを生成するコードの例を次に示します。

    int f(int,void);

メッセージ ID: E_VOID_MUST_BE_SOLE_PARAMETER

## 次元が NULL

配列の次元が NULL であってはならない箇所で、NULL になっています。 問題の次元が一番外側にある場合は、警告になります。 その他の場合は、エラーになります。 このメッセージを生成するコードの例を次に示します。

    int ia[4][];
    struct s { int x, y[];};
    int i = sizeof(int []);

メッセージ ID: E_NULL_DIMENSION

## 関数の配列または void の配列は宣言できません。

関数の配列または `void` 型の配列を、宣言しようとしています。 このメッセージを生成するコードの例を次に示します。

    int f[5]();

メッセージ ID: E_CANT_DECL_ARY_OF_FUNC_VOID

## 関数は関数または配列を返せません。

戻り値の型が、関数または配列のポインタではなく、関数または配列である関数が宣言されています。 このメッセージを生成するコードの例を次に示します。

    int f(void)[];	/* int の配列を返している関数 */

メッセージ ID: E_FUNC_CANT_RTN_FUNC_ARY

## 旧式の関数定義

このメッセージは、`-fd` オプションを指定している場合に表示されます。旧式の関数定義が使用されています。 このメッセージを生成するコードの例を次に示します。

    int f(a)
    char a;
    { }

メッセージ ID: E_OLD_STYLE_FUNC_DEF

## 旧式の関数宣言

このメッセージは、`-fd` オプションを指定している場合に表示されます。旧式の関数宣言が使用されています。 このメッセージを生成するコードの例を次に示します。

    int f();

メッセージ ID: E_OLD_STYLE_FUNC_DECL

## 関数プロト型の引数には型を宣言する必要があります。

関数プロト型宣言に識別子リストを記述することはできません。型を宣言する必要があります。識別子リストは無視されます。 このメッセージを生成するコードの例を次に示します。

    int f(i);

メッセージ ID: E_FUNC_PROTO_REQ_TYPES

## "void" の修飾子が不適切です。

`void` を単独で使用する場合は、`const` や `volatile` で修飾することはできません。 このメッセージを生成するコードの例を次に示します。

    int f(const void);

メッセージ ID: E_BAD_QUALIFIERS_WITH_VOID

## void 型の引数の名前を宣言することはできません。

関数プロト型宣言で、`void` 型のパラメータ名が宣言されています。 このメッセージを生成するコードの例を次に示します。

    int f(void v);

メッセージ ID: E_VOID_PARAM_CANT_HAVE_NAME

## 識別子リスト中にパラメータがありません。

旧式の関数定義のパラメータ宣言中にある変数が、パラメータ識別子リスト中にはありません。 このメッセージを生成するコードの例を次に示します。

    f(a,b)
    int i;
    {}

メッセージ ID: E_PARAM_NOT_IN_IDENTIFIER_LIST

## asm に旧式の書式のパラメータを定義することはできません。

旧式の C に定義されている asm 関数を使用しています。 このメッセージを生成するコードの例

    int f(a)
    int a;
    {
    	asm(" nop ");
    }

メッセージ ID: E_ASM_CANT_HAVE_OLD_STYLE_PARMS

## 仮引数の名前が指定されていません。

関数プロト型定義で、パラメータ名が指定されていません。 このメッセージを生成するコードの例を次に示します。

    int f(int){
    }

メッセージ ID: E_FORMAL_PARAM_LACKS_NAME

## n 番目の引数 (関数 name) はプロト型宣言と整合していません。

関数に対して関数プロト型宣言をしていますが、旧式の定義方法を使用しています。定義されているパラメータ名の型と、プロト型宣言で使用されている型とが一致していません。 以下に、この診断の例を示します。

    int f(char);
    int f(c)
    char c;
    { }

`f` は、旧式の方法で定義されています。互換性を維持するために、`f` の引数を、デフォルトの引数の型拡張に従って拡張する必要があります。このため、関数が使用するのは、その値の `char` の部分だけですが、`f` に実際に渡されるべき値は、`int` です。このメッセージは、関数が必要としている `int` と、関数プロト型で宣言されている `char` とが不一致であることを示しています。 この不一致は、次の 2 つの方法で解決できます。 o `int f(int);` に関数プロト型を変更する。 o `f` を関数プロト型定義で定義する。

    int f(char);
    int f(char c)
    {}

このメッセージを生成するコードの例を次に示します。

    int f(char *);
    int f(p)
    int *p;
    {}

メッセージ ID: E_PROTOTYPE_MISMATCH_PROMOTE

## 引数 (関数) はプロト型宣言と整合していません。

関数に対して関数プロト型宣言をしていますが、旧式の定義方法を使用しています。定義されているパラメータ名の型と、プロト型宣言で使用されている型とが一致していません。または、指定されているパラメータの数が正しくありません。 プロト型宣言と関数定義を確認してください。 このメッセージを生成するコードの例

    int f(char*, int, char*);     /* プロト型宣言 */

    int f(a, b, c)                /* 関数 f の定義 */
    char* a;
    {
      int b;
    }

`f` は、旧式の方法で定義されています。互換性を維持するために、`f` の引数を、デフォルトの引数の型拡張に従って拡張する必要があります。このため、関数が使用するのは、その値の `char` の部分だけですが、`f` に実際に渡されるべき値は、`int` です。このメッセージは、関数が必要としている `int` と、関数プロト型で宣言されている `char` とが不一致であることを示しています。 この衝突を解決するには、次の 2 つの方法があります。 o `int f(int);` に関数プロト型を変更する。 o 関数プロト型の定義で `f` を定義する。

メッセージ ID: E_PROTOTYPE_MISMATCH

## 引数の数が不一致:宣言では n 個、定義では m 個です。

関数プロト型宣言と関数の旧式の定義において、パラメータの数が一致していません。プロト型宣言でのパラメータ数は n 個、定義でのパラメータ数は m 個です。 このメッセージを生成するコードの例を次に示します。

    int f(int);
    int f(i,j)
    int i,j;
    {}

メッセージ ID: E_PARAM_MISMATCH_DECL_DEFINED

## 定義されていない、または不適切な識別子が型として使用されています。

識別子が、正しくない型の情報によって宣言されています。 型が定義されていない、または型として使用できない識別子が型として使用されている可能性があります。 このメッセージを生成するコードの例を次に示します。

    what id1;
    int id2;
    id2 id3;

メッセージ ID: E_UNDEFINED_OR_NOT_A_TYPE

## 関数定義に () がありません。

関数定義の宣言部分には、括弧を入れる必要があります。`typedef` で、識別子と括弧を付けて関数の型として定義した名前を使用して、関数自体を定義することはできません。 このメッセージを生成するコードの例を次に示します。

    typedef int F();
    F f{ }

メッセージ ID: E_PARENLESS_FUNC_DEF

## 宣言が旧式または型が不適切です。

旧式の方法で型を宣言しているか、不適切な型で代入が行われています。 このメッセージを生成するコードの例を次に示します。

    const int i = 10;
    struct foo {int x; int y;};
    foo = &i;                         /* foo には不適切な型 */

    int f();                          /* 旧式の宣言 */

メッセージ ID: E_OLD_STYLE_DECL_OR_BAD_TYPE

## パラメータを初期化できません。

旧式の関数パラメータ name には、初期設定子を設定することはできません。 このメッセージを生成するコードの例を次に示します。

    int f(i)
    int i = 4; {}

メッセージ ID: E_CANT_INITIALIZE_PARAM

## 構文エラー: 宣言が空です。

ファイルスコープに空の宣言文と思われる文があります。K&R C では有効ですが、ANSI C では無効です。 このメッセージを生成するコードの例を次に示します。

    int i;;

メッセージ ID: E_EMPTY_DECLARATION

## 現在のブロックスコープではこの静的関数の定義は不確実です。

このメッセージは、`-Xc` オプションを指定している場合に表示されます。 ブロックスコープで、記憶クラス `static` の関数が宣言されています。ANSI C の場合、ブロックスコープで `extern` 以外の記憶クラスを明示的に使用して関数を宣言すると、動作が未定義になります。K&R C の場合は、この方法で関数を宣言できます。その他のインプリメンテーションでは、この方法を使用することはできません。別の意味が加わることがあります。 このメッセージを生成するコードの例を次に示します。

    void
    f(void){
    	static void g(void);
    }

メッセージ ID: E_STATIC_FUNC_AT_BLOCK_LEVEL

## asm 文は関数の外では使用できません。

"asm" が、関数定義の外で使用されています。 このメッセージを生成するコードの例を次に示します。

    asm(" nop ");
    asm(int f());
    int f() {
    	asm(" ...");
    }

メッセージ ID: E_ASM_VALID_ONLY_FOR_FUNC_DEF

## typedef が有効なのは関数宣言だけです。

関数の定義に、`typedef` で定義された記憶クラスを使用することはできません。そのような typedef で定義された記憶クラスは無視されます。 このメッセージを生成するコードの例を次に示します。

    typedef int f(void){}

メッセージ ID: E_TYPEDEF_VALID_ONLY_FUNC_DEF

## 関数の記憶クラスは static または extern にする必要があります。

関数の宣言または定義において、無効な記憶クラス指示子が使用されています。記憶クラスは省略可能です。また、使用できる指示子は `extern` および `static` だけです。使用された指示子は無視されます。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	auto g(void);
    }

メッセージ ID: E_SC_FUNC_MUST_STATIC_OR_EXTERN

## "extern" 宣言を初期化できません。

関数の中で `extern` 記憶クラスを使用してオブジェクトを宣言する場合に、初期設定子を使用することはできません。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	extern int i = 1;
    }

メッセージ ID: E_CANT_INIT_EXTERN_DECL

## 修正継続機能 再初期化できません。

このメッセージは、修正継続機能を使用して `dbx` からオプションを呼び出した場合に表示されます。`static` 変数を、プログラムの開始時に設定されていた値に再初期化することはできません。このメッセージは、入れ子になったブロック内で変数を宣言した時に出力されます。 また、#pragma weak var1 = var2 の var2 に対しても出力されます。さらに、static として再宣言された外部変数に対しても出力されます。 このメッセージを生成するコードの例 (入れ子になったブロック中で変数が宣言されている)

    void main(int argc, char *argv[])
    {
    		static int g ;

    		{
    		static int k ; /* 再初期化できません */
    		.........
    		}
    }

メッセージ ID: E_CANT_FIXCONTINUE_REINITIALIZE

## typedef は初期化できません。

`typedef` には、初期設定子を設定することはできません。 このメッセージを生成するコードの例を次に示します。

    typedef int INT = 1;

メッセージ ID: E_CANT_INIT_TYPEDEF

## 関数は初期化できません。

関数として宣言した名前には、初期設定子を設定することはできません。 このメッセージを生成するコードの例を次に示します。

    int f(void) = 3;

メッセージ ID: E_CANT_INIT_FUNCTION

## const オブジェクトに初期値が指定されていません。

このメッセージは、`-v` オプションを設定している場合に表示されます。`const` オブジェクトは変更できません。初期値を指定しないと、オブジェクトの値はゼロになります。自動変数の場合、値は未定義になります。 このメッセージを生成するコードの例を次に示します。

    const int i;

メッセージ ID: E_CONST_OBJ_SHOULD_HAVE_INITIZR

## 識別子が再宣言されました。

識別子が宣言されましたが、同じ識別子について以前に行われた宣言と矛盾 しているか、同じスコープで 2 回宣言されています。 K&R C の以前のリリースでは、2 つの型が同じに「近い」ときは (たとえば、SPARC における `int` と `long` など)、 矛盾する再宣言が許されていました。 しかし、ANSI C ではこのような型は 異なるものと見なされます。

    int x;
    long x;
    int y;
    double y;

関数の宣言で、引数情報の有無にかかわらず、出力されるメッセージの意味がわかりにくい場合があります。次の例を参照してください。

    int f(char);
    int f();

ANSI C の型の互換性に関する規則によって、型を指定していない関数宣言 (関数プロト型宣言以外の関数宣言) は、各パラメータの型がデフォルトの引数拡張規則によって変更されない場合のみ、関数プロト型と互換性が保たれます。この例では、`char` が拡張規則によって、`int` に拡張されます。したがって、2 つの宣言の型には、互換性がないことになります。

メッセージ ID: E_IDENTIFIER_REDECLARED

## 識別子の再定義

識別子が複数回定義されています。すなわち初期設定子によって、オブジェクトが複数回宣言されています。または、関数が複数回定義されています。 このメッセージを生成するコードの例を次に示します。

    int i = 1;
    int i = 1;

メッセージ ID: E_IDENTIFIER_REDEFINED

## 宣言によってパラメータは無効になります。

関数のパラメータのうちの 1 つと同じ名前で、識別子が宣言されています。このブロック中でその識別子を参照すると、新しい宣言が参照されます。`-Xa` モードまたは `-Xc` モードの場合は、エラーになります。その他のモードの場合は、警告になります。 このメッセージを生成するコードの例を次に示します。

    int f(int i,int INT){
    	int i;
    	typedef int INT;
    }

メッセージ ID: E_DECLARATION_HIDES_PARAMETER

## 識別子の再宣言;ANSI C では "static" が必要です。

ファイルスコープで name が 2 回宣言されています。最初の宣言では、`static` の記憶クラスを指定していますが、2 つ目の宣言では記憶クラスが指定されていません。ANSI C の記憶クラスに関する規則では、2 回目以降に name を 再宣言する場合は、`static` を指定する必要があります。 このメッセージを生成するコードの例を次に示します。

    static int i;
    int i;

メッセージ ID: E_ID_REDECL_ANSI_REQS_STATIC

## extern として宣言されたシンボルがスコープ外で static として再宣言されています。

このメッセージは、`-Xc` または `-v` オプションを指定している場合に表示されます。すでにスコープ外となったブロックで、name が `extern` として宣言され、その後 name が `static` として宣言されています。ANSI C は、このオブジェクトまたは関数を `static` として扱い、ソースファイル中のここより前の参照も含むすべての参照は、`static` として宣言された方を意味します。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	extern int i;
    }
    static int i;

メッセージ ID: E_OUT_SCOPE_EXTERN_REDECL_STAT

## extern として宣言されたシンボルが static として再宣言されています。

このメッセージは、`-Xc` または `-v` オプションを指定している場合に表示されます。名前 name が、ファイルスコープを持つように `extern` として宣言され、次に同じオブジェクトまたは関数が `static` と宣言されています。ANSI C では、最初にオブジェクトまたは関数を宣言する時に、実際の記憶クラスを指定する必要があります。K&R C では、このような宣言は許されており、あたかも最初に `static` と宣言されているかのように、オブジェクトまたは関数が扱われます。 このメッセージを生成するコードの例を次に示します。

    extern int i;
    static int i;

メッセージ ID: E_EXTERN_PRIOR_REDECL_STATIC

## 関数の記憶クラスが不整合です。

ANSI C では、ファイルスコープで関数またはオブジェクトを最初に宣言する時に、記憶クラスを設定する必要があります。name の再宣言の仕方が、ANSI C の規則に適合していません。 このメッセージを生成するコードの例を次に示します。

    g(void){
    	int f(void);
    	static int f(void);
    }

メッセージ ID: E_INCONSISTENT_STOR_CLASS_FUNC

## 外部シンボルが静的として再宣言されています。

name を extern オブジェクトまたは関数の名前として使用したあと、同じブロック中で、static オブジェクトまたは関数の名前として再使用しています。`static` の name だけが利用可能です。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	extern int i;
    	static int i;
    }

メッセージ ID: E_STATIC_REDECLARES_EXTERN

## 外部シンボルが自動変数として再宣言されています。

自動変数 name は、同じブロック中ですでに `extern` シンボルとして宣言されています。ANSI C ではこのような宣言はできませんが、旧リリースの K&R C ではこのような宣言を行うことができます。旧リリースとの互換性を保つために、このブロック中の name を参照すると、自動変数が参照されます。 このメッセージを生成するコードの例を次に示します。

    f(void){
    extern int i;
    int i;
    }

メッセージ ID: E_AUTO_REDECLARES_EXTERNAL

## 外部シンボルが typedef によって再宣言されています。

`typedef` によって name が宣言されていますが、name は同じブロック中ですでに `extern` として宣言されています。`typedef` で定義した識別子によって、`extern` と宣言したシンボルが無効になります。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	extern int INT;
    	typedef int INT;
    }

メッセージ ID: E_TYPEDEF_REDCLS_EXTERN

## typedef によって再宣言されました。

name が `typedef` によって複数回宣言されています。あとの宣言と最初の宣言が同じ型になっています。 このメッセージを生成するコードの例

    typedef int i;
    typedef int i;

メッセージ ID: E_TYPEDEF_REDECLARED

## 整合しない型で外部シンボルが再宣言されています。

記憶クラスが `extern` である関数またはオブジェクト name が、スコープ外で再宣言されています。2 回目の宣言の型が、最初の宣言の型と一致しません。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int *p = (int *) malloc(5*sizeof(int));
    }
    g(void){
    	void *malloc();
    }

メッセージ ID: E_INCONSISTENT_REDECL_EXTERN

## 整合しない型で静的シンボルが再宣言されています。

記憶クラス `static` によって宣言されたオブジェクトまたは関数が再宣言されています。 2 回目の宣言の型が、最初の宣言の型と矛盾しています。 この問題は、以下の 2 つの状況で頻繁に発生します。 o 関数が、ファイルスコープ以外のスコープを持つ、記憶クラス `static` として宣言された。その後、最初の宣言の型と矛盾する型で、その関数を宣言した。 o 関数またはオブジェクトが、ファイルスコープを持つ、記憶クラス `static` として宣言された。その後、同じ関数またはオブジェクトが、ファイルスコープ以外のスコープを持ち、記憶クラス `extern` または、(関数の場合は) 記憶クラスなしで再宣言された。そして、途中に同じ名前だが無関係の宣言がある。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	static int myfunc(void);
    }
    g(void){
    	static char *myfunc(void);
    }
    static int x;
    f(void){
    	int x;				/* 関連なし */
    {
    		extern float x;		/* 最初の宣言に関連なし */
    	}
    }

メッセージ ID: E_INCONSISTENT_REDECL_STATIC

## 旧式の宣言によってプロト型宣言が無効になります。

このメッセージは、`-v` オプションを指定している場合に表示されます。 内側のスコープ内で、関数 name が再宣言されています。外側の宣言は関数プロト型宣言ですが、内側の宣言に引数の情報がありません。ANSI C のスコープに関する規則によって、引数情報は一時的に無効となり、プロト型によって行われるはずの自動型変換が行われなくなります。 このメッセージを生成するコードの例を次に示します。

    extern double sin(double);
    f(void){
    	extern double sin();
    	double d;
    	d = sin(1);			/* 注: double 型に変換されない */
    }

メッセージ ID: E_OLD_STYLE_DECL_HIDES_PROTO

## 型の種類は実際には "type tag"です。

このメッセージは、`-Xt` オプションを指定している場合に表示されます。型が、`struct`、`union`、または `enum` の型識別子とタグによって宣言されており、その後元の宣言で使用した型識別子とは別の識別子を使用して宣言されています。 旧リリースの K&R C では、2 つの型を同じものとして扱います。ANSI C (`-Xa` または `-Xc` オプション) では、それぞれ別の型として扱われます。 このメッセージを生成するコードの例を次に示します。

    struct s { int x, y, z;};
    f(void){
    unions foo;
    }

メッセージ ID: E_BASE_TYPE_IS_REALLY

## ANSI C では新しい型で置き換えてしまう型の宣言です。

このメッセージは、`-Xt` オプションを指定している場合に表示されます。 内側のスコープで、`struct`、`union`、または `enum` のタグが宣言されています。旧リリースの K&R C では、このタグは既存のタグ宣言を参照します。ANSI C では、このタグは新しいタグを使用します。`-Xt` オプションを指定すると、旧リリースの動作が行われます。 このメッセージを生成するコードの例を次に示します。

    struct s1 { int x;};
    f(void){
    	struct s1;
    	struct s2 { struct s1 *ps1;}; /* s1 は 1 行目を参照します */
    	struct s1 { struct s2 *ps2;};
    }

メッセージ ID: E_DECL_INTRODUCES_NEW_TYPE_ANSI

## 宣言が無意味です。

ANSI C では、各宣言ごとに次のものを実際に宣言する必要があります。 o 宣言子 o 構造体タグまたは共用体タグ o 列挙定数 宣言によってコンパイラに渡される情報はありません。 このメッセージを生成するコードの例を次に示します。

    int;				 	/* 識別子がない */
    enum e { e1, e2 };			/* enum e の宣言 */
    enum e;					/* 新しい情報なし */

メッセージ ID: E_USELESS_DECLARATION

## 列挙型を定義する以前に宣言しています。

このメッセージは、`-v`、`-Xa` または `-Xc` オプションを指定している場合に表示されます。空の列挙型を指定している宣言があります。列挙型は、宣言する前に定義する必要があります。 このメッセージを生成するコードの例を次に示します。

    enum test *ptr;

メッセージ ID: E_FWD_DECLARING_ENUM

## typedef の宣言に型の名前が指定されていません。

`typedef` 記憶クラスによる宣言で、型の名前が宣言されていません。プログラミングエラーだと思われます。 このメッセージを生成するコードの例を次に示します。

    typedef struct s { int x;};

メッセージ ID: E_TYPEDEF_DECLARES_NO_TYPE_NAME

## "type" タグが再宣言されています。

type であったタグ name を再宣言しています。 このメッセージを生成するコードの例を次に示します。

    struct q { int m1, m2;};
    enum q { e1, e2 };

メッセージ ID: E_TAG_REDECLARED

## 関数プロト型宣言に不明確なタグがあります。

タグによって、`struct`、`union`、または `enum` が関数プロト型宣言で参照されています。すでに関数中でタグが宣言されているので、プロト型宣言されている関数を定義する時には、スコープ外になります。このため、プロト型宣言と関数定義が一致しません。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	struct s {int x;};
        int g(struct s *);
    }

メッセージ ID: E_DUBIOUS_TAG_IN_FUNC_PROTO

## 型の宣言が不明確です; タグだけを使用してください。

`struct`、`union`、または `enum` 型 が、関数のプロト型宣言のスコープ中で宣言されているか、または、旧式の関数定義のパラメータリスト中で宣言されていて、宣言中にそのデータ型の宣言子リストが含まれています。ANSI C のスコープ規則によると、タグの宣言は関数のプロト型宣言または定義の最後でスコープ外となるので、関数呼び出しの箇所で、常に型の不一致が発生します。関数のプロト型宣言以外の箇所で、その型のオブジェクトを宣言することが できません。関数のプロト型宣言または関数を定義する前に、`struct`、`union`、`enum` 型を宣言し、関数のプロト型宣言中ではそれをタグによって参照してください。 このメッセージを生成するコードの例

    struct s {int x;};
    int f(struct s st)
    {}

================= /* 正しい例 */

    int f(struct s {int x;} st)
    {}

メッセージ ID: E_DUBIOUS_DECL_USE_TAG_ONLY

## 構造体 / 共用体 / 列挙型の宣言が不明確です: タグだけを使用してください。

`struct`、`union`、または `enum` 型が、関数のプロト型宣言のスコープ中で宣言されています。 つまり、`struct`、`union`、または `enum` 型が、関数のプロト型宣言中で宣言されているか、旧式の関数定義のパラメータリスト中で宣言されていて、宣言中にそのデータ型の宣言子リストが含まれています。ANSI C のスコープ規則によると、タグの宣言は関数のプロト型宣言または定義の最後でスコープ外となるので、関数呼び出しの箇所で、常に型の不一致が発生します。関数のプロト型宣言以外の箇所で、その型のオブジェクトを宣言することが できません。関数のプロト型宣言または関数を定義する前に、`struct`、`union`、`enum` 型を宣言し、関数のプロト型宣言中ではそれをタグによって参照してください。 このメッセージを生成するコードの例

    int f(struct {int x; int y;}; )
    struct s foo;
    { }
    ============
    /* 正しい例 */
    struct s {int x; int y;};
    int f(struct s foo)
    { }

メッセージ ID: E_DUB_DECL_USE_TAG_ONLY_UNNAMED

## タグの宣言が不明確です。

新しく `struct`、`union`、または `enum` 型が、関数のプロト型宣言中で宣言されているか、旧式の関数定義のパラメータリスト中でタグによって宣言されています。ANSI C のスコープに関する規則によると、タグの宣言は関数のプロト型宣言または定義の最後でスコープ外となるので、関数呼び出しの箇所で、常に型の不一致が発生します。その型のオブジェクトを、関数以外の箇所で宣言することができません。 このメッセージを生成するコードの例を次に示します。

    int f(struct s *);

メッセージ ID: E_DUBIOUS_TAG_DECLARATION

## タグの宣言が不明確です (名前なし)

新しく `struct`、`union`、または `enum` 型が、関数のプロト型宣言中で宣言されているか、旧式の関数定義のパラメータリスト中で宣言されています。ANSI C のスコープに関する規則によると、タグの宣言は関数のプロト型宣言または定義の最後でスコープ外となるので、関数呼び出しの箇所で、常に型の不一致が発生します。その型のオブジェクトを、関数以外の箇所で宣言することができません。

メッセージ ID: E_DUBIOUS_TAG_DECL_UNNAMED

## 共用体のメンバーに名前がありません。

共用体の宣言で、メンバーに名前がありません。 このメッセージを生成するコードの例を次に示します。

    union s { int i; char c;};

メッセージ ID: E_UNNAMED_UNION_MEMBER

## 構造体のメンバーに名前がありません。

構造体の宣言で、メンバーに名前がありません。 このメッセージを生成するコードの例を次に示します。

    struct s { int i; char c;};

メッセージ ID: E_UNNAMED_STRUCT_MEMBER

## 移植性のないビットフィールド型

このメッセージは、`-Xc` オプションを指定している場合に表示されます。 `signed int` または `unsigned int` 以外のビットフィールド型が使用されています (signed int または unsigned int の ビットフィールド型のみが移植性があります)。ANSI C では、`int`、`char`、`short`、および `long` のビットフィールド型がサポートされています。それぞれの型は、`signed`、`unsigned`、signed/unsigned の指定なし、のいずれでもかまいません。また、`enum` のビットフィールド型もサポートされています。 このメッセージを生成するコードの例を次に示します。

    1 struct u {
    2 unsigned v:1;
    3 int w:1;
    4 char x:8;
    5 long y:8;
    6 short z:8;
    7 };
    =============
    (3) 警告: 移植性のないビットフィールド型
    (4) 警告: 移植性のないビットフィールド型
    (5) 警告: 移植性のないビットフィールド型
    (6) 警告: 移植性のないビットフィールド型

メッセージ ID: E_NONPORTABLE_BIT_FIELD_TYPE

## ビットフィールドが大きすぎます。

ビットフィールドの宣言で、指定されたビット数が大きすぎるため、宣言した型のオブジェクト中に割り当てられません。 このメッセージを生成するコードの例を次に示します。

    struct s { char c:20;};

メッセージ ID: E_BIT_FIELD_TOO_BIG

## ビットフィールドの型が無効です。

ビットフィールドを指定した型に対しては、ビットフィールドを使用することはできません。ビットフィールドは、整数型に対してのみ宣言できます。 このメッセージを生成するコードの例を次に示します。

    struct s { float f:3;};

メッセージ ID: E_INVALID_TYPE_FOR_BIT_FIELD

## 関数はメンバーにできません。

関数は、構造体または共用体のメンバーにすることはできません。ただし、関数へのポインタはメンバーにすることができます。メンバー名が関数として宣言されています。 このメッセージを生成するコードの例を次に示します。

    struct s { int f(void);};

メッセージ ID: E_MEMBER_CANT_BE_FUNCTION

## メンバー名が重複しています。

`struct` または `union` の宣言で、複数のメンバーに対して同じ名前が使用されています。 このメッセージを生成するコードの例を次に示します。

    union u {
    	int i;
    	float i;
    };

メッセージ ID: E_DUPLICATE_MEMBER_NAME

## 構造体 / 共用体のサイズがゼロです。

サイズがゼロの構造体または共用体が宣言されています。 このメッセージを生成するコードの例を次に示します。

    struct s { int ia[0];};

メッセージ ID: E_ZERO_SIZED_STRUCT_UNION

## 構造体 / 共用体に名前の付いたメンバーがありません。

構造体または共用体の宣言で、メンバーの名前が指定されていません。 このメッセージを生成するコードの例を次に示します。

    struct s { int :4; char :0;};

メッセージ ID: E_STRUCT_UNION_HAS_NO_NAMD_MBRS

## 構造体 / 共用体の最後のメンバーのあとにセミコロン ; が必要です。

構造体または共用体の宣言において、C 構文で最後のメンバーのあとに必要な ; がありません。 このメッセージを生成するコードの例を次に示します。

    struct s { int x };

メッセージ ID: E_SEMI_COLON_REQD_AFT_LAST_MBR

## 識別子が再宣言されました。

同じスコープ内で、識別子が複数回宣言されています。 このメッセージを生成するコードの例を次に示します。

    f(int i) {
    	int j, i;
    }

メッセージ ID: E_ID_REDECLARED

## 列挙型定数によってパラメータが無効になります。

関数中の列挙型の宣言で、引数名 name と同じ名前の列挙定数があります。この列挙定数によって、引数が無効になります。 このメッセージを生成するコードの例を次に示します。

    int
    f(int i){
    	enum e { l, k, j, i };
    }

メッセージ ID: E_ENUM_CONST_HIDES_PARAMETER

## 列挙型の値が INT_MAX (2147483647) をオーバーフローしています。

列挙定数の値が整数の最大値を超えています。 このメッセージを生成するコードの例を次に示します。

    enum e { e1=2147483647, e2 }; /* e2 がオーバーフロー */

メッセージ ID: E_ENUM_VAL_OVERFLOWS_INT_MAX

## 列挙子がそれ自体の初期設定子中で使用されています。

列挙型宣言で、列挙子の値 name を設定する時に、式中で name が使用されています。ANSI C のスコープに関する規則によって、式中の name は、その時点でスコープ内にあるシンボルとして解釈されます。 このメッセージを生成するコードの例を次に示します。

    int i;
    f(void){
    	enum e { i = i+1, j, k };	/* i+1 で大域的な i を使用 */
    }

メッセージ ID: E_ENUM_USED_OWN_INITIALIZER

## 列挙型の宣言では最後に "," は使用できません。

このメッセージは、`-Xc` または `-v` オプションを指定している場合に表示されます。列挙型の宣言の終わりに、余分なカンマがあります。 このカンマは、構文エラーとなります。 このメッセージを生成するコードの例を次に示します。

    enum e { e1, e2, };

メッセージ ID: E_TRAILING_COMMA_IN_ENUM

## { }で囲まれた初期設定子が必要です。

集合体を初期化するときに、{ } で初期設定子を囲む必要があります。ただし文字列リテラルで文字配列、または式で自動構造体を初期化する場合を除きます。 このメッセージを生成するコードの例を次に示します。

    int ia[5] = 1;
    f(void){
    	struct s { int x,y; } st = 1;
    }

メッセージ ID: E_INIT_REQUIRED

## 構造体 / 共用体の値をもつ初期設定子が必要です。

ANSI C では、自動構造体または自動共用体を初期化できます。ただし初期設定子は、初期化するオブジェクトと同じ型にする必要があります。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int i;
    	struct s { int x; } st = i;
    }

メッセージ ID: E_STRUCT_UNION_INIT_REQUIRED

## 初期設定子が適合していないか範囲を超えています。

値が、与えられた変数の記憶領域に収まりません。値をこの領域から読み出しても、格納しようとした値と異なる場合があります。メッセージには、初期設定子が `unsigned` の場合は 16 進数、また `signed` の場合は 10 進数で値が示されます。 `0x80` から `0xff` までの 16 進値は、`char` には適合しません。`0x8000` から `0xffff` の値は `short` に適合しません。 また、`0x80000000` から `0xffffffff` までの値は、`int` には適合しません。 ただしこれらの値は、それぞれ対応する `unsigned` 型には適合します。 このメッセージを生成するコードの例を次に示します。

    struct s {signed int m1:3; unsigned int m2:3;} st = {4, 5};
    unsigned char uc = 300u;

メッセージ ID: E_INIT_DOES_NOT_FIT

## 文字列リテラルは単独の配列初期設定子でなければなりません。

文字配列を、文字列リテラルと別の値で同時に初期化することはできません。 このメッセージを生成するコードの例を次に示します。

    char ca[] = { "abc", 'd' };

メッセージ ID: E_STR_LIT_ARRAY_INIT

## 初期設定子の余分な n バイト分の文字列リテラルは無視されました。

文字配列を初期化する文字列リテラルの文字数が、n 文字多すぎて配列に収まりません。 このメッセージを生成するコードの例を次に示します。

    char ca[3] = "abcd";

メッセージ ID: E_EXTRA_BYTE_IN_STR_IGNORED

## 初期設定値が定数でありません。

外部 (`extern`)、静的 ( `static`)、または配列オブジェクトは、コンパイル時の定数でなければなりません。 自動構造体または共用体オブジェクトの初期設定子も、`{}` で囲まれている場合は、やはりコンパイル時の定数でなければなりません。メッセージ中の演算子は、コンパイル時に結合されないオペランドの演算子を示します。 このメッセージを生成するコードの例を次に示します。

    int j;
    int k = j+1;

メッセージ ID: E_NON_CONST_INIT

## 構造体 / 共用体の初期設定子が多すぎます。

構造体または共用体に対する初期設定子の数が多すぎます。 このメッセージを生成するコードの例を次に示します。

    struct s { int x,y; } st = { 1,2,3 };

メッセージ ID: E_TOO_MANY_STRUCT_UNION_INIT

## 配列の初期設定子が多すぎます。

配列の初期設定子の数が多すぎます。 このメッセージを生成するコードの例を次に示します。

    int ia[3] = { 1, 2, 3, 4 };

メッセージ ID: E_TOO_MANY_ARRAY_INIT

## スカラーの初期設定子が多すぎます。

中括弧 { } で囲んだスカラーの初期設定で、複数の値が指定されています。 このメッセージを生成するコードの例を次に示します。

    int i = { 1, 2 };

メッセージ ID: E_TOO_MANY_INIT_SCALAR

## 初期設定子の符号が拡張されます。

オブジェクトの初期化に使用する値は、そのオブジェクトに適するように変換するときに符号が拡張されます。 このメッセージを生成するコードの例を次に示します。

    unsigned int x = -3;

メッセージ ID: E_INIT_SIGN_EXTEND

## -xO3 以上の最適化レベルが指定されていないため、-xcrossfile オプションが無視されました。

-xcrossfile オプションを使用する時には、-xO3 以上の最適化レベルを指定する必要があります。

メッセージ ID: E_XO3_NOT_SPECIFIED

## 文字定数中に改行文字があります。

文字定数を囲む左の ' に対応する右の ' が同じ行中にありません。 このメッセージを生成するコードの例を次に示します。

    int i = 'a
    ;

メッセージ ID: E_NEWLINE_IN_CHAR_CONST

## 無効な文字列があります。

このメッセージは、`-Xa` または `-Xc` のオプションを指定している場合にエラーが発生すると、表示されます。ソースプログラム中に、有効な ANSI C トークン以外の文字があります。 このメッセージを生成するコードの例を次に示します。

    int i = 1$;

メッセージ ID: E_INVALID_SOURCE_CHARACTER

## 無効な文字列があります。

ソースプログラム中に、有効な ANSI C トークン以外の文字があります。無効な文字自体は表示できません。無効な文字自体は表示できません。メッセージ中の 16 進数は、文字コードの 16 進値を表わしています。

メッセージ ID: E_INVALID_UNPRINTABLE_SRC_CHR

## 無効なトークンがあります。

C 言語のトークンの書式に従っていない文字列があります。トークンとは、C 言語における最小の意味単位です。トークンには、``予約語`、`識別子`、`定数`、`文字列リテラル`、`演算子`、`区切り子`があります。` このメッセージを生成するコードの例を次に示します。

    5d
    int 1e = 1; /* トークンの先頭に数字を使用することはできない */

メッセージ ID: E_INVALID_TOKEN_LEX

## 無効なトークンがあります。

C 言語のトークンの書式に従っていない文字列があります。トークンとは、C 言語における最小の意味単位です。トークンには、``予約語`、`識別子`、`定数`、`文字列リテラル`、`演算子`、`区切り子`があります。` このメッセージを生成するコードの例を次に示します。

    char 2whateveritistoolongmorethan255character... ;   /* 長すぎる文字列 */

メッセージ ID: E_INVALID_TOKEN_TOO_LONG_LEX

## ワイド文字列リテラルと標準文字列リテラルを連結することはできません。

標準文字の文字列リテラルとワイド文字の文字列リテラルを、混用して結合することはできません。たとえば、ワイド文字の文字列リテラルのあとに標準文字列リテラルを続けると、警告が出力されます。この場合は、両方がワイド文字として扱われます。また、標準文字列リテラルのあとにワイド文字の文字列リテラルを続けると、エラーとなります。 このメッセージを生成するコードの例を次に示します。

    #include
    wchar_t wa[] = L"abc" "def";
    char a[] = "abc" L"def";

メッセージ ID: E_CANT_CONCAT_WIDE_REG_STRINGS

## -Xa および -Xt を使用している場合、_Restrict は予約語です。

-Xa または -Xt オプションを使用している場合、`_Restrict` は、C 言語の予約語です。 このメッセージを生成するコードの例を次に示します。

    void func(int * _Restrict intptr);

メッセージ ID: E_KEYWORD_FOR_XA_AND_XT

## __asm は、ANSI C の拡張機能です。

-Xc オプションを指定している場合は、"__asm" 文を使用するとメッセージが出力されます。ANSI C に厳密に準拠するプログラムでは、"__asm" 関数を使用することはできません。 このメッセージを生成するコードの例を次に示します。

    int f(int a) {
    	__asm(" nop ");
    }

メッセージ ID: E_ASM_IS_AN_EXTENSION_OF_ANSI

## 文字エスケープがワイド文字に収まりません。

`L` のあとに続く文字定数または文字列リテラルの中に 16 進数 または 8 進数のエスケープシーケンスがあると、`unsigned char` の範囲を超える値が生成されます。文字エスケープが大きすぎて、`wchar_t` 型のオブジェクトに収まらないため、切り捨てられます。

メッセージ ID: E_CHR_ESC_DOES_NOT_FIT_WCHAR

## double 型への変換が範囲を超えています。

式の値が大きすぎて、double に変換できません。このような式が実行されるコード中にある場合は、警告です。その他の場合は、エラーです。 このメッセージを生成するコードの例を次に示します。

    double f() {
    	return 0xFFFFFFFFFFFFFFFF;
    }

メッセージ ID: E_CONV_TO_DOUBLE_OUT_OF_RANGE

## float 型への変換が範囲を超えています。

式の値が大きすぎて、float にできません。このような式が実行されるコード中にある場合は、警告です。その他の場合は、エラーです。 このメッセージを生成するコードの例を次に示します。

    float f = 1e300 * 1e300;

メッセージ ID: E_CONV_TO_FLOAT_OUT_OF_RANGE

## double 型から整数型への変換が範囲を超えています。

`double` 定数の値が大きすぎて、整数型にできません。このような式が実行されるコード中にある場合は、警告になります。その他の場合は、エラーになります。 このメッセージを生成するコードの例を次に示します。

    int i = 1e100;

メッセージ ID: E_CONV_DOUBLE_INTEGRAL_OUT_RNGE

## シフト回数が負または大きすぎます。

シフト演算子のシフト回数 (右のオペランド) が負の値になっているか、シフトするオペランドのサイズを超えています。 このメッセージを生成するコードの例を次に示します。

    f(){
    	short s;
    	s <<= 25;
    }

メッセージ ID: E_SHIFT_CNT_NEG_TOO_BIG_L

## シフト回数が負または大きすぎます。

シフト演算子のシフト回数 (右オペランド) が負の値になっているか、シフトするオペランドのサイズを超えています。 このメッセージを生成するコードの例を次に示します。

    f(){
    	short s;
    	s <<= 25;
    }

メッセージ ID: E_SHIFT_CNT_NEG_TOO_BIG

## 整数のオーバーフローが検出されました

コンパイル時に、演算子の式を計算しようとし、結果がオーバフローすると判断されました。結果の下位 32 ビットが保持されます。 このメッセージを生成するコードの例を次に示します。

    int i = 1000000 * 1000000;

メッセージ ID: E_INTEGER_OVERFLOW_DETECTED

## 浮動小数点定数の演算が範囲を超えました。

コンパイル時に 2 つの浮動小数点オペランド間で演算を行おうとしましたが、オーバフローがあります。実行されるコード中に式がある場合は、警告になります。その他の場合は、エラーになります このメッセージを生成するコードの例を次に示します。

    double d1 = 1e300 * 1e300;

メッセージ ID: E_FP_CONST_CALC_OUT_OF_RANGE

## ループを先頭以外の場所から開始しています。

`for` または `while` ループの始まりの制御式に、その前にある制御文のために到達できません。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int i;
    	goto lab;
    	for (i = 1; i > 0; --i) {
    lab:;
    		i=5;
    	}
    }

メッセージ ID: E_LOOP_NOT_ENTERED_AT_TOP

## 到達できない文です。

`goto`、`break`、`continue` または `return` の文が前にあるために、到達することができない文があります。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int i;
    	return i;
    	i = 4;
    }

メッセージ ID: E_STATEMENT_NOT_REACHED

## 関数中に return 文がありません。

このメッセージは、`-v` オプションを指定している場合に表示されます。関数には、`return` 文を入れる必要があります。 このメッセージを生成するコードの例を次に示します。

    #include
    main(void)
    {
    	(void) printf("Do the hippy-hippy shake.\n");
    }

メッセージ ID: E_FUNC_HAS_NO_RETURN_STMT

## ラベルが再定義されています。

現在の関数の複数の位置で、同じラベル名が使用されています。1 つのラベルのスコープは関数全体です。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int i;
    	i = 1;
    	if (i) {
    L:
    		while (i)
    			g();
    		goto L;
    	}
    L:  ;
    }

メッセージ ID: E_LABEL_REDEFINED

## ループの終了コードに到達できません。

ループの終わりにある先頭に戻るためのコードに、到達および実行できないループがあります。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int i = 1;
    	while (i) {
    		return 4;
    	}
    }

メッセージ ID: E_END_OF_LOOP_CODE_NOT_REACHED

## "break" がループまたは switch 文の外にあります。

関数中で、`break` 文の位置が正しくありません。たとえば、break 文が、`ループ`文または `switch` 文の外にあります。 このメッセージを生成するコードの例を次に示します。

    f(void){
        break;
    }

メッセージ ID: E_BREAK_OUTSIDE_LOOP_OR_SWITCH

## "continue" がループの外にあります。

`continue` 文が、ループのスコープ内に置かれていません。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	continue;
    }

メッセージ ID: E_CONTINUE_OUTSIDE_LOOP_SWITCH

## この関数は値を返す必要があります。

このメッセージは、`-v` オプションを指定している場合に表示されます。現在の関数が、返す型とともに宣言されていますが、`return` 文に戻り値の式が指定されていません。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	return;
    }

メッセージ ID: E_FUNC_EXPECTS_TO_RETURN_VALUE

## switch 式は整数型にする必要があります。

`switch` 文中の制御式が整数型でない文があります。制御式が浮動小数点型である場合は、警告になります。その他の場合は、エラーになります。浮動小数点の `switch` 式は、`int` に 変換されます。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	float x;
    	switch (x) {
    	case 4:  ;
    	}
    }

メッセージ ID: E_SWITCH_EXP_MUST_BE_INTEGRAL

## "case" が switch の外にあります。

case 文が、`switch` 文のスコープ外にあります。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	case 4:  ;
    }

メッセージ ID: E_CASE_OUTSIDE_SWITCH

## case 式が整数ではありません。

`case` 文のオペランドは、整数定数にする必要があります。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int i = 1;
    	switch (i) {
    	case 5.0:  ;
    	}
    }

メッセージ ID: E_NON_INTEGRAL_CASE_EXPRESSION

## "default" が switch の外にあります。

default ラベルが、`switch` 文のスコープ外にあります。 このメッセージを生成するコードの例を次に示します。

    f(void){
    default: ; }

メッセージ ID: E_DEFAULT_OUTSIDE_SWITCH

## switch 文中に "default" が複数あります。

`switch` 文で、2 つの `default` ラベルが使用されています。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int i = 5;
    	switch(i) {
    	default:
    	default:
    		    break;
    	}
    }

メッセージ ID: E_DUPLICATE_DEFAULT_IN_SWITCH

## 到達できない case ラベルがあります。

`case` 文で指定された式の値が、`switch` 文の制御式の型の範囲を超えているため、 case ラベルに到達できません。メッセージ中の value は、`case` 式が `unsigned` 型である場合は 16 進数、`signed` である場合は 10 進数で示されます。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	unsigned char uc;

    	switch( uc ){
    	case 256:
    		;
    	}
    }

メッセージ ID: E_UNREACHABLE_CASE_LABEL

## case ラベルが変換の影響を受けます。

このメッセージは、`-v` オプションを指定している場合に表示されます。`case` ラベルの値 value を、`switch` 文の制御式の型で表わすことができません。 このメッセージは、`case` 式の型と制御式の型が同じサイズで、case 式の実際のビット表現が変わらない場合に出力されます。たとえば、制御式が `int` 型、`case` 式が unsigned int 型の場合に出力されます。メッセージ中の値は、`case` 式が `unsigned` 型である場合は 16 進数、`signed` 型である場合は 10 進数の値で表されます。 以下の例の `0xffffffffu` は、`int` として表すことはできません。`case` 式を制御式の型に変換するとき、有効な値は `-1` になります。すなわち、`i` の値が `0xffffffff` ではなく、`-1` の場合、case に到達します。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	int i;

    	switch( i ){
    	case 0xffffffffu:
    	;
    	}
    }

メッセージ ID: E_CASE_LBL_AFFECTED_CONVERSION

## void 型のオブジェクトは宣言できません。

`void` 型のオブジェクトを宣言することはできません。 このメッセージを生成するコードの例を次に示します。

    void v;

メッセージ ID: E_CANT_HAVE_VOID_OBJECT

## 構造体 / 共用体 / 列挙型の name が不完全

`struct`、`union`、または `enum` 型でオブジェクト名と タグを宣言していますが、型が不完全です。 このメッセージを生成するコードの例を次に示します。

    struct s st;

メッセージ ID: E_INCOMPLETE_STRUCT_UNION_ENUM

## st_save() のメモリーが不足しています。

メモリーが不足しています。ほとんどの場合は、スワップ領域が不足していることが原因となっています。

メッセージ ID: E_ST_SAVE_OUT_OF_MEMORY

## st_lookup() のメモリーが不足しています。

メモリーが不足しています。ほとんどの場合は、スワップ領域が不足していることが原因となっています。

メッセージ ID: E_ST_LOOKUP_OUT_OF_MEMORY

## 定義されていない静的関数が呼び出されています。

`static` として宣言された関数 name が呼び出されていますが、翻訳単位に name という定義がありません。この状況は、翻訳単位全体を確認したあとに判断されるので、メッセージに表示される行番号は、ファイルの全行数に 1 を加えた値になります。 このメッセージを生成するコードの例を次に示します。

    static int statfunc(int);
    void
    f(){
    	int i = statfunc(4);
    }

メッセージ ID: E_STATIC_FUNC_CALLD_NOT_DEFINED

## ラベルが未定義です。

現在の関数に `goto` が使用されていますが、関数中でターゲットのラベルが定義されていません。 このメッセージを生成するコードの例を次に示します。

    f(void){
    	goto L;
    }

メッセージ ID: E_UNDEFINED_LABEL

## 認識できない #pragma が無視されました。

このメッセージは、`-v` オプションを指定している場合に表示されます。 `#pragma` 指令はインプリメンテーションによって異なるため、無視される指令について警告が出力されます。メッセージ中に表示される `#pragma` は認識されません。 このメッセージを生成するコードの例を次に示します。

    #pragma list

メッセージ ID: E_UNRECOGNIZED_PRAGMA_IGNORED

## "#pragma" のあとにトークンがありません。

このメッセージは、`-v` オプションを指定している場合に表示されます。 ほかのトークンがない `#pragma` 指令があります。 このメッセージを生成するコードの例を次に示します。

    #pragma

メッセージ ID: E_NO_TOKENS_FOLLOW_PRAGMA

## do_pragma: メモリーが不足しています。

メモリーが不足しています。ほとんどの場合、スワップ領域が不足していることが原因です。

メッセージ ID: E_DO_PRAGMA_OUT_OF_MEMORY

## 無効な形式の #pragma pack(n) を無視します。

無効な形式の `#pragma pack` があります。無効な指令は無視されます。 このメッセージを生成するコードの例を次に示します。

    #pragma pack

メッセージ ID: E_IGNORE_MALFORMED_PRAGMA_PACK

## #pragma pack の値に誤りがあります。

`#pragma pack` は、構造体のオフセットを制御します。書式は、次のようにする必要があります。

    #pragma pack(n)

`n` には、各プラットフォームでの厳密な境界整列 (Intel = 4, sparc V8 = 8, sparc v9 = 16) より小さな 2 の乗数を指定します。n を省略した場合には、構造体メンバーの配置は自然な境界整列に戻ります。 pragma はすべての構造体メンバーの要求を満たす厳密な境界整列を指定します。pragma で設定した境界整列は、次の pack 指定があるまですべての構造体の メンバーに適用されます。同じ構造体に対して、異なる翻訳単位で異なる pack 指定を行なった場合、プログラムは予期せぬエラーが発生します。特に、すでにコンパイルされているライブラリのインターフェースを定義しているヘッダーファイルをインクルードするより前に pragma pack を指定しないでください。pragma pack 指定をする場合は、対象となる構造体の直前で行い、その構造体 の直後で #pragma pack() 指定を行い自然な境界整列に戻すことを推奨します。 このメッセージを生成するコードの例を次に示します。

    #pragma pack(-2)
    #pragma pack(7)
    #pragma pack(256)

メッセージ ID: E_BAD_PRAGMA_PACK_VALUE

## 無効な形式の #pragma weak シンボルを無視します。

無効な形式の `#pragma weak` があります。無効な指令は無視されます。 このメッセージを生成するコードの例を次に示します。

    #pragma weak write,_write

メッセージ ID: E_IGNORE_MALFORMED_PRAGMA_WEAK

## #pragma unknown_control_flow 中のシンボルが宣言されていません。

`#pragma unknown_control_flow` 中に、宣言されていない関数名があります。`unknown_control_flow` プラグマの書式は、次のとおりです。

      #pragma unknown_control_flow ( 名前 [ , 名前 ... ] )

プラグマで使用する関数は、#pragma 以前に宣言する必要があります。 このメッセージを生成するコードの例を次に示します。

    #pragma unknown_control_flow(foo, bar)
    int foo();
    int bar();

    ============ 正しい例
    int foo();
    int bar();
    #pragma unknown_control_flow(foo, bar)

メッセージ ID: E_UNKNOWN_CTRL_FLOW_UNDECLARED

## `#pragma no_side_effect` 中のシンボルが宣言されていません。

`#pragma no_side_effect` 中に、宣言されていない関数名があります。`no_side_effect` プラグマの書式は、次のとおりです。

      #pragma no_side_effect (名前 [, 名前 ...])

プラグマで使用する関数は、#pragma 以前に宣言する必要があります。 このメッセージを生成するコードの例を次に示します。

    /* 関数 abc は、どこにも定義または宣言されていません */
    #pragma no_side_effect (abc)

============ 正しい例

    int abc();
    #pragma no_side_effect (abc)

メッセージ ID: E_NO_SIDE_EFFECT_UNDECLARED

## 無効な形式の #pragma unknown_control_flow ( 識別子 [,識別子 ...] ) を無視します。

`#pragma unknown_control_flow` の書式が正しくありません。正しい pragma の設定方法は次の通りです。

      #pragma unknown_control_flow ( 識別子 [,識別子 ...] )

このメッセージを生成するコードの例を次に示します。

    #pragma unknown_control_flow {a, b c}

メッセージ ID: E_IGNORE_MALFORMED_PRAGMA_UCF

## 無効な形式の #pragma no_side_effect ( 識別子 [,識別子 ...] ) を無視します。

`#pragma no_side_effect` の書式が正しくありません。正しい pragma の設定方法は次の通りです。

    #pragma no_side_effect (識別子 [, 識別子 ...])

このメッセージを生成するコードの例を次に示します。

    #pragma no_side_effect {a b}

メッセージ ID: E_IGNORE_MALFORMED_PRAGMA_NSE

## 無効な形式の #pragma init/fini を無視します。

`#pragma init` または `#pragma fini` の書式が正しくありません。`fini` および `init` プラグマの書式は、次のとおりです。

      #pragma fini (f1 [,f2, ...,fn])
      #pragma init (f1 [,f2, ...,fn])

このメッセージを生成するコードの例を次に示します。

    #define ONE 1
    f();
    g();
    #pragma fini {f, g}

メッセージ ID: E_IGNORE_MALFORMED_PRAGMA

## unsigned で関数の戻り値と同じ型にする必要があります。

`#pragma int_to_unsigned` 指令で指定した関数の戻り値の型は、同じ型の `unsigned` の識別子にする必要があります。 このメッセージを生成するコードの例を次に示します。

    extern int f(int);
    #pragma int_to_unsigned f

l

メッセージ ID: E_MUST_B_TYPE_FUNC_RTN_UNSIGNED

## 無効な形式の #pragma int_to_unsigned シンボルを無視します。

無効な形式の `#pragma int_to_unsigned` があります。無効な指令は無視されます。 このメッセージを生成するコードの例を次に示します。

    #pragma int_to_unsigned strlen();

メッセージ ID: E_IGNORE_MALFORMED_INTTOUNSIGND

## #pragma align の値に誤りがあります。

`#pragma align` の値には、128 以下の 2 の正のべき乗になる値を指定してください。 `align` プラグマの書式は、次のとおりです。 `#pragma align 整数値 (識別子 [, 識別子...])` このメッセージを生成するコードの例

    #define ANO 129
    #pragma align ANO (astruct)

正しい例

    #define MAX 128
    #pragma align MAX (astruct, aint, aptr)

メッセージ ID: E_BAD_PRAGMA_ALIGN_VALUE

## 無効な形式の #pragma align を無視します。

`#pragma align` の構文が正しくありません。正しい構文は、次のとおりです。

    #pragma align integer (ident [,ident ...])

integer には、1 から 128 までの 2 のべき乗の値 (1, 2, 4, 8, 16, 32, 64, 128) を指定してください。`ident` には、大域変数または静的変数を指定してください (自動変数は不可)。 このメッセージを生成するコードの例を次に示します。

    #pragma align 128 {astruct, aunion}

メッセージ ID: E_IGNORE_MALFORMED_PRAGMA_ALIGN

## メモリー不足のため領域を割り当てられません。

メモリーが不足しています。ほとんどの場合は、スワップ領域が不足していることが原因となっています。

メッセージ ID: E_REALLOC_OUT_OF_MEMORY

## #line <番号> のあとに文字列リテラルが必要です。

#line 指令の後には、文字列リテラルを続ける必要があります。

メッセージ ID: E_STRING_EXPECTED_POUND_LINE

## ビットフィールドの代入で精度が低下します。

ビットフィールドに代入する定数が大きすぎるため、値が切り捨てられます。 次の例で、ビットフィールド z には、マシンによって 0xA祁、または -4xA軍 の 範囲の値が代入されます。 このメッセージを生成するコードの例を次に示します。

    void
    v(void)
    {
    	struct {
    		signed          x:3;	/* 最大値は 3 */
    		unsigned        y:3;	/* 最大値は is 7 */
    		int             z:3;	/* 最大値は 7 */
    	}               st;
    	st.x = 3;
    	st.x = 4;
    	st.y = 7;
    	st.y = 8;
    	st.z = 7;
    	st.z = 8;
    }

メッセージ ID: E_PRECISION_LOST_IN_BIT_FIELD

## 列挙型が定義されていません。

`enum` の宣言が正しくありません (出力形式:: Simple)。 このメッセージを生成するコードの例

    1  enum e {int, two} en;
    ============
    (1) 警告: 列挙型が定義されていません: e

メッセージ ID: E_ENUM_NEVER_DEF

## 代入演算子 = の使用が想定される場所に等価演算子 == が使用されています。

副作用の可能性がある位置で、等価演算子が使用されています (出力形式: simple)。このメッセージを生成するコードの例

    1 void
    2 main(void)
    3 {
    4 	int             i = 0, j = 1;
    5 	for (i == j; i < 10; i++)
    6 		i == j;
    7 }
    ============
    (5) 警告: 代入演算子 = の使用が想定される場所に等価演算子 == が使用されています。
    (6) 警告: 代入演算子 = の使用が想定される場所に等価演算子 == が使用されています。

メッセージ ID: E_ASSIGNMENT_NOT_EQUALITY

## 等価演算子 == の使用が想定される場所に代入演算子が = が使用されています。

条件式が必要と思われる位置で、代入演算子が使用されています。このメッセージは、関数呼び出しの値を使用して変数への代入を行う場合、または文字列のコピーの場合には、出力されません。また、`-h` を指定して `lint` を起動した場合には表示されません (出力形式: simple)。このメッセージを生成するコードの例

    1 int
    2 main(void)
    3 {
    4 	int             y = 0;
    5 	int             z = 0;
    6 	int             j = 0;
    7 	int             x, i;
    8 	i = (x = y) & (z == j);
    9 	if (y = x)
    10 		i = 1;
    11 	while (z = y)
    12 		i++;
    13 	while ((x = z) == y)
    14 		i--;
    15 	return (i + x);
    16 }
    ============
    (8) 警告: 等価演算子 == の使用が想定される場所に代入演算子 = が使用されています。
    (9) 警告: 等価演算子 == の使用が想定される場所に代入演算子 = が使用されています。
    (11) 警告: 等価演算子 == の使用が想定される場所に代入演算子 = が使用されています。

メッセージ ID: E_EQUALITY_NOT_ASSIGNMENT

## 許可される引数の数は 0 個または 2 個です: main()

プログラム中で定義された `main()` 関数のパラメータが 1 つだけ、または 3 つ以上指定されています。これは ANSI C の規則に反しています (出力形式: simple)。このメッセージを生成するコードの例

    1 void
    2 main(int argc, char **argv, char **envp)
    3 {}
    ============
    (2) 警告: 許可される引数の数は 0 個または 2 個です: main()

メッセージ ID: E_MAIN_PARAM

## 関数は int 型である必要があります: main()

`int` 値を返さない `main()` 関数を使用しています。これは、ANSI C の規則に反しています (出力形式: simple)。このメッセージを生成するコードの例

    1 char           *
    2 main(void)
    3 {
    4 	return "a";
    5 }
    ============
    (2) 警告: 関数は int 型である必要があります: main()

メッセージ ID: E_MAIN_RET_VAL

## 移植性のない文字定数

複数の文字から成る文字定数には移植性がありません (出力形式: simple)。このメッセージを生成するコードの例

    1  int c = 'abc';
    ============
    (1) 警告: 移植性のない文字定数

メッセージ ID: E_NONPORTABLE_CHAR_CONST

## 関数が自動変数へのポインタを返しています。

関数により、自動変数へのポインタが返されます。自動記憶クラスのオブジェクトは、そのブロック外で保持されることは保証されないので、このオブジェクトへのポインタは、ブロックが終わると未定義になります。 このメッセージを生成するコードの例を次に示します。

    1 int *
    2 f(int x)
    3 {
    4 	int             ia[10];
    5 	int             i;
    6 	if (x == 1)
    7 		return ia;
    8 	else
    9 		return &i;
    10 }
    ============
    (7) 警告: 関数が自動変数へのポインタを返しています
    (9) 警告: 関数が自動変数へのポインタを返しています

メッセージ ID: E_FUNC_RET_PTR_TO_AUTO

## 関数が引数へのポインタを返しています。

関数により、パラメータへのポインタが返されます。自動記憶クラスのオブジェクトは、そのブロック外で保持されることは保証されないので、このオブジェクトへのポインタは、ブロックが終わると未定義になります。 このメッセージを生成するコードの例を次に示します。

    1 int	*f(int i)
    2 {
    3 	return &i;
    4 }
    ============
    (3) 警告: 関数が引数へのポインタを返しています

メッセージ ID: E_FUNC_RET_PTR_TO_PARAM

## case 文を通り抜けます。

`break` や `return` がないので、次の `case` 文が続けて実行されます。該当する `case` 文の前に `/* FALLTHRU */` を付けるか、またはその `case` 文に直前の `case` 文からは到達しない場合には (下の例を参照) `/* NOTREACHED */` を付けると、その `case` 文に対するメッセージは表示されなくなります。このメッセージは、`-h` を指定して `lint` を起動した場合には表示されません (出力形式: simple)。このメッセージを生成するコードの例

    1 int
    2 f(int i)
    3 {
    4 	void            error();
    5 	switch (i) {
    6 	case 10:
    7 		i = 0;
    8 	case 12:
    9 		return (i);
    10 	case 14:
    11 		break;
    12 	case 15:
    13 	case 16:
    14 		break;
    15 	case 18:
    16 		i = 0;
    17 		/* FALLTHRU */
    18 	case 20:
    19 		error("bad number");
    20 		/* NOTREACHED */
    21 	case 22:
    22 		return (i);
    23 	}
    24 	return (i);
    25 }
    ============
    (8) 警告: case 文を通り抜けます

メッセージ ID: E_CASE_FALLTHRU

## /* EMPTY */ 指令は if/else の中になければなりません。

lint 指令 `/* EMPTY */` は、`#if` または `#else` のスコープ内にある必要があります。 このメッセージを生成するコードの例

    int f(void) {
    /* EMPTY */
    };

メッセージ ID: E_IF_ELSE_DIRECTIVE

## 文が帰結していません: if

`if` 文に、空文の `if` 部分があります。 `if` とセミコロンの間に `/* EMPTY */` を入れると、その文に対してメッセージが表示されなくなります。`-h` を指定して `lint` を起動した場合には、このメッセージは表示されません (出力形式: Simple)。 このメッセージを生成するコードの例

    1 void
    2 v(int i)
    3 {
    4 	if (i);
    5 	if (i == 10)
    6 		 /* EMPTY */ ;
    7 	else
    8 		return;
    9 }
    ============
    (4) 警告: 文が帰結していません: if

メッセージ ID: E_NOP_IF_STMT

## 文が帰結していません: else

`if` 文に、空文の `else` があります。 `else` とセミコロンの間に `/* EMPTY */` を入れると、その文に対してメッセージが表示されなくなります。`-h` を指定して `lint` を起動した場合には、このメッセージは表示されません (出力形式: simple)。 このメッセージを生成するコードの例

    1 void
    2 v(int i)
    3 {
    4 	if (i)
    5 		return;
    6 	else;
    7 }
    ============
    (6) 警告: 文が帰結していません: else

メッセージ ID: E_NOP_ELSE_STMT

## 静的シンボルが使用されていません。

ファイル中で、変数または関数が `static` として宣言または定義されていますが、ファイル中で使用されていません。これらのオブジェクトは、宣言または定義したファイル以外では使用できないので、プログラム上の何らかのエラーと考えられます。 このメッセージを生成するコードの例を次に示します。

    1  static int i;
    2  static int f(void);
    3  static int j = 1;
    ============
    静的シンボルが使用されていません
        (1) i               (2) f               (3) j

メッセージ ID: E_STATIC_UNUSED1

## 静的シンボルが使用されていません。

ファイル中で、変数または関数が `static` として宣言または定義されていますが、ファイル中で使用されていません。これらのオブジェクトは、宣言または定義したファイル以外では使用できないので、プログラム上の何らかのエラーと考えられます。 このメッセージを生成するコードの例を次に示します。

    1  static int i;
    2  static int f(void);
    3  static int j = 1;

メッセージ ID: E_STATIC_UNUSED

## 引数が関数中で使用されていません。

関数の引数が使用されていません。関数定義の前に `/* ARGSUSEDn */` を置くと、最初の n 個までの引数を除き、すべての引数に対するメッセージが表示されなくなります。`-v` を指定して `lint` を起動した場合には、このメッセージは表示されません。 このメッセージを生成するコードの例を次に示します。

    1 static int      f(int, int);
    2 int
    3 main(int argc, char *argv[])
    4 {
    5 	return (f(argc, 0));
    6 }
    7 /* ARGSUSED1 */
    8
    9 int
    10 f(int x, int y)
    11 {
    12 	return x;
    13 }
    14
    ============
    引数が関数中で使用されていません
        (3) argv (関数: main)

メッセージ ID: E_FUNC_ARG_UNUSED1

## 引数が関数中で使用されていません。

関数の引数が使用されていません。関数定義の前に `/* ARGSUSEDn */` を置くと、最初の n 個までの引数を除き、すべての引数に対するメッセージが表示されなくなります。`-v` を指定して `lint` を起動した場合には、このメッセージは表示されません。 このメッセージを生成するコードの例を次に示します。

    1 static int      f(int, int);
    2 int
    3 main(int argc, char *argv[])
    4 {
    5 	return (f(argc, 0));
    6 }
    7 /* ARGSUSED1 */
    8
    9 int
    10 f(int x, int y)
    11 {
    12 	return x;
    13 }
    14

メッセージ ID: E_FUNC_ARG_UNUSED

## 変数が関数中で使用されていません。

変数が宣言されていますが、関数中で使用されていません。 このメッセージを生成するコードの例を次に示します。

    1 void main(void)
    2 {
    3 	int i, j;
    4 	static k;
    5 }
    6
    7
    ============
    変数が関数中で使用されていません
        (3) i (関数: main)
        (3) j (関数: main)
        (4) k (関数: main)

メッセージ ID: E_FUNC_VAR_UNUSED1

## 変数が関数中で使用されていません。

変数が宣言されていますが、関数中で使用されていません。 このメッセージを生成するコードの例を次に示します。

    1 void main(void)
    2 {
    3 	int i, j;
    4 	static k;
    5 }
    6
    7

メッセージ ID: E_FUNC_VAR_UNUSED

## 変数が関数中で設定されていますが使用されていません。

自動変数または関数パラメータが、宣言または設定されていますが、関数中で使用されていません。 このメッセージを生成するコードの例を次に示します。

    1 void f(int i)
    2 {
    3 	int j = 1;
    4 	i = 1;
    5 }
    ============
    変数が関数中で設定されていますが使用されていません
        (1) i (関数: f)
        (3) j (関数: f)

メッセージ ID: E_FUNC_SET_NOT_USED1

## 変数が関数中で設定されていますが使用されていません。

自動変数または関数パラメータが、宣言または設定されていますが、関数中で使用されていません。 このメッセージを生成するコードの例を次に示します。

    1 void f(int i)
    2 {
    3 	int j = 1;
    4 	i = 1;
    5 }

メッセージ ID: E_FUNC_SET_NOT_USED

## ポインタのキャストが問題を引き起こす可能性ががあります。

あるオブジェクト型へのポインタが、別のオブジェクト型へのポインタに キャストされています。 このメッセージは、`-p` を指定して `lint` を起動した場合のみ出力され、特定の型を持たないポインタ `void *` については出力されません。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 main(void)
    3 {
    4 	int            *ip;
    5 	char           *cp = 0;
    6 	ip = (int *) cp;
    7 }
    ============
    ポインタのキャストが問題を引き起こす可能性があります
        (6)

メッセージ ID: E_BAD_PTR_CAST

## 到達できない文です。

到達できない文です。関数中に、到達できない文があります。この文の前に、`/* NOTREACHED */` を置くと、該当する文に対するメッセージが表示されなくなります。 `-b` を指定して `lint` を起動した場合は、到達していないすべての `break` および空の文に対するメッセージは表示されません。このメッセージは、コンパイラによって出力されることもありますが、その場合はメッセージを非表示にすることはできません。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 v(int i)
    3 {
    4 	switch (i) {
    5 	case 1:
    6 		return;
    7 		break;
    8 	case 2:
    9 		return;
    10 		/* NOTREACHED */
    11 		break;
    12 	}
    13 }
    ============
    到達できない文です
        (7)

メッセージ ID: E_STMT_NOT_REACHED

## int を返すように暗黙的に宣言されています。

宣言されていない関数が呼び出されています。 この場合、`lint` は、関数が `int` を返すとみなします。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 v(void)
    3 {
    4 	f();
    5 }
    ============
    int を返すように暗黙的に宣言されます
        (4) f

メッセージ ID: E_RET_INT_IMPLICITLY1

## int を返すように暗黙的に宣言されています。

宣言されていない関数が呼び出されています。 この場合、`lint` は、関数が `int` を返すとみなします。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 v(void)
    3 {
    4 	f();
    5 }

メッセージ ID: E_RET_INT_IMPLICITLY

## ポインタのキャストによって境界整列が不正確になる可能性があります。

あるオブジェクト型へのポインタを、より強い境界整列条件のある 別のオブジェクト型へのポインタにキャストしています。キャスト結果が、2 つ目のポインタ型では無効になる可能性があります。また、`-h` を指定して `lint` を起動した場合には表示されません 。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 main(void)
    3 {
    4 	short          *sp = 0;
    5 	int            *ip;
    6 	ip = (int *) sp;
    7 }
    8
    ============
    ポインタのキャストによって境界整列が不正確になる可能性があります
        (6)

メッセージ ID: E_BAD_PTR_CAST_ALIGN

## signed 型値に対するビット単位の演算は移植性がなくなる可能性があります。

ビット単位の演算子のオペランドが、ANSI C で定義されている符号付き整数型の変数になっています。これらの演算子は、整数の内部表現に依存する値を返すので、演算子の動作は、その型のオペランドに対する、インプリメンテーションに依存して定義されます。

メッセージ ID: E_POSSIBLY_NONPORT_SBITWISE_OP

## signed 型値に対するビット単位の演算は移植性がありません。

ビット単位の演算子のオペランドが、ANSI C で定義されている符号付き整数型の変数になっています。これらの演算子は、整数の内部表現に依存する値を返すので、演算子の動作は、その型のオペランドに対する、インプリメンテーションに依存して定義されます。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 v(void)
    3 {
    4 	int             i;
    5 	signed int      j;
    6 	i = i & 055;
    7 	j = j | 022;
    8 }
    ============
    signed 型値に対するビット単位の演算は移植性がなくなる可能性があります
        (6)                 (7)

メッセージ ID: E_NONPORT_SBITWISE_OP

## より大きな整数型への変換は符号拡張が不正確になる可能性があります。

通常の `char` 型の変数が、よりサイズが大きい整数型の変数に代入されています。 通常の `char` が signed または unsigned のどちらで扱われるかは、インプリメンテーションによって異なります。 このメッセージは、`-p` を指定して `lint` を起動した場合のみ出力され、`-a` を指定した場合は出力されません。 このメッセージを生成するコードの例を次に示します。

    1 int
    2 main(void)
    3 {
    4 	char            c = 0;
    5 	long            l;
    6 	l = c;
    7 	return (l);
    8 }
    ============
    より大きな整数型への変換は符号拡張が不正確になる可能性があります
        (6)

メッセージ ID: E_BAD_SIGN_EXTEND

## 代入によって暗黙的により小さい型に変換されます。

オブジェクトが、よりサイズが小さいデータ型のオブジェクトに代入されています。このメッセージは、`-a` を指定して `lint` を起動した場合には表示されません。また、明示的なキャストによってサイズがより小さい型に変換した場合も、このメッセージは表示されません。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 main(void)
    3 {
    4 	float         f;
    5 	long long     l = 2.5;
    6 	f = l;
    7 }
    ============
    代入によって暗黙的により小さい型に変換されます
        (6)

メッセージ ID: E_ASSIGN_NARROW_CONV

## 関数が値を返さずに終了しています。

`void` でない関数が、呼び出し側の関数に値を返しません。右の中括弧 } まで到達しない場合は、前に `/* NOTREACHED */` を置くと、このメッセージが表示されなくなります。 このメッセージを生成するコードの例を次に示します。

    1 int f(void) {}
    2 void v(void) {}
    3 h(void)
    4 {
    5 	exit(1);
    6 	/* NOTREACHED */
    7 }
    ============
    関数が値を返さずに終了しています
        (1) f

メッセージ ID: E_FUNC_NO_RET_VAL1

## 関数が値を返さずに終了しています。

`void` でない関数が、呼び出し側の関数に値を返しません。右の中括弧 } まで到達しない場合は、前に `/* NOTREACHED */` を置くと、このメッセージが表示されなくなります。 このメッセージを生成するコードの例を次に示します。

    1 int f(void) {}
    2 void v(void) {}
    3 h(void)
    4 {
    5 	exit(1);
    6 	/* NOTREACHED */
    7 }

メッセージ ID: E_FUNC_NO_RET_VAL

## 宣言がブロック中で使用されていません。

外部変数または関数が宣言されていますが、内部ブロック中で使用されていません。 このメッセージを生成するコードの例を次に示します。

    1 int
    2 main(void)
    3 {
    4 	int             f();
    5 	int             g();
    6 	return f();
    7 }
    ============
    宣言がブロック中で使用されていません
        (5) g

メッセージ ID: E_BLOCK_DECL_UNUSED1

## 宣言がブロック中で使用されていません。

外部変数または関数が宣言されていますが、内部ブロック中で使用されていません。 このメッセージを生成するコードの例を次に示します。

    1 int
    2 main(void)
    3 {
    4 	int             f();
    5 	int             g();
    6 	return f();
    7 }

メッセージ ID: E_BLOCK_DECL_UNUSED

## 未定義の名前が使用されています。

静的でない外部変数または関数が宣言されていますが、いずれのファイルにも定義がありません。このメッセージは、`-u` を指定して `lint` を起動した場合には、表示されません。 このメッセージを生成するコードの例を次に示します。

    1 extern int      f(void);
    2 int
    3 main(void)
    4 {
    5 	return f();
    6 }
    ============
    未定義の名前が使用されています
        f                	f.c(5)

メッセージ ID: E_NAME_USED_NOT_DEF1

## 未定義の名前が使用されています。

静的でない外部変数または関数が宣言されていますが、いずれのファイルにも定義がありません。このメッセージは、`-u` を指定して `lint` を起動した場合には、表示されません。 このメッセージを生成するコードの例を次に示します。

    1 extern int      f(void);
    2 int
    3 main(void)
    4 {
    5 	return f();
    6 }

メッセージ ID: E_NAME_USED_NOT_DEF2

## 名前が定義されていますが使用されていません。

変数または関数が定義されていますが、いずれのファイルでも使用されていません。このメッセージは、`-u` を指定して `lint` を起動した場合には、表示されません。 このメッセージを生成するコードの例を次に示します。

    1  int i;
    ============
    名前が定義されていますが使用されていません
        i                	f.c(1)

メッセージ ID: E_NAME_DEF_NOT_USED1

## 名前が定義されていますが使用されていません。

変数または関数が定義されていますが、いずれのファイルでも使用されていません。このメッセージは、`-u` を指定して `lint` を起動した場合には、表示されません。 このメッセージを生成するコードの例を次に示します。

    1  int i;

メッセージ ID: E_NAME_DEF_NOT_USED2

## 名前が宣言されていますが使用も定義もされていません。

静的でない外部変数または関数が宣言されていますが、いずれのファイルにも定義がありません。このメッセージは、`-x` を指定して `lint` を起動した場合には、表示されません。 このメッセージを生成するコードの例を次に示します。

    1 extern int f(void);
    2 static int g(void);
    ============
    名前が宣言されていますが使用も定義もされていません
        f                	f.c(1)

メッセージ ID: E_NAME_DECL_NOT_USED_DEF1

## 名前が宣言されていますが使用も定義もされていません。

静的でない外部変数または関数が宣言されていますが、いずれのファイルにも定義がありません。このメッセージは、`-x` を指定して `lint` を起動した場合には、表示されません。 このメッセージを生成するコードの例を次に示します。

    1 extern int f(void);
    2 static int g(void);

メッセージ ID: E_NAME_DECL_NOT_USED_DEF2

## 名前が重複して定義されています。

変数が、複数のソースファイルで定義されています。 このメッセージを生成するコードの例を次に示します。

    file f.c:
    1  char i = 'a';

    file f_1.c:
    1  long i = 1;
    ============
    名前が重複して定義されています
        i                	f.c(1) :: f_1.c(1)

メッセージ ID: E_NAME_MULTIPLY_DEF1

## 名前が重複して定義されています。

変数が、複数のソースファイルで定義されています。 このメッセージを生成するコードの例を次に示します。

    file f.c:
    1  char i = 'a';

    file f_1.c:
    1  long i = 1;

メッセージ ID: E_NAME_MULTIPLY_DEF2

## 使用している値の型が整合していません。

関数呼び出しの戻り値の型が、関数定義での型と一致していません。 このメッセージを生成するコードの例を次に示します。

    file f.c:
    1 int            *
    2 f(int *ip)
    3 {
    4 	return ip;
    5 }

    file f_1.c:
    1 void
    2 g(void)
    3 {
    4 	int             i, *ip = &i;
    5 	i = f(ip);
    6 }
    ============
    使用している値の型が整合していません
        f                	f.c(2) int *() :: f_1.c(5) int ()

メッセージ ID: E_INCONS_VAL_TYPE_USED1

## 使用している値の型が整合していません。

関数呼び出しの戻り値の型が、関数定義での型と一致していません。 このメッセージを生成するコードの例を次に示します。

    file f.c:
    1 int            *
    2 f(int *ip)
    3 {
    4 	return ip;
    5 }

    file f_1.c:
    1 void
    2 g(void)
    3 {
    4 	int             i, *ip = &i;
    5 	i = f(ip);
    6 }

メッセージ ID: E_INCONS_VAL_TYPE_USED2

## 宣言している値の型が整合していません。

宣言または定義されている関数の戻り値の型が、この関数の別の宣言または定義での戻り値の型と一致していません。このメッセージは、変数の型の宣言が一致していない場合にも出力されます。 このメッセージを生成するコードの例を次に示します。

    file f.c:
    1 void v(void) {}
    2 void g(void);
    3 extern int i;

    file f_1.c:
    1 extern int f(void);
    2 extern int g(void);
    3 extern char i;
    ============
    宣言している値の型が整合していません
        g                	f.c(2) void () :: f_1.c(2) int ()
        i                	f.c(3) int  :: f_1.c(3) char

メッセージ ID: E_INCONS_VAL_TYPE_DECL1

## 宣言している値の型が整合していません。

宣言または定義されている関数の戻り値の型が、この関数の別の宣言または定義での戻り値の型と一致していません。このメッセージは、変数の型の宣言が一致していない場合にも出力されます。 このメッセージを生成するコードの例を次に示します。

    file f.c:
    1 void v(void) {}
    2 void g(void);
    3 extern int i;

    file f_1.c:
    1 extern int f(void);
    2 extern int g(void);
    3 extern char i;

メッセージ ID: E_INCONS_VAL_TYPE_DECL2

## 使用している関数の引数が整合していません。

関数呼び出しの引数の型が、関数定義中の仮引数の型と一致していません。 このメッセージを生成するコードの例を次に示します。

    file f.c:

    1 int
    2 f(int *x, int *y)
    3 {
    4 	return *x + *y;
    5 }

    file f1.c:

    1 int
    2 main(void)
    3 {
    4 	int             i = 0;
    5 	extern int      f(int, int);
    6 	return f(1, i);
    7 }
    ============
    宣言している関数の引数が整合していません
        f (arg 2) 	f.c(3) int * :: f1.c(6) int

メッセージ ID: E_INCONS_ARG_USED1

## 使用している引数が整合していません。

関数呼び出しの実引数と仮引数の型が一致していません (出力形式: simple)。このメッセージを生成するコードの例

    1 static void
    2 g(x, y)
    3 	int             x;
    4 	int            *y;
    5 {
    6 	return;
    7 }
    8 void
    9 main(void)
    10 {
    11 	float           f = 4.5;
    12 	g(f, (int *) &f);
    13 }
    ============
    "f.c": 12 行目: 警告:引数の型が記憶されている型と整合していません: 1 番目の引数
    使用している引数が整合していません: g(1 番目の引数) f.c(5) では int、f.c(12) で は double

メッセージ ID: E_INCONS_ARG_USED2

## 可変数の引数で関数が呼び出されています。

関数呼び出しの際の引数の数が不適切です。関数定義の前に、`/* VARARGSn */` を置くと、n 個以上の引数が指定された関数呼び出しに対してはこのメッセージが表示されなくなります。また ANSI C の表記法である "..." を使用して関数を定義または 宣言すると、すべての引数に対してこのメッセージが表示されなくなります。 このメッセージを生成するコードの例を次に示します。

    1  int f(int x, int y, int z)
    2  {
    3  	return x + y + z;
    4  }
    5  int g(int x, ...)
    6  {
    7  	return x;
    8  }
    9  /* VARARGS1 */
    10  int h(int x, int y, int z)
    11  {
    12  	return x + y + z;
    13  }
    14  void main(void)
    15  {
    16  	extern int f(), h(), g(int i, ...);
    17  	f();
    18  	g(1, 2, 3, 4);
    19  	h(1, 2, 3, 4, 5);
    20  }
    ============
    可変数の引数で関数が呼び出されています
        f                	f.c(1) :: f.c(17)

メッセージ ID: E_FUNC_USED_VAR_ARG1

## 可変数の引数で関数が呼び出されています。

関数呼び出しの際の引数の数が不適切です。関数定義の前に、`/* VARARGSn */` を置くと、n 個以上の引数が指定された関数呼び出しに対してはこのメッセージが表示されなくなります。また ANSI C の表記法である "..." を使用して関数を定義または 宣言すると、すべての引数に対してこのメッセージが表示されなくなります。 このメッセージを生成するコードの例を次に示します。

    1  int f(int x, int y, int z)
    2  {
    3  	return x + y + z;
    4  }
    5  int g(int x, ...)
    6  {
    7  	return x;
    8  }
    9  /* VARARGS1 */
    10  int h(int x, int y, int z)
    11  {
    12  	return x + y + z;
    13  }
    14  void main(void)
    15  {
    16  	extern int f(), h(), g(int i, ...);
    17  	f();
    18  	g(1, 2, 3, 4);
    19  	h(1, 2, 3, 4, 5);
    20  }

メッセージ ID: E_FUNC_USED_VAR_ARG2

## 関数値が使用されていますが値が返されていません。

`void` でない関数に、`return` 文がありませんが、式中でその関数の戻り値が使用されています。 このメッセージを生成するコードの例を次に示します。

    file f.c:
    1 extern int fun();
    2 main()
    3 {
    4 	return fun();
    5 }
    file f2.c:
    1 int fun()
    2 {}
    ============
    関数値が使用されていますが値が返されていません
        fun

メッセージ ID: E_FUNC_VAL_USED_NONE_RET1

## 関数値が使用されていますが値が返されていません。

`void` でない関数に、`return` 文がありませんが、式中でその関数の戻り値が使用されています。 このメッセージを生成するコードの例を次に示します。

    file f.c:
    1 extern int fun();
    2 main()
    3 {
    4 	return fun();
    5 }
    file f2.c:
    1 int fun()
    2 {}

メッセージ ID: E_FUNC_VAL_USED_NONE_RET2

## 関数が返す値は常に無視されます。

関数中に `return` 文が使用されていますが、すべての関数呼び出しで、戻り値は無視されています。 このメッセージを生成するコードの例を次に示します。

    1 int f(void)
    2 {
    3 	return 1;
    4 }
    5 extern int f(void);
    6 int main(void)
    7 {
    8 	f();
    9 	return 1;
    10 }
    ============
    関数が返す値は常に無視されます
        f

メッセージ ID: E_FUNC_RET_ALWAYS_IGNOR1

## 関数が返す値は常に無視されます。

関数中に `return` 文が使用されていますが、すべての関数呼び出しで、戻り値は無視されています。 このメッセージを生成するコードの例を次に示します。

    1 int f(void)
    2 {
    3 	return 1;
    4 }
    5 extern int f(void);
    6 int main(void)
    7 {
    8 	f();
    9 	return 1;
    10 }

メッセージ ID: E_FUNC_RET_ALWAYS_IGNOR2

## 関数が返す値は無視されることがあります。

関数中に `return` 文が使用されていますが、一部の関数呼び出しで、戻り値が無視されます。 このメッセージを生成するコードの例を次に示します。

    1  int f(void)
    2  {
    3  	return 1;
    4  }
    5  extern int f(void);
    6  int main(void)
    7  {
    8  	if(f()) {
    9  		return f();
    10  	}
    11 	else {
    12  		f();
    13  		return 1;
    14  	}
    15  }
    ============
    関数が返す値は無視されることがあります
        f

メッセージ ID: E_FUNC_RET_MAYBE_IGNORED1

## 関数が返す値は無視されることがあります。

関数中に `return` 文が使用されていますが、一部の関数呼び出しで、戻り値が無視されます。 このメッセージを生成するコードの例を次に示します。

    1  int f(void)
    2  {
    3  	return 1;
    4  }
    5  extern int f(void);
    6  int main(void)
    7  {
    8  	if(f()) {
    9  		return f();
    10  	}
    11 	else {
    12  		f();
    13  		return 1;
    14  	}
    15  }

メッセージ ID: E_FUNC_RET_MAYBE_IGNORED2

## 宣言している関数の引数が整合していません。

関数プロト型で宣言または定義されているパラメータの型が、別の宣言または定義の型と一致していません。 このメッセージを生成するコードの例を次に示します。

    file f.c:

    1 int f(int);
    2 int g(int);

    file f_1.c:

    1 int f(int *ip);
    2 int g(int *ip) {return *ip;}
    3
    ============
    宣言している関数の引数が整合していません
        g (arg 1) 	f_1.c(2) int * :: f.c(2) int
        f (arg 1) 	f.c(1) int  :: f_1.c(1) int *

メッセージ ID: E_INCONS_ARG_DECL1

## 可変数の引数で関数が宣言されています。

関数プロト型で宣言または定義されているパラメータの数が、別の宣言または定義での数と一致していません。すべての宣言で同じ数の引数が使用されている場合は、ANSI C の表記法である "..." を使用して、プロト型を宣言または定義すると、このメッセージが表示されなくなります。 このメッセージを生成するコードの例を次に示します。

    file f.c:

    1 int
    2 f(int x, int y)
    3 {
    4 	return (x + y);
    5 }
    6 int
    7 g(void)
    8 {
    9 	int             i, j = 0, k = 0;
    10 	i = f(j, k);
    11 	return (i);
    12 }

    file f_1.c:

    1 int             f(int);
    2 int             g(int);
    ============
    可変数の引数で関数が宣言されています
        f                	f.c(2) :: f_1.c(1)
        g                	f.c(7) :: f_1.c(2)

メッセージ ID: E_FUNC_DECL_VAR_ARG1

## 可変数の引数で関数が宣言されています。

関数プロト型で宣言または定義されているパラメータの数が、別の宣言または定義での数と一致していません。すべての宣言で同じ数の引数が使用されている場合は、ANSI C の表記法である "..." を使用して、プロト型を宣言または定義すると、このメッセージが表示されなくなります。 このメッセージを生成するコードの例を次に示します。

    file f.c:

    1 int
    2 f(int x, int y)
    3 {
    4 	return (x + y);
    5 }
    6 int
    7 g(void)
    8 {
    9 	int             i, j = 0, k = 0;
    10 	i = f(j, k);
    11 	return (i);
    12 }

    file f_1.c:

    1 int             f(int);
    2 int             g(int);

メッセージ ID: E_FUNC_DECL_VAR_ARG2

## シンボルは名前の切り詰めによって区別できなくなる可能性があります。

プログラムを別のマシンに移植すると、プログラム中の外部名を区別できなくなる 可能性があります。これは、外部名の長さ、および大文字と小文字の区別に関する制限事項が、インプリメンテーションによって異なるためです。 `-Xc` を指定すると、ANSI C の下限に従って外部名が最初の 6 文字に切り捨てられ、大文字または小文字に統一されます。`-p` を指定すると、最初の 8 文字に切り捨てられ、大文字または小文字に統一されます。 このメッセージを生成するコードの例を次に示します。

    1  int foobar1;
    2  int FooBar12;
    3  int foobar2;
    4  int FOOBAR12;
    ============
    -Xc の場合:
    シンボルは名前の切り詰めによって区別できなくなる可能性があります
        FooBar12 in f.c(2) :: foobar1 in f.c(1)
        foobar2 in f.c(3) :: FooBar12 in f.c(2)
        FOOBAR12 in f.c(4) :: foobar2 in f.c(3)

    -p の場合:
     シンボルは名前の切り詰めによって区別できなくなる可能性があります
        FOOBAR12 (4) in f.c :: FooBar12 (2) in f.c

メッセージ ID: E_INDISTING_FROM_TRUNC1

## 名前の切り詰めによって区別できなくなる可能性があります。

プログラムを別のマシンに移植すると、プログラム中の外部名を区別できなくなる 可能性があります。これは、外部名の長さ、および大文字と小文字の区別に関する制限事項が、インプリメンテーションによって異なるためです。 `-Xc` を指定すると、ANSI C の下限に従って外部名が最初の 6 文字に切り捨てられ、大文字または小文字に統一されます。`-p` を指定すると、最初の 8 文字に切り捨てられ、大文字または小文字に統一されます。 このメッセージを生成するコードの例を次に示します。

    1  int foobar1;
    2  int FooBar12;
    3  int foobar2;
    4  int FOOBAR12;

メッセージ ID: E_INDISTING_FROM_TRUNC2

## 書式から参照されない余分な引数があります。

[fs]printf() または [fs]scanf() 関数呼び出しの制御文字列に指定した変換指定子の数が、呼び出し中の引数の数より少ないです。 このメッセージを生成するコードの例を次に示します。

    1 #include
    2 void
    3 main(void)
    4 {
    5 	int             i = 0, j = 1;
    6 	(void) printf("%d", i, j);
    7 }
    ============
    書式から参照されない余分な引数があります
        printf           	f.c(6)

メッセージ ID: E_TOO_MANY_ARG_FOR_FMT1

## 書式から参照されない余分な引数があります。

[fs]printf() または [fs]scanf() 関数呼び出しの制御文字列に指定した変換指定子の数が、呼び出し中の引数の数より少ないです。 このメッセージを生成するコードの例を次に示します。

    1 #include
    2 void
    3 main(void)
    4 {
    5 	int             i = 0, j = 1;
    6 	(void) printf("%d", i, j);
    7 }

メッセージ ID: E_TOO_MANY_ARG_FOR_FMT2

## 書式文字列が正しくありません。

[fs]printf() または [fs]scanf() 制御文字列の書式が正しくありません。 このメッセージを生成するコードの例を次に示します。

    1 #include
    2 void
    3 main(void)
    4 {
    5 	(void) printf("%y");
    6 }
    ============
    書式文字列が正しくありません
        printf           	f.c(5)

メッセージ ID: E_BAD_FORMAT_STR1

## 書式文字列が正しくありません。

[fs]printf() または [fs]scanf() 制御文字列の書式が正しくありません。 このメッセージを生成するコードの例を次に示します。

    1 #include
    2 void
    3 main(void)
    4 {
    5 	(void) printf("%y");
    6 }

メッセージ ID: E_BAD_FORMAT_STR2

## 書式から参照される引数が足りません。

[fs]printf() または [fs]scanf() 関数呼び出しの制御文字列に指定した変換指定子の数が、呼び出し中の引数の数よりも多くなっています。 このメッセージを生成するコードの例を次に示します。

    1 #include
    2 void
    3 main(void)
    4 {
    5 	int             i = 1;
    6 	(void) printf("%d%d", i);
    7 }
    ============
    書式から参照される引数が足りません
        printf           	f.c(6)

メッセージ ID: E_TOO_FEW_ARG_FOR_FORMAT1

## 書式から参照される引数が足りません。

[fs]printf() または [fs]scanf() 関数呼び出しの制御文字列に指定した変換指定子の数が、呼び出し中の引数の数よりも多くなっています。 このメッセージを生成するコードの例を次に示します。

    1 #include
    2 void
    3 main(void)
    4 {
    5 	int             i = 1;
    6 	(void) printf("%d%d", i);
    7 }

メッセージ ID: E_TOO_FEW_ARG_FOR_FORMAT2

## 関数への引数の型と書式とが整合していません。

[fs]printf() または [fs]scanf() 関数呼び出しの制御文字列に指定した変換指定子と、引数が一致していません。 このメッセージを生成するコードの例を次に示します。

    1 #include
    2 void
    3 main(void)
    4 {
    5 	int             i = 0;
    6 	(void) printf("%s", i);
    7 }
    8
    ============
    関数への引数の型と書式とが整合していません
        printf (arg 2) 	int  :: (format) char *	f.c(6)

メッセージ ID: E_BAD_FORMAT_ARG_TYPE1

## 関数への引数の型と書式とが整合していません。

[fs]printf() または [fs]scanf() 関数呼び出しの制御文字列に指定した変換指定子と、引数が一致していません。 このメッセージを生成するコードの例を次に示します。

    1 #include
    2 void
    3 main(void)
    4 {
    5 	int             i = 0;
    6 	(void) printf("%s", i);
    7 }
    8

メッセージ ID: E_BAD_FORMAT_ARG_TYPE2

## 大域的に宣言されていますが静的 (static) にすることができます。

外部参照可能な変数または関数が大域的 (すなわち静的でない) として宣言されていますが、定義されたファイルの内部だけで参照されています。このメッセージは、`-m` を指定して `lint` を起動した場合には、表示されません。 このメッセージを生成するコードの例を次に示します。

    1 int
    2 f(void)
    3 {
    4 	return 1;
    5 }
    6 main(void)
    7 {
    8 	return f();
    9 }
    ============
    大域的に宣言されていますが静的 (static) にすることができます
        f                	f.c(2)

メッセージ ID: E_GLOBAL_COULD_BE_STATIC1

## 大域的に宣言されていますが静的 (static) にすることができます。

外部参照可能な変数または関数が大域的 (すなわち静的でない) として宣言されていますが、定義されたファイルの内部だけで参照されています。このメッセージは、`-m` を指定して `lint` を起動した場合には、表示されません。 このメッセージを生成するコードの例を次に示します。

    1 int
    2 f(void)
    3 {
    4 	return 1;
    5 }
    6 main(void)
    7 {
    8 	return f();
    9 }

メッセージ ID: E_GLOBAL_COULD_BE_STATIC2

## 型に 16 個を超える修飾子がありますが、使用されるのは 16 個だけです。

名前の記述において、16 個(制限値)を超える修飾子が使用されています (出力形式: simple)。このメッセージを生成するコードの例

    1 int ************************ip = 0;
    ============
    (1) 警告: 型に 16 個を超える修飾子がありますが、使用されるのは 16 個だけです。

メッセージ ID: E_MODIFIER_OVERFLOW

## 引数の数が指令に対して正しくありません: /* VARARGS */:有効な引数の数は、指令によって検査される引数の数 n より少なくてはいけません。

パラメータの数が n より少ない関数に、`/* VARARGSn */` 指令を適用すると、n は、実際の関数定義で指定されているパラメータの数に減少します。 このメッセージを生成するコードの例を次に示します。

    1 /* VARARGS4 */
    2 int
    3 f(int x, int y, int z)
    4 {
    5 	return (x + y + z);
    6 }
    ============
    (3) 警告: 引数の数が指令に対して正しくありません: /* VARARGS4 */:
    	有効な引数の数(3) は、指令によって検査される引数の数(4) より少なくてはいけません

メッセージ ID: E_DIRECTIVE_TOO_MANY_ARG

## 引数の数が指令に対して正しくありません: /* VARARGS */:有効な引数の数は、指令によって検査される引数の数 n より少なくてはいけません。

パラメータの数が n より少ない関数に、`/* VARARGSn */` 指令を適用すると、n は、実際の関数定義で指定されているパラメータの数に減少します。 このメッセージを生成するコードの例を次に示します。

    1 /* VARARGS4 */
    2 int
    3 f(int x, int y, int z)
    4 {
    5 	return (x + y + z);
    6 }
    ============
    (3) 警告: 引数の数が指令に対して正しくありません: /* VARARGS4 */:
    	有効な引数の数(3) は、指令によって検査される引数の数(4) より少なくてはいけません

メッセージ ID: E_DIRECTIVE_TOO_MANY_ARG2

## 変数が設定以前に使用されている可能性があります。

配列でない自動変数に値を代入する行より前で、その自動変数を参照しています。変数のアドレスの取得は、変数が設定され使用されたものとみなされます。`構造体`または`共用体`に関しては、いずれかのメンバーに最初に代入を行うと、`構造体`または`共用体`の全メンバーに対して代入が行われたものとみなされます (出力形式: simple)。このメッセージを生成するコードの例

    1 void
    2 v(void)
    3 {
    4 	int             i, j, k;
    5 	static int      x;
    6 	k = j;
    7 	i = i + 1;
    8 	x = x + 1;
    9 }
    ============
    (6) 警告:変数が設定以前に使用されている可能性があります。 j
    (7) 警告:変数が設定以前に使用されている可能性があります。 i

メッセージ ID: E_VAR_USED_BEFORE_SET

## 条件のコンテキストに定数があります。

`if`、`while`、または `for` 文の制御式が定数になっています。 文の前に、`/* CONSTCOND */` を置くと、このメッセージが表示されなくなります (出力形式: simple)。このメッセージを生成するコードの例

    1 void
    2 main(void)
    3 {
    4 	if (!1)
    5 		return;
    6 	while (1)
    7 		f();
    8 	for (; 1;);
    9 	for (;;);
    10 	/* CONSTCOND */
    11 	while (1);
    12 }
    ============
    (4) 警告:条件のコンテキストに定数があります
    (6) 警告: 条件のコンテキストに定数があります
    (8) 警告: 条件のコンテキストに定数があります

メッセージ ID: E_CONSTANT_CONDITION

## 評価順序が未定義となります。

変数が副作用によって変更され、同じ式の別の位置で使用されています (出力形式: Simple)。 このメッセージを生成するコードの例

    1 static int      ia[10];
    2 void
    3 v(void)
    4 {
    5 	int             i = 2;
    6 	ia[i++] = i;
    7 }
    ============
    (6) 警告:評価順序が未定義となります。 i

メッセージ ID: E_UNDEF_EVAL_ORDER

## 論理式が常に偽です:演算子 "&"

論理積 `&` において、オペランドの 1 つが、同一の変数と異なる 2 つの定数との等価性を検査している、または定数 0 です。定数が 0 の場合、式の前に `/* CONSTCOND */` を置くと、このメッセージが表示されなくなります (出力形式: simple)。このメッセージを生成するコードの例

    1 int
    2 main(int argc, char *argv[])
    3 {
    4 	int             i = argc;
    5 	i = (i == 1) & (i == 2);
    6 	i = (i == 1) & (i == 1);
    7 	i = (1 == i) & (i == 2);
    8 	i = (i == 1) & 0;
    9 	/* CONSTCOND */
    10 	i = (0 & (i == 1));
    11 	return (i);
    12 }
    ============
    (5) 警告: 論理式が常に偽です: 演算子 "&"
    (7) 警告: 論理式が常に偽です: 演算子 "&"
    (8) 警告: 論理式が常に偽です:演算子 "&"

メッセージ ID: E_FALSE_LOGICAL_EXPR

## 論理式が常に真です: 演算子 "|| "

論理和 `||` において、オペランドの 1 つが、同一の変数と異なる 2 つの定数との不等価性を検査している、または 0 以外の定数です。0 以外の定数の場合、式の前に `/* CONSTCOND */` を置くと、このメッセージが表示されなくなります (出力形式: simple)。このメッセージを生成するコードの例

    1  int f(int i)
    2  {
    3  	i = (i != 1) || (i != 2);
    4  	i = (i != 1) || (i != 1);
    5  	i = (1 != i) || (i != 2);
    6  	i = (i == 10) || 1;
    7  /* CONSTCOND */
    8  	i = (1 || (i == 10));
    9 	return i;
    10  }
    ============
    (3) 警告: 論理式が常に真です: 演算子 "||"
    (5) 警告: 論理式が常に真です: 演算子 "||"
    (6) 警告: 論理式が常に真です: 演算子 "||"

メッセージ ID: E_TRUE_LOGICAL_EXPR

## char または unsigned の値が負の定数または 0 と比較されています。

「通常」の `char` または `unsigned` の変数が、負またはゼロの値と比較されていますが、この比較は正しくない可能性があります。通常の `char` を `signed` (符号付き) として扱うかどうかは、インプリメンテーションによって定義されます(出力形式: simple)。このメッセージを生成するコードの例

    1 void
    2 v(char c, signed char sc)
    3 {
    4 	int             i;
    5 	i = (c == -5);
    6 	i = (c < 0);
    7 	i = (sc < 0);
    8 }
    ============
    (5) 警告: schar が negative constant と比較されています: 演算子 "=="
    (6) 警告: char が 0 と比較されています: op "<"

このメッセージを生成するコードの例を次に示します。

    1 void
    2 v(unsigned int ui)
    3 {
    4 	int             i;
    5 	i = (ui > -2);
    6 	i = (ui < 0);
    7 	i = (ui <= 0);
    8 	i = (ui >= 0);
    9 	i = (ui > 0);
    10 	i = (-2 < ui);
    11 	i = (ui == -1);
    12 	i = (ui == -1U);
    13 }
    ============
    (5) 警告:unsigned と negative constant が比較されています: 演算子 ">"
    (6) 警告: unsigned と 0 が比較されています: 演算子 "<"
    (7) 警告: unsigned と 0 が比較されています: 演算子 "<="
    (8) 警告: unsigned と 0 が比較されています: 演算子 ">="
    (9) 警告: unsigned と 0 が比較されています: 演算子 ">"
    (10) 警告: unsigned と negative constant が比較されています: op "<"
    (11) 警告:unsigned と negative constant が比較されています: 演算子 "=="

メッセージ ID: E_SUSPICIOUS_COMPARISON

## ! 演算子に定数オペランドが与えられています。

`!` 演算子のオペランドが、定数になっています。この文の前に、`/* CONSTCOND */` を置くと、対応する文に対するメッセージが表示されなくなります。このメッセージは、`-h` を指定して `lint` を起動した場合には表示されません (出力形式: simple)。このメッセージを生成するコードの例

    1  void main(void)
    2  {
    3  	if (! 0) return;
    4  	/* CONSTCOND */
    5  	if (! 0) return;
    6  }
    ============
    (3) 警告: 演算子に定数オペランドが与えられています:""!"

メッセージ ID: E_CONST_EXPR

## 負の定数が unsigned 型に代入されています。

符号なし整数型に、負の定数を代入しています。符号なし整数型にできるのは、正の値またはゼロだけです。 このメッセージを生成するコードの例を次に示します。

    unsigned char uc = -1;
    unsigned int b = -13;

メッセージ ID: E_ASSIGN_NEG_CONST_TO_UNSIGNED

## 代入によって定数が切り捨てられます。

整数定数式の値が、代入先の整数型オブジェクトのサイズを超えているため、式の値が切り捨てられます (出力形式: simple)。このメッセージを生成するコードの例

    1 unsigned char
    2 f()
    3 {
    4 	unsigned char   uc;
    5 	uc = 255;
    6 	uc = 256;
    7 	return uc;
    8 }
    ============
    (6) 警告:代入によって定数が切り捨てられます。

メッセージ ID: E_CONST_TRUNCATED_BY_ASSIGN

## ポインタの変換でビットが失われます。

ポインタのサイズが、代入先の整数型オブジェクトのサイズを超えています。 (出力形式: simple)。このメッセージを生成するコードの例

    1 void
    2 v(void)
    3 {
    4 	int            *ip;
    5 	char            c;
    6 	c = ip;
    7 }
    ============
    (6) 警告：ポインタの変換でビットが失われます。

メッセージ ID: E_PTR_CONV_LOSES_BITS

## 配列の添字に負の数は指定できません。

ポインタではない実際の配列の添え字を表す定数式に、負の値が使用されています (出力形式: simple)。このメッセージを生成するコードの例

    1 int
    2 main(void)
    3 {
    4 	int             ia[10];
    5 	return ia[5 * 2 / 10 - 2];
    6 }
    ============
    (5) 警告:配列の添字に負の数は指定できません。 -1

メッセージ ID: E_NEG_ARRAY_SUBSCRIPT

## 配列の添字に value より大きな値は指定できません。

配列要素の添え字の値が、配列の上限値を超えています (出力形式： simple)。このメッセージを生成するコードの例

    1 int
    2 f(void)
    3 {
    4 	int             ia[10];
    5 	int            *ip = ia;
    6 	while (ip != &ia[10])	/* アドレスとしての使用は可 */
    7 		ip++;
    8 	return ia[5 + 6];
    9 }
    ============
    (8) 警告: 配列の添字に 9 より大きな値は指定できません: 11

メッセージ ID: E_OVERFLOW_ARRAY_SUBSCRIPT

## 優先度が混乱する可能性があります; 括弧

論理演算子とビット単位演算子が混在する式が、括弧で囲まれていません。このメッセージは、`-h` を指定して `lint` を起動した場合には、表示されません (出力形式: simple)。このメッセージを生成するコードの例

    1 void
    2 v(void)
    3 {
    4 	int             i = 0, j = 0, x;
    5 	x = (2 + i == 0);
    6 	x = (i & j == 0);	/* (i & (j == 0)) と解釈 */
    7 	x = (j == 1 & i);	/* ((j == 1) & i) と解釈 */
    8 }
    ============
    (6) 警告:優先度が混乱する可能性があります; 括弧
    (7) 警告: 優先度が混乱する可能性があります; 括弧

メッセージ ID: E_PRECEDENCE_CONFUSION

## long long 型の変数は HP 上の printf および scanf ルーチンファミリでは許可されません。

HP-UX の printf や scanf のルーチンによって、long long 型の変数を出力したり読み込んだりすることはできません。

メッセージ ID: E_HPUX_BAD_FORMAT_STR1

## long long 型の変数は HP 上の printf および scanf ルーチンファミリでは許可されません。

HP-UX の printf や scanf のルーチンによって、long long 型の変数を出力したり読み込んだりすることはできません。

メッセージ ID: E_HPUX_BAD_FORMAT_STR2

## 名前が定義されていますが使用されていません。

変数または関数を定義していますが、ソースファイル中で使用されていません。 このメッセージを生成するコードの例を次に示します。

    int f();
    int main() {
      int a = 10;
      printf("関数 f() の呼び出しはない" );
    return 0;
    }
    int f() {
      return (1+1);
    }

メッセージ ID: E_NAME_DEF_NOT_USED

## 名前が宣言されていますが使用も定義もされていません。

変数または関数を定義していますが、ソースファイル中で使用されていません。 このメッセージを生成するコードの例を次に示します。

    int f();
    int main() {
    	int a;
    	printf("関数 f() の呼び出しと a の使用はない");
    	return 0;
    }

メッセージ ID: E_NAME_DECL_NOT_USED_DEF

## 名前が重複して定義されています。

変数が、複数回、異なる場所で宣言されています。 参照したい変数が、現在のスコープ内の別の変数定義によって、無効にならないように注意してください。 このメッセージを生成するコードの例

    int x = 10;        /* 大域変数 x */
    int main() {
      int x = 1;	   /* 変数 x の別の定義 */
      return f(x);
    }
    int f(int y) {
      int x = 5;	       /* 局所変数 x の宣言 x */
      return (y + g(x));   /* 現在のスコープ中で x を使用 */
    }
    int g(int z) {
      return (x*z);       /* x を使用 */
    }

メッセージ ID: E_NAME_MULTIPLY_DEF

## ファイルからの読み取りエラー

指定したファイルを読み込んでいる時に、ファイルシステムエラーが発生しました。 これは、ソースプログラムのエラーではありません。

メッセージ ID: E_F_RD_ERR

## ファイルでの書き込みエラー

指定したファイルを読み込んでいる時に、ファイルシステムエラーが発生しました。 これは、ソースプログラムのエラーではありません。

メッセージ ID: E_F_WR_ERR

## ファイルを開けません。

指定したファイルを読み込んでいる時に、ファイルシステムエラーが発生しました。 これは、ソースプログラムのエラーではありません。

メッセージ ID: E_OPEN_F

## 列挙型のメンバーの宣言が整合していません。

`enum` のメンバーに、同じ名前で異なる値が定義されています。 このメッセージを生成するコードの例を次に示します。

    file f.c:
    1 typedef enum {
    2 	ONE = 1, TWO = 3
    3 } e;
    file f_1.c:

    1 typedef enum {
    2 	ONE = 1, TWO
    3 } e;
    ============
    列挙型のメンバーの宣言が整合していません
        TWO              3 f.c(2) :: 2 f_1.c(2)

メッセージ ID: E_ENUM

## マクロの定義が異なっています。

複数のソースファイルで、同じ名前で異なるマクロが定義されています。 このメッセージを生成するコードの例を次に示します。

    file f.c:
    1 #define MAX_I   1
    file f_1.c:
    1 #define MAX_I   2
    ============
    マクロの定義が異なっています
        MAX_I            	f.c(1) :: f_1.c(1)

メッセージ ID: E_MCR_NODIFF

## 以下のインクルードファイルは不要です。

指定したインクルードファイルは、プログラムのコンパイル中に使用されていません。 このメッセージを生成するコードの例を次に示します。

    #include      /* 数学関数は使用されていない */
    int main () {
    	return 0;
    }

メッセージ ID: E_INCL_NO_US

## 列挙型のメンバーが定義されていますが使用されていません。

未使用の `enum` メンバーがあります。 このメッセージを生成するコードの例を次に示します。

    1 enum {
    2 	x,
    3 	y = 3,
    4 	z
    5 } en;
    6 main(void)
    7 {
    8 	en = z;
    9 	return en;
    10 }
    ============
    列挙型のメンバーが定義されていますが使用されていません
        x                	f.c(2)
        y                	f.c(3)

メッセージ ID: E_ENUM_UNUSE

## typedef で定義されていますが使用されていません。

`typedef` で宣言されている型が、プログラム中で使用されていません。 このメッセージを生成するコードの例を次に示します。

    1 typedef long int LONG_INT_t;
    2 void
    3 main(void)
    4 {
    5 	return;
    6 }
    ============
    typedef で定義されていますが使用されていません
        LONG_INT_t       	f.c(1)

メッセージ ID: E_TYPEDEF_UNUSE

## typedef による宣言が整合していません。

`typedef` による、同じ名前に対する異なる定義があります。 このメッセージを生成するコードの例を次に示します。

    1 typedef long int LONG_INT_t;
    2 int
    3 f(void)
    4 {
    5 	typedef long long int LONG_INT_t;
    6 	LONG_INT_t      li = 1;
    7 	return li;
    8 }
    ============
    typedef による宣言が整合していません
        LONG_INT_t       	long long  f.c(1) :: long  f.c(5)

メッセージ ID: E_TYPEDEF_INCONSIST

## .c ファイルに対応する .h ファイルがありません。

`.c` ファイルと同じ名前の `.h` ファイルがありません (出力形式: simple)。このメッセージを生成するコードの例

    1 void
    2 main(void)
    3 {
    4 	int            *ip;
    5 	ip = (int *) sizeof(int);
    6 	free(ip);
    7 	ip = (int *) malloc(sizeof(int) * 10);
    8 	ip++;
    9 	free(ip);
    10 }
    ============
    .c ファイルに対応する .h ファイルがありません
        /export/ld6/clint/LINT.EXMPLS/f/f.c

メッセージ ID: E_H_C_CHECK0

## .h ファイルで extern 宣言されていますが、対応する .c ファイルで定義されていません。

`.h` ファイルで `extern` 宣言されていますが、対応する `.c` ファイルで定義されていません。 このメッセージを生成するコードの例を次に示します。

    file f.h:
    1 extern int      i;
    2 extern int      f(int x, int y);

    file f.c:
    1 #include "f.h"
    2 int             ia[2];
    3 int             i;
    4 int
    5 f(int x, int y)
    6 {
    7 	ia[0] = x;
    8 	ia[1] = y;
    9 	if (ia[i] > ia[1])
    10 		ia[0] = ia[1];
    11 	return (x + y) / 2;
    12 }
    ============
    .c ファイルで extern 定義されていますが、対応する .h ファイルで宣言されていません
        ia               	f.c(2)

メッセージ ID: E_H_C_CHECK1

## .c ファイルで extern 定義されていますが、対応する .h ファイルで宣言されていません。

`.c` ファイルで `extern` 名が定義されていますが、対応する `.h` ファイルで宣言されていません。 このメッセージを生成するコードの例を次に示します。

    file f.h:
    1 int             i;
    2 extern int      f(int x, int y);

    file f.c:
    1 #include "f.h"
    2 extern int      i;
    3 int
    4 f(int x, int y)
    5 {
    6 	int             ia[2];
    7 	ia[0] = x;
    8 	ia[1] = y;
    9 	if (ia[i] > ia[1])
    10 		ia[0] = ia[1];
    11 	return (x + y) / 2;
    12 }
    13 int
    14 main(void)
    15 {
    16 	i = 5;
    17 	return f(i, -i);
    18 }
    ============
    .c ファイルで extern 定義されていますが、対応する .h ファイルで宣言されていません
        main             	f.c(14)

メッセージ ID: E_H_C_CHECK2

## 名前が定義されていますが実行時に使用されていません。

関数が定義されていますが、実行時に使用されていません。たとえば、到達されないコードから関数が呼び出されています。 このメッセージを生成するコードの例を次に示します。

    file f.c:
    1 extern int      f(void);
    2
    3 main(void)
    4 {
    5 	int             i = 0;
    6 	if (i > 0)
    7 		i = f();
    8 	return i;
    9 }

    file f_1.c:
    1 int
    2 f(void)
    3 {
    4 	return 3;
    5 }
    ============

メッセージ ID: E_UNCAL_F

## 到達できない文です。

プログラム中に、1 度も実行されない文があります。 このメッセージを生成するコードの例

    int f() {
      printf("前に return 文がある\n");
    return 0;

      assert(FALSE);    /* <==== 到達できない文です */
    }

メッセージ ID: E_STM_RCH

## 引数が正しくないため、メモリーを解放することができません。

引数が、割り当てられたメモリーへのポインタになっていません。 (出力形式: simple)。このメッセージを生成するコードの例

    1 #include <stdlib.h>
    2 int            *ip;
    3 void
    4 main(void)
    5 {
    6 	free(*ip);
    7 	return;
    8 }
    ============
    f.c(6): 引数が正しくないため、メモリーを解放することができません

メッセージ ID: E_A_NOMEM

## メモリーの解放が重複して行われています。

すでに解放されたメモリーを解放しています。 このメッセージを生成するコードの例を次に示します。

    1 #include <malloc.h>
    2 static int     *ip, *jp;
    3 void
    4 main(void)
    5 {
    6 	ip = malloc(sizeof(int));
    7 	jp = ip;
    8 	free(ip);
    9 	free(jp);
    10 }
    ============
    メモリーの解放が重複して行われています
        f.c(9)	:: f.c(8)

メッセージ ID: E_P_FREE_DEALLOC

## メモリーの解放が重複して行われている可能性があります。

すでに解放された可能性のあるメモリーを解放しています。 このメッセージを生成するコードの例を次に示します。

    1 #include <malloc.h>
    2 static int     *ip, *jp;
    3 void
    4 main(int argc, char *argv[])
    5 {
    6 	ip = malloc(sizeof(int));
    7 	*ip = 4;
    8 	jp = ip;
    9 	if (argc > 2)
    10 		free(ip);
    11 	free(jp);
    12 }
    ============
    メモリーの解放が重複して行われている可能性があります
        f.c(11)	:: f.c(10)

メッセージ ID: E_P_FREE_DEALLOC_PSBL

## 解放されたメモリーを参照しています。

解放されたメモリーを参照しています。 このメッセージを生成するコードの例を次に示します。

    1 #include <malloc.h>
    2 static int     *ip;
    3 int
    4 main(void)
    5 {
    6 	int             i;
    7 	ip = malloc(10);
    8 	*ip = 2;
    9 	free(ip);
    10 	i = *ip;
    11 	return (i);
    12 }
    ============
    解放されたメモリーを参照しています
        f.c(10)	:: f.c(9)

メッセージ ID: E_P_REF_DEALLOC

## 解放されたメモリーを参照している可能性があります。

解放されたメモリーが参照される可能性があります。 このメッセージを生成するコードの例を次に示します。

    1 #include <malloc.h>
    2 static int     *ip;
    3 int
    4 main(int argc, char *argv[])
    5 {
    6 	int             i;
    7 	ip = malloc(10);
    8 	*ip = 2;
    9 	if (argc > 2)
    10 		free(ip);
    11 	i = *ip;
    12 	return (i);
    13 }
    ============
    解放されたメモリーを参照している可能性があります
        f.c(13)	:: f.c(12)

メッセージ ID: E_P_REF_DEALLOC_PSBL

## 解放されたメモリーへのポインタを使用しています

解放されたメモリーへのポインタが使用されています。 このメッセージを生成するコードの例を次に示します。

    1 #include <malloc.h>
    2 static int     *ip;
    3 void
    4 main(void)
    5 {
    6 	int            *jp;
    7 	ip = malloc(10);
    8 	free(ip);
    9 	jp = ip;
    10 }
    ============
    解放されたメモリーへのポインタを使用しています
        f.c(9)	:: f.c(8)

メッセージ ID: E_P_USE_DEALLOC

## 解放されたメモリーへのポインタを使用している可能性があります。

解放されたメモリーへのポインタが使用される可能性があります。 このメッセージを生成するコードの例を次に示します。

    1 #include
    2 void
    3 f(char*ip)
    4 { free(ip);
    5 }
    6
    7 char
    8 main(int argc, char *argv[])
    9 { char *ip, *jp;
    10
    11  ip = malloc(argc+4);
    12  if (argc-- == 0) f(ip);
    13  if (argc> 1)
    14  {  jp = ip;
    15     return *jp; }
    16  else
    17     return '0';
    18 }
    ============

メッセージ ID: E_P_USE_DEALLOC_PSBL

## 変数へのポインタを解放しています。

変数へのポインタは解放できません。 このメッセージを生成するコードの例を次に示します。

    1 #include <malloc.h>
    2 int
    3 main(void)
    4 {
    5 	int            *ip;
    6 	int             i;
    7 	ip = &i;
    8 	free(ip);
    9 }
    ============
    変数へのポインタを解放しています
        i defined at f.c(6)	:: f.c(8)

メッセージ ID: E_P_FREE_VAR

## 変数を指している可能性のあるポインタを解放しています。

変数を指す可能性のあるポインタを解放しています。 このメッセージを生成するコードの例を次に示します。

    1 #include <malloc.h>
    2 static int     *ip;
    3 int
    4 main(int argc, char *argv[])
    5 {
    6 	int             i;
    7 	if (argc > 2)
    8 		ip = &i;
    9 	else
    10 		ip = malloc(sizeof i);
    11 	*ip = 99;
    12 	free(ip);
    13 	return (++*ip);
    14 }
    ============
    変数を指している可能性のあるポインタを解放しています
        i defined at f.c(6)	:: f.c(12)

メッセージ ID: E_P_FREE_VAR_PSBL

## 存在しなくなった変数へのポインタを使用して参照しています。

すでに存在していない変数を指すポインタを使用して参照を行なっています。 自動記憶クラスのオブジェクトは、そのブロック外で保持されることは保証されないので、このオブジェクトへのポインタは、ブロックが終わると未定義になります。 このメッセージを生成するコードの例を次に示します。

    1 int            *ip;
    2 f(void)
    3 {
    4 	int             i = 0;
    5 	ip = &i;
    6 	return (i);
    7 }
    8 main(void)
    9 {
    10 	int             j;
    11 	j = f();
    12 	j += *ip;
    13 	return (j);
    14 }
    ============
    存在しなくなった変数へのポインタを使用して参照しています
        i defined at f.c(4)	:: f.c(12)

メッセージ ID: E_P_REF_VAR

## 存在しなくなった変数へのポインタを使用して参照している可能性があります。

すでに存在していない変数を指すポインタを使用して、参照が行われる可能性があります。 自動記憶クラスのオブジェクトは、そのブロック外で保持されることは保証されないので、このオブジェクトへのポインタは、ブロックが終わると未定義になります。 このメッセージを生成するコードの例を次に示します。

    1 int            *ip, ei;
    2 f(int n)
    3 {
    4 	int             i = 0;
    5 	ip = &ei;
    6 	if (n > 0)
    7 		ip = &i;
    8 	return (i);
    9 }
    10 main(int argc, char *argv[])
    11 {
    12 	int             j;
    13 	j = f(argc);
    14 	j += *ip;
    15 	return (ei + j);
    16 }
    ============
    存在しなくなった変数へのポインタを使用して参照している可能性があります
        i defined at f.c(4)	:: f.c(14)

メッセージ ID: E_P_REF_VAR_PSBL

## 存在しなくなった変数へのポインタを使用しています。

すでに存在していない変数を指すポインタが使用されています。 自動記憶クラスのオブジェクトは、そのブロック外で保持されることは保証されないので、このオブジェクトへのポインタは、ブロックが終わると未定義になります。 このメッセージを生成するコードの例を次に示します。

    1 int            *ip, ei;
    2 f(void)
    3 {
    4 	int             x = 0;
    5 	ip = &x;
    6 	return (x);
    7 }
    8 main(void)
    9 {
    10 	int             i;
    11 	i = f();
    12 	ip++;
    13 	return (ei + i);
    14 }
    ============
    存在しなくなった変数へのポインタを使用しています
        x defined at f.c(4)	:: f.c(12)

メッセージ ID: E_P_USE_VAR

## 存在しなくなった可能性のある変数へのポインタを使用しています。

すでに存在していない変数を指す可能性があるポインタが使用されています。 自動記憶クラスのオブジェクトは、そのブロック外で保持されることは保証されないので、このオブジェクトへのポインタは、ブロックが終わると未定義になります。 このメッセージを生成するコードの例を次に示します。

    1 int            *ip, ei;
    2 g(int n)
    3 {
    4 	int             x = 0, y = 1;
    5 	ip = &ei;
    6 	if (n > 0)
    7 		ip = &x;
    8 	return (x);
    9 }
    10 main(int argc, char * argv[])
    11 {
    12 	int             i;
    13 	i = g(argc);
    14 	ip++;
    15 	return (ei + i);
    16 }
    ============
    存在しなくなった可能性のある変数へのポインタを使用しています
        x defined at f.c(4)	:: f.c(14)

メッセージ ID: E_P_USE_VAR_PSBL

## 局所変数へのポインタを返しています。

関数が、ポインタに格納された、自動局所変数またはパラメータのアドレスを返しています。 自動記憶クラスのオブジェクトは、そのブロック外で保持されることは保証されないので、このオブジェクトへのポインタは、ブロックが終わると未定義になります。 このメッセージを生成するコードの例を次に示します。

    1 int            *
    2 f(void)
    3 {
    4 	int             i;
    5 	int            *ip = &i;
    6 	return (ip);
    7 }
    8 void
    9 main(void)
    10 {
    11 	int            *jp;
    12 	jp = f();
    13 	(*jp)++;
    14 }
    ============
    局所変数へのポインタを返しています
        i defined at f.c(4)	:: f.c(6)

メッセージ ID: E_P_RET_VAR

## 局所変数へのポインタを返している可能性があります。

関数が、自動局所変数のアドレスを返す可能性があります。 自動記憶クラスのオブジェクトは、そのブロック外で保持されることは保証されないので、このオブジェクトへのポインタは、ブロックが終わると未定義になります。 このメッセージを生成するコードの例を次に示します。

    1 static int     *
    2 f(int *ip)
    3 {
    4 	int             i;
    5 	int            *jp = ip;
    6 	if (*ip > 5)
    7 		jp = &i;
    8 	return jp;
    9 }
    10 main(void)
    11 {
    12 	int             i = 1;
    13 	i += *f(&i);
    14 	return i;
    15 }
    ============
    局所変数へのポインタを返している可能性があります
        i defined at E_P_RET_VAR_PSBL.c(4)	:: E_P_RET_VAR_PSBL.c(8)

メッセージ ID: E_P_RET_VAR_PSBL

## NULL ポインタを解放しています。

引数が `NULL` になります。 このメッセージを生成するコードの例を次に示します。

    1 #include <malloc.h>
    2 #define ADDR	0
    3 static int     *ip;
    4 main(void)
    5 {
    6 	ip = ADDR * sizeof(int);
    7 	free(ip);
    8 	return 0;
    9 }
    ============
    NULL ポインタを解放しています
        f.c(7)

メッセージ ID: E_P_FREE_NULL

## NULL である可能性のあるポインタを解放しています。

`NULL` になる可能性のあるポインタを解放しています。 このメッセージを生成するコードの例を次に示します。

    1 #include <malloc.h>
    2 static int     *ip;
    3 main(int argc, char *argv[])
    4 {
    5 	if (argc == 2)
    6 		ip = 0;
    7 	else
    8 		ip = malloc(sizeof(int));
    9 	free(ip);
    10 	return 0;
    11 }
    ============
    NULL である可能性のあるポインタを解放しています
        f.c(9)

メッセージ ID: E_P_FREE_NULL_PSBL

## `NULL` ポインタを使用して参照しています。

NULL ポインタを使用して参照を行なっています。 このメッセージを生成するコードの例を次に示します。

    1 static int     *ip;
    2 int
    3 main(void)
    4 {
    5 	int             i = 0;
    6 	ip = (int *) 0;
    7 	i = *ip;
    8 	i = i + *ip;
    9 	return (i);
    10 }
    ============
    NULL ポインタを使用して参照しています
        f.c(7)

メッセージ ID: E_P_REF_NULL

## NULL ポインタを使用して参照している可能性があります。

`NULL` ポインタを使用して、参照が行なわれる可能性があります。 このメッセージを生成するコードの例を次に示します。

    1 static int     *ip;
    2 static int      si = 99;
    3 int
    4 main(int argc, char *argv[])
    5 {
    6 	int             i = 0;
    7 	if (argc == 2)
    8 		ip = (int *) 0;
    9 	else
    10 		ip = &si;
    11 	i = i + *ip;
    12 	return (i);
    13 }
    ============
    NULL ポインタを使用して参照している可能性があります
        f.c(11)

メッセージ ID: E_P_REF_NULL_PSBL

## NULL ポインタを不当に使用している可能性があります。

`NULL` ポインタが正しく使用されない可能性があります。 このメッセージを生成するコードの例を次に示します。

    1 int
    2 main(int argc, char * argv[])
    3 {
    4 	int            *ip, *jp;
    5 	int             i;
    6 	ip = 0;
    7 	if (argc > 1)
    8 		ip = &i;
    9 	jp = ip;
    10 	return (*jp)++;
    11 }
    ============
    NULL の可能性があるポインタを使用して変更しています
        ip defined at f.c(4)	:: f.c(10)

メッセージ ID: E_P_USE_NULL_PSBL

## 初期化されていないポインタを解放しています。

引数が初期化されていません。 このメッセージを生成するコードの例を次に示します。

    1 #include <malloc.h>
    2 void
    3 main(void)
    4 {
    5 	int            *ip;
    6 	free(ip);
    7 }
    ============
    初期化されていないポインタを解放しています
        ip defined at f.c(5)	:: f.c(6)

メッセージ ID: E_P_FREE_UNINI

## 値が初期化されていない可能性のあるポインタを解放しています。

値が初期化されていない可能性があるポインタを解放しています。 このメッセージを生成するコードの例を次に示します。

    1 #include <malloc.h>
    2
    3 void
    4 main(int argc, char *argv[])
    5 {
    6	int     *ip;
    7 	if (argc == 0)
    8 		ip = malloc(sizeof(int));
    9 	free(ip);
    10 }
    ============
    値が初期化されていない可能性のあるポインタを解放しています
        ip defined at f.c(5)	:: f.c(8)

メッセージ ID: E_P_FREE_UNINI_PSBL

## 値が初期化されていないポインタを使用して参照しています。

値が初期化されていないポインタを使用して、参照が行われています。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 main(void)
    3 {
    4 	int             i;
    5 	int            *ip;
    6
    7 	i = *ip;
    8 }
    ============
    値が初期化されていないポインタを使用して参照しています
        ip defined at f.c(5)	:: f.c(7)

メッセージ ID: E_P_REF_UNINI

## 初期化されていないポインタを使用して参照している可能性があります。

初期化されていないポインタを使用して、参照が行われる可能性があります。 このメッセージを生成するコードの例を次に示します。

    1 #include
    2
    3 void
    4 v(int i, char **p)
    5 {
    6	*p = (char *) malloc(sizeof(int) * (i + 1));
    7	**p = '0';
    8 }
    9
    10 char
    11 main(int argc, char *argv[])
    12 {
    13	char           *cp;
    14	if (argc)
    15		v(argc, &cp);
    16	return *cp;
    17 }
    ============
    初期化されていないポインタを使用して参照している可能性があります
        cp defined at f.c(13)	:: f.c(16)

メッセージ ID: E_P_REF_UNINI_PSBL

## 値が初期化されていないポインタを使用しています。

値が初期化されていないポインタを使用しています。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 main(void)
    3 {
    4 	int            *ip;
    5
    6 	ip++;
    7 }
    ============
    値が初期化されていないポインタを使用しています
        ip defined at f.c(4)	:: f.c(6)

メッセージ ID: E_P_USE_UNINI

## 値が初期化されていない可能性のあるポインタを使用しています。

値が初期化されていない可能性のあるポインタを使用しています。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 main(int argc, char *argv[])
    3 {
    4 	int             i;
    5 	int            *ip;
    6 	if (argc > 1)
    7 		ip = &i;
    8 	ip++;
    9 }
    ============
    値が初期化されていない可能性のあるポインタを使用しています
        ip defined at f.c(5)	:: f.c(8)

メッセージ ID: E_P_USE_UNINI_PSBL

## 疑わしい方法で作成されたポインタを解放しています。

不適切な方法で生成されたポインタを解放しています。たとえば、整数値がポインタ値に変換された可能性があります。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 main(void)
    3 {
    4 	int            *ip;
    5 	ip = (int *) sizeof(int);
    6 	free(ip);
    7 }
    ============
    疑わしい方法で作成されたポインタを解放しています
        f.c(6)

メッセージ ID: E_P_FREE_SUSP

## 疑わしい方法で作成された可能性のあるポインタを解放しています。

不適切な方法で生成された可能性のあるポインタを解放しています。 このメッセージを生成するコードの例を次に示します。

    1 #include <malloc.h>
    2 void
    3 main(int argc, char *argv[])
    4 {
    5 	int            *ip;
    6 	ip = (int *) malloc(sizeof(int) * 10);
    7 	*ip = argc - 1;
    8 	if (*ip == 0)
    9 		ip = (int *) sizeof(int);
    10 	free(ip);
    11 }
    ============
    疑わしい方法で作成された可能性のあるポインタを解放しています
        f.c(10)

メッセージ ID: E_P_FREE_SUSP_PSBL

## 疑わしい方法で作成されたポインタを使用して参照しています。

不適切な方法で生成されたポインタを使用して、参照が行われています。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 main(void)
    3 {
    4 	int            *ip;
    5 	int             i;
    6 	ip = (int *) sizeof i;
    7 	i = *ip;
    8 }
    ============
    疑わしい方法で作成されたポインタを使用して参照しています
        f.c(7)

メッセージ ID: E_P_REF_SUSP

## 疑わしい方法で作成されたポインタを使用して参照している可能性があります。

不適切な方法で生成された可能性のあるポインタを使用して、参照が行われる可能性があります。 このメッセージを生成するコードの例を次に示します。

    1 main(int argc, char *argv[])
    2 {
    3 	int            *ip;
    4 	int             i = argc;
    5 	ip = (int *) sizeof i;
    6 	if (argc > 2)
    7 		ip = &i;
    8 	return *ip;
    9 }
    ============
    疑わしい方法で作成されたポインタを使用して参照している可能性があります
        E_P_REF_SUSP_PSBL.c(8)

メッセージ ID: E_P_REF_SUSP_PSBL

## 疑わしい方法で作成されたポインタを使用しています。

不適切な方法で生成されたポインタが使用されています。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 main(void)
    3 {
    4 	int            *ip, *jp;
    5 	int             i = 0;
    6 	ip = (int *) sizeof i;
    7 	jp = ip;
    8 }
    ============
    疑わしい方法で作成されたポインタを使用しています
        f.c(7)

メッセージ ID: E_P_USE_SUSP

## 疑わしい方法で作成されたポインタを使用している可能性があります。

不適切な方法で生成された可能性のあるポインタが使用されています。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 main(int argc, char *argv[])
    3 {
    4 	int            *ip, *jp;
    5 	int             i = 99;
    6 	ip = (int *) sizeof i;
    7 	if (argc> 2)
    8 		ip = &i;
    9 	jp = ++ip;
    10 }
    ============
    疑わしい方法で作成されたポインタを使用している可能性があります
        f.c(9)

メッセージ ID: E_P_USE_SUSP_PSBL

## 代入された値が使用されていません。

プログラム中で変数の値が使用されていません。 不必要な代入は、削除することができます。 このメッセージを生成するコードの例を次に示します。

    1 static int     *ip, i;
    2 static void
    3 f(void)
    4 {
    5 	int            *iq;
    6 	ip = &i;
    7 	iq = ip;
    8 	*ip = 7;
    9 }
    10 int
    11 main(int argc, char *argv[])
    12 {
    13 	int             j = 0xff;
    14 	f();
    15 	j = 0x01;
    16 	if (argc > 2)
    17 		ip = &i;
    18 	else
    19 		ip = &j;
    20 	*ip = 1;
    21 	ip = ip + 1;
    22 	*ip = 2;
    23 	return (0);
    24 }
    ============
    代入された値が使用されていません
        iq defined at f.c(5)	:: set at f.c(7)
        i defined at f.c(1)	:: set at f.c(8)
        j defined at f.c(13)	:: set at f.c(13)
        j defined at f.c(13)	:: set at f.c(15)
        j defined at f.c(13)	:: set at f.c(22)
        i defined at f.c(1)	:: set at f.c(22)

    代入された値が使用されていません
        j defined at f.c(13)	:: set at f.c(20)	:: reset at f.c(22)
        i defined at f.c(1)	:: set at f.c(20)	:: reset at f.c(22)

メッセージ ID: E_ASGN_NEVER_USED

## 代入された値が使用されていません; 再設定

変数に値が代入されていますが、その値は、次に別の値が代入される前に使用されていません。不必要な代入は、削除することができます。 このメッセージを生成するコードの例を次に示します。

    1 static int     i;
    2 int main (void)
    3 {
    4       int            iq;
    5       iq = 8;
    6       i = 7;
    7       iq = i;
    8       return iq;
    9 }
    ==========
    "t2.c", line 5: 警告: assigned value never used: iq defined at t2.c(4); reset at t2.c(7)

メッセージ ID: E_ASGN_RESET

## 定数データを変更しています。

定数データまたは変数が変更されています。 このメッセージを生成するコードの例を次に示します。

    1 static const int ic = 1;
    2 static void
    3 f(int *ip)
    4 {
    5 	(*ip)++;
    6 }
    7 main(void)
    8 {
    9 	int            *ip = (int *) ⁣
    10 	f(ip);
    11 	return ic;
    12 }
    ============
    定数データを変更しています
        ic defined at f.c(1)	:: f.c(5)

メッセージ ID: E_ASGN_CONST

## 定数データを変更している可能性があります。

定数データまたは変数が変更される可能性があります。 このメッセージを生成するコードの例を次に示します。

    1 static const int ic = 1;
    2 static void
    3 f(int *iq)
    4 {
    5 	(*iq)++;
    6 }
    7 main(int argc , char* argv[])
    8 {
    9 	int            *ip = (int *) ⁣
    10 	int             i;
    11 	if (argc > 2)
    12 		ip = &i;
    13 	f(ip);
    14 	return (*ip);
    15 }
    ============
    定数データを変更している可能性があります
        ic defined at f.c(1)	:: f.c(5)

メッセージ ID: E_ASGN_CONST_PSB

## メモリーが解放されていません。

割り当てられたメモリーが、プログラム中で明示的に解放されていません。 このメッセージを生成するコードの例を次に示します。

    1 #include <stdlib.h>
    2 main(void)
    3 {
    4 	int            *ip;
    5 	ip = malloc(sizeof(long));
    6 	*ip += 5;
    7 	return *ip;
    8 }
    ============
    メモリーが解放されていません
        f.c(5)

メッセージ ID: E_NEVER_DEALLOC

## メモリーが解放されていない可能性があります。

割り当てられたメモリーが、プログラム中で解放されていない可能性があります。 このメッセージを生成するコードの例を次に示します。

    1 #include <malloc.h>
    2 void
    3 v(int i)
    4 {
    5 	char           *cp;
    6 	cp = (char *) malloc(sizeof(int) * i);
    7 	*cp = 3;
    8 	if (i > 1)
    9 		free(cp);
    10 }
    11 main(int argc, char *argv[])
    12 {
    13 	v(argc);
    14 }
    ============

メッセージ ID: E_NEVER_DEALLOC_PSB

## 設定前に使用しています。

変数またはメモリーが、設定する前に使用されています。 このメッセージを生成するコードの例を次に示します。

    1 static int      i;
    2 void
    3 main(void)
    4 {
    5 	int             j;
    6 	j += i;
    7 }
    ============
    設定前に使用しています
        j defined at f.c(5)

メッセージ ID: E_USE_BEFORE_SET

## 設定前に使用している可能性があります。

変数が、設定する前に使用されている可能性があります。 このメッセージを生成するコードの例を次に示します。

    1 int
    2 main(int argc, char * argv[])
    3 {
    4 	int             i;
    5 	if (argc>2)
    6 		i = 99;
    7 	i++;
    8 	return i;
    9 }
    ============
    設定前に使用している可能性があります
        i defined at f.c(4)

メッセージ ID: E_USE_BEFORE_SET_PSB

## 使用している値の型が整合していません。

変数またはメモリーに割り当てられた型の値が、別の型の値として使用されています。 このメッセージを生成するコードの例を次に示します。

    1 main(void)
    2 {
    3 	int             i;
    4 	int            *ip = &i;
    5 	*((char *) ip) = '1';
    6 	return (*ip);
    7 }
    ============
    使用している値の型が整合していません
        used as int 	:: i defined at f.c(3)	f.c(6) :: f.c(5) set as char

メッセージ ID: E_VALUE_TYPE

## 使用している値の型が整合していない可能性があります。

変数またはメモリーに割り当てられた型の値が、別の型の値として使用される可能性があります。 このメッセージを生成するコードの例を次に示します。

    1 main(int argc, char * argv[])
    2 {
    3 	int             i;
    4 	int            *ip = &i;
    5 	*ip = 0;
    6 	if (argc > 2)
    7 		*((char *) ip) = '1';
    8 	return (*ip);
    9 }
    ============
    使用している値の型が整合していない可能性があります
        used as int 	:: i defined at f.c(3)	f.c(8) :: f.c(7) set as char

メッセージ ID: E_VALUE_TYPE_PSB

## 到達されない関数があります。

指定された関数が、プログラム中で呼び出されていないということが lint によって確認されました。

メッセージ ID: E_FUNC_UNREACHED

## 解放されたメモリーを変更しています。

解放したメモリーが変更されています。 このメッセージを生成するコードの例を次に示します。

    1 #include <malloc.h>
    2 static int *ip;
    3 static void f(void)  { *ip=1;}
    4 static void g(int i) { ip = malloc(i);}
    5 static void h(void)  { free(ip);}
    6 void
    7 main(void)
    8 {
    9 	ip = malloc(10);
    10 	free(ip);
    11 	*ip = 1;
    12 	g(10);
    13 	h();
    14 	f();
    15 }
    ============
    解放されたメモリーを変更しています
        f.c(3)	:: f.c(5)
        f.c(11)	:: f.c(10)

メッセージ ID: E_P_WRT_DEALLOC

## 解放されたメモリーを変更している可能性があります。

解放したメモリーが変更される可能性があります。 このメッセージを生成するコードの例を次に示します。

    1 #include <malloc.h>
    2 static int     *ip;
    3 int
    4 main(int argc, char *argv[])
    5 {
    6 	ip = malloc(8);
    7 	if (argc > 1)
    8 		free(ip);
    9 	*ip = argc;
    10 	return (*ip);
    11 }
    ============
    解放されたメモリーを変更している可能性があります
        f.c(9)	:: f.c(8)

メッセージ ID: E_P_WRT_DEALLOC_PSBL

## 存在しなくなった変数を変更しています。

すでに存在しない変数が変更されています。 自動記憶クラスのオブジェクトは、そのブロック外で保持されることは保証されないので、このオブジェクトへのポインタは、ブロックが終わると未定義になります。 このメッセージを生成するコードの例を次に示します。

    1 static int     *ip;
    2 static int      si;
    3 static int
    4 f(void)
    5 {
    6 	int             i;
    7 	ip = &i;
    8 	i = 0;
    9 	return (i);
    10 }
    11 main(void)
    12 {
    13 	int             j;
    14 	j = f();
    15 	*ip = 1;
    16 	j = j + f();
    17 	*ip = 1;
    18 	return (si + j);
    19 }
    ============
    存在しなくなった変数を変更しています
        i defined at f.c(6)	:: f.c(15)
        i defined at f.c(6)	:: f.c(17)

メッセージ ID: E_P_WRT_VAR

## 存在しなくなった可能性のある変数を変更しています。

自動記憶クラスのオブジェクトは、そのブロック外で保持されることは保証されないので、このオブジェクトへのポインタは、ブロックが終わると未定義になります。 このメッセージを生成するコードの例を次に示します。

    1 static int     *ip;
    2 static int      si;
    3 static int
    4 f(void)
    5 {
    6 	int             i;
    7 	ip = &i;
    8 	i = 0;
    9 	if (si)
    10 		ip = &si;
    11 	return (i);
    12 }
    13 main(void)
    14 {
    15 	int             j;
    16 	j = f();
    17 	*ip = 1;
    18 	j = j + f();
    19 	*ip = 1;
    20 	return (si + j);
    21 }
    ============
    存在しなくなった可能性のある変数を変更しています
        i defined at f.c(6)	:: f.c(17)
        i defined at f.c(6)	:: f.c(19)

メッセージ ID: E_P_WRT_VAR_PSBL

## NULL ポインタを使用して変更しています。

`NULL` ポインタを使用して変更が行われています。 このメッセージを生成するコードの例を次に示します。

    1 static int     *ip;
    2 static void
    3 v(void)
    4 {
    5 	*ip = 1;
    6 }
    7 void
    8 main(int argc, char *argv[])
    9 {
    10 	switch (argc) {
    11 	case 1:
    12 		ip = (int *) 0;
    13 		*ip = 1;
    14 		break;
    15 	case 2:
    16 		ip = (int *) 0;
    17 		v();
    18 		break;
    19 	default:
    20 		v();
    21 	}
    22 }
    ============
    NULL ポインタを使用して変更しています
        ip defined at f.c(1)	:: f.c(5)
        ip defined at f.c(1)	:: f.c(5)
        ip defined at f.c(1)	:: f.c(13)

メッセージ ID: E_P_WRT_NULL

## NULL である可能性のあるポインタを使用して変更しています。

`NULL` になる可能性があるポインタを使用して変更が行われています。 このメッセージを生成するコードの例を次に示します。

    1 #define VALUE	0
    2 static int     *ip;
    3 static int      si;
    4 int
    5 main(void)
    6 {
    7 	ip = (int *) VALUE;
    8 	if (si)
    9 		ip = &si;
    10 	*ip = VALUE + 1;
    11 	return (si);
    12 }
    ============
    NULL の可能性があるポインタを使用して変更しています
        ip defined at f.c(2)	:: f.c(10)

メッセージ ID: E_P_WRT_NULL_PSBL

## 値が初期化されていないポインタを使用して変更しています。

あるオブジェクトを指すように初期化する前に、ポインタで間接参照しています。 このメッセージを生成するコードの例を次に示します。

    1 f() {
    2       int *p;
    3
    4       *p = 5;
    5 }
    ==========
    "t2.c", line 4: 警告: modification using a pointer that is an uninitialized value
    	p defined at t2.c(2)	:: t2.c(4)

メッセージ ID: E_P_WRT_UNINI

## 値が初期化されていない可能性のあるポインタを使用して変更しています。

値が初期化されていない可能性があるポインタを使用して、変更が行われています。 このメッセージを生成するコードの例を次に示します。

    1 int
    2 main(int argc, char *argv[])
    3 {
    4 	int            *ip, i;
    5 	if (argc > 2)
    6 		ip = &i;
    7 	*ip = 1;
    8 	return i;
    9 }
    ============
    値が初期化されていない可能性のあるポインタを使用して変更しています
        ip defined at f.c(4)	:: f.c(7)

メッセージ ID: E_P_WRT_UNINI_PSBL

## 疑わしい方法で作成されたポインタを使用して変更しています。

不適切な方法で生成されたポインタを使用して、変更が行われています。 このメッセージを生成するコードの例を次に示します。

    1 static int     *ip;
    2 static void
    3 f(void)
    4 {
    5 	*ip = 1;
    6 }
    7 void
    8 main(void)
    9 {
    10 	ip = (int *) 4;
    11 	*ip = 1;
    12 	ip = (int *) 5;
    13 	f();
    14 	*ip = 1;
    15 }
    ============
    疑わしい方法で作成されたポインタを使用して変更しています
        f.c(5)
        f.c(11)
        f.c(14)

メッセージ ID: E_P_WRT_SUSP

## 疑わしい方法で作成された可能性のあるポインタを使用して変更しています。

不適切な方法で生成された可能性のあるポインタを使用して、変更が行われています。 このメッセージを生成するコードの例を次に示します。

    1 #define VALUE 4
    2 static int     *ip;
    3 static int      si;
    4 int
    5 main(void)
    6 {
    7 	ip = (int *) VALUE;
    8 	if (si)
    9 		ip = &si;
    10 	*ip = VALUE + 1;
    11 	return (si);
    12 }
    ============
    疑わしい方法で作成された可能性のあるポインタを使用して変更しています
        f.c(10)

メッセージ ID: E_P_WRT_SUSP_PSBL

## 変数またはメモリーの内容が使用されていません。

変数が定義されていますが、その変数の値または変数に割り当てられたメモリーが、使用されていません。 このメッセージを生成するコードの例を次に示します。

    1 int            *
    2 f(void)
    3 {
    4 	int             i;
    5 	return (&i + (sizeof(int)));
    6 }
    ============
    変数またはメモリーの内容が使用されていません
        i defined at f.c(4)

メッセージ ID: E_VRB_NEVER_USED

## 未使用のラベル

ラベルが定義されていますが、使用されていません。 このメッセージを生成するコードの例を次に示します。

    1 f()
    2 {
    3	int k =7;
    4	switch(k) {
    5	case 1:
    6	    	break;
    7	defult:               /* 検出されない構文エラー */
    8	    	return (10);
    9	}
    10 }
    ===============
    未使用のラベル
         (7) default (関数: f)

メッセージ ID: E_LABEL_NOT_USED

## 空のループ

実行可能な文が含まれていないループが、lint によって検出されました。 このメッセージを生成するコードの例を次に示します。

    1       int i;
    2       for (i = 0; i < 5; i++) ; /* empty for loop */
    3       while (i < 7) { }	  /* empty while loop */

メッセージ ID: E_LOOP_EMPTY

## 引数の型が変換されます。

実引数が、対応する引数の型に暗黙で変換されています (出力形式: simple)。このメッセージを生成するコードの例

    1 static void f(int x1)
    2 {
    3	printf("%d\n", x1);
    4 }
    5 void main ()
    6 {
    7	float x;
    8	x = 4.5;
    9	f(x);
    10 }
    ============
    (9) 警告: float は int に変換されます: 1 番目の引数(関数: f)

メッセージ ID: E_ARGUMENT_CONVERT

## 不正なファイル番号

ファイル番号が無効である (ファイルリスト中の空きスロットよりも大きい) ことが、コンパイラまたは lint によって検出されました。これは内部エラーです。

メッセージ ID: E_BAD_FILE_NUMBER

## ソース行にアクセスできません。

ソースファイルにアクセスできないため、`lint` は メッセージに対応するソース行を出力できません。たとえば、ソースファイルの名前変更、削除、移動が行われた可能性があります (出力形式: simple)。このメッセージを生成するコードの例

      |
      |******* source line is not accessible ...
      |              !  line 677, file.c
    warning: assigned value never used: ReturnVal

メッセージ ID: E_SRC_LINE_UNACCESSIBLE

## ファイルに #line 指令があるためにソース行を見つけられません。

ある `#line` 指令によって、`lint` がメッセージに表示されているソース行を出力できません (出力形式: simple)。このメッセージを生成するコードの例

    file f.c:
    1 #line 20 "nofile.c"
    2 int             i;
    3 void
    4 main(void)
    5 {
    6 	return 99;
    7 }
    ============
          |
          |******* ファイルに #line 指令があるためにソース行を見つけられません
          |!  24 行目, nofile.c
          |
    エラー: void 関数は値を返すことはできません

メッセージ ID: E_SRC_LINE_UNACCESSIBLE2

## 引数がプロト型と整合していません。

呼び出している関数の引数の型を、関数プロト型宣言での型に変換できまません。このメッセージを生成するコードの例

    struct s {int x; } q;
    int g(int, int);
    f() {
    	g(3, q);
    }

メッセージ ID: E_ARG_INCOMPATIBLE_WITH_ARG_L

## 影響を及ぼさない式または式の一部

意味のない式または添字式があります。 このメッセージを生成するコードの例を次に示します。

    int g() {
            1;
            return 0;
    }

メッセージ ID: E_EXPR_NULL_EFFECT

## (return 文に指定された) 戻り値の型は関数の戻り値型に変換されます。

宣言された型とは異なる型の戻り値が、この関数中の return 文に指定されています。コンパイラは、その戻り値を宣言された型に変換します。

    1 char f() {
    2        return 0xffffffffL;
    3 }

メッセージ ID: E_IMPL_CONV_RETURN

## n ビット整数からポインタにキャストしています。

ポインタよりもサイズが小さい整数型のオブジェクトが、ポインタの型に明示的にキャストされています。たとえば、32 ビット整数が、64 ビットポインタにキャストされています。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 v(void)
    3 {
    4	int             i;
    5	char           *ip;
    6	ip = (char *) i;
    7 }
    ============
    "t.c", 6 行目: 警告: 32 ビット整数からポインタにキャストしています

メッセージ ID: E_CAST_TO_PTR_FROM_INT

## n ビット整数から m ビット整数にキャストしています。

整数型のオブジェクトが、よりサイズが小さい整数型に明示的にキャストされています。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 v(void)
    3 {
    4	int             i;
    5	long            l;
    6	i = (int) l;
    7 }
    ============
    "t.c", 6 行目: 警告: 64 ビット整数から 32 ビット整数にキャストしています

メッセージ ID: E_CAST_INT_TO_SMALL_INT

## n ビット整数の定数式から m ビット整数にキャストしています。

整数定数式が、よりサイズが小さい整数型に明示的にキャストされています。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 v(void)
    3 {
    4	char            c;
    5	c = (char) 1024;
    6 }
    ============
    "t.c" 5 行目: 警告: 32 ビット整数の定数式から 8 ビット整数にキャストしています

メッセージ ID: E_CAST_INT_CONST_TO_SMALL_INT

## n ビット整数を m ビット整数に代入します。

整数型のオブジェクトが、よりサイズが小さい別の整数型オブジェクトに代入されています。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 v(void)
    3 {
    4	int             i;
    5	long            l;
    6	i = l;
    7 }
    ============
    "t.c", 6 行目: 警告: 64 ビット整数を 32 ビット整数に代入します

メッセージ ID: E_ASSIGN_INT_TO_SMALL_INT

## 代入によって n ビット定数が m ビットに切り捨てられました。

整数定数式が、整数型のオブジェクトに代入されているまたは返されていますが、値は切り捨てられます。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 v(void)
    3 {
    4	char            c;
    5	c = 1024;
    6 }
    ============
    "t.c" 5 行目: 警告: 代入によって 32 ビット定数が 8 ビットに切り捨てられました

メッセージ ID: E_ASSIGN_INT_FROM_BIG_CONST

## n ビット整数を渡していますが、予期しているのは m ビット整数です。

関数呼び出しの整数型の引数が、関数定義の仮引数の型よりもサイズが大きいです。 このエラーメッセージは、-errchk=longptr64 オプションを付けると表示されます。 このメッセージを生成するコードの例を次に示します。

     1 void
     2 print_int(int i)
     3 {
     4	printf("int %d\n", i);
     5 }
     6
     7 void
     8 v(void)
     9 {
    10	long l = 5;
    11	print_int(l);
    12 }
    ============
    "t.c", 11 行目: 警告: 64 ビット整数を渡していますが、予期しているのは 32 ビット整数です: print_int(引数 1)

メッセージ ID: E_PASS_INT_TO_SMALL_INT

## n ビット整数定数を渡していますが、予期しているのは m ビット整数です。

関数呼び出しの引数が整数定数式で、その整数定数式の型は、関数定義中の仮引数の型よりもサイズが大きいです。 このエラーメッセージは、-errchk=longptr64 オプションを付けると表示されます。 このメッセージを生成するコードの例を次に示します。

     1 void
     2 print_int(int i)
     3 {
     4	printf("int %d\n", i);
     5 }
     6
     7 void
     8 v(void)
     9 {
    10	print_int(11111111024L);
    11 }
    ============
    "t.c", 10 行目: 警告: 64 ビット整数定数を渡していますが、予期しているのは 32 ビット整数で: printi(1 番目の引数)

メッセージ ID: E_PASS_INT_FROM_BIG_CONST

## ロックパラメータを選択するために ?: 演算子が使用されています。

?:lock_lint は、エラーメッセージ中に示されたロックが関数呼び出しで使用されたとみなします。 このメッセージを生成するコードの例

    int waitWriter;
    f() {
      mutex_t mutex1, mutex2;

      mutex_lock((waitWriter == 0) ? &mutex1 : &mutex2);
    }

メッセージ ID: E_CONDITIONAL_OP_LOCKCHOICE

## 予期しない単項演算があります。

`#if` または `#elif` 指令の中に 予期しない単項演算があります。 このメッセージを生成するコードの例を次に示します。

    main()
    {
    #define x 0
    #define y 1

    #if x ! y == 0
            printf("Hello\n");
    #endif
    }

メッセージ ID: E_UNEXPECTED_UNARY

## オブジェクトまたは関数へのポインタが NULL ポインタと等値比較できません。

この警告は、`-p` オプションを付けると表示されます。コンパイラは、オブジェクトまたは関数へのポインタを、常に真として評価されるように最適化することがあります。 このメッセージを生成するコードの例を次に示します。

    extern int foo;
    #pragma weak foo
    int main()
    {
            if (&foo)
                    return foo;
    }

メッセージ ID: E_POINTER_TO_OBJECT

## ポインタよりサイズが小さい整数型の定数の初期設定子にアドレスは指定できません。

定数の初期設定子内のアドレスは、定数の算術式でなければなりません。拡張形として、ポインタのサイズより大きいまたは等しいサイズの整数型の定数初期設定子にアドレスを指定できます。ポインタよりサイズが小さい整数型の定数初期設定子にアドレスを指定することはできません。 このメッセージを生成するコードの例を次に示します。

    int x;
    char c = &x;

メッセージ ID: E_ADDRESS_IN_CONST_INITIALIZER

## n ビット整数を m ビット整数と比較しています。

整数型のオブジェクトを、他の (よりサイズの大きい) 整数型のオブジェクトと比較しています。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 v(void)
    3 {
    4	int             i;
    5	long            l;
    6	i = i > l;
    7 }
    ============
    "t.c", 6 行目: 警告: 32 ビット整数と 64 ビット整数を比較中

メッセージ ID: E_COMP_INT_WITH_LARGE_INT

## n ビット符号なし整数を n ビット符号付き整数に代入しています。

符号なし整数型のオブジェクトが、同じサイズの符号付き整数型のオブジェクトに代入されています。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 v(void)
    3 {
    4	int             i;
    5	unsigned int   ui;
    6	i = ui;
    7 }
    ============
    "t.c", 6 行目: 警告: 32 ビット符号なし整数の 32 ビット符号付き整数への代入

メッセージ ID: E_ASSIGN_UINT_TO_SIGNED_INT

## ビット符号なし整数を渡していますが、正しくは n ビット符号付き整数です。

関数呼び出しに符号なし整数型の引数が指定されていますが、関数定義の仮引数の型は同じサイズの符号付き整数型です。 このエラーメッセージは -errchk=longptr64 または -errchk=sizematch オプションの指定がある場合に出力されます。 このメッセージを生成するコードの例を次に示します。

     1 void
     2 print_int(int i)
     3 {
     4	printf("int %d\n", i);
     5 }
     6
     7 void
     8 v(void)
     9 {
    10	unsigned int   ui = 5;
    11	print_int(ui);
    12 }
    ============
    "t.c", 11 行目: 警告: 32 ビット符号なし整数を、32 ビット符号付き整数が期待される引数へ渡してます: print_int(引数 1)

メッセージ ID: E_PASS_UINT_TO_SIGNED_INT

## n ビット符号なし整数から n ビット符号付き整数にキャストしています。

i符号なし整数型のオブジェクトが、同じサイズの符号付き整数型に明示的にキャスト (型変換) されています。 このメッセージを生成するコードの例を次に示します。

    1 void
    2 v(void)
    3 {
    4	int             i;
    5	unsigned int   ui;
    6	i = (int) ui;
    7 }
    ============
    "t.c", 6 行目: 警告: 32 ビット符号なし整数から 32 ビット符号付き整数へのキャスト

メッセージ ID: E_CAST_UINT_TO_SIGNED_INT

## 形式が正しくない #pragma error_messages を無視します。

`#pragma error_messages` に正しくない構文が使用されています。 `error_messages` プラグマは次のように指定しなければなりません。

      #pragma error_messages ({on|off|default}, errtag1 [,errtag2, ... ,errtag-n])

このメッセージを生成するコードの例

    #pragma error_messages {off: E_BAD_PTR_INT_COMBINATION, }

メッセージ ID: E_IGNORE_MALFORMED_PRAGMA_EMSG

## #pragma weak symbol1 = symbol2 で symbol1 と symbol2 に同じシンボルは指定できません。

`#pragma weak symbol1 = symbol2` は `symbol1` を弱いシンボルとして定義し、これはシンボル `symbol2` の別名となります。両方に同じシンボルを指定することはできません。 このメッセージを生成するコードの例を次に示します。

         1	#pragma weak function_name = function_name
         2
         3	int
         4	_function_name(void) {
         5	       return 1;
         6	}
    ============
    "test.c" 1 行目: 「#pragma weak symbol1 = symbol2」の 2 つのシンボルは同一にはな れません: function_name
    cc: test.c に対して、acomp が失敗しました。

メッセージ ID: E_SYMBOL_IN_PRAGMA_WEAK

## キャストを含む初期設定子が定数ではありません。

外部 (`extern`)、静的 ( `static`)、または配列オブジェクトは、コンパイル時の定数でなければなりません。 自動構造体または共用体オブジェクトの初期設定子も、`{}` で囲まれている場合は、やはりコンパイル時の定数でなければなりません。整数定数式の中でキャスト演算子を使用できるのは、算術型を整数型に変換するときだけです。たとえば、ポインタ型を算術型に変換するキャストは定数式ではありません。また、初期化する変数の型がポインタより小さいとき、コンパイラはこのエラーメッセージを出力します。 このメッセージを生成するコードの例を次に示します。

    extern  int     myf();
    int (*  fptr)() = (int (*)())((int)myf + 1);

メッセージ ID: E_NON_CONST_INIT_SCONV

## __STDC_VERSION__ の定義を解除しています。

ISO C は、定義済みシンボル `__STDC_VERSION__` の定義を解除することを禁じています。プログラマは、ISO C と非 ISO C の両方の環境で動作するように作成した C コードをテストするためにこの機能を使用したい場合があります。 たとえば、 `__STDC_VERSION__` をチェックした後、もしこれが定義されていれば関数プロト型宣言を行い、定義されていなければ古いスタイルの関数宣言または定義を行うという C コードを作成したとします。C コンパイラは `__STDC_VERSION__` を事前に定義するので、通常の方法では、プログラマは古いスタイルのコードをテストすることができません。そこで、別の (ISO C ではない) コンパイラを通じてコードを実行する必要が生じます。`__STDC_VERSION__` の定義を (通常はコマンド行で) 解除すると、C コンパイラを使用してチェックを実行できるようになります。この診断は、プログラマが ISO C の制約に違反していることを通知します。 このメッセージを生成するコードの例を次に示します。

    #undef __STDC_VERSION__   /* 通常は -U__STDC_VERSION_ を*/
                                             /* cc コマンド行に指定する */

    #ifdef __STDC_VERSION__
    int
    myfunc(const char *arg1, int arg2)
    #else	/* non-ISO C case */
    int
    myfunc(arg1,arg2)
    char *arg1,	/* oops */
    int arg2;
    #endif
    {
    }

メッセージ ID: E_UNDEFINING__STDC_VERSION__

## #pragma ? 内の関数が宣言されていません。

通知されたプラグマ内に、使用前にプロト型宣言しなければならない関数名をコンパイラが検出しました。 このメッセージを生成するコードの例を次に示します。

    /* abc 関数がどこにも定義または宣言されていない */
    #pragma inline (abc)

============ The function abc should be prototyped prior to the pragma:

    int abc();
    #pragma inline (abc)

メッセージ ID: E_PRAGMA_FUNC_UNDECLARED

## #pragma ? では識別子が関数を指定していなければなりません。

通知されたプラグマで関数名が必要な場所に、関数名ではない識別子をコンパイラが検出しました。 このメッセージを生成するコードの例を次に示します。

    int abc;
    #pragma inline (abc)

メッセージ ID: E_PRAGMA_FUNC_REQUIRED

## 形式が正しくない #pragma を無視します。

通知された `#pragma` が正しくない構文で指定されています。正しい pragma の設定方法は次の通りです。

    #pragma <pragma_name> (funcname [, funcname ...])

このメッセージを生成するコードの例を次に示します。

    #pragma no_side_effect {a b}

メッセージ ID: E_MALFORMED_PRAGMA_W_FUNC

## 符号なし整数型からより大きな整数型またはポインタサイズへの拡張

異なる型のオペランド式の計算のため、コンパイラは符号なし整数型からより大きな整数型もしくはポインタサイズへの拡張を行います。 このメッセージを生成するコードの例を次に示します。

         1	main()
         2	{
         3		unsigned int i = 1;
         4		unsigned long long ll = 1;
         5		char *p = "hello";
         6		char c;
         7
         8		c = *(p + (-i));
         9		return (ll + (-i));
        10	}
    ============
    (8) 警告: 符号拡張が行われないため、符号なし整数型からより大きな整数型あるいはポインタサイズへの拡張は予期せぬ結果になるかもしれません。
    (9) 警告: 符号拡張が行われないため、符号なし整数型からより大きな整数型あるいはポインタサイズへの拡張は予期せぬ結果になるかもしれません。

メッセージ ID: E_UNEXPECTED_UINT_PROMOTION

## 配列要素の評価で符号なし整数型からポインタサイズへの拡張

配列要素の評価でコンパイラは符号なし整数からポインタサイズへの拡張を行います。 このメッセージを生成するコードの例を次に示します。

         1	void main()
         2	{
         3		unsigned int i = 1;
         4		char *p = "hello";
         5		char c;
         6
         7		c = p[-i];
         8	}
    ============
    (7) 警告: 符号拡張が行われないため、配列要素の評価で符号なし整数型からポインタサイズへの拡張は予期せぬ結果になるかもしれません。

メッセージ ID: E_UNEXPECTED_UINT_PROMOTION_SUB

## n ビット整数から n ビット整数への符号拡張

コンパイラが符号付き整数型からより大きな整数型への拡張を行う場合、符号が拡張されます。 このメッセージを生成するコードの例を次に示します。

         1	void main()
         2	{
         3		int i = -1;
         4		unsigned long ul;
         5
         6		ul = (unsigned long)i;
         7	}
    ============
    (6) 警告: 32 ビット整数から 64 ビット整数への符号拡張

メッセージ ID: E_SIGN_EXTENSION_PSBL

## `#pragma opt` レベルを -xmaxopt の値まで下げます

コンパイラが `#pragma opt` 指定を読み込み、その値がコマンドライン -xmaxopt で 指定された値を越えています。`#pragma opt` で指定された関数の最適化レベルは、コンパイラの -xmaxopt オプションで指定された値まで下げられます。 このメッセージを生成するコードの例を次に示します。

    int abc(); /* compiler invoked with -xO5 -xmaxopt=2 */
    #pragma opt 4 (abc)

メッセージ ID: E_PRAGMA_OPT_REDUCED

## おかしな `#pragma opt` の設定

`#pragma opt` の設定が構文上に間違っています。正しい pragma の設定方法は次の通りです。

    #pragma opt level (funcname [, funcname ...])

このメッセージを生成するコードの例を次に示します。

    #pragma opt 3 {a b}

メッセージ ID: E_IGNORE_MALFORMED_PRAGMA_OPT

## 不明確な宣言によって識別子が再宣言されました。

このメッセージは、不明確な宣言または定義を使用して識別子を再宣言すると出力されます。この場合、識別子の種類は出力できません。 このメッセージを生成するコードの例を次に示します。

         1	#include <stdio.h>
         2	void Function( struct IamNotDefined  *b);
         3	int     counter = 0;
         4	main()
         5	{
         6	}
         7
         8	void Function( struct IamNotDefined *b) ;

メッセージ ID: E_DUBIOUS_ID_REDECLARED

## 不明確な宣言によって識別子が再定義されました。

このメッセージは、不明確な定義を使用して識別子を再定義すると出力されます。この場合、識別子の種類は出力できません。 このメッセージを生成するコードの例を次に示します。

         1	#include <stdio.h>
         2	void Function( struct IamNotDefined  *b) { }
         3
         4  int     counter = 0;
         5	main()
         6	{
         7	}
         8
         9	void Function( )
        10	{
        11	}

メッセージ ID: E_DUBIOUS_ID_REDEFINED

## pragma redefine_extname の使用によって識別子が再定義されました。

コンパイラが、外部的に定義されたオブジェクトまたは関数の再定義を検出しました。本来の外部名は `#pragma redefine_extname` の使用によって変更され、コンパイラは新しい外部名の再定義を検出しました。 このメッセージを生成するコードの例を次に示します。

         1  #pragma redefine_extname fold fnew
         2
         3  fold ()
         4  {
         5  }
         6
         7  fnew ()
         8  {
         9  }
        10
        11  main ()
        12  {
        13  }

-#

メッセージ ID: E_FUNC_REDEFINED_THROUGH_PRAGMA

## 構造体が大きすぎます。

構造体宣言が作成されましたが、宣言されたオブジェクトが対象となるマシンにとって大きすぎます。 このメッセージを生成するコードの例を次に示します。

    typedef int Not_that_big_array[0x10000000];
    struct {
      Not_that_big_array m1,m2,m3,m4,m5,m6,m7,m8;
    }

メッセージ ID: E_STRUCT_SIZE_TOO_BIG

## #pragma タグに対応する struct/union がありません

キーワード struct もしくは union に続くタグが無いか、それらのタグが、この #pragma より前にあるはずの struct もしくは union 宣言を参照できません。このメッセージを生成するコードの例を次に示します。

    /* struct bar はまだ定義されていません */
    void foo() {
    #pragma alias_level strict (struct bar)
        return;
    }

メッセージ ID: E_ALIAS_NO_TAG

## struct `<name>` は #pragma での使用前に定義されている必要があります

通知された識別子はこの pragma での使用前に struct として定義されている必要があります。 このメッセージを生成するコードの例を次に示します。

    union bar { int field;};
    void foo() {
    #pragma alias_level strict (struct bar)
        return;

}

メッセージ ID: E_ALIAS_NOT_A_STRUCT

## union `<name>` は #pragma での使用前に定義されている必要があります

通知された識別子はこの pragma での使用前に union として定義されている必要があります。 このメッセージを生成するコードの例を次に示します。

    struct bar { int field;};
    void foo() {
    #pragma alias_level strict (union bar)
        return;
    }

メッセージ ID: E_ALIAS_NOT_A_UNION

## enum `<name>` は #pragma での使用前に定義されている必要があります

通知された識別子はこの pragma での使用前に enum として定義されている必要があります。 このメッセージを生成するコードの例を次に示します。

    /* enum bar はまだ定義されていません */
    void foo() {
    #pragma alias_level strict (enum bar)
        return;
    }

メッセージ ID: E_ALIAS_NOT_AN_ENUM

## `<name>` は #pragma での使用前にポインタとして定義されている必要があります

通知された識別子はこの pragma での使用前にポインタとして定義されている必要があります。 このメッセージを生成するコードの例を次に示します。

    int bar;
    void foo() {
    #pragma alias_level strict (bar)
        return;
    }

メッセージ ID: E_ALIAS_EXPECTING_POINTER

## `<type>` は構造体ではありません

このメッセージで通知された識別子は pragma で使われる前に構造体として宣言されていません。 このメッセージを生成するコードの例を次に示します。

    enum abc {one, two};
    #pragma alias_level strict (struct abc)

メッセージ ID: E_ALIAS_STRUCT_LIE

## `<type>` は共用体ではありません

このメッセージで通知された識別子は pragma で使われる前に共用体として宣言されていません。このメッセージを生成するコードの例を次に示します。

    enum abc {one, two};
    #pragma alias_level strict (union abc)

メッセージ ID: E_ALIAS_UNION_LIE

## `<type>` は列挙型ではありません

このメッセージで通知された識別子は pragma で使われる前に列挙型として宣言されていません。このメッセージを生成するコードの例を次に示します。

    struct abc {int field;};
    #pragma alias_level strict (enum abc)

メッセージ ID: E_ALIAS_ENUM_LIE

## #pragma には型を指定します

通知された pragma で型以外のものが渡されています。`#pragma alias` および `alias_level` は型を指定します。 このメッセージを生成するコードの例を次に示します。

    int i;
    #pragma alias_level strict (i)

メッセージ ID: E_ALIAS_EXPECTING_TYPE

## `<identifier>` #pragma での使用前に変数として宣言されている必要があります

通知された識別子は、pragma で参照される前に変数として宣言されている必要があります。 このメッセージを生成するコードの例を次に示します。

    int myfunc();
    #pragma alias (myfunc)

メッセージ ID: E_ALIAS_EXPECTING_VARIABLE

## 無効な形式の #pragma alias_level を無視します

alias_level pragma 次のような書式です:

    #pragma alias_level  (  [, ]... )
    #pragma alias_level  (  [, ]... )

このメッセージを生成するコードの例を次に示します。

    #pragma alias_level std (

メッセージ ID: E_IGNORE_BAD_ALIAS_LEVEL_PRAGMA

## 無効な形式の #pragma alias を無視します

alias pragma は次のような書式です:

    #pragma alias (  [, ]... )
    #pragma alias ( ,  [, ]... )

このメッセージを生成するコードの例を次に示します。

    #pragma alias (

メッセージ ID: E_IGNORE_BAD_ALIAS_PRAGMA

## 無効な形式の #pragma noalias を無視します

alias pragma は次のような書式です:

    #pragma noalias (  [, ]... )
    #pragma noalias ( ,  [, ]... )

このメッセージを生成するコードの例を次に示します。

    #pragma alias (

メッセージ ID: E_IGNORE_BAD_NOALIAS_PRAGMA

## 無効な形式の #pragma may_point_to を無視します

may_point_to pragma は次のような書式です:

    pragma may_point_to ( ,  [, ]... )

このメッセージを生成するコードの例を次に示します。

    #pragma may_point_to (

メッセージ ID: E_IGNORE_BAD_MAYPTTO_PRAGMA

## 無効な形式の #pragma may_not_point_to を無視します

may_not_point_to pragma は次のような書式です:

    pragma may_not_point_to ( ,  [, ]... )

このメッセージを生成するコードの例を次に示します。

    #pragma may_not_point_to (

メッセージ ID: E_IGNORE_BAD_MAYNOTPTTO_PRAGMA

## これらの pragma へはポインタを渡さなければなりません

may_not_point_to および may_point_to pragmas は次のような書式です:

    pragma may_not_point_to ( ,  [, ]... )
    pragma may_point_to ( ,  [, ]... )

このメッセージを生成するコードの例を次に示します。

    int i, j;
    #pragma may_point_to ( i, j);

メッセージ ID: E_POINTTO_NOT_A_POINTER

## 不適切なエスケープ: \c

文字列リテラルおよび文字定数では \ の後には特定の文字だけが続きます; `\' \" \? \\ \a \b \f \n \r \t \v \<8 進数> \x<16 進数>`。 ANSI C は \ を無視します。 このメッセージを生成するコードの例を次に示します。

     int i = '\c';

メッセージ ID: E_DUBIOUS_ESCAPE_MBCHAR

## #pragma %s はファイルスコープまたは関数スコープになければなりません

エイリアシングプラグマはファイルスコープまたは関数スコープのみで使用できます。 このメッセージを生成するコードの例を次に示します。

    struct s1 {...};
    struct s2 {...};
    main()
    {
      {
    #pragma alias (struct s1, struct s1)
      }
    }

メッセージ ID: E_IGNORE_BAD_SCOPE_FOR_PRAGMA

## パラメータの型が不完全です: %s

関数プロト型の不完全な配列型の代わりにパラメータとしてポインタを使用してください。 このメッセージを生成するコードの例を次に示します。

    main()
    {
        extern somefunc(void array[]);
    }

メッセージ ID: E_ARRAY_OF_INCOMPLETE

## パラメータの型が不完全です

関数プロト型の不完全な型の代わりにパラメータとしてポインタを使用してください。 このメッセージを生成するコードの例を次に示します。

    struct xxx;
    extern lastfunc(struct xxx xs[]);

メッセージ ID: E_ARRAY_OF_INCOMPLETE_NONAME

## 自動変数が大きすぎます

自動変数宣言は、宣言されたオブジェクトがターゲットマシンのスタックに合わないように構築されます。 このメッセージを生成するコードの例を次に示します。

    void foo(void) {
            int big_array[0x100000000LL];
    }

メッセージ ID: E_AUTO_VARIABLE_TOO_BIG

## スカラーポインタを構造体ポインタへキャスト

-xalias_level で許可される最適化のエイリアス解析中に スカラーポインタを構造体ポインタへキャストすると、 定義されていない動作を起こすかもしれません。 このメッセージを生成するコードの例を次に示します。

    struct foo {
      int a;
    };

    struct foo *foop;
    int *p;

    void
    main()
    {
      foop = (struct foo *)p;
    }

メッセージ ID: E_CAST_SCALAR_TO_STRUCT

## void ポインタを構造体ポインタへキャスト

-xalias_level で許可される最適化のエイリアス解析中に、 void ポインタを構造体ポインタへキャストすると、 定義されていない動作を起こすかもしれません。 このメッセージを生成するコードの例を次に示します。

    struct foo {
      int a;
    };

    struct foo *foop;
    void *p;

    void
    main()
    {
      foop = (struct foo *)p;
    }

メッセージ ID: E_CAST_VOID_PTR_TO_STRUCT

## 構造体フィールドをスカラーポインタへキャスト

-xalias_level で許可される最適化のエイリアス解析中に、 構造体フィールドを構造体ポインタへキャストすると、定義され ていない動作を起こすかもしれません。 このメッセージを生成するコードの例を次に示します。

    struct foo {
      int a;
    };

    struct foo *foop;
    int *p;

    void
    main()
    {
      p = (int *)&foop.a
    }

メッセージ ID: E_CAST_SCALAR_STRUCT_TO_SCALAR

## 構造体ポインタを構造体ポインタへキャストすると、alias_level=strict 下の明示的な別名を必要とします

-xalias_level=strict で許可される最適化のエイリアス解析中に、 ポインタを 2 つの別名解除された構造体にキャストすると、 定義されていない動作を起こすかもしれません。 このメッセージを生成するコードの例を次に示します。

    struct fooa {
      int a;
    };

    struct foob {
      int b;
    };

    struct fooa *fooaa;
    struct foob *foobb;

    void
    main()
    {
      fooaa = (struct fooa *)foobb;
    }

メッセージ ID: E_CAST_STRUCT_TO_STRUCT

## スカラーポインタからスカラーポインタへのキャストでは、-xalias_level=any 以外の明示的な別名指定が必要です

-xalias_level が weak およびそれ以上の場合に許可される 最適化のエイリアス解析中に、 スカラーポインタをスカラーへキャストすると、定義され ていない動作を起こすかもしれません。 このメッセージを生成するコードの例を次に示します。

    int *ip;
    long *lp;

    void
    main()
    {
      ip = (int *)lp;
    }

メッセージ ID: E_CAST_SCALAR_TO_SCALAR

## 非スカラーポインタからスカラーポインタへのキャストは -xalias_level=any のみで有効です

-xalias_level が weak およびそれ以上の場合に許可される 最適化のエイリアス解析中に、 非スカラーポインタをスカラーポインタへキャストすると、定義され ていない動作を起こすかもしれません。 このメッセージを生成するコードの例を次に示します。

    int *ip;
    long a[10];

    void
    main()
    {
      ip = (int *)a[3];
    }

メッセージ ID: E_CAST_NONSCALAR_TO_SCALAR

## threadprivate 指令はファイルスコープになければなりません。

threadprivate 指令はファイルスコープに、つまりすべての定義および 宣言の外になければなりません。 このメッセージを生成するコードの例を次に示します。

    int i;

    void
    main()
    {
      #pragma omp threadprivate(i)
    }

メッセージ ID: E_OMP_NONFILE_THREADPRIV

## threadprivate プラグマで指定された変数は extern または static でなければなりません

threadprivate 指令リスト中の各変数は、ファイルスコープ宣言をもつ必要があります。 このメッセージを生成するコードの例を次に示します。

    void
    main()
    {
      int i;
      #pragma omp threadprivate(i)
    }

メッセージ ID: E_OMP_AUTO_THREADPRIV

## threadprivate 指令は変数へのすべての参照の前になければなりません。

threadprivate 指令は、そのリスト内の変数へのすべての参照よりも (構文的に) 前に存在する必要があります。 このメッセージを生成するコードの例を次に示します。

    int i;

    void foo() {
      i = 10;
    }

    #pragma omp threadprivate(i)

メッセージ ID: E_OMP_THREADPRIV_REF

## threadprivate、firstprivate、lastprivate および 非公開変数は、 不完全な型をもっていてはいけません

threadprivate、firstprivate、lastprivate および非公開変数は、 不完全な型をもっていてはいけません。 このメッセージを生成するコードの例を次に示します。

    struct S s;

    #pragma omp threadprivate(s)

    struct S {
      int i;
    }
    void foo() {
      #pragma omp parallel private(s)
      {
      }
    }

メッセージ ID: E_OMP_VAR_INCOMPLETE

## threadprivate 変数はこの節では使用できません。

threadprivate 変数は、非公開、firstprivate、lastprivate、および 共有または縮約された節では使用できません。しかしデフォルトの節の影響は 受けません。 このメッセージを生成するコードの例を次に示します。

    int i;
    #pragma omp threadprivate(i)

    void
    main()
    {
      #pragma omp parallel private(i)
          i++;
    }

メッセージ ID: E_OMP_THREADPRIV_WRONG_CLAUSE

## 変数は複数の節に指定してはいけません。

変数を 2 つ以上の節に指定することはできません。ただし、firstprivate 節と lastprivate 節の両方に指定することはできます。 このメッセージを生成するコードの例を次に示します。

    void
    main()
    {
      int i;
      #pragma omp parallel private(i) copyin(i)
          i++;
    }

メッセージ ID: E_OMP_DUP_CLAUSE

## 非公開変数は定数指定の型をもっていてはいけません

非公開 (または lastprivate) 節中で指定された変数は、定数指定の型を もっていてはいけません。 このメッセージを生成するコードの例を次に示します。

    void
    main()
    {
      const int ci;
      #pragma omp parallel private(ci)
          ;
    }

メッセージ ID: E_OMP_CONST_PRIVATE

## 変数はすでに openmp pragma を含む非公開変数として指定されています

並列領域内で非公開 (firstprivate/lastprivate) である変数は、囲まれたワークシェアリング指令または並列指令での private (firstprivate/lastprivate) 節に指定することはできません。このため、ワークシェアリング指令または並列指令で非公開として指定されている変数は、囲まれた並列領域内で共有する必要があります。 このメッセージを生成するコードの例を次に示します。

    void
    main()
    {
      int i,j;
      #pragma omp parallel private(j)
      {
        #pragma omp for lastprivate(j)
        for (i=0; i<10; i++)
          j++;
      }
    }

=======

メッセージ ID: E_OMP_PRIVATE_PRIVATE

## 構文エラー: 初期設定子が指定されていません

初期設定子は、括弧の間に何も入っていません。 このメッセージを生成するコードの例を次に示します。

    struct {int i;} = {};

メッセージ ID: E_EMPTY_INITIALIZER

## ptrdiff_t オーバーフローの可能性

このメッセージは、2 つのポインタの差が ptrdiff_t によりオーバーフローする 可能性がある場合に表示されます。 次の例で、char ポインタの差に対して、上記のメッセージが生成されます。int ポインタの差に対しては生成されないことに注意してください。

    #include
    void foo(void){
        char *pc1, *pc2;
        int * pi1, *pi2;
        ptrdiff_t ptrdiff;
        ptrdiff = pc1 - pc2;
        ptrdiff += pi1 - pi2;
    }

メッセージ ID: E_PTRDIFF_OVERFLOW

## OpenMP プラグマの形式が正しくありません

このメッセージは、OpenMP プラグマで一般構文エラーが検出されると表示されます。 このメッセージを生成するコードの例を次に示します。

    void main() {

      #pragma omp parallel private
      {
      }
    }

メッセージ ID: E_OMP_SYNTAX_ERROR

## inline キーワードは関数 \"main\" に適用できません

このメッセージを生成するコードの例を次に示します。

    void
    inline main()
    {
      int i;

      i = 1;
    }

メッセージ ID: E_INLINE_MAIN

## extern インライン関数 \"%s\" は翻訳単位では定義されていません

このメッセージを生成するコードの例を次に示します。

    inline void foo();
    extern foo();

    void
    main()
    {
        foo();
    }
    =======

メッセージ ID: E_EXTERN_INLINE_UNDEFINED

## 構文エラー: 空のメンバー宣言

コードに空の struct メンバー宣言が含まれています。 このメッセージを生成するコードの例を次に示します。

    struct {
      int i;;
    } s;

メッセージ ID: E_EMPTY_MBR_DECLARATION

## schedule 節の繰り返し数の式が不正です

このメッセージは、OpenMP for プラグマの schedule 節に指定された 繰り返し数の式の書式が正しくない場合に表示されます。 このメッセージを生成するコードの例を次に示します。

    void main() {
      int i;
      #pragma omp parallel for schedule(static,1.0)
      for (i=0;i<10;i++) {
      }
    }

メッセージ ID: E_OMP_BAD_CHUNKSIZE

## 繰り返し数は実行時スケジュールでは許可されていません

繰り返し数の値は意味を持たず、OpenMP for プラグマの実行時スケジュールでは 許可されていません。 このメッセージを生成するコードの例を次に示します。

    void main() {
      int i;
    #pragma omp parallel for schedule(runtime,1)
      for (i=0;i<10;i++) {
      }
    }

メッセージ ID: E_OMP_RUNTIME_CHUNKSIZE

## schedule 節に対する無効な種別

schedule 節の種別は、static、dynamic、guided、runtime のうちのいずれかでなければなりません。 このメッセージを生成するコードの例を次に示します。

    void main() {
      int i;
    #pragma omp parallel for schedule(normal,1)
      for (i=0;i<10;i++) {
      }
    }

メッセージ ID: E_OMP_BAD_SCHEDULE_KIND

## インライン extern 関数の非定数静的変数の定義

このメッセージを生成するコードの例を次に示します。

    void foo() {
        static int j = 1;

        i += j;
    }

メッセージ ID: E_DEF_STATIC_INLINE_EXTERN

## ラベルの後には (空の可能性のある) 文がなければなりません

ANSI C 標準では、ラベルの後には文がなければなりません。 GNU C 拡張では、このような構文を許可しますが、それでもこの警告が 表示されます。また、`-Xs` オプションを使用すると、エラーになります。 このメッセージを生成するコードの例を次に示します。

    void
    main()
    {
    some_label:
    }

メッセージ ID: E_LABEL_NO_STMT

## 識別子とオブジェクトのようなマクロの置換リストの間に空白が必要です

識別子とオブジェクトのようなマクロ定義の置換リストの間に空白が必要です。このメッセージを生成するコードの例を次に示します。

    #define THIS$AND$THAT(a, b)  ((a) + (b))
    int c = THIS$AND$THAT(1, 7);

メッセージ ID: E_NO_WHITE_SPACE

## if 節の式がスカラー型をもっていません

OpenMP parallel の if 節に指定された式は、スカラー型をもっている必要があります。 このメッセージを生成するコードの例を次に示します。

    void main() {
      struct { int val; } true = {1};

      #pragma omp parallel if(true)
    	printf("Hello,worlds!\n");
    }

メッセージ ID: E_OMP_BAD_IF_TYPE

## omp の for ループの初期値式は標準の形式をもっていません。

OpenMP の for ループの初期値式は以下のような標準の形式をもっていなければなりません。 = または = このメッセージを生成するコードの例を次に示します。

    void main() {
      int i=0;
      #pragma omp parallel for
      for (; i<10; i++) {
      }
    }

メッセージ ID: E_OMP_FOR_BAD_INIT

## omp for ループのインデックスの値は正の整数でなければなりません。

OpenMP for ループのインデックス変数の値は符号付き整数型である必要があります。このメッセージを生成するコードの例を次に示します。

    void main() {
      unsigned char c;
      #:pragma omp parallel for
      for (c=0; c<10; c++) {
      }
    }

メッセージ ID: E_OMP_FOR_BAD_INDEX_TYPE

## omp の for ループの制御式は標準の形式をもっていません。

OpenMP の for ループの制御式は、以下の標準の形式でなくてはなりません: このメッセージを生成するコードの例を次に示します。 このメッセージを生成するコードの例を次に示します。

    void main() {
      int i,j=0;
      #pragma omp parallel for
      for (i=0; j<10; i++) {
      }
    }

メッセージ ID: E_OMP_FOR_BAD_CONTROL

## omp の for ループの反復式は標準の形式をもっていません。

OpneMP の for ループの反復式は標準の形式をもっている必要があります。 このメッセージを生成するコードの例を次に示します。

    void main() {
      int i;
      #pragma omp parallel for
      for (i=0; i<10; foo(&i)) {
      }
    }

メッセージ ID: E_OMP_FOR_BAD_ITER

## copyin 変数は threadprivate ではありません。

copyin 節に指定する変数は、threadprivate 変数でなければなりません。 このメッセージを生成するコードの例を次に示します。

    void main() {
      int i;
      #pragma omp parallel copyin(i)
    	i++;
    }

メッセージ ID: E_OMP_COPYIN_NOT_THREADPRIVATE

## inline、restrict、_Bool、_Complex、および _Imaginary は ISO C99 のキーワードです

C99 では、次の新しいキーワードが使用されます。 inline、 restrict、 _Bool、 _Complex、および _Imaginary。このメッセージを生成するコードの例を次に示します。

    int _Bool;

メッセージ ID: E_KEYWORD_IN_C99

## サイズ指定なしの可変長配列はプロト型のパラメータとしてのみ有効です

可変長配列はサイズ指定なしで ([*] として) 宣言できます。 このような宣言は、関数プロト型スコープ付きの宣言でのみ使用できます。 このメッセージを生成するコードの例を次に示します。

    int foo (int a[*]) {
       typedef int A[*];
    }

メッセージ ID: E_UNSPEC_VLA_SIZE

## ファイルスコープで可変的に修正された型は宣言できません

可変的に修正された型はファイルスコープで宣言できません。 このメッセージを生成するコードの例を次に示します。

    int n;
    typedef int A[n];
    int a[n];

メッセージ ID: E_CANT_DECL_FILESCOPE_VM

## 可変長配列は静的記憶領域クラスで宣言できません

識別子を、静的記憶期間をもつオブジェクトとして宣言すると、可変長配列型をもつことはできません。 このメッセージを生成するコードの例を次に示します。

    int foo(int n) {
       static int a[n];
    }

メッセージ ID: E_STATIC_VLA

## メンバーは可変的に修正された型をもつことができません

通常の識別子だけが可変的に修正された型をもつことができます。構造体メンバーおよび共用体メンバーは、そのような型をもつことができません。 このメッセージを生成するコードの例を次に示します。

    void foo() {
        int n;
        struct s { int a[n];};
    }

メッセージ ID: E_MEMBER_CANT_BE_VM

## 可変長配列は初期化できません

可変長配列は初期化できません。 このメッセージを生成するコードの例を次に示します。

    void foo() {
        int n;
        int x[n] = { 1 };
    }

メッセージ ID: E_CANT_INIT_VLA

## 配列サイズ式は整数型ではありません

配列サイズを指定する式は、整数型をもっていなくてはなりません。 このメッセージを生成するコードの例を次に示します。

    void foo() {
       int a[1.1];
       float f;
       int b[f];
    }

メッセージ ID: E_ARRAY_SIZE_NONINTEGER

## 配列サイズ式の記憶クラスキーワードに誤りがあります

配列サイズ式に指定できるのは、静的キーワードだけです。 このメッセージを生成するコードの例を次に示します。

    int a[extern 3];

メッセージ ID: E_BAD_ARRSIZE_STORAGE_CLASS

## 型指定子は配列サイズ式修飾子として使用できません

配列サイズ式に指定できるのは、静的キーワードと型修飾子 (const、restrict、および volatile) のみです。 このメッセージを生成するコードの例を次に示します。

    int a[int 3];

メッセージ ID: E_ARRSIZE_TYPE_SPECIFIER

## 関数パラメータの最も外側の配列型の派生のみ修飾できます

オプションの型修飾子および静的キーワードは、配列型を持つ関数パラメータの 宣言、および最も外側の配列型の派生でのみ使用できます。 このメッセージを生成するコードの例を次に示します。

    int a[static 3];
    int bar(int[*][restrict]);

メッセージ ID: E_CANT_QUAL_NONPARAM_ARY

## サイズ指定なしの可変長配列はプロト型のパラメータとしてのみ有効です

可変長配列はサイズ指定なしで ([*] として) 宣言できます。 このような宣言は、関数プロト型スコープ付きの宣言でのみ使用できます。 このメッセージを生成するコードの例を次に示します。

    int foo () {
       int i = sizeof(int[*]);
    }

メッセージ ID: E_UNSPEC_VLA_SIZE_NONAME

## プラグマの openmp の後に for ループがありません

OpenMP for 構文および OpenMP parallel 構文の後には、ループ文が必要です。 このメッセージを生成するコードの例を次に示します。

    int foo() {
      #pragma omp parallel for
      while(1) {
      }
    }

メッセージ ID: E_OMP_FOR_WITHOUT_FOR

## 演算に使用される void 関数、あるいは関数へのポインタ

式中で使用される、void への型ポインタ、または関数へのポインタの引数があります。void または関数のサイズは、1 と想定されます。 このメッセージを生成するコードの例を次に示します。

    void *mem = (void*)7, *retval;
    int sz = 4;
    retval = mem + sz;

メッセージ ID: E_PTR_TO_VOID_IN_ARITHMETIC

## #warning 指令中に無効なトークンがあります

`#warning` 指令中のトークンは、有効な C トークンでなければ なりません。 ソースプログラムに無効なトークンが含まれています。 このメッセージを生成するコードの例を次に示します。

    #warning 038 - this is an invalid token

メッセージ ID: E_BAD_TOKEN_IN_WARN_DIRECTIVE

## #warning

`#warning` 指令がソースファイル中で見つかりました。指令中のほかのトークンが、メッセージの一部として 出力されます。 このメッセージを生成するコードの例を次に示します。

    #define ONE 2
    #if ONE != 1
    #warning ONE != 1
    #endif

メッセージ ID: E_WARNING_PRAGMA

## 可変的に修正された型で識別子のスコープに入る goto は使用できません

goto 文は、可変的に修正された型をもつ識別子のスコープ外から、その識別子の スコープ内にジャンプできません。 このメッセージを生成するコードの例を次に示します。

    void foo() {
       int n = 10;
       {
    	int a[n];
    	vla_scope:
    	a[n-1] = 0;
       }
       goto vla_scope;
    }

メッセージ ID: E_GOTO_INTO_VLA_SCOPE

## openmp 指令はラベルをつけられません

OpenMP 指令フラッシュおよび barrier は文ではないので、ラベルをつけることはできません。 このメッセージを生成するコードの例を次に示します。

    void foo() {
      int i;
    wrong_label:
      #pragma omp barrier
      i++;
    }

メッセージ ID: E_OMP_LABELED_DIRECTIVE

## 縮約変数が共有されていません。

縮約節に指定される変数は、囲んでいるコンテキスト内で共有される必要があります。 このメッセージを生成するコードの例を次に示します。

    void main() {
      int i;
      #pragma omp parallel private(i)
    	#pragma omp sections reduction(+:i)
    	{
    	   i++;
    	}
    }

メッセージ ID: E_OMP_REDUCTION_NOTSHARED

## 縮約変数は定数指定の型をもっていてはいけません。

縮約節に指定される変数は定数指定の型をもつことはできません。 このメッセージを生成するコードの例を次に示します。

    void
    main()
    {
      const int ci;
      #pragma omp parallel reduction(+:ci)
          ;
    }

メッセージ ID: E_OMP_CONST_REDUCTION

## 縮約変数の型が無効です。

縮約節に指定される変数の型は、ポインタの型が使えない場合を除き、縮約演算子に対して有効でなければなりません。 このメッセージを生成するコードの例を次に示します。

    void
    main()
    {
      float f;
      #pragma omp parallel reduction(^:f)
          ;
    }

メッセージ ID: E_OMP_REDUCTION_BADTYPE

## 関数 \"%s\" はインライン化されません。すでに extern として定義されています。

このメッセージを生成するコードの例を次に示します。

    extern int foo(int i)
    {
      i++;

      return i;
    }

    inline int foo(int i);

メッセージ ID: E_INLINE_DEFINED_EXTERN

## 関数 \"%s\" は外部関数にすることはできません。すでにインライン関数として定義されています。

このメッセージを生成するコードの例を次に示します。

    inline int foo()
    {
      return 5;
    }

    extern foo(void);

メッセージ ID: E_INLINE_DEFINED_INLINE

## STDC プラグマの形式が正しくありません

このメッセージは、OpenMP プラグマで一般構文エラーが検出されると表示されます。 このメッセージを生成するコードの例を次に示します。

    #pragma STDC L_FENV_ACCESS ON
    /* "on" ではなく、"ON" が使用されている */

メッセージ ID: E_STDC_SYNTAX_ERROR

## 非ポインタ型を restrict で修飾することはできません

restrict 修飾子は、ポインタ型にのみ有効です。ポインタ型以外の 型は、restrict で修飾することはできません。 このメッセージを生成するコードの例を次に示します。

    restrict int a;

メッセージ ID: E_NON_PTR_CANT_RESTRICT_QUAL_2

## 順序づけられた指令が順序づけられていない指令の構文範囲内で使用されています。

順序づけられた OpenMP 指令は、順序づけられた節が指定されていない for 指令の動的範囲内にあってはなりません。 このメッセージを生成するコードの例を次に示します。

    void
    main()
    {
      int i, a = 0;
      #pragma omp for
      for (i=0; i<10; i++) {
          #pragma omp ordered
    	a+=i;
      }
    }

メッセージ ID: E_OMP_NONORDERED_FOR

## 順序づけられた指令が指令用の字句範囲外にあります

順序づけられた OpenMP 指令は、順序づけられた節をもつ for 構文、または parallel-for 構文の動的範囲内になくてはなりません。 このメッセージを生成するコードの例を次に示します。

    void
    main()
    {
      int i, a = 0;
      for (i=0; i<10; i++) {
          #pragma omp ordered
    	a+=i;
      }
    }

メッセージ ID: E_OMP_ORDERED_NOFOR

## セクション指令はセクション指令の範囲内でのみ使用されるべきです

OpenMP 指令セクションは、セクション指令の字句範囲内になくてはなりません。このメッセージを生成するコードの例を次に示します。

    void
    main()
    {
      int i;
      #pragma omp parallel
      {
          #pragma omp section
    	i++;
      }
    }

メッセージ ID: E_OMP_SECTION_NO_SECTIONS

## デフォルトの節の値が不正です。

デフォルトの節に使用できる値は none または shared のみです。 このメッセージを生成するコードの例を次に示します。

    void
    main()
    {
      int i;
      #pragma omp parallel default(private)
      {
    	i++;
      }
    }

メッセージ ID: E_OMP_BAD_DEFAULT

## #pragma alias_level はファイルスコープでのみ有効です。

Pragma alias_level は、pragma を介して設定された別名レベルが翻訳単位の残りすべてに適用されるので、ファイルスコープでのみ意味を持ちます。 このメッセージを生成するコードの例を次に示します。

    struct s1 {...};
    struct s2 {...};
    foo()
    {
    #pragma alias_level strict (struct s1, struct s2)
    }

メッセージ ID: E_FILE_SCOPE_ALIAS_LEVEL_PRAGMA

## マクロ定義 _Pragma は _Pragma 演算子を無効にします。

前処理演算子 _Pragma はマクロ定義を使用して定義し直すことができます。 ただし、このようにして再定義すると、_Pragma 演算子が完全に無効になります。 このメッセージを生成するコードの例を次に示します。

    #define _Pragma printf("Pragma\n")

メッセージ ID: E_PP_PRAGMA_REDEFINED

## _Pragma 演算子での引数が一致しません。

前処理演算子 _Pragma は引数を 1 つとり、この引数は単一の文字列リテラル である必要があります。 このメッセージを生成するコードの例を次に示します。

    _Pragma("omp", "parallel")
    _Pragma("omp" "parallel")

メッセージ ID: E_PP_PRAGMA_ARG_MISMATCH

## プラグマ critical は同名の critical 内では入れ子にすることができません

同じ名前の critical 指令を互いに入れ子にすることはできません。 このメッセージを生成するコードの例を次に示します。

    void main(void) {
        #pragma omp critical(foo)
            #pragma omp critical(foo)
            ;
    }

メッセージ ID: E_OMP_BAD_CRITICAL_NESTING

## 宣言は文に続くことができません。

宣言の前に文を置くことはできません。 このメッセージを生成するコードの例を次に示します。

    void main(void) {
        int i = 1;
        i++;
        int j = i;
    }

メッセージ ID: E_DECLARATION_IN_CODE

## 宣言文は for ループの初期化中では使用できません。

for 文の初期化部は、式の文でなければなりません。 このメッセージを生成するコードの例を次に示します。

    void main(void) {
        for (int i = 1; i<10; i++);
    }

メッセージ ID: E_DECLARATION_IN_FOR

## for ループ宣言の記憶クラスが間違っています。

for 文の宣言部では、記憶クラス auto または register の変数しか宣言できません。 このメッセージを生成するコードの例を次に示します。

    void main(void) {
        for (static int i = 1; i<10;)
    	i++;
    }

メッセージ ID: E_BAD_STORAGE_IN_FOR_DECL

## 静的配列修飾子のあとに配列サイズがありません。

配列宣言子キーワード内の修飾子として static を使用する場合は、そのあとに 配列サイズの式を指定する必要があります。この式は省略できません。 このメッセージを生成するコードの例を次に示します。

    void foo (int a[static]);

メッセージ ID: E_INVALID_STATIC_VLA_QUAL

## インクルードファイルにアクセスできません

#include 指令で指定されたファイルの読み取りアクセス権がありません。 このメッセージを生成するコードの例を次に示します。

    #include "noperm.h"

メッセージ ID: E_CANT_ACCESS_INCLUDE_FILE

## 開いているファイルが多すぎます。

#include 指令で指定されたファイルは、すでに開かれているファイル数が多すぎて 開くことができません。 このメッセージを生成するコードの例を次に示します。

    #include __FILE__

メッセージ ID: E_TOO_MANY_FILES

## ライセンスエラー:エラーの説明"

ライセンスを取得しようとしているときに、またはライセンスに関する情報を 取得しようとしているときに問題が発生しました。

メッセージ ID: E_LICENSE_ERROR

## 明示的な型が与えられていません。

変数の宣言に明示的な型指定子が含まれていないため、暗黙の int が 指定されているものとみなされます。 このメッセージを生成するコードの例を次に示します。

    static a;

メッセージ ID: E_NO_EXPLICIT_TYPE_GIVEN

## パラメータに明示的な型が与えられていません

パラメータの宣言に明示的な型指定子が含まれていないため、暗黙の int が指定されているものとみなされます。 このメッセージを生成するコードの例を次に示します。

    void
    fux(a)
    {
    	/* body */
    }

メッセージ ID: E_NO_TYPE_FOR_OLDSTYLE_PARAM

## 暗黙的な関数宣言

暗黙的の関数宣言は許されなくなりました。 このメッセージを生成するコードの例を次に示します。

    /* No #include  here */
    void main(void)
    {
    	printf("Hello world!\n");
    }

メッセージ ID: E_NO_IMPLICIT_DECL_ALLOWED

## 構造体/共用体でない型に対して指定された初期化子フィールド参照。

構造体/共用体でない初期化子のコンテキストで構造体/共用体フィールド名が 使用されていました。 このメッセージを生成する初期化子の例を次に示します。

    int a[10] = {.field=1}

メッセージ ID: E_DESIG_INIT_FIELD

## 配列への指定された初期化子インデックスは定数ではありません。

配列初期化子の指定されたインデックスが、定数値ではありません。 このメッセージを生成する初期化子の例を次に示します。

    int i;
    int a[10] = {[i]=1}

メッセージ ID: E_DESIG_INIT_INDEX_CONST

## 配列指定初期化子が配列でない型に対して使用されています。

配列初期化子の指定インデックスを使用して、配列でない型の変数を初期化しました。 このメッセージを生成する初期化子の例を次に示します。

    int a = {[5]=1}

メッセージ ID: E_DESIG_INIT_NON_ARRAY

## 識別子が再宣言されました。

識別子が宣言されましたが、同じ識別子について以前に行われた宣言と矛盾 しているか、同じスコープで 2 回宣言されています。 K&R C の以前のリリースでは、2 つの型が同じに「近い」ときは (たとえば、SPARC における `int` と `long` など)、 矛盾する再宣言が許されていました。 しかし、ANSI C ではこのような型は 異なるものと見なされます。

    int x;
    static long x;

メッセージ ID: E_IDENTIFIER_REDECLARED_STATIC

## void オブジェクトのアドレスを取得できません。

オペランドに & が適用される場合、そのオペランドの型は void 以外のものである必要があります。 このメッセージを生成するコードの例を次に示します。

    void *p;
    *p = &*p;

メッセージ ID: E_TAKING_ADDRESS_OF_VOID

## パラメータの型が不完全です。

関数パラメータを `struct`、 `union`、または `enum` で宣言しましたが、型が不完全です。 このメッセージを生成するコードの例を次に示します。

    typedef struct foo
    {
        void (*function)(struct foo bar);
    } foobar;

メッセージ ID: E_INCOMPLETE_PARAMETER

## __thread 変数指定子は無視されました。

__thread キーワードは extern または static 変数に適用できます。 しかし、自動変数に適用しても効果はありません。 このメッセージを生成するコードの例を次に示します。

    int foo() {
        __thread int i;
    }

メッセージ ID: E_BAD_STORAGE_THREAD_IGNORED

## 不可分構造の不正な式

式の文には、次の形式のうちのいずれかが存在する必要があります。 x binop= expr, x++, x--, ++x, --x. ここで、x はスカラー型の lvlalue 式です。 binop は、次のいずれかです。 +, *, -, /, &, ^, |, << or >>. expr はスカラー型の式であり、x で指示されたオブジェクトを参照しません。このメッセージを生成するコードの例を次に示します。

    void
    main()
    {
      int i;
      #pragma omp atomic
      	i = i+1;
    }

メッセージ ID: E_OMP_BAD_ATOMIC_EXPR

## 定数が 1999 ISO C 標準に準拠して拡張されています。

1999 ISO C 標準は、整定数の型宣言の規則を変更します。 コンパイラは、ANSI 標準の規則で別の型が設定されている整定数に 対してこのメッセージを生成します。 このメッセージを生成するコードの例を次に示します。

    long long a = 2147483648;

メッセージ ID: E_C99_INTEGER_PROMOTION

## 余分な #pragma パラメータを無視します。

コンパイラは、パラメータが多すぎる `#pragma` を検出しました。 余分のパラメータは無視されます。 このメッセージを生成するコードの例を次に示します。

    #pragma MP taskloop maxcpus (2) savelast

メッセージ ID: E_IGNORE_EXTRA_PRAGMA_PARAMS

## 浮動小数点型の配列を含む小さな構造体が渡されているか返されています。

{float|double|long double} の配列を含む小さな構造が、v9 の関数から パラメータとして渡されるかまたは値として戻されるものとして検出されました。小さな構造は、関数からの 16 バイトの引数から 32 バイトの戻り値までを含んでいます。

    typedef struct {
            double tf[4];
    } t_st;

    t_st myfunc(t_st arg) {
            t_st rv;

    	        return rv;
    }

メッセージ ID: E_FLTARRSMLSTRUCT

## このコンテキストでは "." の左側のオペランドは左辺値でなければなりません。プログラムの動作は定義されていません

演算子の左にあるオペランドが、左辺値を生成できない式になっています。通常、 構造体を返す関数の戻り値を変更しようとすると、このメッセージが出力されます。 このメッセージを生成するコードの例を次に示します。

    struct s { int ia[10];};
    struct s sf(void);
    f(void){
            sf().ia[0] = 3;
    }

メッセージ ID: E_L_OPERAND_DOT_NOT_LVALUE_NOW

## pragma omp の後には文がなければなりません。

omp プラグマ構文に続く文が必要とされています。 このエラーの原因となるコードの例を次に示します。

    {
    #pragma omp master
    }

メッセージ ID: E_OMP_NO_STATEMENT

## 共有ループ制御変数は非公開にされました。

parallel for 内のループ制御で使用される変数は、暗黙的に非公開と宣言されます。このため、shared() 節はこのような変数には何の効果もありません。 このメッセージを生成するコードの例を次に示します。

    void
    main()
    {
      int i,j;
      #pragma omp parallel for shared(i,j)
      for (i=0; i<10; i++) j = i;

      printf("i=%d\tj=%d\n",i,j);
    }

メッセージ ID: E_OMP_SHARED_CONTROL_VAR

## 16 進浮動小数点定数の変換は、評価書式で正確に表現できません。

このメッセージを生成するコードの例を次に示します。

    main()
    {
            float f;

            f = 0x1.ffffffp0f;
    }

メッセージ ID: E_CNV_HEX_CONST_EVAL_FMT

## num_threads 節の式は整数型でなければなりません。

OpenMP parallel の num_threads 節に指定された式は整数型をもっている必要があります。 このメッセージを生成するコードの例を次に示します。

    void main() {
      struct { int val; } true = {1};

      #pragma omp parallel num_threads(true)
    	printf("Hello,worlds!\n");
    }

メッセージ ID: E_OMP_BAD_NUM_THREADS_TYPE

## pragma STDC は複合文内の明示的な宣言および文より前になければなりません。

このメッセージを生成するコードの例

    void foo() {
      int i;
      #pragma STDC FP_CONTRACT OFF
    }

メッセージ ID: E_STDC_PRAGMA_WRONG

## num_threads 節の式は正の整数でなければなりません。

OpenMP parallel の num_threads 節に指定された式は、正の整数でなければなりません。 このメッセージを生成するコードの例

    void main() {
      #pragma omp parallel num_threads(-1)
    	printf("Hello,worlds!\n");
    }

メッセージ ID: E_OMP_NEGATIVE_NUM_THREADS

## 非公開変数はその節中に指定することはできません。

並列領域内で非公開である変数は、並列構文にバインドされた、分業指令上の縮約された節内に指定することはできません。 このメッセージを生成するコードの例を次に示します。

    void main() {
      int i;
      #pragma omp parallel private(i)
    	#pragma omp sections reduction(+:i)
    	{
    	   i++;
    	}
    }

メッセージ ID: E_OMP_CANT_BE_IN_PRIVATE

## 縮約変数はこの節中に指定できません。

並列指令の縮約された節に現れる変数は、並列構文にバインドされた、分業指令上の縮約された節内に指定することはできません。 このメッセージを生成するコードの例を次に示します。

    void main() {
      int i;
      #pragma omp parallel reduction(+:i)
    	#pragma omp sections reduction(+:i)
    	{
    	   i++;
    	}
    }

メッセージ ID: E_OMP_CANT_BE_IN_REDUCTION

## section 指令の後に文を指定しなければなりません。

OpenMP section 指令には一連の section 指令が含まれ、各指令のあとには文が 1 つ続きます。 しかし、最初の section 指令は省略される可能性があります。

    void foo() {
         int i,j;
         #pragma omp parallel sections private(i, j)
         {
    	i++;
    	i = i + 1;
    	j++;
         }
    }

メッセージ ID: E_OMP_BAD_SECTION_STATEMENT

## threadprivate 指令は、変数のスコープになければなりません。

ファイルスコープ変数の threadprivate 指令は、ファイルスコープに記述する必要があります。 ブロックスコープ変数の threadprivate 指令は、入れ子になったスコープではなくこの変数のスコープ内に記述する必要があります。 このメッセージを生成するコードの例を次に示します。

    extern int x;
    void
    main()
    {
      #pragma omp threadprivate(x)
      static int i;
      {
        #pragma omp threadprivate(i)
      }
    }

メッセージ ID: E_OMP_THREADPRIV_WRONG_SCOPE

## ブロックスコープ中の threadprivate 指令で指定された変数は静的でなければなりません。

threadprivate 指令リスト内の各変数は、ファイルスコープ宣言または静的なブロックスコープ宣言をもたなければなりません。 このメッセージを生成するコードの例を次に示します。

    void
    foo(int i)
    {
       #pragma omp threadprivate(i)
       int j;
       #pragma omp threadprivate(j)
    }

メッセージ ID: E_OMP_STATIC_THREADPRIV

## 不可分式の右辺が変数を参照しています。

不可分式の右辺は、左辺の実体を引用してはなりません。 このメッセージを生成するコードの例を次に示します。

    void
    main()
    {
      int i;
      #pragma omp atomic
      	i += i;
    }

メッセージ ID: E_OMP_ATOMIC_EXPR_REFERENCE

## PCH ファイルを開けません。

ファイルシステムのエラーのために、コンパイラは a.cpch ファイルを開くことができませんでした。 現在の作業ディレクトリに対する読み取り/書き込みの権限があるかを確認してください。

メッセージ ID: E_CANT_OPEN_PCH_FILE

## #pragma hdrstop または -xpchstop=file に対応する #include がありません。

コンパイル済みヘッダーを通して再使用できるコード部を識別する場合、初期共通ソースの最後は #pragma hdrstop または -xpchstop=filename でマークする必要があります (filename にはプログラムソース内で #include の 1 つに結合しているものと同じ名前を指定する)。

メッセージ ID: E_NO_PCH_STOP_POINT

## 最初の #include より前に存在する #pragma hdrstop または -xpchstop は、プリコンパイル済みヘッダーを無効にします。

#include 指令よりも前に #pragma hdrstop または -xpchstop を使用すると、コンパイル済みヘッダーの使用が無効になります。

メッセージ ID: E_HDRSTOP_BEFORE_INCLUDE

## コンパイル済みヘッダーに使用されるヘッダーファイルには関数を定義できません。

PCH ファイルの一部として使用される予定のヘッダーファイル内に関数を定義することはできません。 このエラーを生成するコードの例

    int
    foo()
    {
        return 1;
    }

メッセージ ID: E_CANT_INIT_IN_PCH

## この指令は、プリコンパイル済みヘッダーには無効です。

指令の中にはプリコンパイル済みヘッダーを使用する場合に無効なものがあります。そのような指令が使用されると、エラーが生成されます。 このエラーの原因となるコードの例を次に示します。

    #line 1
    #error "error message"
    #file "file.h"
    #warning "warning message"
    #assert system (unix)
    #unassert system

メッセージ ID: E_PCH_INVALID_DIRECTIVE

## __DATE__ and __TIME__ は、プリコンパイル済みヘッダーでは無効です。

プリコンパイル済みヘッダーを生成する場合、ヘッダーファイル内に定義済みマクロ __DATE__ と __TIME__ を使用することはできません。

メッセージ ID: E_PCH_INVALID_PREDEFINED

## __LINE__ と __FILE__ はプリコンパイル済みヘッダーの接頭部中では無効です。

プリコンパイル済みヘッダーを収集または使用する場合、コンパイルされたヘッダーの接頭部内で定義済みマクロ __LINE__ と __FILE__ を使用することはできません。

メッセージ ID: E_PCH_PREFIX_PREDEFINED

## PCH ファイル内に認識できないマジックナンバーが存在します。

マジックナンバーが認識されなかったため、この PCH ファイルは使用できません。

メッセージ ID: E_PCH_FILE_UNUSABLE_MAGIC

## 不正なバージョンスタンプが使用されており、PCH ファイルを読み取ることができません。PCH ファイルを生成し直してください。

PCH バージョン番号が不正なため、この PCH ファイルは使用できません。 現在のコンパイラを使用して PCH ファイルを再生成する必要があります。

メッセージ ID: E_PCH_FILE_UNUSABLE_VERSION

## PCH ファイルを使用できません。-D または -U オプションは、PCH ファイルの作成時に使用したものと一致しなければなりません。

PCH ファイルの作成時に使用されたものと -D または -U オプションが正確に一致しなかったため、このPCH ファイルは使用できません。

メッセージ ID: E_PCH_FILE_UNUSABLE_DEFS

## PCH ファイルを使用できません。cc コマンドのオプションは、PCH ファイルの作成時に使用されたものと一致しなければなりません。

PCH ファイルの作成時に使用されたものとこれらのコマンド行オプションが正確に一致しなかったため、このPCH ファイルは使用できません。

メッセージ ID: E_PCH_FILE_UNUSABLE_OPS

## PCH ファイルは使用できません。#include 指定を含む前処理指令の並びは、PCH ファイルの作成時に使用したものと一致しなければなりません。

当初の前処理指令 (#include 指令など) が PCH ファイルの作成時に使用されたものと正確に一致 (コメントを除く) しなかったため、この PCH ファイルは現在のソースファイルで使用できません。

メッセージ ID: E_PCH_FILE_UNUSABLE_PREFIX

## copyprivate 節で指定された変数は、囲み処理を行うコンテキスト中では非公開でなければなりません。

このメッセージを生成するコードの例を次に示します。

    void foo() {
         int i;
         #pragma omp parallel
         {
            #pragma omp single copyprivate(i)
    	;
         }
    }

メッセージ ID: E_OMP_COPYPRIV_MUST_BE_PRIVATE

## copyprivate 節は nowait 節と共に使用してはなりません。

このメッセージを生成するコードの例を次に示します。

    int main() {
        int i = 42;
        #pragma omp single nowait copyprivate(i)
        {
          i++;
        }
    }

メッセージ ID: E_OMP_COPYPRIV_WITH_NOWAIT

## inline キーワードが関数以外の識別子に適用されています。

この inline キーワードが有効なのは、関数識別子に適用される場合だけです。 このエラーを生成するコードの例

    inline int i;

    main()
    {
        inline float f[10];
    }

メッセージ ID: E_INLINE_NEEDS_FUNC

## インライン関数の定義が static となるように再宣言されました。

関数の宣言が以前のインライン関数定義と矛盾しています。 このメッセージを生成するコードの例を次に示します。

    inline int func(int i)
    {
        return ++i
    }

    static int func();

メッセージ ID: E_INLINE_FUNC_REDECL_STATIC

## 条件式が有効な左辺値ではありません。

このメッセージを生成するコードの例を次に示します。

    void
    main(void) {
            int a=1, b=0, c=0;
            (a ? b : c) = 5;
    }

メッセージ ID: E_ASSIGNMENT_TO_COND_EXPR

## 複合リテラルは C99 ISO 機能です。

このメッセージを生成するコードの例を次に示します。

    int *a = &(int[]){10, 20};

メッセージ ID: E_NONC99_COMPOUND_LITERAL

## ポインタに代入される、構造体型の関数の配列メンバーが未定義です。

構造体型の関数の配列メンバーをポインタに代入しようとしていますが、 次の副作用完了点を過ぎてもこの代入の結果が定義されていません。 このメッセージを生成するコードの例を次に示します。

    main()
    {
        int *i;

        i = foo().bar;
        printf("i is %d\n", *i);
    }

メッセージ ID: E_ASG_ARY_TO_PTR

## inline キーワードの使用法が正しくありません。

inline キーワードの使用法が正しくありません。 このメッセージを生成するコードの例を次に示します。

    int foo(inline int);

メッセージ ID: E_INLINE_INVALID_USE

## オペランドは、整数型、実数型、またはポインタ型でなければなりません: op \"%s\"

++ および -- 演算子の演算対象は、整数型、実数型、またはポインタ型でなければなりません。 このメッセージを生成するコードの例を次に示します。

    double _Complex dc = 1.0 + 2.0 * _Imaginary_I;
    dc++; // ここでエラーとなる

    double _Imaginary di = 2.0 * _Imaginary_I;
    --di; // ここでエラーとなる

メッセージ ID: E_OPERAND_MUST_BE_REAL_OR_PTR

## extern のインライン関数中で static の識別子を参照しています。

このメッセージを生成するコードの例を次に示します。

    static int bar();

    inline int foo() {
        static int i;

        return i + bar();
    }

    変数 'i' と関数 'bar' に対する参照が両方とも無効です。

メッセージ ID: E_REF_STATIC_EXTERN_INLINE

## 型識別子 %s が不完全です。

型識別子 Complex/Imaginary が不完全です。 このメッセージを生成するコードの例

    _Complex c = 1.1 + 2.2 * _Imaginary_I;
    _Imaginary i;

メッセージ ID: E_INCOMPLETE_COMPLEX_IMAGINARY

## 浮動小数点演算が無効です。

浮動小数点演算が無効です。

メッセージ ID: E_FP_INVALID

## 浮動小数点演算によってオーバーフローが発生します。

浮動小数点演算によってオーバーフローが発生します。

メッセージ ID: E_FP_OVERFLOW

## 浮動小数点演算によってアンダーフローが発生します。

浮動小数点演算によってアンダーフローが発生します。

メッセージ ID: E_FP_UNDERFLOW

## 0 による除算

0 による除算です。

メッセージ ID: E_FP_DIVISION_BY_ZERO

## _Imaginary 型に変換された実数型は _Imaginary 型の 0.0 となります。

_Imaginary 型に変換された実数型は _Imaginary 型の 0.0 となります。 このメッセージを生成するコードの例を次に示します。

    double d = 1.0;
    double _Imaginary di = d;     // ここで警告が発生する: di gets 0

メッセージ ID: E_REAL_CONV_TO_ZERO

## 実数型に変換された _Imaginary 型は実数型の 0.0 となります。

実数型に変換された _Imaginary 型は実数型の 0.0 となります。 このメッセージを生成するコードの例を次に示します。

    double _Imaginary di = _Imaginary_I;
    double d = di;        // ここで警告が発生する: d gets 0

メッセージ ID: E_IMAGINARY_CONV_TO_ZERO

## omp のループの反復式が制御式と不整合です。

OpenMP の反復式は、制御式と一貫性がなければなりません。 反復のための論理式が <= ならば、反復値は増加されなければなりません。(>= の場合は減少)。 このメッセージを生成するコードの例を次に示します。

    void main() {
      int i;
      #pragma omp parallel for
      for (i=0; i<10; i--) {
      }
    }

メッセージ ID: E_OMP_FOR_INCONSIST_ITER

## 16 ビット文字列リテラルとワイドまたは標準文字列リテラルを連結することはできません。

16 ビットの文字列リテラルはほかの 16 ビット文字列リテラルとしか連結できません。 このメッセージを生成するコードの例を次に示します。

    unsigned short *s = U"abc" "def";

メッセージ ID: E_CANT_CONCAT_MIXED_UTF_STRINGS

## U 文字列リテラルは ASCII だけを含むことができます。

この警告を生成するコードの例を次に示します。

    unsigned short bar[] = U"é";

メッセージ ID: E_ASCII_UTF16_USHORT_CHAR_ERR

## U 文字列リテラルは数値エスケープを含めることはできません。

この警告を生成するコードの例を次に示します。

    unsigned short bar[] = U"\351";

メッセージ ID: E_NUMERIC_ESCAPE_IN_UTF16

## dbx 修正継続機能のために変数名を大域化しています。crossfile 最適化フラグは無視されます。

デバッガから修正継続機能を使用する場合は、-xcrossfile フラグは無視されます。

メッセージ ID: E_X_CROSSFILE_IGNORED

## 外部リンケージを使用した識別子だけがリンカースコープを持つことができます。

このエラーを生成するコードの例を次に示します。

    static __symbolic int i;

メッセージ ID: E_LDSCOPE_FOR_EXTERN_ONLY

## 再宣言は、同等かより制限されるリンカースコープを持たなければなりません。

このエラーを生成するコードの例を次に示します。

    __symbolic void rescopedcl();
    __global void rescopedcl();

メッセージ ID: E_NEW_LDSCOPE_MUST_BE_HIGHER

## リンカースコープは定義と一致していなければなりません。

このエラーを生成するコードの例を次に示します。

    __symbolic void rescopedef() { } __hidden void rescopedef();

メッセージ ID: E_NO_LDSCOPE_AFTER_DEFN

## PCH 活性文字列に含まれているのは、#include 指令などのプリプロセッサ指令やコメントだけである必要があります

このエラーを生成するコードの例を次に示します。

    int i;
    #include "file.h"
    #pragma hdrstop
    main()
    {
    }

メッセージ ID: E_PCH_BAD_VIABLE_PREFIX

## ビットフィールドサイズが 0 より小さくなっています

ビットフィールドの宣言で、負の数のビットが指定されています。 このメッセージを生成するコードの例を次に示します。

    struct s { int x:-3 };

メッセージ ID: E_BIT_FLD_SIZE_LESS_ZERO

## サイズが 0 のビットフィールド

ビットフィールドの宣言で、サイズが 0 に指定されています。 このメッセージを生成するコードの例を次に示します。

    struct s {
    int x:1;
    int y:0;
    };

メッセージ ID: E_BIT_FLD_SIZE_EQUAL_ZERO

## openmp 構造体ブロックに入るために、goto 文を使用することはできません

OpenMP 並列構造とワークシェアリング構造の後には、構造体ブロックが続く必要があります。構造体ブロックは、1 つの入り口と 1 つの出口を持つ文です。構造体ブロックに入ったり、構造体ブロックから出たりする文を使用することはできません。 このメッセージを生成するコードの例を次に示します。

    int foo() {
    goto label_1;
    #pragma omp parallel
      {
    label_1: ;
      }
    }

メッセージ ID: E_OMP_STRUCTBLK_BREAKING_IN

## openmp 構造体ブロックから出るために、return、goto、break、continue 文を使用することはできません

OpenMP 並列構造とワークシェアリング構造の後には、構造体ブロックが続く必要があります。構造体ブロックは、1 つの入り口と 1 つの出口を持つ文です。構造体ブロックに入ったり、構造体ブロックから出たりする文を使用することはできません。つまり、構造体ブロックには、制御をブロックから別の場所に移すような return、goto、break、continue などの文は使用できません。 このメッセージを生成するコードの例を次に示します。

    int foo() {
    #pragma omp parallel
      {
    return;
      }
    }

メッセージ ID: E_OMP_STRUCTBLK_BREAKING_OUT

## __thread 変数は、この節では使用できません

OpenMP データスコープ節で TLS 変数を使用することはできません。ただし、デフォルトの節の影響は受けません。 このメッセージを生成するコードの例を次に示します。

    __thread int i;

    void
    main()
    {
    #pragma omp parallel private(i)
    i++;
    }

メッセージ ID: E_OMP_TLS_WRONG_CLAUSE

## 配列指示が配列ではない型に使用されています

配列初期化子の指示に使われる添え字を使用して、配列ではない型の変数を初期化しました。 このメッセージを生成する初期化子の例を次に示します。

    int a = {[5]=1};

メッセージ ID: E_DESIG_INIT_NONARRAY

## 配列に対する指示が整定数ではありません

配列初期化子の指示に使われている添え字が、定数値でも整数型でもありません。 このメッセージを生成する初期化子の例を次に示します。

    int i;
    int a[10] = {[i]=1};

メッセージ ID: E_DESIG_INIT_INDEX_NONCONST

## 配列に対する指示が範囲外です

配列初期化子の指示に使われている添え字が配列の範囲外です。 このメッセージを生成する初期化子の例を次に示します。

    int a[10] = {[20]=1};

メッセージ ID: E_DESIG_INIT_INDEX_BOUND

## 構造体/共用体ではない型に構造体/共用体指示子が使用されています

構造体/共用体ではない初期化子のコンテキストで構造体/共用体フィールド名が使用されていました。 このメッセージを生成する初期化子の例を次に示します。

    int a[10] = {.field=1};

メッセージ ID: E_DESIG_INIT_NONSTRUCT

## 指示付きの初期化子は C99 ISO 機能です

非 C99 モードで C99 ISO の指示付きの初期化子構文が使用されています。 このメッセージを生成する初期化子の例を次に示します。

    int a[10] = {.field=1};

メッセージ ID: E_DESIG_INIT_DISABLED

## printf 型の関数に変数の書式指定子。展開時に問題になる可能性があります

ユーザー定義データ (入力またはコマンド行オプションから得られるデータなど) を printf 型の関数の書式引数として渡す場合は、書式文字列に意図しない %n 指定子がないようにします。%n の展開は、セキュリティ上の注意すべき点として、よく知られているものです。 このエラーを生成するコードの例を次に示します。

    (void) fprintf(stderr, fmt, i1, i2, i3);

メッセージ ID: E_SEC_PRINTF_VAR_FMT

## sprinf 型の関数の書式文字列にサイズ制限のない文字列指定子が含まれています

書式にサイズ制限のない %s 指定子があると、書式化された引数がバッファよりも大きい場合に、バッファオーバーフローになる可能性があります。 このエラーを生成するコードの例を次に示します。

    (void) sprintf(buf, "%s", string);

メッセージ ID: E_SEC_SPRINTF_UNBOUNDED_COPY

## scanf 型の関数に変数の書式指定子。展開時に問題になる可能性があります

ユーザー定義データ (入力またはコマンド行オプションから得られるデータなど) を scanf 型の関数の書式引数として渡す場合は、書式文字列に意図しない %n 指定子がないようにします。%n の展開が安全面で問題になることはありません。 このエラーを生成するコードの例を次に示します。

    (void) fscanf(stdin, fmt, &i1, &i2, &i3);

メッセージ ID: E_SEC_SCANF_VAR_FMT

## scanf 型の関数の書式文字列にサイズ制限のない文字列指定子が含まれています

書式に非結合 %s 指定子があると、書式化された引数がバッファよりも大きい場合に、バッファオーバーフローになる可能性があります。 このエラーを生成するコードの例を次に示します。

    (void) scanf("%s", string);

メッセージ ID: E_SEC_SCANF_UNBOUNDED_COPY

## strcpy 型の関数への変数の引数。安全であることを確認してください

strcpy() を使用して文字列をコピーすると、バッファが小さすぎて、コピー元のバッファの内容を保持できない場合に、コピー先のバッファがオーバーフローすることがあります。コピー先に十分な大きさのバッファを確保するか、strlcpy() を使用してください。 このエラーを生成するコードの例を次に示します。

    (void) strcpy(dst, src);

メッセージ ID: E_SEC_STRCPY_WARN

## 新しいコードでは strncpy 型の関数を使用しないでください。strl*() を推奨します。

ライブラリ関数 strncpy() は、十分な空き領域がない場合にコピー先の文字列を NUL で終了しないため、使用するのが難しい関数です。strlcpy() にはこの制限がないため、通常は、こちらの方が適しています。 例外が 1 つあります。それは、ディスク上にある構造体を更新する場合で、この場合は、strncpy() がコピー先バッファの未使用の領域を NUL で埋めるという事実が前提になります。 このエラーを生成するコードの例を次に示します。

    (void) strncpy(dst, src, size);

メッセージ ID: E_SEC_STRNCPY_WARN

## 新しいコードでは strncat 型の関数を使用しないでください。strl*() を推奨します。

strncat() では、呼び出す前に残りの領域を計算する必要があるため、使用を推奨しません。 strlcat() の方がより簡単で、安全に使用できます。 このエラーを生成するコードの例を次に示します。

    (void) strncat(dst, src, size);

メッセージ ID: E_SEC_STRNCAT_WARN

## gets() は使用しないでください。代わりに fgets(buf, sizeof(buf), stdin) を使用してください

gets() を安全に使用できる状況はありません。提供されるバッファのサイズに関する情報がないため、常にバッファオーバーフローの危険性があります。fgets() を使用してください。 このエラーを生成するコードの例を次に示します。

    (void) gets(buf);

メッセージ ID: E_SEC_FORBIDDEN_WARN_GETS

## cftime 型の関数を使用しないでください。代わりに strftime(buf, sizeof(buf), fmt, &tm) を使用してください

cftime() は、結果を保持するのに十分な大きさのバッファがあることを前提にしています。この関数は環境 (CFTIME) から情報をインポートするため、提供したバッファに結果が格納できるかどうかは確実ではありません。代わりに strftime() を使用してください。 このエラーを生成するコードの例を次に示します。

    (void) cftime(buf, fmt, clock);

メッセージ ID: E_SEC_FORBIDDEN_WARN_CFTIME

## ascftime 型の関数は使用しないでください。代わりに strftime(buf, sizeof(buf), fmt, &tm) を使用してください

ascftime() は、結果を保持するのに十分な大きさのバッファがあることを前提にしています。この関数は環境 (CFTIME) から情報をインポートするため、提供したバッファに結果が格納できるかどうかは確実ではありません。代わりに strftime() を使用してください。 このエラーを生成するコードの例を次に示します。

    (void) ascftime(buf, fmt, time);

メッセージ ID: E_SEC_FORBIDDEN_WARN_ASCFTIME

## creat 系の関数は使用しないでください。代わりに open(path, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL, mode) を使用してください

creat() はシンボリックリンクの攻撃に弱い関数です。すなわち、作成するファイル名がシンボリックリンクとしてすでに存在している場合、creat() はそのシンボリックリンクをたどり、それが示す場所にファイルを作成します。このため、ファイルを安全に作成することができません。 このエラーを生成するコードの例を次に示します。

    fd = creat(fname, mode);

メッセージ ID: E_SEC_FORBIDDEN_WARN_CREAT

## 文字列のコピーに直接メモリーコピーは使用しないでください。代わりに strlcpy() を使用してください

bcopy() または memcpy() を使用した文字列のコピーでは、正しいサイズを計算しておく必要があるため、エラーが起きやすくなります。このため、代わりに strlcpy() の使用を推奨します。 このエラーを生成するコードの例を次に示します。

    char *src, dst;
    ...
    (void) bcopy(dst, src, len);

メッセージ ID: E_SEC_BCOPY_WARN

## rand() の使用は推奨されません。代わりに /dev/random の使用を推奨します

rand() 系の関数は、比較的脆弱な乱数ジェネレータを実装しています。より強固な乱数が望ましい場合は、/dev/random または /dev/urandom インタフェースを利用してください。 このエラーを生成するコードの例を次に示します。

    i = rand();

メッセージ ID: E_SEC_RAND_WARN

## chdir では、パス名の競合状態が発生しやすくなります。マルチスレッドプログラムでは使用しないでください

同じオブジェクト (ディレクトリ) を扱う別の関数とこの関数を組み合わせて使用すると、パス名の競合状態になる可能性があります。代わりに fchdir() を使用してください。 このエラーを生成するコードの例を次に示します。

    (void) chdir(dirname);

メッセージ ID: E_SEC_CHDIR_WARN

## ユーザー提供のメッセージカタログを使用して catopen 系の関数を呼び出さないでください

ライブラリやプログラムから、ユーザー提供のパス名でこの関数を呼び出さないでください。ユーザー提供のメッセージカタログを利用して、権限が必要なコードを簡単に破ることができます。 このエラーを生成するコードの例を次に示します。

    (void) catopen(fname, flag);

メッセージ ID: E_SEC_CATOPEN_WARN

## argv[0] などのユーザー入力から dl_open() のパラメータを作成しないでください

この関数のパラメータは、後で実行時リンカーのパスを使用して検出されるパス名か、ユーザー入力 (argv[0] を含む) から絶対に得られることのない完全なパス名だけにしてください。 dlopen() 関数が復帰する前に _init() 関数が実行されるため、ユーザー提供の共有オブジェクトを安全に開く方法がないことに注意してください。 このエラーを生成するコードの例を次に示します。

    dlopen(fname, dlopen_mode);

メッセージ ID: E_SEC_DLOPEN_WARN

## この関数はファイルを開きます。パス名が安全か確認してください

この関数は複数のファイルを開きます。安全であることが分かっているパス名のみ使用してください。

メッセージ ID: E_SEC_PATH_WARN

## chroot() された環境は、ほとんどの場合で保護を提供されません

chroot() された環境は、ほとんどの場合で保護を提供されません。 chroot された環境で権限が必要なプログラムを実行していないことを確認し、必ず、chroot() の後で新しいルートの下のポイントに chdir() してください。

メッセージ ID: E_SEC_CHROOT_WARN

## 環境変数は完全にユーザーの制御下にあります。注意が必要です

getenv() によって返される値は慎重に扱ってください。完全にユーザーの制御下にあり、大量の (最大 NCARGS () 文字になる可能性があります。また、あらゆる種類の予期しないデータが含まれることがあり、プログラムで、使用する前に不要なデータを削除する必要があります。

メッセージ ID: E_SEC_GETENV_WARN

## getlogin() の使用は避けてください。戻り値は ユーザー ID に関するヒントにすぎません

getlogin() の使用は避けてください。その出力は信頼できません。マルチスレッドに対して安全ではありません。代わりに getlogin_r() を使用してください。どちらの場合も、返されたログインは信頼できません。uid を使用するか、代わりのユーザー認証方法を用意してください。

メッセージ ID: E_SEC_GETLOGIN_WARN

## mkdir() に対するユーザーの提供するパスに注意してください

mkdir() に使用されるパスをユーザー入力から得る場合は、そのパスが安全であることを確認してください。

メッセージ ID: E_SEC_MKDIR_WARN

## mktemp 系の関数の使用は避けてください。生成されたパス名が安全である保証はありません

パス名の生成とその open() での使用との間に競合状態があるため、生成されたパス名が安全である保証はありません。代わりに「fd = mkstemp(template);」を使用してください。

メッセージ ID: E_SEC_MKTEMP_WARN

## シェルを呼び出す関数の使用を避けてください

この関数は、そのジョブを実行をするためにシェル (/bin/sh) を呼び出す子プロセスを作成します。シェルの子プロセスの生成には、$PATH、$IFS などの環境変数が必要であり、安全に使用することは困難です。また、シェルは引数に存在する特殊文字を解釈することを忘れないでください。

メッセージ ID: E_SEC_SHELL_WARN

## kvm_* 関数の使用は避けてください。カーネルからの情報が必要な場合には、適切な kstat() インタフェースを作成してください

ユーザー指定の \"namelist\" 引数を受け付ける場合は、その引数を使用する前に必ず権限を無効にしてください。

メッセージ ID: E_SEC_KVM_WARN

## readlink の戻り値が NUL 終了である保証はありません

必ず、シンボリックリンクの内容が提供バッファに対して大きすぎる場合の対処をしてください。

メッセージ ID: E_SEC_READLINK_WARN

## getpass() が返す文字数は最大で 8 文字です。getpassphrase() を推奨します

セキュリティ保護するアプリケーションでは getpass() の使用を避けてください。 最大 256 文字の長さのパスワードを返すことができるため、getpassphrase() の方を推奨します。

メッセージ ID: E_SEC_GETPASS_WARN

## tempnam 系の関数の使用は避けてください。代わりに mkstemp() を使用してください

パス名の生成とその open() での使用との間に競合状態があるため、生成されたパス名が安全である保証はありません。代わりに mkstemp() を使用してください。

メッセージ ID: E_SEC_TEMPNAM_WARN

## tmpfile 系の関数はマルチスレッドでの動作が安全ではありません (umask を変更します)

この関数は、マルチスレッドアプリケーションで危険な umask() を呼び出します。

メッセージ ID: E_SEC_TMPFILE_WARN

## truncate 系の関数の使用は避けてください; 代わりに ftruncate() を使用してください

ファイルの名前空間内のオブジェクトを操作するため、この関数はパス名競合状態になりがちです。この関数に提供されるオブジェクトは、以前または以降の呼び出しで提供されるオブジェクトと異なることがあります。これは、それらの呼び出しの間でファイルシステムが変化していることによります。

メッセージ ID: E_SEC_TRUNCATE_WARN

## セキュリティ保護すべきアプリケーションでは、可能な限り umask 変更する関数の使用は避けてください

ユーザー定義の umask を変更するため、umask() の使用は避けてください。open 系の関数でファイル作成モードを使用することを検討してください。

メッセージ ID: E_SEC_UMASK_WARN

## utmp 名を変更する関数の使用は避けてください。デフォルトの utmp ファイルを使用してください

セキュリティ保護するアプリケーションでの utmpname() の使用は避けてください。代わりにデフォルトの utmp ファイル名を使用してください。

メッセージ ID: E_SEC_UTMP_WARN

## select 系の関数の使用は避けてください。poll() を推奨します。

API が難しいため、select() を使用したプログラミングは間違いやすく、セキュリティ面においていくつか問題が発生することが判明しています。 poll() のインタフェースの方がより使用しやすく、制約も少なくて高速です。

メッセージ ID: E_SEC_SELECT_WARN

## strcpy 系の関数はバッファオーバーランを起こしがちです。境界を確認してください

この関数を使用して文字列をコピーすると、バッファが小さすぎて、コピー元のバッファの内容を保持できない場合に、コピー先のバッファがオーバーフローすることがあります。必ずコピー先に十分な大きさのバッファを確保してください。

メッセージ ID: E_SEC_EXPAND_WARN

## chmod() 系の関数を使用は競合状態を引き起こす傾向があります

プロセスが現在の real-uid を受け付け、必要がある場合は、ファイルを開く前にその real-uid に切り替えるようにしてください。ファイルシステムのオブジェクトの属性を変更する必要がある場合は、でれきば、fchown()/fchmod() と一緒に open () を使用してください。

メッセージ ID: E_SEC_CHMOD_WARN

## 権限が必要なソフトウェアでは exec*() 関数の使用は避けてください

execvp() および execlp() は $PATH によって、実行する適切なバイナリを検出し、$PATH はしばしばユーザーの制御下にあります。代わりに execl() か execv()、execve() を使用してください。

メッセージ ID: E_SEC_EXEC_PATH

## exec() 系の関数の使用は制限されています

別のアプリケーション を exec() する前に、必ず環境から不要なものを削除し、重要なすべてのファイル記述子を閉じておいてください。

メッセージ ID: E_SEC_EXEC_WARN

## バッファにインクリメンタルに入力を格納する場合は、必ず境界条件を確認してください

これは安全面で重要です。ループ内でバッファに入力を付加するときは境界を確認してください。境界の計算が間違っていたり、なかったりすると、バッファオーバーランになることがあります。決して、ユーザー入力が固定長であると考えないでください。境界や符号の有無などを確認してください。

メッセージ ID: E_SEC_LOOP_WARN

## access 系の関数の使用は避けてください

この関数が返す情報は、実際に操作できる頃までには古くなっています。このため、安全に使用することはできません。access() の後に open() を使用すると、解消できない競合状態になります。 代わりに、 意図するユーザーのアクセス権付きで open() を使用してください。

メッセージ ID: E_SEC_ACCESS_WARN

## O_EXCL を指定しないで O_CREAT を指定しています

O_EXCL なしで、 O_CREAT だけ付けて open() を呼び出した場合、open() はパス名の最後の要素としてシンボリックリンクを辿ります。このため、意図していなかった場所にユーザーがファイルを作成できる可能性があります。

メッセージ ID: E_SEC_CREAT_WITHOUT_EXCL

## O_CREAT が指定されていますが、 \"mode\" パラメータが設定されていません

必ずファイル作成モードを指定してください。できる限りアクセス権を限定し (通常は、現在のユーザーのみ)、必要に応じて後で拡張するようにしてください。さもないと、作成したファイルに望ましくないユーザーアクセスが行われる可能性があります。

メッセージ ID: E_SEC_CREAT_WITHOUT_MODE

## fopen 系の関数で安全にファイルを作成することはできません

この関数では、新しいファイルに対してアクセス権を指定できません。パス名がすでに存在すること、あるいはディレクトリが一般書き込み可能でないことを確認してください。代わりに open()/fdopen() シーケンスを使用してください。

メッセージ ID: E_SEC_FOPEN_MODE

## 潜在的な競合状態が検出されました。以前に、stat() にパラメータが渡されています

stat 系の呼び出しが完了した後、不正なユーザーによってファイルシステムオブジェクトが変更され、競合状態が発生する可能性があります。代わりに fstat() を使用してください。

メッセージ ID: E_SEC_USE_AFTER_STAT

## glob に変数マスク指定子があります。展開時に問題になる可能性があります

ユーザー定義データ (入力またはコマンド行オプションから得られるデータなど) を glob() の引数として渡す場合は、入力の妥当性を検査して、文字列の書式に誤りがないこと、セキュリティ面の脅威にならないことを確認してください。拡張記号の「..」「/」「-」や空白、その他の特殊文字がないかどうかを確認してください。

メッセージ ID: E_SEC_GLOB_WARN

## 不完全な型の複合リテラルです

複合リテラルで使用する型名は、オブジェクト型か不明なサイズの配列のいずれかにします。 このメッセージを生成するコードの例

    int i = (struct UNKNOWN) { 1 };

メッセージ ID: E_INCOMPLETE_COMPOUND_LITERAL

## ISO C99 では、\u は汎用文字名のエスケープ文字です

1999 ISO C では、\u および \U のエスケープシーケンスは汎用文字名を示します。 このメッセージを生成するコードの例を次に示します。

    char *cp = "This is a ucn: \u0020";

メッセージ ID: E_ESC_U_IS_C99_UCN

## 汎用文字名に十分な桁数の 16 進数ではありません

1999 ISO C の仕様では、\u の後に 4 桁の 16 進数、\U の後に 8 桁の 8 進数が必要です。 このメッセージを生成するコードの例を次に示します。

    char *cp = "&\u00fz";

メッセージ ID: E_BAD_NUM_OF_DIGITS_IN_UCN

## 識別子の汎用文字名の値が有効ではありません

識別子のこの汎用文字名は、1999 ISO C で規定されている制限に違反しており、有効ではありません。 このメッセージを生成するコードの例を次に示します。

    int i\uFFFF;

メッセージ ID: E_INVALID_UCN_FOR_ID

## 無効な汎用文字名の値

この汎用文字名は有効ではありません。 このメッセージを生成するコードの例を次に示します。

    int i\u0033;

メッセージ ID: E_INVALID_UCN_VALUE

## 整定数式が必要です。これは C99 の VLA です

1990 ISO C では、配列のサイズ式に整定数以外の式を使用することはできません。 1999 ISO C では、これは可変長の配列になることに注意してください。 このメッセージを生成するコードの例を次に示します。

    void foo() {
    int a[(int)(5.0+1.0)];
    }

メッセージ ID: E_C90_NON_INTEGRAL_ARRAY_SIZE

## 条件付きコンパイルされるソースコードの途中で活性文字列の終わりが検出されました

PCH ファイルを作成または使用する場合、ソースファイルの活性文字列は、必ず条件付きコンパイルコードの外部で終了する必要があります。 たとえば、cc -xpch=collect:FOO -DFOO は、このメッセージを生成するコードです。

    #ifdef FOO
    #include "foo.h"
    #pragma hdrstop
    #else
    #include "bar.h"
    #pragma hdrstop
    #endif

    main()
    {}

メッセージ ID: E_PCH_CONDITIONAL_PREFIX

## PCH ファイル内に不正なコンパイラバージョン

この PCH ファイルは使用できません。PCH ファイルの生成に使われたコンパイラと、現在のコンパイラが異なります。

メッセージ ID: E_PCH_FILE_UNUSABLE_COMP_VERS

## PCH ファイルを使用できません。現在のソースパスと、PCH ファイルを作成したときのパスは同じである必要があります

この PCH ファイルは使用できません。現在のソースパスと、PCH ファイルを作成したときに有効なソースパスが異なります。相対パスが使用されているなどであり、その場合、異なるヘッダーファイルが取り込まれる可能性があります。このことは、このコンパイルで PCH ファイルの内容が有効でなくなることを意味します。

メッセージ ID: E_PCH_FILE_UNUSABLE_SRC_PATH

## PCH ファイルを使用できません。現在の作業用ディレクトリと、PCH ファイルを作成したときのディレクトリが同じである必要があります

この PCH ファイルは使用できません。現在の作業用ディレクトリと、PCH ファイルを作成したときに有効なディレクトリが異なります。この結果、異なるヘッダーファイルが取り込まれる可能性があり、このことは、このコンパイルで PCH ファイルの内容が有効でなくなることを意味します。

メッセージ ID: E_PCH_FILE_UNUSABLE_CWD

## -xcrossfile または -xipo を使用している場合には、変数を extern から static に宣言し直すことはできません

この警告は、-xcrossfile または -xipo オプションを使用してコンパイラを起動したときに 表示されます。`extern` 変数として宣言済みの変数は、static として 再宣言できません。 このメッセージを生成するコードの例を次に示します。

    extern int local_i;
    void main(int argc, char *argv[])
    {
    	return local_i;
    }
    static int local_i=10;

メッセージ ID: E_CANT_XCROSSFILE_GLOBSTATIC

## 変数の最初の宣言に __thread 指定子がありません

thread 変数の最初の宣言には、__thread 指定子を含める必要があります。 このメッセージを生成するコードの例を次に示します。

    int i;
    __thread int i;

メッセージ ID: E_NONTHREAD_THREAD_REDECL

## #line 指令の行番号は 次である必要があります:

#line 指令に指定する行番号は、C99 モードの場合 2147483647 以下、C90 モードの場合 32767 以下である必要があります。 このメッセージを生成するコードの例を次に示します。

    #line 2147483647 "string"
    #line 2147483648

メッセージ ID: E_OUT_OF_RANGE_POUND_NUMBER

## すでに使用した後に redefine_extname プラグマが存在します:

すでに使用された名前を redefine_extname プラグマを再定義しようとしています。

    void main(){
    foo6(1,1);
    }
    #pragma redefine_extname foo6 foo6_1

メッセージ ID: E_REDEF_EXTNAME_INCORRECT

## 外部リンケージを指定して宣言された変数を値によって変わり得る型にすることはできません。

外部リンケージを指定して宣言された変数を、値によって変わり得る型にすることはできません。 このメッセージを生成するコードの例を次に示します。

    void foo() {
    int n;
    extern int (*a)[n];
    }

メッセージ ID: E_EXTERN_VM

## オペランドは実浮動小数点型である必要があります

実浮動小数点型 (`float、double、long double など`) である必要がオペランドを使用する演算子が使用されているにもかかわらず、たとえば int 型が使われようとしています。 このメッセージを生成するコードの例を次に示します。

    #include
    int foo() {
    double _Complex c;
    return fpclassify(c);
    }

メッセージ ID: E_OPERAND_MUST_BE_REAL_FLOAT

## 構造体メンバーの型を、個数が定義されていない配列をメンバーとして持つ、別の構造体を使用して宣言することはできません

構造体は、個数が定義されていない配列をメンバーとして持つことができます。しかし、そうした構造体、および、そうした構造体をメンバーとして (場合によっては再帰的に) 含む共用体を、別の構造体のメンバーにすることはできません。 このメッセージを生成するコードの例

    struct A {int xa; int ya[];};
    struct B {int xb; struct A yb;};

メッセージ ID: E_STRUCT_DERIVED_FROM_FLEX_MBR

## 配列の型を、個数が定義されていない配列をメンバーとして持つ構造体を使用して宣言することはできません。

構造体は、個数が定義されていない配列をメンバーとして持つことができます。しかし、そうした構造体、および、そうした構造体をメンバーとして (場合によっては再帰的に) 含む共用体を、配列として宣言することはできません。 このメッセージを生成するコードの例

    struct A {int xa; int ya[];};
    struct A n[10];

メッセージ ID: E_ARY_DERIVED_FROM_FLEX_MBR