PClint错误码大全

1.1.1.1.1 PC-LINT中的各种错误信息都有一个相关的错误号，其中各个错误号的分配区间如下：

表1:PC-LINT错误号区间分配

错误类型 语法错误 内部错误 致命错误 告警 提示信息 可选的注解 错误号－C 1 -199 200-299 300-399 400-699 700-899 900-999 错误号－C++ 1001-1199 1400-1699 1700-1899 1900-1999 告警级别 1 0 0 2 3 注：其中200-299号告警为PC-LINT的内部错误，一般不会发生，

1.2 C语法错误

1.2.1

－1―未关闭注释 (位置) ―2―未关闭的引号 －3－#else 没有一个#if

－4－太多的#if 嵌套层次

文件结束的时候，仍然有一个未关闭的注释存在，打开的这个注释位置将被显示出来。

1.2.2

在行尾的时候，仍然存在一个同行的未关闭的引号（单引号或双引号）。

1.2.3

在一个区域内有一个#else ，但是没有一个#if, #ifdef 或#ifndef。

1.2.4

检测出一个内部的限制，有关#if的嵌套层次 (包括 #ifdef和#ifndef)。

1.2.5

－5－太多的#endif －6－堆栈溢出

出现一个#endif ，但不是#if 或 #ifdef 或#ifndef.的。

1.2.6

一个内置的不可展开的堆栈被过分扩展。可能是太多的嵌套的#if 语句、#includes 语句

