## #error

在源文件中遇到 `#error` 指令。该指令中的其它标记已作为消息的一部分打印。 生成消息的代码示例：

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

消息标识：E_ERROR_PRAGMA

## 无法从以前的错误中恢复

解编译时产生的早期错误使编译器不易理解，所以无法继续处理程序。请更正这些错误，然后重试。

消息标识：E_CANNOT_RECOVER

## 无法关闭输出文件

编译器试图关闭标准输出时，出现文件系统错误。这不是来自源程序的错误。

消息标识：E_FCLOSE_ERR

## 无法关闭 .ll 文件

编译器关闭 lock lint 数据库 (.ll) 文件时，出现文件系统错误。

消息标识：E_FCLOSE_LL_ERR

## 无法打开文件。文件的类似创建

编译器无法创建 .ll 文件。可能的原因是文件系统错误或目录或文件权限不正确。

消息标识：E_CANT_CREATE_LL_FILE

## 无法内存分配文件名空间。

编译器内部使用 malloc() 失败。这通常是由于运行超出交换空间造成的。

消息标识：E_CANT_MALLOC_FILENAME

## 内存不足

编译器无法获取足够的内存，以编译该程序。这通常是由于运行超出交换空间造成的。

消息标识：E_OUT_OF_MEMORY

## 无法 freopen 标准输出到 /dev/null

编译器试图将输出文件重定向到 /dev/null 时，出现文件系统错误。

消息标识：E_CANT_FREOPEN_STDOUT

## 浮点常量折叠导致异常

编译器尝试在两个浮点操作数之间运算时，已经在编译时检测到溢出。该运算会产生浮点异常，从而导致该编译器退出。

消息标识：E_FP_CONST_CAUSE_EXCEPT

## 无法内存分配文件名空间

编译器内部使用 malloc() 失败。这通常是由于运行超出交换空间造成的。

消息标识：E_CANT_MALLOC_TMP_FILENAME

## 无法创建文件：

由于文件系统错误，编译器无法创建 .ll 文件。请确保具有写入当前工作目录的权限。

消息标识：E_CANT_OPEN_LL_FILE

## 无法将 freopen 重定向到 /dev/null

编译器不能丢弃 lock_lint 数据库文件。

消息标识：E_CANT_FREOPEN_LL_DEV_NULL

## #include <... 缺少 ">"

在标题名称以 < 开头的 `#include` 指令中，结束字符 > 被省略。 生成消息的代码示例：

    #include <stdio.h

消息标识：E_INCLUDE_MISSING

## 在注释内遇到了 /*

使用 `-v` 选项显示该警告。注释中包含 /*。 生成消息的代码示例：

    /*	This is comment
    	that has another /* inside
    	of the comment
    */

消息标识：E_SLASH_STAR_IN_CMNT

## 注释中有 EOF

编译器在读取注释时遇到文件尾。

消息标识：E_EOF_IN_COMMENT

## 指令中有无效空白字符

只有预处理指令中允许使用的空白字符才是空格和垂直制表符。源代码包含其它一些空白字符，如换页符或垂直制表符。编译器将该字符视为空格。

消息标识：E_WHITE_SPACE_IN_DIRECTIVE

## 串文字中有换行符

字符串文字的结尾处没有“位于开头所在的同一行中”。如果字符串文字是预处理指令的一部分（且编译器提供缺少的 "），则诊断信息是警告；否则是错误。 生成消息的代码示例：

    char *p = "abc
    ;

消息标识：E_NEWLINE_IN_STR_LITERAL

## 解释为 #line 指令

使用 `-Xc` 选项显示该警告。遇到具有某个编号的源行。指令名称通常会使用该编号。该行留作编译器内部使用，但是它必须在 `-Xc`（严格符合）模式下进行诊断。 生成消息的代码示例：

    # 9

消息标识：E_INTERPRETED_AS_LINE_DIRECTIVE

## 无效的指令

编译器无法识别预处理指令行中 # 之后的标识符。 生成消息的代码示例：

    # unknown foo

消息标识：E_INVALID_DIRECTIVE

## “.i”文件中的编译器控制行无效

`.i` 文件是执行 `cc -P` 命令的结果，它已被假设为编译器预处理阶段和编译阶段之间的保留通信通道。通过检查 `.i` 文件，可以检测到难以检测到的错误。但是，该编译器只能找到内部通信所用的一些指令。编译的源文件（`.i` 文件）包含预处理指令，但不包含特殊指令之一。

消息标识：E_BAD_COMP_CNTRL_LINE

## 指令是向上兼容的 ANSI C 扩展

使用 `-Xc` 选项显示该警告。编译器检测到支持的指令（它不是 ANSI C 标准的一部分），且已经选择 `-Xc`。 生成消息的代码示例：

    #assert system( unix )

消息标识：E_UP_COMPATIBLE_DIRECTIVE

## 指令在宏参数列表中不受支持

指令已经出现在用于分隔 function-like 宏调用参数的 ( ) 之间。在这种情况下，不允许使用下列指令：`#ident、#include、#line 和 #undef。` 如果显示在 `if`-group 的 false 组中，则诊断信息是警告，否则是错误。 生成消息的代码示例：

    #define flm(a) a+4
    int i = flm(
    #ifdef flm	/* 允许 */
    	#undef flm	/* 不允许：错误 */
    	4
    #else	/* 允许 */
    	#undef flm/* 不允许：警告 */
    	6
    #endif	/* 允许 */
    );

消息标识：E_DIRECTIVE_IN_MACRO_LIST

## #file 后面应为字符串文字

#`file` 指令（留于编译系统使用）供预处理和编译阶段之间的内部通信使用。字符串文字操作数应该是操作数。

消息标识：E_FILE_MISSING_LITERAL

## #ident 后面应为字符串文字

#`ident` 指令之后必须跟常用（非宽字符）字符串文字。 生成消息的代码示例：

    #ident no-string

消息标识：E_IDENT_MISSING_LITERAL

## 读取错误：

编译器无法读取输入文件，可能是由某种文件系统错误造成的。遇到包含文件时，很可能会发出该错误。

消息标识：E_READ_ERROR

## 错误过多

编译器遇到的错误过多，无法有效地执行进一步处理。如果没有生成更多的诊断信息，该编译器将会退出。

消息标识：E_TOO_MANY_ERRS

## malloc() 失败

编译器内部使用 malloc() 失败。这通常是由于运行超出交换空间造成的。

消息标识：E_MALLOC_FAILS

## realloc() 失败

编译器内部使用 realloc() 失败。这通常是由于运行超出交换空间造成的。

消息标识：E_REALLOC_FAILS

## 无法打开

编译器无法打开输入或输出文件。通常，这意味着，传递到 `cc` 命令的文件名参数不正确。诊断信息中的解释说明了无法打开该文件的原因。 生成消息的代码示例：

    cc badname.c -c x.c

消息标识：E_CANNOT_OPEN

## 宏递归

如果使用 `-Xt` 选项时出现致命错误，将会显示该消息。源代码可以直接或间接调用调用自身的宏。ANSI C 语义可以防止进一步尝试重新扫描该宏。早期的 C 编译器试图重新扫描该宏，从而最终产生致命错误。 因为对于 ANSI C 及其预处理程序，重新扫描规则不尽相同，所以，ANSI C 编译器可以在 `-Xt` 模式下提供原来的功能，其中包括在检测宏递归时生成的该诊断信息。 生成消息的代码示例：

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

消息标识：E_MACRO_RECURSION

## 输入中有空字符

编译器遇到一个空字符，即一个字符代码为零的字符。

消息标识：E_NULL_CHAR_INPUT

## 三字母序列被替换

使用 `-Xt` 选项显示该警告。ANSI C 介绍了代表一个字符的三字母、三字符序列的概念。上面的所有序列都是以 `??` 开头的。因为解释为三字母的序列可以出现在现有的代码中，所以，K&R C 编译器可以在遇到这些序列时生成转换诊断信息。 生成消息的代码示例：

    char *surprise = "this is a trigraph??!";

消息标识：E_TRIGRAPH_REPLACED

## 换行符不是文件中的最后一个字符

每一个非空源文件和标题必须由完整的行组成。该诊断信息提示，文件的最后一行不能以换行符结尾。

消息标识：E_NEWLINE_NOT_LAST

## 宏参数列表中有 EOF

编译器在读取调用 function-like 宏所用的参数时到达文件尾。 生成消息的代码示例：

    #define mac(a)
    mac( arg1

消息标识：E_EOF_IN_MACRO_ARG

## #error 指令中的标记错误

`#error` 指令中的标记必须是有效的 C 标记。源程序包含无效的标记。 生成消息的代码示例：

    #error 038 - this is an invalid token

消息标识：E_BAD_TOKEN_IN_ERROR_DIRECTIVE

## 无法打开包含文件（打开的文件过多）

编译器无法打开新的`包含`文件，因为已经打开其它太多的`包含`文件。该编译器至少支持操作系统定义的最大“嵌套”层，即 8 层。之所以发出诊断信息，最有可能的原因是，`包含`文件有时包括已经包含的文件。

消息标识：E_CANT_OPEN_INCLUDE_FILE

## 找不到包含文件

在 `#include` 指令中指定的文件不能与搜索路径一起位于任何目录中 生成消息的代码示例：

    #include "where_is_it.h"

消息标识：E_CANT_FIND_INCLUDE_FILE

## 标记无效

编译器遇到不包含有效标记的字符序列。无效的标记可能是由预处理 ## 运算符产生的。显示违例的非标记。如果非标记的长度超过 20 个字符，将会打印后面跟 " 的前 20 个字符。. .". 违例的无效标记被忽略。 生成消息的代码示例：

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

消息标识：E_INVALID_TOKEN

## 输入标记无效：

编译器尚未将字符序列识别为有效的 C 语言标记。 生成消息的代码示例：

    int i = 1$;

消息标识：E_INVALID_INPUT_TOKEN

## #define 宏参数中的标记无效

编译器在处理 function-like 宏定义的参数列表时遇到不正确的标记。 生成消息的代码示例：

    #define mac(a,4) a b c

消息标识：E_INVALID_TOKEN_IN_DEFINE_MACRO

## 指令中的标记无效

编译器在结构正确的指令结尾处找到无效的标记。 生成消息的代码示例：

    #line 7 "file.c

消息标识：E_INVALID_TOKEN_IN_DIRECTIVE

## 指令中不允许使用标记

已经在 #`if` 或 #`elif` 指令中使用标记。该标记既不是常量表达式的有效运算符，也不是有效的整型常量。 生成消息的代码示例：

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

消息标识：E_TOKEN_ILLEGAL_IN_DIRECTIVE

## “defined”运算符使用不当

`#if` 或 `#elif` 指令中的定义运算符之后必须跟标识符或括起标识符的 ( )。源代码不能这样使用该运算符。 生成消息的代码示例：

    #if defined
    int i = 1;
    #endif

消息标识：E_INVALID_USE_OF_DEFINE

## 参数不匹配

传递到宏的参数数目与宏定义中的参数数目不同。 生成消息的代码示例：

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

消息标识：E_ARGUEMENT_MISMATCH

## 无标记的宏参数

预处理程序宏的实际参数不包含标记。ANSI C 标准将该条件视为取消定义。C 编译器将空的标记列表视为空的参数。另外，它还可以在 `-Xc` 模式下发出该警告。 生成消息的代码示例：

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

消息标识：E_TOKENLESS_MACRO

## 无效目标文件名

编译器内部错误。

消息标识：E_INVALID_TARGET_FILENAME

## #include 指令缺少文件名

`#include` 指令没有指定要包含的文件。 生成消息的代码示例：

    #include

消息标识：E_INCLUDE_MISSING_FILENAME

## 扩展之后无文件名

已经使用允许宏扩展其参数的 `#include` 指令格式，但生成的扩展并未使标记作为文件名。 生成消息的代码示例：

    #define EMPTY
    #include EMPTY

消息标识：E_INCLUDE_EXPANSION_NO_FILE

## 空文件名

`#include` 指令中的文件名为空。 生成消息的代码示例：

    #include <>

消息标识：E_EMPTY_FILE_NAME

## 空的标题名称

宏替换之后的文件名为空。 生成消息的代码示例：

    #define NULLNAME <>
    #include NULLNAME

消息标识：E_EMPTY_HEADER_NAME

## 没有结束 >

`#include` 指令中缺少结束 >。 生成消息的代码示例：

    #include <stdio.h         /* 应该有结束“>” */

消息标识：E_NO_CLOSING_GREATER_THAN

## 错误的文件说明

`#include` 指令中的文件说明符既不是字符串文字，也不是格式正确的标题名称。 生成消息的代码示例：

    #include <stdio.h

消息标识：E_BAD_FILE_SPEC

## 在 # <number> 指令中 0 是无效的

行号信息指令（供编译器的内部通信使用）中的行号必须是非零正值。 生成消息的代码示例：

    # 0 "foo.c"

消息标识：E_ZERO_INVALID_IN_POUND_NUMBER

## 在 #line 指令中 0 是无效的

`#line` 指令中的行号必须是非零正值。 生成消息的代码示例：

    #line 0

消息标识：E_ZERO_INVALID_IN_POUND_LINE

## # <number> 后面需要字符串文字

# < `number` > 指令后面只能跟字符串文字。 生成消息的代码示例：

    #15 notstring

消息标识：E_STRING_EXPECTED_POUND_NO

## #line < number > 之后应有字符串文字

在 #`line` 指令中，只有字符串文字才跟在数字之后。 生成消息的代码示例：

    #line 12 int

消息标识：E_STRING_EXPECTED_POUND_LINE_NO

## “#”后面应该有标识符或数字序列

说明预处理程序指令行的 # 之后是无效标记或非十进制数字。 生成消息的代码示例：

    #0x12

消息标识：E_POUND_NUMBER_EXPECTED

## "#line"后面需要有数字序列

编译器应该在 `#line 之后找到包含行号的数字序列，`但是找到的标记不是正确的标记或值为零的数字序列。 生成消息的代码示例：

    #line 09a

消息标识：E_POUND_LINE_NO_EXPECTED

## #line 指令中无标记

`#line` 指令的其余部分为空；缺少行号和可选的文件名。 生成消息的代码示例：

    #line

消息标识：E_NO_TOKENS_IN_POUND_LINE

## 扩展之后无标记

对 `#line` 指令中的表达式应用宏扩展之后，没有要解释为行号的标记。 生成消息的代码示例：

    #define EMPTY
    #line EMPTY

消息标识：E_NO_TOKENS_AFTER_EXPANSION

## 形式参数重复

在 function-like 宏定义中，已多次将名称用作形式参数。 生成消息的代码示例：

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

消息标识：E_DUPLICATE_FORMAL_PARAM

## 重新定义宏

源代码重新定义宏。如果除形式参数的顺序和拼写之外，两个定义相同，K&R C 的早期版本允许这样重新定义。ANSI C 要求，重新正确定义宏时，定义必须相同，其中包括形式参数的顺序和拼写。如果新的宏定义与原来的宏定义不符，则使用所有选项时，都会产生该诊断信息。为了获得严格的一致性，如果只有宏定义中的形式参数拼写不符，则使用 `-Xc` 选项时，也会产生该诊断信息。 生成消息的代码示例：

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

消息标识：E_MACRO_REDEFINED

## 字符常量中支持多个字符

字符常量具有派生自字符的字符代码的整数值。如果字符常量包含多个字符，则其它字符的编码与执行有关。该警告提示您，对于该版本的 C 编译器与早期版本，字符常量在预处理阶段使用的编码不同。早期版本仅支持第一个字符。可执行代码中使用的字符常量编码不能进行更改。 生成消息的代码示例：

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

消息标识：E_MULTI_CHAR_CHAR_CONST

## 操作数被视为无符号类型

使用 `-Xt` 选项显示该警告。在 `#if` 或 `#elif` 指令中使用的操作数值大于 `LONG_MAX` (2147483647)，但该操作数没有`无符号`修改符后缀。K&R C 的早期版本由于其值而将这种常量视作`带符号`的数字。这些数字实际上是负数。ANSI C 将这些常量视为`无符号`的 long 整数。这些整数会影响自身在表达式中的功能。该诊断是一种转换工具。借助它，可以获知，该值同以前相比得到了区别对待。 生成消息的代码示例：

    #if 2147483648 > 0
    	char *mesg = "ANSI C-style";
    #endif

消息标识：E_OPERAND_TREATED_AS_UNSIGNED

## /usr/include/...的 #include 可能不可移植

源文件包括使用显式前缀 `/usr/include` 的文件。这种包含与执行有关，且无法移植。对于某些系统，查找标题的缺省位置列表可能不包括 `/usr/include`。在这种情况下，可能包括错误的文件。 生成消息的代码示例：

    #include </usr/include/stdio.h>

消息标识：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 */

消息标识：E_NO_MATCHING_ENDIF

## #elif 前面没有 #if

`#elif` 指令必须是以 `#if` 指令开头的预处理 `if`-section 的一部分。可疑的代码缺少 `#if`。 生成消息的代码示例：

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

消息标识：E_ELIF_MISSING_IF

## #elif 后面必须跟常量表达式

`#elif` 指令的后面没有表达式。 生成消息的代码示例：

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

消息标识：E_ELIF_REQUIRES_CONST_EXP

## #elif 跟在 #else 后面

预处理 `if`-section 中的指令必须遵循下面的顺序：`#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

消息标识：E_ELIF_FOLLOWS_ELSE

## #else 前面没有 #if

遇到 `#else` 指令，它不是预处理 `if`-section 的一部分。 生成消息的代码示例：

    #else
    	int i = 7;
    #endif

消息标识：E_ELSE_MISSING_IF

## #else 太多

代码包含预处理 `if`-section 中的多个 #`else` 指令。第一个 #else 指令之后的所有 #else 指令视为 false。 生成消息的代码示例：

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

消息标识：E_TOO_MANY_ELSES

## 没有 #if 的 #endif

遇到 `#endif` 指令，它不是预处理 `if`-section 的一部分。 生成消息的代码示例：

    	int i = 1;
    #endif

消息标识：E_IFLESS_ENDIF

## #if 后面必须跟常量表达式

`#if` 指令之后不出现表达式。 生成消息的代码示例：

    #if
    	int i = 4;
    #endif

消息标识：E_IF_REQUIRES_CONST_EXP

## #ifdef 后面必须跟标识符

`#ifdef` 预处理指令之后必须跟要检查其定义的宏名称。源代码已经省略标识符。`#ifdef` 被视为 false。 生成消息的代码示例：

    #ifdef
    	int i = 1;
    #endif

消息标识：E_IFDEF_REQUIRES_IDENTIFIER

## #ifndef 后面必须跟标识符

`#ifndef` 指令之后必须跟要测试是否已经定义的标识符。 生成消息的代码示例：

    #ifndef
    	int i = 5;
    #endif

消息标识：E_IFNDEF_REQUIRES_IDENTIFIER

## 正在预处理 .i 文件

使用 -P 选项时，已经提供 .i 文件。 例如：cc -P tst.i

消息标识：E_PREPROCESSING_DOT_I_FILE

## 标准输出 I/O 错误

在编译器访问标准输出 (stdout) 时发生文件系统错误。

消息标识：E_STDOUT_ERROR

## 标准错误 I/O 错误

在编译器访问标准错误 (stderr) 时发生文件系统错误。

消息标识：E_STDERR_ERROR

## 空 #assert 指令

`#assert` 指令不包含要断言的谓词名称。 生成消息的代码示例：

    #assert

消息标识：E_EMPTY_ASSERT_DIRECTIVE

## 应为“#assert 标识符”

在 `#assert` 指令中，该指令之后的标记不是谓词的名称。 生成消息的代码示例：

    #assert 5

消息标识：E_ASSERT_IDENTIFIER_EXPECTED

## 应为“#assert 标识符 (...”

在 `#assert` 指令中，该谓词之后的标记不是必需的 (。 生成消息的代码示例：

    #assert system unix

消息标识：E_ASSERT_ID_DOT_DOT_EXPECTED

## “#assert 名称 (”后面没有标记

`#assert` 指令的使用格式错误。缺少断言和应该跟的 )。 生成消息的代码示例：

    #assert system(

消息标识：E_NO_TOKENS_AFTER_ASSERT_NAME

## 在括号之间缺少标记

在 `#assert` 指令中，谓词的括号内没有断言。 生成消息的代码示例：

    #assert system()

消息标识：E_ASSERT_NO_TKNS_BETWEEN_PARENS

## “#assert”缺少“)”

在 `#assert` 指令中，采用括号结构的断言缺少结束 )。 生成消息的代码示例：

    #assert system(unix

消息标识：E_ASSERT_MISSING_PAREN

## -A- 后的标记被忽略

在 `cc` 命令的 -A- 选项中，没有与该选项相邻的其它标记。这些标记被忽略。 生成消息的代码示例：

    cc -A-extra -c x.c

消息标识：E_TOKENS_AFTER_A_IGNORED

## -A 之后应该有标识符或“-”

`cc` 命令行参数 `-A` 之后必须跟要断言的谓词名称或要去掉所有预定义宏和谓词的 -。`-A` 之后的标记不是上面任何一种类型。 生成消息的代码示例：

    cc -A3b2 -c x.c

消息标识：E_IDENTIFIER_EXPECTED_AFTER_A

## “#”之后应该有标识符

编译器应该在条件编译指令中的 # 之后找到标识符和谓词名称，但未找到。 生成消息的代码示例：

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

消息标识：E_IDENT_EXPECTED_AFTER_POUND

## “# 标识符”之后应该有“(”

在 `#if` 或 `#elif` 指令中使用 # 运算符选择谓词而非命名 like 的宏时，该谓词之后必须跟加括号的标记列表。 生成消息的代码示例：

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

消息标识：E_PAREN_EXPECTED_AFTER_ID_PND

## “# 标识符 (”之后应该有标记

在 #`if` 或 #`elif` 指令中使用 # 运算符选择谓词而非命名 like 的宏时，该谓词之后必须跟加括号的标记列表。 生成消息的代码示例：

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

消息标识：E_TOKENS_EXPECTED_AFTER_ID_PND

## 在括号之间应有标记

在 #`if` 或 #`elif` 指令中，要测试的谓词断言名称被省略。 生成消息的代码示例：

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

消息标识：E_TKNS_EXPECTED_BETWEEN_PARENS

## 缺少“)”

在测试 `#if` 或 `#elif` 指令中 # 运算符之后的谓词时，缺少断言之后的 `)`。 生成消息的代码示例：

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

消息标识：E_MISSING_R_PAREN

## 空 #unassert 指令

`#unassert` 指令不包含要丢弃的谓词名称。 生成消息的代码示例：

    #unassert

消息标识：E_EMPTY_UNASSERT_DIRECTIVE

## #unassert 要求标识符标记

#`unassert` 指令必须将谓词命名为“未断言”。 生成消息的代码示例：

    #unassert 5

消息标识：E_UNASSERT_REQUIRES_IDENTIFIER

## “(”之后应该有标记

在 #`unassert` 指令中，缺少断言和谓词之后的结束 )。 生成消息的代码示例：

    #unassert system(

消息标识：E_TOKENS_EXPECTED_AFTER_L_PAREN

## 应该有“)”

在 `unassert` 指令中，必须给要丢弃的谓词断言加括号。 生成消息的代码示例：

    #unassert system(unix

消息标识：E_R_PAREN_EXPECTED

## 空谓词参数

编译器应该在 ( ) 之间找到标记。( ) 用于分隔 `#unassert` 指令中谓词的断言。但是，未找到任何标记。 生成消息的代码示例：

    #unassert machine()

消息标识：E_EMPTY_PREDICATE_ARGUMENT

## 第一个标识符之后应该有“(”

在 `#unassert` 指令中，必须给要丢弃的谓词断言加括号。 生成消息的代码示例：

    #unassert system unix

消息标识：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"

消息标识：E_CANT_REDEFINE_ANSI_PREDEFINE

## 无法定义“defined”

不能将预定义的预处理运算符“defined”定义为宏名称。 生成消息的代码示例：

    #define defined xyz

消息标识：E_CANNOT_DEFINE_DEFINED

## 取消定义 __STDC__

ANSI C 禁止取消定义预定义的符号 `__STDC__`。您可能需要使用该功能测试已经编写的 C 代码。这些代码可以同时在 ANSI C 和非 ANSI C 环境下运行。 例如，假定拥有可以检查 `__STDC__` 的 C 代码，同时声明函数原型声明（如果定义）和旧式函数声明或定义（如果未定义）。因为 C 编译器预定义了 `__STDC__`，所以在一般情况下，无法检查旧式代码，必须通过其它（非 ANSI C）编译器运行该代码。通常，在命令行中取消定义 `__STDC__` 之后，可以使用 C 编译器执行检查操作。该诊断信息说明，您违反了 ANSI C 的约束规定。 生成消息的代码示例：

    #undef __STDC__	/*通常，-U__STDC__位于 cc 行 */

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

消息标识：E_UNDEFINING__STDC__

## ANSI C 预定义的宏不能被取消定义

源代码包含尝试取消定义由 ANSI C 预定义的宏。 生成消息的代码示例：

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

消息标识：E_CANT_UNDEFINE_ANSI_PREDEFINE

## 无法取消定义“defined”

无法取消定义预定义的预处理运算符“defined”。 生成消息的代码示例：

    #undef defined

消息标识：E_CANT_UNDEFINE_DEFINED

## -D 选项参数不是标识符

`cc -D` 命令行选项之后必须跟标识符。 生成消息的代码示例：

    cc -D3b2 -c x.c

消息标识：E_D_OPT_ARG_NOT_AN_IDENTIFIER

## -D 选项参数后面没有跟“=”

如果 `cc` 命令的 `-D` 命令行选项中的标识符之后有任何标记，则这样的第一个标记必须是 =。 生成消息的代码示例：

    cc -DTWO+2 -c x.c

消息标识：E_D_OPT_NOT_FOLLOWED_BY_EQUAL

## -U 选项参数不是标识符

`cc -U` 命令行选项之后必须跟标识符。 生成消息的代码示例：

    cc -U3b2 -c x.c

消息标识：E_U_OPT_ARG_NOT_AN_IDENTIFIER

## “-U{identifier}”之后的标记被忽略

在包含 `-U` 选项的命令行中，要取消定义的宏名称之后有标记。 生成消息的代码示例：

    cc -Uunix,u3b2 -c x.c

消息标识：E_TOKENS_IGNORED_AFTER_U_OPT

## 空 #define 指令行

`#define` 指令缺少要定义的宏名称和其它所有标记。 生成消息的代码示例：

    #define

消息标识：E_EMPTY_POIND_DEFINE_DIRECTIVE

## #define 要求宏名称

`#define` 指令之后必须跟要定义的宏名称。 生成消息的代码示例：

    #define +3

消息标识：E_PND_DEF_REQUIRES_MACRO_NAME

## 不完整的 #define 宏参数列表

定义 function-like 参数时，编译器在 `#define` 指令所在的同一行中找不到 ) 字符。 生成消息的代码示例：

    #define mac(a

消息标识：E_INCOMPLETE_DEF_MACRO_PARAMS

## 宏参数中有语法错误

function-like 宏定义的宏参数列表的格式错误。该列表必须是以逗号分隔的标识符列表。 生成消息的代码示例：

    #define mac(a,b,) a b

消息标识：E_SYNTAX_ERROR_IN_MACRO_PARAMS

## 宏 #define 中的“#”或“##”用法错误

在宏定义中，`#` 或 `##` 运算符之后跟的是 `#` 或 `##` 运算符。 生成消息的代码示例：

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

消息标识：E_BAD_SHARP_OR_SHARPS_IN_MACRO

## 不能用“##”开始宏替换

