#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