msg.txt

PC-Lint是一种静态代码检测工具

      file.  See also Section 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.  (Section 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 infor
      mation 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.  (Section 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 Section
      5.)

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 Section 5.)

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 Section 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 (Section
      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