## 运算符是二进制中缀运算符，所以不能是宏定义的宏替换列表中的第一个标记。 生成消息的代码示例：

    #define mac(s) ## s

消息标识：E_CANT_BEGIN_MACRO_WITH_SHARP

## #define 中的“#”后面跟非形式标识符

宏定义中 # 运算符之后的标识符必须是 function-like 宏的形式参数。 生成消息的代码示例：

    #define mac(a) "abc" # b

消息标识：E_NON_FORMAL_ID_FOLLOWS_SHARP

## 注释被“##”替换

使用 `-Xt` 选项显示该警告。该诊断信息指出，编译器将明显的并置视作 `##` 运算符。源代码应该予以更新，以便使用新的运算符。 生成消息的代码示例：

    #define PASTE(a,b) a/*GLUE*/b
    int PASTE(prefix,suffix) = 1; /* 创建“prefixsuffix” */

消息标识：E_COMMENT_REPLACED_BY_SHARPS

## 注释没有并置标记

使用 `-Xa` 和 `-Xc` 选项显示该警告。在 K&R C 的早期版本中，可以使用两个标记之间的注释将其并置于一个宏中，从而将其“粘贴”在一起。这种功能从未得到定义或保证。ANSI C 提供了定义明确的运算符 ##。该运算符的用途相同，应该予以使用。该诊断信息提示，提供的不是原来的功能。 生成消息的代码示例：

    #define PASTE(a,b) a/*GLUE*/b
    int PASTE(prefix,suffix) = 1; /* 未创建“prefixsuffix” */

消息标识：E_COMMENT_DOSNT_CONCAT_TOKENS

## 字符串文字内的宏替换

借助 K&R C 的早期版本，可以替换字符串文字中的形式参数值。该字符串文字是宏定义的一部分。ANSI C 不允许这样使用。 ANSI C 提供了一种完成相同任务的方法。“string-ize”运算符 # 可以将宏参数的标记转换成字符串文字，然后并置相邻的字符串文字。正确的结构如下：

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

生成消息的代码示例：

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

消息标识：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);

消息标识：E_MACRO_REPLACEMENT_CHAR_CONST

## 字符串文字内不能进行宏替换

使用 `-Xa` 或 `-Xc` 选项显示该警告。该警告提示，在 -Xt 模式下完成的宏替换尚未在 `-Xa` 或 `-Xc` 模式下完成。

消息标识：E_NO_REPLACEMENT_IN_STRING

## 在字符常量内不能进行宏替换

使用 `-Xa` 或 `-Xc` 选项显示该警告。该警告提示，在 -Xt 模式下完成的宏替换尚未在 `-Xa` 或 `-Xt` 模式下完成。

消息标识：E_NO_REPLACEMENT_IN_CHAR_CONST

## #define 中“#”后面必须跟形式标识符

“string-ize”运算符 # 之后必须跟 function-like 宏中的形式参数名称。 生成消息的代码示例：

    #define mac(a) # + a

消息标识：E_ID_REQUIRED_FOR_POUND_DEFINE

## 宏替换结尾不能用“#”或“##”

# 或 ## 运算符不能是宏定义的宏替换列表中的最后一个标记。 生成消息的代码示例：

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

消息标识：E_CANT_END_MACRO_WITH_SHARP

## 空 #undef 指令，需要标识符

`#undef` 指令缺少要“取消定义”的宏名称。 生成消息的代码示例：

    #undef

消息标识：E_EMPTY_UNDEF_DIRECTIVE

## #undef 后面应为标识符

`#undef` 之后必须跟要取消定义的宏名称。指令后面的标记不是标识符。 生成消息的代码示例：

    #undef 4

消息标识：E_ID_EXPECTED_AFTER_UNDEF

## 标记在指令行的结尾被忽略

指令行包含多余的标记。这些标记不应该是该指令的一部分。 生成消息的代码示例：

    #undef a b	/* 只能取消定义一个 */

消息标识：E_TKNS_IGNORED_AT_END_OF_DIR

## 应为数字

编译器应该在 `#if` 或 `#elif` 指令中找到一个数字，但该编译器无法找到。 生成消息的代码示例：

    #if 1 +
    	int i = 1;
    #endif

消息标识：E_NUMBER_EXPECTED

## 缺少操作符

预处理条件编译指令的常量表达式格式错误。应该有运算符，但未遇到。 生成消息的代码示例：

    #if 1 4
    	int i = 1;
    #endif

消息标识：E_MISSING_OPERATOR

## 不应该有“)”

在 #`if` 或 #`elif` 指令中已检测到位置错误的 )。 生成消息的代码示例：

    #if ) 1
    	int i = 1;
    #endif

消息标识：E_UNEXPECTED_R_PAREN

## 不应该有“(”

在 #`if` 或 #`elif` 指令中已检测到位置错误的 (。 生成消息的代码示例：

    #if 1 (
    int i = 1;
    #endif

消息标识：E_UNEXPECTED_L_PAREN

## 缺少操作数

预处理条件编译指令的常量表达式格式错误。缺少某个运算符必需的操作数。 生成消息的代码示例：

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

消息标识：E_MISSING_OPERAND

## 除以 0

表达式包含编译时检测到的除以零的运算。如果除法是 `#if` 或 `#elif` 指令的一部分，则结果为零。如果除法运算位于可执行代码中，则诊断信息是警告；如果表达式位于全局或`静态`初始化程序中，则诊断信息是错误。 生成消息的代码示例：

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

消息标识：E_DIVISION_BY_ZERO

## 以 0 为模数

`%` 运算符的第二个操作数是零。如果模数运算是 `#if` 或 `#elif` 指令的一部分，则结果为零。 如果模数运算位于可执行代码中，则诊断信息是警告；如果表达式位于全局或`静态`初始化程序中，则诊断信息是错误。 生成消息的代码示例：

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

消息标识：E_MODULUS_BY_ZERO

## 可疑的换码：\c

只有某些字符才能跟在字符串文字和字符常量中的 \ 之后；`c` 不属于其中的一个字符。ANSI C 会忽略该 \。 生成消息的代码示例：

    int i = '\c';

消息标识：E_DUBIOUS_ESCAPE_CHAR

## 可疑的换码

只有某些非打印的字符才能跟在字符串文字和字符常量中的 \ 之后。在诊断信息中，尖括号内的值是作为十六进制数字打印的字符代码。

消息标识：E_DUBIOUS_ESCAPE_UNPRINTABLE

## \a 是 ANSI C“警报”字符

使用 `-Xt` 选项显示该警告。在其它 K&R C 编译器中，‘\a’等价于‘a’。但是，ANSI C 可以将‘\a’定义为警告字符。在这种执行过程中，相应的字符代码是 07，即 BEL 字符。 生成消息的代码示例：

    int c = '\a';

消息标识：E_ESC_A_IS_ANSI_ALERT

## \x 是 ANSI C 十六进制换码

指定 -Xs 或 -Xt 编译模式时，该编译器会将“\x”视为字符“x”。ANSI C 编译模式（-Xa 和 -Xc）除外

    "\x<hexadecimal-digits>"

制度十六进制换码序列。 使用 -Xs 选项编译时生成消息的代码示例：

    char *cp = "This is a hex escape sequence for 254:\xfe";

消息标识：E_ESC_X_IS_ANSI_HEX_ESCAPE

## \x 后面没有跟十六进制数字

使用 `-Xa` 或 `-Xc` 选项显示该警告。字符常量和字符串文字中的 \x 换码说明了十六进制的字符换码。\x 之后必须至少跟一个十六进制的数字。 生成消息的代码示例：

    char *cp = "&\xz";

消息标识：E_NO_HEX_DIGITS_AFTER_ESCAPE_X

## 十六进制换码中出现溢出

在字符常量或字符串文字的十六进制换码 (`\x`) 中，该换码的累计值增加得过大。只能保留低位 32 位值。 生成消息的代码示例：

    int i = '\xabcdefedc';

消息标识：E_OVERFLOW_IN_HEX_ESCAPE

## 空字符常量

已经使用不包含字符的字符常量。 生成消息的代码示例：

    f(void) {

    char c = '';    /* 建议：char c = ' ';      */
    }

消息标识：E_EMPTY_CHAR_CONSTANT

## 字符常量太长

字符常量包含的字符太多，无法适合于整数。只能使用正则字符常量的前四个字符和宽字符常量的第一个字符。长度超过一个字符的字符常量无法进行移植。 生成消息的代码示例：

    int i = 'abcde';

消息标识：E_CHAR_CONST_TOO_LONG

## 无效多字节字符

在主机环境中，字符串文字或字符常量中的多字节字符无法转换成单个宽字符。否则，会忽略别处找到的多字节字符。

消息标识：E_INVALID_MULTIBYTE_CHAR

## 字符换码不适合于字符

在字符常量或字符串文字中，十六进制或八进制换码序列生成的值太大，不适合于`无符合 char`。为了适合，要截断该值。 生成消息的代码示例：

    char *p = "\x1ff\400";

消息标识：E_CHAR_ESC_DOES_NO_FIT_IN_CHAR

## 八进制数字错误

使用 `-Xt` 选项显示该警告。以 0 开头的整型常量包含一个非八进制数字。如果要获取值 8，则要使用 8；如果要获取值 9，则要使用值 9。即便这些值无效，也是如此。 生成消息的代码示例：

    int i = 08;

消息标识：E_BAD_OCTAL_DIGIT

## 括号不匹配

预处理条件编译指令中的括号不匹配。 生成消息的代码示例：

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

消息标识：E_MISMATCHED_PARENS

## “?”和“:”不匹配

`#if` 或 `#elif` 指令中的表达式包含格式错误的 `?~:`表达式。 生成消息的代码示例：

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

消息标识：E_MISMATCHED_TERNARY_OP

## 进行宏扩展后常量表达式为空

`#if` 或 `#elif` 指令包含扩展宏后的表达式，但不包含标记。 生成消息的代码示例：

    #define EMPTY
    #if EMPTY
    	char *mesg = "EMPTY is non-empty";
    #endif

消息标识：E_EMPTY_CONST_EXP_AFTER_EXPAND

## 预处理程序：无法复制标准输出

在编译器访问标准输出 (stdout) 时发生文件系统错误。

消息标识：E_CANT_DUP_STDOUT

## 预处理程序：无法打开替代的标准输出

在编译器访问标准输出 (stdout) 时发生文件系统错误。

消息标识：E_CANT_OPEN_ALT_STDOUT

## 预处理程序：无法打开 /dev/null

在编译器访问 /dev/null. 时发生文件系统错误。

消息标识：E_CANT_OPEN_DEV_NULL

## 临时文件写入失败：文件系统已满

写入中间文件时，编译器用完了磁盘空间。请在开始编译之前验证写入临时文件的文件系统是否具有足够的可用空间。使用 `TMPDIR` 环境变量指定替代的位置，以便于编译器写入临时文件。

消息标识：E_TMPFILE_FILE_SYSTEM_FULL

## 取消定义或缺少类型

在函数定义中，已经使用无效的类型信息声明参数。已经将尚未定义的类型或无法表示类型的标识符用作类型。通常，遇到语法错误消息之后，会发出该警告。 生成消息的代码示例：

    int f1(what arg)
    {
    }

消息标识：E_UNDEFINED_OR_MISSING_TYPE

## 语法错误，位于或在其之前：

这是全面的诊断信息，它指出了编译器找到的任何一种可能出现的语法错误，其中包括缺少分号、缺少结束圆括号或大括号，或语言标记并置。诊断信息中的标记指出该编译器找到的错误位于源代码的位置点和指定的行。 生成消息的代码示例：

    f(void){
    	int i = 3	/* 此处缺少分号 */
    }

    f(int i){
    	int j;

    	j = (i + 24;	/* 此处缺少结束圆括号 */
    }

消息标识：E_YACC_GENERIC_ERROR

## 语法错误，位于或在其之前：

这是全面的诊断信息，它指出了编译器找到的任何一种可能出现的语法错误，其中包括缺少分号、缺少结束圆括号或大括号，或语言标记并置。诊断信息中的标记指出该编译器找到的错误位于源代码的位置点和指定的行。 生成消息的代码示例：

    f(void){
    	int i = 3	/* 此处缺少分号 */
    }

    f(int i){
    	int j;

    	j = (i + 24;	/* 此处缺少结束圆括号 */
    }

消息标识：E_YACC_ERROR

## 通过“void”指针的访问被忽略

无法使用指向 `void` 的指针访问对象。源代码包含表达式。该表达式可以通过指向 `void` 的指针（可能限定）进行间接引用。虽然支持表达式的其余部分（如果有），但是会忽略该间接引用。 生成消息的代码示例：

    f(void){
    	volatile void *vp1, *vp2;
    	*(vp1 = vp2);/* 赋值完成 */
    }

消息标识：E_ACCESS_VIA_VOID_PTR_IGNORED

## switch 条件重复

当前具有相同常量值的 `switch` 语句包含两个 case 语句。 生成消息的代码示例：

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

消息标识：E_DUP_CASE_IN_SWITCH_L

## switch 条件重复

当前具有相同常量值的 `switch` 语句包含两个 case 语句。 生成消息的代码示例：

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

消息标识：E_DUP_CASE_IN_SWITCH

## asm 语句在函数外属于非法

asm 语句只能出现在函数主体内，而不能出现在外部声明层。 生成消息的代码示例：

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

消息标识：E_ASM_ILLEGAL_OUTSIDE_FUNC

## asm() 参数必须是标准字符串文字

旧式 `asm()` 的参数必须是标准字符串文字，而不是宽字符。 生成消息的代码示例：

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

消息标识：E_ASM_ARG_MUST_BE_STRING

## asm() 中不允许嵌入的 NUL

旧式 `asm`( ) 中出现的字符串文字包含嵌入的 `NUL` 字符（字符代码为 0）。 生成消息的代码示例：

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

消息标识：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");
    }

消息标识：E_ASM_DISABLES_OPTIMIZATION

## 空转换单元

预处理完成之后，源文本中没有标记。ANSI C 标准要求该编译器诊断没有标记的文件。 生成消息的代码示例：

    #ifdef COMPILE
    	int token;
    #endif

消息标识：E_EMPTY_TRANSLATION_UNIT

## 忽略指向锁定的简单指针

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;
    }

消息标识：E_LOCK_FUNC_IGNORES_PTR

## ?: 正在使用运算符选择函数的锁定参数

如果调用函数时使用`?:` 运算符，则 lock_lint 对源代码所做的静态分析无法确定正传递给该函数的参数。该消息指出，传递给该函数的是 lock_lint 要假设的值。 生成消息的代码示例：

    mutex_t mutex1;
    mutex_t mutex2;

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

消息标识：E_CONDITIONAL_OP_LOCK_CHOICE

## 将假设该调用继续获得锁定

lock_lint 所做的静态源代码分析将假设，指定的函数继续获得锁定。 生成消息的代码示例：

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

消息标识：E_ASSUME_SUCCESSFUL_LOCK

## ?: 正在使用操作符选择函数的条件变量参数；lock_lint 将假设已选择条件变量

如果调用函数时使用 ?:运算符，则 lock_lint 对源代码所做的静态分析无法确定正传递给该函数的参数。lock_lint 所做的静态源代码分析将假设，作为参数传递给指定的函数的锁骨指定的条件变量。 生成该消息的代码示例：

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

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

消息标识：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);

消息标识：E_CV_FUNC_IGNORES_SIMPLE_PTR

## 函数需要两个参数

该函数需要两个参数。尚未指定第二个互斥参数。 生成消息的代码示例：

    	kcondvar_t cvp;
    	cv_wait(&cvp);

    /*======================
    ** 正确代码应该是：
    */
    	kcondvar_t cvp;
    	kmutex_t mp;
    	cv_wait(&cvp, &mp);

消息标识：E_SECOND_MUTEX_MISSING

## 操作数不能是 void 类型

操作数之一具有 `void` 类型。 生成消息的代码示例：

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

消息标识：E_OPERAND_CANT_BE_VOID_TYPE

## 在两个字符赋值操作符之间有空白

-Xs 允许两个字符赋值运算符之间有空白。字符赋值运算符包括：

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

但是，其它所有编译器不允许这些运算符之间有空白。 生成消息的代码示例：

    	int i + = 1;        /* 对于运算符： +=   */
    	int k - = 1;

消息标识：E_WHITESPACE_IN_CHAR_ASSIGN_OPS

## ANSI C 将常量视为无符号类型

对于 ANSI C 和早期版本的 K&R C，它们的类型提升规则略有不同。在当前版本中，缺省功能是复制以前的规则。使用`compiler` 命令中的 `-Xa` 选项，可以获得 ANSI C 解释。 以前的 K&R C 类型提升规则保留为`无符号`类型。如果表达式操作数之一属于`无符号`类型，则执行运算之前，该操作数要提升为常见的`无符号`类型。 ANSI C 使用保留值类型提升规则。如果其所有值都可以`带符号`类型表示，则`无符号`类型可以提升为`带符号`类型。 另外，对于隐式设置`符号`位的整型常量类型，ANSI C 和早期版本的 K&R C 的规则有所不同。 由于类型提升规则不同，所以运算符的程序功能也不尽相同。这些运算符受其操作数的“`unsigned`-ness”的影响：

    o 除法运算符：       /, /=, %, %=
    o 向右移动运算符：    >>, >>=
    o 关系型运算符：     <, <=, >, >=

警告消息指出，程序包含其中的运算符功能在未来将会发生更改的表达式。通过在该表达式中插入显式转换，可以为该功能提供保证。 生成消息的代码示例：

    f(void){
    	int i;
    	/* 常量是 K&R C 中的整数，是 ANSI C 中的无符号类型 */
    	i /= 0xf0000000;
    }

消息标识：E_ANSI_CONST_UNSIGNED_OP

## 运算符的语义在 ANSI C 中发生更改；使用显式转换

对于 ANSI C 和早期版本的 K&R C，它们的类型提升规则略有不同。在当前版本中，缺省功能是复制以前的规则。使用 `cc` 命令中的 `-Xa` 选项，可以获得 ANSI C 解释。 以前的 K&R C 类型提升规则保留为`无符号`类型。如果表达式操作数之一属于`无符号`类型，则执行运算之前，该操作数要提升为常见的`无符号`类型。 ANSI C 使用保留值类型提升规则。如果其所有值都可以`带符号`类型表示，则`无符号`类型可以提升为`带符号`类型。 由于类型提升规则不同，所以运算符的程序功能也不尽相同。这些运算符受其操作数的“`unsigned`-ness”的影响：

    o 除法运算符：       /, /=, %, %=
    o 向右移动运算符：    >>, >>=
    o 关系型运算符：     <, <=, >, >=

警告消息指出，程序包含其中的运算符功能在未来将会发生更改的表达式。通过在该表达式中插入显式转换，可以为该功能提供保证，如下所述：

    f(void){
    	unsigned char uc;
    	int i;
    	/* 是 K&R C 中的无符号除法，是 ANSI C 中的带符号除法 */
    	i /= (unsigned int) uc;
    }

生成消息的代码示例：

    f(void){
    	unsigned char uc;
    	int i;
    	/* 是 K&R C 中的无符号除法，是 ANSI C 中的带符号除法 */
    	i /= uc;
    }

消息标识：E_SEMANTICS_OF_OP_CHG_IN_ANSI_C

## 整型常量太大

整型常量太大，无法适合于`无符号 long` 类型。 生成消息的代码示例：

    int i = 123456789012345678901;

消息标识：E_INTEGRAL_CONSTANT_TOO_LARGE

## 常量被提升到无符号整型

加后缀的常量太大，无法适合于后缀 Hence 指定的类型，所以将其提升为无符号整型。

消息标识：E_CONST_PROMOTED_UNSIGNED_INT

## 常量被提升到无符号长型

加后缀的常量太大，无法适合于后缀 Hence 指定的类型，所以将其提升为无符号的 long 类型。

消息标识：E_CONST_PROMOTED_UNSIGNED_LONG

## 常量被提升到无符号 long long

使用 `-v` 选项显示该警告。加后缀的常量太大，无法适合于该后缀指定的类型，所以将其提升为 `long long` 或`无符号 long long` 类型。 生成消息的代码示例：

    if (9223372036854775807L > 0)  printf("promoted\n");
    if (9223372036854775807UL > 0)  printf("promoted\n");

消息标识：E_CONST_PROMOTED_UNSIGNED_LL

## 常量被提升到长型

加后缀的常量太大，无法适合于后缀 Hence 指定的类型，所以将其提升为 long 类型。

消息标识：E_CONST_PROMOTED_LONG

## 常量被提升到 long long

使用 `-v` 选项显示该警告。加后缀的常量太大，无法适合于该后缀指定的类型，所以将其提升为 `long long` 或`无符号 long long` 类型。 生成消息的代码示例：

    if (9223372036854775807L > 0)  printf("promoted\n");
    if (9223372036854775807UL > 0)  printf("promoted\n");

消息标识：E_CONST_PROMOTED_LONG_LONG

## 浮点常量到浮点型的转换溢出

浮点常量值太大，无法适合于浮点类型。 生成消息的代码示例：

    float f = 1e300f;

消息标识：E_CONV_CONST_FP_FLOAT_OUT_RANGE

## 浮点常量到双精度长型的转换溢出

浮点常量值太大，无法适合于 long 双精度类型。

消息标识：E_CNV_CNST_FP_LONG_DBL_OUTRANGE

## 浮点常量到双精度型的转换溢出

浮点常量值太大，无法适合于双精度类型。

消息标识：E_CONV_CONST_FP_DBL_OUT_RANGE

## 语法错误："&..." 无效

如果使用 `-Xc` 选项时出现错误，将会显示该消息。程序包含 &...，它是使用 `-Xc` 选项编译的。&... 是无效的 ANSI C 语法。请不要显式使用这种表示法。

消息标识：E_AND_DOT_DOT_DOT_INVALID

## 应为整型常量表达式

编译器需要整型常量或可以在编译时求值以生成整数值的表达式。该表达式包含非整型值、指向对象的引用，或在编译时无法求值的运算符。 生成消息的代码示例：

    int ia[5.0];

消息标识：E_INTEGRAL_CONST_EXP_EXPECTED

## 成员使用不正确

程序包含使用 -> 或 . 运算符的表达式，名称不是运算符左侧引用的结构或联合成员，但是其它一些结构或联合的成员。 如果成员不“唯一”，则该诊断信息是错误。唯一成员是一个或多个结构或联合的一部分，但它与结构或联合中的所有成员具有相同的类型和偏移。 生成消息的代码示例：

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

消息标识：E_IMPROPER_MEMBER_USE

## 取消定义结构/联合成员

程序引用的是尚未声明为任何结构的一部分的结构或联合成员。 生成消息的代码示例：

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

消息标识：E_UNDEFINED_STRUCT_UNION_MEMBER

## 非唯一成员需要结构/联合指针

-> 运算符的左操作数不是结构、联合或指向一个对象的指针，所以该成员名称在已经声明的所有结构和联合成员中不是唯一的。结构或联合只能使用 ->，所以该成员应该是与左操作数对应的结构或联合成员。

消息标识：E_NON_UNIQUE_REQRS_S_U_PTR

## 非唯一成员需要结构/联合对象

. 运算符的左操作数不是结构、联合或指向一个对象的指针，所以该成员名称在已经声明的所有结构和联合成员中不是唯一的。结构或联合只能使用 .。该成员应该是 与左操作数对应的结构或联合成员。 生成消息的代码示例：

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

消息标识：E_NON_UNIQUE_REQRS_S_U_OBJ

## 隐式声明函数返回 int

使用 `-v` 选项显示该警告。该程序调用以前未声明的函数。编译器提示，该程序假设函数返回 `int`。 生成消息的代码示例：

    void v(void){
    	g();
    }

消息标识：E_IMPLICIT_DECL_FUNC_RETURN_INT

## 取消定义符号

已经引用作用域内没有声明的符号。 生成消息的代码示例：

    f(void){
    g(i);
    }

消息标识：E_UNDEFINED_SYMBOL

## 使用了超出作用域的声明

以前声明对象的作用域不再处于活动状态。在某些 ANSI C 执行中，引用对象时会产生错误；调用这种函数可以解释为调用返回 `int` 的函数。C 编译器可以记住并使用以前的声明。该警告会提示您编译器已经完成的任务。 生成消息的代码示例：

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

消息标识：E_USING_OUT_OF_SCOPE_DECL

## 不能使用 sizeof 函数

不能对函数应用 `sizeof` 运算符。 生成消息的代码示例：

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

消息标识：E_CANT_TAKE_SIZEOF_FUNC

## 不能使用 sizeof 函数

不能对函数应用 `sizeof` 运算符。 生成消息的代码示例：

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

消息标识：E_CANT_TAKE_SIZEOF_FUNC_N

## 不能使用 sizeof void

不能将 `sizeof` 运算符应用于 `void` 类型。 生成消息的代码示例：

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

消息标识：E_CANT_TAKE_SIZEOF_VOID

## 不能使用 sizeof 位字段

不能对位字段应用 `sizeof` 运算符。 生成消息的代码示例：

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

消息标识：E_CANT_TAKE_SIZEOF_BIT_FIELD

## 操作数具有不兼容类型

对于某个操作数，操作数类型不适合于这种操作数。 生成消息的代码示例：

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

消息标识：E_OPERANDS_INCOMPATIBLE_TYPES

## 第一个操作数必须具有标量类型：op“?:”

`?:` 表达式中的条件表达式必须具有标量类型：整型、浮点或指针。 生成消息的代码示例：

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

消息标识：E_FIRST_OPERAND_SCALAR_TYPE

## “.”的左操作数必须是结构/联合对象

只有 . 运算符，才能应用于结构或联合对象。如果左侧操作数是数组、指针、函数调用、枚举常量或变量或分配给寄存器的寄存器值，则诊断信息是错误；否则是警告。 生成消息的代码示例：

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

消息标识：E_DOT_L_OPERAND_NOT_STRUCT_U

## 无法访问非结构/联合对象的成员

. 运算符的左侧操作数内必须完全包含结构或联合成员。 生成消息的代码示例：

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

消息标识：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;
    /* newS 是结构，而不是指向该结构的指针 */
    }

消息标识：E_LEFT_MUST_BE_PTR_TO_STRUCT_U

## 操作数必须具有整数类型

运算符使用的操作数必须是整数类型（`short、int 和 long` 等），但不是，例如使用的是结构。 生成消息的代码示例：

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

消息标识：E_OPERAND_MUST_BE_INTEGRAL_TYPE

## 操作数必须具有运算类型

一元 `- 和 +` 运算符的操作数必须属于运算类型。 生成消息的代码示例：

    struct Astr {
    	int a;
    	int b;
    }
    g(void) {
    	struct Astr l;
    	int k = l * 2;   /* l 是结构 struct Astr，不属于运算类型 */
    	l = -l;		 /* l 是一元“-”或“+”的操作数 */
    	l = +l;		 /* 但 l 不属于运算类型     */
    }

消息标识：E_OPERAND_MUST_BE_ARITH_TYPE

## 操作数必须具有标量类型

一元“!”运算符的操作数必须具有标量类型。或者，使用运算符“++”或“--”的代码应该是标量类型。 生成消息的代码示例：

    struct aStr{
    	int a;
    	int b;
    };
    g(void) {
    	struct aStr newStr;
    	newStr++;               /* 一元 ++ 运算符的操作数必须是标量类型 */
    	newStr.a++;             /* 这是正确的 */
    }

消息标识：E_OPERAND_MUST_BE_SCALAR_TYPE

## 无法在未知大小的操作数上执行指针运算

表达式包含指向大小未知的对象指针的指针运算。 生成消息的代码示例：

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