(包括所有的递归的#include 语句)，static块(有限制的括号) 或#define置换。

1.2.7

－7－不能打开include的文件：FileName

FileName 是不能打开的include文件的名字。，可以见flag fdi (见章节5.5 标志选项)，选项 -i... (见章节5.7其它选项) 和章节13.2.1 INCLUDE 环境变量。

1.2.8

－8－未关闭的#if (位置) －9－太多的#else在#if (位置)

一个#if (或 #ifdef 或 #ifndef) 没有遇到相应的#endif。位置是#if.的位置

1.2.9

一个给定的 #if 包含一个 #else，然后轮流流被紧跟另一个 #else 或一个 #elif。错误消息给出#if语句条件包含异常的行号

1.2.10 －10－ 期望的字符串

字符串是期望的记号，期望的记号不能被发现。当一定的保留字没有被认出时，给出这条消息，例如：

int __interrupt f();

将收到一个 Expecting ';' message at the f ，因为它认为你想声明__interrupt。 改正的方法是建立一个新的保留字使用 +rw(__interrupt)。 同样，保证使用正确的编译器选项文件。见章节15.10 奇怪的编译器.

1.2.11

－11－超出大小范围 －12－需要 < or “

在#include l行确定的文件名的长度超过了FILENAME_MAX 字符。

1.2.12

-在一个#include I被检测出来后和宏置换被执行后，期望一个文件的规范格式 或 \filename\

1.2.13 －13－不好的类型

类型形容词例如long、unsigned 等等。不能应用到紧跟的类型。

1.2.14 －14－ 符号 'Symbol' 以前定义过(位置)

符号被定义第二次。提供出以前定义的位置，如果这是一个暂定的定义（没有初始化），这个消息可以用+fmd flag抑制。（章节5.5Flag 选项）.

1.2.15

－15－符号'Symbol'重新被声明(TypeDiff) (位置)

符号被以前声明过或在其它模块定义过(其它位置)的类型和在当前位置的声明的类型不同。参数TypeDiffr提供了类型怎么不同的进一步信息(见章节17. 信息).

1.2.16 －16－不认识的名字

一个# 指示符后没有跟着一个可认识的单词。如果这不是错误使用+ppw 选项(章节5.7其它选项).

1.2.17 －17－未被承认的名称

A non-parameter is being declared where only parameters should be. 1.2.18 －18－符号重新声明(TypeDiff) 和此位置冲突

一个符号被重新声明。参数TypeDiff 提供类型不同的进一步信息(见Chapter 17. 信息)。位置是先前定义的位置。

1.2.19 －19－无效的声明

一个类型独自的出现而没有相关的变量，类型不是struct、union 和 enum. 一个双分号能导致这个：

int x;;

1.2.20 －20－非法使用 =

一个函数声明后紧跟一个符号.

1.2.21

－21－期望{

对于不确定大小的数组的初始化必须以一个左括号开始。

1.2.22 －22－非法的操作符

发现一个一元操作符紧跟一个操作数，这个操作符不是一个post 操作符。

1.2.23

－23－期望“：”

-碰到一个 ? 操作符， o但是没有紧跟一个期望的 : 操作符。

1.2.24 －24－期望一个表达式，但是得到一个字符串

发现一个在一个表达式开始的操作符，但是它不是一个一元操作符。

1.2.25

－25－非法的常量

在一个字符常量中遇到太多的字符。

1.2.26 －26－期望一个表达式，但是得到一个字符串 1.2.27

－27－非法的字符（0xff）

源代码中发现非法的字符。消息中提供十六进制代码。 假定是一个空格。如果你使用奇怪的字符在标识符名称中，你将得到这个信息。你可以使用选项 - ident (见章节5.7其它选项.)

1.2.28 －28－重定义一个符号（符号位置）

给出的在以前（Location）声明的冒号前的标识符不是一个label.

1.2.29

－30－期望一个常量

期望一个常量，但是没有得到。可能是在case 关键字后， 数组维数、bit field 长度、 枚举指、#if 表达式等等.

1.2.30 －31－重新定义一个符号（Symbol' conflicts with Location） 数据对象或函数在此模块中以前定义过又被定义。

1.2.31 －32 －Field 大小 (member 'Symbol') 不能是0

给出的field 的长度是非正(0或负数).

1.2.32 －33－ 非法常量

当一个8进制的常量包含数字8或9时，这是一个错误的形式。

1.2.33 －34－ 非常量初始化

-在一个static数据项中发现非常量初始化.

1.2.34 －35－ 初始化有副作用

在一个static数据项中发现有副作用的初始化.

1.2.35 －36－ 重新定义存储类的符号 'Symbol' 和位置Location冲突 对象的存储类被改变.

1.2.36 －37－ 枚举值'Symbol' 不一致(和位置Location冲突)

枚举值不一致.

1.2.37 －38－符号 'Symbol' 的偏移量不一致(Location)

很多类或结构比早期的声明出现在不同的位置(从结构开始的偏移量).可能因为数组维数从一个模块到另一个模块的改变.

1.2.38 －39－ 重新定义符号 'Symbol' c和位置 Location 冲突

struct 或 union 被重新定义.

1.2.39 －40－ 没有声明标识符'Name'

在表达式内, 一个标识符在以前没有被声明并且没有紧跟一个左括号. Name 是标识符的名称.

1.2.40 －41－ 重新定义符号'Symbol'

一个宏或函数的参数被重新定义.

1.2.41 －42－期望一个语句

1.2.42 －43－变量 'Symbol'虚的类型

在一个实例的上下文中发现虚类型例如void类型.

1.2.43 －44－需要一个switch

在一个switch外出现case或default语句.

1.2.44 －45－错误的使用register

一个变量被声明为register ，但是它的类型不应该是register (例如一个函数).

1.2.45 －46－域类型应该是int

在结构中位域应该是类型为unsigned 或 int. 如果你的编译器允许其它类型，例如char, 那么抑制这条信息.

1.2.46 －47－错误的类型

一元减需要一个算术操作数.

1.2.47 －48－错误的类型

一元的 * 或左手边的指针 (->)

操作符需要一个指针操作数o.

1.2.48 －49－期望一个类型

在原型内只有类型被允许。原型是圆括号内有一系列的类型的函数声明. 处理器是在它

检测到至少圆括号内的一个类型时，期望更多的类型或关闭的右圆括号.

1.2.49 －50－试图取非左值的地址

一元 & 操作符需要一个左值(对分配操作符左手边合适的值).

1.2.50 －51－期望整型

一元 ~ 期望一个整型(signed 或unsigned char、short、int、或long).

1.2.51 －52－期望一个左值

自动递减(--) 和自动递增(++) 操作符需要一个左值（对分配操作符左手边合适的值）。记住括号不产生左值。因此

++(char *)p;

按照ANSI标准是非法的。一些编译器允许这个结构，允许你使用+fpc 选项(指针括号是左值). (见章节5.5Flag选项.)

1.2.52 －53－期望一个标量

自动递减(--) 和自动递增(++) 操作符可能只应用于标量（算术和指针）或这些操作符定义的对象.

1.2.53 －54－被0除

常量0 w被用于除操作符 (/) 或取余操作符的右手边。

1.2.54 －55－坏类型

上下文需要一个标量、函数或结构(除非-fsa).

1.2.55 －56－坏类型

需要标量类型和指针的加/减操作符可能被加到指针中。

1.2.56 －57－坏类型

Bit 操作符( &, | 和 ^ ) 需要require 整型参数.

1.2.57 －58－坏类型

错误的参数给相关的操作符；这些通常需要两个标量和指针，不能和整数比较(除非常量0).

1.2.58 －59－坏类型

移位的数量必须是整数.

1.2.59 －60－坏类型

被移位的值必须是整数.

1.2.60 －61－坏类型

上下文需要一个布尔值. 布尔值必须是算术或指针形式.

1.2.61 －62－对操作符':'矛盾的的类型(TypeDiff)

? :的第二和第三个参数必须是一致的类型.

1.2.62 －63－期望一个左值

分配操作符期望它的第一个操作数是一个左值. 请注意a cast removes the lvaluedness of an expression. 参考flag +fpc 在章节5.5 Flag选项.

1.2.63 －64－类型不匹配(Context) (TypeDiff)

T在分配中有类型不匹配(或隐含分配，见Context)。TypeDiff 确定类型的区别. 当分配一些种类的指针时用选项 -epn, -eps, -epu, -epp (章节5.2错误禁止选项) 来抑制这个消息.

1.2.64 －65－期望一个成员名称

在一个 (.) 或 (->) 操作符后，一个成员名称应该出现.

1.2.65 －66－坏类型

用一个不允许的void 类型。如果一个void 类型放置在一个原型内，那么它必须只能是原型内的仅有类型。(参考错误号49.)

1.2.66 －67－不能从Type到 Type计算 试图非标量到整数计算.

1.2.67 －68－不能从Type到 Type计算 试图非标量到浮点数计算.

1.2.68 －69－不能从Type到 Type计算 涉及结构到结构或其它对象间的不匹配的转换.

1.2.134 －149－ C++ 构造'String' 在代码中发现

一个非法的结构被在C代码中发现。它看起来象适合于C++。 1.2.135 －150－ 记号'String' 不期望 String

遇到一个不期望的记号。发生后，被标识为第二个信息的参数。

1.2.136 －151－记号 'Name' 和抽象类型不一致

在一个上下文中，抽象类型被允许在一个转换内或一个sizeof 后，在开始分析抽象类型后，发现一个标识符。例如：

x = (int y) z;

1.2.137 －152－ 丢失Lob 基础文件 'file name'

指示的文件被确定为一个lob 的基础文件，通过选项 -lobbase()产生。在输出中，如果这个lob基础文件丢失，给出这个信息。情形是可纠正的，通过简单的产生丢失的 lob 输出。在makefile中给出合适的从属这可能是一个问题 。在输出中，最可能导致这个信息的是基础文件是过时的。一个lob文件中的无用代码信息被读取，不匹配一个早嵌入在基础文件中的相似的代码。输入 lob 文件一个被认为错误，应该被重新产生。见章节7.lint目标模块

1.2.138 －153－ 不能创建临时文件

当基于一个lob基础文件产生一个lob 输出文件时产生这个信息，它被首先写入一个临时文件，这个临时文件通过C库函数 tmpnam()产生。

1.2.139 －154－ 不能估计类型'String', 假定为int

信息中的String 是第二个参数，或者是一个printf_code 选项，或者是一个scanf_code 选项。当使用了，它被认为是一个类型，不幸的是，这个类型不能被标识。

1.2.140 －155－ 在一个表达式内忽略 {…}系列，假定为0

在一个表达式内的braced

系列是某些编译器(特别是GCC)的非标准的扩展。在内，我

们对待这个braced 系列为等于零的常量。如果你仅仅抑制这个信息，这意味着我们可以lint 这个结构。

1.3 内部错误

编号为200-299的一些矛盾被FlexeLint/PC-lint 发现。这些可能不是用户的错误，可能是Gimpel Software的问题。

1.4 致命错误

这些错误是通常致命的，限制这些错误被检查出来是不可能的。但是，这些标记有‘*’的错误可以被限制显示，例如： -e306

1.4.1

－301－堆栈溢出

当处理声明时，有一个堆栈溢出。发现大约50 个嵌套的声明。例如，如果一个 ' /' 紧跟 50 个连续的'*' 被引入一个盒子似的注释，而且如果 '/' 被省略 ，将产生这个信息。

1.4.2

－302－ 超过可用的内存

－303－ 字符串太长 (尝试 +macros)

主内存被耗尽。

1.4.3

一个单独的 #define 定义或宏调用超过一个内部的限制 (超过 409字符)。诊断指出的问

题可以被使用一个选项校正。

1.4.4 －304－被破坏的目标文件，代码Integer, 符号=String

一个PC-lint/FlexeLint 目标文件是明显的被破坏的。请删除这个目标模块，并重新创建

它，使用选项 -oo .见章节7.3 产生一个LOB. 特殊的代码标识符号和符号名列表是可选的信息后缀作为帮助技术支持诊断问题。

1.4.5

－305－ 不能打开模块 'file name' －306－* 以前遇到的模块 'FileName' －307－ 不能打开间接文件 'FileName' －308－ 不能写到标准输出

这是最不寻常的。

file name 是文件名称。这个名称的模块不能为读被打开。可能你拼写错误名称。

1.4.6

FileName 是模块的名称。这个名称的模块以前遇到过。这可能是用户的一个失误。

1.4.7

FileName 是间接文件的名称。这个名称的间接文件(结尾是 .lnt) 不能为读被打开。

1.4.8

stdout 被发现等于NULL。

1.4.9

－309－* #error ...

#error 指示被遇到。省略号反映最初的行。通常地处理在这点中断。如果你设置 fce (连

续#error) 标志。处理将继续。 1.4.10 －310－声明太长：'String...'

发现一个单独的声明对于内部的缓冲太长(差不多2000 个字符)。当试图使用选项-o... 写出到声明时发生。声明的最初的30 个字符给出在String。代表性地，这通过一个非常长的结构，子结构是没有标签的导致的。首先标识导致困难的声明。如果一个 struct 或 union, 分配给一个没有名称的子结构或子联合。一个typedef 能被用于减少这个声明的大小。

1.4.11 －312－ lob是荒废的或外来的版本号

一个lob被PC-lint/FlexeLint以前的或不同的版本产生。删除这个 .lob 文件，使用你的新版本的PC-lint/FlexeLint重新创建它。

1.4.12 －313－ 太多文件

PC-lint/FlexeLint能处理的文件的数量超过内部的限制。FlexeLint 用户可以重新编译它的系统以增加这个限制。在 custom.h内寻找符号 FSETLEN。 目前，文件的数量限制到6400。

1.4.13 －314－* 以前使用的 .lnt 文件：FileName

指定名称的间接文件以前遇到过。如果这不是一次事故，你可以抑制这个信息。

1.4.14 －315－ 超过信息限制 (见 -limit)

超过信息的最大量。通常没有限制除非强加限制使用选项 -limit(n) (见章节5.7 其它 选项.)

1.4.15 －316－ 写文件\file name\时错误

给定的文件不能输出打开。

1.4.16 －321－ 声明堆栈溢出

当处理一个声明时在堆栈使用于特定的数组、指针、函数或引用修饰符时发生堆栈溢出。

1.4.17 －322－* 不能打开包含文件 FileName

FileName 是不能被打开的包含文件的名称。目录寻找通过选项：－i (见章节 5.7其它选项.)+fdi (章节5.5标志选项) 和 INCLUDE 环境变量控制。这是一个可以禁止的致命信息。如果使用选项-e322 ，错误信息 7 将踢掉砸开。一个诊断将被发布，但是处理将继续。

1.4.18 －323－记号String 太长

试图为以后的重用存储一个记号，超过一个固定的大小缓冲。(通过大小M_TOKEN 来控制)。

1.4.19 －324－太多的符号Integer 遇到太多的符号。打断内部的限制。

1.4.20 －325－不能重新打开文件 'file name'

在大量的嵌套的include的情况下，在外部边缘的文件需要在一个新的被打开前被关闭。这些外部文件然后需要被重新打开。当试图重新打开这样的一个文件时，发生一个错误。

1.5 C告警信息

1.5.1 －401－标示符“Symbol”之前并没有被声明为静态存储类型

此符号之前不是以静态存储类型的形式声明，此种形式从技术上违背了ANSI标准，某些编译器会默认此种形式，认为此符号是静态。

1.5.2

－402－静态函数“Symbol” (Location)没有被定义 －403－静态符号“Symbol”被异常类型的修改者修改 －404－在文件 'FileName' 中结构没有定义完成

在当前模块中被引用的此静态函数没有被定义，仅仅进行了声明。

1.5.3

某些类型修改者，如，修改者类型为_export，与静态存储类型不一致。 1.5.4

结构，联合体，枚举类型需要在同一个头文件中被定义完成。不要跨文件定义和声明结构，联合体，枚举类型。

1.5.5

－405－＃if之类的宏开关没有在同一个头文件'FileName'被关闭

错误如：

文件a

#if _LOGIC_BOARD == _LOGIC_CHMHDR_CPUF ... 文件b

#elif _LOGIC_BOARD == _LOGIC_CHMHDR_CPUR ... #endif

1.5.6

－406－注释没有在同一个头文件'FileName'被关闭。

注释没有在同一个头文件被关闭。错误如： 文件a

/* ************************************** 文件结束

1.5.7 －407－不一致地使用tag 'Symbol' ，在 Location 冲突

同一个标示符，在不同的位置被定义认为不同的类型，如联合体，结构体，枚举类型。 例如：

struct tag *p;

union tag *q;

1.5.8

－408－switch表达式中，类型不匹配

表达式中的case和switch语句类型没有达成同一 如： typedef enum {

HRPDDEFS_ALPHA = 0, HRPDDEFS_BETA, HRPDDEFS_GAMMA,

HRPDDEFS_NUMBER_OF_SECTORS } HRPDDEFS_SectorType;

HRPDDEFS_SectorType m_tSector; switch (m_tSector) {

case 1: ... break; case 4: ... break; default:

...

return FALSE; } 1.5.9

－409－期望是一个指针或者数组

此种类型i[...]的表达式中，发现i是一个整型变量，这种情况可能是合法的，与脚本操作符有关。例如：ｉ是整型，ａ是数组，那么i[a]是合法的，但属于异常。如果这种情况是你编码风格，请屏蔽之。

1.5.10

－410－size_t 不是fzl或者fzu类型，使用 'Type'

如果你以前试图设置过sizeof选项为+fzl, -fzl, or -fzu，后来size_t声明和此种设置相冲突，此种告警有可能发生。

fzl siZeof-is-Long flag OFF

fzu siZeof-is-Unsigned flag ON

这通常意味着你试图使用你自己系统的头文件对其它系统lint程序。如果是这样，我们建议你创建一个目录放置其它系统的头文件，在那个目录里置换size_t ，使用那个目录lint程序。

1.5.11

－411－ptrdiff_t不是fdl期望的选项, 使用 'Type'

此种告警可能发生，如果你以前试图设置过指针的差异类型，但后来ptrdiff_t的声明与以前设置相冲突。参考错误信息410。

1.5.12

－412－模糊的格式表达式'%X'

在scanf系列中，%X含义不清晰，在Microsoft C中，它代表%lx，在ANSI C，它代表 %x。此种模糊表达式不应该在等级程度高的代码中出现。

1.5.13

－413－在操作符号“String”引用中，左参数或者右参数里，可能使用NULL指

针

一个null 指针(一个可能值是0的指针) 被不合适的使用。参考信息613和794，和章节9.2数值跟踪

1.5.14

－414－可能被０除

除函数(/)或取模函数(%)的第二个参数可能是0。见章节9.2数值跟踪

1.5.15

－415－操作符'String'试图超出指针的范围

一个超出范围的指针。String 指定操作符. 参数'Integer' 给出指针能达到的界限。它通过单元的给出的指向对象的指针大小来度量。这个值和最后的好数据相关，因此应该始终大于零。 例如:

int a[10]; a[10] = 0;

溢出信息的结果包含短语'1 beyond end of data'. 见章节9.2数值跟踪

1.5.16 －416－ 操作符'String'创建出越界的指针 ('Integer' beyond end of data)

创建出一个越界的指针。参考信息415。例如:

int a[10]; ... f( a + 11 );

这里，创建出一个违法的指针值。注意：指针a+10 不被PC-lint/FlexeLint 认为是一个越界的指针。因为ANSI C 明确地允许指针可以超越数组。访问a+10、或者形式 *(a+10)、或者更熟悉的a[10], w将被认为是错误的，但是如果是那样的话，信息415 would be issued. 见章节9.2数值跟踪.

1.5.17

－417－整型常量'String'比long long int还要大

最长可能的整型缺省是8个字节。 例如：0xFFFF0000FFFF0000F

1.5.18 －418－传递NULL指针给引用的函数

传递NULL指针给引用的函数Symbol.。正被讨论的参数在上下文中被给出。函数或者是一个库函数或者是一个用户函数被设计为不接受一个NULL指针，通过选项 -function. 见章节10.1 函数模仿和章节10.2.1 可能的模仿.

结构和语句和其它控制子句和它的范围内的括号被期望有少点的缩排。如果你的程序中的tab的值不是8个空格，你可以使用-t 选项 (见章节11.3缩排检查).

1.5.59

－526－符号“Symbol”没有定义

外部的名称被引用，但是没有被定义，而且没有程序在任何库头文件中，或者出现在库模块中。对单元检查，这个信息被抑制。如果 Symbol 是一个库符号，确保它被在你所包含的头文件中声明。而且确保这个头文件被作为PC-lint/FlexeLint 的库头文件。做为选择，这个符号可以被声明在一个库模块中，见章节6.1库头文件和章节 6.2 库模块了解进一步的讨论。

1.5.60 －527－不能达到的

程序的部分代码不能达到。

1.5.61

－528－符号“Symbol”没有引用

－529－在函数定义的符号“Symbol”没有引用 －530－符号“Symbol”在使用之前没有进行初始化 －531－对于标示符“Symbol”来说，位域存储空间太大

static 变量或 static函数在被声明后没有在模块内引用。

1.5.62

变量被声明了但是没有在函数内引用。

1.5.63

一个auto 变量在使用前没有被初始化。 1.5.64

结构中给出的位域大小超过了一个 int的大小。

1.5.65 －532－函数“Symbol”的返回值不一致

函数的声明(或定义) 不以前的语句应用于不同的返回模式 (函数的返回模式和函数是否返回一个值有关。)。 从一个声明中察看函数返回是否是void来觉得函数的返回模式，或者观察是否给出一个明确的类型。见 fvr 和 fvo 标志在章节5.5标志选项.。

1.5.66

－533－函数“Symbol”在此处是否应该有返回值

和以前的语句相比应用不

在一个函数内的返回语句(或在函数的结尾缺少一个return )

同的返回模式。参见fvr、fvo 、fdr 标志在章节5.5标志选项.

1.5.67

－534－函数返回值被忽略

例如，在一个自己的语句中或逗号操作符的左手边。试试：(void) function(); 要调用一个函数并忽略它的返回值，见fvr、fvo 和 fdr 标志在章节5.5标志选项。 1.5.68 －537－重复包含头文件

文件被正常处理甚至给出这个信息。如果它是你的标准实践要重复包含文件，那么抑制这个信息。

1.5.69

－538－ 数组大小超过

数组大小等于或者超过64k 字节

1.5.70 －539－不期望从当前位置积极缩排

当前行发现被积极的缩排，子句可怀疑的没有控制行。例如：

if( n > 0 ) x = 3; y = 4;

对y = 4;将发布这个告警。位置引用是if子句。见章节11.3缩排检查

1.5.71

－540－分配的存储空间太小

字符串初始化超过了其所分配的内存的大小。 如： char acTemp[5] = \

1.5.72

－541－分配的存储空间太小

字符常量（用\\xddd or \\xhhh确定的）的存储空间长度等于或者超过字节的bit数2**b。 －sb选项确定，缺省是-sb8。

1.5.73

－542－超过bit字段的存储大小

试图分配一个值到看起来太小的位域。这个被分配的值或者是比目标大的另一个位域的值，或者是一个太大的数字值。你可以转换这个值到一个普通的无符号类型来抑制这个信息。如果这个位域是一个int。例如：

struct { int b : 1 } s;

s.b = 1; /* Warning - - requires 0 or -1 */

这种情况的解决方法是使用 'unsigned' 代替 'int' 在 b 的声明中。

1.5.74

－544－此处endif 或者else后面没有紧跟EOL符号（行结束符号）

endif 或者 else 后面应该紧跟EOL符号。如：

#if ----

#endif if () { --- }

一些编译器明确地允许注释紧跟#endif。如果你按照协定，可以关闭这个消息。

1.5.75

－545－ & 用法值得怀疑

试图取数组名的地址。这种表达式是官方合法的(K&R C )， 但是没有一致的使用，因此，令人怀疑，但是，表达式在标准C中上合法的，指定一个指针到数组。例如：

int a[10]; int (*p) [10];

那么 a 和 &a, 作为指针，都代表同样的位模式，但是 a 是一个指向 int 的指针，&a 是一个指向数组10个int 的指针。只有 &a 可以被分配给 p 没有抱怨。如果你以这种方式使用& 操作符，我们建议你抑制这个信息。

1.5.76

－546－& 用法值得怀疑

试图取函数名的地址。因为函数名自己被提升到地址，使用 & 是多于的，可能导致错误。

1.5.77 －547－重复定义符号“Symbol” 指出的符号以前定义过(通过 #define)为其它值。

1.5.78

－548－有if没有else －549－转换做法令人怀疑

发现一个if(e); 的结构，没有紧跟一个 else。 这很可能是一个不希望的分号导致。

1.5.79

执行了指针和一些列举的类型转换。这可能是一个错误，检查你的代码，如果这不是一

个错误，在最终的转换前转换项为一个中间的格式 (例如一个 int 或一个 long)。

1.5.80

－550－符号“symbol”被赋值后没有被使用

一个变量 (一些函数的局部变量)没有被访问。这意味着这个变量的值一直没有被使用。可能这个变量被分配了一个值，但是从没有被使用。注意：一个变量的值通过自增或自减不被认为是被访问了的，除非自增或自减在一个表达式内，使用结果的值。同样应用于格式的结构：

var += expression。如果取变量的地址，它的值假定被访问。一个数组、结构、联合被认为访问了的，只要其中的部分被访问了。

1.5.81

－551 －静态符号“symbol”被赋值后没有被使用

一个变量(在模块水平被声明为 static ) 没有被访问，尽管变量被引用。见信息550 对访问的描述。

1.5.82

－552－外部符号“symbol”被赋值后没有被使用 －553－预处理变量“Name”没有定义，假设是0

一个外部变量没有被访问，尽管这个变量被引用了。见信息550 对访问的描述。 1.5.83

指示的变量在以前没有在一个#define 语句中定义，但是它却被使用在预处理条件格式 #if 或 #elif 中。按照惯例所有的变量在预处理表达式中应该被预先定义。这个变量被假定值为0。

1.5.84

－555－ K&R没有#elif

被设置。或者不要设置这个标志，或者不要

#elif 指示被使用，K&R 预处理标志 (+fkp)

使用#elif。

1.5.85

－556－ “#”预处理指令没有对齐

在一个行内的预处理指令缩排，并且K&R 预处理标志(+fkp) 被设置。或者不要设置这个标志，或者不要缩排#。

1.5.86

－557－编译器无法识别的格式

由printf, fprintf, sprintf, scanf,fscanf,

或sscanf函数提供的格式字符串不认识。它不是一个

标志格式，也不是一个用户定义的格式(见printf_code和scanf_code，章节5.7其它选项).

1.5.87

－558－ 格式字符串与参数数目不统一

用于printf, sprintf, fprintf, scanf, fscanf 或sscanf 的参数数目和期望的分析格式字符串的数目不一致。

1.5.88

－559－ 格式字符串与参数不统

printf, sprintf或fprintf

等等给出的参数和期望的分析格式字符串不一致。参数计算从1开

始，包括文件、字符串和格式说明。例如：

sprintf( buffer, \

将在参数数字3上显示错误，因为常量371不是一个浮点数。

1.5.89

－560－没有参数，Integer参数应该是一个指针

scanf或printf family函数族的一个函数给出的参数应该是一个指针。对于scanf函数族，响

应所有的格式说明的参数应该指向一个可以被修改的区域。(接收扫描的结果)。对于printf 函数族，响应%s或%n 的参数也需要是指针。参数计算从1开始，包括文件、字符串和格式说明。例如：

scanf( \

将产生告警，第二参数应该是个指针。

1.5.90

－561－调用scanf, sscanf, or fscanf函数时格式化字符串与参数格式不一致

scanf, sscanf或fscanf scanf( \

给定的参数是一个指针，和预期的格式字符串的结果不一致。参数

计算从1开始，包括文件、字符串和格式说明。例如：如果n 被说明为int 那么： 对第二个参数产生告警。

1.5.91

－562－函数原型中需要省略号（…）

在一个函数原型内，一个逗号跟着一个右括号。这在一些编译器中等于一个省略号 (三个点) ，这在 PC-lint/FlexeLint中是假定的。如果你的编译器不接受省略号但是接受这个假定，那么你将抑制这个信息。

1.5.92

－563－标签“symbol”未被引用 －564－变量依赖于求值的顺序

Symbol 在引用的位置 Location表现为一个标签，但是没有语句引用这个标签。

1.5.93

在同样的表达式中变量修改和访问的结果取决于计算的顺序是从左到右还是从右到左。一个例子：

n + n++ 因为没有保证在递增n之前首先访问n 。其它的典型例子参考章节11.1计算顺序and 章节11.5volatile检查。 变量也对在表达式中的重复使用进行检查。

1.5.94

－565－ Tag“symbol“未定义，假定在文件级别的范围

tag出现在一个原型内，或内部的块中，而且在外部（文件水平）以前没有见过。对于大多数编译器，这不是一个错误，你可以安全地抑制这个信息。另一方面，要严格按照标准C，你应该在程序早期放置一个小声明桩。例如：

struct name;

足够保留一个对name的在符号表中的位置。

1.5.95

－566－printf/scanf系列函数中的格式字符串不一致或冗余

这个信息是对printf/scanf 函数族的格式化进行检查。在格式说明中发现的指示的字符Char和在通用的格式说明中的早些的字符不一致或多余。例如，一个格式包含\将产生字符's' 指示的这个错误，这是因为长度修改器被设计成用于整型或浮点型转换，没有字符串转换。这些字符通常被编译器忽略。

1.5.96

－567－ printf/scanf系列函数中的格式字符前缺少数字

这个信息是对printf/scanf 函数族的格式内的格式说明检查。在扫描格式的特定点期望一个数字域或星号。例如：%-d 需要一个在格式域的十进制整型的左边调整，但是既然给出没有，这个需要就是没有意义的。

1.5.97

－568－非负数不可能小于0

比较格式：

u >= 0 0 <= u u < 0 0 > u

是可疑的，如果 u 是一个无符号量，或一个量断定永远不会小于零。参见信息775。

1.5.98

－569－赋值时的信息丢失

从一个常量到一个整型变量的一个分配(或隐含分配，见Context)不够大去拥有常量。

1.5.99

－570－赋值时符号位的丢失

从一个负值常量到一个无符号量的一个分配(或隐含分配，见Context)。转换这个常量为unsigned 将去除这个诊断，但是这是你希望的吗。

1.5.100

－571－可疑的转换

通常这个信息的发布针对格式的转换：

(unsigned) ch

这里 ch 被声明为 char ,而char 是有符号的。尽管转换可能看起来阻止对 ch 的符号扩展，它没有按照正常的C语言的提升规则，ch 首先被转换为 int, 要抑制符号扩展，你可以使用：

(unsigned char) ch

另外，如果符号扩展是你希望的，你仅仅希望抑制这个告警，你可以使用：

(unsigned) (int) ch

1.5.101 －572－位移值太大

一个量被右移，它的精度等于或小于移位的值。例如：

ch >> 10

将得出这个信息，如果 ch 类型是 char ，这里 char 是一个小于 10 比特宽度(通常情况下)的类型。在这种情况下抑制这个信息，你可以转换移位的量的类型的长度至少是移位的值。常量的精度(包括枚举常量) 从需要在它的二进制表示的比特的数量决定。通过转换精度不会改编，所以仍旧产生 (unsigned) 1 >> 3 信息。但是通常表达式例如 1>>3能合法发生的唯一的方式是通过一个宏。在这种情况下使用： -emacro。

1.5.102

－573－在除法中，混合使用有符号数和无符号数

/ 或 % 的一个操作数是有符号的，另一个是无符号的；甚至有符号的量可能是负值。例

如：

u / n

这里 u 是一个无符号的，n 是一个有符号的，将发布这个信息，但是：

u / 4

将不会，甚至 4 是名义上地的 int。在任何情况下混合有符号量和无符号量都不是个好主意，但是， 对于除法，一个负值可能产生破坏。例如：

n = n / u

如果 n 为 -2 ， u为 2，不是分配 -1 到 n ，而是分配一些非常大的值。要解决这个问题，或者转换整数为无符号的如果你知道它永远不会小于零，或者转换 unsigned 为一个整数如果你知道它永远不会超过整数的最大值。

1.5.103

－574－在关系表达式中，有符号数和无符号数混合使用

四个关系操作符是：> >= < <=

其中的一个关系操作符的操作数是有符号的，其它的是无符号的；而且有符号的量是一个负值。例如： if( u > n ) ...

这里 u 是一个无符号的，n 是一个有符号的， 将得出这个信息，但是： if( u > 12 ) ...

将不会 (甚至 12 是一个正式的 int ，明显它不是负值)。混合有符号和无符号的量在一起在任何情况下不是个好主意，但是，对于四个关系操作符，一个负值可以产生模糊的结果。例如，如果条件：

if( n < 0 ) ...

为真，那么相似的：

u = 0; if( n < u ) ...

为假，因为提升到无符号使得 n 非常大。要解决这个问题，或者转换整型为 unsigned 如果你知道它永远不会小于零，或者转换 unsigned 到一个 int 如果你知道它永远不会超过 int 的最大值。

1.5.104

－575－枚举类型常量范围超过整型变量范围 －577－混合内存模式

对于很多编译器，一个枚举常量的值被限制到那些 signed 或 unsigned int 内的值。

1.5.105

指出的信息需要在部分所有其它模块被处理后改变内存模式。内存模式选项应该在模块处理前被确定。最通常导致这个错误是因为在确定标准库后确定内存模式。

1.5.106

－578－“Symbol”的声明隐藏了此符号其它地方声明

一个局部符号和一个全局符号（或可能另一个局部符号）有相同的名称。这可能很危险。这是故意的？最好重命名这个局部符号。

1.5.107

－579－函数参数省略号前面的参数为无效类型

当使用一个省略号时，省略号前的类型应该不是一个将默认提升的类型，例如char,short

或 float。 原因是很多编译器的变量参数方案(使用stdarg.h) 将中止。

1.5.108

－580－函数“Symbol”声明导致原型畸变

在一个块内函数的声明隐藏了一个在外部范围的声明，内部的声明没有原型，外部的声明有。一个通常的误解是作为结果的声明是两个声明的合成，这只是当声明是在同一范围，不是在嵌套的范围内。如果你不关心声明，你可以抑制这个信息。你将仍旧得到其它的类型区别告警。

1.5.109

－581－选项“String”过时了，不应该再使用 －582－esym (或者 emacro)不应该包含“(\

无论何时当我们遇到一个选项看起来要有害时发布这个信息。'String' 是有问题的选项。

1.5.110

。例如，要抑制信息 534 ，当调用 f(int) 使用选项-esym(534,f) ， 甚至如果 f 被重载。

esym 中提供的名称应该不包含一个 ( 1.5.111

－601－对于给定的symbol没有给出其类型

一个声明没有明确的类型。假定为 int 。这是一个错误吗？这个很容易发生，如果一个逗号代替分号， 例如：

double radius, diameter;

程序员写为：

double radius; diameter;

这个信息将被发布。

1.5.112

－602－注释嵌套使用

这是故意的吗？或者是一个注释结束被不注意地删除了？如果你希望PC-lint/FlexeLint

识别注释嵌套，你应该使用选项+fnc设置注释嵌套标志。那么这个告警将不被发布。

1.5.113

－603－ “symbol”未初始化

名称为’ symbol’的地址被传递给一个函数，相应的参数被声明为一个const指针。这应用于函数没有修改目标，如果是这种情况，那么最初的目标应该早些初始化。

1.5.114

－604－返回自动变量（临时变量）的地址

符号的地址被传回给一个函数。因为目标是一个 auto， 一个 auto 的持续时间不保证传递给 return， 这很可能是一个错误。你可能希望复制这个值到一个全局变量，传回全局的地址，或你可能考虑调用者传递一个它自己的一个变量的地址给被调用者。

1.5.115 －605－ 增加指针的能力

这个告警针对分配一个指向 const的指针到一个普通指针。例如：

int *p; const int *q; p = q; /* 605 */

如果使用一个转换，将不会告警：

p = (int *) q;

增强能力表示因为 const 指针 q 能现在通过 p被修改。这个信息也可以适用于限定词 volatile ，和限定词 const 一样，可以被用于任何指针深度(指向指针、指向数组等等)。如果指针的水平超过一，事情变得轻易的糟糕。例如：

const char ** ppc; char ** pp;

pp = ppc; /* 605 - clearly not safe */ ppc = pp; /* 605 - looks safe but it's not */

C委员会直到最近才明白分配 pp 到 ppc 是危险的。问题是在上面的分配以后，一个 const char 的指针能被间接通过 ppc 分配，并通过 pp 访问，然后可以修改 const char。因为间指针有较少的能力。但是，分配指针没有破坏旧的一个，而两个指针的联合表现为纯粹的能力上的增加。当一个函数的原型包含一个比在其它原型中相应的指针有更高能力的指针时，也发布这个信息。这里有一个古怪的倒置，为何一个低些能力的原型转换为一个更强信任的函数，因此更强的能力 (一个特洛伊木马)。例如，让

void warrior( char * );

成为一个函数破坏它的参数，考虑函数：

void Troy( void (*horse)(const char *) );

Troy() 将调用 horse() 用一个参数，考虑信任 horse() 将有害的。在编译器更好知道之前，

相信加上一个 const 到目的地永远不会伤害任何事情，编译器早点允许 Greeks 传递 warrior() 到 Troy 和其余的，如他们所说，是历史。

1.5.116

－606－非ANSI转义系列: '\\String'

在一个字符或字符串内出现一个转义系列，不在经核准的列表中：

\\' \\\

\\octal-digits \\xhex-digits

1.5.117 －607－ 在字符串内发现宏的参数 'Symbol'

在宏内的字符串内出现的名称和宏的形参的名称碰巧相同，如：

#define mac(n) printf( \

这是一致的吗？ANSI标准指出名称将不会被代替，但是因为很多C编译器替换这个名称，所以结构是可疑的。检查宏定义，如果你不希望替换，改变参数的名称。如果你希

望替换，设置 +fps 标志 (字符串内的参数)，并抑制这个信息。

1.5.118

－608－赋值给数组类型的参数

分配给一个数组类型的参数。为分配的目的，参数被认为是一个指针。通常这个参数的类型是指针胜于数组。但是，如果这是你代码的形式，抑制这个信息。

1.5.119

－609－两个不同大小指针（far和near）间的转换 －610－可疑的指针合并操作

在两个不同大小的指针间分配 (一个是 far， 另一个是 near) ，是不兼容的。

1.5.120

比较、减或paired(在一个条件表达式中)不同大小的指针(一个是 far， 另一个是 near)。这是可疑的，因为正常的指针进行这样的操作是同样大小的。

1.5.121

－611－可疑的强制类型转换（按照ANSI标准）

函数指针和目标指针之间转换。这被ANSI标准认为是有问题的。如果这是一个用户错误，抑制这个告警。

1.5.122

－612－期望一个声明

一个声明包含仅一个存储类和一个类型。这差不多的确是一个错误，因为仅安排一个没有声明符的类型有意义是在一个struct, union 或 enum ，但是在这种情况下，你不能使用一个存储类。

1.5.123 －613－可能使用空指针（左值或右值）

上下文包括：一元的 *， 指针递增 (++) 或递减(--)，加指针到数字、两个指针相减。在二元操作符中，'left' 或 'right'被用于指定哪个操作数是null。 Symbol 指示指针变量可能为NULL。参见信息413 和 794.

1.5.124

－614－自动集合类型变量的初始化非常量

一个自动集合的初始化器正常地由一系列的常量值表达式组成。一些编译器可能允许变量，如果是这种情况，你可疑抑制这个信息。

1.5.125

－615－ 自动集合类型变量的初始化有副作用

这个告警和信息 614 相似。自动集合(数组、结构和联合)通过没有副作用的常量值表达式正常地初始化。如果编译器能支持副作用，你可疑抑制这个信息。

1.5.126

－616－ Case/default语句少了Break

可能控制流从上面一个case语句或default 语句进入到下一个。这是有意的还是程序员忘记插入一个 break 语句？如果这是有意的，那么放置一个注释在标志的语句前，例如：

case 'a': a = 0; /* fall through */ case 'b': a++;

注意： 如果case 语句仅仅跟着case语句而没有干涉语句，信息将不被发布。

1.5.127

－617－ String 是一个模块和一个包含文件

文件被用于作为一个包含文件和一个模块。这是一个错误吗？不象错误 306 (重复的模块)，这仅是一个告警，试图处理这个文件。

1.5.128 －618－存储类型修饰符（static, extern, typedef, register 或 auto）在类型之后

存储类型修饰符(static, extern, typedef,register 或 auto) 被发现在一个类型确定之后。这是合法的，但是反对或者把存储类修饰符放置在类型之前，或抑制这个信息。

1.5.129 －619－在指针赋值时导致数据丢失（精度丢失）

一个 far 指针被分配给一个 near 指针，或者在一个分配语句中，或者是一个隐含分配，例如一个初始化器、一个返回语句、传递参数到一个存在的原型。 这种分配是一个时常发生的错误源，当实际的段不等于默认的数据段时。如果你能保证 far 指针的段等于默认的数据段，你应该使用一个转换来抑制这个信息。

1.5.130

－620－分不清是常量1还是字母l；所以建议使用L

一个常量结束为一个小写的字母 'l'。这是有意为1吗？这两个字母看起来非常象，要避免拼写错误，使用大小的字母'L'。

1.5.131 －621－标识符崩溃 (符号 'Name' 和符号 'Name' at String)

两个符号出现在同一个命名空间，但是在第一个count 字符内是相同的。通过选项-idlen(count,option)设置。见-idlen在章节5.7其它选项。

1.5.132

－622－ scanf, fscanf or sscanf函数的参数与格式不一致

scanf , fscanf 或 sscanf 的参数是一个指针，它的大小和格式不匹配。例如： int far *p; scanf( \

将发布一个告警(在默认的内存模式l)。 1.5.133 －623－ 重新定义存储类符号

在一个模块中一个内部模块符号是一个 typedef 符号，在另一个模块中是一个普通的符号。这是合法的，但是存在潜在的混淆。这是程序员有意的吗？ 1.5.134 －624－ typedef 被声明

一个符号在两个模块内被声明为不同的 typedef。 这在学术上是合法的，但是不是一个明智的程序实践。

1.5.135

－625 －自动变量使用了不该使用的类型修饰符

－626－ printf (或fprintf 、sprintf)的参数与格式不一致

一些类型修饰符，如 far, near, fortran 对 auto 变量不合适。

1.5.136

printf的参数(或fprintf或sprintf)

和格式不一致。尽管大小一样，但是类型不一致。你可以

一致这个信息，当看到更多不能容忍的告警559的侵害。

1.5.137 －627－间接目标和格式不一致

scanf (或fscanf、sscanf)的参数的类型和格式不一致。但是，参数是个指针，指向的是期

望的大小。

1.5.138 －628－ 没有参数信息提供给函数

函数被调用，但是没有提供参数信息。参数信息可疑来自原型或函数定义。当一个旧形式的函数声明指出函数在一个库中，但是没有为函数给出原型或在一个标准库文件中没有提供任何参数信息时，这种情况发生。如果你产生一个lob文件，因为大概在以后时间目标模块将和一个库文件进行比较，这个信息将被抑制。

1.5.139 －629－ 对函数的static类是非标准的

在一个函数内发现一个 static 类函数声明。static 类仅仅被允许在文件范围内的函数声明(也就是说任何函数外 )。或者移动声明到函数外，或者改变 static 为 extern；如果选择第二个，确保在文件范围 extern 声明前也存在一个 static 声明。虽然在技术上结构

不是轻便的，很多编译器能忍受它。如果你抑制这个信息，PC-lint/FlexeLint 将把它作为一个正确的函数声明。

1.5.140 －630－ 对符号不明确地引用

如果设置 +fab 标志，那么如果两个结构包含同样的成员名称 (不必要是不同种类的结构 ) ，被嵌入在同样的结构里，一个到这个成员的引用省略其中之一的干涉(消除模棱两可情况)名称，这个告警被发出。

1.5.141 －631－ tag 'Symbol' 定义的不同

struct, union 或 enum tag被不同地定义在在不同的范围。这不是一个必要的错误，因为C

允许重定义，但是它是一个狡猾的错误的源头。这通常不是一个被推荐的程序实践。 1.5.142 －632－ 分配给强类型

一个分配违背一个-strong(A... 选项请求的强类型检查。见章节 8. 强类型 1.5.143 －633－ 从一个强类型分配

一个分配违背一个-strong(X... 选项请求的强类型检查。见章节 8. 强类型

1.5.144 －634－ 在等式不条件式中强类型不匹配

一个等式操作 (== or !=) 或一个条件操作 (? :) 违背一个-strong(J... 选项请求的强类型检查。这个信息可疑使用标志 \Je\来抑制。见章节 8. 强类型

1.5.145 －635－ 重新设置类型的双亲

给出的强类型双亲被重新设置。这通过一个 -parent 选项或一个 typedef 来完成。 注意这可能不是一个必要的错误，你可疑断言事实旧的链接被抹去。见章节 8. 强类型

1.5.146 －636－ 强类型指针与其它类型相对

指针被比较，并且在第一个水平下有一个强类型冲突。例如：

/*lint -strong(J,INT) */ typedef int INT; INT *p; int *q;

if( p == q ) /* Warning 636 */

将发布这个告警。这个信息可以使用标志\Je\或 \Jr\或两个一起使用来抑制。

1.5.147 －637－ 期望对强类型的索引类型

这个信息收到 -index 选项被认为不一致。下标不是规定的类型 (在信息中提到的第一个类型) ，或等于类型层次内的类型。见章节 8. 强类型和 +fhx。

1.5.148 －638－ 在关系操作中强类型类型不匹配

一个关系操作违背一个-strong(J... 选项请求的强类型检查。这个信息可以通过使用标志 \Jr\来抑制。见章节 8. 强类型

1.5.149

－639－在二元操作中强类型类型不匹配

一个二元操作违背一个-strong(J... 选项请求的强类型检查。这个信息可以通过使用标志 \Jo\来抑制。见章节 8. 强类型

1.5.150 －640－在布尔表达式中期望强类型

一个布尔上下文期望一个通过选项-strong(B...确定的类型。见章节 8. 强类型

//lint -sp8 pointers are 8 bytes //lint -si4 integers are 4 bytes char *f( char *p, int n, int m )

{

return p + (n + m); // warning 679 }

按照 C/C++的规则，加运算 n+m 被独立地在它的上下文中执行，并且按照整型精度。任何溢出被忽略，甚至指针的大些的精度能很容易地提供溢出。如果，在另一方面表达式是：p+n+m，分析为 (p+n)+m, 没有告警被发布。如果表达式是 p+n*m ，那么要抑制告警，需要一个转换。如果 long 和指针的大小相同，你应该使用表达式：

return p + ((long) n * m);

1.5.190 －680－在算术表达式转换为指针中可疑的切断

一个算术表达式被转换为指针。而且，指针的大小比表达式的大小大。在计算表达式里，任何溢出将被丢失甚至指针类型将被I提供丢失信息。要抑制信息，转换其中的一个操作数为一个足够容纳指针的整型类型。作为选择，如果你保证没有问题，你可以在转换为指针前转换表达式为一个整型类型。见信息 647, 776, 790 和 679。

1.5.191 －681－ 循环没有输入

对一个循环的控制表达式(或者在一个while 子句中的表达式，或者是for 子句内的第二个表达式) 最初的计算是零，因此看起来好像循环没有输入。

1.5.192 －682－ sizeof 用于类型是一个数组的参数'Symbol'

如果一个参数的类型是一个数组，它被提升为一个指针。取这个数组的大小将实际产生指针的大小。考虑，例如：

unsigned f( char a[100] ) { return sizeof(a); }

这里，它看起来似乎函数 f() 将返回值 100，但是它实际返回指针的大小，是4。

1.5.193 －683－ 函数 'Symbol' #define'd

无论何时有一些语义相关的函数名被定义为一个宏，这个信息被发布。例如：

#define strlen mystrlen

问题是对strlen 定义的语义将被丢失。考虑这个信息，一个断言去转换语义从 strlen 到 mystrlen， 使用 -function(strlen, mystrlen)， 这个信息将对内置函数发布(有内置语义) ，或对以后定义的语义。如果这个函数被定义为一个相似的名称，但是有下划线或者在前面，或者在后面，或者两边都有，则信息不会被发布。例如：

#define strlen __strlen

将不会产生这个信息。将会代替而产生信息 828。

1.5.194 －684－ 传递auto 变量的地址 'Symbol' 到调用者空间

一个auto 变量的地址通过分配给一个通过调用者确定的函数位置被传递。例如： void f( int *a[] )

{ int n; a[1] = &n; }

这里一个auto 变量(n)的地址被传递给数组的第二个元素，传递到函数 f。这看起来可疑，因为在返回的数组之上将包含一个寿命结束的指向变量的指针。这可能是良性的，因为

可能是 f()的调用者仅仅传递一个工作空间给被丢弃的返回上。如果是这种情况，你可以对函数 f() 抑制这个信息，使用选项： -efunc(684,f)

参见告警 604。

1.5.195 －685－ 关系操作符 'String,' 总是计算 'String'

第一个String 是以下之一：'>'、'>='、'<' 或 '<=' ，并标识关系操作符。第二个 string 是 'True' 或 'False' 之一。 当一个表达式和一个常量比较，并表达式的精度显示判断将总是成功或总是失败时，发布这个信息。例如：

char ch; ...

if( ch >= -128 ) ...

在这个例子中，char ch 的精度是 8 比特有符号的(假定 fcu 标志在关闭状态)， 因此它的值的范围是从 -128 到 127 。因此这个判断总为真。注意，学术上，ch 在和常量比较前被提升为 int 。为这个比较的目的，我们仅考虑根本的精度。作为另一个例子，如果 u 是一个 unsigned int 那么

if( (u & 0xFF) > 0xFF ) ...

将发布信息 685 ，因为左手边的表达式有一个有效的16 比特的精度。

1.6 C 情报信息

1.6.1

－701－int类型（有符号）变量左移 －702－int类型（有符号）变量右移

移位应该在无符号数上操作

1.6.2

移位应该在无符号数上操作。一个有符号数右移依赖于系统

1.6.3 －703－long类型（有符号）变量左移

移位应该在无符号数上操作

1.6.4

－704－long类型（有符号）变量右移 －708－union类型变量初始化

移位应该在无符号数上操作.

1.6.5

试图初始化一个联合的值。这可能在一些旧的编译器上不允许。这是因为明显的不明确：成员应该被初始化。标准解释是应用初始化到联合的第一个图表类型。

1.6.6

－712－精确度损失

在两个整型量之间进行一个分配 (或隐含分配) ，第一个类型比第二个类型大。一个转换将抑制这个信息。 1.6.7 －713－精确度损失

从一个无符号量分配（或隐含分配）到一个有符号量，将导致可能丢失一个比特的整型精度，例如从unsigned int 到 int 的转换。一个强制转换将抑制这个信息。 1.6.8 －714－符号没有使用

外部变量或外部函数被定义，但是没有被引用。这个信息对单元检查被抑制。

1.6.9

－715－符号没有使用

形参没有被引用。

1.6.10 －716－发现while(1) ...

发现一个 while(1) ... 形式的结构。尽管这代表在期望一个布尔值的上下文的一个常量，它可能反映一个程序政策，为何无限循环在这个结构的前面。因此，这个信息被给出一个独立的号，并放置于情报的种类中。更方便的无限循环前缀的形式是 for(;;) 1.6.11 －717－发现do ... while(0) –

尽管这代表在期望一个布尔值的上下文的一个常量，这个结构可能是故意试图压缩一系列语句为一个单独的语句，因此给出一个单独的错误信息。例如:

#define f(k) do {n=k; m=n+1;} while(0)

允许 f(k) 被用于一个条件语句中：

if(n>0) f(3); else f(2);

从而，如果你故意这样做，使用-e717。

1.6.12 －718－'Symbol'符号没有定义，假定返回int

一个函数被引用没有（或之前）被在当前的模块内声明或定义。这不是一个必要的错误，你可能希望抑制它(见章节14. 灵活使用LINT.). 注意：通过在另一个模块内增加声明，你将不能抑制这个信息。它只能被抑制通过在被处理的模块内放置一个声明。 1.6.13 －719 －过多的格式参数

在 printf/scanf 函数族中函数的参数个数比在格式中确定参数要多。这个信息和告警 558 相似，后者断言用户使用过少的格式参数。它接受一个轻微的信息分级，因为附加的参数被简单地忽略。

1.6.14

－720－布尔测试中有赋值

在一个分配中发现上下文需要一个布尔。(例如在一个 if() 或 while() 子句或一个操作数到 && 或 ||)。这可能是合法的，或者它由错误的对＝＝使用＝产生。 1.6.15 －721－ 怀疑 ; 使用错误

在一个形式 if(e);的结构中，发现一个分号在右括号的右边。这可能是没有注意到或对使用分号结束语句困惑。如果分号被至少一个空格从')'分隔，这个信息将被抑制。最好，把它放置于一个单独的行。参见信息 548。

1.6.16

－722 －怀疑 ; 使用错误

在一个形式 while(e); 或 for(e;e;e);的结构中，发现一个分号在右括号的右边。这可能是没有注意到或对使用分号结束语句困惑。如果分号被至少一个空格从')'分隔，这个信息将被抑制。最好，把它放置于一个单独的行。 1.6.17 －723－怀疑＝使用错误

一个预处理定义以一个 = 符号开始。例如：

#define LIMIT = 50

这是故意的吗？或者是程序员当他写这些的时候他想起分配。 1.6.18 －725－期望从当前位置积极缩排

从指示行发现当前行被积极缩排。后面的相应子句引入的控制结构和语句和其它控制子句和它的范围内的括号被期望有少点的缩排。如果你的程序中的tab的值不是8个空格，你可以使用-t 选项 (见章节11.3缩排检查)

1.6.19 －726－多了无关的逗号

在一个枚举中，一个逗号跟着一个右括号，这不是一个有效的ANSI结构。逗号被忽略。 1.6.20 －727－符号 'Symbol' (Location) 没有明确地初始化

static变量(函数的局部变量) 在使用前没有被明确地初始化。下面的评论适用于信息728、729、727。 “没有明确地初始化”我们的意思是：在目标的定义中没有初始化器存在，没有直接分配到目标、没有地址操作符用于目标，或如果取目标的地址，它分配一个指针到 const。这些信息不是必要的信号错误，因为对static 变量隐含地初始化是零。但是，信息对指出你忘记初始化一个值有帮助。要从信息中吸取最大益处，我们建议你对那些你希望初始化为零的变量使用明确地初始化。例如：

static int n = 0;

对那些需要动态初始化的变量，不要使用明确地初始化，例如：

static int m;

对任何数组、结构或联合，如果没有成员或元素被分配一个值，这个信息将被发布。 1.6.21 －728－符号 'Symbol' (Location) 没有明确地初始化

模块内的变量(文件范围的 static 变量) 没有被明确的初始化。见在信息 727 中更多的细节。

1.6.22 －729－符号 'Symbol' (Location) 没有明确地初始化

模块内的变量(外部变量) 没有被明确的初始化。见在信息 727 中更多的细节。这个信息对单元检查是被抑制的。 1.6.23 －730－函数的变量为布尔型

一个布尔被用于作为一个函数的参数。这是故意的吗？或是程序员被一个独特的复杂的条件语句迷惑了。有经验的C程序员经常抑制这个信息。这个信息仅仅针对如果相关的参数不被声明为bool。

1.6.24

－731－布尔型变量使用了== or !=

一个布尔被用于作为== 或 !=的参数。例如： if( (a > b) == (c > d) ) ...

判断是否不等式有同样的值。这可能是一个错误，因为是一个不寻常的使用一个布尔 (见告警 503 和 514) ，但它可能是故意的，因为这是唯一的方式去有效地获得等值。因为可能的使用，结构被给出为一个相关的轻微的情报分级。如果布尔参数被转换为其它类型，信息不会被给出。

1.6.25 －732－符号位丢失(Context) (Type to Type)

从一个有符号量分配（或隐含分配）到一个无符号量。而且，不能决定这个有符号量没有符号。例如：

u = n; /* Info 732 */ u = 4; /* OK */

这里 u 是一个无符号的，而 n 不是，只是对第一个分配授权这个信息，即使常量 4 是名义上地一个有符号的 int。确保这不是一个错误 (分配的值永远不是一个负值) ，然后使用一个转换(到无符号)来去除这个信息。 1.6.26 －733－把自动变量的地址赋值给外部变量

一个 auto 变量的地址仅仅在变量被声明的块内是有效的。这个变量的地址被分配给一

个更长生命期望的变量。做这种事情有内在的危险。

1.6.27

－734－精确度的丢失(Context) (整型之间)

-- An assignment

is being made into an object smaller than an int. The information being assigned is derived from another object or combination of objects in such a way that information could potentially

be lost. The number of bits given does not count the sign bit. 例如 if ch is a char and n is an int then:

ch = n;

will trigger this message whereas:

ch = n & 1;

will not. To suppress the message a cast can be made as in:

ch = (char) n;

You may receive notices involving multiplication and shift operators with subinteger variables. 例如:

ch = ch << 2 ch = ch * ch

where, 例如, ch is an unsigned char. These can be suppressed by using the flag +fpm (precision of an operator is bound by the maximum of its operands). See 章节 5.5 Flag 选项.

1.6.28

－735－精度丢失(Context) (Integer bits to Integer bits)

-- An assignment

(or implied assignment, see Context) is made from a long double to a double. Using a cast will suppress the message. The number of bits includes the sign bit.

1.6.29

－736－精度丢失(Context) (Integer bits to Integer bits)

-- An assignment

(or implied assignment, see Context) is being made to a float from a value or combination of values that appear to have higher precision than a float. You may suppress this message by using a cast. The number of bits includes the sign bit. 1.6.30 －737－符号位的丢失

-- An unsigned quantity was joined with

a signed quantity in a binary operator (or 2nd and 3rd arguments to the conditional operator ? :)

and the signed quantity is implicitly converted to unsigned. The message will not be given if the

signed quantity is an unsigned constant, a Boolean, or an expression involving bit manipulation. 例如,

u & ~0xFF

where u is unsigned does not draw the message even though the operand on the right is technically

本文来源：https://www.bwwdw.com/article/8l03.html