Num	Name	Detailed Description
1	Unclosed Comment (Location)	End of file was reached with an open comment still unclosed.  The Location of the open comment is shown.
2	Unclosed Quote	An end of line was reached and a matching quote character (single or double) to an earlier quote character on the same line was not found.
3	#else without a #if	A #else was encountered not in the scope of a #if, #ifdef or #ifndef.
4	Too many #if levels	An internal limit was reached on the level of nesting of #if statements (including #ifdef and #ifndef).
5	Too many #endif's	A #endif was encountered not in the scope of a #if or #ifdef or #ifndef.
6	Stack Overflow	One of the built-in non-extendable stacks has been overextended.  The possibilities are too many nested #if statements, #includes statements (including all recursive #include statements), static blocks (bounded by braces) or #define replacements.
7	Unable to open include file: FileName	FileName is the name of the include file which could not be opened.  See also flag fdi (§5.5 "Flag Options"), option -i...  (§5.7 "Other Options") and §13.2.1 "INCLUDE environment variable"
8	Unclosed #if (Location)	A #if (or #ifdef or #ifndef) was encountered without a corresponding #endif.  Location is the location of the #if.
9	Too many #else's in #if (Location)	A given #if contained a #else which in turn was followed by either another #else or a #elif.  The error message gives the line of the #if statement that started the conditional that contained the aberration.
10	Expecting 'String'	String is the expected token.  The expected token could not be found.  This is commonly given when certain reserved words are not recognized.
		int __interrupt f();
		will receive an Expecting ';' message at the f because it thinks you just declared __interrupt.  The cure is to establish a new reserved word with +rw(__interrupt).  Also, make sure you are using the correct compiler options file.  See also §15.10 "Strange Compilers".
11	Excessive Size	The filename specified on a #include line had a length that exceeded FILENAME_MAX characters.
12	Need < or "	After a #include is detected and after macro substitution is performed, a file specification of the form <filename> or "filename" is expected.
13	Bad type	A type adjective such as long, unsigned, etc. cannot be applied to the type which follows.
14	Symbol 'Symbol' previously defined (Location)	The named object has been defined a second time.  The location of the previous definition is provided.  If this is a tentative definition (no initializer) then the message can be suppressed with the +fmd flag.  (§5.5 "Flag Options").
15	Symbol 'Symbol' redeclared (TypeDiff) (Location)	The named symbol has been previously declared or defined in some other module (location given) with a type different from the type given by the declaration at the current location.  The parameter TypeDiff provides further information on how the types differ (see Glossary in Chapter §17. "MESSAGES").
16	Unrecognized name	A # directive is not followed by a recognizable word.  If this is not an error, use the +ppw option. (§5.7 "Other Options").
17	Unrecognized name	A non-parameter is being declared where only parameters should be.
18	Symbol 'Symbol' redeclared (TypeDiff) conflicts with Location	A symbol is being redeclared.  The parameter TypeDiff provides further information on how the types differ (see Glossary Chapter §17. "MESSAGES").  Location is the location of the previous definition.
19	Useless Declaration	A type appeared by itself without an associated variable, and the type was not a struct and not a union and not an enum.  A double semi-colon can cause this as in:
		int x;;