消息标识：E_PTR_ARITH_MUST_KNOW_SIZE

## 不正确的指针减法

减法的操作数都是指针，但这两个操作数指向不同的类型。只能对指向相同数组的同类指针执行减法运算。 如果指针指向大小相同的对象，则诊断信息是警告，否则是错误。 生成消息的代码示例：

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

消息标识：E_BAD_POINTER_SUBTRACTION

## 函数指示器不是函数类型

表达式在函数调用中的使用方式与函数或指向函数的指针（如果不是函数）的名称相同。 生成消息的代码示例：

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

消息标识：E_FUNC_DESIGNATOR_NOT_FUNC_TYPE

## 原型不匹配：传递了 n 个参数，应该传递 m 个参数

已经调用作用域内有函数原型声明的函数。另外，调用时所用的参数数目与声明中的参数数目 n 不匹配。 生成消息的代码示例：

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

消息标识：E_PROTOTYPE_MISMATCH_ARGS

## 原型不匹配：传递了 n 个参数，应该传递 m 个参数

已经调用作用域内有函数原型声明的函数。另外，调用时所用的参数数目与声明中的参数数目 n 不匹配。

消息标识：E_PROTOTYPE_MISMATCH_ARG

## 参数不匹配：传递了 n 个参数，应该传递 m 个参数

使用 `-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 应该有一个参数 */
    }

消息标识：E_ARGS_MISMATCH

## 参数不匹配：传递了 n 个参数，应该传递 m 个参数

使用 `-v` 选项显示该警告。调用函数时，编译器已经确定，传递给函数的参数数目与有关该函数的其它信息不符。其他信息来自于两个来源：旧样式（非原型）函数定义或函数原型声明已经超出范围，但是其类型信息将被记住。 如果旧样式函数定义情况适用，并且该函数采用不同参数数目，则该诊断可能有误。

消息标识：E_ARG_MISMATCH

## 无法返回不完整的类型

调用返回结构或联合的函数时，该结构或联合的完整声明必须已经显示。否则，会发出该消息。 生成消息的代码示例：

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

消息标识：E_CANT_RETURN_INCOMPLETE_TYPE

## void 表达式不能是参数

函数调用包含表达式类型为 `void` 的参数。 生成消息的代码示例：

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

消息标识：E_VOID_EXP_MAY_NOT_BE_ARGS

## 参数不能具有未知大小

调用函数时所用的参数必须具有完整的类型。已经传递的`结构、联合`或`枚举`对象的类型不完整。 生成消息的代码示例：

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

消息标识：E_ARG_CANT_BE_UNKNOWN_SIZE

## 参数与原型不兼容

对于已经调用的函数，其参数类型无法转换成该函数的函数原型声明中的类型。 生成消息的代码示例：

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

消息标识：E_ARG_INCOMPATIBLE_WITH_ARG

## 赋值类型不匹配

赋值运算的操作数类型不兼容。如果类型是不匹配的指针类型，则消息是警告。否则，消息是错误。 生成消息的代码示例：

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

消息标识：E_ASSIGNMENT_TYPE_MISMATCH

## 无效的类型转换表达式

无法对表达式应用类型转换，因为类型不适合于类型转换。正在进行类型转换的表达式类型和已发生类型转换的表达式类型必须具有标量类型。指针只能转换为整数类型或从整数类型进行转换。 生成消息的代码示例：

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

消息标识：E_INVALID_CAST_EXPRESSION

## 返回值类型不匹配

正在尝试从无法转换成该函数的返回类型的函数返回一个值。 生成消息的代码示例：

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

消息标识：E_RETURN_VALUE_TYPE_MISMATCH

## 初始化类型不匹配

正在使用类型不兼容的初始化程序初始化变量。例如，正在初始化指针，使其指向不同类型的对象。 生成消息的代码示例：

    struct s { int x; int y; };
    const int i = 10;
    int *j = &i;               /* <====== 类型不匹配 */
    struct s *foo = j;         /* <====== 类型不匹配 */

消息标识：E_INITIALIZATION_TYPE_MISMATCH

## 无效的 switch 表达式类型

`switch` 语句的控制表达式不能转换为 `int`。该消息跟在 `switch 表达式必须具有整数类型`这则消息之后。 生成消息的代码示例：

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

消息标识：E_INVALID_SWITCH_EXP_TYPE

## 参数与记住的类型不匹配

使用 `-v` 选项显示该警告。调用函数时，编译器已经确定，传递给函数的参数类型与有关该函数的其它信息不符。其他信息来自于两个来源：旧样式（非原型）函数定义或函数原型声明已经超出范围，但是其类型信息将被记住。 可疑的参数是根据缺省的参数提升规则提升的。如果旧样式函数定义情况适用，并且该函数采用不同参数数目，则该诊断可能有误。 生成消息的代码示例：

    void f(i)
    int i;
    { }

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

消息标识：E_ARG_NOT_MATCH_REMEMBERED_TYPE

## 无法获取位字段的地址

无法获取结构或联合的位字段成员地址。 生成消息的代码示例：

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

消息标识：E_CANT_TAKE_ADDRESS_BIT_FIELD

## 无法获取寄存器的地址

已经尝试获取使用寄存器存储类声明的对象地址。无论编译器是否为寄存器真正分配该对象，都不能这样做。尝试获取对象地址可能是隐式的，例如在非关联化数组的时候。如果已为对象分配了寄存器，则诊断信息是错误，否则是警告。 生成消息的代码示例：

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

消息标识：E_CANT_TAKE_ADDRESS_REGISTER

## 一元 & 不可接受的操作数

已经尝试获取无法获取其地址的对象地址。 生成消息的代码示例：

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

消息标识：E_BAD_OPERAND_FOR_UNARY_AND

## 不能非关联化非指针类型

*（指针非关联化）的操作数必须具有指针类型。另外，遇到指向非数组的数组引用时，会发出该诊断信息。 生成消息的代码示例：

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

消息标识：E_CANT_DEREF_NON_POINTER_TYPE

## 控制表达式必须具有标量类型

`if、for、while` 或 `do-while` 的表达式必须具有整数、浮点或指针类型。 生成消息的代码示例：

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

消息标识：E_CNTRL_EXP_MUST_BE_SCALAR_TYPE

## 类型转换不产生左值

无法对包含赋值运算中要更改的对象操作数应用类型转换。如果操作数类型的大小与正在发生类型转换的类型大小相同，则诊断信息是警告，否则是错误。 生成消息的代码示例：

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

消息标识：E_CAST_DOESNT_YIELD_LVALUE

## 操作数必须是可修改的左值

运算符的操作数必须是可修改的`左值`，但它不是。 生成消息的代码示例：

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

消息标识：E_OPERAND_NOT_MODIFIABLE_LVALUE

## 左操作数必须是可修改的左值

运算符的左操作数不是可修改的`左值`；它必须是一个可修改的左值。 生成消息的代码示例：

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

消息标识：E_L_OPERAND_NOT_MODIFIABLE_LVAL

## 对 void 表达式进行不正确的类型转换

不能将 `void` 表达式转换成 `void` 之外的类型。 生成消息的代码示例：

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

消息标识：E_BAD_CAST_OF_VOID_EXP

## enum 类型不匹配：参数

使用 `-v` 选项显示该警告。程序正在向作用域内原型声明的函数传递枚举常量或对象。传递的参数与函数原型中的一个参数具有不同的枚举类型，这表明存在编程错误。 生成消息的代码示例：

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

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

消息标识：E_ENUM_TYPE_MISMATCH_ARG

## enum 类型不匹配：op

运算符的一个操作数是枚举对象或常量，另一个操作数是来自不同枚举类型的枚举对象或常量。 生成消息的代码示例：

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

消息标识：E_ENUM_TYPE_MISMATCH_OP

## void 函数不能返回值

`return` 语句包含一个表达式，但是该函数的声明类型不是 `void`。 生成消息的代码示例：

    void v(void){
    return 3;
    }

消息标识：E_VOID_CANT_RETURN_VALUE

## 无法内存分配 ND1 树空间

编译器内部使用 malloc() 失败。这通常是由于运行超出交换空间造成的。

消息标识：E_CANT_MALLOC_ND1_TREE

## 操作数大小未知

已经对大小未知的操作数应用运算符 ++、-- 或 =。通常，该操作数是指向尚未声明成员的结构或联合的指针。 生成消息的代码示例：

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

消息标识：E_UNKNOWN_OPERAND_SIZE

## 枚举常量具有不同类型

使用 `-v` 选项显示该警告。已经使用关系型运算符比较来自两个不同枚举类型中的枚举常量。这表明存在编程错误。编译时的比较作用是既知的，因为常量值是既知的。 生成消息的代码示例：

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

消息标识：E_ENUM_CONSTS_HAVE_DIFF_TYPES

## 操作数具有不兼容的指针类型

已经对指向不同类型的指针应用运算符。 生成消息的代码示例：

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

消息标识：E_OPERANDS_INCOMPAT_PTR_TYPES

## 指针/整型组合不正确

运算符的一个操作数是指针，而另一个是整数；这种组合是无效的。 生成消息的代码示例：

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

消息标识：E_BAD_PTR_INT_COMBINATION

## 指针/整型组合不正确

在作用域内有函数原型声明的函数调用期间，代码传递的是应该为指针的整数，反之亦然。 生成消息的代码示例：

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

消息标识：E_BAD_PTR_INT_COMB_ARG

## 在 Xc 模式下不允许 long long

long long int 和无符号的 long long int 不是标准的 C 类型，所以在使用 -Xc 选项时不可用。

消息标识：E_LONG_LONG_NOT_ALLOWED_XC

## 无效类型组合

已经在声明中使用类型说明符的错误组合。 生成消息的代码示例：

    short float f;

消息标识：E_INVALID_TYPE_COMBINATION

## 类型后的存储类将被废弃

使用 `-v` 选项显示该警告。根据 ANSI C 标准，编写其中的存储类说明符不是第一个说明符的声明是一个废弃特征。 生成消息的代码示例：

    int static i;

消息标识：E_TYP_STORAGE_CLASS_OBSOLESCENT

## 只允许一个存储类

已经在声明中指定多个存储类。 生成消息的代码示例：

    f(void){
    register auto i;
    }

消息标识：E_ONLY_ONE_STORAGE_CLASS_ALLOWD

## 此处使用 auto/register 不合适

任何函数之外的声明都具有存储类 `auto` 或 `register`。 生成消息的代码示例：

    auto int i;
    f(void){
    }

消息标识：E_AUTO_REG_INAPPROPRIATE_HERE

## 只有作为形式参数存储类“register”时才有效

可以在函数原型声明中指定存储类说明符，但只允许指定 `register`。 生成消息的代码示例：

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

消息标识：E_ONLY_REG_VALID_FORMAL_PARAM

## 忽略对 typedef 的修改

在 ANSI C 中，使用类型限定符修改 `typedef`。 生成消息的代码示例：

    typedef int INT;
    unsigned INT i

消息标识：E_MODIFY_TYPEDEF_IGNORED

## 已经限定 typedef

类型说明符包括 `typedef` 和显式类型限定符。声明限定符时，该 `typedef` 已经包括该限定符。 生成消息的代码示例：

    typedef volatile int VOL;
    volatile VOL v;

消息标识：E_TYPE_DEF_ALREADY_QUALIFIED

## 指向 typedef 的引用可疑

函数原型声明使用名称引用`联合、结构`或`枚举 typedef`。因为已经在函数中声明`结构、联合`或`枚举`，所以定义正在声明其原型的函数时，它不能位于作用域中。因此，原型声明和函数定义不符。 生成消息的代码示例：

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

消息标识：E_DUBIOUS_REF_TYPEDEF

## 使用“双精度”代替“long 浮点型”

已经将对象或函数声明为 `long 浮点`类型，即`双精度`的同义词。ANSI C 不允许使用 `long 浮点`类型，即便 C 编译器将其作为转换工具予以接受。 生成消息的代码示例：

    long float f = 1.0;

消息标识：E_USE_DOUBLE_INSTEAD_LONG_FLOAT

## * 之后只允许限定符

只能在声明中 * 之后指定 `const` 或 `volatile` 类型的限定符。 生成消息的代码示例：

    int * const p;
    int * unsigned q;

消息标识：E_ONLY_QUALS_ALLOWED_AFTER_STAR

## 零或负下标

数组声明的大小不能为零或负数。 生成消息的代码示例：

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

消息标识：E_ZERO_OR_NEGATIVE_SUBSCRIPT

## 数组维数太大

数组声明具有维数组合，所以对于目标计算机，声明的对象太大。 生成消息的代码示例：

    int bigarray[2000000000];

消息标识：E_ARRAY_DIMENSION_TOO_BIG

## 重新声明参数

已经多次将名称用作函数定义中的参数名称。 生成消息的代码示例：

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

消息标识：E_PARAM_REDECLARED

## 在参数中使用“$”符号

使用 -Xt 选项时，已经在参数标识符中使用“$”。使用 -Xa 或 -Xc 选项时，这会导致语法错误。 生成消息的代码示例：

    int f(int i$j ){ };

消息标识：E_DOLLAR_USED_IN_PARAMETER

## 在标识符中使用“$”

使用 -Xt 选项时，已经在标识符中使用“$”。使用 -Xa 或 -Xc 选项时，这会导致语法错误。 生成消息的代码示例：

    int a$b;

消息标识：E_DOLLAR_USED_IN_IDENTIFIER

## ANSI C 要求在“...”之前有形式参数

使用 `-Xc` 和 `-v` 选项显示该警告。在 K&R C 中，可以使用数目变化的参数和非固定参数定义函数。ANSI C 至少需要一个固定参数。 生成消息的代码示例：

    f(...){}

消息标识：E_ANSI_REQS_FRML_PARM_BFORE_DOT

## “void”必须是唯一的参数

只有函数原型声明中的第一个参数才能具有 `void` 类型，所以它必须是唯一的参数。 生成消息的代码示例：

    int f(int,void);

消息标识：E_VOID_MUST_BE_SOLE_PARAMETER

## 维数为空

在禁止使用的情况下，数组的维数为空。如果违例维数是最远的，则诊断信息是警告，否则是错误。 生成消息的代码示例：

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

消息标识：E_NULL_DIMENSION

## 不能声明函数或 void 数组

已经尝试声明函数数组或 `void` 数组。 生成消息的代码示例：

    int f[5]();

消息标识：E_CANT_DECL_ARY_OF_FUNC_VOID

## 函数不能返回函数或数组

已经声明返回类型为函数或数组的函数，而不是指向该函数或数组的指针（可能）。 生成消息的代码示例：

    int f(void)[];	/* 返回整数数组的函数 */

消息标识：E_FUNC_CANT_RTN_FUNC_ARY

## 旧式函数定义

使用 `-fd` 选项显示该警告。已经找到旧式函数定义。 生成消息的代码示例：

    int f(a)
    char a;
    { }

消息标识：E_OLD_STYLE_FUNC_DEF

## 旧式函数声明

使用 `-fd` 选项显示该警告。已经找到旧式函数声明。 生成消息的代码示例：

    int f();

消息标识：E_OLD_STYLE_FUNC_DECL

## 函数原型参数必须具有类型

函数原型声明不能包含标识符列表；它必须声明类型。标识符列表被忽略。 生成消息的代码示例：

    int f(i);

消息标识：E_FUNC_PROTO_REQ_TYPES

## “void”的限定符不合适

为自身提供支持时，无法限定 `void`（使用 `const` 或 `volatile`）。 生成消息的代码示例：

    int f(const void);

消息标识：E_BAD_QUALIFIERS_WITH_VOID

## void 参数不能具有名称

已经在具有 `void` 类型的函数原型声明中声明参数名称。 生成消息的代码示例：

    int f(void v);

消息标识：E_VOID_PARAM_CANT_HAVE_NAME

## 参数不在标识符列表中

变量出现在旧式函数定义的参数声明中，但不出现在该参数标识符列表中。 生成消息的代码示例：

    f(a,b)
    int i;
    {}

消息标识：E_PARAM_NOT_IN_IDENTIFIER_LIST

## asm 定义不能具有旧式参数

具有使用旧式 C 定义的 asm 函数。 生成消息的代码示例：

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

消息标识：E_ASM_CANT_HAVE_OLD_STYLE_PARMS

## 形式参数缺少名称

函数原型定义中没有参数名称。 生成消息的代码示例：

    int f(int){
    }

消息标识：E_FORMAL_PARAM_LACKS_NAME

## 原型在函数名称的参数 n 中不匹配

已经为函数提供函数原型声明，但使用了旧式定义。该定义中的参数名称类型与原型声明中使用的类型不兼容。 下面的示例说明了该诊断信息的实例。

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

`f` 具有旧式定义。鉴于兼容性，`f` 参数必须根据缺省参数提升规则进行提升。因此，必须传递给 `f` 的值实际上是 `int`，即便函数只能使用该值的 `char` 部分。此后，诊断信息可以标识该函数应该具有的 `int` 类型与函数原型导致传递的 `char` 类型之间的冲突。 解决冲突的方法有下面两种： o 更改函数原型，以便读取 `int f(int);` o 使用函数原型定义定义 `f`：

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

生成消息的代码示例：

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

消息标识：E_PROTOTYPE_MISMATCH_PROMOTE

## 函数参数中的原型不匹配

已经为函数提供函数原型声明，但使用了旧式定义。该定义中的参数名称类型与原型声明中使用的类型不兼容。或者，已经指定的参数数目不正确。请检查原型声明和函数定义。 生成消息的代码示例：

    int f(char*, int, char*);     /* 原型声明 */

    int f(a, b, c)                /* 函数 f 的定义 */
    char* a;
    {
    int b;
    }

`f` 具有旧式定义。鉴于兼容性，`f` 参数必须根据缺省参数提升规则进行提升。因此，必须传递给 `f` 的值实际上是 `int`，即便函数只能使用该值的 `char` 部分。此后，诊断信息可以标识该函数应该具有的 `int` 类型与函数原型导致传递的 `char` 类型之间的冲突。解决冲突的方法有下面两种： o 更改函数原型，以便读取 `int f(int);` o 使用函数原型定义定义 `f`：

消息标识：E_PROTOTYPE_MISMATCH

## 参数不匹配：声明了 n 个参数，并定义了 m 个参数

函数的函数原型声明和旧式定义与参数数目不匹配。声明具有 n 个参数，而定义具有 m 个参数。 生成消息的代码示例：

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

消息标识：E_PARAM_MISMATCH_DECL_DEFINED

## 取消定义或不是类型

已经声明指定错误类型信息的标识符。尚未定义类型或已经将无法表示类型的标识符用作类型。 生成消息的代码示例：

    what id1;
    int id2;
    id2 id3;

消息标识：E_UNDEFINED_OR_NOT_A_TYPE

## 函数定义没有 ()

函数定义的声明符部分必须包含括号。不能通过编写函数类型的 `typedef` 名称、标识符和定义函数的大括号定义函数。 生成消息的代码示例：

    typedef int F();
    F f{ }

消息标识：E_PARENLESS_FUNC_DEF

## 旧式声明或不正确的类型

已经使用该类型的旧式声明或类型不正确的赋值。 生成消息的代码示例：

    const int i = 10;
    struct foo {int x; int y; };
    foo = &i;                         /* foo 的类型错误 */

    int f();                          /* 旧式声明 */

消息标识：E_OLD_STYLE_DECL_OR_BAD_TYPE

## 无法初始化参数

旧式函数参数 name 不能具有初始化程序。 生成消息的代码示例：

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

消息标识：E_CANT_INITIALIZE_PARAM

## 语法错误：声明为空

代码在文件作用域包含如同空声明语句的空语句。K&R C 允许，但 ANSI C 不允许。 生成消息的代码示例：

    int i;;

消息标识：E_EMPTY_DECLARATION

## 在块级别具有可疑的静态函数

使用 `-Xc` 选项显示该警告。已经在块作用域中使用存储类 `static` 声明函数。ANSI C 标准说明，如果在块作用域内使用 `extern` 之外的显式存储类声明函数，则将取消定义这种功能。虽然在 K&R C 中可以这样声明函数，但是无法在其它执行中这样做，或者它们可以将不同的含义连接到这个声明上。 生成消息的代码示例：

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

消息标识：E_STATIC_FUNC_AT_BLOCK_LEVEL

## “asm”只对函数定义有效

关键字“asm”在函数定义之外使用。 生成消息的代码示例：

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

消息标识：E_ASM_VALID_ONLY_FOR_FUNC_DEF

## “typedef”只对函数声明有效

函数定义不能具有 `typedef` 存储类。此处，它将被忽略。 生成消息的代码示例：

    typedef int f(void){}

消息标识：E_TYPEDEF_VALID_ONLY_FUNC_DEF

## 函数的存储类必须是 static 或 extern

用于函数声明或定义的存储类说明符不正确。只能使用 `extern` 和 `static`，或者可以省略存储类。该说明符被忽略。 生成消息的代码示例：

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

消息标识：E_SC_FUNC_MUST_STATIC_OR_EXTERN

## 不能初始化“extern”声明

在函数中，使用 `extern` 存储类的对象声明不能具有初始化程序。 生成消息的代码示例：

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

消息标识：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 ; /* 不能重试初始化 */
    		.........
    		}
    }

消息标识：E_CANT_FIXCONTINUE_REINITIALIZE

## 无法初始化 typedef

`typedef` 不能具有初始化程序。 生成消息的代码示例：

    typedef int INT = 1;

消息标识：E_CANT_INIT_TYPEDEF

## 无法初始化函数

声明为函数的名称不能具有初始化程序。 生成消息的代码示例：

    int f(void) = 3;

消息标识：E_CANT_INIT_FUNCTION

## const 对象应该具有初始化程序

使用 `-v` 选项显示该警告。不能修改 `const` 对象。如果没有提供初始值，则该对象的值为零；对于自动变量，其值是不确定的。 生成消息的代码示例：

    const int i;

消息标识：E_CONST_OBJ_SHOULD_HAVE_INITIZR

## 标识符被重新声明

已经采用与标识符的早期外观不一致的方式声明标识符，或者已经在相同的作用域中对标识符声明了两次。 在 K&R C 的早期版本中，如果类型近乎“相同”（如 SPARC 上的 `int` 和 `long`），则允许重新声明不一致。ANSI C 可以认为类型不同。

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

通常，包含和不包含参数信息的函数声明会导致诊断不明确。请参见下面的示例。

    int f(char);
    int f();

根据 ANSI C 类型兼容规则，缺少类型信息的函数声明，即不是函数原型声明的函数声明，只与缺省参数提升规则取消更改每个参数类型时的函数原型兼容。在该示例中，`char` 受提升规则的影响，它可以提升为 `int`。因此，两个声明的类型不兼容。

消息标识：E_IDENTIFIER_REDECLARED

## 重新定义标识符

已经多次定义标识符。换而言之，已经使用初始化程序多次声明对象，或者已经多次定义函数。 生成消息的代码示例：

    int i = 1;
    int i = 1;

消息标识：E_IDENTIFIER_REDEFINED

## 声明隐藏参数

已经使用与该函数的一个参数相同的名称声明标识符。在该块中，指向标识符的引用是新声明。在 `-Xa` 或 `-Xc` 模式下，诊断信息是错误；在其它所有模式下，诊断信息是警告。 生成消息的代码示例：

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

消息标识：E_DECLARATION_HIDES_PARAMETER

## 标识符被重新声明；ANSI C 要求“static”

已经在文件作用域中两次声明名称。第一个标识符使用了存储类 `static`，但第二个标识符未指定存储类。存储类的 ANSI C 规则要求，在第一个标识符之后的所有 name 的重新声明必须指定 `static`。 生成消息的代码示例：

    static int i;
    int i;

消息标识：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;

消息标识：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;

消息标识：E_EXTERN_PRIOR_REDECL_STATIC

## 函数的存储类不一致

ANSI C 要求，在文件作用域内，函数或对象的第一个声明必须建立其存储类。根据这些规则，已经采用不一致的方法对函数 name 重新声明。 生成消息的代码示例：

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

消息标识：E_INCONSISTENT_STOR_CLASS_FUNC

## static 重新声明为 external

将 name 用作相同块中的外部对象或函数的名称之后，已经将其重新用作静态对象或函数的名称。可见的 name 版本是 `static` 版本。 生成消息的代码示例：

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

消息标识：E_STATIC_REDECLARES_EXTERN

## automatic 重新声明为 external

已经在相同块中声明了自动变量 name，其名称与是 `extern` 的其它符号相同。ANSI C 禁止这样声明，但 K&R C 的早期版本允许这样声明。由于兼容早期版本，所以指向该块中的 name 的引用将是自动变量。 生成消息的代码示例：

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

消息标识：E_AUTO_REDECLARES_EXTERNAL

## typedef 重新声明 external

已经声明 `typedef` name，但相同块中的 `extern` 名称相同。`typedef` 隐藏了 `external`。 生成消息的代码示例：

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

消息标识：E_TYPEDEF_REDCLS_EXTERN

## 重新声明 typedef

已经多次声明 `typedef` name。后面的声明与第一个声明的类型相同。 生成警告的代码示例：

    typedef int i;
    typedef int i;

消息标识：E_TYPEDEF_REDECLARED

## extern 的重新声明不一致

已经使用存储类 `extern` 重新声明函数或对象 name。对于该存储类，存在超出作用域范围的早期声明。第二个声明和第一个声明的类型冲突。 生成消息的代码示例：

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

消息标识：E_INCONSISTENT_REDECL_EXTERN

## static 的重新声明不一致

已经重新声明以前使用存储类 `static` 声明的对象或函数。第二个声明和第一个声明的类型冲突。 发出该诊断信息最常见两个的条件是： 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;		/* 与第一个声明有关 */
    	}
    }

消息标识：E_INCONSISTENT_REDECL_STATIC

## 旧式声明隐藏了原型声明

使用 `-v` 选项显示该警告。已经在较深层作用域内重新声明了函数 name。外部声明是函数原型声明，但内部声明缺少参数信息。根据 ANSI C 作用域规则，会隐藏参数信息，并禁止到原型提供的自动转换类型。 生成消息的代码示例：

    extern double sin(double);
    f(void){
    	extern double sin();
    	double d;
    	d = sin(1);			/* 注意：不能转换成双精度！ */
    }

消息标识：E_OLD_STYLE_DECL_HIDES_PROTO

## 基本类型实际上是“类型标记”

使用 `-Xt` 选项显示该警告。使用`struct、union` 或 `enum` 类型和“标记”声明类型，然后使用不同类型的标识符将该类型声明为原始声明中使用的类型标识符。 因为兼容 K&R C 的早期版本，所以编译器可以将两个类型视为相同的类型。在 ANSI C（使用 `-Xa` 或 `-Xc` 选项）中，类型是不同的。 生成消息的代码示例：

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

消息标识：E_BASE_TYPE_IS_REALLY

## 声明在 ANSI C 中引入了新类型

使用 `-Xt` 选项显示该警告。已经在内部作用域中声明了 `struct、union` 或 `enum` tag。在 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; };
    }

消息标识：E_DECL_INTRODUCES_NEW_TYPE_ANSI

## 无用的声明

ANSI C 提出了每项声明实际声明的内容要求，如下： o 声明符 o 结构或联合标记 o 枚举常量 声明没有向编译器提供信息。 生成消息的代码示例：

    int;				 	/* 无标识符 */
    enum e { e1, e2 };			/* 引入枚举 e */
    enum e;					/* 无新信息 */

消息标识：E_USELESS_DECLARATION

## 前向声明枚举

使用 `-v、-Xa` 或 `-Xc` 选项显示该警告。已经找到提示空枚举的声明；在该代码中，后面必须跟该枚举的定义。 生成消息的代码示例：

    enum test *ptr;

消息标识：E_FWD_DECLARING_ENUM

## typedef 没有声明类型名称

使用存储类 `typedef` 声明时，实际上没有声明类型名称。这表明可能存在编程错误。 生成消息的代码示例：

    typedef struct s { int x; };

消息标识：E_TYPEDEF_DECLARES_NO_TYPE_NAME

## 重新声明“类型”标记

已经重新声明以前为 type 标记的 name 标记。 生成消息的代码示例：

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

消息标识：E_TAG_REDECLARED

## 函数原型中的标记可疑

函数原型声明使用 tag 引用 `struct、union` 或 `enum` 类型。该 tag 已经在函数内声明。因此，定义正在声明原型的函数时，它不能在作用域内。为此，原型声明和函数定义不符。 生成消息的代码示例：

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

消息标识：E_DUBIOUS_TAG_IN_FUNC_PROTO

## “类型”声明可疑；只能使用标记

已经使用 tag 在函数原型声明或旧式函数定义的参数声明列表中声明新的 `struct、union` 或 `enum` type，该声明包括 type 的声明符列表。调用该函数时，总会产生类型不匹配问题，因为根据 ANSI C 作用域规则，在函数原型声明或定义的结尾处，标记声明超出了作用域的范围。不能在函数之外声明该类型的对象。相反，在函数原型或函数定义之前声明 `struct、union` 或 `enum`，然后只能通过其标记对其进行引用。 代码如下：

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

应该采用下列方式编写：

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

消息标识：E_DUBIOUS_DECL_USE_TAG_ONLY

## 结构/联合/枚举类型声明可疑，只能使用标记

已经在函数原型作用域中声明了 `struct、union` 或 `enum` type。换而言之，已经在函数原型声明或旧式函数定义的参数声明列表中声明 `struct、union` 或 `enum` type，该声明包括 type 的声明符列表。调用该函数时，总会产生类型不匹配问题，因为根据标准的 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)
    { }

消息标识：E_DUB_DECL_USE_TAG_ONLY_UNNAMED

## 标记声明可疑

已经使用 tag 在函数原型声明或旧式函数定义的参数声明列表中声明新的 `struct、union` 或 `enum` 类型。调用该函数时，总会产生类型不匹配问题，因为根据 ANSI C 作用域规则，在函数声明或定义的结尾处，标记声明超出了作用域范围。不能在函数之外声明该类型的对象。 生成消息的代码示例：

    int f(struct s *);

消息标识：E_DUBIOUS_TAG_DECLARATION

## 没有名称的标记声明可疑

已经在函数原型声明或旧式函数定义的参数声明列表中声明新的 `struct、union` 或 `enum` 类型。调用该函数时，总会产生类型不匹配问题，因为根据标准的 C 作用域规则，在函数声明或定义的结尾处，标记声明超出了作用域范围。不能在函数之外声明该类型的对象。

消息标识：E_DUBIOUS_TAG_DECL_UNNAMED

## 未命名的联合成员

在联合声明中，成员没有名称。 生成消息的代码示例：

    union s { int i; char c; };

消息标识：E_UNNAMED_UNION_MEMBER

## 未命名的结构成员

在结构声明中，成员没有名称。 生成消息的代码示例：

    struct s { int i; char c; };

消息标识：E_UNNAMED_STRUCT_MEMBER

## 不可移植的位字段类型

使用 `-Xc` 选项显示该警告。已经使用`带符号 int` 或`无符号 int` 之外的位字段类型，这些类型是可移植的位字段类型。ANSI C 支持 `int、char、short` 和 `long` 位字段类型，这些类型可能是`带符号、无符号`或“无格式”类型。另外，它还支持<TT>枚举</TT>位字段类型。 生成消息的代码示例：

    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) 警告：不可移植的位字段类型

消息标识：E_NONPORTABLE_BIT_FIELD_TYPE

## 位字段太大

位字段的声明指定的位数要比适合于声明类型的对象位数多。 生成消息的代码示例：

    struct s { char c:20; };

消息标识：E_BIT_FIELD_TOO_BIG

## 位字段的类型无效

对于位字段，不允许使用已经为位字段选择的类型。只能使用整数类型声明位字段。 生成消息的代码示例：

    struct s { float f:3; };

消息标识：E_INVALID_TYPE_FOR_BIT_FIELD

## 成员不能是函数

函数不能是结构或联合的成员，即便指向函数的指针可能是其成员，也是如此。已经将成员名称声明为函数。 生成消息的代码示例：

    struct s { int f(void); };

消息标识：E_MEMBER_CANT_BE_FUNCTION

## 成员名称重复

`struct` 或 `union` 声明将相同名称用于多个成员。 生成消息的代码示例：

    union u {
    	int i;
    	float i;
    };

消息标识：E_DUPLICATE_MEMBER_NAME

## 零大小的结构/联合

已经使用零大小声明结构或联合。 生成消息的代码示例：

    struct s { int ia[0]; };

消息标识：E_ZERO_SIZED_STRUCT_UNION

## 结构/联合没有命名的成员

已经声明其中未命名任何成员的结构或联合。 生成消息的代码示例：

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

消息标识：E_STRUCT_UNION_HAS_NO_NAMD_MBRS

## 语法要求在最后一个结构/联合成员之后有“;”

缺少 C 语法要求结构或联合中最后一个结构或联合成员之后应该有的 ;。 生成消息的代码示例：

    struct s { int x };

消息标识：E_SEMI_COLON_REQD_AFT_LAST_MBR

## 标识符被重新声明

标识符已经在相同作用域中声明多次。 生成消息的代码示例：

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

消息标识：E_ID_REDECLARED

## 枚举常量隐藏了参数

函数中的枚举类型声明包括名称与参数名称相同的枚举常量。该枚举常量隐藏了参数。 生成消息的代码示例：

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

消息标识：E_ENUM_CONST_HIDES_PARAMETER

## 枚举器值溢出 INT_MAX (2147483647)

枚举常量值溢出最大整数值。 生成消息的代码示例：

    enum e { e1=2147483647, e2 }; /* 对于 e2 溢出 */

消息标识：E_ENUM_VAL_OVERFLOWS_INT_MAX

## 在自身的初始化程序中使用了枚举器

在枚举类型声明中设置枚举器名称的值时，已经在表达式中使用该名称。此时，无论符号是否在作用域内，ANSI C 作用域规则都可以在表达式中使用该名称。 生成消息的代码示例：

    int i;
    f(void){
    	enum e { i = i+1, j, k };	/* 在 i+1 中使用全局 i */
    }

消息标识：E_ENUM_USED_OWN_INITIALIZER

## 枚举声明中禁止以“,”结尾

使用 `-Xc` 或 `-v` 选项生成该警告。在枚举类型声明的结尾处提供的逗号多余。语法禁止使用多余的逗号。 生成消息的代码示例：

    enum e { e1, e2, };

消息标识：E_TRAILING_COMMA_IN_ENUM

## 要求使用 {} 括起来的初始化程序

初始化聚集时，必须用 { } 将初始化程序括起来，使用字符串文字初始化字符或使用表达式初始化自动结构时除外。 生成消息的代码示例：

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

消息标识：E_INIT_REQUIRED

## 要求具有结构/联合值的初始化函数

在 ANSI C 中，可以初始化自动结构或联合，但初始化程序的类型与正在初始化的对象类型必须相同。 生成消息的代码示例：

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

消息标识：E_STRUCT_UNION_INIT_REQUIRED

## 初始化函数不适合或溢出

值不适合指定的空间。如果初始化重新从该空间中获取值，则它不能重新生成与输入的值相同的值。在该消息中，如果初始化程序是`无符号`类型，则该值表示为十六进制值，如果是`带符号`类型，则表示为十进制值。 `0x80` 到 0xff 之间的十六进制值不适合 `char 类型；0x8000` 到 `0xffff` 之间的值不适合 `short 类型；0x80000000` 到 `0xffffffff` 之间的值不适合 `int` 类型。但是，这些值可以与相应的`无符号`类型一起使用。 生成消息的代码示例：

    struct s {signed int m1:3; unsigned int m2:3;} st = {4, 5};
    unsigned char uc = 300u;

消息标识：E_INIT_DOES_NOT_FIT

## 字符串文字必须是唯一的数组初始化函数

在相同的初始化过程中，不能同时使用字符串文字和其它值初始化字符数组。 生成消息的代码示例：

    char ca[] = { "abc", 'd' };

消息标识：E_STR_LIT_ARRAY_INIT

## 字符串文字初始化程序中的 n 个多余字节被忽略

初始化字符数组的字符串文字包含 n 个字符，超过了数组所能容纳的字符数。 生成消息的代码示例：

    char ca[3] = "abcd";

消息标识：E_EXTRA_BYTE_IN_STR_IGNORED

## 非常量初始化程序

`extern、static` 或 `array` 对象的初始化程序必须是编译时常量。如果用 `{}` 将自动结构或联合的初始化程序括起来，则该初始化程序还必须是编译时常量。诊断信息中的运算符是编译时无法组合其操作数的运算符。 生成消息的代码示例：

    int j;
    int k = j+1;

消息标识：E_NON_CONST_INIT

## 结构/联合初始化函数太多

已经为结构或联合提供太多的初始化程序。 生成消息的代码示例：

    struct s { int x,y; } st = { 1,2,3 };

消息标识：E_TOO_MANY_STRUCT_UNION_INIT

## 数组初始化函数太多

代码包含的初始化程序要比数组所能容纳的初始化程序多。 生成消息的代码示例：

    int ia[3] = { 1, 2, 3, 4 };

消息标识：E_TOO_MANY_ARRAY_INIT

## 对于标量来说初始化函数太多

对于标量，用 { } 括起来的初始化包含多个值。 生成消息的代码示例：

    int i = { 1, 2 };

消息标识：E_TOO_MANY_INIT_SCALAR

## 将使用符号扩展初始化程序

如果对初始化对象时所用的值进行转换，使其适合该对象，则该值是使用符号扩展的。 生成消息的代码示例：

    unsigned int x = -3;

消息标识：E_INIT_SIGN_EXTEND

## 未指定 -xO3 或更高级别，-crossmodinline 标志被忽略。

-xO3 选项或更高的优化级别必须与 -crossfiles 标记一起使用。

消息标识：E_XO3_NOT_SPECIFIED

## 字符常量中有换行符

没有结束 ' 的字符常量与开始 ' 位于同一行。 生成消息的代码示例：

    int i = 'a
    ;

消息标识：E_NEWLINE_IN_CHAR_CONST

## 源字符无效

如果使用 `-Xa` 或 `-Xc` 选项时出错，将会显示该消息。编译器在源程序中遇到一个是无效 ANSI C 标记的字符。 生成消息的代码示例：

    int i = 1$;

消息标识：E_INVALID_SOURCE_CHARACTER

## 源字符无效

编译器在源程序中遇到一个是无效 ANSI C 标记的字符。无法打印无效字符。诊断信息中的十六进制值是字符代码的十六进制值。

消息标识：E_INVALID_UNPRINTABLE_SRC_CHR

## 无效的标记：

指定的字符集不能组成有效的 C 语言标记。标记是 C 语言中最小的词法元素。标记分为下面几个类别：`关键字、标识符、常量、字符串文字、运算符和标点符号。` 生成消息的代码示例：

    5d
    int 1e = 1; /* 标记应该以数字开头 */

消息标识：E_INVALID_TOKEN_LEX

## 无效的标记：

指定的字符集不能组成有效的 C 语言标记。标记是 C 语言中最小的词法元素。标记分为下面几个类别：`关键字、标识符、常量、字符串文字、运算符和标点符号。` 生成消息的代码示例：

    char 2whateveritistoolongmorethan255character...;   /*long 字符串*/

消息标识：E_INVALID_TOKEN_TOO_LONG_LEX

## 不能并置宽字符串文字和普通字符串文字

对于普通字符串文字和宽字符的字符串文字，只有这两种文字是普通字符或宽字符时，才能将其并置。如果宽字符串文字之后跟普通字符串文字（且两种文字都是宽字符串文字），编译器将会发出警告；如果普通字符串文字之后跟宽字符串文字，则会发出错误。 生成消息的代码示例：

    #include <stddef.h>
    wchar_t wa[] = L"abc" "def";
    char a[] = "abc" L"def";

消息标识：E_CANT_CONCAT_WIDE_REG_STRINGS

## _Restrict 是 -Xa 和 -Xt 的关键字

使用 -Xa 或 -Xt 选项时，`Restrict` 是 C 语言的关键字。 生成消息的代码示例：

    void func(int * _Restrict intptr);

消息标识：E_KEYWORD_FOR_XA_AND_XT

## __asm 是 ANSI C 的扩展

使用 -Xc 选项时，编译器会报告“__asm”语句的用法。“__asm”函数不能在一致性要求严格的 ANSI C 程序中使用。 生成消息的代码示例：

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

消息标识：E_ASM_IS_AN_EXTENSION_OF_ANSI

## 字符换码不适合于宽字符

在前缀为 `L` 的字符常量或字符串文字中，十六进制或八进制换码序列生成的值太大，不适合于`无符号 char`。字符换码太大，无法适合于 `type wchar_t` 的对象，所以只有将其截断后，才能适合。

消息标识：E_CHR_ESC_DOES_NOT_FIT_WCHAR

## 到双精度型的转换溢出

表达式的值太大。该值的转换太大，无法适合于双精度类型。如果表达式位于可执行代码中，则诊断信息是警告，否则是错误。 生成消息的代码示例：

    double f() {
    	return 0xFFFFFFFFFFFFFFFF;
    }

消息标识：E_CONV_TO_DOUBLE_OUT_OF_RANGE

## 到浮点型的转换溢出

表达式的值太大，无法适合于浮点型。如果表达式位于可执行代码中，则诊断信息是警告，否则是错误。 生成消息的代码示例：

    float f = 1e300 * 1e300;

消息标识：E_CONV_TO_FLOAT_OUT_OF_RANGE

## 双精度型到整型的转换溢出

`双精度`常量的值太大，无法适合于整数类型。如果表达式位于可执行代码中，则诊断信息是警告，否则是错误。 生成消息的代码示例：

    int i = 1e100;

消息标识：E_CONV_DOUBLE_INTEGRAL_OUT_RNGE

## 移位计数为负或太大

编译器已经确定，移位运算符的移位计数（左操作数）为负，或者大于正在移位的操作数的大小。 生成消息的代码示例：

    f(){
    	short s;
    	s <<= 25;
    }

消息标识：E_SHIFT_CNT_NEG_TOO_BIG_L

## 移位计数为负或太大

编译器已经确定，移位运算符的移位计数（左操作数）为负，或者大于正在移位的操作数的大小。 生成消息的代码示例：

    f(){
    	short s;
    	s <<= 25;
    }

消息标识：E_SHIFT_CNT_NEG_TOO_BIG

## 检测到整数溢出

编译器尝试在编译时计算运算符表达式的结果，并确定该结果溢出。低位 32 位结果将被保留，而编译器将执行此诊断。 生成消息的代码示例：

    int i = 1000000 * 1000000;

消息标识：E_INTEGER_OVERFLOW_DETECTED

## 浮点常量计算溢出

编译器尝试在两个浮点操作数之间运算时，已经在编译时检测到溢出。如果表达式位于可执行代码中，则诊断信息是警告，否则是错误。 生成消息的代码示例：

    double d1 = 1e300 * 1e300;

消息标识：E_FP_CONST_CALC_OUT_OF_RANGE

## 未从顶部进入循环语句

序列控制流不能通过之前的语句访问 `for` 或 `while` 循环开头的控制表达式。 生成消息的代码示例：

    f(void){
    	int i;
    	goto lab;
    	for (i = 1; i > 0; --i) {
    lab:;
    		i=5;
    	}
    }

消息标识：E_LOOP_NOT_ENTERED_AT_TOP

## 语句执行不到

执行不到程序中的该语句，因为 `goto、break、continue` 或 `return` 语句位于该语句之前。 生成消息的代码示例：

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

消息标识：E_STATEMENT_NOT_REACHED

## 函数无 return 语句

使用 `-v` 选项显示该警告。函数应该包括 `return` 语句。 生成消息的代码示例：

    #include <stdio.h>
    main(void)
    {
    	(void) printf("Do the hippy-hippy shake.\n");
    }

消息标识：E_FUNC_HAS_NO_RETURN_STMT

## 重新定义标签

相同的标签名称已经在当前的函数中多次出现。标签的作用域是整个函数。 生成消息的代码示例：

    f(void){
    	int i;
    	i = 1;
    	if (i) {
    L:
    		while (i)
    			g();
    		goto L;
    	}
    L:  ;
    }

消息标识：E_LABEL_REDEFINED

## end-of-loop 代码执行不到

已经编写这种循环：循环结尾处的代码不仅执行不到，而且无法执行。其中，该代码是由编译器为分支语句生成的，用于返回到循环的开头。 生成消息的代码示例：

    f(void){
    	int i = 1;
    	while (i) {
    		return 4;
    	}
    }

消息标识：E_END_OF_LOOP_CODE_NOT_REACHED

## “break”位于 loop 或 switch 语句之外

函数包含的 `break` 语句位置不当，即位于任意 `loop` 或 `switch` 语句之外。 生成消息的代码示例：

    f(void){
    break;
    }

消息标识：E_BREAK_OUTSIDE_LOOP_OR_SWITCH

## “continue”位于 loop 语句之外

程序包含的 `continue` 语句位于所有循环语句的作用域之外。 生成消息的代码示例：

    f(void){
    	continue;
    }

消息标识：E_CONTINUE_OUTSIDE_LOOP_SWITCH

## 函数应有返回值

使用 `-v` 选项显示该警告。当前的函数是使用类型声明的，但是已经使用一个不包含返回值表达式的 `return` 语句。 生成消息的代码示例：

    f(void){
    	return;
    }

消息标识：E_FUNC_EXPECTS_TO_RETURN_VALUE

## switch 表达式必须为整数类型

代码包含一个控制表达式不具有整数类型的 `switch` 语句。如果无效类型是浮点类型，则该消息是警告；否则是错误。浮点 `switch` 表达式被转换为 `int`。 生成消息的代码示例：

    f(void){
    	float x;
    	switch (x) {
    	case 4:  ;
    	}
    }

消息标识：E_SWITCH_EXP_MUST_BE_INTEGRAL

## “case”位于 switch 语句之外

case 语句出现在任意 `switch` 语句的作用域之外。 生成消息的代码示例：

    f(void){
    	case 4:  ;
    }

消息标识：E_CASE_OUTSIDE_SWITCH

## 非整数条件表达式

`case` 语句的操作数必须是整型常量。 生成消息的代码示例：

    f(void){
    	int i = 1;
    	switch (i) {
    	case 5.0:  ;
    	}
    }

消息标识：E_NON_INTEGRAL_CASE_EXPRESSION

## “default”位于 switch 语句之外

default 标签出现在 `switch` 语句的作用域之外。 生成消息的代码示例：

    f(void){
    default: ; }

消息标识：E_DEFAULT_OUTSIDE_SWITCH

## switch 语句中的“default”重复

当前的 `switch` 语句中有两个 `default` 标签。 生成消息的代码示例：

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

消息标识：E_DUPLICATE_DEFAULT_IN_SWITCH

## 执行不到 case 标签

在 `case` 语句中已经指定的表达式值位于封闭的 `switch` 语句的控制表达式类型范围之外。因此，可能从来就执行不到 case 标签。在该消息中，如果 `case` 表达式是`无符号`类型，则 value 表示为十六进制的值，如果该表达式是`带符号`类型，则表示为十进制的值。 生成消息的代码示例：

    f(void){
    	unsigned char uc;

    	switch( uc ){
    	case 256:
    		;
    	}
    }

消息标识：E_UNREACHABLE_CASE_LABEL

## case 标签受转换的影响

使用 `-v` 选项显示该警告。`case` 标签的 value 不能用 `switch` 语句的控制表达式类型来表示。如果 `case` 表达式的类型和控制表达式的类型具有相同的大小，且该 case 表达式的实际位表示法无法进行更改，则会生成该警告。例如，控制表达式可能具有 `int` 类型，而 case 表达式可能具有`无符号 int` 类型。在该诊断信息中，如果 `case` 表达式是`无符号`的类型，则 value 表示为十六进制的值，如果该表达式是`带符号`的类型，则表示为十进制的值。 在该示例中，`0xffffffffu` 不能表示为 `int`。将 `case` 表达式转换为控制表达式的类型时，其有效值是 `-1`。换而言之，如果 `i` 具有值 `-1`，而不是 `0xffffffff`，将执行到 case 语句。 生成消息的代码示例：

    f(void){
    	int i;

    	switch( i ){
    	case 0xffffffffu:
    	;
    	}
    }

消息标识：E_CASE_LBL_AFFECTED_CONVERSION

## 不能有 void 对象

不能将声明类型为 `void` 的对象。 生成消息的代码示例：

    void v;

消息标识：E_CANT_HAVE_VOID_OBJECT

## 结构/联合/枚举 tag 不完整：名称

已经使用 `struct、union` 或 `enum` 类型和 tag 声明对象名称，但该类型不完整。 生成消息的代码示例：

    struct s st;

消息标识：E_INCOMPLETE_STRUCT_UNION_ENUM

## st_save() 内存不足

该编译器内存不足。这通常是由于运行超出交换空间造成的。

消息标识：E_ST_SAVE_OUT_OF_MEMORY

## st_lookup() 内存不足

该编译器内存不足。这通常是由于运行超出交换空间造成的。

消息标识：E_ST_LOOKUP_OUT_OF_MEMORY

## 静态函数已调用但未定义

程序调用了函数 name（已经声明为 `static`），但翻译单元中不会出现该 name 的任何定义。消息中显示的行号比文件中的行号大一个号，因为只有显示整个翻译单元之后，才能诊断该条件。 生成消息的代码示例：

    static int statfunc(int);
    void
    f(){
    	int i = statfunc(4);
    }

消息标识：E_STATIC_FUNC_CALLD_NOT_DEFINED

## 取消定义的标签

代码包含当前函数中的 `goto` 语句，但未在该函数中定义目标 label。 生成消息的代码示例：

    f(void){
    	goto L;
    }

消息标识：E_UNDEFINED_LABEL

## 不可识别的 #pragma 被忽略

使用 `-v` 选项显示该警告。因为 #`pragma` 指令是用来实现专用行为的，所以设置 `-v` 编译标记时，C 编译器会提示所有忽略的指令。C 编译器无法识别诊断信息中显示的 #`pragma`。 生成消息的代码示例：

    #pragma list

消息标识：E_UNRECOGNIZED_PRAGMA_IGNORED

## “#pragma”之后无标记

使用 `-v` 选项显示该警告。编译器遇到不包含其它标记的 `#pragma` 指令。 生成消息的代码示例：

    #pragma

