在源文件中遇到 #error 指令。该指令中的其他标记已作为消息的一部分进行输出。
生成该消息的代码示例：
#define ONE 2 #if ONE != 1 #error ONE != 1 #endif
消息 ID：E_ERROR_PRAGMA
由于编译早期产生的错误造成了编译器无法正常编译，因此不能继续处理程序。请更正这些错误，然后重试。
消息 ID：E_CANNOT_RECOVER
编译器试图关闭标准输出时，出现文件系统错误。这不是来自源程序的错误。
消息 ID：E_FCLOSE_ERR
编译器关闭 lock lint 数据库 (.ll) 文件时，出现文件系统错误。
消息 ID：E_FCLOSE_LL_ERR
编译器无法创建 .ll 文件。可能的原因是文件系统错误或目录或文件权限不正确。
消息 ID：E_CANT_CREATE_LL_FILE
编译器内部使用 malloc() 失败。这通常是由于交换空间不足造成的。
消息 ID：E_CANT_MALLOC_FILENAME
编译器无法获取足够的内存来编译该程序。这通常是由于交换空间不足造成的。
消息 ID：E_OUT_OF_MEMORY
编译器试图将输出文件重定向到 /dev/null 时，出现文件系统错误。
消息 ID：E_CANT_FREOPEN_STDOUT
编译器在编译时尝试在两个浮点操作数之间运算时，检测到溢出问题。该运算会产生浮点异常，从而导致该编译器退出。
消息 ID：E_FP_CONST_CAUSE_EXCEPT
编译器内部使用 malloc() 失败。这通常是由于交换空间不足造成的。
消息 ID：E_CANT_MALLOC_TMP_FILENAME
由于文件系统错误，因此编译器无法创建 .ll 文件。请确保具有写入到当前工作目录的权限。
消息 ID：E_CANT_OPEN_LL_FILE
编译器不能丢弃 lock_lint 数据库文件。
消息 ID：E_CANT_FREOPEN_LL_DEV_NULL
在标题名称以 < 开头的 #include 指令中，结束字符 > 被省略。
生成该消息的代码示例：
#include <stdio.h
消息 ID：E_INCLUDE_MISSING
使用 -v 选项显示该警告。注释中包含 /*。
生成该消息的代码示例：
/* This is comment that has another /* inside of the comment */
消息 ID：E_SLASH_STAR_IN_CMNT
编译器在读取注释时遇到文件尾。
消息 ID：E_EOF_IN_COMMENT
预处理指令中允许使用的空白字符只有空格和水平制表符。源代码中包含一些其他的空白字符，如换页符或垂直制表符。编译器将该字符视为空格。
消息 ID：E_WHITE_SPACE_IN_DIRECTIVE
字符串型在同一行没有右 " 号，只有左 " 号。如果字符串型是预处理指令的一部分（并且编译器提供缺少的 "），则诊断信息是警告；否则是错误。
生成该消息的代码示例：
char *p = "abc ;
消息 ID：E_NEWLINE_IN_STR_LITERAL
使用 -Xc 选项显示该警告。遇到具有某个编号的源代码行。其中指令名称通常会使用该编号。该行留作编译器内部使用，但是它必须在 -Xc（严格符合）模式下进行诊断。
生成该消息的代码示例：
# 9
消息 ID：E_INTERPRETED_AS_LINE_DIRECTIVE
编译器无法识别预处理指令行中 # 之后的标识符。
生成该消息的代码示例：
# unknown foo
消息 ID：E_INVALID_DIRECTIVE
.i 文件是执行 cc -P 命令的结果，它已被假设为编译器预处理阶段和编译阶段之间的保留通信通道。通过检查 .i 文件，可以检测到难以检测到的错误。但是，该编译器只能找到内部通信所用的一些指令。编译的源文件（.i 文件）包含预处理指令，但不包含某个特殊指令。
消息 ID：E_BAD_COMP_CNTRL_LINE
使用 -Xc 选项显示该警告。编译器检测到支持的指令（它不是 ANSI C 标准的一部分），且已经选择 -Xc。
生成该消息的代码示例：
#assert system( unix )
消息 ID：E_UP_COMPATIBLE_DIRECTIVE
指令已经出现在用于分隔函数之类的宏调用参数的 ( ) 之间。在这种情况下，不允许使用以下指令：#ident、#include、#line、#undef。 如果显示在 if-group 的 false 组中，则诊断信息是警告，否则是错误。
生成该消息的代码示例：
#define flm(a) a+4 int i = flm( #ifdef flm /* allowed */ #undef flm /* disallowed: error */ 4 #else /* allowed */ #undef flm/* disallowed: warn */ 6 #endif /* allowed */ );
消息 ID：E_DIRECTIVE_IN_MACRO_LIST
#file 指令（留于编译系统使用）供预处理和编译阶段之间的内部通信使用。字符串型操作数应该是操作数。
消息 ID：E_FILE_MISSING_LITERAL
#ident 指令之后必须跟常用（非宽字符）字符串型。
生成该消息的代码示例：
#ident no-string
消息 ID：E_IDENT_MISSING_LITERAL
编译器无法读取输入文件，可能是由某种文件系统错误造成的。遇到包含文件时，很可能会出现该错误。
消息 ID：E_READ_ERROR
编译器遇到的错误过多，无法有效地执行进一步处理。如果没有生成更多的诊断信息，该编译器将会退出。
消息 ID：E_TOO_MANY_ERRS
编译器内部使用 malloc() 失败。这通常是由于交换空间不足造成的。
消息 ID：E_MALLOC_FAILS
编译器内部使用 realloc() 失败。这通常是由于交换空间不足造成的。
消息 ID：E_REALLOC_FAILS
编译器无法打开输入或输出文件。通常，这意味着传递到 cc 命令的文件名参数不正确。诊断信息中的解释说明了无法打开该文件的原因。
生成该消息的代码示例：
cc badname.c -c x.c
消息 ID：E_CANNOT_OPEN
如果使用 -Xt 选项时出现致命错误，将会显示该消息。源代码可以直接或间接调用宏（调用其自身）。ANSI C 语义可以防止进一步尝试重新扫描该宏。早期的 C 编译器试图重新扫描该宏，从而最终产生致命错误。 因为 ANSI C 及其早期产品在重新扫描规则方面是不相同的，所以 ANSI C 编译器会在 -Xt 模式下提供旧的行为，其中包括在检测宏递归时生成该诊断信息。
生成该消息的代码示例：
#define a(x) b(x) #define b(x) a(x) a(3)
消息 ID：E_MACRO_RECURSION
编译器遇到一个空字符，即一个字符代码为零的字符。
消息 ID：E_NULL_CHAR_INPUT
使用 -Xt 选项显示该警告。ANSI C 介绍了三字母的概念，即代表一个字符的三字符序列。上面的所有序列都是以 ?? 开头的。因为解释为三字母的序列可以出现在现有的代码中，所以，K&R C 编译器在遇到这些序列时会生成转换诊断信息。
生成该消息的代码示例：
char *surprise = "this is a trigraph??!";
消息 ID：E_TRIGRAPH_REPLACED
每一个非空源文件和标题必须由完整的行组成。该诊断信息警告，文件的最后一行不能以换行符结尾。
消息 ID：E_NEWLINE_NOT_LAST
编译器在读取用于函数之类的宏调用的参数时，到达了文件尾。
生成该消息的代码示例：
#define mac(a) mac( arg1
消息 ID：E_EOF_IN_MACRO_ARG
#error 指令中的标记必须是有效的 C 标记。源程序包含无效的标记。
生成该消息的代码示例：
#error 038 - this is an invalid token
消息 ID：E_BAD_TOKEN_IN_ERROR_DIRECTIVE
编译器无法打开新的包含文件，因为已经打开其他太多的包含文件。该编译器至少支持操作系统定义的最大“嵌套”层，即 8 层。之所以发出诊断信息，最有可能的原因是，包含文件有时包括已经包含的文件。
消息 ID：E_CANT_OPEN_INCLUDE_FILE
在搜索的任何目录路径中都找不到 #include 指令中指定的文件。
生成该消息的代码示例：
#include "where_is_it.h"
消息 ID：E_CANT_FIND_INCLUDE_FILE
编译器遇到了不能组成有效标记的字符序列。无效的标记可能是由预处理 ## 运算符产生的。显示违例的非标记。如果非标记的长度超过 20 个字符，将会打印后面跟 ". . ." 的前 20 个字符。违例的无效标记被忽略。
生成该消息的代码示例：
#define PASTE(l,r) l ## r double d1 = 1e; double d2 = PASTE(1,e); int i = 1veryverylongnontoken;
消息 ID：E_INVALID_TOKEN
编译器未将字符序列识别为有效的 C 语言标记。
生成该消息的代码示例：
int i = 1$;
消息 ID：E_INVALID_INPUT_TOKEN
编译器在处理函数之类的宏定义的参数列表时遇到不正确的标记。
生成该消息的代码示例：
#define mac(a,4) a b c
消息 ID：E_INVALID_TOKEN_IN_DEFINE_MACRO
编译器在结构正确的指令结尾处找到无效的标记。
生成该消息的代码示例：
#line 7 "file.c
消息 ID：E_INVALID_TOKEN_IN_DIRECTIVE
已经在 #if 或 #elif 指令中使用标记。该标记既不是常量表达式的有效运算符，也不是有效的整型常量。
生成该消息的代码示例：
#if 1 > "1" int i = 1; #endif
消息 ID：E_TOKEN_ILLEGAL_IN_DIRECTIVE
#if 或 #elif 指令中的定义运算符之后必须跟标识符或括起标识符的 ( )。源代码不能这样使用该运算符。
生成该消息的代码示例：
#if defined int i = 1; #endif
消息 ID：E_INVALID_USE_OF_DEFINE
传递到宏的参数数量与宏定义中的参数数量不同。
生成该消息的代码示例：
#define twoarg(a,b) a+b int i = twoarg(4);
消息 ID：E_ARGUEMENT_MISMATCH
预处理程序宏的实际参数不包含标记。ANSI C 标准将该条件视为未定义。C 编译器将空的标记列表视为空的参数。另外，它还可以在 -Xc 模式下发出该警告。
生成该消息的代码示例：
#define m(x) x+3 int i = m();
消息 ID：E_TOKENLESS_MACRO
编译器内部错误。
消息 ID：E_INVALID_TARGET_FILENAME
#include 指令未指定要包含的文件。
生成该消息的代码示例：
#include
消息 ID：E_INCLUDE_MISSING_FILENAME
已经使用允许宏扩展其参数的 #include 指令格式，但生成的扩展并没有用标记作为文件名。
生成该消息的代码示例：
#define EMPTY #include EMPTY
消息 ID：E_INCLUDE_EXPANSION_NO_FILE
#include 指令中的文件名为空。
生成该消息的代码示例：
#include <>
消息 ID：E_EMPTY_FILE_NAME
宏替换之后的文件名为空。
生成该消息的代码示例：
#define NULLNAME <> #include NULLNAME
消息 ID：E_EMPTY_HEADER_NAME
#include 指令中缺少右 >。
生成该消息的代码示例：
#include <stdio.h /* closing ">" expected */
消息 ID：E_NO_CLOSING_GREATER_THAN
#include 指令中的文件说明符既不是字符串型，也不是格式正确的标题名称。
生成该消息的代码示例：
#include stdio.h
消息 ID：E_BAD_FILE_SPEC
行号信息指令（供编译器的内部通信使用）中的行号必须是非零正值。
生成该消息的代码示例：
# 0 "foo.c"
消息 ID：E_ZERO_INVALID_IN_POUND_NUMBER
#line 指令中的行号必须是非零正值。
生成该消息的代码示例：
#line 0
消息 ID：E_ZERO_INVALID_IN_POUND_LINE
# < number > 指令后面只能跟字符串型。
生成该消息的代码示例：
#15 notstring
消息 ID：E_STRING_EXPECTED_POUND_NO
在 #line 指令中，只有字符串型才跟在行号后面。
生成该消息的代码示例：
#line 12 int
消息 ID：E_STRING_EXPECTED_POUND_LINE_NO
说明预处理程序指令行的 # 之后是无效标记或非十进制数字。
生成该消息的代码示例：
#0x12
消息 ID：E_POUND_NUMBER_EXPECTED
编译器应该在 #line 之后找到包含行号的数字序列，但是找到的标记不是正确的标记或值为零的数字序列。
生成该消息的代码示例：
#line 09a
消息 ID：E_POUND_LINE_NO_EXPECTED
#line 指令的其余部分为空；缺少行号和可选的文件名。
生成该消息的代码示例：
#line
消息 ID：E_NO_TOKENS_IN_POUND_LINE
对 #line 指令中的表达式应用宏扩展之后，没有要解释为行号的标记。
生成该消息的代码示例：
#define EMPTY #line EMPTY
消息 ID：E_NO_TOKENS_AFTER_EXPANSION
在函数之类的宏定义中，已多次将名称用作形式参数。
生成该消息的代码示例：
#define add3(a,a,c) a + b + c
消息 ID：E_DUPLICATE_FORMAL_PARAM
源代码重新定义宏。如果除形式参数的顺序和拼写之外，两个定义相同，K&R C 的早期版本允许这样重新定义。ANSI C 要求，重新正确定义宏时，定义必须相同，其中包括形式参数的顺序和拼写。如果新的宏定义与原来的宏定义不符，则使用所有选项时，都会产生该诊断信息。为了获得严格的一致性，如果只有宏定义中的形式参数拼写不符，则使用 -Xc 选项时，也会产生该诊断信息。
生成该消息的代码示例：
#define TIMES(a,b) a * b #define TIMES(a,b) a - b
消息 ID：E_MACRO_REDEFINED
字符常量具有派生自字符的字符代码的整数值。如果字符常量包含多个字符，则其他字符的编码与执行有关。该警告提示您，该发行版本的 C 编译器与早期版本的编译器相比，预处理阶段使用的字符常量的编码不同。早期版本仅支持第一个字符。不能对可执行代码中使用的字符常量编码进行更改。
生成该消息的代码示例：
#if 'ab' != ('b' * 256 + 'a')
#error unknown encoding
#endif
消息 ID：E_MULTI_CHAR_CHAR_CONST
使用 -Xt 选项显示该警告。在 #if 或 #elif 指令中使用的操作数值大于 LONG_MAX (2147483647)，但该操作数没有无符号修改符后缀。K&R C 的早期版本将这种常量视为带符号的数字。因为这些常量的数值确实为负数。ANSI C 将这些常量视为无符号的长整型。这些整数会影响其自身在表达式中的行为。该诊断信息可以暂时帮助您了解该值在过去与现在的使用区别。
生成该消息的代码示例：
#if 2147483648 > 0 char *mesg = "ANSI C-style"; #endif
消息 ID：E_OPERAND_TREATED_AS_UNSIGNED
源文件包括使用显式前缀 /usr/include 的文件。这种包含与执行有关，且无法移植。对于某些系统，查找标题的缺省位置列表可能不包括 /usr/include 目录。在这种情况下，可能会包括错误的文件。
生成该消息的代码示例：
#include </usr/include/stdio.h>
消息 ID：E_INC_USR_INC_MAY_NOT_PORTABLE
在没有遇到与以前遇到的 #if、#elif、#else、#ifdef 或 #ifndef 指令匹配的 #endif 情况下，编译器已经到达源文件的结尾。
生成该消息的代码示例：
#ifndef STUB TranslationEntry* pageTable = NULL; /* 编译器开始在此点之后查找 #endif */ #ifdef CHANGED int newfuntion(int a); #endif /* 此 #endif 与 #ifdef 相匹配 */ /* 编译器仍在该行之后查找 #endif */ /* 但在该行之后未找到 #endif */
消息 ID：E_NO_MATCHING_ENDIF
#elif 指令必须是以 #if 指令开头的预处理 if 部分的一部分。可疑的代码缺少 #if。
生成该消息的代码示例：
#elif defined(TWO) int i = 2; #endif
消息 ID：E_ELIF_MISSING_IF
#elif 指令的后面没有表达式。
生成该消息的代码示例：
#if defined(ONE) int i = 1; #elif int i = 4; #endif
消息 ID：E_ELIF_REQUIRES_CONST_EXP
预处理 if 部分必须遵循下面的顺序：#if、可选的 #elifs、可选的 #else 和 #endif。代码在 #else 指令之后包含 #elif。
生成该消息的代码示例：
#if defined(ONE) int i = 1; #elif defined(TWO) int i = 2; #else int i = 3; #elif defined(FOUR) int i = 4; #endif
消息 ID：E_ELIF_FOLLOWS_ELSE
遇到 #else 指令，它不是预处理 if 部分的一部分。
生成该消息的代码示例：
#else int i = 7; #endif
消息 ID：E_ELSE_MISSING_IF
代码在预处理 if 部分包含多个 #else 指令。第一个 #else 指令之后的所有 #else 指令被视为 false。
生成该消息的代码示例：
#ifdef ONE int i = 1; #else int i = 2; #else int i = 3 #endif
消息 ID：E_TOO_MANY_ELSES
遇到 #endif 指令，它不是预处理 if 部分的一部分。
生成该消息的代码示例：
int i = 1; #endif
消息 ID：E_IFLESS_ENDIF
#if 指令之后不出现表达式。
生成该消息的代码示例：
#if int i = 4; #endif
消息 ID：E_IF_REQUIRES_CONST_EXP
#ifdef 预处理指令之后必须跟要检查其定义的宏名称。源代码已经省略标识符。#ifdef 被视为 false。
生成该消息的代码示例：
#ifdef int i = 1; #endif
消息 ID：E_IFDEF_REQUIRES_IDENTIFIER
#ifndef 指令之后必须跟要测试是否已经定义的标识符。
生成该消息的代码示例：
#ifndef int i = 5; #endif
消息 ID：E_IFNDEF_REQUIRES_IDENTIFIER
使用 -P 选项时，已经提供 .i 文件。例如：cc -P tst.i
消息 ID：E_PREPROCESSING_DOT_I_FILE
在编译器访问标准输出 (stdout) 时发生文件系统错误。
消息 ID：E_STDOUT_ERROR
在编译器访问标准错误 (stderr) 时发生文件系统错误。
消息 ID：E_STDERR_ERROR
#assert 指令不包含要断言的谓词名称。
生成该消息的代码示例：
#assert
消息 ID：E_EMPTY_ASSERT_DIRECTIVE
在 #assert 指令中，该指令之后的标记不是谓词的名称。
生成该消息的代码示例：
#assert 5
消息 ID：E_ASSERT_IDENTIFIER_EXPECTED
在 #assert 指令中，该谓词之后的标记不是必需的 (。
生成该消息的代码示例：
#assert system unix
消息 ID：E_ASSERT_ID_DOT_DOT_EXPECTED
#assert 指令的使用格式错误。缺少断言以及应该跟随的 )。
生成该消息的代码示例：
#assert system(
消息 ID：E_NO_TOKENS_AFTER_ASSERT_NAME
在 #assert 指令中，谓词的圆括号内没有断言。
生成该消息的代码示例：
#assert system()
消息 ID：E_ASSERT_NO_TKNS_BETWEEN_PARENS
在 #assert 指令中，采用圆括号结构的断言缺少右 )。
生成该消息的代码示例：
#assert system(unix
消息 ID：E_ASSERT_MISSING_PAREN
在 cc 命令的 -A- 选项中，没有与该选项相邻的其他标记。这些标记被忽略。
生成该消息的代码示例：
cc -A-extra -c x.c
消息 ID：E_TOKENS_AFTER_A_IGNORED
cc 命令行参数 -A 之后必须跟要断言的谓词名称或要去掉所有预定义宏和谓词的 -。-A 之后的标记不是上面任何一种类型。
生成该消息的代码示例：
cc -A3b2 -c x.c
消息 ID：E_IDENTIFIER_EXPECTED_AFTER_A
编译器应该在条件编译指令中的 # 之后找到标识符和谓词名称，但未找到。
生成该消息的代码示例：
#if #system(unix) || # char *os = "sys"; #endif
消息 ID：E_IDENT_EXPECTED_AFTER_POUND
在 #if 或 #elif 指令中使用 # 运算符选择谓词而不是类似名称的宏时，该谓词之后必须跟具有圆括号的标记列表。
生成该消息的代码示例：
#assert system(unix) #define system "unix" #if #system char *systype = system; #endif
消息 ID：E_PAREN_EXPECTED_AFTER_ID_PND
在 #if 或 #elif 指令中使用 # 运算符选择谓词而不是类似名称的宏时，该谓词之后必须跟具有圆括号的标记列表。
生成该消息的代码示例：
#if #system( char *system = "unix"; #endif
消息 ID：E_TOKENS_EXPECTED_AFTER_ID_PND
在 #if 或 #elif 指令中，要测试的谓词断言名称被省略。
生成该消息的代码示例：
#if #system() char *sysname = "??"; #endif
消息 ID：E_TKNS_EXPECTED_BETWEEN_PARENS
在测试 #if 或 #elif 指令中 # 运算符之后的谓词时，缺少断言之后的 )。
生成该消息的代码示例：
#if # system(unix char *system = "unix"; #endif
消息 ID：E_MISSING_R_PAREN
#unassert 指令不包含要丢弃的谓词名称。
生成该消息的代码示例：
#unassert
消息 ID：E_EMPTY_UNASSERT_DIRECTIVE
#unassert 指令必须将谓词命名为“未断言”。
生成该消息的代码示例：
#unassert 5
消息 ID：E_UNASSERT_REQUIRES_IDENTIFIER
在 #unassert 指令中，谓词之后缺少断言和右 )。
生成该消息的代码示例：
#unassert system(
消息 ID：E_TOKENS_EXPECTED_AFTER_L_PAREN
在 unassert 指令中，必须为要放置的谓词断言加圆括号。
生成该消息的代码示例：
#unassert system(unix
消息 ID：E_R_PAREN_EXPECTED
编译器应该在 ( ) 之间找到标记。该标记用于分隔 #unassert 指令中谓词的断言。但是，未找到任何标记。
生成该消息的代码示例：
#unassert machine()
消息 ID：E_EMPTY_PREDICATE_ARGUMENT
在 #unassert 指令中，必须为要放置的谓词断言加圆括号。
生成该消息的代码示例：
#unassert system unix
消息 ID：E_L_PAREN_EXPECTED_AFT_FIRST_ID
源代码尝试定义或重新定义 ANSI C 预定义的宏。预定义的宏不能更改。
生成该消息的代码示例：
#define __FILE__ "xyz.c" #define __LINE__ "10" #define __DATE__ "Jan 21 1993" #define __TIME__ "10:20:04"
消息 ID：E_CANT_REDEFINE_ANSI_PREDEFINE
不能将预定义的预处理运算符 "defined" 定义为宏名称。
生成该消息的代码示例：
#define defined xyz
消息 ID：E_CANNOT_DEFINE_DEFINED
ANSI C 禁止取消定义预定义的符号 __STDC__。您可能需要使用该功能测试已经编写的 C 代码。这些代码可以同时在 ANSI C 和非 ANSI C 环境下运行。例如，假设拥有可以检查 __STDC__ 的 C 代码，同时声明函数原型声明（如果定义）和旧式函数声明或定义（如果未定义）。因为 C 编译器预定义了 __STDC__，所以在一般情况下，无法检查旧式代码，必须通过其他（非 ANSI C）编译器运行该代码。通常，在命令行中取消定义 __STDC__ 之后，可以使用 C 编译器执行检查操作。该诊断信息说明，您违反了 ANSI C 的约束规定。
生成该消息的代码示例：
#undef __STDC__ /* cc 行上通常为 -U__STDC__ */
#ifdef __STDC__
int
myfunc(const char *arg1, int arg2)
#else /* 非 ANSI C 条件 */
int
myfunc(arg1,arg2)
char *arg1, /* oops */
int arg2;
#endif
{
}
消息 ID：E_UNDEFINING__STDC__
源代码包含对 ANSI C 预定义的宏进行取消定义的尝试。
生成该消息的代码示例：
#undef __FILE__ #undef __LINE__ #undef __DATE__ #undef __TIME__
消息 ID：E_CANT_UNDEFINE_ANSI_PREDEFINE
无法取消定义预定义的预处理运算符 "defined"。
生成该消息的代码示例：
#undef defined
消息 ID：E_CANT_UNDEFINE_DEFINED
cc -D 命令行选项之后必须跟标识符。
生成该消息的代码示例：
cc -D3b2 -c x.c
消息 ID：E_D_OPT_ARG_NOT_AN_IDENTIFIER
如果 cc 命令的 -D 命令行选项中的标识符之后有任何标记，则这样的第一个标记必须是 =。
生成该消息的代码示例：
cc -DTWO+2 -c x.c
消息 ID：E_D_OPT_NOT_FOLLOWED_BY_EQUAL
cc -U 命令行选项之后必须跟标识符。
生成该消息的代码示例：
cc -U3b2 -c x.c
消息 ID：E_U_OPT_ARG_NOT_AN_IDENTIFIER
在包含 -U 选项的命令行中，要取消定义的宏名称之后有标记。
生成该消息的代码示例：
cc -Uunix,u3b2 -c x.c
消息 ID：E_TOKENS_IGNORED_AFTER_U_OPT
#define 指令缺少要定义的宏名称和其他所有标记。
生成该消息的代码示例：
#define
消息 ID：E_EMPTY_POIND_DEFINE_DIRECTIVE
#define 指令之后必须跟要定义的宏名称。
生成该消息的代码示例：
#define +3
消息 ID：E_PND_DEF_REQUIRES_MACRO_NAME
在定义函数之类的参数时，编译器在 #define 指令所在的同一行中找不到 ) 字符。
生成该消息的代码示例：
#define mac(a
消息 ID：E_INCOMPLETE_DEF_MACRO_PARAMS
函数之类的宏定义的宏参数列表的格式错误。该列表必须是以逗号分隔的标识符列表。
生成该消息的代码示例：
#define mac(a,b,) a b
消息 ID：E_SYNTAX_ERROR_IN_MACRO_PARAMS
在宏定义中，# 或 ## 运算符之后跟的是 # 或 ## 运算符。
生成该消息的代码示例：
#define bug(s) # # s #define bug2(s) # ## s
消息 ID：E_BAD_SHARP_OR_SHARPS_IN_MACRO
## 运算符是二进制中缀运算符，所以不能是宏定义的宏替换列表中的第一个标记。
生成该消息的代码示例：
#define mac(s) ## s
消息 ID：E_CANT_BEGIN_MACRO_WITH_SHARP
宏定义中 # 运算符之后的标识符必须是函数之类的宏的形式参数。
生成该消息的代码示例：
#define mac(a) "abc" # b
消息 ID：E_NON_FORMAL_ID_FOLLOWS_SHARP
使用 -Xt 选项显示该警告。该诊断信息指出，编译器将明显的并置视作 ## 运算符。应该更新源代码以便使用新的运算符。
生成该消息的代码示例：
#define PASTE(a,b) a/*GLUE*/b int PASTE(prefix,suffix) = 1; /* 创建“prefixsuffix” */
消息 ID：E_COMMENT_REPLACED_BY_SHARPS
使用 -Xa 和 -Xc 选项显示该警告。在 K&R C 的早期版本中，通过将两个标记并置在一个宏中并在标记之间使用注释，从而将这些标记“粘贴”在一起。这种行为从未得到定义或确认。ANSI C 提供了明确定义的运算符 ##。该运算符具有相同的功能，应该使用该运算符。该诊断信息警告，将不提供旧的行为。
生成该消息的代码示例：
#define PASTE(a,b) a/*GLUE*/b int PASTE(prefix,suffix) = 1; /* 未创建 "prefixsuffix" */
消息 ID：E_COMMENT_DOSNT_CONCAT_TOKENS
K&R C 的早期版本允许在作为宏定义的一部分的字符串型中替换形式参数值。ANSI C 不允许这样使用。 ANSI C 提供了一种完成相同任务的方法。"string-ize" 运算符 # 可以将宏参数的标记转换成字符串型，然后并置相邻的字符串型。正确的结构如下：
#define HELLO(name) name
char *hello_mindy = HELLO("Mindy");
生成该消息的代码示例：
#define HELLO(name) "name" char *hello_mindy = HELLO(Mindy);
消息 ID：E_MACRO_REPLACEMENT_IN_STRING
K&R C 的早期版本允许在作为宏定义的一部分的字符常量中替换形式参数值。ANSI C 不允许这样使用。 在 ANSI C 中，表示这种构造的正确方法如下：
#define CTRL(x) (x037) /* 形式控制字符 */
int ctrl_c = CTRL('c');
生成该消息的代码示例：
#define CTRL(x) ('x'037) /* 形式控制字符 */
int ctrl_c = CTRL(c);
消息 ID：E_MACRO_REPLACEMENT_CHAR_CONST
使用 -Xa 或 -Xc 选项显示该警告。该警告提示，在 -Xt 模式下完成的宏替换尚未在 -Xa 或 -Xc 模式下完成。
消息 ID：E_NO_REPLACEMENT_IN_STRING
使用 -Xa 或 -Xc 选项显示该警告。该警告提示，在 -Xt 模式下完成的宏替换尚未在 -Xa 或 -Xt 模式下完成。
消息 ID：E_NO_REPLACEMENT_IN_CHAR_CONST
"string-ize" 运算符 # 之后必须跟函数之类的宏中的形式参数名称。
生成该消息的代码示例：
#define mac(a) # + a
消息 ID：E_ID_REQUIRED_FOR_POUND_DEFINE
# 或 ## 运算符不能是宏定义的宏替换列表中的最后一个标记。
生成该消息的代码示例：
#define mac1(s) abc ## s ## #define mac2(s) s #
消息 ID：E_CANT_END_MACRO_WITH_SHARP
#undef 指令缺少要“取消定义”的宏名称。
生成该消息的代码示例：
#undef
消息 ID：E_EMPTY_UNDEF_DIRECTIVE
#undef 之后必须跟要取消定义的宏名称。指令后面的标记不是标识符。
生成该消息的代码示例：
#undef 4
消息 ID：E_ID_EXPECTED_AFTER_UNDEF
指令行包含多余的标记。这些标记不应该是该指令的一部分。
生成该消息的代码示例：
#undef a b /* 只能取消定义一个 */
消息 ID：E_TKNS_IGNORED_AT_END_OF_DIR
编译器应该在 #if 或 #elif 指令中找到一个数字，但该编译器无法找到。
生成该消息的代码示例：
#if 1 + int i = 1; #endif
消息 ID：E_NUMBER_EXPECTED
预处理条件编译指令的常量表达式格式错误。应该有运算符，但未遇到。
生成该消息的代码示例：
#if 1 4 int i = 1; #endif
消息 ID：E_MISSING_OPERATOR
在 #if 或 #elif 指令中已检测到位置错误的 )。
生成该消息的代码示例：
#if ) 1 int i = 1; #endif
消息 ID：E_UNEXPECTED_R_PAREN
在 #if 或 #elif 指令中已检测到位置错误的 (。
生成该消息的代码示例：
#if 1 ( int i = 1; #endif
消息 ID：E_UNEXPECTED_L_PAREN
预处理条件编译指令的常量表达式格式错误。缺少某个运算符必需的操作数。
生成该消息的代码示例：
#define EMPTY #if EMPTY / 4 int i = 1; #endif
消息 ID：E_MISSING_OPERAND
表达式包含编译时检测到的除以零的运算。如果除法运算是 #if 或 #elif 指令的一部分，则结果为零。如果除法运算位于可执行代码中，则诊断信息是警告；如果表达式位于全局或静态初始化程序中，则诊断信息是错误。
生成该消息的代码示例：
f(void) {
int i = 1/0;
}
消息 ID：E_DIVISION_BY_ZERO
% 运算符的第二个操作数是零。如果模数运算是 #if 或 #elif 指令的一部分，则结果为零。如果模数运算位于可执行代码中，则诊断信息是警告；如果表达式位于全局或静态初始化程序中，则诊断信息是错误。
生成该消息的代码示例：
#if 42 % 0 int i = 1; #endif
消息 ID：E_MODULUS_BY_ZERO
在字符串型和字符常量中，只有某些字符才能跟在 \ 之后；c 不属于其中的一个字符。ANSI C 会忽略 \。
生成该消息的代码示例：
int i = '\c';
消息 ID：E_DUBIOUS_ESCAPE_CHAR
在字符串型和字符常量中，只有某些非输出的字符才能跟在 \ 之后。在诊断信息中，尖括号内的值是作为十六进制数字输出的字符代码。
消息 ID：E_DUBIOUS_ESCAPE_UNPRINTABLE
使用 -Xt 选项显示该警告。在其他 K&R C 编译器中，'\a' 等效于 'a'。但是，ANSI C 会将‘\a’定义为警告字符。在这种执行过程中，其对应的字符代码是 07，即 BEL 字符。
生成该消息的代码示例：
int c = '\a';
消息 ID：E_ESC_A_IS_ANSI_ALERT
指定 -Xs 或 -Xt 编译模式时，该编译器会将 "\x" 视为字符 "x"。ANSI C 编译模式（-Xa 和 -Xc）除外
"\x<十六进制的数字>"指定十六进制转义符序列。
使用 -Xs 选项编译时生成该消息的代码示例：
char *cp = "This is a hex escape sequence for 254: \xfe";
消息 ID：E_ESC_X_IS_ANSI_HEX_ESCAPE
使用 -Xa 或 -Xc 选项显示该警告。字符常量和字符串型中的 \x 转义符说明了十六进制的字符转义符。\x 之后必须至少跟一个十六进制的数字。
生成该消息的代码示例：
char *cp = "&\xz";
消息 ID：E_NO_HEX_DIGITS_AFTER_ESCAPE_X
在字符常量或字符串型的十六进制转义符 (\x) 中，该转义符的累计值变得过大。只能保留低位 32 位值。
生成该消息的代码示例：
int i = '\xabcdefedc';
消息 ID：E_OVERFLOW_IN_HEX_ESCAPE
已经使用未包含字符的字符常量。
生成该消息的代码示例：
f(void) {
char c = ''; /* 建议：char c = ' '; */
}
消息 ID：E_EMPTY_CHAR_CONSTANT
字符常量包含的字符太多，不适用于整数。只能使用正则字符常量的前四个字符和宽字符常量的第一个字符。长度超过一个字符的字符常量无法进行移植。
生成该消息的代码示例：
int i = 'abcde';
消息 ID：E_CHAR_CONST_TOO_LONG
在主机环境中，字符串型或字符常量中的多字节字符无法转换成单个宽字符。否则，会忽略别处找到的多字节字符。
消息 ID：E_INVALID_MULTIBYTE_CHAR
在字符常量或字符串型中，十六进制或八进制转义序列生成的值太大，不适用于无符号的字符。为了适合，要截断该值。
生成该消息的代码示例：
char *p = "\x1ff\400";
消息 ID：E_CHAR_ESC_DOES_NO_FIT_IN_CHAR
使用 -Xt 选项显示该警告。以 0 开头的整型常量包含非八进制的数字。值 8 所采用的形式为 8；值 9 所采用的形式为 9。即使这些值是无效的。
生成该消息的代码示例：
int i = 08;
消息 ID：E_BAD_OCTAL_DIGIT
预处理条件编译指令中的圆括号不匹配。
生成该消息的代码示例：
#if ((1) int i = 1; #endif
消息 ID：E_MISMATCHED_PARENS
#if 或 #elif 指令中的表达式包含格式错误的 ?~: 表达式。
生成该消息的代码示例：
#if defined(foo) ? 5 int i; #endif
消息 ID：E_MISMATCHED_TERNARY_OP
#if 或 #elif 指令包含的表达式在宏扩展后无标记。
生成该消息的代码示例：
#define EMPTY #if EMPTY char *mesg = "EMPTY is non-empty"; #endif
消息 ID：E_EMPTY_CONST_EXP_AFTER_EXPAND
在编译器访问标准输出 (stdout) 时发生文件系统错误。
消息 ID：E_CANT_DUP_STDOUT
在编译器访问标准输出 (stdout) 时发生文件系统错误。
消息 ID：E_CANT_OPEN_ALT_STDOUT
在编译器访问 /dev/null 时发生文件系统错误。
消息 ID：E_CANT_OPEN_DEV_NULL
编译器在写入中间文件时，磁盘空间已不足。请在开始编译之前验证写入临时文件的文件系统是否具有足够的可用空间。使用 TMPDIR 环境变量指定替代的位置，以便于编译器写入临时文件。
消息 ID：E_TMPFILE_FILE_SYSTEM_FULL
在函数定义中，已经使用无效的类型信息声明参数。尚未定义类型或已将不表示类型的标识符用作类型。通常，遇到语法错误消息之后，会发出该警告。
生成该消息的代码示例：
int f1(what arg)
{
}
消息 ID：E_UNDEFINED_OR_MISSING_TYPE
这是通用的诊断信息，它指出了编译器找到的任何一种可能出现的语法错误，其中包括缺少分号、缺少右圆括号或花括号，或语言标记并置。诊断信息中的标记指出该编译器找到的错误位于源代码的位置点和指定的行。
生成该消息的代码示例：
f(void) {
int i = 3 /* 此处缺少分号 */
}
f(int i){
int j;
j = (i + 24; /* 此处缺少右圆括号 */
}
消息 ID：E_YACC_GENERIC_ERROR
这是通用的诊断信息，它指出了编译器找到的任何一种可能出现的语法错误，其中包括缺少分号、缺少右圆括号或花括号，或语言标记并置。诊断信息中的标记指出该编译器找到的错误位于源代码的位置点和指定的行。
生成该消息的代码示例：
f(void) {
int i = 3 /* 此处缺少分号 */
}
f(int i){
int j;
j = (i + 24; /* 此处缺少右圆括号 */
}
消息 ID：E_YACC_ERROR
无法使用 void 指针访问对象。源代码中包含通过 void 指针（可能限定）进行间接引用的表达式。虽然支持表达式的其余部分（如果有），但是会忽略该间接引用。
生成该消息的代码示例：
f(void) {
volatile void *vp1, *vp2;
*(vp1 = vp2);/* 赋值完成 */
}
消息 ID：E_ACCESS_VIA_VOID_PTR_IGNORED
当前具有相同常量值的 switch 语句包含两个 case 语句。
生成该消息的代码示例：
f(void) {
long long i = 5;
switch(i) {
case 4:
case 4:
break;
}
}
消息 ID：E_DUP_CASE_IN_SWITCH_L
当前具有相同常量值的 switch 语句包含两个 case 语句。
生成该消息的代码示例：
f(void) {
int i = 5;
switch(i) {
case 4:
case 4:
break;
}
}
消息 ID：E_DUP_CASE_IN_SWITCH
asm 语句只能出现在函数主体内，而不能出现在外部声明层。
生成该消息的代码示例：
asm(" .align 4 "); /* 不正确 */
void f(void) {
asm(" nop "); /* 正确 */
消息 ID：E_ASM_ILLEGAL_OUTSIDE_FUNC
旧式 asm() 的参数必须是标准字符串型，而不是宽字符。
生成该消息的代码示例：
asm(L"wide string literal not allowed");
消息 ID：E_ASM_ARG_MUST_BE_STRING
旧式 asm( ) 中出现的字符串型包含嵌入的 NUL 字符（字符代码为 0）。
生成该消息的代码示例：
asm("this is an old-style asm with embedded NUL: \0");
消息 ID：E_EMBEDDED_NUL_ILLEGAL_IN_ASM
使用 -v、-O 和 -xO[level] 选项显示该警告。如果在函数中找到 asm 语句，则会禁用对该函数的优化。
生成该消息的代码示例：
void foo(void)
{
asm(".volatile");
asm(" st %g0, [%sp+0x44]");
asm(" ld [%sp+0x44], %fsr");
asm(" nop");
asm(".nonvolatile");
}
消息 ID：E_ASM_DISABLES_OPTIMIZATION
预处理完成之后，源文本中没有标记。ANSI C 标准要求该编译器诊断没有标记的文件。
生成该消息的代码示例：
#ifdef COMPILE int token; #endif
消息 ID：E_EMPTY_TRANSLATION_UNIT
Lock_lint 无法说明使用指向锁定的简单指针时处理的锁定。
生成该消息的代码示例：
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; /* <=== 正确 */
int global_data;
};
int add_data() {
mutex_lock(&global_mutex->amutex); /* <=== 正确 */
global_mutex->global_data++;
mutex_unlock(&global_mutex->amutex); /* <=== 正确 */
return global_mutex->global_data;
}
消息 ID：E_LOCK_FUNC_IGNORES_PTR
如果在函数调用中使用 ?: 运算符，则通过 lock_lint 对源代码所执行的静态分析，无法确定正在传递给函数的参数。该消息表明，lock_lint 假设的值是传递给该函数的值。
生成该消息的代码示例：
mutex_t mutex1; mutex_t mutex2; mutex_lock((1==1)? &mutex1 : &mutex2);
消息 ID：E_CONDITIONAL_OP_LOCK_CHOICE
lock_lint 所执行的静态源代码分析将假设，指定的函数已成功获取锁。
生成该消息的代码示例：
mutex_t mutex1; if (mutex_trylock(&mutex1)) goto getlock;
消息 ID：E_ASSUME_SUCCESSFUL_LOCK
如果在函数调用中使用 ?: 运算符，则通过 lock_lint 对源代码所执行的静态分析，无法确定正在传递给函数的参数。lock_lint 所执行的静态源代码分析将假设，指定的条件变量正作为参数传递给指定的函数。
生成该消息的代码示例：
int waitWriter;
f() {
cond_t condt1, condt2;
cond_wait((waitWriter == 0) ? condt1 : condt2);
}
消息 ID：E_CONDITIONAL_OP_CONDVAR_CHOICE
Lock_lint 忽略指向条件变量的简单指针，因为它无法说明正在处理的锁定。
生成该消息的代码示例：
cond_t* ptr; int count = 0; /* 共享变量 */ while (count == 0) cond_wait(ptr); /* 如果这样重写，lock_lint 可以对其进行分析 */ cond_t p; while (count == 0) cond_wait(&p);
消息 ID：E_CV_FUNC_IGNORES_SIMPLE_PTR
该函数需要两个参数。尚未指定第二个互斥参数。
生成该消息的代码示例：
kcondvar_t cvp; cv_wait(&cvp); /*====================== ** 正确代码应该是： */ kcondvar_t cvp; kmutex_t mp; cv_wait(&cvp, &mp);
消息 ID：E_SECOND_MUTEX_MISSING
一个操作数具有 void 类型。
生成该消息的代码示例：
f(void) {
void v(void);
int i = v();
}
消息 ID：E_OPERAND_CANT_BE_VOID_TYPE
-Xs 选项允许两个字符赋值运算符之间有空白。字符赋值运算符包括：
+=, -=, *=, /=, &=, |=, ^=, %=但是，其他所有编译器模式不允许这些运算符之间有空白。
生成该消息的代码示例：
int i + = 1; /* 对于运算符: += */ int k - = 1;
消息 ID：E_WHITESPACE_IN_CHAR_ASSIGN_OPS
对于 ANSI C 和早期版本的 K&R C，它们的类型改进规则略有不同。在当前发行版本中，缺省行为是复制以前的规则。使用 compiler 命令中的 -Xa 选项，可以获取 ANSI C 解释。以前的 K&R C 类型改进规则将保留无符号类型。如果表达式的一个操作数属于无符号类型，则执行运算之前，该操作数要改进为常见的无符号类型。ANSI C 使用保留值类型改进规则。如果其所有值都可以使用符号类型表示，则无符号类型可以改进为符号类型。另外，对于隐式设置符号位的整型常量类型，ANSI C 和早期版本的 K&R C 的规则有所不同。由于类型改进规则不同，所以运算符的程序行为也不尽相同。这些运算符受其操作数的“无符号”的影响：
o 除法运算符： /、/=、%、%= o 右移位运算符： >>、>>= o 关系运算符： <、<=、>、>=警告消息指出，程序包含其运算符行为将在未来发生更改的表达式。通过在该表达式中插入显式强制转换，可以确保您需要的行为。
生成该消息的代码示例：
f(void) {
int i;
/* 在 K&R C 中，常量是一个整数；在 ANSI C 中，常量是一个无符号整数 */
i /= 0xf0000000;
}
消息 ID：E_ANSI_CONST_UNSIGNED_OP
对于 ANSI C 和早期版本的 K&R C，它们的类型改进规则略有不同。在当前发行版本中，缺省行为是复制以前的规则。使用 cc 命令中的 -Xa 选项，可以获得 ANSI C 解释。以前的 K&R C 类型改进规则将保留无符号类型。如果表达式的一个操作数属于无符号类型，则执行运算之前，该操作数要改进为常见的无符号类型。ANSI C 使用保留值类型改进规则。如果其所有值都可以使用符号类型表示，则无符号类型可以改进为符号类型。由于类型改进规则不同，所以运算符的程序行为也不尽相同。这些运算符受其操作数的“无符号”的影响：
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;
}
消息 ID：E_SEMANTICS_OF_OP_CHG_IN_ANSI_C
整型常量太大，不适用于无符号长型。
生成该消息的代码示例：
int i = 123456789012345678901;
消息 ID：E_INTEGRAL_CONSTANT_TOO_LARGE
加后缀的常量太大，不适用于后缀 Hence 指定的类型，所以将其改进为无符号的整型。
消息 ID：E_CONST_PROMOTED_UNSIGNED_INT
加后缀的常量太大，不适用于后缀 Hence 指定的类型，所以将其改进为无符号的长型。
消息 ID：E_CONST_PROMOTED_UNSIGNED_LONG
使用 -v 选项显示该警告。加后缀的常量太大，不适用于该后缀指定的类型，所以将其改进为 long long 或无符号 long long 类型。
生成该消息的代码示例：
if (9223372036854775807L > 0) printf("promoted\n");
if (9223372036854775807UL > 0) printf("promoted\n");
消息 ID：E_CONST_PROMOTED_UNSIGNED_LL
加后缀的常量太大，不适用于后缀 Hence 指定的类型，所以将其改进为 long 类型。
消息 ID：E_CONST_PROMOTED_LONG
使用 -v 选项显示该警告。加后缀的常量太大，不适用于该后缀指定的类型，所以将其改进为 long long 或无符号 long long 类型。
生成该消息的代码示例：
if (9223372036854775807L > 0) printf("promoted\n");
if (9223372036854775807UL > 0) printf("promoted\n");
消息 ID：E_CONST_PROMOTED_LONG_LONG
浮点常量值太大，不适用于浮点类型。
生成该消息的代码示例：
float f = 1e300f;
消息 ID：E_CONV_CONST_FP_FLOAT_OUT_RANGE
浮点常量值太大，不适用于双精度长型类型。
消息 ID：E_CNV_CNST_FP_LONG_DBL_OUTRANGE
浮点常量值太大，不适用于双精度类型。
消息 ID：E_CONV_CONST_FP_DBL_OUT_RANGE
如果使用 -Xc 选项时出现错误，将会显示该消息。程序包含 &...，它是使用 -Xc 选项编译的。&... 是无效的 ANSI C 语法。请不要显式使用这种表示法。
消息 ID：E_AND_DOT_DOT_DOT_INVALID
编译器需要整型常量或可以在编译时求值以生成整数值的表达式。该表达式包含非整型值、对象引用，或在编译时无法求值的运算符。
生成该消息的代码示例：
int ia[5.0];
消息 ID：E_INTEGRAL_CONST_EXP_EXPECTED
程序包含使用 "->" 或 "." 运算符的表达式，名称不是运算符左侧引用的结构或联合成员，但是其他一些结构或联合的成员。如果成员不“唯一”，则该诊断信息是错误。唯一成员是一个或多个结构或联合的一部分，但它与结构或联合中的所有成员具有相同的类型和偏移。
生成该消息的代码示例：
struct s1 { int x,y; };
struct s2 { int q,r; };
f(void) {
struct s1 *ps1;
ps1->r = 3;
}
消息 ID：E_IMPROPER_MEMBER_USE
程序引用的是尚未声明为任何结构一部分的结构或联合成员。
生成该消息的代码示例：
struct s {int x;};
f(void) {
struct s q;
q.y = 1;
}
消息 ID：E_UNDEFINED_STRUCT_UNION_MEMBER
-> 运算符的左操作数不是结构、联合或指向一个对象的指针，所以该成员名称在已经声明的所有结构和联合成员中不唯一。结构或联合只能使用 ->，所以该成员应该是与左操作数对应的结构或联合成员。
消息 ID：E_NON_UNIQUE_REQRS_S_U_PTR
"." 运算符的左操作数不是结构、联合或指向一个对象的指针，所以该成员名称在已经声明的所有结构和联合成员中不唯一。结构或联合只能使用 "."。该成员应该是与左操作数对应的结构或联合成员。
生成该消息的代码示例：
struct s1 { int x,y; };
struct s2 { int y,z; };
f(void) {
long *lp;
lp.y = 1;
}
消息 ID：E_NON_UNIQUE_REQRS_S_U_OBJ
使用 -v 选项显示该警告。该程序调用以前未声明的函数。编译器警告，该程序假设函数返回 int。
生成该消息的代码示例：
void v(void){
g();
}
消息 ID：E_IMPLICIT_DECL_FUNC_RETURN_INT
已经引用范围内没有声明的符号。
生成该消息的代码示例：
f(void) {
g(i);
}
消息 ID：E_UNDEFINED_SYMBOL
以前声明对象的范围不再处于活动状态。在某些 ANSI C 执行中，引用对象时会产生错误；调用这种函数可以解释为调用返回 int 的函数。C 编译器可以记住并使用以前的声明。该警告会提示您编译器已经完成的任务。
生成该消息的代码示例：
f(void) {
extern int i;
double sin(double);
}
g(void){
double d = sin(1.5);
i = 1;
}
消息 ID：E_USING_OUT_OF_SCOPE_DECL
不能对函数应用 sizeof 运算符。
生成该消息的代码示例：
int f(void); int i = sizeof(f);
消息 ID：E_CANT_TAKE_SIZEOF_FUNC
不能对函数应用 sizeof 运算符。
生成该消息的代码示例：
int f(void); int i = sizeof(f);
消息 ID：E_CANT_TAKE_SIZEOF_FUNC_N
不能将 sizeof 运算符应用于 void 类型。
生成该消息的代码示例：
void v(void); int i = sizeof(v());
消息 ID：E_CANT_TAKE_SIZEOF_VOID
不能对位字段应用 sizeof 运算符。
生成该消息的代码示例：
struct s { int x:3; } st;
int i = sizeof(st.x);
消息 ID：E_CANT_TAKE_SIZEOF_BIT_FIELD
对于该类型的操作符，没有适用的操作数类型。
生成该消息的代码示例：
f(void){
char *cp;
int *ip;
void *vp = ip + cp;
}
消息 ID：E_OPERANDS_INCOMPATIBLE_TYPES
?: 表达式中的条件表达式必须具有标量类型：整数、浮点或指针。
生成该消息的代码示例：
struct s {int x;} st;
f(void) {
int i = st ? 3 : 4;
}
消息 ID：E_FIRST_OPERAND_SCALAR_TYPE
只有 "." 运算符，才能应用于结构或联合对象。如果 "." 的左操作数是数组、指针、函数调用、枚举常量或变量或分配给寄存器的寄存器值，则诊断信息是错误；否则是警告。
生成该消息的代码示例：
f(void) {
struct s { short s; };
int i;
i.s = 4;
}
消息 ID：E_DOT_L_OPERAND_NOT_STRUCT_U
"." 运算符的左操作数内必须完全包含结构或联合成员。
生成该消息的代码示例：
f(void) {
struct s {int x;};
char c;
c.x = 1;
}
消息 ID：E_CANT_ACCESS_MBR_NON_STRUCT_U
-> 运算符的左操作数必须是指向结构或联合的指针，但它不是。如果该操作数是指针，则诊断信息是警告，否则是错误。
生成该消息的代码示例：
struct s {int x;};
f(void) {
long *lp;
lp->x = 1;
}
g(void) :
struct s newStr;
newS->x = 1;
/* newS 是结构，而不是指向该结构的指针 */
}
消息 ID：E_LEFT_MUST_BE_PTR_TO_STRUCT_U
运算符使用的操作数必须是整型（short、int 和 long 等），但不是，例如使用的是结构。
生成该消息的代码示例：
struct Astr b; int a = 0x345 & b;
消息 ID：E_OPERAND_MUST_BE_INTEGRAL_TYPE
一元 - 和 + 运算符的操作数必须属于运算类型。
生成该消息的代码示例：
struct Astr {
int a;
int b;
}
g(void){
struct Astr l;
int k = l * 2; /* l 是结构 Astr，不属于运算类型 */
l = -l; /* l 是一元“-”或“+”的操作数 */
l = +l; /* 但 l 不属于运算类型 */
}
消息 ID：E_OPERAND_MUST_BE_ARITH_TYPE
一元 "!" 运算符的操作数必须具有标量类型。或者，使用运算符 "++" 或 "--" 的代码应该是标量类型。
生成该消息的代码示例：
struct aStr{
int a;
int b;
};
g(void){
struct aStr newStr;
newStr++; /* 一元 ++ 运算符的操作数必须是标量类型 */
newStr.a++; /* 这是正确的 */
}
消息 ID：E_OPERAND_MUST_BE_SCALAR_TYPE
表达式包含指向大小未知的对象指针的指针运算。
生成该消息的代码示例：
f(void) {
struct s *ps;
g(ps+1);
}
消息 ID：E_PTR_ARITH_MUST_KNOW_SIZE
减法的操作数都是指针，但这两个操作数指向不同的类型。只能对指向相同数组的同类指针执行减法运算。如果指针指向大小相同的对象，则诊断信息是警告，否则是错误。
生成该消息的代码示例：
f(void) {
int *ip;
char *cp;
int i = ip - cp;
}
消息 ID：E_BAD_POINTER_SUBTRACTION
您在函数调用中使用了表达式，该表达式就好像是函数或指向函数的指针的名称，实际上该表达式不是函数。
生成该消息的代码示例：
f(void) {
char *p;
p();
}
消息 ID：E_FUNC_DESIGNATOR_NOT_FUNC_TYPE
已经调用了范围内有函数原型声明的函数。另外，调用时所用的参数数量与声明中的参数数量 n 不匹配。
生成该消息的代码示例：
int f(int);
g(void){
f(1,2);
}
消息 ID：E_PROTOTYPE_MISMATCH_ARGS
已经调用了范围内有函数原型声明的函数。另外，调用时所用的参数数量与声明中的参数数量 n 不匹配。
消息 ID：E_PROTOTYPE_MISMATCH_ARG
使用 -v 选项显示该警告。在函数调用时，编译器已经确定，传递给函数的参数数量与有关该函数的其他信息不符。其他信息来自于两个来源：旧样式（非原型）的函数定义或已经超出了范围的函数原型声明，但是其类型信息将被记住。如果旧样式函数定义情况适用，并且该函数采用可变数量的参数，则该诊断可能有误。
生成该消息的代码示例：
extern int out_of_scope();
int f()
{ /* 函数没有参数 */
extern int out_of_scope(int);
}
int g()
{
f(1); /* f 没有参数 */
out_of_scope(); /* out_of_scope 应该有一个参数 */
}
消息 ID：E_ARGS_MISMATCH
使用 -v 选项显示该警告。在函数调用时，编译器已经确定，传递给函数的参数数量与有关该函数的其他信息不符。其他信息来自于两个来源：旧样式（非原型）的函数定义或已经超出了范围的函数原型声明，但是其类型信息将被记住。如果使用了旧样式函数定义，并且该函数采用可变数量的参数，则该诊断可能有误。
消息 ID：E_ARG_MISMATCH
调用返回结构或联合的函数时，必须可以看到该结构或联合的完整声明。否则，会出现该消息。
生成该消息的代码示例：
f(void) {
struct s g();
g();
}
消息 ID：E_CANT_RETURN_INCOMPLETE_TYPE
函数调用包含表达式类型为 void 的参数。
生成该消息的代码示例：
f(void) {
void v(void);
g(v());
}
消息 ID：E_VOID_EXP_MAY_NOT_BE_ARGS
在函数调用中的参数必须具有完整的类型。已经传递的结构、联合或枚举对象的类型不完整。
生成该消息的代码示例：
f(void) {
struct s *st;
g(*st);
}
消息 ID：E_ARG_CANT_BE_UNKNOWN_SIZE
对于已经调用的函数，其参数类型无法转换成该函数的函数原型声明中的类型。
生成该消息的代码示例：
struct s {int x; } q;
f(void) {
int g(int,int);
g(3, q);
}
消息 ID：E_ARG_INCOMPATIBLE_WITH_ARG
赋值运算的操作数类型不兼容。如果类型是不匹配的指针类型，则消息是警告。否则，消息是错误。
生成该消息的代码示例：
struct s {int x;} st;
f(void) {
int i;
char *cp;
const char *ccp;
i = st;
cp = ccp;
}
消息 ID：E_ASSIGNMENT_TYPE_MISMATCH
无法对表达式应用强制转换，因为类型不适合于强制转换。正在进行强制转换的表达式类型和已发生强制转换的表达式类型必须具有标量类型。指针只能强制转换为整型或从整型进行强制转换。
生成该消息的代码示例：
f(void) {
struct s {int x;} st;
int i = (int) st;
}
消息 ID：E_INVALID_CAST_EXPRESSION
正在尝试从无法转换成该函数的返回类型的函数返回一个值。
生成该消息的代码示例：
f(void) {
struct s {int x;} st;
return( st );
}
消息 ID：E_RETURN_VALUE_TYPE_MISMATCH
正在使用类型不兼容的初始化程序初始化变量。例如，正在初始化指针，使其指向不同类型的对象。
生成该消息的代码示例：
struct s {int x; int y; };
const int i = 10;
int *j = &i; /* <====== 类型不匹配 */
struct s *foo = j; /* <====== 类型不匹配 */
消息 ID：E_INITIALIZATION_TYPE_MISMATCH
switch 语句的控制表达式不能转换为 int。该消息跟在 switch 表达式必须具有整型消息之后。
生成该消息的代码示例：
f(void) {
struct s {int x;} sx;
switch(sx){
case 4: ;
}
}
消息 ID：E_INVALID_SWITCH_EXP_TYPE
使用 -v 选项显示该警告。在函数调用时，编译器已经确定，传递给函数的参数类型与有关该函数的其他信息不符。其他信息来自于两个来源：旧样式（非原型）的函数定义或已经超出了范围的函数原型声明，但是其类型信息将被记住。可疑的参数是根据缺省的参数改进规则进行改进的。如果使用了旧样式函数定义，并且该函数采用可变数量的参数，则该诊断可能有误。
生成该消息的代码示例：
void f(i)
int i;
{ }
void g(void)
{
f("erroneous");
}
消息 ID：E_ARG_NOT_MATCH_REMEMBERED_TYPE
无法获取结构或联合的位字段成员地址。
生成该消息的代码示例：
f(void) {
struct s { int x:3, y:4; } st;
int *ip = &st.y;
}
消息 ID：E_CANT_TAKE_ADDRESS_BIT_FIELD
已经尝试获取使用寄存器存储类声明的对象地址。无论编译器是否为寄存器真正分配该对象，都不能这样做。尝试获取对象地址可能是隐式的，例如在非关联化数组的时候。如果已为对象分配了寄存器，则诊断信息是错误，否则是警告。
生成该消息的代码示例：
f(void) {
register int i;
register int ia[5];
int *ip = &i;
ia[2] = 1;
}
消息 ID：E_CANT_TAKE_ADDRESS_REGISTER
已经尝试获取无法获取其地址的对象地址。
生成该消息的代码示例：
f(void) {
int *ip = &g();
}
消息 ID：E_BAD_OPERAND_FOR_UNARY_AND
*（解除指针引用）的操作数必须具有指针类型。另外，如果出现对非数组的数组引用时，则会出现该诊断信息。
生成该消息的代码示例：
f(void) {
int i;
*i = 4;
i[4] = 5;
}
消息 ID：E_CANT_DEREF_NON_POINTER_TYPE
if、for、while 或 do-while 的表达式必须具有整数、浮点或指针类型。
生成该消息的代码示例：
f(void) {
struct s {int x;} st;
while (st) {}
}
消息 ID：E_CNTRL_EXP_MUST_BE_SCALAR_TYPE
无法对构成赋值运算中要更改的对象的操作数应用强制转换。如果操作数类型的大小与正在发生强制转换的类型大小相同，则诊断信息是警告，否则是错误。
生成该消息的代码示例：
f(void) {
int i;
(long) i = 5;
(short) i = 4;
}
消息 ID：E_CAST_DOESNT_YIELD_LVALUE
运算符的操作数必须是可修改的左值，但它不是。
生成该消息的代码示例：
f(void) {
int i = --3;
}
消息 ID：E_OPERAND_NOT_MODIFIABLE_LVALUE
运算符的左操作数不是可修改的左值；它必须是一个可修改的左值。
生成该消息的代码示例：
f(void) {
int i = 1;
+i -= 1;
}
消息 ID：E_L_OPERAND_NOT_MODIFIABLE_LVAL
不能将 void 表达式强制转换成 void 之外的类型。
生成该消息的代码示例：
f(void) {
void v(void);
int i = (int) v();
}
消息 ID：E_BAD_CAST_OF_VOID_EXP
使用 -v 选项显示该警告。程序正在向范围内原型声明的函数传递枚举常量或对象。传递的参数与函数原型中的一个参数具有不同的枚举类型，这表明存在编程错误。
生成该消息的代码示例：
enum e1 { ec11 } ev1;
enum e2 { ec21 } ev2;
void ef(enum e1);
void v(void){
ef(ec21);
}
消息 ID：E_ENUM_TYPE_MISMATCH_ARG
运算符的一个操作数是枚举对象或常量，另一个操作数是来自不同枚举类型的枚举对象或常量。
生成该消息的代码示例：
enum e1 { ec11, ec12 } ev1;
enum e2 { ec21, ec22 } ev2;
void v(void){
if (ev1 > ec22)
;
}
消息 ID：E_ENUM_TYPE_MISMATCH_OP
return 语句包含一个表达式，但是该函数的声明类型是 void。
生成该消息的代码示例：
void v(void){
return 3;
}
消息 ID：E_VOID_CANT_RETURN_VALUE
编译器内部使用 malloc() 失败。这通常是由于交换空间不足造成的。
消息 ID：E_CANT_MALLOC_ND1_TREE
已经对大小未知的操作数应用运算符 ++、-- 或 =。通常，该操作数是指向尚未声明成员的结构或联合的指针。
生成该消息的代码示例：
f(void) {
struct s *sp;
sp++;
}
消息 ID：E_UNKNOWN_OPERAND_SIZE
使用 -v 选项显示该警告。已经使用关系运算符比较两个不同枚举类型的枚举常量。这表明存在编程错误。编译时的比较作用是既知的，因为常量值是既知的。
生成该消息的代码示例：
enum e1 { ec11, ec12 } ev1;
enum e2 { ec21, ec22 } ev2;
void v(void){
if (ec11 > ec22)
;
}
消息 ID：E_ENUM_CONSTS_HAVE_DIFF_TYPES
已经对指向不同类型的指针应用运算符。
生成该消息的代码示例：
f(void) {
char *cp;
int *ip;
if (ip < cp)
;
}
消息 ID：E_OPERANDS_INCOMPAT_PTR_TYPES
运算符的一个操作数是指针，而另一个是整数；这种组合是无效的。
生成该消息的代码示例：
f(void){
int i = "abc";
int j = i ? 4 : "def";
}
消息 ID：E_BAD_PTR_INT_COMBINATION
在范围内有函数原型声明的函数调用期间，代码传递的是应该为指针的整数，反之亦然。
生成该消息的代码示例：
int f(char *);
g(void){
f(5);
}
消息 ID：E_BAD_PTR_INT_COMB_ARG
long long int 和无符号的 long long int 不是标准的 C 类型，所以在使用 -Xc 选项时不可用。
消息 ID：E_LONG_LONG_NOT_ALLOWED_XC
已经在声明中使用类型说明符的错误组合。
生成该消息的代码示例：
short float f;
消息 ID：E_INVALID_TYPE_COMBINATION
使用 -v 选项显示该警告。根据 ANSI C 标准，编写存储类说明符不是第一个说明符的声明已过时。
生成该消息的代码示例：
int static i;
消息 ID：E_TYP_STORAGE_CLASS_OBSOLESCENT
已经在声明中指定多个存储类。
生成该消息的代码示例：
f(void) {
register auto i;
}
消息 ID：E_ONLY_ONE_STORAGE_CLASS_ALLOWD
任何函数之外的声明都具有存储类 auto 或 register。
生成该消息的代码示例：
auto int i;
f(void) {
}
消息 ID：E_AUTO_REG_INAPPROPRIATE_HERE
可以在函数原型声明中指定存储类说明符，但只允许指定 register。
生成该消息的代码示例：
int f( register int x, auto int y );
消息 ID：E_ONLY_REG_VALID_FORMAL_PARAM
在 ANSI C 中，使用类型限定符修改 typedef。
生成该消息的代码示例：
typedef int INT; unsigned INT i
消息 ID：E_MODIFY_TYPEDEF_IGNORED
类型说明符包括 typedef 和显式类型限定符。声明限定符时，该 typedef 已经包括该限定符。
生成该消息的代码示例：
typedef volatile int VOL; volatile VOL v;
消息 ID：E_TYPE_DEF_ALREADY_QUALIFIED
函数原型声明使用名称引用联合、结构或枚举 typedef。因为已经在函数中声明结构、联合或枚举，所以定义正在声明其原型的函数时，它不能位于此范围中。为此，原型声明和函数定义不符。
生成该消息的代码示例：
f(void) {
struct s {int x;};
typedef struct s ST;
extern int g(ST, struct s);
}
消息 ID：E_DUBIOUS_REF_TYPEDEF
已经将对象或函数声明为 long 浮点类型，即双精度的同义词。ANSI C 不允许使用 long 浮点型，即使 C 编译器将其作为暂时的辅助工具。
生成该消息的代码示例：
long float f = 1.0;
消息 ID：E_USE_DOUBLE_INSTEAD_LONG_FLOAT
只能在声明中的 * 之后指定 const 或 volatile 类型的限定符。
生成该消息的代码示例：
int * const p; int * unsigned q;
消息 ID：E_ONLY_QUALS_ALLOWED_AFTER_STAR
数组声明中的大小为零或负数。
生成该消息的代码示例：
int ia[-5]; int ib[0];
消息 ID：E_ZERO_OR_NEGATIVE_SUBSCRIPT
数组声明具有维数组合，所以对于目标计算机，声明的对象太大。
生成该消息的代码示例：
int bigarray[2000000000];
消息 ID：E_ARRAY_DIMENSION_TOO_BIG
已经多次将名称用作函数定义中的参数名称。
生成该消息的代码示例：
int f(int i, int i) { }
int g(i,j)
int i;
int i;
{ }
消息 ID：E_PARAM_REDECLARED
使用 -Xt 选项时，已经在参数标识符中使用 "$"。使用 -Xa 或 -Xc 选项时，会产生语法错误。
生成该消息的代码示例：
int f(int i$j ){ };
消息 ID：E_DOLLAR_USED_IN_PARAMETER
使用 -Xt 选项时，已经在标识符中使用 "$"。使用 -Xa 或 -Xc 选项时，会产生语法错误。
生成该消息的代码示例：
int a$b;
消息 ID：E_DOLLAR_USED_IN_IDENTIFIER
使用 -Xc 和 -v 选项显示该警告。在 K&R C 中，可以使用数量可变的参数和非固定参数来定义函数。ANSI C 至少需要一个固定参数。
生成该消息的代码示例：
f(...){}
消息 ID：E_ANSI_REQS_FRML_PARM_BFORE_DOT
只有函数原型声明中的第一个参数才能具有 void 类型，所以它必须是唯一的参数。
生成该消息的代码示例：
int f(int,void);
消息 ID：E_VOID_MUST_BE_SOLE_PARAMETER
在禁止使用的情况下，数组的维数为空。如果违例维数是最远的，则诊断信息是警告，否则是错误。
生成该消息的代码示例：
int ia[4][];
struct s { int x, y[]; };
int i = sizeof(int []);
消息 ID：E_NULL_DIMENSION
已经尝试声明函数数组或 void 数组。
生成该消息的代码示例：
int f[5]();
消息 ID：E_CANT_DECL_ARY_OF_FUNC_VOID
已经声明返回类型为函数或数组的函数，而不是指向该函数或数组的指针（可能）。
生成该消息的代码示例：
int f(void)[]; /* 返回整数数组的函数 */
消息 ID：E_FUNC_CANT_RTN_FUNC_ARY
使用 -fd 选项显示该警告。已经找到旧式函数定义。
生成该消息的代码示例：
int f(a)
char a;
{ }
消息 ID：E_OLD_STYLE_FUNC_DEF
使用 -fd 选项显示该警告。已经找到旧式函数声明。
生成该消息的代码示例：
int f();
消息 ID：E_OLD_STYLE_FUNC_DECL
函数原型声明不能包含标识符列表；它必须声明类型。标识符列表被忽略。
生成该消息的代码示例：
int f(i);
消息 ID：E_FUNC_PROTO_REQ_TYPES
在代表其自身时，无法限定 void（使用 const 或 volatile）。
生成该消息的代码示例：
int f(const void);
消息 ID：E_BAD_QUALIFIERS_WITH_VOID
已经在具有 void 类型的函数原型声明中声明参数名称。
生成该消息的代码示例：
int f(void v);
消息 ID：E_VOID_PARAM_CANT_HAVE_NAME
变量出现在旧式函数定义的参数声明中，但不出现在该参数标识符列表中。
生成该消息的代码示例：
f(a,b)
int i;
{}
消息 ID：E_PARAM_NOT_IN_IDENTIFIER_LIST
具有使用旧式 C 定义的 asm 函数。
生成该消息的代码示例：
int f(a)
int a;
{
asm(" nop ");
}
消息 ID：E_ASM_CANT_HAVE_OLD_STYLE_PARMS
函数原型定义中没有参数名称。
生成该消息的代码示例：
int f(int){
}
消息 ID：E_FORMAL_PARAM_LACKS_NAME
已经为函数提供函数原型声明，但使用了旧式定义。该定义中的参数名称类型与原型声明中使用的类型不兼容。下面的示例说明了该诊断信息的实例。
int f(char);
int f(c)
char c;
{ }
f 具有旧式定义。鉴于兼容性原因，f 参数必须根据缺省参数改进规则进行改进。因此，必须传递给 f 的值实际上是 int，即便函数只能使用该值的 char 部分。此后，诊断信息可以标识该函数应该具有的 int 类型与函数原型导致传递的 char 类型之间的冲突。有两种解决冲突的方法：
int f(char);
int f(char c)
{}
生成该消息的代码示例：
int f(char *);
int f(p)
int *p;
{}
消息 ID：E_PROTOTYPE_MISMATCH_PROMOTE
已经为函数提供函数原型声明，但使用了旧式定义。该定义中的参数名称类型与原型声明中使用的类型不兼容。或者，已经指定的参数数量不正确。请检查原型声明和函数定义。
生成该消息的代码示例：
int f(char*, int, char*); /* 原型声明 */
int f(a, b, c) /* 函数 f 的定义 */
char* a;
{
int b;
}
f 具有旧式定义。鉴于兼容性原因，f 参数必须根据缺省参数改进规则进行改进。因此，必须传递给 f 的值实际上是 int，即便函数只能使用该值的 char 部分。此后，诊断信息可以标识该函数应该具有的 int 类型与函数原型导致传递的 char 类型之间的冲突。有两种解决冲突的方法：消息 ID：E_PROTOTYPE_MISMATCH
函数的函数原型声明和旧式定义在参数数量上不相同。声明具有 n 个参数，而定义具有 m 个参数。
生成该消息的代码示例：
int f(int);
int f(i,j)
int i,j;
{}
消息 ID：E_PARAM_MISMATCH_DECL_DEFINED
已经声明标识符指定了错误类型信息。尚未定义该类型或已经将无法表示类型的标识符用作类型。
生成该消息的代码示例：
what id1; int id2; id2 id3;
消息 ID：E_UNDEFINED_OR_NOT_A_TYPE
函数定义的声明符部分必须包含圆括号。不能通过编写函数类型的 typedef 名称、以及后面的标识符和定义函数的花括号来定义函数。
生成该消息的代码示例：
typedef int F();
F f{ }
消息 ID：E_PARENLESS_FUNC_DEF
已经使用该类型的旧式声明或类型不正确的赋值。
生成该消息的代码示例：
const int i = 10;
struct foo {int x; int y; };
foo = &i; /* foo 的类型错误 */
int f(); /* 旧式声明 */
消息 ID：E_OLD_STYLE_DECL_OR_BAD_TYPE
旧式函数参数 name 不能具有初始化程序。
生成该消息的代码示例：
int f(i)
int i = 4; {}
消息 ID：E_CANT_INITIALIZE_PARAM
代码在文件范围中包含如同空声明语句的空语句。K&R C 允许使用空声明，但 ANSI C 不允许使用空声明。
生成该消息的代码示例：
int i;;
消息 ID：E_EMPTY_DECLARATION
使用 -Xc 选项显示该警告。已经在块范围中使用存储类 static 声明函数。ANSI C 标准说明，如果在块范围内使用 extern 之外的显式存储类声明函数，则将取消定义这种行为。虽然在 K&R C 中可以这样声明函数，但是不能在其他实现中这样做，否则它们可能将不同的含义附加到这个声明上。
生成该消息的代码示例：
void
f(void) {
static void g(void);
}
消息 ID：E_STATIC_FUNC_AT_BLOCK_LEVEL
关键字 "asm" 在函数定义之外使用。
生成该消息的代码示例：
asm(" nop ");
asm(int f());
int f() {
asm(" ...");
}
消息 ID：E_ASM_VALID_ONLY_FOR_FUNC_DEF
函数定义不能具有 typedef 存储类。它将在此处被忽略。
生成该消息的代码示例：
typedef int f(void){}
消息 ID：E_TYPEDEF_VALID_ONLY_FUNC_DEF
用于函数声明或定义的存储类说明符不正确。只能使用 extern 和 static，或者可以省略存储类。该说明符被忽略。
生成该消息的代码示例：
f(void) {
auto g(void);
}
消息 ID：E_SC_FUNC_MUST_STATIC_OR_EXTERN
在函数中，使用 extern 存储类的对象声明不能具有初始化程序。
生成该消息的代码示例：
f(void) {
extern int i = 1;
}
消息 ID：E_CANT_INIT_EXTERN_DECL
通过 dbx 的修复和继续功能调用选项时，会显示该警告。无法将 static 变量重新初始化为启动程序时的值。在嵌套的块中声明变量时，将会生成该警告。如果遇到 #pragma weak var1 = var2 的 var2，也会发出该警告。另外，如果遇到重新声明为 static 的外部变量，也会发出该警告。
生成该消息的代码示例（在嵌套的块内声明变量）：
void main(int argc, char *argv[])
{
static int g ;
{
static int k ; /* 不能重试初始化 */
.........
}
}
消息 ID：E_CANT_FIXCONTINUE_REINITIALIZE
typedef 不能具有初始化程序。
生成该消息的代码示例：
typedef int INT = 1;
消息 ID：E_CANT_INIT_TYPEDEF
声明为函数的名称不能具有初始化程序。
生成该消息的代码示例：
int f(void) = 3;
消息 ID：E_CANT_INIT_FUNCTION
使用 -v 选项显示该警告。不能修改 const 对象。如果没有提供初始值，则该对象的值为零；对于自动变量，其值是不确定的。
生成该消息的代码示例：
const int i;
消息 ID：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。因此，两个声明的类型不兼容。
消息 ID：E_IDENTIFIER_REDECLARED
已经多次定义标识符。也就是说，已经多次使用初始化程序声明对象，或者已经多次定义了函数。
生成该消息的代码示例：
int i = 1; int i = 1;
消息 ID：E_IDENTIFIER_REDEFINED
已经使用与该函数的一个参数相同的名称声明了标识符。在该块中，指向标识符的引用是新声明。在 -Xa 或 -Xc 模式下，诊断信息是错误；在其他所有模式下，诊断信息是警告。
生成该消息的代码示例：
int f(int i,int INT){
int i;
typedef int INT;
}
消息 ID：E_DECLARATION_HIDES_PARAMETER
已经在文件范围中两次声明 name。第一个标识符使用了存储类 static，但第二个标识符未指定存储类。存储类的 ANSI C 规则要求，在第一个标识符之后的所有 name 的重新声明必须指定 static。
生成该消息的代码示例：
static int i; int i;
消息 ID：E_ID_REDECL_ANSI_REQS_STATIC
使用 -Xc 或 -v 选项显示该警告。已经在块中将 name 声明为范围之外的 extern，然后将该 name 声明为 static。ANSI C 编译器将对象或函数视为 static。另外，包含源文件中的早期对象或函数在内的所有引用都应用于 static 版本。
生成该消息的代码示例：
f(void) {
extern int i;
}
static int i;
消息 ID：E_OUT_SCOPE_EXTERN_REDECL_STAT
使用 -Xc 或 -v 选项显示该警告。已经在文件范围内将 name 声明为 extern，然后将相同对象或函数声明为 static。ANSI C 规则要求，对象或函数的第一个声明必须提供其实际的存储类。K&R C 接受该声明，并将该对象或函数的第一个声明视为 static。
生成该消息的代码示例：
extern int i; static int i;
消息 ID：E_EXTERN_PRIOR_REDECL_STATIC
ANSI C 要求，在文件范围内，函数或对象的第一个声明必须建立其存储类。根据这些规则，已经使用了不一致的方式重新声明了函数 name。
生成该消息的代码示例：
g(void){
int f(void);
static int f(void);
}
消息 ID：E_INCONSISTENT_STOR_CLASS_FUNC
将 name 用作相同块中的外部对象或函数的名称之后，已经将其重新用作静态对象或函数的名称。可见的 name 版本是 static 版本。
生成该消息的代码示例：
f(void) {
extern int i;
static int i;
}
消息 ID：E_STATIC_REDECLARES_EXTERN
已经在相同块中声明了自动变量 name，其名称与是 extern 的其他符号相同。ANSI C 禁止这样声明，但 K&R C 的早期版本允许这样声明。由于与早期版本相兼容，所以将自动引用该块中的 name。
生成该消息的代码示例：
f(void) {
extern int i;
int i;
}
消息 ID：E_AUTO_REDECLARES_EXTERNAL
已经声明 typedef name，但相同块中的 extern 名称相同。typedef 隐藏了 external。
生成该消息的代码示例：
f(void) {
extern int INT;
typedef int INT;
}
消息 ID：E_TYPEDEF_REDCLS_EXTERN
已经多次声明 typedef name。后面的声明与第一个声明的类型相同。
生成警告的代码示例：
typedef int i; typedef int i;
消息 ID：E_TYPEDEF_REDECLARED
已经使用存储类 extern 重新声明函数或对象 name。对于该存储类，存在超出范围的早期声明。第二个声明和第一个声明的类型冲突。
生成该消息的代码示例：
f(void) {
int *p = (int *) malloc(5*sizeof(int));
}
g(void){
void *malloc();
}
消息 ID：E_INCONSISTENT_REDECL_EXTERN
已经重新声明以前使用存储类 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; /* 与第一个声明有关 */
}
}
消息 ID：E_INCONSISTENT_REDECL_STATIC
使用 -v 选项显示该警告。已经在内部范围中重新声明了函数 name。外部声明是函数原型声明，但内部声明缺少参数信息。根据 ANSI C 作用域规则，会隐藏参数信息，并禁止原型提供的自动转换类型。
生成该消息的代码示例：
extern double sin(double);
f(void) {
extern double sin();
double d;
d = sin(1); /* 注意：不能转换成双精度！ */
}
消息 ID：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;
}
消息 ID：E_BASE_TYPE_IS_REALLY
使用 -Xt 选项显示该警告。已经在内部范围中重新声明了 struct、union 或 enum 标记。在 K&R C 的早期版本中，使用该标记引用标记的早期声明。在 ANSI C 中，声明引入了新标记。选择 -Xt 选项后，编译器会重新产生早期的行为。
生成该消息的代码示例：
struct s1 { int x; };
f(void) {
struct s1;
struct s2 { struct s1 *ps1; }; /* s1 引用了第 1 行 */
struct s1 { struct s2 *ps2; };
}
消息 ID：E_DECL_INTRODUCES_NEW_TYPE_ANSI
ANSI C 要求每项声明实际进行声明的内容如下：
o 声明符
o 结构或联合标记
o 枚举常量
声明未向编译器提供任何信息。
生成该消息的代码示例：
int; /* 无标识符 */
enum e { e1, e2 }; /* 引入枚举 e */
enum e; /* 无新信息 */
消息 ID：E_USELESS_DECLARATION
使用 -v、-Xa 或 -Xc 选项显示该警告。已经找到含有空枚举的声明；在该代码的后面部分必须跟该枚举的定义。
生成该消息的代码示例：
enum test *ptr;
消息 ID：E_FWD_DECLARING_ENUM
使用存储类 typedef 进行声明时，实际上没有声明类型名称。这表明可能存在编程错误。
生成该消息的代码示例：
typedef struct s { int x; };
消息 ID：E_TYPEDEF_DECLARES_NO_TYPE_NAME
已经重新声明了以前为类型标记的名称标记。
生成该消息的代码示例：
struct q { int m1, m2; };
enum q { e1, e2 };
消息 ID：E_TAG_REDECLARED
函数原型声明为标记引用了 struct、union 或 enum 类型。已经在函数内声明了该标记。因此，定义正在声明原型的函数时，它不能在范围内。为此，原型声明和函数定义不符。
生成该消息的代码示例：
f(void) {
struct s {int x;};
int g(struct s *);
}
消息 ID：E_DUBIOUS_TAG_IN_FUNC_PROTO
已经在函数原型声明或旧式函数定义的参数声明列表中为标记声明了新的 struct、union 或 enum 类型，该声明包括类型的声明符列表。调用该函数时，总会产生类型不匹配的问题，因为根据 ANSI C 作用域规则，在函数原型声明或定义的结尾处，标记声明超出了作用域范围。不能在函数之外声明该类型的对象。而是，在函数原型或函数定义之前声明 struct、union 或 enum，然后通过其标记对其进行引用。 代码如下：
struct s {int x;};
int f(struct s st)
{}
应该采用下列方式编写：
int f(struct s {int x;} st)
{}
消息 ID：E_DUBIOUS_DECL_USE_TAG_ONLY
已经在函数原型范围中声明了 struct、union 或 enum 类型。也就是说，已经在函数原型声明或旧式函数定义的参数声明列表中声明了 struct、union 或 enum 类型，该声明包括了类型的声明符列表。调用该函数时，总会产生类型不匹配的问题，因为根据标准的 C 作用域规则，在函数原型声明或定义的结尾处，标记声明超出了作用域的范围。无法在函数原型之外声明该类型的对象。而是，在函数原型或函数定义之前声明 struct、union 或 enum，然后通过其标记对其进行引用。
生成该消息的代码示例：
int f(struct {int x; int y; }; )
struct s foo;
{ }
============
/* 正确代码 */
struct s {int x; int y; };
int f(struct s foo)
{ }
消息 ID：E_DUB_DECL_USE_TAG_ONLY_UNNAMED
已经在函数原型声明或旧式函数定义的参数声明列表中为标记声明了新的 struct、union 或 enum 类型。调用该函数时，总会产生类型不匹配的问题，因为根据 ANSI C 作用域规则，在函数声明或定义的结尾处，标记声明超出了作用域范围。不能在函数之外声明该类型的对象。
生成该消息的代码示例：
int f(struct s *);
消息 ID：E_DUBIOUS_TAG_DECLARATION
已经在函数原型声明或旧式函数定义的参数声明列表中声明了新的 struct、union 或 enum 类型。调用该函数时，总会产生类型不匹配的问题，因为根据标准的 C 作用域规则，在函数声明或定义的结尾处，标记声明超出了作用域范围。不能在函数之外声明该类型的对象。
消息 ID：E_DUBIOUS_TAG_DECL_UNNAMED
在联合声明中，成员没有名称。
生成该消息的代码示例：
union s { int i; char c; };
消息 ID：E_UNNAMED_UNION_MEMBER
在结构声明中，成员没有名称。
生成该消息的代码示例：
struct s { int i; char c; };
消息 ID：E_UNNAMED_STRUCT_MEMBER
使用 -Xc 选项显示该警告。已经使用带符号 int 或无符号 int 之外的位字段类型，这些类型是唯一的可移植位字段类型。ANSI C 支持 int、char、short 和 long 位字段类型，这些类型可能是带符号、无符号或“普通”类型。它还支持枚举位字段类型。
生成该消息的代码示例：
1 struct u {
2 unsigned v:1;
3 int w:1;
4 char x:8;
5 long y:8;
6 short z:8;
7 };
=============
(3) 警告：不可移植的位字段类型
(4) 警告：不可移植的位字段类型
(5) 警告：不可移植的位字段类型
(6) 警告：不可移植的位字段类型
消息 ID：E_NONPORTABLE_BIT_FIELD_TYPE
位字段的声明指定的位数要比适合于声明类型的对象位数多。
生成该消息的代码示例：
struct s { char c:20; };
消息 ID：E_BIT_FIELD_TOO_BIG
对于位字段，不允许使用已经为位字段选择的类型。只能使用整型声明位字段。
生成该消息的代码示例：
struct s { float f:3; };
消息 ID：E_INVALID_TYPE_FOR_BIT_FIELD
函数不能是结构或联合的成员，即便指向函数的指针可能是其成员，也是如此。已经将成员名称声明为函数。
生成该消息的代码示例：
struct s { int f(void); };
消息 ID：E_MEMBER_CANT_BE_FUNCTION
struct 或 union 声明为多个成员使用了相同的名称。
生成该消息的代码示例：
union u {
int i;
float i;
};
消息 ID：E_DUPLICATE_MEMBER_NAME
已经使用零大小声明结构或联合。
生成该消息的代码示例：
struct s { int ia[0]; };
消息 ID：E_ZERO_SIZED_STRUCT_UNION
已经声明其中未命名任何成员的结构或联合。
生成该消息的代码示例：
struct s { int :4; char :0; };
消息 ID：E_STRUCT_UNION_HAS_NO_NAMD_MBRS
缺少 ";"，C 语法要求在结构或联合声明中的最后一个结构或联合成员之后使用该符号。
生成该消息的代码示例：
struct s { int x };
消息 ID：E_SEMI_COLON_REQD_AFT_LAST_MBR
标识符已经在相同范围中声明了多次。
生成该消息的代码示例：
f(int i){
int j, i;
}
消息 ID：E_ID_REDECLARED
函数中的枚举类型声明包括名称与参数名称相同的枚举常量。该枚举常量隐藏了参数。
生成该消息的代码示例：
int
f(int i){
enum e { l, k, j, i };
}
消息 ID：E_ENUM_CONST_HIDES_PARAMETER
枚举常量值溢出最大的整数值。
生成该消息的代码示例：
enum e { e1=2147483647, e2 }; /* 对于 e2 溢出 */
消息 ID：E_ENUM_VAL_OVERFLOWS_INT_MAX
在枚举类型声明中设置枚举器名称的值时，已经在表达式中使用了该名称。此时，无论在作用域中使用了什么符号，ANSI C 作用域规则都将在表达式中使用该名称。
生成该消息的代码示例：
int i;
f(void) {
enum e { i = i+1, j, k }; /* 在 i+1 中使用全局 i */
}
消息 ID：E_ENUM_USED_OWN_INITIALIZER
使用 -Xc 或 -v 选项生成该警告。在枚举类型声明的结尾处提供了一个多余的逗号。在语法中禁止使用多余的逗号。
生成该消息的代码示例：
enum e { e1, e2, };
消息 ID：E_TRAILING_COMMA_IN_ENUM
在初始化聚合时，必须用 { } 将初始化程序括起来，但使用字符串型初始化字符数组或使用表达式初始化自动结构时除外。
生成该消息的代码示例：
int ia[5] = 1;
f(void) {
struct s { int x,y; } st = 1;
}
消息 ID：E_INIT_REQUIRED
在 ANSI C 中，可以初始化自动结构或联合，但初始化程序的类型必须与正在初始化的对象类型相同。
生成该消息的代码示例：
f(void) {
int i;
struct s { int x; } st = i;
}
消息 ID：E_STRUCT_UNION_INIT_REQUIRED
值不适合在此指定的空间范围内。如果初始化重新从该空间中获取值，则它不能重新生成与输入的值相同的值。在该消息中，如果初始化程序是无符号类型，则该值表示为十六进制值，如果是带符号类型，则表示为十进制值。0x80 到 0xff 之间的十六进制值不适合 char; 0x8000 到 0xffff 之间的值，char; 0x8000 到 0xffff 之间的值不适合 short; 0x80000000 到 0xffffffff 之间的值，short; 0x80000000 到 0xffffffff 之间的值不适合 int 类型。但是，这些值可以与相应的无符号类型一起使用。
生成该消息的代码示例：
struct s {signed int m1:3; unsigned int m2:3;} st = {4, 5};
unsigned char uc = 300u;
消息 ID：E_INIT_DOES_NOT_FIT
在相同的初始化过程中，不能同时使用字符串型和其他值初始化字符数组。
生成该消息的代码示例：
char ca[] = { "abc", 'd' };
消息 ID：E_STR_LIT_ARRAY_INIT
初始化字符数组的字符串型包含 n 个字符，超过了数组所能容纳的字符数。
生成该消息的代码示例：
char ca[3] = "abcd";
消息 ID：E_EXTRA_BYTE_IN_STR_IGNORED
extern、static 或 array 对象的初始化程序必须是编译时常量。如果用 {} 将初始化程序括起来，则自动结构或联合对象的初始化程序还必须是编译时常量。诊断信息中的运算符是编译时无法组合其操作数的运算符。
生成该消息的代码示例：
int j; int k = j+1;
消息 ID：E_NON_CONST_INIT
已经为结构或联合提供太多的初始化程序。
生成该消息的代码示例：
struct s { int x,y; } st = { 1,2,3 };
消息 ID：E_TOO_MANY_STRUCT_UNION_INIT
代码包含的初始化程序要比数组所能容纳的初始化程序多。
生成该消息的代码示例：
int ia[3] = { 1, 2, 3, 4 };
消息 ID：E_TOO_MANY_ARRAY_INIT
对于标量，用 { } 括起来的初始化包含多个值。
生成该消息的代码示例：
int i = { 1, 2 };
消息 ID：E_TOO_MANY_INIT_SCALAR
如果对初始化对象时所用的值进行转换，使其适合该对象，则该值是使用符号扩展的。
生成该消息的代码示例：
unsigned int x = -3;
消息 ID：E_INIT_SIGN_EXTEND
-xO3 选项或更高的优化级别必须与 -crossfiles 标记一起使用。
消息 ID：E_XO3_NOT_SPECIFIED
没有右 ' 的字符常量与左 ' 位于同一行。
生成该消息的代码示例：
int i = 'a ;
消息 ID：E_NEWLINE_IN_CHAR_CONST
如果使用 -Xa 或 -Xc 选项时出错，将会显示该消息。编译器在源程序中遇到一个是无效 ANSI C 标记的字符。
生成该消息的代码示例：
int i = 1$;
消息 ID：E_INVALID_SOURCE_CHARACTER
编译器在源程序中遇到一个是无效 ANSI C 标记的字符。无法输出无效字符。诊断信息中的十六进制值是字符代码的十六进制值。
消息 ID：E_INVALID_UNPRINTABLE_SRC_CHR
指定的字符集不能组成有效的 C 语言标记。标记是 C 语言中最小的词法元素。标记分为下面几个类别：关键字、标识符、常量、字符串型、运算符和标点符号。
生成该消息的代码示例：
5d int 1e = 1; /* 标记不应该以数字开头 */
消息 ID：E_INVALID_TOKEN_LEX
指定的字符集不能组成有效的 C 语言标记。标记是 C 语言中最小的词法元素。标记分为下面几个类别：关键字、标识符、常量、字符串型、运算符和标点符号。
生成该消息的代码示例：
char 2whateveritistoolongmorethan255character...; /*long 字符串*/
消息 ID：E_INVALID_TOKEN_TOO_LONG_LEX
对于普通字符串型和宽字符的字符串型，只有这两种类型都是普通字符或宽字符时，才能将其并置。如果宽字符串型之后跟普通字符串型（且两种类型都是宽字符串类型），编译器将会发出警告；如果普通字符串型之后跟宽字符串型，则会发出错误。
生成该消息的代码示例：
#include <stddef.h> wchar_t wa[] = L"abc" "def"; char a[] = "abc" L"def";
消息 ID：E_CANT_CONCAT_WIDE_REG_STRINGS
使用 -Xa 或 -Xt 选项时，_Restrict 是 C 语言的关键字。
生成该消息的代码示例：
void func(int * _Restrict intptr);
消息 ID：E_KEYWORD_FOR_XA_AND_XT
在前缀为 L 的字符常量或字符串型中，十六进制或八进制转义符序列生成的值太大，不适合于无符号的字符。字符转义符太大，无法适合于 type wchar_t 的对象，所以只有将其截断后，才能适合。
消息 ID：E_CHR_ESC_DOES_NOT_FIT_WCHAR
表达式的值太大。转换后的值太大，无法适合于双精度类型。如果表达式位于可执行代码中，则诊断信息是警告，否则是错误。
生成该消息的代码示例：
double f() {
return 0xFFFFFFFFFFFFFFFF;
}
消息 ID：E_CONV_TO_DOUBLE_OUT_OF_RANGE
表达式的值太大，无法适合于浮点型。如果表达式位于可执行代码中，则诊断信息是警告，否则是错误。
生成该消息的代码示例：
float f = 1e300 * 1e300;
消息 ID：E_CONV_TO_FLOAT_OUT_OF_RANGE
双精度常量的值太大，无法适合于整型。如果表达式位于可执行代码中，则诊断信息是警告，否则是错误。
生成该消息的代码示例：
int i = 1e100;
消息 ID：E_CONV_DOUBLE_INTEGRAL_OUT_RNGE
编译器已经确定，移位运算符的移位计数（右操作数）为负值，或者大于正在移位的操作数的大小。
生成该消息的代码示例：
f() {
short s;
s <<= 25;
}
消息 ID：E_SHIFT_CNT_NEG_TOO_BIG_L
编译器已经确定，移位运算符的移位计数（右操作数）为负值，或者大于正在移位的操作数的大小。
生成该消息的代码示例：
f() {
short s;
s <<= 25;
}
消息 ID：E_SHIFT_CNT_NEG_TOO_BIG
编译器尝试在编译时计算运算符表达式的结果，并确定该结果是否出现溢出。低位 32 位结果将被保留，而编译器将发出此诊断信息。
生成该消息的代码示例：
int i = 1000000 * 1000000;
消息 ID：E_INTEGER_OVERFLOW_DETECTED
编译器尝试在两个浮点操作数之间运算时，在编译时检测到了溢出。如果表达式位于可执行代码中，则诊断信息是警告，否则是错误。
生成该消息的代码示例：
double d1 = 1e300 * 1e300;
消息 ID：E_FP_CONST_CALC_OUT_OF_RANGE
序列控制流不能通过之前的语句访问 for 或 while 循环开头的控制表达式。
生成该消息的代码示例：
f(void) {
int i;
goto lab;
for (i = 1; i > 0; --i) {
lab:;
i=5;
}
}
消息 ID：E_LOOP_NOT_ENTERED_AT_TOP
无法执行到程序中的该语句，因为 goto、break、continue 或 return 语句位于该语句之前。
生成该消息的代码示例：
f(void) {
int i;
return i;
i = 4;
}
消息 ID：E_STATEMENT_NOT_REACHED
使用 -v 选项显示该警告。函数应该包括 return 语句。
生成该消息的代码示例：
#include <stdio.h>
main(void)
{
(void) printf("Do the hippy-hippy shake.\n");
}
消息 ID：E_FUNC_HAS_NO_RETURN_STMT
相同的标签名称已经在当前的函数中多次出现。标签的范围是整个函数。
生成该消息的代码示例：
f(void) {
int i;
i = 1;
if (i) {
L:
while (i)
g();
goto L;
}
L: ;
}
消息 ID：E_LABEL_REDEFINED
已经编写这种循环：循环结尾处的代码不仅执行不到，而且无法执行。其中，该代码是由编译器为分支语句生成的，用于返回到循环的开头。
生成该消息的代码示例：
f(void) {
int i = 1;
while (i) {
return 4;
}
}
消息 ID：E_END_OF_LOOP_CODE_NOT_REACHED
函数包含的 break 语句位置不当，即位于任意 loop 或 switch 语句之外。
生成该消息的代码示例：
f(void){
break;
}
消息 ID：E_BREAK_OUTSIDE_LOOP_OR_SWITCH
程序包含的 continue 语句位于所有循环语句的范围之外。
生成该消息的代码示例：
f(void) {
continue;
}
消息 ID：E_CONTINUE_OUTSIDE_LOOP_SWITCH
使用 -v 选项显示该警告。当前的函数是使用类型声明的，但是已经使用一个不包含返回值表达式的 return 语句。
生成该消息的代码示例：
f(void) {
return;
}
消息 ID：E_FUNC_EXPECTS_TO_RETURN_VALUE
代码包含一个控制表达式不具有整型的 switch 语句。如果无效类型是浮点类型，则该消息是警告；否则是错误。浮点 switch 表达式被转换为 int。
生成该消息的代码示例：
f(void) {
float x;
switch (x) {
case 4: ;
}
}
消息 ID：E_SWITCH_EXP_MUST_BE_INTEGRAL
case 语句出现在任意 switch 语句的范围之外。
生成该消息的代码示例：
f(void) {
case 4: ;
}
消息 ID：E_CASE_OUTSIDE_SWITCH
case 语句的操作数必须是整型常量。
生成该消息的代码示例：
f(void) {
int i = 1;
switch(i) {
case 5.0: ;
}
}
消息 ID：E_NON_INTEGRAL_CASE_EXPRESSION
default 标签出现在 switch 语句的范围之外。
生成该消息的代码示例：
f(void) {
default: ; }
消息 ID：E_DEFAULT_OUTSIDE_SWITCH
当前的 switch 语句中有两个 default 标签。
生成该消息的代码示例：
f(void) {
int i = 5;
switch(i) {
default:
default:
break;
}
}
消息 ID：E_DUPLICATE_DEFAULT_IN_SWITCH
在 case 语句中已经指定的表达式值位于封闭的 switch 语句的控制表达式类型范围之外。因此，可能从未执行到 case 标签。在该消息中，如果 case 表达式是无符号类型，则 value 表示为十六进制的值，如果该表达式是带符号类型，则表示为十进制的值。
生成该消息的代码示例：
f(void) {
unsigned char uc;
switch( uc ){
case 256:
;
}
}
消息 ID：E_UNREACHABLE_CASE_LABEL
使用 -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:
;
}
}
消息 ID：E_CASE_LBL_AFFECTED_CONVERSION
不能声明类型为 void 的对象。
生成该消息的代码示例：
void v;
消息 ID：E_CANT_HAVE_VOID_OBJECT
已经使用 struct、union 或 enum 类型和标记声明对象名称，但该类型是不完整的。
生成该消息的代码示例：
struct s st;
消息 ID：E_INCOMPLETE_STRUCT_UNION_ENUM
该编译器所使用的内存不足。这通常是由于交换空间不足造成的。
消息 ID：E_ST_SAVE_OUT_OF_MEMORY
该编译器所使用的内存不足。这通常是由于交换空间不足造成的。
消息 ID：E_ST_LOOKUP_OUT_OF_MEMORY
程序调用了函数 name（已经声明为 static），但翻译单元中未出现该 name 的任何定义。消息中显示的行号比文件中的行号大一号，因为只有显示整个翻译单元之后，才能诊断该条件。
生成该消息的代码示例：
static int statfunc(int);
void
f() {
int i = statfunc(4);
}
消息 ID：E_STATIC_FUNC_CALLD_NOT_DEFINED
代码在当前函数中包含 goto 语句，但未在该函数中定义目标 label。
生成该消息的代码示例：
f(void) {
goto L;
}
消息 ID：E_UNDEFINED_LABEL
使用 -v 选项显示该警告。因为 #pragma 指令是特定于实现的，所以设置 -v 编译标记时，C 编译器会提示所有忽略的指令。C 编译器无法识别诊断信息中显示的 #pragma。
生成该消息的代码示例：
#pragma list
消息 ID：E_UNRECOGNIZED_PRAGMA_IGNORED
使用 -v 选项显示该警告。编译器遇到不包含其他标记的 #pragma 指令。
生成该消息的代码示例：
#pragma
消息 ID：E_NO_TOKENS_FOLLOW_PRAGMA
该编译器所使用的内存不足。这通常是由于交换空间不足造成的。
消息 ID：E_DO_PRAGMA_OUT_OF_MEMORY
编译器已经遇到没有所示格式的 #pragma pack。该错误指令被忽略。
生成该消息的代码示例：
#pragma pack
消息 ID：E_IGNORE_MALFORMED_PRAGMA_PACK
pack pragma 可以控制结构偏移的布局，所以必须采用下列格式：
#pragma pack(n)其中，n 是二的幂，它小于平台上最严格的对齐（对于 Intel，是 4；对于 sparc v8，是 8；对于 sparc v9，是 16）。如果 n 被省略，则成员对齐恢复为普遍的对齐边界。pragma 可以为任何结构成员指定所需的最严格对齐。该 pragma 还可以应用于其后的所有结构定义，直至下一个 pack 指令出现为止。如果使用不同的包装在不同的翻译单元中定义相同的结构，则程序可能会意外失败。尤其是，不应该在包括定义预编译库界面的标题之前使用 pragma pack。建议的用法是，使程序代码中的 pragma 直接位于要使用紧跟在结构之后的 #pragma pack() 包装的任意结构之前。
生成该消息的代码示例：
#pragma pack (-2) #pragma pack (7) #pragma pack (256)
消息 ID：E_BAD_PRAGMA_PACK_VALUE
编译器已经遇到没有所示格式的 #pragma weak 指令。该错误指令被忽略。
生成该消息的代码示例：
#pragma weak write,_write
消息 ID：E_IGNORE_MALFORMED_PRAGMA_WEAK
编译器已经在尚未声明的 #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)
消息 ID：E_UNKNOWN_CTRL_FLOW_UNDECLARED
编译器已经在尚未声明的 #pragma no_side_effect 中遇到函数名称。unknown_control_flow pragma 的语法如下：
#pragma no_side_effect (name [, name ...])ID 列表中命名的所有函数必须在 pragma 之前声明。
生成该消息的代码示例：
/* ABS 函数并未在任何位置定义或声明 */ #pragma no_side_effect (abc)============ 代码应该是：
int abc(); #pragma no_side_effect (abc)
消息 ID：E_NO_SIDE_EFFECT_UNDECLARED
已经使用错误的语法指定 #pragma unknown_control_flow。pragma 的正确语法如下：
#pragma unknown_control_flow ( id [,id ...] )
生成该消息的代码示例：
#pragma unknown_control_flow {a, b c}
消息 ID：E_IGNORE_MALFORMED_PRAGMA_UCF
已经使用错误的语法指定 #pragma unknown_control_flow。pragma 的正确语法如下：
#pragma no_side_effect (id [, id ...])
生成该消息的代码示例：
#pragma no_side_effect {a b}
消息 ID：E_IGNORE_MALFORMED_PRAGMA_NSE
#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}
消息 ID：E_IGNORE_MALFORMED_PRAGMA
作为 #pragma int_to_unsigned 指令的一部分，名称必须是其类型是 function-returning-unsigned 的标识符。
生成该消息的代码示例：
extern int f(int); #pragma int_to_unsigned fl
消息 ID：E_MUST_B_TYPE_FUNC_RTN_UNSIGNED
编译器已经遇到没有所示格式的 #pragma int_to_unsigned 指令。该错误指令被忽略。
生成该消息的代码示例：
#pragma int_to_unsigned strlen();
消息 ID：E_IGNORE_MALFORMED_INTTOUNSIGND
#pragma align 使用的语法不正确。正确的语法如下：
#pragma align integer (ident [,ident ...])其中 integer 是介于 1 至 128 的 2 的幂，有效的值为：1、2、4、8、16、32、64 和 128。ident 必须是全局或静态变量；它不能是自动变量。
生成该消息的代码示例：
#pragma align 128 {astruct, aunion}
消息 ID：E_IGNORE_MALFORMED_PRAGMA_ALIGN
该编译器所使用的内存不足。这通常是由于交换空间不足造成的。
消息 ID：E_REALLOC_OUT_OF_MEMORY
#line < number > 指令之后必须跟普通的字符串型。
消息 ID：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;
}
消息 ID：E_PRECISION_LOST_IN_BIT_FIELD
enum 声明不正确。格式：简单。
生成该消息的代码示例：
1 enum e {int, two} en;
============
(1) 警告：从未定义枚举：e
消息 ID：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) 警告：等号运算符 "==" 出现在需要赋值运算符 "=" 的位置
消息 ID：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) 警告：赋值运算符 "=" 出现在需要 "==" 的位置
消息 ID：E_EQUALITY_NOT_ASSIGNMENT
仅使用一个参数或两个以上的参数定义程序中的函数 main()，所以不符合 ANSI C 要求。格式：简单。
生成该消息的代码示例：
1 void
2 main(int argc, char **argv, char **envp)
3 {}
============
(2) 警告：只允许 0 个参数或 2 个参数：main()
消息 ID：E_MAIN_PARAM
已经使用不返回 int 的 main()，所以违反了 ANSI C 限制条件。格式：简单。
生成该消息的代码示例：
1 char *
2 main(void)
3 {
4 return "a";
5 }
============
(2) 警告：函数必须是 int 类型：main()
消息 ID：E_MAIN_RET_VAL
无法移植程序中的多字符字符常量。格式：简单。
生成该消息的代码示例：
1 int c = 'abc'; ============ (1) 警告：不可移植的字符常量
消息 ID：E_NONPORTABLE_CHAR_CONST
函数返回指向自动变量的指针。由于不能再保证在块结束之后保留带有自动存储持续时间的对象，因此在块结束之后未定义指向该对象的指针。
生成该消息的代码示例：
1 int *
2 f(int x)
3 {
4 int ia[10];
5 int i;
6 if (x == 1)
7 return ia;
8 else
9 return &i;
10 }
============
(7) 警告：函数返回指向自动变量的指针
(9) 警告：函数返回指向自动变量的指针
消息 ID：E_FUNC_RET_PTR_TO_AUTO
函数返回指向参数的指针。由于不能再保证在块结束之后保留带有自动存储持续时间的对象，因此在块结束之后未定义指向该对象的指针。
生成该消息的代码示例：
1 int *f(int i)
2 {
3 return &i;
4 }
============
(3) 警告：函数返回指向参数的指针
消息 ID：E_FUNC_RET_PTR_TO_PARAM
如果没有 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 语句失败
消息 ID：E_CASE_FALLTHRU
lint 指令 /* EMPTY */ 必须出现在 #if 或 #else 的范围内。
生成该消息的代码示例：
int f(void) {
/* EMPTY */
};
消息 ID：E_IF_ELSE_DIRECTIVE
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
消息 ID：E_NOP_IF_STMT
if 语句包含一个空的 else 部分。在 else 语句和分号之间插入 /* EMPTY */ 时，如果遇到该语句，会禁止该消息；使用 -h 调用 lint 时，如果遇到每个语句，会禁止该消息。格式：简单。
生成该消息的代码示例：
1 void
2 v(int i)
3 {
4 if (i)
5 return;
6 else;
7 }
============
(6) 警告：语句无结果：else
消息 ID：E_NOP_ELSE_STMT
虽然变量或函数已经在文件中定义或声明为 static，但没有在该文件中使用。之所以会这样，可能是由编程问题造成的，因为对象不能在文件之外使用。
生成该消息的代码示例：
1 static int i; 2 static int f(void); 3 static int j = 1; ============ 未使用 static (1) i (2) f (3) j
消息 ID：E_STATIC_UNUSED1
虽然变量或函数已经在文件中定义或声明为 static，但没有在该文件中使用。之所以会这样，可能是由编程问题造成的，因为对象不能在文件之外使用。
生成该消息的代码示例：
1 static int i; 2 static int f(void); 3 static int j = 1;
消息 ID：E_STATIC_UNUSED
未使用函数参数。函数定义以 /* ARGSUSEDn */ 开头时，如果遇到所有参数（前 n 个参数除外），会禁止该消息；使用 -v 调用 lint 时，如果遇到每个参数，会禁止该消息。
生成该消息的代码示例：
1 static int f(int, int);
2 int
3 main(int argc, char *argv[])
4 {
5 return (f(argc, 0));
6 }
7 /* ARGSUSED1 */
8
9 int
10 f(int x, int y)
11 {
12 return x;
13 }
14
============
未在函数中使用参数
(3) argv in main
消息 ID：E_FUNC_ARG_UNUSED1
未使用函数参数。函数定义以 /* ARGSUSEDn */ 开头时，如果遇到所有参数（前 n 个参数除外），会禁止该消息；使用 -v 调用 lint 时，如果遇到每个参数，会禁止该消息。
生成该消息的代码示例：
1 static int f(int, int);
2 int
3 main(int argc, char *argv[])
4 {
5 return (f(argc, 0));
6 }
7 /* ARGSUSED1 */
8
9 int
10 f(int x, int y)
11 {
12 return x;
13 }
14
消息 ID：E_FUNC_ARG_UNUSED
已声明变量，但从未在函数中使用。
生成该消息的代码示例：
1 void main(void)
2 {
3 int i, j;
4 static k;
5 }
6
7
============
未在函数中使用变量
(3) i in main
(3) j in main
(4) k in main
消息 ID：E_FUNC_VAR_UNUSED1
已声明变量，但从未在函数中使用。
生成该消息的代码示例：
1 void main(void)
2 {
3 int i, j;
4 static k;
5 }
6
7
消息 ID：E_FUNC_VAR_UNUSED
已声明和设置自动变量或函数参数，但未在函数中使用。
生成该消息的代码示例：
1 void f(int i)
2 {
3 int j = 1;
4 i = 1;
5 }
============
已设置但未在函数中使用
(1) i in f
(3) j in f
消息 ID：E_FUNC_SET_NOT_USED1
已声明和设置自动变量或函数参数，但未在函数中使用。
生成该消息的代码示例：
1 void f(int i)
2 {
3 int j = 1;
4 i = 1;
5 }
消息 ID：E_FUNC_SET_NOT_USED
已经将指向一个对象类型的指针强制转换成指向其他对象类型的指针。只有使用 -p 调用 lint 时，才会发出该消息。如果遇到普通指针 void *，不会发出该消息。
生成该消息的代码示例：
1 void
2 main(void)
3 {
4 int *ip;
5 char *cp = 0;
6 ip = (int *) cp;
7 }
============
指针强制转换可能有问题
(6)
消息 ID：E_BAD_PTR_CAST
函数包含一个执行不到的语句。无法执行到的语句以 /* NOTREACHED */ 开头时，如果遇到该语句，会禁止该消息；使用 -b 调用 lint 时，如果遇到无法执行到的 break 语句和空语句，会禁止该消息。编译器可以发出但不能禁止该消息。
生成该消息的代码示例：
1 void
2 v(int i)
3 {
4 switch (i) {
5 case 1:
6 return;
7 break;
8 case 2:
9 return;
10 /* NOTREACHED */
11 break;
12 }
13 }
============
无法执行到语句
(7)
消息 ID：E_STMT_NOT_REACHED
该程序调用以前未声明的函数。在这种情况下，lint 会假设该函数返回 int。
生成该消息的代码示例：
1 void
2 v(void)
3 {
4 f();
5 }
============
隐式声明为返回 int
(4) f
消息 ID：E_RET_INT_IMPLICITLY1
该程序调用以前未声明的函数。在这种情况下，lint 会假设该函数返回 int。
生成该消息的代码示例：
1 void
2 v(void)
3 {
4 f();
5 }
消息 ID：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)
消息 ID：E_BAD_PTR_CAST_ALIGN
根据 ANSI C 的定义，按位运算符的操作数是带符号的整型变量。因为这些运算符返回的值与整数的内部表示法有关，所以其行为是针对该类型的操作数执行定义的。
消息 ID：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)
消息 ID：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)
消息 ID：E_BAD_SIGN_EXTEND
对象已赋值给其中一个较小的类型。使用 -a 调用 lint 时，会禁止该消息。显式强制转换为较小的类型时，也会禁止该消息。
生成该消息的代码示例：
1 void
2 main(void)
3 {
4 float f;
5 long long l = 2.5;
6 f = l;
7 }
============
赋值引起隐式缩小转换
(6)
消息 ID：E_ASSIGN_NARROW_CONV
非 void 函数没有向调用函数返回值。如果确实未能到达右花括号，则在该括号前插入 /* NOTREACHED */ 时，会禁止该消息。
生成该消息的代码示例：
1 int f(void) {}
2 void v(void) {}
3 h(void)
4 {
5 exit(1);
6 /* NOTREACHED */
7 }
============
函数未返回值即转向底部
(1) f
消息 ID：E_FUNC_NO_RET_VAL1
非 void 函数没有向调用函数返回值。如果确实未能到达右花括号，则在该括号前插入 /* NOTREACHED */ 时，会禁止该消息。
生成该消息的代码示例：
1 int f(void) {}
2 void v(void) {}
3 h(void)
4 {
5 exit(1);
6 /* NOTREACHED */
7 }
消息 ID：E_FUNC_NO_RET_VAL
已声明外部变量或函数，但未在内部块中使用。
生成该消息的代码示例：
1 int
2 main(void)
3 {
4 int f();
5 int g();
6 return f();
7 }
============
未在块中使用声明
(5) g
消息 ID：E_BLOCK_DECL_UNUSED1
已声明外部变量或函数，但未在内部块中使用。
生成该消息的代码示例：
1 int
2 main(void)
3 {
4 int f();
5 int g();
6 return f();
7 }
消息 ID：E_BLOCK_DECL_UNUSED
已声明非静态外部变量或函数，但未在任何文件中定义。使用 -u 调用 lint 时，会禁止该消息。
生成该消息的代码示例：
1 extern int f(void);
2 int
3 main(void)
4 {
5 return f();
6 }
============
名称已使用但未定义
f f.c(5)
消息 ID：E_NAME_USED_NOT_DEF1
已声明非静态外部变量或函数，但未在任何文件中定义。使用 -u 调用 lint 时，会禁止该消息。
生成该消息的代码示例：
1 extern int f(void);
2 int
3 main(void)
4 {
5 return f();
6 }
消息 ID：E_NAME_USED_NOT_DEF2
已定义变量或函数，但未在任何文件中使用。使用 -u 调用 lint 时，会禁止该消息。
生成该消息的代码示例：
1 int i;
============
名称已定义但从未使用
i f.c(1)
消息 ID：E_NAME_DEF_NOT_USED1
已定义变量或函数，但未在任何文件中使用。使用 -u 调用 lint 时，会禁止该消息。
生成该消息的代码示例：
1 int i;
消息 ID：E_NAME_DEF_NOT_USED2
已声明非静态外部变量或函数，但未在任何文件中使用或定义。使用 -x 调用 lint 时，会禁止该消息。
生成该消息的代码示例：
1 extern int f(void);
2 static int g(void);
============
名称已声明但从未使用或定义
f f.c(1)
消息 ID：E_NAME_DECL_NOT_USED_DEF1
已声明非静态外部变量或函数，但未在任何文件中使用或定义。使用 -x 调用 lint 时，会禁止该消息。
生成该消息的代码示例：
1 extern int f(void); 2 static int g(void);
消息 ID：E_NAME_DECL_NOT_USED_DEF2
已在多个源文件中定义了变量。
生成该消息的代码示例：
file f.c:
1 char i = 'a';
file f_1.c:
1 long i = 1;
============
名称多次定义
i f.c(1) :: f_1.c(1)
消息 ID：E_NAME_MULTIPLY_DEF1
已在多个源文件中定义了变量。
生成该消息的代码示例：
file f.c: 1 char i = 'a'; file f_1.c: 1 long i = 1;
消息 ID：E_NAME_MULTIPLY_DEF2
调用函数时所用的返回类型与定义函数所用的返回类型不匹配。
生成该消息的代码示例：
file f.c:
1 int *
2 f(int *ip)
3 {
4 return ip;
5 }
file f_1.c:
1 void
2 g(void)
3 {
4 int i, *ip = &i;
5 i = f(ip);
6 }
============
使用的值类型不一致
f f.c(2) int *() :: f_1.c(5) int ()
消息 ID：E_INCONS_VAL_TYPE_USED1
调用函数时所用的返回类型与定义函数所用的返回类型不匹配。
生成该消息的代码示例：
file f.c:
1 int *
2 f(int *ip)
3 {
4 return ip;
5 }
file f_1.c:
1 void
2 g(void)
3 {
4 int i, *ip = &i;
5 i = f(ip);
6 }
消息 ID：E_INCONS_VAL_TYPE_USED2
函数声明或定义中的返回类型与其他声明或定义中的返回类型不匹配。遇到不一致的变量类型声明时，也会发出该消息。
生成该消息的代码示例：
file f.c:
1 void v(void) {}
2 void g(void);
3 extern int i;
file f_1.c:
1 extern int f(void);
2 extern int g(void);
3 extern char i;
============
声明的值类型不一致
g f.c(2) void () :: f_1.c(2) int ()
i f.c(3) int :: f_1.c(3) char
消息 ID：E_INCONS_VAL_TYPE_DECL1
函数声明或定义中的返回类型与其他声明或定义中的返回类型不匹配。遇到不一致的变量类型声明时，也会发出该消息。
生成该消息的代码示例：
file f.c:
1 void v(void) {}
2 void g(void);
3 extern int i;
file f_1.c:
1 extern int f(void);
2 extern int g(void);
3 extern char i;
消息 ID：E_INCONS_VAL_TYPE_DECL2
调用函数时使用的参数类型与函数定义中的形式参数类型不匹配。
生成该消息的代码示例：
file f.c:
1 int
2 f(int *x, int *y)
3 {
4 return *x + *y;
5 }
file f1.c:
1 int
2 main(void)
3 {
4 int i = 0;
5 extern int f(int, int);
6 return f(1, i);
7 }
============
使用的函数参数（数量）不一致
f (arg 2) f.c(3) int * :: f1.c(6) int
消息 ID：E_INCONS_ARG_USED1
对于函数调用，实际参数和伪参数的类型不匹配。格式：简单。
生成该消息的代码示例：
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), 位于 f.c(5) int 和 f.c(12) double 中
消息 ID：E_INCONS_ARG_USED2
调用函数时使用的参数数量不正确。函数定义以 /* VARARGSn */ 开头时，如果遇到使用 n 或多个参数的调用，会禁止该消息；使用 ANSI C 表示法 "..." 定义和声明函数时，如果遇到每个参数，会禁止该消息。
生成该消息的代码示例：
1 int f(int x, int y, int z)
2 {
3 return x + y + z;
4 }
5 int g(int x, ...)
6 {
7 return x;
8 }
9 /* VARARGS1 */
10 int h(int x, int y, int z)
11 {
12 return x + y + z;
13 }
14 void main(void)
15 {
16 extern int f(), h(), g(int i, ...);
17 f();
18 g(1, 2, 3, 4);
19 h(1, 2, 3, 4, 5);
20 }
============
使用不同数量的参数调用了函数
f f.c(1) :: f.c(17)
消息 ID：E_FUNC_USED_VAR_ARG1
调用函数时使用的参数数量不正确。函数定义以 /* VARARGSn */ 开头时，如果遇到使用 n 或多个参数的调用，会禁止该消息；使用 ANSI C 表示法 "..." 定义和声明函数时，如果遇到每个参数，会禁止该消息。
生成该消息的代码示例：
1 int f(int x, int y, int z)
2 {
3 return x + y + z;
4 }
5 int g(int x, ...)
6 {
7 return x;
8 }
9 /* VARARGS1 */
10 int h(int x, int y, int z)
11 {
12 return x + y + z;
13 }
14 void main(void)
15 {
16 extern int f(), h(), g(int i, ...);
17 f();
18 g(1, 2, 3, 4);
19 h(1, 2, 3, 4, 5);
20 }
消息 ID：E_FUNC_USED_VAR_ARG2
非 void 函数不包含 return 语句，但可以用于表达式中的值。
生成该消息的代码示例：
file f.c:
1 extern int fun();
2 main()
3 {
4 return fun();
5 }
file f2.c:
1 int fun()
2 {}
============
已使用函数值，但没有返回值
fun
消息 ID：E_FUNC_VAL_USED_NONE_RET1
非 void 函数不包含 return 语句，但可以用于表达式中的值。
生成该消息的代码示例：
file f.c:
1 extern int fun();
2 main()
3 {
4 return fun();
5 }
file f2.c:
1 int fun()
2 {}
消息 ID：E_FUNC_VAL_USED_NONE_RET2
函数包含 return 语句，所以每次调用该函数时，会忽略其返回值。
生成该消息的代码示例：
1 int f(void)
2 {
3 return 1;
4 }
5 extern int f(void);
6 int main(void)
7 {
8 f();
9 return 1;
10 }
============
函数返回的值总是被忽略
f
消息 ID：E_FUNC_RET_ALWAYS_IGNOR1
函数包含 return 语句，所以每次调用该函数时，会忽略其返回值。
生成该消息的代码示例：
1 int f(void)
2 {
3 return 1;
4 }
5 extern int f(void);
6 int main(void)
7 {
8 f();
9 return 1;
10 }
消息 ID：E_FUNC_RET_ALWAYS_IGNOR2
函数包含 return 语句，所以对该函数执行（并非全部）调用时，会忽略其返回值。
生成该消息的代码示例：
1 int f(void)
2 {
3 return 1;
4 }
5 extern int f(void);
6 int main(void)
7 {
8 if(f()) {
9 return f();
10 }
11 else {
12 f();
13 return 1;
14 }
15 }
============
函数返回的值有时被忽略
f
消息 ID：E_FUNC_RET_MAYBE_IGNORED1
函数包含 return 语句，所以对该函数执行（并非全部）调用时，会忽略其返回值。
生成该消息的代码示例：
1 int f(void)
2 {
3 return 1;
4 }
5 extern int f(void);
6 int main(void)
7 {
8 if(f()) {
9 return f();
10 }
11 else {
12 f();
13 return 1;
14 }
15 }
消息 ID：E_FUNC_RET_MAYBE_IGNORED2
函数原型声明或定义中的参数类型与其他声明或定义中的类型不同。
生成该消息的代码示例：
file f.c:
1 int f(int);
2 int g(int);
file f_1.c:
1 int f(int *ip);
2 int g(int *ip) {return *ip;}
3
============
声明的函数参数（数量）不一致
g (arg 1) f_1.c(2) int * :: f.c(2) int
f (arg 1) f.c(1) int :: f_1.c(1) int *
消息 ID：E_INCONS_ARG_DECL1
函数原型声明或定义中的参数数量与其他声明或定义中的参数数量不同。如果所有声明具有相同的参数数量，使用 ANSI C 表示法 "..." 声明和定义原型时，会禁止该警告。
生成该消息的代码示例：
file f.c:
1 int
2 f(int x, int y)
3 {
4 return (x + y);
5 }
6 int
7 g(void)
8 {
9 int i, j = 0, k = 0;
10 i = f(j, k);
11 return (i);
12 }
file f_1.c:
1 int f(int);
2 int g(int);
============
使用不同的参数数量声明函数
f f.c(2) :: f_1.c(1)
g f.c(7) :: f_1.c(2)
消息 ID：E_FUNC_DECL_VAR_ARG1
函数原型声明或定义中的参数数量与其他声明或定义中的参数数量不同。如果所有声明具有相同的参数数量，使用 ANSI C 表示法 "..." 声明和定义原型时，会禁止该警告。
生成该消息的代码示例：
file f.c:
1 int
2 f(int x, int y)
3 {
4 return (x + y);
5 }
6 int
7 g(void)
8 {
9 int i, j = 0, k = 0;
10 i = f(j, k);
11 return (i);
12 }
file f_1.c:
1 int f(int);
2 int g(int);
消息 ID：E_FUNC_DECL_VAR_ARG2
由于长度或条件方面的执行定义限制，将程序中的外部名称移植到其他计算机上时，该名称可能无法识别。根据 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
消息 ID：E_INDISTING_FROM_TRUNC1
由于长度或条件方面的执行定义限制，将程序中的外部名称移植到其他计算机上时，该名称可能无法识别。根据 ANSI C 的下界要求，在 -Xc 环境下，使用一个 case 语句将外部名称截断为前 6 个字符；在 -p 环境下，使用一个 case 语句将其截断为前 8 个字符。
生成该消息的代码示例：
1 int foobar1; 2 int FooBar12; 3 int foobar2; 4 int FOOBAR12;
消息 ID：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)
消息 ID：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 }
消息 ID：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)
消息 ID：E_BAD_FORMAT_STR1
[fs]printf() 或 [fs]scanf() 控制字符串的格式不正确。
生成该消息的代码示例：
1 #include <stdio.h>
2 void
3 main(void)
4 {
5 (void) printf("%y");
6 }
消息 ID：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)
消息 ID：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 }
消息 ID：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)
消息 ID：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
消息 ID：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)
消息 ID：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 }
消息 ID：E_GLOBAL_COULD_BE_STATIC2
名称说明所用的修改符数超过了上限 16。格式：简单。
生成该消息的代码示例：
1 int ************************ip = 0; ============ (1) 警告：类型的修饰符 > 16，但只能使用 16 个
消息 ID：E_MODIFIER_OVERFLOW
如果将指令 /* 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) 选中的数量
消息 ID：E_DIRECTIVE_TOO_MANY_ARG
如果将指令 /* 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) 检查的数量
消息 ID：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
消息 ID：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) 警告：常量在条件上下文中
消息 ID：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
消息 ID：E_UNDEF_EVAL_ORDER
逻辑 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：运算符 "&"
(7) 警告：逻辑表达式总是为 false：运算符 "&"
(8) 警告：逻辑表达式总是为 false：运算符 "&"
消息 ID：E_FALSE_LOGICAL_EXPR
逻辑 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：运算符 "||"
(5) 警告：逻辑表达式始终为 true：运算符 "||"
(6) 警告：逻辑表达式始终为 true：运算符 "||"
消息 ID：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) 警告：字符与负常量的比较可疑：运算符 "=="
(6) 警告：字符与 0 的比较可疑：运算符 "<"
生成该消息的代码示例：
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) 警告：无符号与负常量的比较可疑：运算符 ">"
(6) 警告：无符号与 0 的比较可疑：运算符 "<"
(7) 警告：无符号与 0 的比较可疑：运算符 "<="
(8) 警告：无符号与 0 的比较可疑：运算符 ">="
(9) 警告：无符号与 0 的比较可疑：运算符 ">"
(10) 警告：无符号与负常量的比较可疑：运算符 "<"
(11) 警告：无符号与负常量的比较可疑：运算符 "=="
消息 ID：E_SUSPICIOUS_COMPARISON
NOT 运算符的操作数是常量。如果语句以 /* CONSTCOND */ 开头，如果遇到该语句，会禁止该消息；如果使用 -h 调用 lint，如果遇到每个语句，会禁止该消息。格式：简单。
生成该消息的代码示例：
1 void main(void)
2 {
3 if (! 0) return;
4 /* CONSTCOND */
5 if (! 0) return;
6 }
============
(3) 警告：运算符的操作数为常量："!"
消息 ID：E_CONST_EXPR
已经将负常量赋值给无符号整型。无符号整型的值只能为正值或零。
生成该消息的代码示例：
unsigned char uc = -1; unsigned int b = -13;
消息 ID：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) 警告：常量被赋值截断
消息 ID：E_CONST_TRUNCATED_BY_ASSIGN
已将指针赋值给小于该指针的整型对象。格式：简单。
生成该消息的代码示例：
1 void
2 v(void)
3 {
4 int *ip;
5 char c;
6 c = ip;
7 }
============
(6) 警告：指针转换丢失位
消息 ID：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
消息 ID：E_NEG_ARRAY_SUBSCRIPT
数组元素的下标值超过了数组的上界。格式：简单。
生成该消息的代码示例：
1 int
2 f(void)
3 {
4 int ia[10];
5 int *ip = ia;
6 while (ip != &ia[10]) /* 可以使用地址 */
7 ip++;
8 return ia[5 + 6];
9 }
============
(8) 警告：数组下标不能 > 9：11
消息 ID：E_OVERFLOW_ARRAY_SUBSCRIPT
尚未给混合使用逻辑和按位运算符的表达式加圆括号。使用 -h 调用 lint 时，会禁止该消息。格式：简单。
生成该消息的代码示例：
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) 警告：优先级可能不明确；请加圆括号
消息 ID：E_PRECEDENCE_CONFUSION
在 HP-UX 上，printf 和 scanf 例程系列不支持输出或读取 long long 类型变量。
消息 ID：E_HPUX_BAD_FORMAT_STR1
在 HP-UX 上，printf 和 scanf 例程系列不支持输出或读取 long long 类型变量。
消息 ID：E_HPUX_BAD_FORMAT_STR2
已经定义变量或函数，但从未在源文件的任何位置对其进行访问。
生成该消息的代码示例：
int f();
int main() {
int a = 10;
printf("never call function f() " );
return 0;
}
int f() {
return (1+1);
}
消息 ID：E_NAME_DEF_NOT_USED
已经声明变量或函数，但从未在源文件的任何位置对其进行访问。
生成该消息的代码示例：
int f();
int main() {
int a;
printf("never call to function f() or use a");
return 0;
}
消息 ID：E_NAME_DECL_NOT_USED_DEF
已经在不同位置多次声明变量。请注意，当前范围内其他变量定义并未隐藏要引用的变量。
生成该消息的代码示例：
int x = 10; /* 全局变量：x */
int main() {
int x = 1; /* x 的其他声明 */
return f(x);
}
int f(int y) {
int x = 5; /* 声明局部 x */
return (y + g(x)); /* 在当前范围内使用 x */
}
int g(int z) {
return (x*z); /* 在此处使用 x */
}
消息 ID：E_NAME_MULTIPLY_DEF
读取表示的文件时出现文件系统错误。这不是来自源程序的错误。
消息 ID：E_F_RD_ERR
读取表示的文件时出现文件系统错误。这不是来自源程序的错误。
消息 ID：E_F_WR_ERR
读取表示的文件时出现文件系统错误。这不是来自源程序的错误。
消息 ID：E_OPEN_F
定义枚举成员的不同值时所用的名称相同。
生成该消息的代码示例：
file f.c:
1 typedef enum {
2 ONE = 1, TWO = 3
3 } e;
file f_1.c:
1 typedef enum {
2 ONE = 1, TWO
3 } e;
============
枚举成员的声明不一致
TWO 3 f.c(2) :: 2 f_1.c(2)
消息 ID：E_ENUM
两个或多个源文件对相同宏名称的定义不同。
生成该消息的代码示例：
file f.c:
1 #define MAX_I 1
file f_1.c:
1 #define MAX_I 2
============
宏的不同定义
MAX_I f.c(1) :: f_1.c(1)
消息 ID：E_MCR_NODIFF
在程序编译期间未使用指定的包含文件。
生成该消息的代码示例：
#include <math.h> /* 未使用数学函数 */
int main() {
return 0;
}
消息 ID：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)
消息 ID：E_ENUM_UNUSE
从未在程序中使用声明的 typedef。
生成该消息的代码示例：
1 typedef long int LONG_INT_t;
2 void
3 main(void)
4 {
5 return;
6 }
============
typedef 已定义但未使用
LONG_INT_t f.c(1)
消息 ID：E_TYPEDEF_UNUSE
相同的 typedef 名称存在不同的定义。
生成该消息的代码示例：
1 typedef long int LONG_INT_t;
2 int
3 f(void)
4 {
5 typedef long long int LONG_INT_t;
6 LONG_INT_t li = 1;
7 return li;
8 }
============
typedef 的声明不一致
LONG_INT_t long long f.c(1) :: long f.c(5)
消息 ID：E_TYPEDEF_INCONSIST
不存在与 .c 文件的名称相同的 .h 文件。格式：简单。
生成该消息的代码示例：
1 void
2 main(void)
3 {
4 int *ip;
5 ip = (int *) sizeof(int);
6 free(ip);
7 ip = (int *) malloc(sizeof(int) * 10);
8 ip++;
9 free(ip);
10 }
============
.c 文件无相应的 .h 文件
/export/ld6/clint/LINT.EXMPLS/f/f.c
消息 ID：E_H_C_CHECK0
.h 文件中已声明 extern 名称，但未在相应的 .c 文件中定义该名称。
生成该消息的代码示例：
file f.h:
1 extern int i;
2 extern int f(int x, int y);
file f.c:
1 #include "f.h"
2 int ia[2];
3 int i;
4 int
5 f(int x, int y)
6 {
7 ia[0] = x;
8 ia[1] = y;
9 if (ia[i] > ia[1])
10 ia[0] = ia[1];
11 return (x + y) / 2;
12 }
============
在 .c 文件中定义了 extern，但未在相应的 .h 文件中声明
ia f.c(2)
消息 ID：E_H_C_CHECK1
.c 文件中已定义了 extern 名称，但相应的 .h 文件中未声明该名称。
生成该消息的代码示例：
file f.h:
1 int i;
2 extern int f(int x, int y);
file f.c:
1 #include "f.h"
2 extern int i;
3 int
4 f(int x, int y)
5 {
6 int ia[2];
7 ia[0] = x;
8 ia[1] = y;
9 if (ia[i] > ia[1])
10 ia[0] = ia[1];
11 return (x + y) / 2;
12 }
13 int
14 main(void)
15 {
16 i = 5;
17 return f(i, -i);
18 }
============
在 .c 文件中定义了 extern，但未在相应的 .h 文件中声明
main f.c(14)
消息 ID：E_H_C_CHECK2
已定义函数，但未在运行时使用，例如，从无法执行到的代码调用函数时。
生成该消息的代码示例： <
file f.c:
1 extern int f(void);
2
3 main(void)
4 {
5 int i = 0;
6 if (i > 0)
7 i = f();
8 return i;
9 }
file f_1.c:
1 int
2 f(void)
3 {
4 return 3;
5 }
============
消息 ID：E_UNCAL_F
程序中包含无法执行到的语句。
生成该消息的代码示例：
int f() {
printf("return before reach\n");
return 0;
assert(FALSE); /* <==== 无法执行到该语句 */
}
消息 ID：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) 警告：参数错误导致内存无法解除分配
消息 ID：E_A_NOMEM
解除分配的是已经解除分配的内存。
生成该消息的代码示例：
1 #include <malloc.h>
2 static int *ip, *jp;
3 void
4 main(void)
5 {
6 ip = malloc(sizeof(int));
7 jp = ip;
8 free(ip);
9 free(jp);
10 }
============
重复内存解除分配
f.c(9) :: f.c(8)
消息 ID：E_P_FREE_DEALLOC
解除分配的是可能已经解除分配的内存。
生成该消息的代码示例：
1 #include <malloc.h>
2 static int *ip, *jp;
3 void
4 main(int argc, char *argv[])
5 {
6 ip = malloc(sizeof(int));
7 *ip = 4;
8 jp = ip;
9 if (argc > 2)
10 free(ip);
11 free(jp);
12 }
============
内存解除分配可能重复
f.c(11) :: f.c(10)
消息 ID：E_P_FREE_DEALLOC_PSBL
引用已解除分配的内存。
生成该消息的代码示例：
1 #include <malloc.h>
2 static int *ip;
3 int
4 main(void)
5 {
6 int i;
7 ip = malloc(10);
8 *ip = 2;
9 free(ip);
10 i = *ip;
11 return (i);
12 }
============
引用已解除分配的内存
f.c(10) :: f.c(9)
消息 ID：E_P_REF_DEALLOC
可能存在指向已解除分配内存的引用。
生成该消息的代码示例：
1 #include <malloc.h>
2 static int *ip;
3 int
4 main(int argc, char *argv[])
5 {
6 int i;
7 ip = malloc(10);
8 *ip = 2;
9 if (argc > 2)
10 free(ip);
11 i = *ip;
12 return (i);
13 }
============
可能引用已解除分配的内存
f.c(13) :: f.c(12)
消息 ID：E_P_REF_DEALLOC_PSBL
使用指向已解除分配内存的指针。
生成该消息的代码示例：
1 #include <malloc.h>
2 static int *ip;
3 void
4 main(void)
5 {
6 int *jp;
7 ip = malloc(10);
8 free(ip);
9 jp = ip;
10 }
============
使用指向已解除分配内存的指针
f.c(9) :: f.c(8)
消息 ID：E_P_USE_DEALLOC
可能使用指向已解除分配内存的指针。
生成该消息的代码示例：
1 #include <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 }
============
消息 ID：E_P_USE_DEALLOC_PSBL
禁止解除分配指向变量的指针。
生成该消息的代码示例：
1 #include <malloc.h>
2 int
3 main(void)
4 {
5 int *ip;
6 int i;
7 ip = &i;
8 free(ip);
9 }
============
解除分配指向变量的指针
i defined at f.c(6) :: f.c(8)
消息 ID：E_P_FREE_VAR
解除分配可能指向变量的指针。
生成该消息的代码示例：
1 #include <malloc.h>
2 static int *ip;
3 int
4 main(int argc, char *argv[])
5 {
6 int i;
7 if (argc > 2)
8 ip = &i;
9 else
10 ip = malloc(sizeof i);
11 *ip = 99;
12 free(ip);
13 return (++*ip);
14 }
============
解除分配可能指向变量的指针
i defined at f.c(6) :: f.c(12)
消息 ID：E_P_FREE_VAR_PSBL
使用指向不再存在的变量指针进行引用。由于不能再保证在块结束之后保留带有自动存储持续时间的对象，因此在块结束之后未定义指向该对象的指针。
生成该消息的代码示例：
1 int *ip;
2 f(void)
3 {
4 int i = 0;
5 ip = &i;
6 return (i);
7 }
8 main(void)
9 {
10 int j;
11 j = f();
12 j += *ip;
13 return (j);
14 }
============
使用指向不再存在的变量的指针进行引用
i defined at f.c(4) :: f.c(12)
消息 ID：E_P_REF_VAR
可能使用指向不再存在的变量的指针进行引用。由于不能再保证在块结束之后保留带有自动存储持续时间的对象，因此在块结束之后未定义指向该对象的指针。
生成该消息的代码示例：
1 int *ip, ei;
2 f(int n)
3 {
4 int i = 0;
5 ip = &ei;
6 if (n > 0)
7 ip = &i;
8 return (i);
9 }
10 main(int argc, char *argv[])
11 {
12 int j;
13 j = f(argc);
14 j += *ip;
15 return (ei + j);
16 }
============
可能使用指向不再存在的变量的指针进行引用
i defined at f.c(4) :: f.c(14)
消息 ID：E_P_REF_VAR_PSBL
使用了指向不再存在的变量的指针。由于不能再保证在块结束之后保留带有自动存储持续时间的对象，因此在块结束之后未定义指向该对象的指针。
生成该消息的代码示例：
1 int *ip, ei;
2 f(void)
3 {
4 int x = 0;
5 ip = &x;
6 return (x);
7 }
8 main(void)
9 {
10 int i;
11 i = f();
12 ip++;
13 return (ei + i);
14 }
============
使用了指向不再存在的变量的指针
x defined at f.c(4) :: f.c(12)
消息 ID：E_P_USE_VAR
使用了可能指向不再存在的变量指针。由于不能再保证在块结束之后保留带有自动存储持续时间的对象，因此在块结束之后未定义指向该对象的指针。
生成该消息的代码示例：
1 int *ip, ei;
2 g(int n)
3 {
4 int x = 0, y = 1;
5 ip = &ei;
6 if (n > 0)
7 ip = &x;
8 return (x);
9 }
10 main(int argc, char * argv[])
11 {
12 int i;
13 i = g(argc);
14 ip++;
15 return (ei + i);
16 }
============
使用了指向可能不再存在的变量的指针
x defined at f.c(4) :: f.c(14)
消息 ID：E_P_USE_VAR_PSBL
函数返回了其自动局部变量的地址或某些指针中存储的参数。由于不能再保证在块结束之后保留带有自动存储持续时间的对象，因此在块结束之后未定义指向该对象的指针。
生成该消息的代码示例：
1 int *
2 f(void)
3 {
4 int i;
5 int *ip = &i;
6 return (ip);
7 }
8 void
9 main(void)
10 {
11 int *jp;
12 jp = f();
13 (*jp)++;
14 }
============
返回了指向局部变量的指针
i defined at f.c(4) :: f.c(6)
消息 ID：E_P_RET_VAR
例程可能返回其自动局部变量的地址。由于不能再保证在块结束之后保留带有自动存储持续时间的对象，因此在块结束之后未定义指向该对象的指针。
生成该消息的代码示例：
1 static int *
2 f(int *ip)
3 {
4 int i;
5 int *jp = ip;
6 if (*ip > 5)
7 jp = &i;
8 return jp;
9 }
10 main(void)
11 {
12 int i = 1;
13 i += *f(&i);
14 return i;
15 }
============
可能返回了指向局部变量的指针
i defined at E_P_RET_VAR_PSBL.c(4) :: E_P_RET_VAR_PSBL.c(8)
消息 ID：E_P_RET_VAR_PSBL
参数为 NULL。
生成该消息的代码示例：
1 #include <malloc.h>
2 #define ADDR 0
3 static int *ip;
4 main(void)
5 {
6 ip = ADDR * sizeof(int);
7 free(ip);
8 return 0;
9 }
============
解除分配 NULL 指针
f.c(7)
消息 ID：E_P_FREE_NULL
解除分配可能为 NULL 的指针。
生成该消息的代码示例：
1 #include <malloc.h>
2 static int *ip;
3 main(int argc, char *argv[])
4 {
5 if (argc == 2)
6 ip = 0;
7 else
8 ip = malloc(sizeof(int));
9 free(ip);
10 return 0;
11 }
============
解除分配可能为 NULL 的指针
f.c(9)
消息 ID：E_P_FREE_NULL_PSBL
使用 NULL 指针进行引用。
生成该消息的代码示例：
1 static int *ip;
2 int
3 main(void)
4 {
5 int i = 0;
6 ip = (int *) 0;
7 i = *ip;
8 i = i + *ip;
9 return (i);
10 }
============
使用 NULL 指针进行引用
f.c(7)
消息 ID：E_P_REF_NULL
可能使用 NULL 指针进行引用。
生成该消息的代码示例：
1 static int *ip;
2 static int si = 99;
3 int
4 main(int argc, char *argv[])
5 {
6 int i = 0;
7 if (argc == 2)
8 ip = (int *) 0;
9 else
10 ip = &si;
11 i = i + *ip;
12 return (i);
13 }
============
可能使用 NULL 指针进行引用
f.c(11)
消息 ID：E_P_REF_NULL_PSBL
可能未正确使用 NULL 指针。
生成该消息的代码示例：
1 int
2 main(int argc, char * argv[])
3 {
4 int *ip, *jp;
5 int i;
6 ip = 0;
7 if (argc > 1)
8 ip = &i;
9 jp = ip;
10 return (*jp)++;
11 }
============
使用可能为 NULL 的指针进行修改
ip defined at f.c(4) :: f.c(10)
消息 ID：E_P_USE_NULL_PSBL
未初始化参数。
生成该消息的代码示例：
1 #include <malloc.h>
2 void
3 main(void)
4 {
5 int *ip;
6 free(ip);
7 }
============
解除分配未初始化的指针
ip defined at f.c(5) :: f.c(6)
消息 ID：E_P_FREE_UNINI
解除分配可能是未初始化值的指针。
生成该消息的代码示例：
1 #include <malloc.h>
2
3 void
4 main(int argc, char *argv[])
5 {
6 int *ip;
7 if (argc == 0)
8 ip = malloc(sizeof(int));
9 free(ip);
10 }
============
解除分配可能是未初始化值的指针
ip defined at f.c(5) :: f.c(8)
消息 ID：E_P_FREE_UNINI_PSBL
使用作为未初始化值的指针进行引用。
生成该消息的代码示例：
1 void
2 main(void)
3 {
4 int i;
5 int *ip;
6
7 i = *ip;
8 }
============
使用是未初始化值的指针进行引用
ip defined at f.c(5) :: f.c(7)
消息 ID：E_P_REF_UNINI
可能使用未初始化的指针进行引用。
生成该消息的代码示例：
1 #include <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)
消息 ID：E_P_REF_UNINI_PSBL
使用了是未初始化值的指针。
生成该消息的代码示例：
1 void
2 main(void)
3 {
4 int *ip;
5
6 ip++;
7 }
============
使用了是未初始化值的指针
ip defined at f.c(4) :: f.c(6)
消息 ID：E_P_USE_UNINI
使用了可能是未初始化值的指针。
生成该消息的代码示例：
1 void
2 main(int argc, char *argv[])
3 {
4 int i;
5 int *ip;
6 if (argc > 1)
7 ip = &i;
8 ip++;
9 }
============
使用了可能是未初始化值的指针
ip defined at f.c(5) :: f.c(8)
消息 ID：E_P_USE_UNINI_PSBL
解除分配采用不可靠方法产生的指针，例如，通过将整数值转换成指针值。
生成该消息的代码示例：
1 void
2 main(void)
3 {
4 int *ip;
5 ip = (int *) sizeof(int);
6 free(ip);
7 }
============
解除分配用不可靠方法产生的指针
f.c(6)
消息 ID：E_P_FREE_SUSP
解除分配可能用不可靠方法产生的指针。
生成该消息的代码示例：
1 #include <malloc.h>
2 void
3 main(int argc, char *argv[])
4 {
5 int *ip;
6 ip = (int *) malloc(sizeof(int) * 10);
7 *ip = argc - 1;
8 if (*ip == 0)
9 ip = (int *) sizeof(int);
10 free(ip);
11 }
============
解除分配可能用不可靠方法产生的指针
f.c(10)
消息 ID：E_P_FREE_SUSP_PSBL
使用不可靠方法产生的指针进行引用。
生成该消息的代码示例：
1 void
2 main(void)
3 {
4 int *ip;
5 int i;
6 ip = (int *) sizeof i;
7 i = *ip;
8 }
============
使用不可靠方法产生的指针进行引用
f.c(7)
消息 ID：E_P_REF_SUSP
可能使用不可靠方法产生的指针进行引用。
生成该消息的代码示例：
1 main(int argc, char *argv[])
2 {
3 int *ip;
4 int i = argc;
5 ip = (int *) sizeof i;
6 if (argc > 2)
7 ip = &i;
8 return *ip;
9 }
============
可能使用不可靠方法产生的指针进行引用
E_P_REF_SUSP_PSBL.c(8)
消息 ID：E_P_REF_SUSP_PSBL
使用了不可靠方法产生的指针。
生成该消息的代码示例：
1 void
2 main(void)
3 {
4 int *ip, *jp;
5 int i = 0;
6 ip = (int *) sizeof i;
7 jp = ip;
8 }
============
使用了不可靠方法产生的指针
f.c(7)
消息 ID：E_P_USE_SUSP
使用了可能以不可靠方法产生的指针。
生成该消息的代码示例：
1 void
2 main(int argc, char *argv[])
3 {
4 int *ip, *jp;
5 int i = 99;
6 ip = (int *) sizeof i;
7 if (argc > 2)
8 ip = &i;
9 jp = ++ip;
10 }
============
使用了可能以不可靠方法产生的指针
f.c(9)
消息 ID：E_P_USE_SUSP_PSBL
尚未在程序中使用变量值。可以删除多余的赋值。
生成该消息的代码示例：
1 static int *ip, i;
2 static void
3 f(void)
4 {
5 int *iq;
6 ip = &i;
7 iq = ip;
8 *ip = 7;
9 }
10 int
11 main(int argc, char *argv[])
12 {
13 int j = 0xff;
14 f();
15 j = 0x01;
16 if (argc > 2)
17 ip = &i;
18 else
19 ip = &j;
20 *ip = 1;
21 ip = ip + 1;
22 *ip = 2;
23 return (0);
24 }
============
从未使用赋值
iq defined at f.c(5) :: 在 f.c(7) 设置
i defined at f.c(1) :: 在 f.c(8) 设置
j defined at f.c(13) :: 在 f.c(13) 设置
j defined at f.c(13) :: 在 f.c(15) 设置
j defined at f.c(13) :: 在 f.c(22) 设置
i defined at f.c(1) :: 在 f.c(22) 设置
从未使用赋值
j defined at f.c(13) :: 在 f.c(20) 设置 :: 在 f.c(22) 重置
i defined at f.c(1) :: 在 f.c(20) 设置 :: 在 f.c(22) 重置
消息 ID：E_ASGN_NEVER_USED
将变量重置为其他值之前，已经给该变量赋予从未使用的值。可以删除多余的赋值。
生成该消息的代码示例：
1 static int i;
2 int main (void)
3 {
4 int iq;
5 iq = 8;
6 i = 7;
7 iq = i;
8 return iq;
9 }
==========
"t2.c", line 5: 警告：从未使用赋值：iq 在 t2.c(4) 定义；在 t2.c(7) 重置
消息 ID：E_ASGN_RESET
常量数据或变量已发生更改。
生成该消息的代码示例：
1 static const int ic = 1;
2 static void
3 f(int *ip)
4 {
5 (*ip)++;
6 }
7 main(void)
8 {
9 int *ip = (int *) ⁣
10 f(ip);
11 return ic;
12 }
============
常量数据已修改
ic defined at f.c(1) :: f.c(5)
消息 ID：E_ASGN_CONST
常量数据或值可能已发生更改。
生成该消息的代码示例：
1 static const int ic = 1;
2 static void
3 f(int *iq)
4 {
5 (*iq)++;
6 }
7 main(int argc , char* argv[])
8 {
9 int *ip = (int *) ⁣
10 int i;
11 if (argc > 2)
12 ip = &i;
13 f(ip);
14 return (*ip);
15 }
============
可能修改了常量数据
ic defined at f.c(1) :: f.c(5)
消息 ID：E_ASGN_CONST_PSB
在程序中未显式释放分配的内存。
生成该消息的代码示例：
1 #include <stdlib.h>
2 main(void)
3 {
4 int *ip;
5 ip = malloc(sizeof(long));
6 *ip += 5;
7 return *ip;
8 }
============
未解除内存分配
f.c(5)
消息 ID：E_NEVER_DEALLOC
在程序中可能未释放分配的内存。
生成该消息的代码示例：
1 #include <malloc.h>
2 void
3 v(int i)
4 {
5 char *cp;
6 cp = (char *) malloc(sizeof(int) * i);
7 *cp = 3;
8 if ( i > 1 )
9 free(cp);
10 }
11 main(int argc, char *argv[])
12 {
13 v(argc);
14 }
============
消息 ID：E_NEVER_DEALLOC_PSB
在设置之前使用了变量或内存。
生成该消息的代码示例：
1 static int i;
2 void
3 main(void)
4 {
5 int j;
6 j += i;
7 }
============
在设置前已使用
j defined at f.c(5)
消息 ID：E_USE_BEFORE_SET
在设置之前可能使用了变量。
生成该消息的代码示例：
1 int
2 main(int argc, char * argv[])
3 {
4 int i;
5 if (argc>2)
6 i = 99;
7 i++;
8 return i;
9 }
============
在设置前可能已使用
i defined at f.c(4)
消息 ID：E_USE_BEFORE_SET_PSB
变量或内存中存储的一个类型值已用作另外一种不一致的类型值。
生成该消息的代码示例：
1 main(void)
2 {
3 int i;
4 int *ip = &i;
5 *((char *) ip) = '1';
6 return (*ip);
7 }
============
值类型的使用不一致
used as int :: 在 f.c(3) 定义 i f.c(6) :: f.c(5) 设置为 char
消息 ID：E_VALUE_TYPE
变量或内存中存储的一个类型值可能已用作另外一种不一致的类型值。
生成该消息的代码示例：
1 main(int argc, char * argv[])
2 {
3 int i;
4 int *ip = &i;
5 *ip = 0;
6 if (argc > 2)
7 *((char *) ip) = '1';
8 return (*ip);
9 }
============
值类型的使用可能不一致
used as int :: 在 f.c(3) 定义 i f.c(8) :: f.c(7) 设置为 char
消息 ID：E_VALUE_TYPE_PSB
Lint 已经确定，程序流决不调用命名的函数。
消息 ID：E_FUNC_UNREACHED
修改了解除分配的内存。
生成该消息的代码示例：
1 #include <malloc.h>
2 static int *ip;
3 static void f(void) { *ip=1;}
4 static void g(int i) { ip = malloc(i);}
5 static void h(void) { free(ip);}
6 void
7 main(void)
8 {
9 ip = malloc(10);
10 free(ip);
11 *ip = 1;
12 g(10);
13 h();
14 f();
15 }
============
修改了解除分配的内存
f.c(3) :: f.c(5)
f.c(11) :: f.c(10)
消息 ID：E_P_WRT_DEALLOC
可能修改了解除分配的内存。
生成该消息的代码示例：
1 #include <malloc.h>
2 static int *ip;
3 int
4 main(int argc, char *argv[])
5 {
6 ip = malloc(8);
7 if (argc > 1)
8 free(ip);
9 *ip = argc;
10 return (*ip);
11 }
============
可能修改了解除分配的内存
f.c(9) :: f.c(8)
消息 ID：E_P_WRT_DEALLOC_PSBL
修改了不再存在的变量。由于不能再保证在块结束之后保留带有自动存储持续时间的对象，因此在块结束之后未定义指向该对象的指针。
生成该消息的代码示例：
1 static int *ip;
2 static int si;
3 static int
4 f(void)
5 {
6 int i;
7 ip = &i;
8 i = 0;
9 return (i);
10 }
11 main(void)
12 {
13 int j;
14 j = f();
15 *ip = 1;
16 j = j + f();
17 *ip = 1;
18 return (si + j);
19 }
============
修改了不再存在的变量
i defined at f.c(6) :: f.c(15)
i defined at f.c(6) :: f.c(17)
消息 ID：E_P_WRT_VAR
由于不能再保证在块结束之后保留带有自动存储持续时间的对象，因此在块结束之后未定义指向该对象的指针。
生成该消息的代码示例：
1 static int *ip;
2 static int si;
3 static int
4 f(void)
5 {
6 int i;
7 ip = &i;
8 i = 0;
9 if (si)
10 ip = &si;
11 return (i);
12 }
13 main(void)
14 {
15 int j;
16 j = f();
17 *ip = 1;
18 j = j + f();
19 *ip = 1;
20 return (si + j);
21 }
============
修改了可能不再存在的变量
i defined at f.c(6) :: f.c(17)
i defined at f.c(6) :: f.c(19)
消息 ID：E_P_WRT_VAR_PSBL
使用 NULL 指针进行了修改。
生成该消息的代码示例：
1 static int *ip;
2 static void
3 v(void)
4 {
5 *ip = 1;
6 }
7 void
8 main(int argc, char *argv[])
9 {
10 switch (argc) {
11 case 1:
12 ip = (int *) 0;
13 *ip = 1;
14 break;
15 case 2:
16 ip = (int *) 0;
17 v();
18 break;
19 default:
20 v();
21 }
22 }
============
使用 NULL 指针进行了修改
ip defined at f.c(1) :: f.c(5)
ip defined at f.c(1) :: f.c(5)
ip defined at f.c(1) :: f.c(13)
消息 ID：E_P_WRT_NULL
使用可能为 NULL 的指针进行了修改。
生成该消息的代码示例：
1 #define VALUE 0
2 static int *ip;
3 static int si;
4 int
5 main(void)
6 {
7 ip = (int *) VALUE;
8 if (si)
9 ip = &si;
10 *ip = VALUE + 1;
11 return (si);
12 }
============
使用可能为 NULL 的指针进行了修改
ip defined at f.c(2) :: f.c(10)
消息 ID：E_P_WRT_NULL_PSBL
在初始化指针以指向对象之前，解除了对指针的引用。
生成该消息的代码示例：
1 f() {
2 int *p;
3
4 *p = 5;
5 }
==========
"t2.c", line 4: 警告：使用作为未初始化值的指针进行了修改
p defined at t2.c(2) :: t2.c(4)
消息 ID：E_P_WRT_UNINI
使用可能是未初始化值的指针进行了修改。
生成该消息的代码示例：
1 int
2 main(int argc, char *argv[])
3 {
4 int *ip, i;
5 if (argc > 2)
6 ip = &i;
7 *ip = 1;
8 return i;
9 }
============
使用可能是未初始化值的指针进行了修改
ip defined at f.c(4) :: f.c(7)
消息 ID：E_P_WRT_UNINI_PSBL
使用不可靠方法产生的指针进行了修改。
生成该消息的代码示例：
1 static int *ip;
2 static void
3 f(void)
4 {
5 *ip = 1;
6 }
7 void
8 main(void)
9 {
10 ip = (int *) 4;
11 *ip = 1;
12 ip = (int *) 5;
13 f();
14 *ip = 1;
15 }
============
使用不可靠方法产生的指针进行了修改
f.c(5)
f.c(11)
f.c(14)
消息 ID：E_P_WRT_SUSP
使用可能以不可靠方式产生的指针进行了修改。
生成该消息的代码示例：
1 #define VALUE 4
2 static int *ip;
3 static int si;
4 int
5 main(void)
6 {
7 ip = (int *) VALUE;
8 if (si)
9 ip = &si;
10 *ip = VALUE + 1;
11 return (si);
12 }
============
使用可能以不可靠方式产生的指针进行了修改
f.c(10)
消息 ID：E_P_WRT_SUSP_PSBL
已定义变量，但未在程序中使用其值或占用的内存。
生成该消息的代码示例：
1 int *
2 f(void)
3 {
4 int i;
5 return (&i + (sizeof(int)));
6 }
============
未使用变量的内容或内存
i defined at f.c(4)
消息 ID：E_VRB_NEVER_USED
已定义标签，但未使用该标签。
生成该消息的代码示例：
1 f()
2 {
3 int k =7;
4 switch(k) {
5 case 1:
6 break;
7 defult: /* 未检测到语法错误 */
8 return (10);
9 }
10 }
===============
未使用标签
(7) defult in f
消息 ID：E_LABEL_NOT_USED
Lint 已检测到不包含可执行语句的循环。
生成该消息的代码示例：
1 int i;
2 for (i = 0; i < 5; i++) ; /* for 循环为空 */
3 while (i < 7) { } /* while 循环为空 */
消息 ID：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) 警告：将浮点转换成整型：函数 f 的参数 #1
消息 ID：E_ARGUMENT_CONVERT
编译器或 lint 检测到无效的文件号（大于文件列表中的可用插槽）。这是一个内部错误。
消息 ID：E_BAD_FILE_NUMBER
lint 无法输出与消息对应的源文件，因为无法访问该源文件，例如，该源文件可能已经重新命名、删除或移动。格式：简单。
生成该消息的代码示例：
| |******* 无法访问源代码行 ... | ! line 677, file.c 警告：从未使用赋值：ReturnVal
消息 ID：E_SRC_LINE_UNACCESSIBLE
某些 #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 函数不能返回值
消息 ID：E_SRC_LINE_UNACCESSIBLE2
对于已经调用的函数，其参数类型无法转换成该函数的函数原型声明中的类型。
生成该消息的代码示例：
struct s {int x; } q;
int g(int, int);
f() {
g(3, q);
}
消息 ID：E_ARG_INCOMPATIBLE_WITH_ARG_L
该代码包含无效的表达式或子表达式。
生成该消息的代码示例：
int g() {
1;
return 0;
}
消息 ID：E_EXPR_NULL_EFFECT
已经从该函数返回的类型与其声明的返回类型不同，所以编译器无法将其转换成该函数的返回类型。
生成该消息的代码示例：
1 char f() {
2 return 0xffffffffL;
3 }
消息 ID：E_IMPL_CONV_RETURN
正在将小于指针大小的整型对象显式强制转换为指针类型。例如，正在将 32 位整数强制转换成 64 位指针。
生成该消息的代码示例：
1 void
2 v(void)
3 {
4 int i;
5 char *ip;
6 ip = (char *) i;
7 }
============
"t.c", line 6: 警告：从 32 位整数强制转换为指针
消息 ID：E_CAST_TO_PTR_FROM_INT
将整型对象显式强制转换成较小的其他整型。
生成该消息的代码示例：
1 void
2 v(void)
3 {
4 int i;
5 long l;
6 i = (int) l;
7 }
============
"t.c", line 6: 警告：从 64 位整数强制转换为 32 位整数
消息 ID：E_CAST_INT_TO_SMALL_INT
将整型常量表达式显式强制转换为小于该整型常量表达式类型的整型。
生成该消息的代码示例：
1 void
2 v(void)
3 {
4 char c;
5 c = (char) 1024;
6 }
============
"t.c", line 5: 警告：从 32 位整型常量表达式强制转换为 8 位整数
消息 ID：E_CAST_INT_CONST_TO_SMALL_INT
将整型的对象赋值给其他（较小）的整型对象。
生成该消息的代码示例：
1 void
2 v(void)
3 {
4 int i;
5 long l;
6 i = l;
7 }
============
"t.c", line 6: 警告：将 64 位整数赋值给 32 位整数
消息 ID：E_ASSIGN_INT_TO_SMALL_INT
整型常量表达式已赋值或返回给整型对象。如果不截断，则该对象不能具有该值。
生成该消息的代码示例：
1 void
2 v(void)
3 {
4 char c;
5 c = 1024;
6 }
============
"t.c", line 5: 警告：32 位常量赋值后被截断为 8 位
消息 ID：E_ASSIGN_INT_FROM_BIG_CONST
函数调用包含大于函数定义中形式参数类型的整型参数。使用 -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)
消息 ID：E_PASS_INT_TO_SMALL_INT
函数调用包含是整型常量表达式的参数。整型常量表达式的类型大于函数定义中形式参数的类型。使用 -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)
消息 ID：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);
}
消息 ID：E_CONDITIONAL_OP_LOCKCHOICE
在 #if 或 #elif 指令中已检测到意外的一元运算。
生成该消息的代码示例：
main()
{
#define x 0
#define y 1
#if x ! y == 0
printf("Hello\n");
#endif
}
消息 ID：E_UNEXPECTED_UNARY
使用 -p 选项显示该警告。编译器可能会对指向任意对象或函数的指针进行优化，使其始终作为 true 进行求值。
生成该消息的代码示例：
extern int foo;
#pragma weak foo
int main()
{
if (&foo)
return foo;
}
消息 ID：E_POINTER_TO_OBJECT
常量初始化程序中的地址必须是运算常量表达式。作为扩展，地址可以出现在大小大于或等于指针大小的整型的常量初始化程序中。不允许出现在大小小于指针大小的整型的常量初始化程序中。
生成该消息的代码示例：
int x; char c = &x;
消息 ID：E_ADDRESS_IN_CONST_INITIALIZER
将整型对象与其他（较大）的整型对象进行比较。
生成该消息的代码示例：
1 void
2 v(void)
3 {
4 int i;
5 long l;
6 i = i > l;
7 }
============
"t.c", line 6: 警告：将 32 位整数与 64 位整数进行比较
消息 ID：E_COMP_INT_WITH_LARGE_INT
将无符号整型的对象赋值给大小相等的带符号整型对象。
生成该消息的代码示例：
1 void
2 v(void)
3 {
4 int i;
5 unsigned int ui;
6 i = ui;
7 }
============
"t.c", line 6: 警告：将 32 位无符号整数赋值给 32 位有符号整数
消息 ID：E_ASSIGN_UINT_TO_SIGNED_INT
函数调用包含无符号整型的参数，其中函数定义中形式参数的类型是大小相等的带符号整型。使用 -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)
消息 ID：E_PASS_UINT_TO_SIGNED_INT
将无符号整型对象显式强制转换为大小相等的带符号整型。
生成该消息的代码示例：
1 void
2 v(void)
3 {
4 int i;
5 unsigned int ui;
6 i = (int) ui;
7 }
============
"t.c", line 6: 警告：将 32 位无符号整数强制转换为 32 位有符号整数
消息 ID：E_CAST_UINT_TO_SIGNED_INT
#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, }
消息 ID：E_IGNORE_MALFORMED_PRAGMA_EMSG
根据 #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
消息 ID：E_SYMBOL_IN_PRAGMA_WEAK
extern、static 或 array 对象的初始化程序必须是编译时常量。如果用 {} 将初始化程序括起来，则自动结构或联合对象的初始化程序还必须是编译时常量。整型常量表达式中的强制转换运算符只能将运算类型转换为整型。例如，指针类型到运算类型的强制转换不是常量表达式。另外，如果要初始化的变量类型小于指针，则编译器会发出该错误消息。
生成该消息的代码示例：
extern int myf(); int (* fptr)() = (int (*)())((int)myf + 1);
消息 ID：E_NON_CONST_INIT_SCONV
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
{
}
消息 ID：E_UNDEFINING__STDC_VERSION__
在指定的 pragma 中使用函数名称之前，编译器已经遇到必须定制为原型的该函数名称。
生成该消息的代码示例：
/* abc 函数并未在任何位置定义或声明 */ #pragma inline (abc)============ 函数 abc 应该在 pragma 之前定制原型：
int abc(); #pragma inline (abc)
消息 ID：E_PRAGMA_FUNC_UNDECLARED
编译器已经遇到不是函数名称的标识符，其中指定的 pragma 需要该函数名称。
生成该消息的代码示例：
int abc; #pragma inline (abc)
消息 ID：E_PRAGMA_FUNC_REQUIRED
已经使用错误的语法指定指出的 #pragma。pragma 的正确语法如下：
#pragma(funcname [, funcname ...])
生成该消息的代码示例：
#pragma no_side_effect {a b}
消息 ID：E_MALFORMED_PRAGMA_W_FUNC
要使用不同类型的操作数计算表达式，该编译器需要将无符号整型的操作数改进为较大的整型或指针大小。
生成该消息的代码示例：
1 main()
2 {
3 unsigned int i = 1;
4 unsigned long long ll = 1;
5 char *p = "hello";
6 char c;
7
8 c = *(p + (-i));
9 return (ll + (-i));
10 }
============
(8) 警告：将无符号的整型改进为较大的整型或指针大小可能会产生意外的结果，因为没有符号扩展。
(9) 警告: 将无符号的整型改进为较大的整型或指针大小可能会产生意外的结果，因为没有符号扩展。
消息 ID：E_UNEXPECTED_UINT_PROMOTION
在下标求值期间，编译器将无符号整数改进为指针大小。
生成该消息的代码示例：
1 void main()
2 {
3 unsigned int i = 1;
4 char *p = "hello";
5 char c;
6
7 c = p[-i];
8 }
============
(7) 警告：在下标求值期间将无符号整数改进为指针大小会产生意外的结果，因为没有符号扩展。
消息 ID：E_UNEXPECTED_UINT_PROMOTION_SUB
如果编译器将带符号整型的操作数改进为较大的无符号整型，则会扩展符号。
生成该消息的代码示例：
1 void main()
2 {
3 int i = -1;
4 unsigned long ul;
5
6 ul = (unsigned long)i;
7 }
============
(6) 警告：从 32 位到 64 位整数的符号扩展
消息 ID：E_SIGN_EXTENSION_PSBL
编译器已经遇到级别超过命令行 -xmaxopt 值的 #pragma opt。该 #pragma opt 遇到的函数优化级别已减少到编译器 -xmaxopt 选项指定的值。
生成该消息的代码示例：
int abc(); /* 使用 -xO5 -xmaxopt=2 调用编译器 */ #pragma opt 4 (abc)
消息 ID：E_PRAGMA_OPT_REDUCED
指定 #pragma opt 时所用的语法不正确。pragma 的正确语法如下：
#pragma opt level (funcname [, funcname ...])
生成该消息的代码示例：
#pragma opt 3 {a b}
消息 ID：E_IGNORE_MALFORMED_PRAGMA_OPT
如果使用可疑声明或定义重新声明了标识符，将会输出该消息。在这种情况下，不会输出标识符的类型。
生成该消息的代码示例：
1 #include <stdio.h>
2 void Function( struct IamNotDefined *b);
3 int counter = 0;
4 main()
5 {
6 }
7
8 void Function( struct IamNotDefined *b) ;
消息 ID：E_DUBIOUS_ID_REDECLARED
如果使用可疑定义重新定义标识符，将会输出该消息。在这种情况下，不会输出标识符的类型。
生成该消息的代码示例：
1 #include <stdio.h>
2 void Function( struct IamNotDefined *b) { }
3
4 int counter = 0;
5 main()
6 {
7 }
8
9 void Function( )
10 {
11 }
消息 ID：E_DUBIOUS_ID_REDEFINED
编译器已经遇到重新定义外部定义的对象或函数。原始的外部名称已经通过使用 #pragma redefine_extname 加以更改。另外，编译器已经检测到新外部名称的重新定义。
生成该消息的代码示例：
1 #pragma redefine_extname fold fnew
2
3 fold ()
4 {
5 }
6
7 fnew ()
8 {
9 }
10
11 main ()
12 {
13 }
-#
消息 ID：E_FUNC_REDEFINED_THROUGH_PRAGMA
已对结构声明进行构造，所以对于目标计算机，声明的对象太大。
生成该消息的代码示例：
typedef int Not_that_big_array[0x10000000];
struct {
Not_that_big_array m1,m2,m3,m4,m5,m6,m7,m8;
}
消息 ID：E_STRUCT_SIZE_TOO_BIG
结构或联合关键字之后缺少标记，或者结构或联合关键字之后的标记未引用该 #pragma 之前正确声明的结构或联合。
生成该消息的代码示例：
/* 尚未定义 struct bar */
void foo() {
#pragma alias_level strict (struct bar)
return;
}
消息 ID：E_ALIAS_NO_TAG
在该 pragma 之前，必须将指定的标识符定义为结构。
生成该消息的代码示例：
union bar { int field; };
void foo() {
#pragma alias_level strict (struct bar)
return;
}
消息 ID：E_ALIAS_NOT_A_STRUCT
在该 pragma 中之前，必须将指定的标识符定义为联合。
生成该消息的代码示例：
struct bar { int field; };
void foo() {
#pragma alias_level strict (union bar)
return;
}
消息 ID：E_ALIAS_NOT_A_UNION
在该 pragma 中引用之前，必须将指定的标识符声明为枚举。
生成该消息的代码示例：
/* 尚未定义 enum bar */
void foo() {
#pragma alias_level strict (enum bar)
return;
}
消息 ID：E_ALIAS_NOT_AN_ENUM
在该 pragma 中引用之前，必须将指定的标识符声明为指针。
生成该消息的代码示例：
int bar;
void foo() {
#pragma alias_level strict (bar)
return;
}
消息 ID：E_ALIAS_EXPECTING_POINTER
将该消息中注明的标识符用作该 pragma 中的结构之前，不能将其声明为结构。
生成该消息的代码示例：
enum abc {one, two};
#pragma alias_level strict (struct abc)
消息 ID：E_ALIAS_STRUCT_LIE
将该消息中注明的标识符用作该 pragma 中的联合之前，不能将其声明为联合。
生成该消息的代码示例：
enum abc {one, two};
#pragma alias_level strict (union abc)
消息 ID：E_ALIAS_UNION_LIE
将该消息中注明的标识符用作该 pragma 中的枚举之前，不能将其声明为枚举。
生成该消息的代码示例：
struct abc {int field;};
#pragma alias_level strict (enum abc)
消息 ID：E_ALIAS_ENUM_LIE
指定的 pragma 中提供的不是类型。#pragma alias 和 alias_level 应该有类型列表。
生成该消息的代码示例：
int i; #pragma alias_level strict (i)
消息 ID：E_ALIAS_EXPECTING_TYPE
在该 pragma 中引用之前，必须将指定的标识符声明为变量。
生成该消息的代码示例：
int myfunc(); #pragma alias (myfunc)
消息 ID：E_ALIAS_EXPECTING_VARIABLE
alias_level pragma 的格式如下：
#pragma alias_level( [, ]... ) #pragma alias_level ( [, ]... )
生成该消息的代码示例：
#pragma alias_level std (
消息 ID：E_IGNORE_BAD_ALIAS_LEVEL_PRAGMA
alias pragma 的格式如下：
#pragma alias ([, ]... ) #pragma alias ( , [, ]... )
生成该消息的代码示例：
#pragma alias (
消息 ID：E_IGNORE_BAD_ALIAS_PRAGMA
alias pragma 的格式如下：
#pragma noalias ([, ]... ) #pragma noalias ( , [, ]... )
生成该消息的代码示例：
#pragma alias (
消息 ID：E_IGNORE_BAD_NOALIAS_PRAGMA
may_point_to pragma 的格式如下：
pragma may_point_to (, [, ]... )
生成该消息的代码示例：
#pragma may_point_to (
消息 ID：E_IGNORE_BAD_MAYPTTO_PRAGMA
may_not_point_to pragma 的格式如下：
pragma may_not_point_to (, [, ]... )
生成该消息的代码示例：
#pragma may_not_point_to (
消息 ID：E_IGNORE_BAD_MAYNOTPTTO_PRAGMA
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);
消息 ID：E_POINTTO_NOT_A_POINTER
只有某些字符才能跟在字符串型和字符常量中的 \ 之后：\' \" \?\\ \a \b \f \n \r \t \v \<octal-digit> \x<hexadecimal-digit>。ANSI C 会忽略 \。
生成该消息的代码示例：
int i = '\c';
消息 ID：E_DUBIOUS_ESCAPE_MBCHAR
别名 pragma 只能在文件或函数范围内使用。
生成该消息的代码示例：
struct s1 {...};
struct s2 {...};
main()
{
{
#pragma alias (struct s1, struct s1)
}
}
消息 ID：E_IGNORE_BAD_SCOPE_FOR_PRAGMA
用指针代替不完整的数组类型，以其作为函数原型中的参数。
生成该消息的代码示例：
main()
{
extern somefunc(void array[]);
}
消息 ID：E_ARRAY_OF_INCOMPLETE
用指针代替不完整的类型，以其作为函数原型中的参数。
生成该消息的代码示例：
struct xxx; extern lastfunc(struct xxx xs[]);
消息 ID：E_ARRAY_OF_INCOMPLETE_NONAME
已对自动变量声明进行构造，所以声明的对象不适合于目标计算机的栈。
生成该消息的代码示例：
void foo(void){
int big_array[0x100000000LL];
}
消息 ID：E_AUTO_VARIABLE_TOO_BIG
对 -xalias_level 下允许的优化进行别名分析时，如果将标量指针强制转换为结构指针，可能会出现取消定义的行为。
生成该消息的代码示例：
struct foo {
int a;
};
struct foo *foop;
int *p;
void
main()
{
foop = (struct foo *)p;
}
消息 ID：E_CAST_SCALAR_TO_STRUCT
对 -xalias_level 下允许的优化进行别名分析时，如果将 void 指针强制转换为结构指针，可能会出现取消定义的行为。
生成该消息的代码示例：
struct foo {
int a;
};
struct foo *foop;
void *p;
void
main()
{
foop = (struct foo *)p;
}
消息 ID：E_CAST_VOID_PTR_TO_STRUCT
对 -xalias_level 下允许的优化进行别名分析时，如果将结构字段强制转换为结构指针，可能会出现取消定义的行为。
生成该消息的代码示例：
struct foo {
int a;
};
struct foo *foop;
int *p;
void
main()
{
p = (int *)&foop.a
}
消息 ID：E_CAST_SCALAR_STRUCT_TO_SCALAR
对 -xalias_level=strict 下允许的优化进行别名分析时，如果将指针强制转换为两个无别名的结构，可能会出现取消定义的行为。
生成该消息的代码示例：
struct fooa {
int a;
};
struct foob {
int b;
};
struct fooa *fooaa;
struct foob *foobb;
void
main()
{
fooaa = (struct fooa *)foobb;
}
消息 ID：E_CAST_STRUCT_TO_STRUCT
对 -xalias_level=weak 和更高级别下允许的优化进行别名分析时，如果将标量指针强制转换为标量，可能会出现取消定义的行为。
生成该消息的代码示例：
int *ip;
long *lp;
void
main()
{
ip = (int *)lp;
}
消息 ID：E_CAST_SCALAR_TO_SCALAR
对 -xalias_level=weak 和更高级别下允许的优化进行别名分析时，如果将非标量指针强制转换为标量指针，可能会出现取消定义的行为。
生成该消息的代码示例：
int *ip;
long a[10];
void
main()
{
ip = (int *)a[3];
}
消息 ID：E_CAST_NONSCALAR_TO_SCALAR
threadprivate 指令必须显示在文件范围内，而在任何定义或声明之外。
生成该消息的代码示例：
int i;
void
main()
{
#pragma omp threadprivate(i)
}
消息 ID：E_OMP_NONFILE_THREADPRIV
threadprivate 指令列表中的每个变量必须具有文件范围声明。
生成该消息的代码示例：
void
main()
{
int i;
#pragma omp threadprivate(i)
}
消息 ID：E_OMP_AUTO_THREADPRIV
Threadprivate 指令必须按照字典方式位于列表中所有变量引用之前。
生成该消息的代码示例：
int i;
void foo() {
i = 10;
}
#pragma omp threadprivate(i)
消息 ID：E_OMP_THREADPRIV_REF
threadprivate、firstprivate、lastprivate 和 private 变量不能具有不完整的类型。
生成该消息的代码示例：
struct S s;
#pragma omp threadprivate(s)
struct S {
int i;
}
void foo() {
#pragma omp parallel private(s)
{
}
}
消息 ID：E_OMP_VAR_INCOMPLETE
不能在 private、firstprivate、lastprivate、shared 或 reduction 子句中使用 threadprivate 变量。但是，这些变量不受缺省子句的影响。
生成该消息的代码示例：
int i;
#pragma omp threadprivate(i)
void
main()
{
#pragma omp parallel private(i)
i++;
}
消息 ID：E_OMP_THREADPRIV_WRONG_CLAUSE
不能在多个子句中指定变量，除非该变量可以同时在 firstprivate 和 lastprivate 子句中指定。
生成该消息的代码示例：
void
main()
{
int i;
#pragma omp parallel private(i) copyin(i)
i++;
}
消息 ID：E_OMP_DUP_CLAUSE
在 private（或 lastprivate）子句中指定的变量不能有常量限定的类型。
生成该消息的代码示例：
void
main()
{
const int ci;
#pragma omp parallel private(ci)
;
}
消息 ID：E_OMP_CONST_PRIVATE
不能在封闭的共享作业或并行指令的 private (firstprivate/lastprivate) 子句中指定在并行区域内为 private 的变量。因此，在共享作业或并行指令中指定为 private 的变量必须在封闭的并行区域中进行共享。
生成该消息的代码示例：
void
main()
{
int i,j;
#pragma omp parallel private(j)
{
#pragma omp for lastprivate(j)
for (i=0; i<10; i++)
j++;
}
}
=======
消息 ID：E_OMP_PRIVATE_PRIVATE
初始化程序的花括号内不包含任何内容。
生成该消息的代码示例：
struct {int i;} = {};
消息 ID：E_EMPTY_INITIALIZER
如果两个指针的差异可能通过 ptrdiff_t 溢出，则显示该消息。 在下面的示例中，如果遇到 char 指针差异，会生成该消息。请注意，如果遇到 int 指针差异，将不会生成该消息。
#includevoid foo(void){ char *pc1, *pc2; int * pi1, *pi2; ptrdiff_t ptrdiff; ptrdiff = pc1 - pc2; ptrdiff += pi1 - pi2; }
消息 ID：E_PTRDIFF_OVERFLOW
在 OpenMP pragma 中发现通用语法错误时显示此消息。
生成该消息的代码示例：
void main() {
#pragma omp parallel private
{
}
}
消息 ID：E_OMP_SYNTAX_ERROR
生成该消息的代码示例：
void
inline main()
{
int i;
i = 1;
}
消息 ID：E_INLINE_MAIN
生成该消息的代码示例：
inline void foo();
extern foo();
void
main()
{
foo();
}
=======
消息 ID：E_EXTERN_INLINE_UNDEFINED
代码包含空的结构成员声明。
生成该消息的代码示例：
struct {
int i;;
} s;
消息 ID：E_EMPTY_MBR_DECLARATION
如果 OpenMP for pragma 的 schedule 子句中指定的 chunksize 表达式格式错误，则会显示该消息。
生成该消息的代码示例：
void main() {
int i;
#pragma omp parallel for schedule(static,1.0)
for (i=0;i<10;i++) {
}
}
消息 ID：E_OMP_BAD_CHUNKSIZE
Chunksize 值没有意义，所以不能在 OpenMP for pragma 的运行时 schedule 中使用。
生成该消息的代码示例：
void main() {
int i;
#pragma omp parallel for schedule(runtime,1)
for (i=0;i<10;i++) {
}
}
消息 ID：E_OMP_RUNTIME_CHUNKSIZE
schedule 子句的种类必须属于 static、dynamic、guided 或 runtime 之一。
生成该消息的代码示例：
void main() {
int i;
#pragma omp parallel for schedule(normal,1)
for (i=0;i<10;i++) {
}
}
消息 ID：E_OMP_BAD_SCHEDULE_KIND
生成该消息的代码示例：
void foo() {
static int j = 1;
i += j;
}
消息 ID：E_DEF_STATIC_INLINE_EXTERN
ANSI C 标准要求，标签的后面要跟一条语句。GNU C 扩展允许使用这种构造，但是显示的是该警告，所以使用 -Xs选项时，显示的是错误。
生成该消息的代码示例：
void
main()
{
some_label:
}
消息 ID：E_LABEL_NO_STMT
定义对象之类的宏时，标识符和替换列表之间将会存在空白。
生成该消息的代码示例：
#define THIS$AND$THAT(a, b) ((a) + (b)) int c = THIS$AND$THAT(1, 7);
消息 ID：E_NO_WHITE_SPACE
在 OpenMP 并行区域的 if 子句中指定的表达式必须具有标量类型。
生成该消息的代码示例：
void main() {
struct { int val; } true = {1};
#pragma omp parallel if(true)
printf("Hello,worlds!\n");
}
消息 ID：E_OMP_BAD_IF_TYPE
OpenMP for 的初始化表达式必须采用规范的形式，如下所示： 生成该消息的代码示例：
消息 ID：E_OMP_FOR_BAD_INIT
void main() {
int i=0;
#pragma omp parallel for
for (; i<10; i++) {
}
}
OpenMP for 的索引变量必须具有带符号的整型
生成该消息的代码示例：
void main() {
unsigned char c;
#pragma omp parallel for
for (c=0; c<10; c++) {
}
}
消息 ID：E_OMP_FOR_BAD_INDEX_TYPE
OpenMP for 的控制表达式必须采用规范的形式，如下所示： 生成该消息的代码示例：
消息 ID：E_OMP_FOR_BAD_CONTROL
void main() {
int i,j=0;
#pragma omp parallel for
for (i=0; j<10; i++) {
}
}
OpenMP for 的迭代表达式的形式必须规范。
生成该消息的代码示例：
void main() {
int i;
#pragma omp parallel for
for (i=0; i<10; foo(&i)) {
}
}
消息 ID：E_OMP_FOR_BAD_ITER
在 copyin 子句中指定的变量必须是 threadprivate 变量。
生成该消息的代码示例：
void main() {
int i;
#pragma omp parallel copyin(i)
i++;
}
消息 ID：E_OMP_COPYIN_NOT_THREADPRIVATE
C99 引入了下列新的关键字：inline、restrict、_Bool、_Complex 和 _Imaginary
生成该消息的代码示例：
int _Bool;
消息 ID：E_KEYWORD_IN_C99
可以使用未指定的大小 (via[*]) 声明变量长度数组。只有这种声明才能在使用函数原型范围的声明中使用。
生成该消息的代码示例：
int foo (int a[*]) {
typedef int A[*];
}
消息 ID：E_UNSPEC_VLA_SIZE
不能在文件范围中声明可变的修改类型。
生成该消息的代码示例：
int n; typedef int A[n]; int a[n];
消息 ID：E_CANT_DECL_FILESCOPE_VM
如果标识符声明为使用静态存储持续时间的对象，则不会具有变量长度数组类型。
生成该消息的代码示例：
int foo(int n) {
static int a[n];
}
消息 ID：E_STATIC_VLA
只有普通标识符才能具有可变的修改类型。因此，不允许结构/联合成员具有这种类型。
生成该消息的代码示例：
void foo() {
int n;
struct s { int a[n]; };
}
消息 ID：E_MEMBER_CANT_BE_VM
指定数组大小的表达式将会具有整型。
生成该消息的代码示例：
void foo() {
int a[1.1];
float f;
int b[f];
}
消息 ID：E_ARRAY_SIZE_NONINTEGER
只有静态关键字才能在数组大小表达式中指定。
生成该消息的代码示例：
int a[extern 3];
消息 ID：E_BAD_ARRSIZE_STORAGE_CLASS
只有关键字 static 和类型限定符（const、restrict 和 volatile）才能在数组大小表达式中指定。
生成该消息的代码示例：
int a[int 3];
消息 ID：E_ARRSIZE_TYPE_SPECIFIER
只有在使用数组类型的函数参数的声明和最外层数组类型派生中，才会出现可选的类型限定符和关键字 static。
生成该消息的代码示例：
int a[static 3]; int bar(int[*][restrict]);
消息 ID：E_CANT_QUAL_NONPARAM_ARY
可以使用未指定的大小 (via[*]) 声明变量长度数组。只有这种声明才能在使用函数原型范围的声明中使用。
生成该消息的代码示例：
int foo () {
int i = sizeof(int[*]);
}
消息 ID：E_UNSPEC_VLA_SIZE_NONAME
OpenMP for 和 parallel for 构造之后必须跟 for 循环语句。
生成该消息的代码示例：
int foo() {
#pragma omp parallel for
while(1) {
}
}
消息 ID：E_OMP_FOR_WITHOUT_FOR
表达式中使用了指向 void 或函数的参数类型指针。假设 void 或函数的大小为 1。
生成该消息的代码示例：
void *mem = (void*)7, *retval; int sz = 4; retval = mem + sz;
消息 ID：E_PTR_TO_VOID_IN_ARITHMETIC
#warning 指令中的标记必须是有效的 C 标记。源程序包含无效的标记。
生成该消息的代码示例：
#warning 038 - this is an invalid token
消息 ID：E_BAD_TOKEN_IN_WARN_DIRECTIVE
在源文件中遇到 #warning 指令。该指令中的其他标记已作为消息的一部分进行输出。
生成该消息的代码示例：
#define ONE 2 #if ONE != 1 #warning ONE != 1 #endif
消息 ID：E_WARNING_PRAGMA
goto 语句不能从具有可变的修改类型的标识符范围之外跳至该标识符范围之内。
生成该消息的代码示例：
void foo() {
int n = 10;
{
int a[n];
vla_scope:
a[n-1] = 0;
}
goto vla_scope;
}
消息 ID：E_GOTO_INTO_VLA_SCOPE
OpenMP 指令 flush 和 barrier 不是语句，所以不能加标签。
生成该消息的代码示例：
void foo() {
int i;
wrong_label:
#pragma omp barrier
i++;
}
消息 ID：E_OMP_LABELED_DIRECTIVE
在 reduction 子句中指定的变量必须在封闭的上下文中进行共享。
生成该消息的代码示例：
void main() {
int i;
#pragma omp parallel private(i)
#pragma omp sections reduction(+:i)
{
i++;
}
}
消息 ID：E_OMP_REDUCTION_NOTSHARED
在 reduction 子句中指定的变量不能有常量限定的类型。
生成该消息的代码示例：
void
main()
{
const int ci;
#pragma omp parallel reduction(+:ci)
;
}
消息 ID：E_OMP_CONST_REDUCTION
对于 reduction 运算符，在 reduction 子句中指定的变量类型是有效的，除非从不允许使用指针类型。
生成该消息的代码示例：
void
main()
{
float f;
#pragma omp parallel reduction(^:f)
;
}
消息 ID：E_OMP_REDUCTION_BADTYPE
生成该消息的代码示例：
extern int foo(int i)
{
i++;
return i;
}
inline int foo(int i);
消息 ID：E_INLINE_DEFINED_EXTERN
生成该消息的代码示例：
inline int foo()
{
return 5;
}
extern foo(void);
消息 ID：E_INLINE_DEFINED_INLINE
在 OpenMP pragma 中发现通用语法错误时显示此消息。
生成该消息的代码示例：
#pragma STDC L_FENV_ACCESS ON /* 使用的是 "ON"，而不是 "on" */
消息 ID：E_STDC_SYNTAX_ERROR
Restrict 限定符仅对指针类型有效。指针类型之外的类型不受 restrict 限定。
生成该消息的代码示例：
restrict int a;
消息 ID：E_NON_PTR_CANT_RESTRICT_QUAL_2
OpenMP 指令 ordered 不能在 for 指令的动态范围内。其中，该指令尚未指定 ordered 子句。
生成该消息的代码示例：
void
main()
{
int i, a = 0;
#pragma omp for
for (i=0; i<10; i++) {
#pragma omp ordered
a+=i;
}
}
消息 ID：E_OMP_NONORDERED_FOR
OpenMP 指令 ordered 必须位于具有 ordered 子句的 for 或 parallel-for 构造的动态范围之内。
生成该消息的代码示例：
void
main()
{
int i, a = 0;
for (i=0; i<10; i++) {
#pragma omp ordered
a+=i;
}
}
消息 ID：E_OMP_ORDERED_NOFOR
OpenMP 指令 section 必须出现在 sections 指令的词法范围之内。
生成该消息的代码示例：
void
main()
{
int i;
#pragma omp parallel
{
#pragma omp section
i++;
}
}
消息 ID：E_OMP_SECTION_NO_SECTIONS
对于 default 子句，只有 none 或 shared 才是有效值。
生成该消息的代码示例：
void
main()
{
int i;
#pragma omp parallel default(private)
{
i++;
}
}
消息 ID：E_OMP_BAD_DEFAULT
Pragma alias_level 只在文件范围内有效，因为通过 pragma 设置的别名级别被应用于其余的翻译单元中。
生成该消息的代码示例：
struct s1 {...};
struct s2 {...};
foo()
{
#pragma alias_level strict (struct s1, struct s2)
}
消息 ID：E_FILE_SCOPE_ALIAS_LEVEL_PRAGMA
预处理运算符 _Pragma 可以通过宏定义进行重新定义。但是，这样的重新定义会完全隐藏 _Pragma 运算符。
生成该消息的代码示例：
#define _Pragma printf("Pragma\n")
消息 ID：E_PP_PRAGMA_REDEFINED
预处理运算符 _Pragma 获取了一个应该是单个字符串型的参数。
生成该消息的代码示例：
_Pragma("omp", "parallel")
_Pragma("omp" "parallel")
消息 ID：E_PP_PRAGMA_ARG_MISMATCH
不允许具有相同名称的 critical 指令相互嵌套。
生成该消息的代码示例：
void main(void) {
#pragma omp critical(foo)
#pragma omp critical(foo)
;
}
消息 ID：E_OMP_BAD_CRITICAL_NESTING
声明必须位于所有语句之前。
生成该消息的代码示例：
void main(void) {
int i = 1;
i++;
int j = i;
}
消息 ID：E_DECLARATION_IN_CODE
for 语句的初始化部分只能是表达式语句。
生成该消息的代码示例：
void main(void) {
for (int i = 1; i<10; i++);
}
消息 ID：E_DECLARATION_IN_FOR
for 语句的声明部分只能使用存储类 auto 或 register 声明变量。
生成该消息的代码示例：
void main(void) {
for (static int i = 1; i<10;)
i++;
}
消息 ID：E_BAD_STORAGE_IN_FOR_DECL
关键字 static 在数组声明符中用作限定符时，其后应跟数组大小表达式。该表达式可以被省略。
生成该消息的代码示例：
void foo (int a[static]);
消息 ID：E_INVALID_STATIC_VLA_QUAL
在 #include 指令中未指定文件的读取权限。
生成该消息的代码示例：
#include "noperm.h"
消息 ID：E_CANT_ACCESS_INCLUDE_FILE
无法打开在 #include 指令中指定的文件，因为已经打开的文件太多。
生成该消息的代码示例：
#include __FILE__
消息 ID：E_TOO_MANY_FILES
试图获得许可证或与许可证有关的信息时出现问题。
消息 ID：E_LICENSE_ERROR
如果不使用任何显式类型说明符声明变量，则假设为隐式的 int。
生成该消息的代码示例：
static a;
消息 ID：E_NO_EXPLICIT_TYPE_GIVEN
如果不使用任何显式类型说明符声明参数，则假设为隐式的 int。
生成该消息的代码示例：
void
fux(a)
{
/* 主体 */
}
消息 ID：E_NO_TYPE_FOR_OLDSTYLE_PARAM
不再允许有隐式函数声明。
生成该消息的代码示例：
/* 此处没有 #include*/ void main(void) { printf("Hello world!\n"); }
消息 ID：E_NO_IMPLICIT_DECL_ALLOWED
已经在非结构/联合初始化程序上下文中使用了结构/联合字段名称。
生成该消息的初始化程序的示例：
int a[10] = {.field=1}
消息 ID：E_DESIG_INIT_FIELD
数组初始化程序的指定索引不是常量值。
生成该消息的初始化程序的示例：
int i;
int a[10] = {[i]=1}
消息 ID：E_DESIG_INIT_INDEX_CONST
已经使用数组初始化程序的指定索引初始化非数组变量。
生成该消息的初始化程序的示例：
int a = {[5]=1}
消息 ID：E_DESIG_INIT_NON_ARRAY
已经采用与标识符的早期外观不一致的方式声明了标识符，或者已经在相同的范围中对标识符声明了两次。在 K&R C 的早期版本中，如果类型“近乎”相同（如 SPARC 上的 int 和 long），则允许重新声明不一致。ANSI C 将这些类型视为不同的类型。
int x; static long x;
消息 ID：E_IDENTIFIER_REDECLARED_STATIC
将 & 应用于操作数时，该操作数不能属于 void 类型。
生成该消息的代码示例：
void *p; *p = &*p;
消息 ID：E_TAKING_ADDRESS_OF_VOID
已经使用不完整的 struct、union 或 enum 类型声明了函数参数。
生成该消息的代码示例：
typedef struct foo
{
void (*function)(struct foo bar);
} foobar;
消息 ID：E_INCOMPLETE_PARAMETER
__thread 关键字可以应用于外部或静态变量。它不会对自动变量产生影响。
生成该消息的代码示例：
int foo() {
__thread int i;
}
消息 ID：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;
}
消息 ID：E_OMP_BAD_ATOMIC_EXPR
1999 ISO C 标准对整型常量的类型规则进行了更改。如果遇到任意整型常量与 ANSI 标准规则设置的类型不同时，编译器会发出该消息。
生成该消息的代码示例：
long long a = 2147483648;
消息 ID：E_C99_INTEGER_PROMOTION
编译器已经遇到具有太多参数的 #pragma。忽略多余的参数。
生成该消息的代码示例：
#pragma MP taskloop maxcpus (2) savelast
消息 ID：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;
}
消息 ID：E_FLTARRSMLSTRUCT
"." 运算符的左操作数是不会生成左值的表达式。通常，如果遇到试图更改返回结构的函数返回值的程序时，会发出该警告。
生成该消息的代码示例：
struct s { int ia[10]; };
struct s sf(void);
f(void) {
sf().ia[0] = 3;
}
消息 ID：E_L_OPERAND_DOT_NOT_LVALUE_NOW
omp pragma 构造中应该有语句。
导致该错误的代码示例：
{
#pragma omp master
}
消息 ID：E_OMP_NO_STATEMENT
parallel for 中循环控制所用的变量被隐式声明为专用变量，所以 shared() 子句不会对这些变量产生影响。
生成该消息的代码示例：
void
main()
{
int i,j;
#pragma omp parallel for shared(i,j)
for (i=0; i<10; i++) j = i;
printf("i=%d\tj=%d\n",i,j);
}
消息 ID：E_OMP_SHARED_CONTROL_VAR
生成该消息的代码示例：
main()
{
float f;
f = 0x1.ffffffp0f;
}
消息 ID：E_CNV_HEX_CONST_EVAL_FMT
在 OpenMP 并行区域的 num_threads 子句中指定的表达式必须具有整型。
生成该消息的代码示例：
void main() {
struct { int val; } true = {1};
#pragma omp parallel num_threads(true)
printf("Hello,worlds!\n");
}
消息 ID：E_OMP_BAD_NUM_THREADS_TYPE
生成该消息的代码示例：
void foo() {
int i;
#pragma STDC FP_CONTRACT OFF
}
消息 ID：E_STDC_PRAGMA_WRONG
在 OpenMP 并行区域的 num_threads 子句中指定的表达式必须是正整数。
生成该消息的代码示例：
void main() {
#pragma omp parallel num_threads(-1)
printf("Hello,worlds!\n");
}
消息 ID：E_OMP_NEGATIVE_NUM_THREADS
不能在绑定到并行构造的共享作业指令的 reduction 子句中指定并行区域中的专用变量。
生成该消息的代码示例：
void main() {
int i;
#pragma omp parallel private(i)
#pragma omp sections reduction(+:i)
{
i++;
}
}
消息 ID：E_OMP_CANT_BE_IN_PRIVATE
不能在绑定到并行构造的共享作业指令的 reduction 子句中指定并行指令 reduction 子句中出现的变量。
生成该消息的代码示例：
void main() {
int i;
#pragma omp parallel reduction(+:i)
#pragma omp sections reduction(+:i)
{
i++;
}
}
消息 ID：E_OMP_CANT_BE_IN_REDUCTION
OpenMP sections 指令包含一系列 section 指令，其中每个指令之后都跟有一个语句。但是，第一个 section 指令可能被省略。
void foo() {
int i,j;
#pragma omp parallel sections private(i, j)
{
i++;
i = i + 1;
j++;
}
}
消息 ID：E_OMP_BAD_SECTION_STATEMENT
文件范围变量的 Threadprivate 指令必须出现在文件范围中。块范围变量的 Threadprivate 指令必须出现在该变量的范围内，但不能出现在嵌套的范围内。
生成该消息的代码示例：
extern int x;
void
main()
{
#pragma omp threadprivate(x)
static int i;
{
#pragma omp threadprivate(i)
}
}
消息 ID：E_OMP_THREADPRIV_WRONG_SCOPE
threadprivate 指令列表中的每个变量必须具有文件范围或静态块范围声明。
生成该消息的代码示例：
void
foo(int i)
{
#pragma omp threadprivate(i)
int j;
#pragma omp threadprivate(j)
}
消息 ID：E_OMP_STATIC_THREADPRIV
原子表达式的右侧不应该引用左侧的对象。
生成该消息的代码示例：
void
main()
{
int i;
#pragma omp atomic
i += i;
}
消息 ID：E_OMP_ATOMIC_EXPR_REFERENCE
由于文件系统错误，编译器无法打开 .cpch 文件。请确保具有读/写当前工作目录的权限。
消息 ID：E_CANT_OPEN_PCH_FILE
必须使用 #pragma hdrstop 或 -xpchstop=filename 标记初始通用源的结尾，其中文件名与程序源中一个 #include 的名称相同。使用初始通用源，可以标识可以通过预编译头重用的程序部分。
消息 ID：E_NO_PCH_STOP_POINT
使用任何 #include 指令之前的 #pragma hdrstop 或 -xpchstop 时，将禁用预编译的头。
消息 ID：E_HDRSTOP_BEFORE_INCLUDE
函数不能在用作 PCH 文件的一部分的头文件中定义。
生成该错误的代码示例：
int
foo()
{
return 1;
}
消息 ID：E_CANT_INIT_IN_PCH
使用预编译的头时，某些指令是无效的。如果使用这些指令，将会产生错误。导致该错误的代码示例
#line 1 #error "error message" #file "file.h" #warning "warning message" #assert system (unix) #unassert system
消息 ID：E_PCH_INVALID_DIRECTIVE
创建预编译的头时，__DATE__ and __TIME__ 预定义的宏不能在头文件中使用。
消息 ID：E_PCH_INVALID_PREDEFINED
收集或使用预编译的头时，__LINE__ and __FILE__ 预定义的宏不能在预编译的头前缀中使用。
消息 ID：E_PCH_PREFIX_PREDEFINED
PCH 文件不可用，因为无法识别该魔数。
消息 ID：E_PCH_FILE_UNUSABLE_MAGIC
PCH 文件不可用，因为 PCH 版本号不正确。必须使用当前的编译器重新生成 PCH 文件。
消息 ID：E_PCH_FILE_UNUSABLE_VERSION
PCH 文件不可用，因为 -D 或 -U 选项与创建 PCH 文件时使用的选项不完全一致。
消息 ID：E_PCH_FILE_UNUSABLE_DEFS
PCH 文件不可用，因为命令行选项与创建 PCH 文件时使用的选项不完全一致。
消息 ID：E_PCH_FILE_UNUSABLE_OPS
PCH 文件无法与当前的源文件一起使用，因为包含 #include 指令的初始预处理指令序列与创建 PCH 文件时所用的序列不完全一致（不包括任何注释）。
消息 ID：E_PCH_FILE_UNUSABLE_PREFIX
生成该消息的代码示例：
void foo() {
int i;
#pragma omp parallel
{
#pragma omp single copyprivate(i)
;
}
}
消息 ID：E_OMP_COPYPRIV_MUST_BE_PRIVATE
生成该消息的代码示例：
int main() {
int i = 42;
#pragma omp single nowait copyprivate(i)
{
i++;
}
}
消息 ID：E_OMP_COPYPRIV_WITH_NOWAIT
只有对函数标识符应用内联关键字时，该关键字才有效。
导致该错误的代码示例：
inline int i;
main()
{
inline float f[10];
}
消息 ID：E_INLINE_NEEDS_FUNC
函数声明与以前的内联函数定义不一致。
导致该错误的代码示例：
inline int func(int i)
{
return ++i
}
static int func();
消息 ID：E_INLINE_FUNC_REDECL_STATIC
生成该消息的代码示例：
void
main(void) {
int a=1, b=0, c=0;
(a ? b : c) = 5;
}
消息 ID：E_ASSIGNMENT_TO_COND_EXPR
生成该消息的代码示例：
int *a = &(int[]){10, 20};
消息 ID：E_NONC99_COMPOUND_LITERAL
正在将类型结构的函数数组成员赋值给指针。除下一个序列点外，会取消定义这种赋值结果。
生成该消息的代码示例：
main()
{
int *i;
i = foo().bar;
printf("i is %d\n", *i);
}
消息 ID：E_ASG_ARY_TO_PTR
使用 inline 关键字无效
生成该消息的代码示例：
int foo(inline int);
消息 ID：E_INLINE_INVALID_USE
++ 和 -- 运算符的操作数必须是整数、实数或指针类型。
生成该消息的代码示例：
double _Complex dc = 1.0 + 2.0 * _Imaginary_I; dc++; // 此处有错 double _Imaginary di = 2.0 * _Imaginary_I; --di; // 此处有错
消息 ID：E_OPERAND_MUST_BE_REAL_OR_PTR
生成该消息的代码示例：
static int bar();
inline int foo() {
static int i;
return i + bar();
}
指向变量 'i' 和函数 'bar' 的引用均无效。
消息 ID：E_REF_STATIC_EXTERN_INLINE
复数/虚数类型的说明符不完整。
生成该消息的代码示例：
_Complex c = 1.1 + 2.2 * _Imaginary_I; _Imaginary i;
消息 ID：E_INCOMPLETE_COMPLEX_IMAGINARY
无效的浮点运算。
消息 ID：E_FP_INVALID
浮点运算导致溢出。
消息 ID：E_FP_OVERFLOW
浮点运算导致下溢。
消息 ID：E_FP_UNDERFLOW
除数为 0。
消息 ID：E_FP_DIVISION_BY_ZERO
实数类型转换为 _Imaginary 类型导致 _Imaginary 类型为 0.0。
生成该消息的代码示例：
double d = 1.0; double _Imaginary di = d; // 此处有警告：di gets 0
消息 ID：E_REAL_CONV_TO_ZERO
_Imaginary 类型转换为实数类型导致实数类型为 0.0。
生成该消息的代码示例：
double _Imaginary di = _Imaginary_I; double d = di; // 此处有警告：d gets 0
消息 ID：E_IMAGINARY_CONV_TO_ZERO
OpenMP for 的迭代表达式必须与控制表达式一致。如果 for 循环中的逻辑运算符是 <=，则该循环变量应该递增，反之亦然。
生成该消息的代码示例：
void main() {
int i;
#pragma omp parallel for
for (i=0; i<10; i--) {
}
}
消息 ID：E_OMP_FOR_INCONSIST_ITER
十六位字符串型只能与其他十六位字符串型并置在一起。
生成该消息的代码示例：
unsigned short *s = U"abc" "def";
消息 ID：E_CANT_CONCAT_MIXED_UTF_STRINGS
生成该警告的代码示例：
unsigned short bar[] = U"é";
消息 ID：E_ASCII_UTF16_USHORT_CHAR_ERR
使用调试程序中的修复和继续功能进行编译时，会忽略 -xcrossfile 标志。
消息 ID：E_X_CROSSFILE_IGNORED
生成该错误的代码示例：
static __symbolic int i;
消息 ID：E_LDSCOPE_FOR_EXTERN_ONLY
生成该错误的代码示例：
__symbolic void rescopedcl(); __global void rescopedcl();
消息 ID：E_NEW_LDSCOPE_MUST_BE_HIGHER
生成该错误的代码示例：
__symbolic void rescopedef() { } __hidden void rescopedef();
消息 ID：E_NO_LDSCOPE_AFTER_DEFN
生成该错误的代码示例：
int i;
#include "file.h"
#pragma hdrstop
main()
{
}
消息 ID：E_PCH_BAD_VIABLE_PREFIX
位字段声明指定的大小为负位数。
生成该消息的代码示例：
struct s { int x:-3 };
消息 ID：E_BIT_FLD_SIZE_LESS_ZERO
位字段声明指定的大小为零。
生成该消息的代码示例：
struct s {
int x:1;
int y:0;
};
消息 ID：E_BIT_FLD_SIZE_EQUAL_ZERO
OpenMP 并行和共享作业构造之后必须跟结构化块。结构化块是拥有一个 entry 和一个 exit 的语句。不允许使用跳转至块或跳出块的语句。
生成该消息的代码示例：
int foo() {
goto label_1;
#pragma omp parallel
{
label_1: ;
}
}
消息 ID：E_OMP_STRUCTBLK_BREAKING_IN
OpenMP 并行和共享作业构造之后必须跟结构化块。结构化块是拥有一个 entry 和一个 exit 的语句。不允许使用跳转至块或跳出块的语句。结构化块不能包含造成控制从块流出的 return、goto、break 或 continue 语句。
生成该消息的代码示例：
int foo() {
#pragma omp parallel
{
return;
}
}
消息 ID：E_OMP_STRUCTBLK_BREAKING_OUT
不能在 OpenMP 数据范围子句中使用 TLS 变量。这些变量也不受缺省子句的影响。
生成该消息的代码示例：
__thread int i;
void
main()
{
#pragma omp parallel private(i)
i++;
}
消息 ID：E_OMP_TLS_WRONG_CLAUSE
已经使用数组初始化程序的指定索引初始化非数组变量。
生成该消息的初始化程序的示例：
int a = {[5]=1};
消息 ID：E_DESIG_INIT_NONARRAY
数组初始化程序的指定索引不是常量值或整型。
生成该消息的初始化程序的示例：
int i;
int a[10] = {[i]=1};
消息 ID：E_DESIG_INIT_INDEX_NONCONST
数组初始化程序的指定索引超出数组范围。
生成该消息的初始化程序的示例：
int a[10] = {[20]=1};
消息 ID：E_DESIG_INIT_INDEX_BOUND
已经在非结构/联合初始化程序上下文中使用了结构/联合字段名称。
生成该消息的初始化程序的示例：
int a[10] = {.field=1};
消息 ID：E_DESIG_INIT_NONSTRUCT
已经在非 C99 模式下使用了 C99 ISO 指定的初始化程序语法。
生成该消息的初始化程序的示例：
int a[10] = {.field=1};
消息 ID：E_DESIG_INIT_DISABLED
将用户定义的数据（如派生自输入或命令行选项）作为 printf 之类的函数的格式参数传递时，应该确保格式字符串中没有 %n 个非专用说明符。%n 扩展是安全漏洞的常见起因。
生成该错误的代码示例：
(void) fprintf(stderr, fmt, i1, i2, i3);
消息 ID：E_SEC_PRINTF_VAR_FMT
如果格式化的参数大于缓冲区，则采用该格式的未绑定 %s 说明符可能会使缓冲区溢出。
生成该错误的代码示例：
(void) sprintf(buf, "%s", string);
消息 ID：E_SEC_SPRINTF_UNBOUNDED_COPY
将用户定义的数据（如派生自输入或命令行选项）作为 scanf 之类函数的格式参数传递时，应该确保格式字符串中没有 %n 个非专用说明符。%n 扩展是安全漏洞的常见起因。
生成该错误的代码示例：
(void) fscanf(stdin, fmt, &i1, &i2, &i3);
消息 ID：E_SEC_SCANF_VAR_FMT
如果格式化的参数大于缓冲区，则采用该格式的未绑定 %s 说明符可能会使缓冲区溢出。
生成该错误的代码示例：
(void) scanf("%s", string);
消息 ID：E_SEC_SCANF_UNBOUNDED_COPY
如果该缓冲区太小，无法容纳源缓冲区的内容，则使用 strcpy() 复制字符串时，会使目标缓冲区溢出。请确保该目标缓冲区具有足够的空间，或使用 strlcpy()。
生成该错误的代码示例：
(void) strcpy(dst, src);
消息 ID：E_SEC_STRCPY_WARN
库函数 strncpy() 有时难以使用，因为如果空间不足，该函数会终止目标字符串。strlcpy() 没有这种限制，所以它一般是理想的选择函数。 其中有一个例外：在更新磁盘中驻留的结构时，可能取决于以下事实：strncpy() 将不会充满目标缓冲区中的所有未使用的空间。
生成该错误的代码示例：
(void) strncpy(dst, src, size);
消息 ID：E_SEC_STRNCPY_WARN
不建议使用 strncat() 函数，因为该函数需要在调用之前计算剩余的空间。但您可以更安全地使用 strlcat()。
生成该错误的代码示例：
(void) strncat(dst, src, size);
消息 ID：E_SEC_STRNCAT_WARN
在任何情况下都无法安全使用 gets()。因为它没有与附带的缓冲区大小有关的信息，所以总是易于缓冲区溢出。请使用 fgets()。
生成该错误的代码示例：
(void) gets(buf);
消息 ID：E_SEC_FORBIDDEN_WARN_GETS
cftime() 只有借助足够大的缓冲区，才能保留结果。因为它可以从环境 (CFTIME) 中导入信息，所以无法确保所提供的缓冲区可以容纳该结果。应该使用 strftime()。
生成该错误的代码示例：
(void) cftime(buf, fmt, clock);
消息 ID：E_SEC_FORBIDDEN_WARN_CFTIME
ascftime() 只有借助足够大的缓冲区，才能保留结果。因为它可以从环境 (CFTIME) 中导入信息，所以无法确保所提供的缓冲区可以容纳该结果。应该使用 strftime()。
生成该错误的代码示例：
(void) ascftime(buf, fmt, time);
消息 ID：E_SEC_FORBIDDEN_WARN_ASCFTIME
creat() 很容易受到 symlink 的攻击。换而言之，如果要创建的文件名已经作为符号链接存在，则 creat() 之后将会跟该符号链接，还会在该 symlink 所指的位置创建该文件。由于这种执行是人工完成的，所以无法安全创建文件。
生成该错误的代码示例：
fd = creat(fname, mode);
消息 ID：E_SEC_FORBIDDEN_WARN_CREAT
使用 bcopy() 或 memcpy() 复制字符串时容易出错，因为它需要编程人员计算正确的大小。因此，我们建议使用 strlcpy()。
生成该错误的代码示例：
char *src, dst; ... (void) bcopy(dst, src, len);
消息 ID：E_SEC_BCOPY_WARN
rand() 函数系列执行相当弱的随机数生成器。如果借助强的随机数，请使用 /dev/random 或 /dev/urandom 接口。
生成该错误的代码示例：
i = rand();
消息 ID：E_SEC_STRNCAT_WARN
如果将该函数与处理相同对象（目录）的其他函数结合使用，会出现基于路径名的竞争条件。将 fchdir() 用作备选方案。
生成该错误的代码示例：
(void) chdir(dirname);
消息 ID：E_SEC_CHDIR_WARN
库和程序不应该对用户提供的路径名调用该函数。可以利用用户提供的消息目录，以便轻松地中断特权代码。
生成该错误的代码示例：
(void) catopen(fname, flag);
消息 ID：E_SEC_CATOPEN_WARN
该函数的参数只能是使用运行时链接器的路径找到的非限定路径名，或无法通过任何方法从用户输入（包括 argv[0]）派生的完整路径名。请注意，无法安全打开用户提供的共享对象，因为 _init() 函数是在 dlopen() 返回之前执行的。
生成该错误的代码示例：
dlopen(fname, dlopen_mode);
消息 ID：E_SEC_DLOPEN_WARN
该函数可以打开若干个文件，所以只能与认为安全的路径名一起使用。
消息 ID：E_SEC_PATH_WARN
chroot-ed 环境提供的保护很少。请确保没有在 chroot-ed 环境下运行特权程序，且在 chroot() 之后对新根目录之下的点执行 chdir() 操作。
消息 ID：E_SEC_CHROOT_WARN
请仔细处理 getenv() 返回的值。这些值完全受用户控制，所以可以是很大（达到 NCARGS ( 消息 ID：E_SEC_GETENV_WARN
避免使用 getlogin()；无法借助其输出，所以它不是多线程安全函数（应该使用 getlogin_r()）。在任何情况下，都不能信任返回的登录；请使用 uid 或提供备选的用户验证方法。
消息 ID：E_SEC_GETLOGIN_WARN
如果 mkdir() 所用的路径是从用户输入派生的，请检查其是否安全。
消息 ID：E_SEC_MKDIR_WARN
无法确保安全使用生成的路径名，因为路径名的生成和在 open() 使用直接存在竞争条件。应该使用 "fd = mkstemp(template);"。
消息 ID：E_SEC_MKTEMP_WARN
该函数会创建运行 shell (/bin/sh) 来执行其任务的子进程。产生 shell 时，会涉及 $PATH、$IFS 和其他环境变量，从而很难确保安全使用这些变量。另外请记住，该 shell 将会解释其参数中出现的特殊字符。
消息 ID：E_SEC_SHELL_WARN
如果接受用户指定的 \"namelist\" 参数，请确保在使用之前取消这些特权。
消息 ID：E_SEC_KVM_WARN
请确保由于符号链接的内容太大，所提供的缓冲区无法容纳这些内容时能够处理该情况。
消息 ID：E_SEC_READLINK_WARN
避免在安全应用程序中使用 getpass()。最好使用 getpassphrase()，因为它最多可以返回 256 个字符的口令。
消息 ID：E_SEC_GETPASS_WARN
无法确保安全使用生成的路径名，因为路径名的生成和在 open() 使用直接存在竞争条件。应该使用 mkstemp()。
消息 ID：E_SEC_TEMPNAM_WARN
该函数会调用多线程应用程序中不安全的 umask()。
消息 ID：E_SEC_TMPFILE_WARN
该函数取决于路径名竞争条件，因为它可以对文件名称空间内的对象进行操作。显示给该函数的对象可能与早期或后续调用中的对象不同，因为文件系统可能在这些后续调用之间直接发生了更改。
消息 ID：E_SEC_TRUNCATE_WARN
避免使用 umask()，因为它可以修改用户定义的 umask。请考虑在 open 之类的函数中使用文件创建模式。
消息 ID：E_SEC_UMASK_WARN
避免在安全应用程序中使用 utmpname()；应该使用缺省的 utmp 文件名。
消息 ID：E_SEC_UTMP_WARN
由于 API 很复杂，所以使用 select() 编程容易出错，并会导致各种安全问题。poll() 具有一个更为简单易用的接口，不仅限制少，而且速度更快。
消息 ID：E_SEC_SELECT_WARN
如果该缓冲区太小，无法容纳源缓冲区的内容，则使用该函数复制字符串时，可能会使目标缓冲区溢出。请确保该目标缓冲区具有足够的空间。
消息 ID：E_SEC_EXPAND_WARN
进程应该支持当前的 real-uid，并可以在打开文件之前切换回该 real-uid（如果需要）。如果必须更改文件系统对象的属性，则最好将 open() 与 fchown()/fchmod() 结合使用。
消息 ID：E_SEC_CHMOD_WARN
execvp() 和 execlp() 借助 $PATH 查找要运行的正确二元类型，通常，$PATH 受用户的控制。应该使用其中的一个 execl()、execv() 或 execve()。
消息 ID：E_SEC_EXEC_PATH
请确保，对其他应用程序执行 exec() 操作之前先清除该环境，并关闭所有敏感的文件说明符。
消息 ID：E_SEC_EXEC_WARN
这是安全提示：附加到循环内的缓冲区时，应该检查边界。如果未进行边界计算或该计算不正确，可能会使缓冲区溢出；决不要假设用户输入已具有固定的长度，请检查边界符号等。
消息 ID：E_SEC_LOOP_WARN
无法安全使用该函数，因为在可以对返回的信息执行操作时，该信息已经过时。使用 open() 之前的 access() 时，会存在无法解决的竞争条件问题。备选方案：具有专用用户权限的 open()。
消息 ID：E_SEC_ACCESS_WARN
如果使用 O_CREAT 而不是 O_EXCL 调用 open()，则该 open() 将作为路径名的最后一个组件跟在 symlink 之后。这样做会使用户在非专用的目标中创建文件。
消息 ID：E_SEC_CREAT_WITHOUT_EXCL
应该始终指定文件创建模式，尽可能严格地设置权限（通常仅限当前用户），并根据需要稍后扩大权限；否则，用户可能会擅自访问创建的文件。
消息 ID：E_SEC_CREAT_WITHOUT_MODE
该函数不允许为新文件指定权限。请确保路径名已经存在，或目录不能公开写入。备选方案：使用 open()/fdopen() 序列。
消息 ID：E_SEC_FOPEN_MODE
恶意用户可能在 stat 之类的调用完成之后修改了文件系统对象，这样做可能会导致竞争条件的产生。应该使用 fstat()。
消息 ID：E_SEC_USE_AFTER_STAT
如果将用户定义的数据（例如从输入或命令行选项派生）作为屏蔽参数传递给 glob()，则应该验证输入，以确保字符串的格式正确无误，且不会造成安全威胁。检查扩展符号，包括 '..'、'/'、'-'、空格和其他特殊字符。
消息 ID：E_SEC_GLOB_WARN
复合型中使用的类型名称应该是对象类型或大小未知的数组。
生成该消息的代码示例：
int i = (struct UNKNOWN) { 1 };
消息 ID：E_INCOMPLETE_COMPOUND_LITERAL
\u 和 \U 转义符序列会在 1999 ISO C 中指定通用字符名称。
生成该消息的代码示例：
char *cp = "This is a ucn: \u0020";
消息 ID：E_ESC_U_IS_C99_UCN
1999 ISO C 要求，\u 之后必须跟 4 个十六进制的数字，而 \U 之后必须跟 8 个十六进制的数字。
生成该消息的代码示例：
char *cp = "&\u00fz";
消息 ID：E_BAD_NUM_OF_DIGITS_IN_UCN
根据 1999 ISO C 中指定的限制条件，该通用字符名称在标识符中无效。
生成该消息的代码示例：
int i\uFFFF;
消息 ID：E_INVALID_UCN_FOR_ID
该通用字符名称无效。
生成该消息的代码示例：
int i\u0033;
消息 ID：E_INVALID_UCN_VALUE
非整型常量表达式不能在 1990 ISO C 的数组大小表达式中使用。请注意，在 1999 ISO C 中，它将是变量长度数组。
生成该消息的代码示例：
void foo() {
int a[(int)(5.0+1.0)];
}
消息 ID：E_C90_NON_INTEGRAL_ARRAY_SIZE
在创建或使用 PCH 文件时，源文件的可用前缀必须始终在有条件编译的代码外部终止。
生成该消息的代码示例：cc -xpch=collect:FOO -DFOO
#ifdef FOO
#include "foo.h"
#pragma hdrstop
#else
#include "bar.h"
#pragma hdrstop
#endif
main()
{}
消息 ID：E_PCH_CONDITIONAL_PREFIX
无法使用 PCH 文件，因为生成 PCH 文件时所用的编译器与当前的编译器不同。
消息 ID：E_PCH_FILE_UNUSABLE_COMP_VERS
无法使用 PCH 文件，因为当前的源文件路径与创建 PCH 文件时生效的源路径不同。这种影响包括使用相对路径，所以可能会导致包括不同的头文件，即 PCH 文件的内容可能对该编译无效。
消息 ID：E_PCH_FILE_UNUSABLE_SRC_PATH
无法使用 PCH 文件，因为当前的工作目录与创建 PCH 文件时生效的目录不同。这样会导致包括不同的头文件，即 PCH 文件的内容对该编译无效。
消息 ID：E_PCH_FILE_UNUSABLE_CWD
使用 -xcrossfile 或 -xipo 调用编译器时，会显示该警告。以前作为外部变量声明的变量无法重新声明为静态变量。
生成该消息的代码示例：
extern int local_i;
void main(int argc, char *argv[])
{
return local_i;
}
static int local_i=10;
消息 ID：E_CANT_XCROSSFILE_GLOBSTATIC
线程变量的第一个声明必须包含 __thread 说明符。
生成该消息的代码示例：
int i; __thread int i;
消息 ID：E_NONTHREAD_THREAD_REDECL
#line 指令中指定的行号必须小于或等于 2147483647（对于 C99 模式）或 32767（对于 C90 模式）。
生成该消息的代码示例：
#line 2147483647 "string" #line 2147483648
消息 ID：E_OUT_OF_RANGE_POUND_NUMBER
不能使用 redefine_extname pragma 重新定义的名称。
void main(){
foo6(1,1);
}
#pragma redefine_extname foo6 foo6_1
消息 ID：E_REDEF_EXTNAME_INCORRECT
可变的修改类型的变量不能使用外部链接进行声明。
生成该消息的代码示例：
void foo() {
int n;
extern int (*a)[n];
}
消息 ID：E_EXTERN_VM
运算符使用的操作数必须是实数浮点类型（short、double 和 long double 等），但不是，例如使用的是 int。
生成该消息的代码示例：
#includeint foo() { double _Complex c; return fpclassify(c); }
消息 ID：E_OPERAND_MUST_BE_REAL_FLOAT
结构可以包含灵活的数组成员。这种结构（和任何包含，可能是递归包含，这种结构的成员的联合）不会是结构的成员。
生成该消息的代码示例：
struct A {int xa; int ya[];};
struct B {int xb; struct A yb;};
消息 ID：E_STRUCT_DERIVED_FROM_FLEX_MBR
结构可以包含灵活的数组成员。这种结构（和任何包含，可能是递归包含，属于这种结构的成员的联合）将不是数组元素。
生成该消息的代码示例：
struct A {int xa; int ya[];};
struct A n[10];
消息 ID：E_ARY_DERIVED_FROM_FLEX_MBR
不具有对使用 -I file_path 选项指定的目录的访问权限。
消息 ID：E_CANT_ACCESS_INCLUDE_DIR
不允许初始化变量长度数组。
生成该消息的代码示例：
void foo() {
int n;
int x[n] = { 1 };
}
消息 ID：E_CANT_INIT_VLA2
<、>、<=、>= 之类的运算符不适用于复数或虚数。
生成该消息的代码示例：
int foo(float _Complex parm1, float _Complex parm2)
{
return (parm1 > parm2);
}
int foo(float _Imaginary parm1, float _Imaginary parm2)
{
return (parm1 < parm2);
}
消息 ID：E_OPERANDS_INVALID_TO_BIN_RELOP
使用带有 nowait 子句的 OpenMP reduction 循环时需谨慎。在执行同步处理之前，将无法确定 reduction 变量的值。
生成该消息的代码示例：
#pragma omp for reduction(+:s) private(i) nowait
for (i=0; i<*p;i++)
s += a[i];
消息 ID：E_NOWAIT_REDUCTION_USE
为浮点赋值整数可能会导致隐式缩小转换范围或损失精度。
生成该消息的代码示例：
int i; double d; d = 2.78; i = d; // 此处有警告
消息 ID：E_ASSIGMENT_CAUSE_LOSS_PREC
已经显式引用了参数数量不正确的变量参数内置函数。
消息 ID：E_VAR_ARG_PARAM_NUM
已经显式引用了参数类型不正确的变量参数内置函数。
消息 ID：E_VAR_ARG_PARAM_TYPE
错误 c99 pragma 格式，必须为 #pragma c99 (\"key_to_switch\")。
生成该消息的代码示例：
#pragma c99 (bubble)
消息 ID：E_PRAGMA_C99_BAD_FORMAT
遇到函数调用，并且它不包含任何参数类型信息
生成该消息的代码示例：
#pragma warn_missing_parameter_info int foo(); foo(3.1416); // 此处有警告
消息 ID：E_NO_MISSED_PARAMS_ALLOWED
当编译器确定指针运算表达式的结果将溢出可在类型为 ptrdiff_t 的对象中表示的值时，将发出该警告。
生成该消息的代码示例：
int foo (int *a) {
return a[536870912];
}
int foo2 (int a) {
int *ptr = &a;
ptr = ptr + 536870912;
return *ptr;
}
消息 ID：E_ADDR_EXPR_OVERFLOW
U 字符型只应包含一个字符。
生成该消息的代码示例：
int i = U'AB';
消息 ID：E_UTF16_CHAR_LIT_TOO_BIG
尝试将过程或其他信息写入到 SunIR 文件时出错。
消息 ID：E_IR_FILE_WRITE_ERR
准备将 SunIR 输出到 SunIR 文件时出错。
消息 ID：E_IR_PREP_FOR_OUTPUT
尝试最小化 SunIR 过程失败。
消息 ID：E_IR_MINIMIZE_ERR
准备将调试信息输出到 SunIR 文件时出错。
消息 ID：E_IR_DBG_PREP_ERR
这意味着，pragma struct_align 中使用的名称在用作用户定义的类型名称之前没有进行声明。
生成该消息的代码示例：
int foo() {
#pragma struct_align 16 (unknown) /* 此处有警告 */
struct tagUNKNOWN {
int x;
int y;
} unknown;
unknown.x = 12345;
unknown.y = 56789;
return 0;
}
消息 ID：E_PRAGMA_STRUCT_ALIGN_UNDECL
这意味着，pragma struct_align 中使用的名称不是结构/联合或 typedef 结构或联合。
生成该消息的代码示例：
int foo() {
long double err;
#pragma struct_align 16 (err); /* 此处有警告 */
typedef unsigned long myulong;
#pragma struct_align 16 (myulong); /* 此处还有一条警告 */
....
....
return 0;
}
消息 ID：E_PRAGMA_STRUCT_ALIGN_BAD_TYPE
#pragma align/struct_align 的值必须是 2 的正整数幂，且不能大于 128。该 align pragma 的语法如下：
#pragma align integer (id [, id...])
struct_align pragma 的语法是：
#pragma struct_align 整数（结构/联合标记）
生成该消息的代码示例：
#define ANO 129 #pragma align ANO (astruct)
struct q; #pragma struct_align 123 (q)不错的示例：
#define MAX 128 #pragma align MAX (astruct, aint, aptr)
消息 ID：E_BAD_PRAGMA_ALIGNMENT_VALUE
在指定 -xmodel=medium 时，如果 TLS 对象满足这样一个条件，即将非 TLS 对象放在一个较大部分中，则会在 TLS 对象上生成一条错误消息。
生成该消息的代码示例：
__thread int large_tls_array[16384] = { ...} // 此处有错误
__thread int large_tls_array[16384]; // 此处有错误
消息 ID：E_TLS_USED_WITH_MODEL_MEDIUM
openmp 数据子句中的名称不是变量。
生成该消息的代码示例：
typedef struct{
int x;
int y;
}st1;
#pragma omp parallel private(st1) // 此处有错误
{
....
}
消息 ID：E_OMP_DATA_CLAUSE_INVALID_NAME
threadprivate 指令中不允许包含循环控制变量。
生成该消息的代码示例：
static int i = 0;
#pragma omp threadprivate (i)
#pragma omp parallel for
for (i = 0; i < 4; i++) { // 此处有错误
....
}
消息 ID：E_OMP_THREADPRIV_CONTROL_VAR
由 pragma redefine_extname 重定义的标识符已声明为静态。
生成该消息的代码示例：
1 #pragma redefine_extname fold fnew
2
3 static int fold()
4 {
5 return 1;
6 }
7
8 main ()
9 {
10 }
消息 ID：E_PRAGMA_REDEFINE_STATIC
asm 语句只能使用 volatile 限定符。
生成该消息的代码示例：
__asm__ unsigned (...) /* 此处有致命错误 */
消息 ID：E_ASM_INVALID_QUALIFIER
输出参数必须是左值。
生成该消息的代码示例：
__asm__ ("..." : "w" (10) : ...)
消息 ID：E_ASM_OUTPUT_PARAM_MUST_BE_LVAL
汇编程序语句中存在未定义的命名参数。
生成该消息的代码示例：
asm ("addl %2, %[out]" : [out1] "=a" (b) : "0" (b), "Z" (3));
消息 ID：E_ASM_UNDEF_NAMED_PARAM
命名的参数列表缺少 \"]\"。
生成该消息的代码示例：
asm ("addl %2, %[out" : [out1] "=a" (b) : "0" (b), "Z" (3));
消息 ID：E_ASM_NAMED_PARAM_LOST_BRACKET
无法引用具有 void 类型的语句表达式的结果。必须显式将其强制转换为 void。
生成该消息的代码示例：
int
f(int i) {
int j;
j = ({
int t = -1;
if (i > 10) {
t = 1;
} else {
t = 0;
}
});
printf("Statement expression result is %d\n", j);
}
消息 ID：E_VOID_STMT_EXPR_NOT_IGNORED
同一个符号多次指定了链接器的范围，实际范围为最后一个范围。
生成该消息的代码示例：
void __symbolic foo() __attribute__((visibility("global"))); /* 此处有警告：实际范围是“全局的” */
消息 ID：E_MULTIPLE_LDSCOPE_SPECIFIED
属性中存在参数错误。
生成该消息的代码示例：
void __attribute__((visibility(__hidden__))) foo(); /* 属性 "visibility" 参数必须是字符串 */
void __attribute__((visibility("blablabla"))) foo(); /* 属性 "visibility" 参数必须是以下内容之一
：hidden、internal、protected 或 default */
消息 ID：E_ATTRIBUTE_BAD_PARAM
未知的属性，将被忽略。
生成该消息的代码示例：
int c __attribute__((visibi("hidden"))); //此处有警告
消息 ID：E_ATTRIBUTE_UNKNOWN
该属性不能应用于函数。
生成该消息的代码示例：
int __attribute__((aligned(8))) f(); // 此处有警告
消息 ID：E_ATTRIBUTE_NOT_FUNC
该属性不能应用于类型。
生成该消息的代码示例：
struct s { int i; } __attribute__((visibility("hidden"))); // 此处有警告
消息 ID：E_ATTRIBUTE_NOT_TYPE
该属性不能应用于变量。
生成该消息的代码示例：
int (*f)() __attribute__((noreturn)); // 此处有警告：指针是变量
消息 ID：E_ATTRIBUTE_NOT_VAR
属性参数是未定义的标识符。
生成该消息的代码示例：
int ddd __attribute__((cleanup(f))); // 此处有警告：前面应该定义 f
消息 ID：E_ATTRIBUTE_PARAM_UNDEFINED
已将 typeof 运算符应用于位字段。
生成该消息的代码示例：
struct foo
{
int i:4;
int j:4;
};
int
main()
{
typeof(bar.i) j = 1;
}
消息 ID：E_TYPEOF_ON_BITFIELD
在函数外部使用了语句表达式。
生成该消息的代码示例：
int i = ({1;});
消息 ID：E_STMT_EXPR_OUTSIDE_FUNC
未定义 'typeof' 运算符的操作数。
生成该消息的代码示例：
int a __attribute__((aligned(sizeof(__typeof(a)))));
消息 ID：E_TYPEOF_OPERAND_UNDEF
在文件范围中的局部标签声明。
生成该消息的代码示例：
__label__ l;
main()
{}
消息 ID：E_LOC_LAB_FILE_SCOPE
输出约束不能包含 + 和 = 约束修饰符。
生成该消息的代码示例：
int var1;
__asm__ ("nop" : "+=r" (var1));
消息 ID：E_ASM_PLUS_EQUAL_MODIFIERS_BOTH
复合型不是常量，不能用作静态初始化的直接值。它被视为静态初始化程序列表。
生成该消息的代码示例：
static int i[] = (int[]) { 10, 20 };
消息 ID：E_STATIC_INIT_WITH_CMPLIT
aligned 属性的值应该为 2 的幂。
生成该消息的代码示例：
char * __attribute__((aligned(5))); // 此处有错误
消息 ID：E_BAD_ATTR_ALIGNED_VALUE
属性 "aligned" 参数应该为整型常量。
生成该消息的代码示例：
int __attribute__((aligned(foo()));
消息 ID：E_ALIGNMENT_NOT_ICON
使用 -Xc 选项时，编译器将报告不能在严格遵循 ANSI C 的程序中使用的某些关键字。
生成该消息的代码示例：
int f(int a) {
__typeof(a) b;
__asm(" nop ");
}
消息 ID：E_KW_IS_AN_EXTENSION_OF_ANSI
不能将 alignof 运算符应用于函数类型。
生成该消息的代码示例：
int i = __alignof__(int ());
消息 ID：E_CANT_TAKE_ALIGNOF_FUNC
不能将 alignof 运算符应用于函数。
生成该消息的代码示例：
int f(void); int i = __alignof__(f);
消息 ID：E_CANT_TAKE_ALIGNOF_FUNC_N
不能将 alignof 运算符应用于 void 类型。
生成该消息的代码示例：
void v(void); int i = __alignof__(v());
消息 ID：E_CANT_TAKE_ALIGNOF_VOID
不能将 alignof 运算符应用于位字段。
生成该消息的代码示例：
struct s { int x:3; } st;
int i = __alignof__(st.x);
消息 ID：E_CANT_TAKE_ALIGNOF_BIT_FIELD
输入参数约束中不允许使用 "+" 或 "=" 修饰符。
生成该消息的代码示例：
asm("nop" : "+r" (param1) : "+r" (param2));
消息 ID：E_ASM_WRONG_INPUT_CONSTR_MOD
不允许将常量变量作为 asm 输出参数。
生成该消息的代码示例：
void foo(void)
{
const int a = 5;
asm("nop" : "=r"(a));
}
消息 ID：E_ASM_OUTPUT_PARAM_MUST_BE_MVAL
当前符号已被定义为另一个符号的别名。
生成该消息的代码示例：
int f() __attribute__((alias("g")));
int f() { // 此处有错误。
return 0;
}
消息 ID：E_ALIAS_REDEFINED
如果当前声明实际上是一个定义，则不能将函数声明为别名。
生成该消息的代码示例：
int __attribute__((alias("g"))) f() { // 此处有警告。
return 0;
}
消息 ID：E_DEF_ALIAS_IGNORED
不能将开关语句的条件标签放置在嵌套语句表达式中。
生成该消息的代码示例：
int
main()
{
int i=3;
switch(i) {
case 1:
i++;
i = ({
int j = i;
j++;
case 2:
j+=({
int k=j;
k+=(j+i);
}
);
}
);
default:
break;
}
}
消息 ID：E_MISSING_SWITCH_IN_STMT_EXPR
#if 或 #elif 指令中的 defined 运算符之后必须紧跟标识符或括起标识符的 ( )。如果定义的标记是因宏替换过程而生成的，则未定义这种行为。
生成该消息的代码示例：
#define CHECK defined #if CHECK FOO int i = 1; #endif
消息 ID：E_NONPORTABLE_USE_OF_DEFINE
在指针中加上或减去一个整数时，指针和结果必须同时指向相同数组对象的元素，或指向紧靠相同数组对象的最后一个元素后面的一个位置。
生成该消息的代码示例：
void foo(int p) {
(&p)[1] = 0;
}
消息 ID：E_BAD_VAR_ADDRESS_ARITH
m、o、v、p 中的一个约束的操作数必须是左值表达式。
生成该消息的代码示例：
int b;
asm ("nop" : "m" (1, b));
消息 ID：E_CANNOT_TAKE_ADDRESS_ASM_PARAM
未使用内联 asm 语句中的输入或输出参数。
生成该消息的代码示例：
asm ("nop" : m(output));
消息 ID：E_ASM_UNUSED_PARAM
如果在相同声明中指定了多个对齐值，则应使用最大值。
生成该消息的代码示例：
int __attribute__((aligned(128))) s __attribute__((aligned(64))); // 此处有警告
消息 ID：E_CONFLICT_ALIGN_MODIFICATION
符号对齐方式不能小于其类型的对其方式。
生成该消息的代码示例：
struct S {
...
} __attribute__((aligned(128)));
struct S s1 __attribute__((aligned(64))); // 此处有警告。
消息 ID：E_OBJECT_ALIGN_LESS_THAN_TYPE
声明对齐方式不能小于其类型的对齐方式。
生成该消息的代码示例：
typedef int __attribute__((aligned(64))) ai64; int align = __alignof__(ai64 __attribute__((aligned(32)))); // 此处有警告
消息 ID：E_CUR_ALIGN_LESS_THAN_BASE
忽略指针前面的显式对齐方式。
生成该消息的代码示例：
int __attribute__((aligned(64))) * p; // 此处有警告
消息 ID：E_USELESS_PTR_TO_ALIGNED
不允许通过重新声明来更改对齐方式。
生成该消息的代码示例：
int __attribute__((aligned(64))) a; int __attribute__((aligned(32))) a; // 此处有警告
消息 ID：E_CONFLICT_ALIGN_REDECL_CURR
不允许通过重新声明来更改对齐方式。
生成该消息的代码示例：
static int __attribute__((aligned(64))) a; int __attribute__((aligned(32))) a; // 此处有警告
消息 ID：E_CONFLICT_ALIGN_REDECL_PREV
无法为参数设置非缺省的对齐方式。
生成该消息的代码示例：
typedef int __attribute__((aligned(128))) i128; void foo(i128 i1); // 此处有警告
消息 ID：E_CANT_SET_NONDEF_ALIGN_PARAM
无法为函数返回类型设置非缺省的对齐方式。
生成该消息的代码示例：
typedef int __attribute__((aligned(128))) i128; i128 foo(); // 此处有警告 int __attribute__((aligned(64))) foo(); // 此处有警告
消息 ID：E_CANT_SET_NONDEF_ALIGN_FUNC
无法为自动变量设置非缺省的对齐方式。
生成该消息的代码示例：
typedef int __attribute__((aligned(128))) i128;
void boo() {
i128 i2; //此处有警告
.....
}
消息 ID：E_CANT_SET_NONDEF_ALIGN_AUTO