20	Illegal use of =	A function declaration was followed by an = sign.
21	Expected {	An initializer for an indefinite size array must begin with a left brace.
22	Illegal operator	A unary operator was found following an operand and the operator is not a post operator.
23	Expected colon	A ? operator was encountered but this was not followed by a : as was expected.
24	Expected an expression, found 'String'	An operator was found at the start of an expression but it was not a unary operator.
25	Illegal constant	Too many characters were encountered in a character constant (a constant bounded by ' marks).
26	Expected an expression, found 'String'	An expression was not found where one was expected.  The unexpected token is placed in the message.
27	Illegal character (0xhh)	An illegal character was found in the source code. The hex code is provided in the message.  A blank is assumed.  If you are using strange characters in identifier names you will get this message for which you may use the -ident option.  (See §5.7 "Other Options")
28	Redefinition of symbol 'Symbol' Location	The identifier preceding a colon was previously declared at the Location given as not being a label.
30	Expected a constant	A constant was expected but not obtained. This could be following a case keyword, an array dimension, bit field length, enumeration value, #if expression, etc.
31	Redefinition of symbol 'Symbol' conflicts with Location	A data object or function previously defined in this module is being redefined.
32	Field size (member 'Symbol') should not be zero	The length of a field was given as non-positive, (0 or negative).
33	Illegal constant	A constant was badly formed as when an octal constant contains one of the digits 8 or 9.
34	Non-constant initializer	A non-constant initializer was found for a static data item.
35	Initializer has side-effects	An initializer with side effects was found for a static data item.
36	Redefining the storage class of symbol 'Symbol' conflicts with Location	An object's storage class is being changed.
37	Value of enumerator 'Symbol' inconsistent (conflicts with Location)	An enumerator was inconsistently valued.
38	Offset of symbol 'Symbol' inconsistent (Location)	A member of a class or struct appears in a different position (offset from the start of the structure) than an earlier declaration.  This could be caused by array dimensions changing from one module to another.
39	Redefinition of symbol 'Symbol' conflicts with Location	A struct or union is being redefined.
40	Undeclared identifier 'Name'	Within an expression, an identifier was encountered that had not previously been declared and was not followed by a left parenthesis.  Name is the name of the identifier.
41	Redefinition of symbol 'Symbol'	A parameter of either a function or a macro is being repeated.
42	Expected a statement	A statement was expected but a token was encountered that could not possibly begin a statement.
43	Vacuous type for variable 'Symbol'	A vacuous type was found such as the void type in a context that expected substance.
44	Need a switch	A case or default statement occurred outside a switch.
45	Bad use of register	A variable is declared as a register but its type is inconsistent with it being a register (such as a function).
46	Field type should be int	Bit fields in a structure should be typed unsigned or int.  If your compiler allows other kinds of objects, such as char, then simply suppress this message.
47	Bad type	Unary minus requires an arithmetic operand.
48	Bad type	Unary * or the left hand side of the ptr (->) operator requires a pointer operand.
49	Expected a type	Only types are allowed within prototypes.  A prototype is a function declaration with a sequence of types within parentheses.  The processor is at a state where it has detected at least one type within parentheses and so is expecting more types or a closing right parenthesis.
50	Attempted to take the address of a non-lvalue	Unary & operator requires an lvalue (a value suitable for placement on the left hand side of an assignment operator).
51	Expected integral type	Unary ~ expects an integral type (signed or unsigned char, short, int, or long).
52	Expected an lvalue	autodecrement (--) and autoincrement (++) operators require an lvalue (a value suitable for placement on the left hand side of an assignment operator).  Remember that casts do not normally produce lvalues.  Thus
		++(char *)p;
		is illegal according to the ANSI standard.  This construct is allowed by some compilers and is allowed if you use the +fpc option (Pointer Casts are lvalues).  (See §5.5 "Flag Options")
53	Expected a scalar	Autodecrement (--) and autoincrement (++) operators may only be applied to scalars (arithmetics and pointers) or to objects for which these operators have been defined.
54	Division by 0	The constant 0 was used on the right hand side of the division operator (/) or the remainder operator (%).
55	Bad type	The context requires a scalar, function, array, or struct (unless -fsa).
56	Bad type	Add/subtract operator requires scalar types and pointers may not be added to pointers.
57	Bad type	Bit operators ( &, | and ^ ) require integral arguments.
58	Bad type	Bad arguments were given to a relational operator; these always require two scalars and pointers can't be compared with integers (unless constant 0).
59	Bad type	The amount by which an item can be shifted must be integral.
60	Bad type	The value to be shifted must be integral.
61	Bad type	The context requires a Boolean.  Booleans must be some form of arithmetic or pointer.
62	Incompatible types (TypeDiff) for operator ':'	The 2nd and 3rd arguments to ? : must be compatible types.
63	Expected an lvalue	Assignment expects its first operand to be an lvalue.  Please note that a cast removes the lvaluedness of an expression.  But see also flag +fpc in §5.5 "Flag Options".
64	Type mismatch (Context) (TypeDiff)	There was a mismatch in types across an assignment (or implied assignment, see Context). TypeDiff specifies the type difference.  See options -epn, -eps, -epu, -epp (§5.2 "Error Inhibition Options") to suppress this message when assigning some kinds of pointers.
65	Expected a member name	After a dot (.) or pointer (->) operator a member name should appear.
66	Bad type	A void type was employed where it is not permitted. If a void type is placed in a prototype then it must be the only type within a prototype.  (See error number 49.)
67	Can't cast from Type to Type	Attempt to cast a non-scalar to an integral.
68	Can't cast from Type to Type	Attempt to cast a non-arithmetic to a float.
69	Can't cast from Type to Type	Bad conversion involving incompatible structures or a structure and some other object.
70	Can't cast from Type to Type	Attempt to cast to a pointer from an unusual type (non-integral).
71	Can't cast from Type to Type	Attempt to cast to a type that does not allow conversions.
72	Bad option 'String'	Was not able to interpret an option.  The option is given in String.
73	Bad left operand	The cursor is positioned at or just beyond either an -> or a . operator.  These operators expect an expression primary on their left.  Please enclose any complex expression in this position within parentheses.
74	Address of Register	An attempt was made to apply the address (&) operator to a variable whose storage class was given as register.
75	Too late to change sizes (option 'String')	The size option was given after all or part of a module was processed.  Make sure that any option to reset sizes of objects be done at the beginning of the first module processed or on the command line before any module is processed.
76	can't open file  String	String is the name of the file.  The named file could not be opened for output.  The file was destined to become a PC-lint/FlexeLint object module.
77	Address of bit-field cannot be taken	The address of a bit-field cannot be taken.  The rules of C only allow for taking the address of a whole byte (a whole char).
78	Symbol 'Symbol' typedef'ed at Location used in expression	The named symbol was defined in a typedef statement and is therefore considered a type.  It was subsequently found in a context where an expression was expected.
79	Bad type for % operator	The % operator should be used with some form of integer.
80	this use of ellipsis is not strictly ANSI	The ellipsis should be used in a prototype only after a sequence of types not after a sequence of identifiers.  Some compilers support this extension. If you want to use this feature suppress this message.
81	struct/union not permitted in equality comparison	Two struct's or union's are being compared with one of == or !=. This is not permitted by the ANSI standard.  If your compiler supports this, suppress this message.
82	return <exp>; illegal with void function	The ANSI standard does not allow an expression form of the return statement with a void function.  If you are trying to cast to void as in return (void)f(); and your compiler allows it, suppress this message.
83	Incompatible pointer types with subtraction	Two pointers being subtracted have indirect types which differ.  You can get PC-lint/FlexeLint to ignore slight differences in the pointers by employing one or more of the -ep... options described in §5.2 "Error Inhibition Options".
84	sizeof object is zero or object is undefined	A sizeof returned a 0 value.  This could happen if the object were undefined or incompletely defined.  Make sure a complete definition of the object is in scope when you use sizeof.
85	Array 'Symbol' has dimension 0	An array (named Symbol) was declared without a dimension in a context that required a non-zero dimension.
86	Structure 'Symbol' has no data elements	A structure was declared (in a C module) that had no data members.  Though legal in C++ this is not legal C.
87	Expression too complicated for #ifdef or #ifndef	By the rules of C there should be only a single identifier following a #ifdef or a #ifndef.  You may also supply a validly constructed C (or C++) comment.
88	Symbol 'Symbol' is an array of empty elements	An array was declared (in a C module) whose elements were each of 0 length. Though legal in C++ this is not permitted C.
89	Argument or option too long ('String')	The length of an option (shown in String) exceeds an internal limit.  Please try to decompose the option into something smaller.  At this writing the limit is 610 characters.
90	Option 'String' is only appropriate within a lint comment	The indicated option is not appropriate at the command or the .lnt level.  For example if -unreachable is given on the command line you will get this message.
91	Line exceeds Integer characters (use +linebuf)	A line read from one of the input files is longer than anticipated.  By default the line buffer size is 600 characters.  Each time you use the +linebuf option you can double this size.  The size can be doubled ad infinitum.
92	Negative array dimension or bit field length (Integer)	A negative array dimension or bit field length is not permitted.
93	New-line is not permitted within string arguments to macros	A macro invocation contains a string that is split across more than one line.  For example:
		A( "Hello
		World" );
		will trigger this message.  Some compilers accept this construct and you can suppress this message with -e93 if this is your current practice.  But it is more portable to place the string constant on one line.  Thus
		A( "Hello World" );
		would be better.
96	Unmatched left brace for String on Location	The purpose of this message is to report the location of a left curly brace that is unmatched by a right curly brace.  Such an unmatched left curly can be far removed from the point at which the unbalance was detected (often the end of the compilation unit).  Providing the location of the left curly can be extremely helpful in determining the source of the imbalance.
101	Expected an identifier	While processing a function declarator, a parameter specifier was encountered that was not an identifier, whereas a prior parameter was specified as an identifier.  This is mixing old-style function declarations with the new-style and is not permitted.  For example
		void f(n,int m)
		will elicit this message.
102	Illegal parameter specification	Within a function declarator, a parameter must be specified as either an identifier or as a type followed by a declarator.
103	Unexpected declaration	After a prototype, only a comma, semi-colon, right parenthesis or a left brace may occur.  This error could occur if you have omitted a terminating character after a declaration or if you are mixing old-style parameter declarations with new-style prototypes.
104	Conflicting types	Two consecutive conflicting types were found such as int followed by double.  Remove one of the types!
105	Conflicting modifiers	Two consecutive conflicting modifiers were found such as far followed by near.  Remove one of the modifiers!
106	Illegal constant	A string constant was found within a preprocessor expression as in
		#if ABC == "abc"
		Such expressions should be integral expressions.
107	Label 'Symbol' (Location) not defined	The Symbol at the given Location appeared in a goto but there was no corresponding label.
108	Invalid context	A continue or break statement was encountered without an appropriate surrounding context such as a for, while, or do loop or, for the break statement only, a surrounding switch statement.
110	Attempt to assign to void	An attempt was made to assign a value to an object designated (possibly through a pointer) as void.
111	Assignment to const object	An object declared as const was assigned a value.  This could arise via indirection.  For example, if p is a pointer to a const int then assigning to *p will raise this error.
113	Inconsistent enum declaration	The sequence of members within an enum (or their values) is inconsistent with that of another enum (usually in some other module) having the same name.
114	Inconsistent structure declaration for tag 'Symbol'	The sequence of members within a structure (or union) is inconsistent with another structure (usually in some other module) having the same name.
115	Struct/union not defined	A reference to a structure or a union was made that required a definition and there is no definition in scope. For example, a reference to p->a where p is a pointer to a struct that had not yet been defined in the current module.
116	Inappropriate storage class	A storage class other than register was given in a section of code that is dedicated to declaring parameters.  The section is that part of a function preceding the first left brace.
117	Inappropriate storage class	A storage class was provided outside any function that indicated either auto or register. Such storage classes are appropriate only within functions.
118	Too few arguments for prototype	The number of arguments provided for a function was less than the number indicated by a prototype in scope.
119	Too many arguments for prototype	The number of arguments provided for a function was greater than the number indicated by a prototype in scope.
122	Digit (Char) too large for radix	The indicated character was found in a constant beginning with zero.  For example, 08 is accepted by some compilers to represent 8 but it should be 010 or plain 8.
123	Macro 'Symbol' defined with arguments at Location this is just a warning	The name of a macro defined with arguments was subsequently used without a following '('.  This is legal but may be an oversight.  It is not uncommon to suppress this message (with -e123), because some compilers allow, for example, the macro max() to coexist with a variable max.  (See §15.6 "Error 123 using min or max").
124	Pointer to void not allowed	A pointer to void was used in a context that does not permit void.  This includes subtraction, addition and the relationals (> >= < <=).
125	Too many storage class specifiers	More than one storage class specifier (static, extern, typedef, register or auto) was found. Only one is permitted.
126	Inconsistent structure definition 'Symbol'	The named structure (or union or enum) was inconsistently defined across modules.  The inconsistency was recognized while processing a lint object module.  Line number information was not available with this message.  Alter the structures so that the member information is consistent.
127	Illegal constant	An empty character constant ('') was found.
128	Pointer to function not allowed	A pointer to a function was found in an arithmetic context such as subtraction, addition, or one of the relationals (> >= < <=).
129	declaration expected, identifier 'Symbol' ignored	In a context in which a declaration was expected an identifier was found.  Moreover, the identifier was not followed by '(' or a '['
130	Expected integral type	The expression in a switch statement must be some variation of an int (possibly long or unsigned) or an enum.
131	syntax error in call of macro 'Symbol' at location Location	This message is issued when a macro with arguments (function-like macro) is invoked and an incorrect number of arguments is provided.  Location is the location of the start of the macro call.  This can be useful because an errant macro call can extend over many lines.
132	Expected function definition	A function declaration with identifiers between parentheses is the start of an old-style function definition (K&R style).  This is normally followed by optional declarations and a left brace to signal the start of the function body.  Either replace the identifier(s) with type(s) or complete the function with a function body.
133	Too many initializers for aggregate	In a brace-enclosed initializer, there are more items than there are elements of the aggregate.
134	Missing initializer	An initializer was expected but only a comma was present.
135	comma assumed in initializer	A comma was missing between two initializers.  For example:
		int a[2][2] = { { 1, 2 }  { 3, 4 } };
		is missing a comma after the first right brace (}).
136	Illegal macro name	The ANSI standard restricts the use of certain names as macros.  defined is on the restricted list.
137	constant 'Symbol' used twice within switch	The indicated constant was used twice as a case within a switch statement. Currently only enumerated types are checked for repeated occurrence.
138	Can't add parent 'Symbol' to strong type String; creates loop	An attempt was made to add a strong type parent to a typedef type.  The attempt is either explicit (with the -strong option) or implicit with the use of a typedef to a known strong type. This attempt would have caused a loop in the strong parent relationship.  Such loops are simply not tolerated.
139	Can't take sizeof function	There is an attempt to take the sizeof a function.
140	Type appears after modifier	Microsoft modifiers such as far, _near, __huge, _pascal, etc. etc. modify the declarator to its immediate right.  It therefore should not appear before the type. For example, you should write int pascal f(void); rather than pascal int f(void);.  Note that const and volatile differ from the Microsoft modifiers.  They may appear before or after the type.  After reporting the error an attempt is made to process the modifiers as the programmer probably intended.  See also the +fem flag in §5.5 "Flag Options".
141	The following option has too many elements: 'String'	The indicated option (given by 'String') is too big.  It most likely consists of an itemized list that has too many items.  You should decompose the large option into two or more smaller options that in sum are equivalent to the one large option.
144	Non-existent return value for symbol 'Symbol', compare with Location	An attempt was made to use a non-existent return value of the named function (identified by Symbol).  It was previously decided that the function did not return a value or was declared with void.
145	Type expected before operator, void assumed	In a context in which a type is expected no type is found.  Rather, an operator '*' or '&' was encountered.  The keyword void was assumed to have preceded this operator.
146	Assuming a binary constant	A constant of the form 0b... was encountered.  This was taken to be a binary constant.  For example, 0b100 represents the value 4.  If your compiler supports binary constants you may suppress this message.
147	sizeof takes just one argument	An expression of the form sizeof(a,b) was detected.  A second argument is non standard and has been used by some compilers to denote an option to the sizeof operator.  If your compiler has a use for the second argument then suppress this message.
148	member 'Symbol' previously declared at Location	The indicated member was previously declared within the same structure or union.  Although a redeclaration of a function may appear benign it is just not permitted by the rules of the language. One of the declarations should be removed.
149	C++ construct 'String' found in C code	An illegal construct was found in C code.  It looked as though it might be suitable for C++.  The quoted string identifies the construct further.
150	Token 'String' unexpected String	An unexpected token was encountered.  The action taken, if any, is identified by the second message parameter.
151	Token 'Name' inconsistent with abstract type	In a context in which an abstract type is allowed such as within a cast or after a sizeof, and after starting to parse the abstract type, an identifier was found.  For example:
		x = (int y) z;
152	Lob base file 'file name' missing	The indicated file has been specified as the base of lob production via the option -lobbase().  On output, this message is given if the lob base is missing.  The situation is correctable by simply producing the missing lob output.  This will not be a problem given the appropriate dependencies in the make file.  On input, the most likely cause of this message is an out-of-date base file.  A hash code within the lob file being read, did not match a similar code already embedded within the base.  The input lob file should be considered in error and should be regenerated.  See Chapter §7. "LINT OBJECT MODULES".
153	Could not create temporary file	This message is produced when generating a lob output file based upon some lob base file.  When the lob file is produced, it is first written to a temporary. The temporary is generated by the C library function tmpnam().
154	Could not evaluate type 'String', int assumed	String in the message is the second argument to either a printf_code option or a scanf_code option.  When used, it was to be evaluated as a type.  Unfortunately the type could not be identified.
155	Ignoring { }'ed sequence within an expression, 0 assumed	Some compilers support what looks like a compound statement as a C/C++ expression.  For example to define the absolute value of an integer which guarantees that it will be read only once you may use:
		#define abs(a) { int b = a; b >= 0 ? b : -b; }
		The last expression in the list is the result.  To syntactically support the construct without running amuck we recognize the sequence and issue this message.  If you want to use the facility just suppress the message.
156	Braced initializer for scalar type 'Name'	An example of an initializer that will draw this complaint is as follows.
		int s[] = { { 1 } };
		After the compiler has seen the first curly it is expecting to see a number (or other numeric expression).  Compilers that strictly adhere to the ISO C and C++ Standards will flag this as ill-formed code.
		Note that it is legal (but somewhat arcane) to employ a left curly at the top-level when initializing an object of scalar type. For example, the following is well-formed:
		int i = { 0 };       // OK; initialize scalar i with 0.
		char *t = { "bar" }; // OK; initialize scalar t with a
		// pointer to a statically allocated array
		Also note: as the example above implies, this message can apply to pointers to arrays of char; it does not apply to arrays.
157	No data may follow an incomplete array	An incomplete array is allowed within a struct of a C99 or C++ program but no data is allowed to appear after this array.  For example:
		struct A { int x; int a[]; int b; };
		This diagnostic is issued when the 'b' is seen.
200-299		Some inconsistency or contradiction was discovered in the PC-lint/FlexeLint system.  This may or may not be the result of a user error.  This inconsistency should be brought to the attention of Gimpel Software.
301	Stack overflow	There was a stack overflow while processing declarations.  Approximately 50 nested declarators were found. For example, if a '/' followed by 50 consecutive '*'s were to introduce a box-like comment and if the '/' were omitted, then this message would be produced.  Cannot be suppressed.
302	Exceeded Available Memory	Main memory has been exhausted. Cannot be suppressed.
303	String too long (try +macros)	A single #define definition or macro invocation exceeded an internal limit (of 4096 characters). As the diagnostic indicates the problem can be corrected with an option.  Cannot be suppressed.
304	Corrupt object file, code Integer, symbol=String	A PC-lint/FlexeLint object file is apparently corrupted.  Please delete the object module and recreate it using the -oo option. See §7.3 "Producing a LOB".  The special code identifier number as well as a list of symbol names are optionally suffixed to the message as an aid in diagnosing the problem by technical support. Cannot be suppressed.
305	Unable to open module 'file name'	file name is the name of the file.  The named module could not be opened for reading. Perhaps you misspelled the name.  Cannot be suppressed.
306	Previously encountered module 'FileName'	FileName is the name of the module.  The named module was previously encountered. This is probably a user blunder.  May be suppressed.
307	Can't open indirect file 'FileName'	FileName is the name of the indirect file.  The named indirect file (ending in .lnt) could not be opened for reading.  Cannot be suppressed.
308	Can't write to standard out	stdout was found to equal NULL. This is most unusual.  Cannot be suppressed.
309	#error ...	The #error directive was encountered.  The ellipsis reflects the original line.  Normally processing is terminated at this point.  If you set the fce (continue on #error) flag, processing will continue.  May be suppressed.
310	Declaration too long: 'String...'	A single declaration was found to be too long for an internal buffer (about 2000 characters).  This occurred when attempting to write out the declaration using the -o... option.  The first 30 characters of the declaration is given in String.  Typically this is caused by a very long struct whose substructures, if any, are untagged. First identify the declaration that is causing the difficulty. If a struct or union, assign a tag to any unnamed substructures or subunion.  A typedef can also be used to reduce the size of such a declaration.  Cannot be suppressed.
312	Lint Object Module has obsolete or foreign version id	A lint object module was produced with a prior or different version of PC-lint/FlexeLint.  Delete the.lob file and recreate it using your new version of PC-lint/FlexeLint.  Cannot be suppressed.
313	Too many files	The number of files that PC-lint/FlexeLint can process has exceeded an internal limit.  The FlexeLint user may recompile his system to increase this limit.  Look for symbol FSETLEN in custom.h.  Currently, the number of files is limited to 4096.  Cannot be suppressed.
314	Previously used .lnt file: FileName	The indirect file named was previously encountered.  If this was not an accident, you may suppress this message.  May be suppressed.
315	Exceeded message limit (see -limit)	The maximum number of messages was exceeded.  Normally there is no limit unless one is imposed by the -limit(n) option.  (See §5.7 "Other Options".)  Cannot be suppressed.
316	Error while writing to file "file name"	The given file could not be opened for output.  Cannot be suppressed.
321	Declaration stack overflow	An overflow occurred in the stack used to contain array, pointer, function or reference modifiers when processing a declarator.  Cannot be suppressed.
322	Unable to open include file FileName	FileName is the name of the include file which could not be opened.  Directory search is controlled by options:  -i (see §5.7 "Other Options"), +fdi (§5.5 "Flag Options") and the INCLUDE environment variable.  This is a suppressible fatal message.  If option -e322 is used, Error message 7 will kick in.  A diagnostic will be issued but processing will continue.  May be suppressed.
323	Token String too long	In attempting to save a token for later reuse, a fixed size buffer was exceeded (governed by the size M_TOKEN).  Cannot be suppressed.
324	Too many symbols Integer	Too many symbols were encountered. An internal limit was reached.  Cannot be suppressed.
325	Cannot re-open file 'file name'	In the case of a large number of nested includes, files in the outer fringe need to be closed before new ones are opened.  These outer files then need to be re-opened.  An error occurred when attempting to re-open such a file.  Cannot be suppressed.
326	String 'String ...' too long, exceeds Integer characters	A string (first 40 characters provided in the message) exceeds some internal limit (provided in the message).  There is no antidote to this condition in the form of an option.  FlexeLint customers may recompile with a redefinition of either M_STRING (maximum string) or M_NAME (maximum name).  To override the definition in custom.h we suggest recompiling with an appropriate -dvar=value option assuming your compiler supports the option.  Cannot be suppressed.
401	symbol 'Symbol' not previously declared static at Location	The indicated Symbol declared static was previously declared without the static storage class.  This is technically a violation of the ANSI standard. Some compilers will accept this situation without complaint and regard the Symbol as static.
402	static function 'Symbol' (Location) not defined	The named Symbol was declared as a static function in the current module and was referenced but was not defined (in the module).
403	static symbol 'Symbol' has unusual type modifier	Some type modifiers such as _export are inconsistent with the static storage class.
404	struct not completed within file 'FileName'	A struct (or union or enum) definition was started within a header file but was not completed within the same header file.
405	#if not closed off within file 'FileName'	An #if construct was begun within a header file (name given) but was not completed within that header file.  Was this intentional?
406	Comment not closed off within file 'FileName'	A comment was begun within a header file (name given) but was not completed within that header file.  Was this intentional?
407	Inconsistent use of tag 'Symbol' conflicts with Location	A tag specified as a union, struct or enum was respecified as being one of the other two in the same module. For example:
		struct tag *p;
		union tag *q;
		will elicit this message.
408	Type mismatch with switch expression	The expression within a case does not agree exactly with the type within the switch expression.  For example, an enumerated type is matched against an int.
409	Expecting a pointer or array	An expression of the form i[...] was encountered where i is an integral expression.  This could be legitimate depending on the subscript operand.  For example, if i is an int and a is an array then i[a] is legitimate but unusual. If this is your coding style, suppress this message.
410	size_t not what was expected from fzl and/or fzu, using 'Type'	This warning is issued if you had previously attempted to set the type of sizeof by use of the options +fzl, -fzl, or -fzu, and a later size_t declaration contradicts the setting.  This usually means you are attempting to lint programs for another system using header files for your own system.  If this is the case we suggest you create a directory housing header files for that foreign system, alter size_t within that directory, and lint using that directory.
411	ptrdiff_t not what was expected from fdl option, using 'Type'	This warning is issued if you had previously attempted to set the type of pointer differences by use of the fdl option and a later ptrdiff_t declaration contradicts the setting.  See suggestion in Error Message 410.
412	Ambiguous format specifier '%X'	The format specifier %X when used with one of the scanf family, is ambiguous.  With Microsoft C it means %lx whereas in ANSI C it has the meaning of %x.  This ambiguous format specification has no place in any serious C program and should be replaced by one of the above.
413	Likely use of null pointer 'Symbol' in [left/right] argument to operator 'String' Reference	From information gleaned from earlier statements, it appears certain that a null pointer (a pointer whose value is 0) has been used in a context where null pointers are inappropriate.  These include:  Unary *, pointer increment (++) or decrement(--), addition of pointer to numeric, and subtraction of two pointers.  In the case of binary operators, one of the words 'left' or 'right' is used to designate which operand is null.  Symbol identifies the pointer variable that may be null.  See also messages 613 and 794, and §9.2 "Value Tracking".
414	Possible division by 0	The second argument to either the division operator (/) or the modulus operator (%) may be zero. Information is taken from earlier statements including assignments, initialization and tests.  See §9.2 "Value Tracking".
415	access of out-of-bounds pointer ('Integer' beyond end of data) by operator 'String'	An out-of-bounds pointer was accessed. String designates the operator.  The parameter 'Integer' gives some idea how far out of bounds the pointer may be.  It is measured in units given by the size of the pointed to object. The value is relative to the last item of good data and therefore should always be greater than zero.  For example:
		int a[10];
		a[10] = 0;
		results in an overflow message containing the phrase '1 beyond end of data'.  See §9.2 "Value Tracking".
416	creation of out-of-bounds pointer ('Integer' beyond end of data) by operator 'String'	An out-of-bounds pointer was created. See message 415 for a description of the parameters Integer and String.  For example:
		int a[10];
		...
		f( a + 11 );
		Here, an illicit pointer value is created and is flagged as such by PC-lint/FlexeLint.  Note that the pointer a+10 is not considered by PC-lint/FlexeLint to be the creation of an out-of-bounds pointer.  This is because ANSI C explicitly allows pointing just beyond an array.  Access through a+10, however, as in *(a+10) or the more familiar a[10], would be considered erroneous but in that case message 415 would be issued.  See §9.2 "Value Tracking".
417	integral constant 'String' longer than long long int	The longest possible integer is by default 8 bytes (see the +fll flag and then the -sll# option).  An integral constant was found to be even larger than such a quantity.  For example: 0xFFFF0000FFFF0000F.  String is the token in error.
418	Passing null pointer to function 'Symbol', Context Reference	A NULL pointer is being passed to a function identified by Symbol.  The argument in question is given by Context.  The function is either a library function designed not to receive a NULL pointer or a user function dubbed so via the option -function.  See §10.1 "Function Mimicry" and §10.2.1 "Possible Semantics".
419	Apparent data overrun for function 'Symbol', argument Integer exceeds argument Integer	This message is for data transfer functions such as memcpy, strcpy, fgets, etc. when the size indicated by the first cited argument (or arguments) exceeds the size of the buffer area cited by the second.  The message may also be issued for user functions via the -function option.  See §10.1 "Function Mimicry" and §10.2.1 "Possible Semantics".
420	Apparent access beyond array for function 'Symbol', argument Integer exceeds Integer Reference	This message is issued for several library functions (such as fwrite, memcmp, etc.) wherein there is an apparent attempt to access more data than exist.  For example, if the length of data specified in the fwrite call exceeds the size of the data specified.  The function is specified by Symbol and the arguments are identified by argument number.  See also §10.1 "Function Mimicry" and §10.2.1 "Possible Semantics".
421	Caution - function 'Symbol' is considered dangerous	This message is issued (by default) for the built-in function gets. This function is considered dangerous because there is no mechanism to ensure that the buffer provided as first argument will not overflow.  A well known computer virus (technically a worm) was created based on this defect.  Through the -function option, the user may designate other functions as dangerous.
422	Passing to function 'Symbol' a negative value (Integer), Context Reference	An integral value that appears to be negative is being passed to a function that is expecting only positive values for a particular argument.  The message contains the name of the function (Symbol), the questionable value (Integer) and the argument number (Context).  The function may be a standard library function designed to accept only positive values such as malloc or memcpy (third argument), or may have been identified by the user as such through the -function or -sem options.
		The negative integral value may in fact be unsigned.  Thus:
		void *malloc( unsigned );
		void f()
		{