消息标识：E_NO_TOKENS_FOLLOW_PRAGMA

## do_pragma：内存不足

该编译器内存不足。这通常是由于运行超出交换空间造成的。

消息标识：E_DO_PRAGMA_OUT_OF_MEMORY

## 忽略格式错误的 #pragma pack(n)

编译器已经遇到没有所示格式的 `#pragma pack`。该错误指令被忽略。 生成消息的代码示例：

    #pragma pack

消息标识：E_IGNORE_MALFORMED_PRAGMA_PACK

## 错误的 #pragma pack 值：

`pack` pragma 可以控制结构偏移的布局，所以必须采用下列格式：

    #pragma pack(n)

其中，`n` 是二的幂，它小于平台上最严格的对齐（对于 Intel，是 4；对于 sparc v8，是 8；对于 v9，是 16）。如果 n 被省略，则成员对齐恢复为普遍的对齐边界。 pragma 可以为任何结构成员指定所需的最严格对齐。该 pragma 还可以应用于其后的所有结构定义，直至下一个 pack 指令出现为止。如果使用不同的包装在不同的翻译单元中定义相同的结构，则程序可能会意外失败。尤其是，不应该在包括定义预编译库界面的标题之前使用 pragma pack。建议的用法是，使程序代码中的 pragma 直接位于要使用紧跟在结构之后的 #pragma pack() 压缩的任意结构之前。 生成消息的代码示例：

    #pragma pack(-2)
    #pragma pack(7)
    #pragma pack(256)

消息标识：E_BAD_PRAGMA_PACK_VALUE

## 忽略格式错误的 #pragma 弱符号

编译器已经遇到没有所示格式的 `#pragma weak` 指令。该错误指令被忽略。 生成消息的代码示例：

    #pragma weak write,_write

消息标识：E_IGNORE_MALFORMED_PRAGMA_WEAK

## #pragma unknown_control_flow 中的符号尚未声明

编译器已经在尚未声明的 `#pragma unknown_control_flow` 中遇到函数名称。`unknown_control_flow` pragma 的语法如下：

    #pragma unknown_control_flow ( name [ , name ... ] )

pragma 中命名的函数必须在 #pragma 之前声明。 生成消息的代码示例：

    #pragma unknown_control_flow(foo, bar)
    int foo();
    int bar();

    代码应该指定为：
    int foo();
    int bar();
    #pragma unknown_control_flow(foo, bar)

消息标识：E_UNKNOWN_CTRL_FLOW_UNDECLARED

## `#pragma no_side_effect` 中的符号尚未声明

编译器已经在尚未声明的 `#pragma no_side_effect` 中遇到函数名称。`unknown_control_flow` pragma 的语法如下：

    #pragma no_side_effect (name [, name ...])

标识列表中命名的所有函数必须在 pragma 之前声明。 生成消息的代码示例：

    /* ABS 函数并未在任何位置定义或声明 */
    #pragma no_side_effect (abc)

============ 代码应该是：

    int abc();
    #pragma no_side_effect (abc)

消息标识：E_NO_SIDE_EFFECT_UNDECLARED

## 忽略格式错误的 #pragma unknown_control_flow (id [,id ...] )

已经使用错误的语法指定 `#pragma unknown_control_flow`。pragma 的正确语法如下：

    #pragma unknown_control_flow ( id [,id ...] )

生成消息的代码示例：

    #pragma unknown_control_flow {a, b c}

消息标识：E_IGNORE_MALFORMED_PRAGMA_UCF

## 忽略格式错误的 #pragma no_side_effect (id [,id ...] )

已经使用错误的语法指定 `#pragma unknown_control_flow`。pragma 的正确语法如下：

    #pragma no_side_effect (id [, id ...])

生成消息的代码示例：

    #pragma no_side_effect {a b}

消息标识：E_IGNORE_MALFORMED_PRAGMA_NSE

## 忽略格式错误的 #pragma init/fini

`#pragma init` 或 `#pragma fini` 使用的语法不正确。必须采用下列方式指定 `fini` 和 `init` pragma：

    #pragma fini (f1 [,f2, ...,fn])
    #pragma init (f1 [,f2, ...,fn])

生成消息的代码示例：

    #define ONE 1
    f();
    g();
    #pragma fini {f, g}

消息标识：E_IGNORE_MALFORMED_PRAGMA

## 必须具有类型“function-returning-unsigned”

作为 `#pragma int_to_unsigned` 指令的一部分，名称必须是其类型是 function-returning-`unsigned` 的标识符。 生成消息的代码示例：

    extern int f(int);
    #pragma int_to_unsigned f

l

消息标识：E_MUST_B_TYPE_FUNC_RTN_UNSIGNED

## 忽略格式错误的 #pragma int_to_unsigned 符号

编译器已经遇到没有所示格式的 `#pragma int_to_unsigned` 指令。该错误指令被忽略。 生成消息的代码示例：

    #pragma int_to_unsigned strlen();

消息标识：E_IGNORE_MALFORMED_INTTOUNSIGND

## 错误的 #pragma align 值

`#pragma align` 的值必须是正值或幂为二的正值，且不能大于 128。该 `align` pragma 的语法如下： `#pragma align integer (id [, id...])` 生成消息的代码示例：

    #define ANO 129
    #pragma align ANO (astruct)

不错的示例：

    #define MAX 128
    #pragma align MAX (astruct, aint, aptr)

消息标识：E_BAD_PRAGMA_ALIGN_VALUE

## 忽略格式错误的 #pragma align int ( ident [,ident ...] )

`#pragma align` 使用的语法不正确。正确的语法如下：

    #pragma align integer (ident [,ident ...])

其中，整数是介于 1 到 128 之间二的幂；有效值为：1, 2, 4, 8, 16, 32, 64, 128. `ident` 必须是全局或静态变量；它不能是自动变量。 生成消息的代码示例：

    #pragma align 128 {astruct, aunion}

消息标识：E_IGNORE_MALFORMED_PRAGMA_ALIGN

## 内存不足，无法分配空间

该编译器内存不足。这通常是由于运行超出交换空间造成的。

消息标识：E_REALLOC_OUT_OF_MEMORY

## #line < number > 之后应有字符串文字

#`line` < number > 指令之后必须跟普通的字符串文字。

消息标识：E_STRING_EXPECTED_POUND_LINE

## 位字段赋值中丢失精度

将常量赋值给太小的位字段，如果不截断，则无法获取值。在下面的示例中，位字段 z 的值可能介于 0 到 7 或 -4 到 3 之间，具体值视计算机而定。 生成消息的代码示例：

    void
    v(void)
    {
    	struct {
    		signed          x:3;	/* 允许使用的最大值是 3 */
    		unsigned        y:3;	/* 允许使用的最大值是 7 */
    		int             z:3;	/* 允许使用的最大值是 7 */
    	}               st;
    	st.x = 3;
    	st.x = 4;
    	st.y = 7;
    	st.y = 8;
    	st.z = 7;
    	st.z = 8;
    }

消息标识：E_PRECISION_LOST_IN_BIT_FIELD

## 从未定义枚举

`enum` 声明不正确。格式：简单 生成消息的代码示例：

    1  enum e {int, two} en;
    ============
    (1) 警告：从未定义枚举：e

消息标识：E_ENUM_NEVER_DEF

## 等号运算符"=="出现在需要赋值运算符"="的位置

等号运算符出现在应该是副作用的位置。格式：简单 生成消息的代码示例：

    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) 警告：等号运算符“==”出现在应该是赋值运算符“=”的位置

消息标识：E_ASSIGNMENT_NOT_EQUALITY

## 赋值运算符"="出现在需要"=="的位置

赋值运算符出现在应该是条件表达式的位置。使用函数调用的值对变量进行赋值或复制字符串时，不会发出该消息（请参加下面的示例）。使用 `-h` 调用 `lint` 时，禁止该警告。格式：简单 生成消息的代码示例：

    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) 警告：赋值运算符“=”出现在应该是“==”的位置

消息标识：E_EQUALITY_NOT_ASSIGNMENT

## 只允许 0 个参数或 2 个参数：main()

仅使用一个参数或两个以上的参数定义程序中的函数 `main()`，所以不符合 ANSI C 要求。格式：简单 生成消息的代码示例：

    1 void
    2 main(int argc, char **argv, char **envp)
    3 {}
    ============
    (2) 警告：只允许 0 个参数或 2 个参数：main()

消息标识：E_MAIN_PARAM

## 函数必须是 int 类型：main()

已经使用不返回 `int` 的 `main()`，所以违反了 ANSI C 限制条件。格式：简单 生成消息的代码示例：

    1 char           *
    2 main(void)
    3 {
    4 	return "a";
    5 }
    ============
    (2) 警告：函数必须是 int 类型：main()

消息标识：E_MAIN_RET_VAL

## 不可移植的字符常量

程序中的多字符字符常量无法进行移植。格式：简单 生成消息的代码示例：

    1  int c = 'abc';
    ============
    (1) 警告：不可移植的字符常量

消息标识：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) 警告：函数返回指向自动变量的指针

消息标识：E_FUNC_RET_PTR_TO_AUTO

## 函数返回指向参数的指针

函数返回指向参数的指针。由于不能再保证在块结束之后保留带有自动存储持续时间的对象，因此在块结束之后未定义指向该对象的指针。 生成消息的代码示例：

    1 int	*f(int i)
    2 {
    3 	return &i;
    4 }
    ============
    (3) 警告：函数返回指向参数的指针

消息标识：E_FUNC_RET_PTR_TO_PARAM

## case 语句失败

如果没有 `break` 或 `return`，从 `case` 到另一个 case 语句的执行会失败。从前面的 `case` 语句执行不到该 `case` 语句时，`case` 语句以 `/* FALLTHRU */` 或 `/* NOTREACHED */` 开头（请参加下面的示例）。此时，如果遇到该语句，会禁止该消息。使用 `-h` 调用 `lint` 时，如果遇到每个语句，会禁止该消息。格式：简单 生成消息的代码示例：

    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 语句失败

消息标识：E_CASE_FALLTHRU

## 指令必须在 if/else 中：/* EMPTY */

lint 指令 `/* EMPTY */` 必须出现在 `#if` 或 `#else` 的作用域内。 生成消息的代码示例：

    int f(void) {
    /* EMPTY */
    };

消息标识：E_IF_ELSE_DIRECTIVE

## 语句无结果：if

`if` 语句包含一个空 `if` 部分。在 `if` 语句和分号的控制表达式之间插入 `/* EMPTY */` 时，如果遇到该语句，会禁止该消息；使用 `-h` 调用 `lint` 时，如果遇到每个语句，会禁止该消息。格式：简单 生成消息的代码示例：

    1 void
    2 v(int i)
    3 {
    4 	if (i);
    5 	if (i == 10)
    6 		 /* EMPTY */ ;
    7 	else
    8 		return;
    9 }
    ============
    (4) 警告：语句无结果：if

消息标识：E_NOP_IF_STMT

## 语句无结果：else

`if` 语句包含一个空 `else` 部分。在 `else` 语句和分号之间插入 `/* EMPTY */` 时，如果遇到该语句，会禁止该消息；使用 `-h` 调用 `lint` 时，如果遇到每个语句，会禁止该消息。格式：简单 生成消息的代码示例：

    1 void
    2 v(int i)
    3 {
    4 	if (i)
    5 		return;
    6 	else;
    7 }
    ============
    (6) 警告：语句无结果：else

消息标识：E_NOP_ELSE_STMT

## static 未使用

虽然变量或函数已经在文件中定义或声明为 `static`，但没有在该文件中使用。之所以会这样，可能是由编程问题造成的，因为对象不能在文件之外使用。 生成消息的代码示例：

    1  static int i;
    2  static int f(void);
    3  static int j = 1;
    ============
    static 未使用
    (1) i               (2) f               (3) j

消息标识：E_STATIC_UNUSED1

## static 未使用

虽然变量或函数已经在文件中定义或声明为 `static`，但没有在该文件中使用。之所以会这样，可能是由编程问题造成的，因为对象不能在文件之外使用。 生成消息的代码示例：

    1  static int i;
    2  static int f(void);
    3  static int j = 1;

消息标识：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 in main

消息标识：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

消息标识：E_FUNC_ARG_UNUSED

## 变量未在函数中使用：%s（在%s中）

变量已声明，但从未在函数中使用。 生成消息的代码示例：

    1 void main(void)
    2 {
    3 	int i, j;
    4 	static k;
    5 }
    6
    7
    ============
    变量未在函数中使用：%s（在%s中）
    (3) i in main
    (3) j in main
    (4) k in main

消息标识：E_FUNC_VAR_UNUSED1

## 变量未在函数中使用：%s（在%s中）

变量已声明，但从未在函数中使用。 生成消息的代码示例：

    1 void main(void)
    2 {
    3 	int i, j;
    4 	static k;
    5 }
    6
    7

消息标识：E_FUNC_VAR_UNUSED

## 已设置但未在函数中使用

自动变量或函数参数已声明和设置，但未在函数中使用。 生成消息的代码示例：

    1 void f(int i)
    2 {
    3 	int j = 1;
    4 	i = 1;
    5 }
    ============
    已设置但未在函数中使用
    (1) i in f
    (3) j in f

消息标识：E_FUNC_SET_NOT_USED1

## 已设置但未在函数中使用

自动变量或函数参数已声明和设置，但未在函数中使用。 生成消息的代码示例：

    1 void f(int i)
    2 {
    3 	int j = 1;
    4 	i = 1;
    5 }

消息标识：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)

消息标识：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)

消息标识：E_STMT_NOT_REACHED

## 隐式声明为返回 int

该程序调用以前未声明的函数。在这种情况下，`lint` 会假设该函数返回 `int`。 生成消息的代码示例：

    1 void
    2 v(void)
    3 {
    4 	f();
    5 }
    ============
    隐式声明为返回 int
    (4) f

消息标识：E_RET_INT_IMPLICITLY1

## 隐式声明为返回 int

该程序调用以前未声明的函数。在这种情况下，`lint` 会假设该函数返回 `int`。 生成消息的代码示例：

    1 void
    2 v(void)
    3 {
    4 	f();
    5 }

消息标识：E_RET_INT_IMPLICITLY

## 指针强制类型转换会导致不正确的排列

已经将指向一个对象类型的指针转换成指向其它对象类型（具有更严格的对齐要求）的指针。之所以会这样，可能是由第二个指针类型的无效值造成的。使用 `-h` 调用 `lint` 时，会禁止该警告。 生成消息的代码示例：

    1 void
    2 main(void)
    3 {
    4 	short          *sp = 0;
    5 	int            *ip;
    6 	ip = (int *) sp;
    7 }
    8
    ============
    指针强制类型转换会导致不正确的排列
        (6)

消息标识：E_BAD_PTR_CAST_ALIGN

## 对有符号值的按位运算可能不可移植

根据 ANSI C 的定义，按位运算符的操作数是带符号的整数类型变量。因为这些运算符返回的值与整数的内部表示法有关，所以其功能是针对该类型的操作数执行定义的。

消息标识：E_POSSIBLY_NONPORT_SBITWISE_OP

## 对有符号值的按位运算不可移植

根据 ANSI C 的定义，按位运算符的操作数是带符号的整数类型变量。因为这些运算符返回的值与整数的内部表示法有关，所以其功能是针对该类型的操作数执行定义的。 生成消息的代码示例：

    1 void
    2 v(void)
    3 {
    4 	int             i;
    5 	signed int      j;
    6 	i = i & 055;
    7 	j = j | 022;
    8 }
    ============
    对有符号值的按位运算不可移植
        (6)                 (7)

消息标识：E_NONPORT_SBITWISE_OP

## 向较大整数类型转换时符号扩展可能不正确

类型“无格式”`char` 的变量已赋值给较大的整数类型变量。“无格式”`char` 是否可以视为带符号或无符号变量是由执行定义的。只有使用 `-p` 调用 `lint` 时，才会发出该消息；如果使用 `-a` 调用，会禁止该消息。 生成消息的代码示例：

    1 int
    2 main(void)
    3 {
    4 	char            c = 0;
    5 	long            l;
    6 	l = c;
    7 	return (l);
    8 }
    ============
    向较大整数类型转换时符号扩展可能不正确
        (6)

消息标识：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)

消息标识：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

消息标识：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 }

消息标识：E_FUNC_NO_RET_VAL

## 声明未在块中使用

外部变量或函数已声明，但未在内部块中使用。 生成消息的代码示例：

    1 int
    2 main(void)
    3 {
    4 	int             f();
    5 	int             g();
    6 	return f();
    7 }
    ============
    声明未在块中使用
    (5) g

消息标识：E_BLOCK_DECL_UNUSED1

## 声明未在块中使用

外部变量或函数已声明，但未在内部块中使用。 生成消息的代码示例：

    1 int
    2 main(void)
    3 {
    4 	int             f();
    5 	int             g();
    6 	return f();
    7 }

消息标识：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)

消息标识：E_NAME_USED_NOT_DEF1

## 名称已使用但未定义

非静态外部变量或函数已声明，但未在任何文件中定义。使用 `-u` 调用 `lint` 时，会禁止该消息。 生成消息的代码示例：

    1 extern int      f(void);
    2 int
    3 main(void)
    4 {
    5 	return f();
    6 }

消息标识：E_NAME_USED_NOT_DEF2

## 名称已定义但从未使用：

变量或函数已定义，但未在任何文件中使用。使用 `-u` 调用 `lint` 时，会禁止该消息。 生成消息的代码示例：

    1  int i;
    ============
    名称已定义但从未使用：
    i	f.c(1)

消息标识：E_NAME_DEF_NOT_USED1

## 名称已定义但从未使用：

变量或函数已定义，但未在任何文件中使用。使用 `-u` 调用 `lint` 时，会禁止该消息。 生成消息的代码示例：

    1  int i;

消息标识：E_NAME_DEF_NOT_USED2

## 名称已声明但从未使用或定义

非静态外部变量或函数已声明，但未在任何文件中使用或定义。使用 `-x` 调用 `lint` 时，会禁止该消息。 生成消息的代码示例：

    1 extern int      f(void);
    2 static int g(void);
    ============
    名称已声明但从未使用或定义
    f	f.c(1)

消息标识：E_NAME_DECL_NOT_USED_DEF1

## 名称已声明但从未使用或定义

非静态外部变量或函数已声明，但未在任何文件中使用或定义。使用 `-x` 调用 `lint` 时，会禁止该消息。 生成消息的代码示例：

    1 extern int      f(void);
    2 static int g(void);

消息标识：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)

消息标识：E_NAME_MULTIPLY_DEF1

## 名称多次定义

变量已在多个源文件中定义。 生成消息的代码示例：

    file f.c:
    1  char i = 'a';

    file f_1.c:
    1  long i = 1;

消息标识：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 ()

消息标识：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 }

消息标识：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

消息标识：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;

消息标识：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

消息标识：E_INCONS_ARG_USED1

## 使用的参数不一致

对于函数调用，实际参数和伪参数的类型不匹配。格式：简单 生成消息的代码示例：

    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", line 12:警告：参数与记住的类型不匹配：arg #1
    使用的参数不一致：g(arg 1) in f.c(5) int  and f.c(12) double

消息标识：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)

消息标识：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  }

消息标识：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

消息标识：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 {}

消息标识：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

消息标识：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 }

消息标识：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

消息标识：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  }

消息标识：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 *

消息标识：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)

消息标识：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);

消息标识：E_FUNC_DECL_VAR_ARG2

## 由于截断，可能无法识别

由于长度或条件方面的执行定义限制，将程序中的外部名称移植到其它计算机上时，该名称可能无法识别。根据 ANSI C 的下界要求，在 `-Xc` 环境下，使用一个 case 语句将外部名称截断为前 6 个字符；在 `-p` 环境下，使用一个 case 语句将其截断为前 8 个字符。 生成消息的代码示例：

    1  int foobar1;
    2  int FooBar12;
    3  int foobar2;
    4  int FOOBAR12;
    ============
    under -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)

    under -p:
    由于截断，可能无法识别
    FOOBAR12 (4) in f.c ::FooBar12 (2) in f.c

消息标识：E_INDISTING_FROM_TRUNC1

## 由于截断，可能无法识别

由于长度或条件方面的执行定义限制，将程序中的外部名称移植到其它计算机上时，该名称可能无法识别。根据 ANSI C 的下界要求，在 `-Xc` 环境下，使用一个 case 语句将外部名称截断为前 6 个字符；在 `-p` 环境下，使用一个 case 语句将其截断为前 8 个字符。 生成消息的代码示例：

    1  int foobar1;
    2  int FooBar12;
    3  int foobar2;
    4  int FOOBAR12;

消息标识：E_INDISTING_FROM_TRUNC2

## 格式的参数过多

与调用过程中保留的参数相比，[fs]printf() 或 [fs]scanf() 函数调用的控制字符串具有较少的转换说明。 生成消息的代码示例：

    1 #include <stdio.h>
    2 void
    3 main(void)
    4 {
    5 	int             i = 0, j = 1;
    6 	(void) printf("%d", i, j);
    7 }
    ============
    格式的参数过多
    printf	f.c(6)

消息标识：E_TOO_MANY_ARG_FOR_FMT1

## 格式的参数过多

与调用过程中保留的参数相比，[fs]printf() 或 [fs]scanf() 函数调用的控制字符串具有较少的转换说明。 生成消息的代码示例：

    1 #include <stdio.h>
    2 void
    3 main(void)
    4 {
    5 	int             i = 0, j = 1;
    6 	(void) printf("%d", i, j);
    7 }

消息标识：E_TOO_MANY_ARG_FOR_FMT2

## 格式错误的格式字符串

[fs]printf() 或 [fs]scanf() 控制字符的格式不正确。 生成消息的代码示例：

    1 #include <stdio.h>
    2 void
    3 main(void)
    4 {
    5 	(void) printf("%y");
    6 }
    ============
    格式错误的格式字符串
    printf	f.c(5)

消息标识：E_BAD_FORMAT_STR1

## 格式错误的格式字符串

[fs]printf() 或 [fs]scanf() 控制字符串的格式不正确。 生成消息的代码示例：

    1 #include <stdio.h>
    2 void
    3 main(void)
    4 {
    5 	(void) printf("%y");
    6 }

消息标识：E_BAD_FORMAT_STR2

## 格式的参数过少

与调用过程中保留的参数相比，[fs]printf() 或 [fs]scanf() 函数调用的控制字符串具有较多的转换说明。 生成消息的代码示例：

    1 #include <stdio.h>
    2 void
    3 main(void)
    4 {
    5 	int             i = 1;
    6 	(void) printf("%d%d", i);
    7 }
    ============
    格式的参数过少
    printf	f.c(6)

消息标识：E_TOO_FEW_ARG_FOR_FORMAT1

## 格式的参数过少

与调用过程中保留的参数相比，[fs]printf() 或 [fs]scanf() 函数调用的控制字符串具有较多的转换说明。 生成消息的代码示例：

    1 #include <stdio.h>
    2 void
    3 main(void)
    4 {
    5 	int             i = 1;
    6 	(void) printf("%d%d", i);
    7 }

消息标识：E_TOO_FEW_ARG_FOR_FORMAT2

## 函数参数（数目）类型与格式不一致

参数与 [fs]printf() 或 [fs]scanf() 函数调用的控制字符串中相应的转换说明不一致。 生成消息的代码示例：

    1 #include <stdio.h>
    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)

消息标识：E_BAD_FORMAT_ARG_TYPE1

## 函数参数（数目）类型与格式不一致

参数与 [fs]printf() 或 [fs]scanf() 函数调用的控制字符串中相应的转换说明不一致。 生成消息的代码示例：

    1 #include <stdio.h>
    2 void
    3 main(void)
    4 {
    5 	int             i = 0;
    6 	(void) printf("%s", i);
    7 }
    8

消息标识：E_BAD_FORMAT_ARG_TYPE2

## 声明为全局，应为静态

外部变量或函数已声明为全局，即未声明为静态，但只在定义该变量或函数的文件中加以引用。使用 `-m` 调用 `lint` 时，会禁止该消息。 生成消息的代码示例：

    1 int
    2 f(void)
    3 {
    4 	return 1;
    5 }
    6 main(void)
    7 {
    8 	return f();
    9 }
    ============
    声明为全局，应为静态
    f	f.c(2)

消息标识：E_GLOBAL_COULD_BE_STATIC1

## 声明为全局，应为静态

外部变量或函数已声明为全局，即未声明为静态，但只在定义该变量或函数的文件中加以引用。使用 `-m` 调用 `lint` 时，会禁止该消息。 生成消息的代码示例：

    1 int
    2 f(void)
    3 {
    4 	return 1;
    5 }
    6 main(void)
    7 {
    8 	return f();
    9 }

消息标识：E_GLOBAL_COULD_BE_STATIC2

## 类型带有大于 16 个的修饰符，但只能使用 16 个

名称说明所用的修改符数超过了上限 16。格式如下：简单 生成消息的代码示例：

    1 int ************************ip = 0;
    ============
    (1) 警告：类型带有大于 16 个的修饰符，但只能使用 16 个

消息标识：E_MODIFIER_OVERFLOW

## 参数数目与指令不一致：/* VARARGS */：有效的 args() 必须少于 directive(n) 选中的数目

如果将指令 `/* VARARGSn */` 应用于参数数目少于 n 的函数，则 n 会减少到函数标题中出现的参数数目。 生成消息的代码示例：

    1 /* VARARGS4 */
    2 int
    3 f(int x, int y, int z)
    4 {
    5 	return (x + y + z);
    6 }
    ============
    (3) 警告：参数数目与指令不一致：/* VARARGS4 */：
    	有效的 args(3) 必须少于 directive(4) 选中的数目

消息标识：E_DIRECTIVE_TOO_MANY_ARG

## 参数数目与指令不一致：/* VARARGS */：有效的 args() 必须少于 directive(n) 选中的数目

如果将指令 `/* VARARGSn */` 应用于参数数目少于 n 的函数，则 n 会减少到函数标题中出现的参数数目。 生成消息的代码示例：

    1 /* VARARGS4 */
    2 int
    3 f(int x, int y, int z)
    4 {
    5 	return (x + y + z);
    6 }
    ============
    (3) 警告：参数数目与指令不一致：/* VARARGS4 */：
    	有效的 args(3) 必须少于 directive(4) 选中的数目

消息标识：E_DIRECTIVE_TOO_MANY_ARG2

## 变量在设置之前使用

指向自动非数组变量的第一个引用所在的行号小于指向该变量的第一个赋值所在的行号。如果获取变量的地址，则表示变量已设置并使用；如果首次赋值给`结构`或`联合`的任意成员，则表示赋值给了整个`结构`或`联合`。格式：简单 生成消息的代码示例：

    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

消息标识：E_VAR_USED_BEFORE_SET

## 常量在条件上下文中

`if`、`while` 或 `for` 语句的控制表达式是常量。如果语句以 `/* CONSTCOND */` 开头，会禁止该消息。格式：简单 生成消息的代码示例：

    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) 警告：常量在条件上下文中

消息标识：E_CONSTANT_CONDITION

## 取消定义求值顺序

变量由副作用进行更改，并在相同表达式的其它地方使用。格式：简单 生成消息的代码示例：

    1 static int      ia[10];
    2 void
    3 v(void)
    4 {
    5 	int             i = 2;
    6 	ia[i++] = i;
    7 }
    ============
    (6) 警告：取消定义求值顺序：i

消息标识：E_UNDEF_EVAL_ORDER

## 逻辑表达式总是为 false：op "&"

逻辑 `AND` 表达式可以检查两个不同常量相同变量的等价性，还可以将常量 0 作为操作数。对于后者，如果语句以 `/* CONSTCOND */` 开头，则会禁止该消息。格式：简单 生成消息的代码示例：

    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) 警告：逻辑表达式总是为 false：op "&"
    (7) 警告：逻辑表达式总是为 false：op "&"
    (8) 警告：逻辑表达式总是为 false：op "&"

消息标识：E_FALSE_LOGICAL_EXPR

## 逻辑表达式总是为 true：op "|| "

逻辑 `OR` 表达式可以检查两个不同常量相同变量的非等价性，还可以将非零整数常量作为操作数。对于后者，如果语句以 `/* CONSTCOND */` 开头，则会禁止该消息。格式：简单 生成消息的代码示例：

    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) 警告：逻辑表达式总是为 true：op "|| "
    (5) 警告：逻辑表达式总是为 true：op "|| "
    (6) 警告：逻辑表达式总是为 true：op "|| "

消息标识：E_TRUE_LOGICAL_EXPR

## 字符或无符号值与负常量或零的比较可疑

已经对“无格式”`char` 或`无符号`类型变量进行比较。该类型提示，其值可能为负或零。“无格式”`char` 视为`带符号`类型，或非负类型是由执行定义的。格式：简单 生成消息的代码示例：

    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) 警告：char 负常量的比较可疑：op "=="
    (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) 警告：无符号负常数的比较可疑：op ">"
    (6) 警告：无符号 0 的比较可疑：op "<"
    (7) 警告：无符号 0 的比较可疑：op "<="
    (8) 警告：无符号 0 的比较可疑：op ">="
    (9) 警告：无符号 0 的比较可疑：op "<"
    (10) 警告：无符号负常数的比较可疑：op "<"
    (11) 警告：无符号负常数的比较可疑：op "<"

消息标识：E_SUSPICIOUS_COMPARISON

## op 的常量操作数

`NOT` 运算符的操作数是常量。如果语句以 `/* CONSTCOND */` 开头，如果遇到该语句，会禁止该消息；如果使用 `-h` 调用 `lint`，如果遇到每个语句，会禁止该消息。格式：简单 生成消息的代码示例：

    1 void main(void)
    2  {
    3  	if (! 0) return;
    4  	/* CONSTCOND */
    5  	if (! 0) return;
    6  }
    ============
    (3) 警告：op 的常量操作数： "!"

消息标识：E_CONST_EXPR

## 将负常数赋值给无符号类型

已经将负常量赋值给无符号整数类型。无符号整数类型的值只能为正或零。 生成消息的代码示例：

    unsigned char uc = -1;
    unsigned int b = -13;

消息标识：E_ASSIGN_NEG_CONST_TO_UNSIGNED

## 常数被赋值截断

整型常量表达式已赋值或返回给整数类型的对象。如果不截断，则该对象不能具有该值。格式：简单 生成消息的代码示例：

    1 unsigned char
    2 f()
    3 {
    4 	unsigned char uc;
    5 	uc = 255;
    6 	uc = 256;
    7 	return uc;
    8 }
    ============
    (6) 警告：常数被赋值截断

消息标识：E_CONST_TRUNCATED_BY_ASSIGN

## 指针转换丢失位

已将指针赋值给小于该指针的整数类型对象。格式：简单 生成消息的代码示例：

    1 void
    2 v(void)
    3 {
    4 	int            *ip;
    5 	char            c;
    6 	c = ip;
    7 }
    ============
    (6) 警告：指针转换丢失位

消息标识：E_PTR_CONV_LOSES_BITS

## 数组下标不能为负

表示实际数组（相对于指针）下标的常量表达式具有一个负值。格式：简单 生成消息的代码示例：

    1 int
    2 main(void)
    3 {
    4 	int             ia[10];
    5 	return ia[5 * 2 / 10 - 2];
    6 }
    ============
    (5) 警告：数组下标不能为负： -1

消息标识：E_NEG_ARRAY_SUBSCRIPT

## 数组下标不能 > value

数组元素的下标值超过了数组的上界。格式：简单 生成消息的代码示例：

    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

消息标识：E_OVERFLOW_ARRAY_SUBSCRIPT

## 优先级可能不明确；请加括号

尚未给混合使用逻辑和按位运算符的表达式加括号。使用 `-h` 调用 `lint` 时，会禁止该消息。格式：简单 生成消息的代码示例：

    1 void
    2 v(void)
    3 {
    4 	int             i = 0, j = 0, x;
    5 	x = (2 + i == 0);
    6 	x = (i & j == 0);	/* eval'd (i & (j == 0)) */
    7 	x = (j == 1 & i);	/* eval'd ((j == 1) & i) */
    8 }
    ============
    (6) 警告：优先级可能不明确；请加括号
    (7) 警告：优先级可能不明确；请加括号

消息标识：E_PRECEDENCE_CONFUSION

## hp 上的 printf 和 scanf 例程系列不允许使用 long long 类型变量

在 HP-UX 上，printf 和 scanf 例程系列不支持打印或读取 long long 类型变量。

消息标识：E_HPUX_BAD_FORMAT_STR1

## hp 上的 printf 和 scanf 例程系列不允许使用 long long 类型变量

在 HP-UX 上，printf 和 scanf 例程系列不支持打印或读取 long long 类型变量。

消息标识：E_HPUX_BAD_FORMAT_STR2

## 名称已定义但从未使用：

已经定义变量或函数，但从未在源文件的任何位置对其进行访问。 生成消息的代码示例：

    int f();
    int main() {
    int a = 10;
    printf("never call function f() " );
    return 0;
    }
    int f() {
    return (1+1);
    }

消息标识：E_NAME_DEF_NOT_USED

## 名称已声明但从未使用或定义

已经声明变量或函数，但从未在源文件的任何位置对其进行访问。 生成消息的代码示例：

    int f();
    int main() {
    	int a;
    	printf("never call to function f() or use a");
    	return 0;
    }

消息标识：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 */
    return (y + g(x));   /* 在当前作用域内使用 x */
    }
    int g(int z) {
    return (x*z);       /* 在此处使用 x */
    }

消息标识：E_NAME_MULTIPLY_DEF

## 读取文件时出错

读取表示的文件时出现文件系统错误。这不是来自源程序的错误。

消息标识：E_F_RD_ERR

## 写入文件时出错

读取表示的文件时出现文件系统错误。这不是来自源程序的错误。

消息标识：E_F_WR_ERR

## 无法打开文件

读取表示的文件时出现文件系统错误。这不是来自源程序的错误。

消息标识：E_OPEN_F

## 枚举成员的声明不一致

定义`枚举`成员的不同值时所用的名称相同。 生成消息的代码示例：

    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)

消息标识：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)

消息标识：E_MCR_NODIFF

## 包含文件不必要

在程序编译期间未使用指定的包含文件。 生成消息的代码示例：

    #include <math.h>     /* 未使用数学函数 */
    int main () {
    	return 0;
    }

消息标识：E_INCL_NO_US

## 枚举成员已定义但从未使用

已找到未使用的`枚举`成员。 生成消息的代码示例：

    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)

消息标识：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)

消息标识：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)

消息标识：E_TYPEDEF_INCONSIST

## .c 文件无相应的 .h 文件

不存在与 `.c` 文件的名称相同的 `.h` 文件。格式：简单 生成消息的代码示例：

    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

消息标识：E_H_C_CHECK0

## 在 .h 文件中声明了 extern，但未在相应的 .c 文件中定义

`.h` 文件中已声明`外部`名称，但相应的 `.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)

消息标识：E_H_C_CHECK1

## 在 .c 文件中定义了 extern，但未在相应的 .h 文件中声明

`.c` 文件中已定义`外部`名称，但相应的 `.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)

消息标识：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 }
    ============

消息标识：E_UNCAL_F

## 语句执行不到

程序中包含执行不到的语句。 生成消息的代码示例：

    int f() {
    printf("return before reach\n");
    return 0;

    assert(FALSE);    /* <==== 执行不到该语句 */
    }

消息标识：E_STM_RCH

## 参数错误导致内存无法释放

该参数不是指向分配内存的指针。格式：简单 生成消息的代码示例：

    1 #include <stdlib.h>
    2 int            *ip;
    3 void
    4 main(void)
    5 {
    6 	free(*ip);
    7 	return;
    8 }
    ============
    f.c(6) 警告：参数错误导致内存无法释放

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：E_P_USE_DEALLOC

## 可能使用指向已释放内存的指针

可能使用指向已释放内存的指针。 生成消息的代码示例：

    1 #include <malloc.h>
    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 }
    ============

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：E_P_REF_UNINI

## 可能使用未初始化的指针的引用

可能存在使用未初始化指针的引用。 生成消息的代码示例：

    1 #include <malloc.h>
    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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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:警告：所赋的值从未使用：iq 的定义位置是 t2.c(4)；重置位置是 t2.c(7)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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 }
    ============

消息标识：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)

消息标识：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)

消息标识：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

消息标识：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

消息标识：E_VALUE_TYPE_PSB

## 执行不到的函数

Lint 已经确定，程序流决不会调用命名的函数。

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：E_P_WRT_NULL_PSBL

## 使用尚未初始化的指针做了修改

对指针进行初始化，使其指向对象之前，已非关联化该指针。 生成消息的代码示例：

    1 f() {
    2       int *p;
    3
    4       *p = 5;
    5 }
    ==========
    "t2.c", line 4:警告：使用尚未初始化的指针做了修改
    	p defined at t2.c(2)	:: t2.c(4)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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)

消息标识：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) defult in f

消息标识：E_LABEL_NOT_USED

## 空循环体

Lint 已检测不包含可执行语句的循环。 生成消息的代码示例：

    1       int i;
    2       for (i = 0; i < 5; i++) ; /* for 循环为空 */
    3       while (i < 7) { }	  /* while 循环为空 */

消息标识：E_LOOP_EMPTY

## 将参数转换为类型

实际参数已隐式转换成匹配参数的类型。格式：简单 生成消息的代码示例：

    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) 警告：浮点型已转换为 int：arg #1 of function f

消息标识：E_ARGUMENT_CONVERT

## 错误的文件号

编译器或 lint 检测到无效的文件号（大于文件列表中的可用插槽）。这是一个内部错误。

消息标识：E_BAD_FILE_NUMBER

## 源代码行不可访问

`lint` 无法打印与消息对应的源文件，因为该源文件不可访问，例如，该源文件可能已经重新命名、删除或移动。格式：简单 生成消息的代码示例：

      |
    |******* 源代码行不可访问 ...
    |              !  line 677, file.c
    警告：所赋的值从未使用：ReturnVal

消息标识：E_SRC_LINE_UNACCESSIBLE

## 由于文件包含 #line 指令，找不到源代码行

某些 `#line` 指令可以防止 `lint` 打印与该消息对应的源代码行。格式：简单 生成消息的代码示例：

    file f.c:
    1 #line 20 "nofile.c"
    2 int             i;
    3 void
    4 main(void)
    5 {
    6 	return 99;
    7 }
    ============
          |
    |******* 由于文件包含 #line 指令，找不到源代码行
    |!  line 24, nofile.c
          |
    错误:void 函数不能返回值

消息标识：E_SRC_LINE_UNACCESSIBLE2

## 参数与原型不兼容

对于已经调用的函数，其参数类型无法转换成该函数的函数原型声明中的类型 生成消息的代码示例：

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

消息标识：E_ARG_INCOMPATIBLE_WITH_ARG_L

## 表达式或子表达式为空值

该代码包含无效的表达式或子表达式。 生成消息的代码示例：

    int g() {
            1;
    return 0;
    }

消息标识：E_EXPR_NULL_EFFECT

## 返回类型被转换为函数返回类型

已经从该函数返回的类型与其声明的返回类型不同，所以编译器无法将其转换成该函数的返回类型 生成消息的代码示例：

    1 char f() {
    2        return 0xffffffffL;
    3 }

消息标识：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", line 6:警告：从 32 位整数转换为指针

消息标识：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", line 6:警告：从 64 位整数转换为 32 位整数

消息标识：E_CAST_INT_TO_SMALL_INT

## 从 n 位整数常量表达式转换为 m 位整数

将整数常量表达式显式转换为小于该整数常量表达式类型的整数类型。 生成消息的代码示例：

    1 void
    2 v(void)
    3 {
    4	char            c;
    5	c = (char) 1024;
    6 }
    ============
    "t.c", line 5:警告：从 32 位整数常量表达式转换为 8 位整数

消息标识：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", line 6:警告：将 64 位整数赋值给 32 位整数

消息标识：E_ASSIGN_INT_TO_SMALL_INT

## 赋值时将 n 位常量截断为 m 位

整型常量表达式已赋值或返回给整数类型的对象。如果不截断，则该对象不能具有该值。 生成消息的代码示例：

    1 void
    2 v(void)
    3 {
    4	char            c;
    5	c = 1024;
    6 }
    ============
    "t.c", line 5:警告：赋值时将 32 位常量截断为 8 位

消息标识：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", line 11:警告：传递的是 64 位整数参数，应该是 32 位整数：print_int(arg 1)

消息标识：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", line 10:警告：传递的是 64 位整数常量参数，应该是 32 位整数：printi(arg 1)

消息标识：E_PASS_INT_FROM_BIG_CONST

## ?: 正在使用运算符选择锁定参数

在 mutex_lock 函数调用中使用 ?:运算符时，lock_lint 无法确定已经使用的锁定。Lock_lint 将会假设，函数调用中已经使用指定的锁定。 生成该消息的代码示例：

    int waitWriter;
    f() {
    mutex_t mutex1, mutex2;

    mutex_lock((waitWriter == 0) ?&mutex1 :&mutex2);
    }

消息标识：E_CONDITIONAL_OP_LOCKCHOICE

## 未预料的一元运算符

在 #`if` 或 #`elif` 指令中已检测到意味的一元运算符。 生成消息的代码示例：

    main()
    {
    #define x 0
    #define y 1

    #if x ! y == 0
    printf("Hello\n");
    #endif
    }

消息标识：E_UNEXPECTED_UNARY

## 指向任意对象或函数的指针不能等同于空指针

使用 `-p` 选项显示该警告。编译器可能会对指向任意对象或函数的指针进行优化，使其始终作为 true 进行求值。 生成消息的代码示例：

    extern int foo;
    #pragma weak foo
    int main()
    {
    if (&foo)
    return foo;
    }

消息标识：E_POINTER_TO_OBJECT

## 在小于指针大小的整数类型的常数初始化程序中不允许出现地址

常量初始化程序中的地址必须是运算常量表达式。作为扩展，地址可以出现在大小大于或等于指针大小的整数类型的常量初始化程序中。不允许出现在大小小于指针大小的整数类型的常数初始化程序中。 生成消息的代码示例：

    int x;
    char c = &x;

消息标识：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", line 6:警告：将 32 位整数与 64 位整数进行比较

消息标识：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", line 6:警告：将 32 位无符号整数赋值给 32 位带符号整数

消息标识：E_ASSIGN_UINT_TO_SIGNED_INT

## 传递的是 n 位无符号整数，应该是 n 位带符号整数

函数调用包含无符号整数类型的参数，其中函数定义中形式参数的类型是大小相等的带符号整数类型。使用 -errchk=longptr64 或 -errchk=sizematc 选项发出该错误消息。 生成消息的代码示例：

    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", line 11:警告：传递的是 32 位无符号整数参数，应该是 32 位带符号整数：print_int(arg 1)

消息标识：E_PASS_UINT_TO_SIGNED_INT

## 将 n 位无符号整数转换为 n 位带符号整数

将无符号整数类型对象显式转换成大小相等的带符号整数类型。 生成消息的代码示例：

    1 void
    2 v(void)
    3 {
    4	int             i;
    5	unsigned int   ui;
    6	i = (int) ui;
    7 }
    ============
    "t.c", line 6:警告：将 32 位无符号整数转换为 32 位带符号整数

消息标识：E_CAST_UINT_TO_SIGNED_INT

## 忽略格式错误的 #pragma error_messages

`#pragma error_messages` 所用的语法不正确。必须采用下列方式指定 `error_messages` pragma：

    #pragma error_messages ({on|off|default}, errtag1 [,errtag2, ...,errtag-n])

生成此消息的代码示例：

    #pragma error_messages {off:E_BAD_PTR_INT_COMBINATION, }

消息标识：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", line 1:在 #pragma weak symbol1 = symbol2 中，symbol1 和 symbol2 不能相同function_name
    cc:acomp failed for test.c

消息标识：E_SYMBOL_IN_PRAGMA_WEAK

## 非常量初始化程序中包含强制类型转换

`extern、static` 或 `array` 对象的初始化程序必须是编译时常量。如果用 `{}` 将初始化程序括起来，则自动结构或联合的初始化程序还必须是编译时常量。整数常量表达式中的转换运算符只能将运算类型转换为整数类型。例如，指针类型到运算类型的转换不是常量表达式。另外，如果要初始化的变量类型小于指针，则编译器会发出该错误消息。 生成消息的代码示例：

    extern  int     myf();
    int (*  fptr)() = (int (*)())((int)myf + 1);

消息标识：E_NON_CONST_INIT_SCONV

## 未定义 __STDC_VERSION__

ISO C 禁止取消定义预定义的符号 `__STDC_VERSION__`。您可能需要使用该功能测试已经编写的 C 代码。这些代码可以同时在 ISO C 和非 ISO C 环境下工作。 例如，假定拥有可以检查 `__STDC_VERSION__` 的 C 代码，同时声明函数原型声明（如果定义）和旧式函数声明或定义（如果未定义）。因为 C 编译器预定义了 `__STDC_VERSION__`，所以在一般情况下，无法检查旧式代码，必须通过其它（非 ANSI C）编译器运行该代码。通常，在命令行中取消定义 `__STDC_VERSION__` 之后，可以使用 C 执行检查操作。该诊断信息说明，您违反了 ISO C 约束规定。 生成消息的代码示例：

    #undef __STDC_VERSION__	/* 通常是 -U__STDC_VERSION_ */
    /* _on cc line */

    #ifdef __STDC_VERSION__
    int
    myfunc(const char *arg1, int arg2)
    #else	/* 非 ISO C 条件 */
    int
    myfunc(arg1,arg2)
    char *arg1,	/* oops */
    int arg2;
    #endif
    {
    }

消息标识：E_UNDEFINING__STDC_VERSION__

## 尚未声明 `#pragma ?` 中的函数

在指定的 pragma 中使用函数名称之前，编译器已经遇到必须定制为原型的该函数名称。 生成消息的代码示例：

    /* abc 函数并未在任何位置定义或声明 */
    #pragma inline (abc)

============ 函数 abc 应该在 pragma 之前定制原型：

    int abc();
    #pragma inline (abc)

消息标识：E_PRAGMA_FUNC_UNDECLARED

## 标识符必须为 `#pragma ?` 指定函数

编译器已经遇到不是函数名称的标识符，其中指定的 pragma 需要该函数名称。 生成消息的代码示例：

    int abc;
    #pragma inline (abc)

消息标识：E_PRAGMA_FUNC_REQUIRED

## 忽略格式错误的 #pragma ?

已经使用错误的语法指定指出的 `#pragma`。pragma 的正确语法如下：

    #pragma  (funcname [, funcname ...])

生成消息的代码示例：

    #pragma no_side_effect {a b}

消息标识：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) 警告：将无符号的整数类型提升为较大的整数类型或指针大小可能会产生未预料的结果，不进行符号扩展。

消息标识：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) 警告：在下标求值期间将无符号整数提升为指针大小会产生不可预料的结果，无符号扩展。

消息标识：E_UNEXPECTED_UINT_PROMOTION_SUB

## 从 n 位到 m 位整数的符号扩展

如果编译器将带符号整数类型的操作数提升为较大的无符号整数类型，则会扩展符号。 生成消息的代码示例：

    1	void main()
         2	{
    3		int i = -1;
    4		unsigned long ul;
         5
    6		ul = (unsigned long)i;
         7	}
    ============
    (6) 警告：从 32 位到 64 位整数的符号扩展

消息标识：E_SIGN_EXTENSION_PSBL

## `#pragma opt` 级别已减小到 -xmaxopt 的值

编译器已经遇到级别超过命令行 -xmaxopt 值的 `#pragma opt`。该 `#pragma opt` 遇到的函数优化级别已减少到编译器 -xmaxopt 选项指定的值。 生成消息的代码示例：

    int abc(); /* 使用 -xO5 -xmaxopt=2 调用编译器 */
    #pragma opt 4 (abc)

消息标识：E_PRAGMA_OPT_REDUCED

## 忽略格式错误的 `#pragma opt`

指定 `#pragma opt` 时所用的语法不正确。pragma 的正确语法如下：

    #pragma opt level (funcname [, funcname ...])

生成消息的代码示例：

    #pragma opt 3 {a b}

消息标识：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) ;

消息标识：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	}

消息标识：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  }

-#

消息标识：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;
    }

消息标识：E_STRUCT_SIZE_TOO_BIG

## #pragma 中的结构/联合缺少标记

缺少结构或联合关键字之后的标记，或者结构或联合关键字之后的标记未引用该 #pragma 之前正确声明的结构或联合。 生成消息的代码示例：

    /* 尚未定义结构 bar */
    void foo() {
    #pragma alias_level strict (struct bar)
    return;
    }

消息标识：E_ALIAS_NO_TAG

## 在 #pragma 中使用之前必须定义结构 `<name>`

在该 pragma 中使用之前，必须将指定的标识符定义为结构。 生成消息的代码示例：

    union bar { int field; };
    void foo() {
    #pragma alias_level strict (struct bar)
    return;

}

消息标识：E_ALIAS_NOT_A_STRUCT

## 在 #pragma 中使用之前必须定义联合 `<name>`

在该 pragma 中使用之前，必须将指定的标识符定义为联合。 生成消息的代码示例：

    struct bar { int field; };
    void foo() {
    #pragma alias_level strict (union bar)
    return;
    }

消息标识：E_ALIAS_NOT_A_UNION

## 在 #pragma 中使用之前必须定义枚举 `<name>`

在该 pragma 引用之前，必须将指定的标识符声明为枚举。 生成消息的代码示例：

    /* 尚未定义枚举 bar */
    void foo() {
    #pragma alias_level strict (enum bar)
    return;
    }

消息标识：E_ALIAS_NOT_AN_ENUM

## 在 #pragma 使用之前，必须将 `<name>` 定义为指针

在该 pragma 中引用之前，必须将指定的标识符声明为指针。 生成消息的代码示例：

    int bar;
    void foo() {
    #pragma alias_level strict (bar)
    return;
    }

消息标识：E_ALIAS_EXPECTING_POINTER

## `<type>` 不是结构

将该消息中记录的标识符用作该 pragma 中的结构之前，不能将其声明为结构。 生成消息的代码示例：

    enum abc {one, two};
    #pragma alias_level strict (struct abc)

消息标识：E_ALIAS_STRUCT_LIE

## `<type>` 不是联合

将该消息中记录的标识符用作该 pragma 中的联合之前，不能将其声明为联合。 生成消息的代码示例：

    enum abc {one, two};
    #pragma alias_level strict (union abc)

消息标识：E_ALIAS_UNION_LIE

## `<type>` 不是枚举

将该消息中记录的标识符用作该 pragma 中的枚举之前，不能将其声明为枚举。 生成消息的代码示例：

    struct abc {int field;};
    #pragma alias_level strict (enum abc)

消息标识：E_ALIAS_ENUM_LIE

## #pragma 中应该有类型

指定的 pragma 中提供的不是类型。`#pragma alias` 和 `alias_level` 应该有类型列表。 生成消息的代码示例：

    int i;
    #pragma alias_level strict (i)

消息标识：E_ALIAS_EXPECTING_TYPE

## 在 #pragma 使用之前，必须将 `<identifier>` 声明为变量

在该 pragma 中引用之前，必须将指定的标识符声明为变量。 生成消息的代码示例：

    int myfunc();
    #pragma alias (myfunc)

消息标识：E_ALIAS_EXPECTING_VARIABLE

## 忽略格式错误的 #pragma alias_level

alias_level pragma 的格式如下：

    #pragma alias_level  (  [, ]... )
    #pragma alias_level  (  [, ]... )

生成消息的代码示例：

    #pragma alias_level std (

消息标识：E_IGNORE_BAD_ALIAS_LEVEL_PRAGMA

## 忽略格式错误的 #pragma alias

alias pragma 的格式如下：

    #pragma alias (  [, ]... )
    #pragma alias ( ,  [, ]... )

生成消息的代码示例：

    #pragma alias (

消息标识：E_IGNORE_BAD_ALIAS_PRAGMA

## 忽略格式错误的 #pragma noalias

alias pragma 的格式如下：

    #pragma noalias (  [, ]... )
    #pragma noalias ( ,  [, ]... )

生成消息的代码示例：

    #pragma alias (

消息标识：E_IGNORE_BAD_NOALIAS_PRAGMA

## 忽略格式错误的 #pragma may_point_to

may_point_to pragma 的格式如下：

    pragma may_point_to ( ,  [, ]... )

生成消息的代码示例：

    #pragma may_point_to (

消息标识：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 (

消息标识：E_IGNORE_BAD_MAYNOTPTTO_PRAGMA

## %s（在 #pragma %s 中）必须为指针

may_not_point_to 和 may_point_to 的 pragma 格式如下：

    pragma may_not_point_to ( ,  [, ]... )
    pragma may_point_to ( ,  [, ]... )

生成消息的代码示例：

    int i, j;
    #pragma may_point_to ( i, j);

消息标识：E_POINTTO_NOT_A_POINTER

## 可疑的换码：\c

只有某些字符才能跟在字符串文字和字符常量中的 \ 之后：`\' \" \? \\ \a \b \f \n \r \t \v \<octal-digit> \x<hexadecimal-digit>`.ANSI C 会忽略 \。 生成消息的代码示例：

    int i = '\c';

消息标识：E_DUBIOUS_ESCAPE_MBCHAR

## #pragma %s 必须位于文件范围或函数作用域

别名 pragma 只能在文件或函数作用域内使用。 生成消息的代码示例：

    struct s1 {...};
    struct s2 {...};
    main()
    {
      {
    #pragma alias (struct s1, struct s1)
      }
    }

消息标识：E_IGNORE_BAD_SCOPE_FOR_PRAGMA

## 参数的类型不完整：%s

用指针代替不完整的数组类型，以其作为函数原型中的参数。 生成消息的代码示例：

    main()
    {
    extern somefunc(void array[]);
    }

消息标识：E_ARRAY_OF_INCOMPLETE

## 参数为不完全类型

用指针代替不完整的类型，以其作为函数原型中的参数。 生成消息的代码示例：

    struct xxx;
    extern lastfunc(struct xxx xs[]);

消息标识：E_ARRAY_OF_INCOMPLETE_NONAME

## 自动变量太大

自动变量声明已构造，所以声明的对象不适合于目标计算机的栈。 生成消息的代码示例：

    void foo(void) {
    	int big_array[0x100000000LL];
    }

消息标识：E_AUTO_VARIABLE_TOO_BIG

## 标量指针被转换为结构指针

对 -xalias_level 允许的优化进行别名分析时，如果将标量指针转换为结构指针，可能会取消定义功能。 生成消息的代码示例：

    struct foo {
    int a;
    };

    struct foo *foop;
    int *p;

    void
    main()
    {
    foop = (struct foo *)p;
    }

消息标识：E_CAST_SCALAR_TO_STRUCT

## void 指针被转换为结构指针

对 -xalias_level 下允许的优化进行别名分析时，如果将 void 指针转换为结构指针，可能会取消定义功能。 生成消息的代码示例：

    struct foo {
    int a;
    };

    struct foo *foop;
    void *p;

    void
    main()
    {
    foop = (struct foo *)p;
    }

消息标识：E_CAST_VOID_PTR_TO_STRUCT

## 结构字段被转换为标量指针

对 -xalias_level 下允许的优化进行别名分析时，如果将结构字段转换为结构指针，可能会取消定义功能。 生成消息的代码示例：

    struct foo {
    int a;
    };

    struct foo *foop;
    int *p;

    void
    main()
    {
    p = (int *)&foop.a
    }

消息标识：E_CAST_SCALAR_STRUCT_TO_SCALAR

## 将结构指针转换为结构指针要求满足 alias_level=strict 的显式别名

对 -xalias_level=strict 下允许的优化进行别名分析时，如果将指针转换为两个无别名的结构，可能会取消定义功能。 生成消息的代码示例：

    struct fooa {
    int a;
    };

    struct foob {
    int b;
    };

    struct fooa *fooaa;
    struct foob *foobb;

    void
    main()
    {
    fooaa = (struct fooa *)foobb;
    }

消息标识：E_CAST_STRUCT_TO_STRUCT

## 将标量指针转换为标量指针要求满足除 any 之外的所有 -xalias_level 的显式别名

对 -xalias_level=weak 和更高级别下允许的优化进行别名分析时，如果将标量指针转换为标量，可能会取消定义功能。 生成消息的代码示例：

    int *ip;
    long *lp;

    void
    main()
    {
    ip = (int *)lp;
    }

消息标识：E_CAST_SCALAR_TO_SCALAR

## 将非标量指针转换为标量指针仅在 -xalias_level=any 时有效

对 -xalias_level=weak 和更高级别下允许的优化进行别名分析时，如果将非标量指针转换为标量指针，可能会取消定义功能。 生成消息的代码示例：

    int *ip;
    long a[10];

    void
    main()
    {
    ip = (int *)a[3];
    }

消息标识：E_CAST_NONSCALAR_TO_SCALAR

## threadprivate 指令必须显示在文件作用域内

threadprivate 指令必须出现在文件作用域内，而在定义或声明之外。 生成消息的代码示例：

    int i;

    void
    main()
    {
    #pragma omp threadprivate(i)
    }

消息标识：E_OMP_NONFILE_THREADPRIV

## 在 threadprivate pragma 中指定的变量必须为外部变量或静态变量

threadprivate 指令列表中的每个变量必须具有文件作用域重新声明。 生成消息的代码示例：

    void
    main()
    {
    int i;
    #pragma omp threadprivate(i)
    }

消息标识：E_OMP_AUTO_THREADPRIV

## threadprivate 指令必须位于所有变量引用之前

Threadprivate 指令必须按照字典方式位于列表中所有变量引用之前。 生成消息的代码示例：

    int i;

    void foo() {
    i = 10;
    }

    #pragma omp threadprivate(i)

消息标识：E_OMP_THREADPRIV_REF

## threadprivate、firstprivate、lastprivate 和 private 变量必须具有不完整的类型

threadprivate、firstprivate、lastprivate 和 private 变量不能具有不完整的类型。 生成消息的代码示例：

    struct S s;

    #pragma omp threadprivate(s)

    struct S {
    int i;
    }
    void foo() {
    #pragma omp parallel private(s)
      {
      }
    }

消息标识：E_OMP_VAR_INCOMPLETE

## 该子句中不允许使用 threadprivate 变量

不能在 private、firstprivate、lastprivate、shared 或 reduction 子句中使用 threadprivate 变量。但是，这些变量不受缺省子句的影响。 生成消息的代码示例：

    int i;
    #pragma omp threadprivate(i)

    void
    main()
    {
    #pragma omp parallel private(i)
    i++;
    }

消息标识：E_OMP_THREADPRIV_WRONG_CLAUSE

## 不能在多个子句中指定变量

不能在多个子句中指定变量，除非该变量可以同时在 firstprivate 和 lastprivate 子句中指定。 生成消息的代码示例：

    void
    main()
    {
    int i;
    #pragma omp parallel private(i) copyin(i)
    i++;
    }

消息标识：E_OMP_DUP_CLAUSE

## 专用变量不能有常量限定的类型

在 private（或 lastprivate）子句中指定的变量不能有常量限定的类型。 生成消息的代码示例：

    void
    main()
    {
    const int ci;
    #pragma omp parallel private(ci)
          ;
    }

消息标识：E_OMP_CONST_PRIVATE

## 已在封装 openmp pragma 中将变量指定为专用变量

不能在封装共享作业或并行指令的 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++;
      }
    }

=======

消息标识：E_OMP_PRIVATE_PRIVATE

## 语法错误：初始化程序为空

初始化程序的大括号内不包含任何内容。 生成消息的代码示例：

    struct {int i;} = {};

消息标识：E_EMPTY_INITIALIZER

## ptrdiff_t 可能溢出

如果两个指针的差异可以通过 ptrdiff_t 溢出，则显示的是该消息。 在下面的示例中，如果遇到 char 指针差异，会生成该消息。请注意，如果遇到 int 指针差异，将不会生成该消息。

    #include
    void foo(void){
    char *pc1, *pc2;
    int * pi1, *pi2;
    ptrdiff_t ptrdiff;
    ptrdiff = pc1 - pc2;
    ptrdiff += pi1 - pi2;
    }

消息标识：E_PTRDIFF_OVERFLOW

## 结构错误的 OpenMP pragma

在 OpenMP pragma 中发现通用语法错误时显示此消息。 生成消息的代码示例：

    void main() {

    #pragma omp parallel private
      {
      }
    }

消息标识：E_OMP_SYNTAX_ERROR

## 不能将 inline 关键字应用于函数 \"main\"

生成消息的代码示例：

    void
    inline main()
    {
    int i;

    i = 1;
    }

消息标识：E_INLINE_MAIN

## 未在翻译单元中定义外部内联函数 \"%s\"

生成消息的代码示例：

    inline void foo();
    extern foo();

    void
    main()
    {
    foo();
    }
    =======

消息标识：E_EXTERN_INLINE_UNDEFINED

## 语法错误：成员声明为空

代码包含空的结构成员声明。 生成消息的代码示例：

    struct {
    int i;;
    } s;

消息标识：E_EMPTY_MBR_DECLARATION

## schedule 子句中存在错误的 chunksize 表达式

如果 OpenMP for pragma 的 schedule 子句中指定的 chunksize 表达式格式错误，则会显示该消息。 生成消息的代码示例：

    void main() {
    int i;
    #pragma omp parallel for schedule(static,1.0)
    for (i=0;i<10;i++) {
      }
    }

消息标识：E_OMP_BAD_CHUNKSIZE

## 在运行时 schedule 中不允许指定块大小

Chunksize 值没有意义，所以不能在 OpenMP for pragma 的运行时 schedule 中使用。 生成消息的代码示例：

    void main() {
    int i;
    #pragma omp parallel for schedule(runtime,1)
    for (i=0;i<10;i++) {
      }
    }

消息标识：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++) {
      }
    }

消息标识：E_OMP_BAD_SCHEDULE_KIND

## 在外部内联函数中定义非常量静态变量

生成消息的代码示例：

    void foo() {
    static int j = 1;

    i += j;
    }

消息标识：E_DEF_STATIC_INLINE_EXTERN

## 标签后应该跟一条语句（可为空语句）

ANSI C 标准要求，标签的后面要跟一条语句。GNU C 扩展允许使用这种构造，但是显示的是该警告，所以使用 `-Xs`选项时，显示的是错误。 生成消息的代码示例：

    void
    main()
    {
    some_label:
    }

消息标识：E_LABEL_NO_STMT

## 在标识符和类对象宏的替换列表之间需要空白

定义 object-like 宏时，标识符和替换列表之间将会存在空白。 生成消息的代码示例：

    #define THIS$AND$THAT(a, b)  ((a) + (b))
    int c = THIS$AND$THAT(1, 7);

消息标识：E_NO_WHITE_SPACE

## if 子句表达式没有标量类型

在 OpenMP 并行区域的 if 子句中指定的表达式必须具有标量类型。 生成消息的代码示例：

    void main() {
    struct { int val; } true = {1};

    #pragma omp parallel if(true)
    	printf("Hello,worlds!\n");
    }

消息标识：E_OMP_BAD_IF_TYPE

## omp for 循环的初始化表达式形式不规范

OpenMP for 的 Init 表达式必须采用规范的形式，如下： = 或 = 生成消息的代码示例：

    void main() {
    int i=0;
    #pragma omp parallel for
    for (; i<10; i++) {
      }
    }

消息标识：E_OMP_FOR_BAD_INIT

## omp for 循环的索引变量必须是带符号整数

OpenMP for 的索引变量必须具有带符号的整数类型 生成消息的代码示例：

    void main() {
    unsigned char c;
    #pragma omp parallel for
    for (c=0; c<10; c++) {
      }
    }

消息标识：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++) {
      }
    }

消息标识：E_OMP_FOR_BAD_CONTROL

## omp for 循环的迭代表达式形式不规范

OpenMP for 迭代表达式的形式必须规范。 生成消息的代码示例：

    void main() {
    int i;
    #pragma omp parallel for
    for (i=0; i<10; foo(&i)) {
      }
    }

消息标识：E_OMP_FOR_BAD_ITER

## copyin 变量不是 threadprivate 变量

在 copyin 子句中指定的变量必须是 threadprivate 变量。 生成消息的代码示例：

    void main() {
    int i;
    #pragma omp parallel copyin(i)
    	i++;
    }

消息标识：E_OMP_COPYIN_NOT_THREADPRIVATE

## inline、restrict、_Bool、_Complex 和 _Imaginary 是 ISO C99 中的关键字

C99 引入了下列新的关键字：inline restrict _Bool _Complex _Imaginary 生成消息的代码示例：

    int _Bool;

消息标识：E_KEYWORD_IN_C99

## 未指定长度的变长数组只能作用原型参数

可以使用未指定的大小 (via[*]) 声明变量长度数组。只有这种声明才能在使用函数原型作用域的重新声明中使用。 生成消息的代码示例：

    int foo (int a[*]) {
    typedef int A[*];
    }

消息标识：E_UNSPEC_VLA_SIZE

## 不能在文件范围声明反复修改的类型

不能在文件作用域内声明反复修改的类型。 生成消息的代码示例：

    int n;
    typedef int A[n];
    int a[n];

消息标识：E_CANT_DECL_FILESCOPE_VM

## 变量长度数组不能用静态存储类声明

如果标识符声明为使用静态存储持续时间的对象，则不会具有变量长度数组类型。 生成消息的代码示例：

    int foo(int n) {
    static int a[n];
    }

消息标识：E_STATIC_VLA

## 成员不能具有反复修改的类型

只有普通标识符才能具有反复修改的类型。因此，不允许结构/联合成员具有这种类型。 生成消息的代码示例：

    void foo() {
    int n;
    struct s { int a[n]; };
    }

消息标识：E_MEMBER_CANT_BE_VM

## 变量长度数组不能初始化

不允许初始化变量长度数组。 生成消息的代码示例：

    void foo() {
    int n;
    int x[n] = { 1 };
    }

消息标识：E_CANT_INIT_VLA

## 数组长度表达式不是整数类型

指定数组大小的表达式将会具有整数类型。 生成消息的代码示例：

    void foo() {
    int a[1.1];
    float f;
    int b[f];
    }

消息标识：E_ARRAY_SIZE_NONINTEGER

## 数组长度表达式中的存储类关键字错误

只有静态关键字才能在数组大小表达式中指定。 生成消息的代码示例：

    int a[extern 3];

消息标识：E_BAD_ARRSIZE_STORAGE_CLASS

## 类型说明符不能用作数组长度表达式限定词

只有关键字 static 和类型限定符（const、restrict 和 volatile）才能在数组大小表达式中指定。 生成消息的代码示例：

    int a[int 3];

消息标识：E_ARRSIZE_TYPE_SPECIFIER

## 只能限定函数参数的最外层数组类型派生

只有在声明使用数组类型的函数参数和派生外部数组时，才会出现可选的类型限定符和关键字 static。 生成消息的代码示例：

    int a[static 3];
    int bar(int[*][restrict]);

消息标识：E_CANT_QUAL_NONPARAM_ARY

## 未指定长度的变长数组只能作用原型参数

可以使用未指定的大小 (via[*]) 声明变量长度数组。只有这种声明才能在使用函数原型作用域的重新声明中使用。 生成消息的代码示例：

    int foo() {
    int i = sizeof(int[*]);
    }

消息标识：E_UNSPEC_VLA_SIZE_NONAME

## pragma 的 openmp for 之后未跟 for 循环

OpenMP for 和 parallel for 构造之后必须跟 for 循环语句。 生成消息的代码示例：

    int foo() {
    #pragma omp parallel for
    while(1) {
      }
    }

消息标识：E_OMP_FOR_WITHOUT_FOR

## 算术表达式中用了指向 void 或函数的指针

表达式中使用了指向 void 或函数的参数类型指针。假设 void 或函数的大小为 1。 生成消息的代码示例：

    void *mem = (void*)7, *retval;
    int sz = 4;
    retval = mem + sz;

消息标识：E_PTR_TO_VOID_IN_ARITHMETIC

## #warning 指令中的标记错误

`#warning` 指令中的标记必须是有效的 C 标记。源程序包含无效的标记。 生成消息的代码示例：

    #warning 038 - this is an invalid token

消息标识：E_BAD_TOKEN_IN_WARN_DIRECTIVE

## #warning

在源文件中遇到 `#warning` 指令。该指令中的其它标记已作为消息的一部分打印。 生成消息的代码示例：

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

消息标识：E_WARNING_PRAGMA

## 不允许转到带有反复修改类型的标识符范围中

goto 语句不能从具有反复修改类型的标识符作用域之外跳转到该标识符作用域之内。 生成消息的代码示例：

    void foo() {
    int n = 10;
       {
    	int a[n];
    	vla_scope:
    	a[n-1] = 0;
       }
    goto vla_scope;
    }

消息标识：E_GOTO_INTO_VLA_SCOPE

## 不能对 openmp 指令加标签

OpenMP 指令 flush 和 barrier 不是语句，所以不能加标签。 生成消息的代码示例：

    void foo() {
    int i;
    wrong_label:
    #pragma omp barrier
    i++;
    }

消息标识：E_OMP_LABELED_DIRECTIVE

## 简约变量未共享

在 reduction 子句中指定的变量必须在封装的上下文中进行共享。 生成消息的代码示例：

    void main() {
    int i;
    #pragma omp parallel private(i)
    	#pragma omp sections reduction(+:i)
    	{
    	   i++;
    	}
    }

消息标识：E_OMP_REDUCTION_NOTSHARED

## 约简变量不能有常量限定的类型

在 reduction 子句中指定的变量不能有常量限定的类型。 生成消息的代码示例：

    void
    main()
    {
    const int ci;
    #pragma omp parallel reduction(+:ci)
          ;
    }

消息标识：E_OMP_CONST_REDUCTION

## 约简变量的类型无效

对于 reduction 运算符，reduction 语句中指定的变量类型必须是有效的，除非从未允许使用该指针类型。 生成消息的代码示例：

    void
    main()
    {
    float f;
    #pragma omp parallel reduction(^:f)
          ;
    }

消息标识：E_OMP_REDUCTION_BADTYPE

## 未内联函数 \"%s\"。已经定义为外部函数。

生成消息的代码示例：

    extern int foo(int i)
    {
    i++;

    return i;
    }

    inline int foo(int i);

消息标识：E_INLINE_DEFINED_EXTERN

## 函数 \"%s\" 不是外部函数。已经定义为内联函数。

生成消息的代码示例：

    inline int foo()
    {
    return 5;
    }

    extern foo(void);

消息标识：E_INLINE_DEFINED_INLINE

## 形式错误的 STDC pragma

在 OpenMP pragma 中发现通用语法错误时显示此消息。 生成消息的代码示例：

    #pragma STDC L_FENV_ACCESS ON
    /* 使用的是“ON”，而不是“on” */

消息标识：E_STDC_SYNTAX_ERROR

## 非指针类型不能带 restrict 限定词

Restrict 限定符仅对指针类型有效。除指针类型之外的类型不是 restrict 限定的。 生成消息的代码示例：

    restrict int a;

消息标识：E_NON_PTR_CANT_RESTRICT_QUAL_2

## 在 non-ordered for 的词法范围内使用了 ordered 指令

OpenMP 指令 ordered 不能位于指令的动态范围内。其中，该指令尚未指定 ordered 子句。 生成消息的代码示例：

    void
    main()
    {
    int i, a = 0;
    #pragma omp for
    for (i=0; i<10; i++) {
    #pragma omp ordered
    	a+=i;
      }
    }

消息标识：E_OMP_NONORDERED_FOR

## ordered 指令位于 for 指令的文字范围之外

OpenMP 指令 ordered 必须位于具有 ordered 子句的 for 或 parallel-for 构造动态范围之内。 生成消息的代码示例：

    void
    main()
    {
    int i, a = 0;
    for (i=0; i<10; i++) {
    #pragma omp ordered
    	a+=i;
      }
    }

消息标识：E_OMP_ORDERED_NOFOR

## section 指令只能在 sections 指令内部使用

section 指令 section 必须出现在 sections 指令的词法范围之内 生成消息的代码示例：

    void
    main()
    {
    int i;
    #pragma omp parallel
      {
    #pragma omp section
    	i++;
      }
    }

消息标识：E_OMP_SECTION_NO_SECTIONS

## default 子句的值不正确

对于 default 子句，只有 none 或 shared 才是有效值。 生成消息的代码示例：

    void
    main()
    {
    int i;
    #pragma omp parallel default(private)
      {
    	i++;
      }
    }

消息标识：E_OMP_BAD_DEFAULT

## #pragma alias_level 只在文件范围内有效。

Pragma alias_level 只在文件作用域内有效，因为通过 pragma 设置的别名级别被应用于其余的翻译单元中。 生成消息的代码示例：

    struct s1 {...};
    struct s2 {...};
    foo()
    {
    #pragma alias_level strict (struct s1, struct s2)
    }

消息标识：E_FILE_SCOPE_ALIAS_LEVEL_PRAGMA

## 宏定义 _Pragma 隐藏了预处理运算符 _Pragma

预处理运算符 _Pragma 可以通过宏定义进行重新定义。但是，这样的重新定义会完全隐藏 _Pragma 运算符。 生成消息的代码示例：

    #define _Pragma printf("Pragma\n")

消息标识：E_PP_PRAGMA_REDEFINED

## _Pragma 运算符中的参数不匹配

预处理运算符 _Pragma 获取了一个应该是单个字符串文字的参数。 生成消息的代码示例：

    _Pragma("omp", "parallel")
    _Pragma("omp" "parallel")

消息标识：E_PP_PRAGMA_ARG_MISMATCH

## 不允许 pragma critical 以相同的名称嵌套在 critical 中

不允许具有相同名称的 critical 指令相互嵌套 生成消息的代码示例：

    void main(void) {
    #pragma omp critical(foo)
    #pragma omp critical(foo)
            ;
    }

消息标识：E_OMP_BAD_CRITICAL_NESTING

## 声明不能位于语句之后

重新声明必须位于所有语句之前。 生成消息的代码示例：

    void main(void) {
    int i = 1;
    i++;
    int j = i;
    }

消息标识：E_DECLARATION_IN_CODE

## 声明语句不能出现在 for 循环的初始化部分

for 语句的初始化部分只能是表达式语句。 生成消息的代码示例：

    void main(void) {
    for (int i = 1; i<10; i++);
    }

消息标识：E_DECLARATION_IN_FOR

## for 循环声明中包含错误的存储类

for 语句的声明部分只能使用存储类 auto 或 register 声明变量。 生成消息的代码示例：

    void main(void) {
    for (static int i = 1; i<10;)
    	i++;
    }

消息标识：E_BAD_STORAGE_IN_FOR_DECL

## 静态数组限定词之后没有数组长度

关键字 static 在数组声明符中用作限定符时，其后应该跟数组大小表达式。该表达式可以被省略。 生成消息的代码示例：

    void foo (int a[static]);

消息标识：E_INVALID_STATIC_VLA_QUAL

## 无法访问包含文件

在 #include 指令中未指定文件的读取权限。 生成消息的代码示例：

    #include "noperm.h"

消息标识：E_CANT_ACCESS_INCLUDE_FILE

## 打开的文件太多

在 #include 指令中指定的文件无法打开，因为已经打开的文件太多。 生成消息的代码示例：

    #include __FILE__

消息标识：E_TOO_MANY_FILES

## 许可证错误“错误说明”

试图获得许可证或与许可证有关的信息时，出现问题。

消息标识：E_LICENSE_ERROR

## 没有显式指定类型

如果不使用任何显式类型说明符声明变量，则假设为隐式的 int。 生成消息的代码示例：

    static a;

消息标识：E_NO_EXPLICIT_TYPE_GIVEN

## 没有为参数指定显式类型

如果不使用任何显式类型说明符声明参数，则假设为隐式的 int。 生成消息的代码示例：

    void
    fux(a)
    {
    	/* 主体 */
    }

消息标识：E_NO_TYPE_FOR_OLDSTYLE_PARAM

## 隐式函数声明

不再允许有隐式函数声明。 生成消息的代码示例：

    /* 此处没有 #include  */
    void main(void)
    {
    	printf("Hello world!\n");
    }

消息标识：E_NO_IMPLICIT_DECL_ALLOWED

## 指定的初始化程序字段引用用于非结构/联合类型

已经在非结构/联合初始化程序上下文中使用了结构/联合字段名称。 生成消息的初始化函数的示例：

    int a[10] = {.field=1}

消息标识：E_DESIG_INIT_FIELD

## 为数组指定的初始化程序索引不是常量

数组初始化程序的指定索引不是常量值。 生成消息的初始化函数的示例：

    int i;
    int a[10] = {[i]=1}

消息标识：E_DESIG_INIT_INDEX_CONST

## 数组专用的初始化程序被用于非数组类型

已经使用数组初始化程序的指定索引初始化非数组变量。 生成消息的初始化函数的示例：

    int a = {[5]=1}

消息标识：E_DESIG_INIT_NON_ARRAY

## 标识符被重新声明

已经采用与标识符的早期外观不一致的方式声明标识符，或者已经在相同的作用域中对标识符声明了两次。 在 K&R C 的早期版本中，如果类型近乎“相同”（如 SPARC 上的 `int` 和 `long`），则允许重新声明不一致。ANSI C 可以认为类型不同。

    int x;
    static long x;

消息标识：E_IDENTIFIER_REDECLARED_STATIC

## 无法获取 void 对象的地址

将 & 应用于操作数时，该操作数不能属于 void 类型。 生成消息的代码示例：

    void *p;
    *p = &*p;

消息标识：E_TAKING_ADDRESS_OF_VOID

## 参数为不完全类型

已经使用不完整的 `struct`、`union` 或 `enum` 类型声明了函数参数。 生成消息的代码示例：

    typedef struct foo
    {
    void (*function)(struct foo bar);
    } foobar;

消息标识：E_INCOMPLETE_PARAMETER

## __thread 变量说明符被忽略

__thread 关键字可以应用于外部或静态变量。它不会对自动变量产生影响。 生成消息的代码示例：

    int foo() {
    __thread int i;
    }

消息标识：E_BAD_STORAGE_THREAD_IGNORED

## 原子构造的表达式错误

表达式语句必须具有下列格式之一： x binop= expr, x++, x--, ++x, --x. 其中，x 是具有标量类型的左值表达式。binop 是下列对象之一：+、*、-、/、&、^、|、<< 或 >>。expr 是具有标量类型的表达式，它不会引用 x 指定的对象。 生成消息的代码示例：

    void
    main()
    {
    int i;
    #pragma omp atomic
    	i = i+1;
    }

消息标识：E_OMP_BAD_ATOMIC_EXPR

## 根据 1999 ISO C 标准对常量进行了提升

1999 ISO C 标准可以更改整型常量的键入规则。如果遇到具有 ANSI 标准规则设置的不同类型的任意整型常量，编译器会发出该消息。 生成消息的代码示例：

    long long a = 2147483648;

消息标识：E_C99_INTEGER_PROMOTION

## 忽略多余的 #pragma 参数

编译器已经遇到具有太多参数的 `#pragma`。忽略多余的参数。 生成消息的代码示例：

    #pragma MP taskloop maxcpus (2) savelast

消息标识：E_IGNORE_EXTRA_PRAGMA_PARAMS

## 小型结构包含传递或返回的浮点型数组。

在 v9 上已经发现，包含 {float|double|long double} 数组的小型结构不是作为参数传递，便是作为值从函数中返回。在小型结构中，有 16 个字节作为参数，而有 32 个字节作为函数的返回值。

    typedef struct {
    	double tf[4];
    } t_st;

    t_st myfunc(t_st arg) {
    	t_st rv;

    	return rv;
    }

消息标识：E_FLTARRSMLSTRUCT

## 在此上下文中，“.”的左操作数必须为左值，取消定义程序功能

. 运算符的左操作数是不会生成左值的表达式。通常，如果遇到试图更改返回结构的函数返回值的程序，会发出该警告。 生成消息的代码示例：

    struct s { int ia[10]; };
    struct s sf(void);
    f(void){
    	sf().ia[0] = 3;
    }

消息标识：E_L_OPERAND_DOT_NOT_LVALUE_NOW

## pragma omp 之后应该跟语句

omp pragma 构造中应该有语句。导致该错误的代码示例：

    {
    #pragma omp master
    }

消息标识：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);
    }

消息标识：E_OMP_SHARED_CONTROL_VAR

## 十六进制浮点常量的转换无法由其计算格式准确表示

生成消息的代码示例：

    main()
    {
    float f;

    f = 0x1.ffffffp0f;
    }

消息标识：E_CNV_HEX_CONST_EVAL_FMT

## num_threads 子句表达式没有整型

在 OpenMP 并行区域的 num_threads 子句中指定的表达式必须具有整数类型。 生成消息的代码示例：

    void main() {
    struct { int val; } true = {1};

    #pragma omp parallel num_threads(true)
    	printf("Hello,worlds!\n");
    }

消息标识：E_OMP_BAD_NUM_THREADS_TYPE

## 在复合语句中，pragma STDC 必须位于显式声明和语句之前

生成消息的代码示例

    void foo() {
    int i;
    #pragma STDC FP_CONTRACT OFF
    }

消息标识：E_STDC_PRAGMA_WRONG

## num_threads 子句表达式必须为正整数

在 OpenMP 并行区域的 num_threads 子句中指定的表达式必须是正整数。 生成消息的代码示例：

    void main() {
    #pragma omp parallel num_threads(-1)
    	printf("Hello,worlds!\n");
    }

消息标识：E_OMP_NEGATIVE_NUM_THREADS

## 不能在子句中指定专用变量

不能在绑定到并行构造的共享作业指令的 reduction 子句中指定并行区域中的专用变量。 生成消息的代码示例：

    void main() {
    int i;
    #pragma omp parallel private(i)
    	#pragma omp sections reduction(+:i)
    	{
    	   i++;
    	}
    }

消息标识：E_OMP_CANT_BE_IN_PRIVATE

## 不能在子句中指定约简变量

不能在绑定到并行构造的共享作业指令的 reduction 子句中指定并行指令的 reduction 子句中出现的变量。 生成消息的代码示例：

    void main() {
    int i;
    #pragma omp parallel reduction(+:i)
    	#pragma omp sections reduction(+:i)
    	{
    	   i++;
    	}
    }

消息标识：E_OMP_CANT_BE_IN_REDUCTION

## section 指令后应跟一条语句

OpenMP sections 指令包含 section 指令的序列，其中每个指令之后都跟有一个语句。但是，第一个 section 指令可能被省略。

    void foo() {
    int i,j;
    #pragma omp parallel sections private(i, j)
         {
    	i++;
    	i = i + 1;
    	j++;
         }
    }

消息标识：E_OMP_BAD_SECTION_STATEMENT

## threadprivate 指令必须出现在变量的作用域中

文件作用域变量的 Threadprivate 指令必须出现在文件作用域中。块作用域变量的 Threadprivate 指令必须出现在该变量的作用域内，但不能出现在嵌套的作用域内。 生成消息的代码示例：

    extern int x;
    void
    main()
    {
    #pragma omp threadprivate(x)
    static int i;
      {
    #pragma omp threadprivate(i)
      }
    }

消息标识：E_OMP_THREADPRIV_WRONG_SCOPE

## 在块作用域的 threadprivate 指令中指定的变量必须为静态变量

threadprivate 指令列表中的每个变量必须具有文件作用域或静态块作用域声明。生成消息的代码示例：

    void
    foo(int i)
    {
    #pragma omp threadprivate(i)
    int j;
    #pragma omp threadprivate(j)
    }

消息标识：E_OMP_STATIC_THREADPRIV

## 原子表达式的右侧引用变量

原子表达式的右侧不应该引用左侧的对象。 生成消息的代码示例：

    void
    main()
    {
    int i;
    #pragma omp atomic
    	i += i;
    }

消息标识：E_OMP_ATOMIC_EXPR_REFERENCE

## 无法打开 PCH 文件：

由于文件系统错误，编译器无法打开 .cpch 文件。请确保具有读取/写入当前工作目录的权限。

消息标识：E_CANT_OPEN_PCH_FILE

## #pragma hdrstop 或 #include 均不匹配 -xpchstop=file

必须使用 #pragma hdrstop 或 -xpchstop=filename 标记初始通用源的结尾，其中文件名同与程序源中一个 #include 相关的名称相同。使用初始通用源，可以标识可以通过预编译标题重复使用的程序部分。

消息标识：E_NO_PCH_STOP_POINT

## 第一个 #include 之前的 #pragma hdrstop/-xpchstop 禁用 PCH

使用任何 #include 指令之前的 #pragma hdrstop 或 -xpchstop 时，将禁用预编译的标题。

消息标识：E_HDRSTOP_BEFORE_INCLUDE

## 函数不能在预编译标题所用的标题文件中定义

函数不能在要用作 PCH 文件的一部分的标题文件中定义。 生成错误的代码示例：

    int
    foo()
    {
    return 1;
    }

消息标识：E_CANT_INIT_IN_PCH

## 指令在预编译头中无效

使用预编译的标题时，某些指令是无效的。如果使用这些指令，将会产生错误。 导致该错误的代码示例

    #line 1
    #error "error message"
    #file "file.h"
    #warning "warning message"
    #assert system( unix )
    #unassert system

消息标识：E_PCH_INVALID_DIRECTIVE

## __DATE__ 和 __TIME__ 在预编译头中无效

创建预编译的标题时，__DATE__ and __TIME__ 预定义宏不能在标题文件中使用。

消息标识：E_PCH_INVALID_PREDEFINED

## __LINE__ 和 __FILE__ 在预编译头前缀中无效

收集或使用预编译的标题时，__LINE__ and __FILE__ 预定义宏不能在预编译的标题前缀中使用。

消息标识：E_PCH_PREFIX_PREDEFINED

## PCH 文件中的魔数无法识别

无法使用 PCH 文件，因为魔数无法识别。

消息标识：E_PCH_FILE_UNUSABLE_MAGIC

## 无法读取版本标记错误的 PCH 文件，重新创建 PCH 文件

无法使用 PCH 文件，因为 PCH 版本号不正确。PCH 文件必须使用当前的编译器重新生成。

消息标识：E_PCH_FILE_UNUSABLE_VERSION

## PCH 文件不可用，-D 或 -U 选项必须与创建 PCH 文件时所用的选项一致

无法使用 PCH 文件，因为 -D 或 -U 选项与创建 PCH 文件时使用的那些选项不完全匹配。

消息标识：E_PCH_FILE_UNUSABLE_DEFS

## PCH 文件不可用，cc 命令选项必须与创建 PCH 文件时所用的选项一致

无法使用 PCH 文件，因为命令行选项与创建 PCH 文件时使用的那些选项不完全匹配。

消息标识：E_PCH_FILE_UNUSABLE_OPS

## PCH 文件不可用，预处理指令序列（包括 #include 指令）必须与创建 PCH 文件时所用的指令一致

PCH file 无法使用当前的源文件，因为包含 #include 指令的初始预处理指令序列与创建 PCH 文件时所用的序列不完全匹配（不包括任何注释）。

消息标识：E_PCH_FILE_UNUSABLE_PREFIX

## 在 copyprivate 子句中指定的变量在封装的上下文中必须为专用变量

生成消息的代码示例：

    void foo() {
    int i;
    #pragma omp parallel
         {
    #pragma omp single copyprivate(i)
    	;
         }
    }

消息标识：E_OMP_COPYPRIV_MUST_BE_PRIVATE

## copyprivate 子句不能与 nowait 子句同时使用

生成消息的代码示例：

    int main() {
    int i = 42;
    #pragma omp single nowait copyprivate(i)
        {
    i++;
        }
    }

消息标识：E_OMP_COPYPRIV_WITH_NOWAIT

## 对非函数标识符应用内联关键字

只有对函数标识符应用内联关键字时，该关键字才有效。 导致该错误的代码示例：

    inline int i;

    main()
    {
    inline float f[10];
    }

消息标识：E_INLINE_NEEDS_FUNC

## 将内联函数定义重新声明为静态函数定义

函数的重新声明与以前的内联函数定义不一致。 导致该错误的代码示例：

    inline int func(int i)
    {
    return ++i
    }

    static int func();

消息标识：E_INLINE_FUNC_REDECL_STATIC

## 条件表达式不是有效的左值

生成消息的代码示例：

    void
    main(void) {
    int a=1, b=0, c=0;
    (a ? b :c) = 5;
    }

消息标识：E_ASSIGNMENT_TO_COND_EXPR

## 复合文字是 C99 ISO 的功能

生成消息的代码示例：

    int *a = &(int[]){10, 20};

消息标识：E_NONC99_COMPOUND_LITERAL

## 取消定义结构类型赋值给指针的函数数组成员

正在将类型结构的函数数组成员赋值给指针。除下一个序列点外，会取消定义这种赋值的结果。 生成消息的代码示例：

    main()
    {
    int *i;

    i = foo().bar;
    printf("i is %d\n", *i);
    }

消息标识：E_ASG_ARY_TO_PTR

## inline 关键字使用不当

inline 关键字使用不当 生成消息的代码示例：

    int foo(inline int);

消息标识：E_INLINE_INVALID_USE

## 操作数必须为整数、实数或指针类型：op \"%s\"

++ 和 -- 运算符的操作数必须是整数、实数或指针类型。 生成消息的代码示例：

    double _Complex dc = 1.0 + 2.0 * _Imaginary_I;
    dc++; // 此处有错

    double _Imaginary di = 2.0 * _Imaginary_I;
    --di; // 此处有错

消息标识：E_OPERAND_MUST_BE_REAL_OR_PTR

## 在外部内联函数中引用静态标识符

生成消息的代码示例：

    static int bar();

    inline int foo() {
    static int i;

    return i + bar();
    }

    指向变量‘i’和函数‘bar’的引用均无效。

消息标识：E_REF_STATIC_EXTERN_INLINE

## 不完全的%s类型说明符

复数/虚数类型的说明符不完整 生成消息的代码示例：

    _Complex c = 1.1 + 2.2 * _Imaginary_I;
    _Imaginary i;

消息标识：E_INCOMPLETE_COMPLEX_IMAGINARY

## 无效的浮点运算

无效的浮点运算

消息标识：E_FP_INVALID

## 浮点运算导致溢出

浮点运算导致溢出

消息标识：E_FP_OVERFLOW

## 浮点运算导致下溢

浮点运算导致下溢

消息标识：E_FP_UNDERFLOW

## 除以 0

除数为零

消息标识：E_FP_DIVISION_BY_ZERO

## 实数类型转换为 _Imaginary 类型导致 _Imaginary 类型的 0.0

实数类型转换为 _Imaginary 类型导致 _Imaginary 类型的 0.0 生成消息的代码示例：

    double d = 1.0;
    double _Imaginary di = d;     // 此处有警告：di gets 0

消息标识：E_REAL_CONV_TO_ZERO

## _Imaginary 类型转换为实数类型导致实数类型的 0.0

_Imaginary 类型转换为实数类型导致实数类型的 0.0 生成消息的代码示例：

    double _Imaginary di = _Imaginary_I;
    double d = di;        // 此处有警告：d gets 0

消息标识：E_IMAGINARY_CONV_TO_ZERO

## omp for 循环的迭代表达式与控制表达式不一致

OpenMP for 的迭代表达式必须与控制表达式一致。如果 for 循环中的逻辑运算符是 <=，则该循环的变量应该递增，反之亦然。 生成消息的代码示例：

    void main() {
    int i;
    #pragma omp parallel for
    for (i=0; i<10; i--) {
      }
    }

消息标识：E_OMP_FOR_INCONSIST_ITER

## 不能连接十六位字符串文字与宽字符串文字或常规字符串文字

十六位字符串文字只能与其它十六位字符串文字并置在一起。 生成消息的代码示例：

    unsigned short *s = U"abc" "def";

消息标识：E_CANT_CONCAT_MIXED_UTF_STRINGS

## U 字符串文字只能包含 ASCII

生成警告的代码示例：

    unsigned short bar[] = U"é";

消息标识：E_ASCII_UTF16_USHORT_CHAR_ERR

## U 字符串文字不能包含数字换码

生成警告的代码示例：

    unsigned short bar[] = U"\351";

消息标识：E_NUMERIC_ESCAPE_IN_UTF16

## 将 dbx 的变量名改为全局变量进行修复并继续执行，crossfile 优化标记被忽略。

使用调试程序中的修复和继续功能进行编译时，会忽略 -xcrossfile 标记。

消息标识：E_X_CROSSFILE_IGNORED

## 只有带外部链接的标识符才能有链接程序作用域

生成错误的代码示例：

    static __symbolic int i;

消息标识：E_LDSCOPE_FOR_EXTERN_ONLY

## 重新声明必须有相同或更严格的链接程序作用域

生成错误的代码示例：

    __symbolic void rescopedcl();
    __global void rescopedcl();

消息标识：E_NEW_LDSCOPE_MUST_BE_HIGHER

## 链接程序作用域必须与定义匹配

生成错误的代码示例：

    __symbolic void rescopedef() { } __hidden void rescopedef();

消息标识：E_NO_LDSCOPE_AFTER_DEFN

## PCH 的可用前缀只能包含预处理程序指令，其中包括 #include 指令和注释

生成错误的代码示例：

    int i;
    #include "file.h"
    #pragma hdrstop
    main()
    {
    }

消息标识：E_PCH_BAD_VIABLE_PREFIX

## 位字段大小 < 0

位字段声明指定的大小为负位数。 生成消息的代码示例：

    struct s { int x:-3 };

消息标识：E_BIT_FLD_SIZE_LESS_ZERO

## 位字段的大小为零

位字段声明指定的大小为零。 生成消息的代码示例：

    struct s {
    int x:1;
    int y:0;
    };

消息标识：E_BIT_FLD_SIZE_EQUAL_ZERO

## goto 语句不能跳转到 penmp 结构的块中

OpenMP 并行和共享作业构造之后必须跟结构化的块。结构化块是拥有一个 entry 和一个 exit 的语句。不允许使用造成跳转到块或跳转出块的语句。 生成消息的代码示例：

    int foo() {
    goto label_1;
    #pragma omp parallel
      {
    label_1: ;
      }
    }

消息标识：E_OMP_STRUCTBLK_BREAKING_IN

## return、goto、break 或 continue 语句不允许跳出 openmp 结构的块

OpenMP 并行和共享作业构造之后必须跟结构化的块。结构化块是拥有一个 entry 和一个 exit 的语句。不允许使用造成跳转到块或跳转出块的语句。结构化块不能包含造成控制从块流出的 return、goto、break 或 continue 语句。 生成消息的代码示例：

    int foo() {
    #pragma omp parallel
      {
    return;
      }
    }

消息标识：E_OMP_STRUCTBLK_BREAKING_OUT

## 该子句中不允许使用 __thread 变量

TLS 变量不能在 OpenMP 数据作用域子句中使用。这些变量也不受缺省子句的影响。 生成消息的代码示例：

    __thread int i;

    void
    main()
    {
    #pragma omp parallel private(i)
    i++;
    }

消息标识：E_OMP_TLS_WRONG_CLAUSE

## 非数组类型中使用的数组指示器

已经使用数组初始化程序的指定索引初始化非数组变量。 生成消息的初始化函数的示例：

    int a = {[5]=1};

消息标识：E_DESIG_INIT_NONARRAY

## 数组的指示器表达式不是整型常量

数组初始化程序的指定索引不是常量值或整数类型。 生成消息的初始化函数的示例：

    int i;
    int a[10] = {[i]=1};

消息标识：E_DESIG_INIT_INDEX_NONCONST

## 数组的指示器表达式溢出

数组初始化程序的指定索引溢出数组。 生成消息的初始化函数的示例：

    int a[10] = {[20]=1};

消息标识：E_DESIG_INIT_INDEX_BOUND

## 非结构/联合类型中使用结构/联合指示器

已经在非结构/联合初始化程序上下文中使用了结构/联合字段名称。 生成消息的初始化函数的示例：

    int a[10] = {.field=1};

消息标识：E_DESIG_INIT_NONSTRUCT

## 指定的初始程序是 C99 ISO 的功能

已经在非 C99 模式下使用了 C99 ISO 指定的初始化程序语法。 生成消息的初始化函数的示例：

    int a[10] = {.field=1};

消息标识：E_DESIG_INIT_DISABLED

## printf-like 函数的变量格式说明符；可能出现扩展问题

将用户定义的数据（如派生自输入或命令行选项）作为 printf-like 函数的形式参数传递时，应该确保形式字符串中没有 %n 个非专用说明符。%n 扩展是安全漏洞的常见起因。 生成错误的代码示例：

    (void) fprintf(stderr, fmt, i1, i2, i3);

消息标识：E_SEC_PRINTF_VAR_FMT

## sprintf-like 函数的形式参数包含未绑定的字符串说明符

如果格式化的参数大于缓冲区，则采用该格式的未绑定 %s 说明符可能会使缓冲区溢出。 生成错误的代码示例：

    (void) sprintf(buf, "%s", string);

消息标识：E_SEC_SPRINTF_UNBOUNDED_COPY

## sprintf-like 函数的变量格式说明符；可能出现扩展问题

将用户定义的数据（如派生自输入或命令行选项）作为 scanf-like 函数的形式参数传递时，应该确保形式字符串中没有 %n 个非专用说明符。%n 扩展是安全漏洞的常见起因。 生成错误的代码示例：

    (void) fscanf(stdin, fmt, &i1, &i2, &i3);

消息标识：E_SEC_SCANF_VAR_FMT

## scanf-like 函数的形式参数包含未绑定的字符串说明符

如果格式化的参数大于缓冲区，则采用该格式的未绑定 %s 说明符可能会使缓冲区溢出。 生成错误的代码示例：

    (void) scanf("%s", string);

消息标识：E_SEC_SCANF_UNBOUNDED_COPY

## strcpy-like 函数的变量参数；确保它是安全的

如果该缓冲区太小，无法容纳源缓冲区的内容，则使用 strcpy() 复制字符串时，会使目标缓冲区溢出。请确保该目标缓冲区足够大，或使用 strlcpy()。 生成错误的代码示例：

    (void) strcpy(dst, src);

消息标识：E_SEC_STRCPY_WARN

## 不要在新代码中使用 strncpy-like 函数。最好使用 strl*() 的函数。

库函数 strncpy() 有时难以使用，因为如果空间不足，该函数会终止目标字符串。strlcpy() 没有这种限制，所以它一般是理想的选择函数。 但是，存在下面一种例外情况：更新磁盘中驻留的结构时，可能与下列事实有关：strncpy() 将不会充满目标缓冲区中的所有未使用的空间。 生成错误的代码示例：

    (void) strncpy(dst, src, size);

消息标识：E_SEC_STRNCPY_WARN

## 不要在新代码中使用 strncat-like 函数。最好使用 strl*() 函数

不要使用 strncat() 函数，因为该函数需要在调用之前计算剩余的空间。strlcat() 更容易安全使用。 生成错误的代码示例：

    (void) strncat(dst, src, size);

消息标识：E_SEC_STRNCAT_WARN

## 不要使用 gets()；应该使用 fgets(buf, sizeof(buf), stdin)

在任何情况下都无法安全使用 gets()。因为它没有与附带的缓冲区大小有关的信息，所以总是易于使缓冲区溢出。请使用 fgets()。 生成错误的代码示例：

    (void) gets(buf);

消息标识：E_SEC_FORBIDDEN_WARN_GETS

## 不要使用 cftime-like 函数；应该使用 strftime(buf, sizeof(buf), fmt, &tm)

cftime() 只有借助足够大的缓冲区，才能获取所需的结果。因为它可以从环境 (CFTIME) 中导入信息，所以无法确保所需的结果适合于提供的缓冲区。应该使用 strftime()。 生成错误的代码示例：

    (void) cftime(buf, fmt, clock);

消息标识：E_SEC_FORBIDDEN_WARN_CFTIME

## 不要使用 ascftime-like 函数；应该使用 strftime(buf, sizeof(buf), fmt, &tm)

ascftime() 只有借助足够大的缓冲区，才能获取所需的结果。因为它可以从环境 (CFTIME) 中导入信息，所以无法确保所需的结果适合于提供的缓冲区。应该使用 strftime()。 生成错误的代码示例：

    (void) ascftime(buf, fmt, time);

消息标识：E_SEC_FORBIDDEN_WARN_ASCFTIME

## 不要使用 creat-like 函数；应该使用 open(path, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL, mode)

creat() 很容易受到 symlink 的攻击。换而言之，如果要创建的文件名已经作为符号链接存在，则 creat() 之后将会跟该符号链接，还会在该 symlink 所指的位置创建该文件。由于这种执行是人工完成的，所以无法安全创建文件。 生成错误的代码示例：

    fd = creat(fname, mode);

消息标识：E_SEC_FORBIDDEN_WARN_CREAT

## 复制字符串时不能使用直接内存复制；应该使用 strlcpy()

使用 bcopy() 或 memcpy() 复制字符串时容易出错，因为它需要编程人员计算正确的大小。因此，我们建议使用 strlcpy()。 生成错误的代码示例：

    char *src, dst;
    ...
    (void) bcopy(dst, src, len);

消息标识：E_SEC_BCOPY_WARN

## 不要使用 rand()。备选方案：/dev/random

rand() 函数系列执行相当弱的随机数生成器。如果借助强的随机数，请使用 /dev/random 或 /dev/urandom 接口。 生成错误的代码示例：

    i = rand();

消息标识：E_SEC_RAND_WARN

## chdir 倾向于路径名的竞争条件。请不要在多线程程序中使用

如果将该函数与处理相同对象（目录）的其它函数结合使用，可以导致基于路径名的竞争条件。将 fchdir() 用作备选方案。 生成错误的代码示例：

    (void) chdir(dirname);

消息标识：E_SEC_CHDIR_WARN

## 不要使用用户提供的消息目录调用 catopen-like 函数

库和程序不应该对用户提供的路径名调用该函数。可以提升用户提供的消息目录，以便轻松中断特权代码。 生成错误的代码示例：

    (void) catopen(fname, flag);

消息标识：E_SEC_CATOPEN_WARN

## 确保无法从用户输入构造 dl_open() 参数，其中包括 argv[0]

该函数的参数只能是使用运行时 linker 路径找到的非限定路径名，或无法通过任何方法从用户输入（包括 argv[0]）派生的完整路径名。 请注意，无法安全打开用户提供的共享对象，因为 _init() 函数是在 dlopen() 返回之前执行的。 生成错误的代码示例：

    dlopen(fname, dlopen_mode);

消息标识：E_SEC_DLOPEN_WARN

## 该函数可以打开文件；验证文件名是否安全

该函数可以打开若干个文件，所以只能与认为安全的路径名一起使用。

消息标识：E_SEC_PATH_WARN

## chroot()-ed 环境提供的保护很少

chroot-ed 环境提供的保护很少。请确保没有在 chroot-ed 环境下运行特权程序，且在 chroot() 之后对新根目录之下的点执行 chdir() 操作。

消息标识：E_SEC_CHROOT_WARN

## 环境变量是完全由用户控制的；需要谨慎

认真对待 getenv() 返回的值。这些值完全受用户控制，所以可以是大（达到 NCARGS (）字符。另外，它们还可以保护需要在使用之前清除的所有意外数据种类。

消息标识：E_SEC_GETENV_WARN

## 避免使用 getlogin()；返回值仅是对用户标识的提示

避免使用 getlogin()；无法借助其输出，所以它不是多线程安全函数（应该使用 getlogin_r()）。在任何情况下，都不能信任返回的登录；使用 uid 或提供备选的用户验证方法。

消息标识：E_SEC_GETLOGIN_WARN

## 注意 mkdir() 所用的用户提供路径

如果 mkdir() 所用的路径是从用户输入派生的，请检查其是否安全。

消息标识：E_SEC_MKDIR_WARN

## 避免使用 mktemp-like 函数；生成的路径名无法安全使用

无法保证可以安全使用生成的路径名，因为路径名的生成和在 open() 中的使用直接存在竞争条件。应该使用“fd = mkstemp(template);”。

消息标识：E_SEC_MKTEMP_WARN

## 避免使用调用 shell 的函数

该函数可以创建运行 shell (/bin/sh) 的子进程，以便执行其作业。产生 shell 时，会涉及到 $PATH、$IFS 和其它环境变量，从而使其难以安全使用。另外，切记，该 shell 将会解释其参数中出现的特殊字符。

消息标识：E_SEC_SHELL_WARN

## 避免使用 kvm_* 函数；如果需要内核信息，请写入正确的 kstat() 接口

如果接受用户定义的 \"namelist\" 参数，请确保在使用之前对特权进行调用。

消息标识：E_SEC_KVM_WARN

## readlink 的返回值不能是 NUL 终止

请确保在符号链接的内容对提供的缓冲区太大的前提下处理情况。

消息标识：E_SEC_READLINK_WARN

## getpass() 最多返回 8 个字符。最好使用 getpassphrase()

避免在安全应用程序中使用 getpass()。最好使用 getpassphrase()，因为它最多可以返回 256 个字符的口令。

消息标识：E_SEC_GETPASS_WARN

## 避免使用 tempnam-like 函数；应该使用 mkstemp()

无法保证可以安全使用生成的路径名，因为路径名的生成和在 open() 使用直接存在竞争条件。应该使用 mkstemp()。

消息标识：E_SEC_TEMPNAM_WARN

## tmpfile-like 函数不是 MT 安全的（它会更改 umask）

该函数可以调用多线程应用程序中不安全的 umask()。

消息标识：E_SEC_TMPFILE_WARN

## 避免使用 truncate-like 函数；应该使用 ftruncate()

该函数取决于路径名竞争条件，因为它可以对文件名称空间内的对象进行操作。显示给该函数的对象可能与早期或后续调用中的对象不同，因为文件系统可能在这些后续调用之间直接发生了更改。

消息标识：E_SEC_TRUNCATE_WARN

## 如若可能，避免在安全应用程序中使用 umask-changing

避免使用 umask()，因为它可以修改用户定义的 umask。请考虑在 open-like 函数中使用文件创建模式。

消息标识：E_SEC_UMASK_WARN

## 避免使用 utmp 名称更改函数；使用缺省的 utmp 文件

避免在安全应用程序中使用 utmpname()；应该使用缺省的 utmp 文件名称。

消息标识：E_SEC_UTMP_WARN

## 避免使用 select-like 函数；最好使用 poll()

由于 API 复杂，所以使用 select() 编程时容易出错，并会导致各种安全问题。poll() 具有一个更为简单易用的接口，不仅限制少，而且速度更快。

消息标识：E_SEC_SELECT_WARN

## strcpy-like 函数易于使缓冲区溢出；检查边界

如果该缓冲区太小，无法容纳源缓冲区的内容，则使用该函数复制字符串时，可能会使目标缓冲区溢出。请确保该目标缓冲区足够大。

消息标识：E_SEC_EXPAND_WARN

## 使用 chmod()-like 函数易于产生竞争条件

进程应该支持当前的 real-uid，并可以在打开文件之前切换回该 real-uid（如果需要的话）。如果必须更改文件系统对象的属性，则最好将 open() 与 fchown()/fchmod() 结合使用。

消息标识：E_SEC_CHMOD_WARN

## 避免在特权软件中使用 exec*() 函数

execvp() 和 execlp() 借助 $PATH 查找正确的一元类型，以便于运行。通常，$PATH 受用户的控制。应该使用 execl()、execv() 或 execve() 之一。

消息标识：E_SEC_EXEC_PATH

## 限制使用 exec()-like 函数

请确保，对其它应用程序执行 exec() 操作之前先清除环境，以及关闭所有敏感的文件说明符。

消息标识：E_SEC_EXEC_WARN

## 如果在缓冲区中递增输入，请确保检查边界条件

这是安全提示：附加到循环内的缓冲区时，应该检查边界。如果边界计算不正确或缺少，可能会使缓冲区溢出；决不要假设用户输入的长度已经固定和检查边界符号等。

消息标识：E_SEC_LOOP_WARN

## 应该避免使用 access-like 函数

无法安全使用该函数，因为在可以对返回的信息执行操作时，该信息已经过时。使用 open() 之前的 access() 时，会存在无法解决的竞争条件问题。 备选方案：具有专用用户权限的 open()。

消息标识：E_SEC_ACCESS_WARN

## 指定不使用 O_EXCL 的 O_CREAT

如果使用 O_CREAT 而不是 O_EXCL 调用 open()，则该 open() 之后将会跟一个 symlink，作为路径名的最后一个组件。这样做会使用户在非专用的目标中创建文件。

消息标识：E_SEC_CREAT_WITHOUT_EXCL

## 指定 O_CREAT，但未设置 \"mode\" 参数

应该始终指定文件创建模式，尽可能严格地设置权限（通常仅限当前用户），并根据需要稍后对其进行扩展；否则，用户可能会擅自访问创建的文件。

消息标识：E_SEC_CREAT_WITHOUT_MODE

## 无法使用 fopen-like 函数安全创建文件

该函数不允许为新文件指定权限。请确保，路径名已经存在，或目录不能公开写入。备选方案：使用 open()/fdopen() 序列。

消息标识：E_SEC_FOPEN_MODE

## 竞争条件可能检测到的参数 - 之前已经传递到 stat()

恶意用户可能在 stat-like 调用完成之后修改了文件系统对象，这样做可能会导致竞争条件的产生。应该使用 fstat()。

消息标识：E_SEC_USE_AFTER_STAT

## glob 的变量屏蔽说明符；可能出现扩展问题

如果将用户定义的数据（例如从输入或命令行选项派生）作为屏蔽参数传递给 glob()，则应该验证输入，以便确保字符串的格式正确无误，且不会造成安全威胁。检查扩展符号，包括‘..’、‘/’、‘-’、空格和其它特殊字符。

消息标识：E_SEC_GLOB_WARN

## 不完整类型的复合文字

复合文字中使用的类型名称应该是对象类型或大小未知的数组。 生成消息的代码示例：

    int i = (struct UNKNOWN) { 1 };

消息标识：E_INCOMPLETE_COMPOUND_LITERAL

## \u 是 ISO C99 中的通用字符名称换码

\u 和 \U 换码序列可以在 1999 ISO C 指定通用字符名称。 生成消息的代码示例：

    char *cp = "This is a ucn:\u0020";

消息标识：E_ESC_U_IS_C99_UCN

## 通用字符名称中的十六进制数组不足

1999 ISO C 要求，\u 之后必须跟 4 个十六进制的数字，而 \U 之后必须跟 8 个十六进制的数字。 生成消息的代码示例：

    char *cp = "&\u00fz";

消息标识：E_BAD_NUM_OF_DIGITS_IN_UCN

## 通用字符名称值在标识符中无效

根据 1999 ISO C 中指定的限制条件，该通用字符名称在标识符中无效。 生成消息的代码示例：

    int i\uFFFF;

消息标识：E_INVALID_UCN_FOR_ID

## 通用字符名称值无效

该通用字符名称无效。 生成消息的代码示例：

    int i\u0033;

消息标识：E_INVALID_UCN_VALUE

## 应该是整型常量表达式，注意这是 C99 中的 vla

非整型常量表达式不能在 1990 ISO C 的数字大小表达式中使用。请注意，在 1999 ISO C 中，它将是变量长度数组。 生成消息的代码示例：

    void foo() {
    int a[(int)(5.0+1.0)];
    }

消息标识：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()
    {}

消息标识：E_PCH_CONDITIONAL_PREFIX

## PCH 文件中的编译器版本不正确

无法使用 PCH 文件，因为生成 PCH 文件时所用的编译器与当前的编译器不同。

消息标识：E_PCH_FILE_UNUSABLE_COMP_VERS

## 无法使用 PCH 文件，当前的源路径必须与创建 PCH 文件时所用的路径匹配。

无法使用 PCH 文件，因为当前的源文件路径与创建 PCH 文件时生效的源路径不同。这种影响包括使用相关的路径，所以可能会导致包括不同的标题文件，即 PCH 文件的内容可能对该编译无效。

消息标识：E_PCH_FILE_UNUSABLE_SRC_PATH

## 无法使用 PCH 文件，当前的工作目录必须与创建 PCH 文件时生效的目录匹配。

无法使用 PCH 文件，因为当前的工作目录与创建 PCH 文件时生效的目录不同。这样会导致包括不同的标题文件，即 PCH 文件的内容对该编译无效。

消息标识：E_PCH_FILE_UNUSABLE_CWD

## 使用 -xcrossfile 或 -xipo 时，无法将外部变量重新声明为静态变量

使用 -xcrossfile 或 -xipo 调用编译器时，会显示该警告。以前作为`外部`变量声明的变量无法重新声明为静态变量。 生成消息的代码示例：

    extern int local_i;
    void main(int argc, char *argv[])
    {
    	return local_i;
    }
    static int local_i=10;

消息标识：E_CANT_XCROSSFILE_GLOBSTATIC

## 变量的第一个重新声明没有 __thread 说明符

线程变量的正数第一个重新声明必须包含 __thread 说明符。 生成消息的代码示例：

    int i;
    __thread int i;

消息标识：E_NONTHREAD_THREAD_REDECL

## #line 指令中的行号必须小于或等于

#line 指令中的行号必须小于或等于 2147483647（对于 C99 模式）或 32767（对于 C90 模式）。 生成消息的代码示例：

    #line 2147483647 "string"
    #line 2147483648

消息标识：E_OUT_OF_RANGE_POUND_NUMBER

## 首次使用下列对象时遇到 redefine_extname pragma：

不能使用 redefine_extname pragma 重新定义的名称。

    void main(){
    foo6(1,1);
    }
    #pragma redefine_extname foo6 foo6_1

消息标识：E_REDEF_EXTNAME_INCORRECT

## 使用外部链接声明的变量不能有反复修改的类型：

反复修改类型的变量不能使用外部链接进行声明。 生成消息的代码示例：

    void foo() {
    int n;
    extern int (*a)[n];
    }

消息标识：E_EXTERN_VM

## 操作数必须有实数浮点类型

运算符使用的操作数必须是实数浮点类型（`short、double 和 long double` 等），但不是，例如使用的是 int。 生成消息的代码示例：

    #include
    int foo() {
    double _Complex c;
    return fpclassify(c);
    }

消息标识：E_OPERAND_MUST_BE_REAL_FLOAT

## 不能从具有灵活数组成员的结构派生结构成员的类型

结构可以包含灵活的数组成员。这种结构（和任何包含，可能是递归包含，属于这种结构的成员的联合）不会是结构的成员。 生成消息的代码示例：

    struct A {int xa; int ya[];};
    struct B {int xb; struct A yb;};

消息标识：E_STRUCT_DERIVED_FROM_FLEX_MBR

## 不能从具有灵活数组成员的结构派生数组的类型

结构可以包含灵活的数组成员。这种结构（和任何包含，可能是递归包含，属于这种结构的成员的联合）不会是数组的元素。 生成消息的代码示例：

    struct A {int xa; int ya[];};
    struct A n[10];

消息标识：E_ARY_DERIVED_FROM_FLEX_MBR