src/flags.def

   1 /*;-*-C-*-;
   2 **
   3 ** flags.def
   4 **
   5 ** This file is used to generate the flag header files.
   6 **
   7 ** Don't forget to regenerate flag_codes.gen. (lost the Makefile...bleech!)
   8 */
   9                              /* spec   idem   global  mode  args */
  10 /*@-namechecks@*/
  11 /*@notfunction@*/
  12 # define modeFlag               FALSE, FALSE, FALSE,  TRUE, ARG_NONE
  13 /*@notfunction@*/
  14 # define plainFlag              FALSE, FALSE, FALSE, FALSE, ARG_NONE
  15 /*@notfunction@*/
  16 # define specialFlag            TRUE,  FALSE, FALSE, FALSE, ARG_NONE
  17 /*@notfunction@*/
  18 # define plainSpecialFlag       TRUE,  FALSE, FALSE, FALSE, ARG_NONE
  19 /*@notfunction@*/
  20 # define idemSpecialFlag        TRUE,  TRUE,  FALSE, FALSE, ARG_NONE
  21 /*@notfunction@*/
  22 # define valueFlag              FALSE, FALSE, FALSE, FALSE, ARG_VALUE
  23 /*@notfunction@*/
  24 # define modeValueFlag          FALSE, FALSE, FALSE, TRUE,  ARG_VALUE
  25 /*@notfunction@*/
  26 # define specialValueFlag       TRUE,  FALSE, FALSE, FALSE, ARG_VALUE
  27 /*@notfunction@*/
  28 # define debugFlag              FALSE, TRUE,  FALSE, FALSE, ARG_NONE
  29 /*@notfunction@*/
  30 # define debugValueFlag         FALSE, TRUE,  FALSE, FALSE, ARG_VALUE
  31 /*@notfunction@*/
  32 # define specialDebugFlag       TRUE,  TRUE,  FALSE, FALSE, ARG_NONE
  33 /*@notfunction@*/
  34 # define globalFlag             FALSE, FALSE, TRUE,  FALSE, ARG_NONE
  35 /*@notfunction@*/
  36 # define idemGlobalFlag         FALSE, TRUE,  TRUE,  FALSE, ARG_NONE
  37 /*@notfunction@*/
  38 # define globalValueFlag        FALSE, FALSE, TRUE,  FALSE, ARG_VALUE
  39 /*@notfunction@*/
  40 # define regStringFlag          FALSE, FALSE, FALSE, FALSE, ARG_STRING
  41 /*@notfunction@*/
  42 # define idemStringFlag         FALSE, TRUE,  FALSE, FALSE, ARG_STRING
  43 /*@notfunction@*/
  44 # define globalStringFlag       FALSE, FALSE, TRUE,  FALSE, ARG_STRING
  45 /*@notfunction@*/
  46 # define extraArgFlag           FALSE, FALSE, FALSE, FALSE, ARG_SPECIAL
  47 /*@notfunction@*/
  48 # define globalExtraArgFlag     FALSE, FALSE, TRUE,  FALSE, ARG_SPECIAL
  49 /*@=namechecks@*/
  50
  51 /*
  52 ** Note: the flag code must be on a separate line, since I'm
  53 ** too stupid to write an awk/sed/whatever script that can separate
  54 ** the lines.
  55 */
  56
  57 static flaglist flags =
  58 {
  59   {
  60     FK_BOOL, FK_HELP, plainFlag,
  61     "likelybool",
  62     FLG_LIKELYBOOL,
  63     "type name is probably a boolean type but does not match default "
  64     "boolean type name, \"bool\", and alternate name is not set",
  65     "Use the -booltype, -boolfalse and -booltrue flags to change the "
  66     "name of the default boolean type.",
  67     0, 0
  68   },
  69   {
  70     FK_ABSTRACT, FK_IMPLICIT, plainFlag,
  71     "impabstract",
  72     FLG_IMPABSTRACT,
  73     "assume user type definitions are abstract (unless /*@concrete@*/ is used)",
  74     NULL,
  75     0, 0
  76   },
  77   {
  78     FK_ABSTRACT, FK_NAMES, specialFlag,
  79     "accessall",
  80     FLG_ACCESSALL,
  81     "set accessmodule, accessfile and accessczech",
  82     "Sets accessmodule, accessfile and accessczech",
  83     0, 0
  84   },
  85   {
  86     FK_ABSTRACT, FK_NAMES, plainFlag,
  87     "accessmodule",
  88     FLG_ACCESSMODULE,
  89     "allow access to abstract types in definition module",
  90     "The representation of an abstract type defined in <M>.<x> is "
  91     "accessible anywhere in a file named <M>.<y>.",
  92     0, 0
  93   },
  94   {
  95     FK_ABSTRACT, FK_NAMES, plainFlag,
  96     "accessfile",
  97     FLG_ACCESSFILE,
  98     "allow access to abstract types by file name convention",
  99     "The representation of an abstract type named <t> is "
 100     "accessible anywhere in a file named <t>.<x>.",
 101     0, 0
 102   },
 103   {
 104     FK_ABSTRACT, FK_NAMES, plainFlag,
 105     "accessczech",
 106     FLG_ACCESSCZECH,
 107     "allow access to abstract types by czech naming convention",
 108     "The representation of an abstract type named <t> is accessible "
 109     "in the definition of a function or constant named <t>_<name>",
 110     0, 0
 111   },
 112   {
 113     FK_ABSTRACT, FK_NAMES, plainFlag,
 114     "accessslovak",
 115     FLG_ACCESSSLOVAK,
 116     "allow access to abstract types by slovak naming convention",
 117     "The representation of an abstract type named <t> is accessible "
 118     "in the definition of a function or constant named <t><Name>",
 119     0, 0
 120   },
 121   {
 122     FK_ABSTRACT, FK_NAMES, plainFlag,
 123     "accessczechoslovak",
 124     FLG_ACCESSCZECHOSLOVAK,
 125     "allow access to abstract types by czechoslovak naming convention",
 126     "The representation of an abstract type named <t> is accessible "
 127     "in the definition of a function or constant named <t>_<name> or <t><Name>",
 128     0, 0
 129   },
 130   {
 131     FK_ABSTRACT, FK_NONE, plainFlag,
 132     "abstract",
 133     FLG_ABSTRACT,
 134     "data abstraction barriers",
 135     "An abstraction barrier is broken. If necessary, use /*@access <type>@*/ to allow access to an abstract type.",
 136     0, 0
 137   },
 138   {
 139     FK_ABSTRACT, FK_NONE, modeFlag,
 140     "mutrep",
 141     FLG_MUTREP,
 142     "representation of mutable type has sharing semantics",
 143     "LCL semantics requires that a mutable type exhibits sharing semantics. In order for objects to be shared a indirection is necessary in the representation. A mutable type may be represented by a pointer or an abstract mutable type. Handles into static data are fine, too, but will generate this error message unless it is suppressed.",
 144     0, 0
 145   },
 146   {
 147     FK_ALIAS, FK_GLOBALS, specialFlag,
 148     "globalias",
 149     FLG_GLOBALIAS,
 150     "function returns with global aliasing external state (sets "
 151     "checkstrictglobalias, checkedglobalias, checkmodglobalias and "
 152     "uncheckedglobalias)",
 153     "A global variable aliases externally-visible state when the function returns.",
 154     0, 0
 155   },
 156   {
 157     FK_ALIAS, FK_GLOBALS, modeFlag,
 158     "checkstrictglobalias",
 159     FLG_CHECKSTRICTGLOBALIAS,
 160     "function returns with a checkstrict global aliasing external state",
 161     "A global variable aliases externally-visible state when the function returns.",
 162     0, 0
 163   },
 164   {
 165     FK_ALIAS, FK_GLOBALS, modeFlag,
 166     "checkedglobalias",
 167     FLG_CHECKEDGLOBALIAS,
 168     "function returns with a checked global aliasing external state",
 169     "A global variable aliases externally-visible state when the function returns.",
 170     0, 0
 171   },
 172   {
 173     FK_ALIAS, FK_GLOBALS, modeFlag,
 174     "checkmodglobalias",
 175     FLG_CHECKMODGLOBALIAS,
 176     "function returns with a checkmod global aliasing external state",
 177     "A global variable aliases externally-visible state when the function returns.",
 178     0, 0
 179   },
 180   {
 181     FK_ALIAS, FK_GLOBALS, modeFlag,
 182     "uncheckedglobalias",
 183     FLG_UNCHECKEDGLOBALIAS,
 184     "function returns with an unchecked global aliasing external state",
 185     "A global variable aliases externally-visible state when the function returns.",
 186     0, 0
 187   },
 188   {
 189     FK_ALIAS, FK_MEMORY, modeFlag,
 190     "aliasunique",
 191     FLG_ALIASUNIQUE,
 192     "unique parameter is aliased",
 193     "A unique or only parameter is aliased by some other parameter or visible global.",
 194     0, 0
 195   },
 196   {
 197     FK_ALIAS, FK_MEMORY, modeFlag,
 198     "mayaliasunique",
 199     FLG_MAYALIASUNIQUE,
 200     "unique parameter may be aliased",
 201     "A unique or only parameter may be aliased by some other parameter or visible global.",
 202     0, 0
 203   },
 204   {
 205     FK_ALIAS, FK_MEMORY, modeFlag,
 206     "mustnotalias",
 207     FLG_MUSTNOTALIAS,
 208     "temp storage aliased at return point or scope exit",
 209     "An alias has been added to a temp-qualifier parameter or global that is visible externally when the function returns. If the aliasing is needed, use the /*@shared@*/ annotation to indicate that new aliases to the parameter may be created.",
 210     0, 0
 211   },
 212   {
 213     FK_ALIAS, FK_NONE, modeFlag,
 214     "retalias",
 215     FLG_RETALIAS,
 216     "function returns alias to parameter or global",
 217     "The returned value shares storage with a parameter or global. If a parameter is to be returned, use the returned qualifier. If the result is not modified, use the observer qualifier on the result type. Otherwise, exposed can be used, but limited checking is done.", 0, 0
 218   },
 219   {
 220     FK_ANSI, FK_PROTOS, modeFlag,
 221     "noparams",
 222     FLG_NOPARAMS,
 223     "function declaration has no parameter list",
 224     "A function declaration does not have a parameter list.",
 225     0, 0
 226   },
 227   {
 228     FK_ANSI, FK_PROTOS, modeFlag,
 229     "oldstyle",
 230     FLG_OLDSTYLE,
 231     "old style function definition",
 232     "Function definition is in old style syntax. Standard prototype "
 233     "syntax is preferred.",
 234     0, 0
 235   },
 236   {
 237     FK_ANSI, FK_SYNTAX, plainFlag,
 238     "gnuextensions",
 239     FLG_GNUEXTENSIONS,
 240     "support some gnu (gcc) language extensions",
 241     "ANSI C does not allow some language features supported by gcc and other compilers. "
 242     "Use +gnuextensions to allow some of these extensions.", 0, 0
 243   },
 244   {
 245     FK_ANSI, FK_NONE, plainFlag,
 246     "usevarargs",
 247     FLG_USEVARARGS,
 248     "non-standard <varargs.h> included",
 249     "Header <varargs.h> is not part of ANSI Standard. "
 250     "Should use <stdarg.h> instead.",
 251     0, 0
 252   },
 253   {
 254     FK_ANSI, FK_LIBS, plainFlag,
 255     "warnposixheaders",
 256     FLG_WARNPOSIX,
 257     "a POSIX header is included, but the POSIX library is not used",
 258     "Header name matches a POSIX header, but the POSIX library is not selected.",
 259     0, 0
 260   },
 261   {
 262     FK_BEHAVIOR, FK_ANSI, modeFlag,
 263     "exitarg",
 264     FLG_EXITARG,
 265     "argument to exit has implementation defined behavior",
 266     "The argument to exit should be 0, EXIT_SUCCESS or EXIT_FAILURE",
 267     0, 0
 268   },
 269   {
 270     FK_BEHAVIOR, FK_ANSI, modeFlag,
 271     "evalorder",
 272     FLG_EVALORDER,
 273     "code has unspecified or implementation-dependent behavior "
 274     "because of order of evaluation",
 275     "Code has unspecified behavior. "
 276     "Order of evaluation of function parameters or subexpressions "
 277     "is not defined, so if a value is used and modified in different "
 278     "places not separated by a sequence point constraining "
 279     "evaluation order, then the result of the expression is "
 280     "unspecified.",
 281     0, 0
 282   },
 283   {
 284     FK_BEHAVIOR, FK_ANSI, modeFlag,
 285     "evalorderuncon",
 286     FLG_EVALORDERUNCON,
 287     "code involving call to unspecified function has undefined or implementation-dependent behavior",
 288     "Code involving a call to function with no modifies or globals clause "
 289     "may have undefined or implementation-dependent behavior (LCLint assumes the "
 290     "unconstrained call may modify any reachable state or use any global). Add a "
 291     "specification for the function.",
 292     0, 0
 293   },
 294   {
 295     FK_BOOL, FK_NONE, regStringFlag,
 296     "boolfalse",
 297     FLG_BOOLFALSE,
 298     "set name of boolean false (default FALSE)",
 299     NULL, 0, 0
 300   },
 301   {
 302     FK_BOOL, FK_NONE, regStringFlag,
 303     "booltype",
 304     FLG_BOOLTYPE,
 305     "set name of boolean type (default bool)",
 306     NULL, 0, 0
 307   },
 308   {
 309     FK_BOOL, FK_NONE, regStringFlag,
 310     "booltrue",
 311     FLG_BOOLTRUE,
 312     "set name of boolean true (default TRUE)",
 313     NULL, 0, 0
 314   },
 315   {
 316     FK_COMMENTS, FK_ABSTRACT, plainFlag,
 317     "noaccess",
 318     FLG_NOACCESS,
 319     "ignore access comments",
 320     NULL, 0, 0
 321   },
 322   {
 323     FK_COMMENTS, FK_SUPPRESS, plainFlag,
 324     "nocomments",
 325     FLG_NOCOMMENTS,
 326     "ignore all stylized comments",
 327     NULL, 0, 0
 328   },
 329   {
 330     FK_COMMENTS, FK_SYNTAX, plainFlag,
 331     "unrecogcomments",
 332     FLG_UNRECOGCOMMENTS,
 333     "stylized comment is unrecognized",
 334     "Word after a stylized comment marker does not correspond to a "
 335     "stylized comment.",
 336     0, 0
 337   },
 338   {
 339     FK_COMMENTS, FK_SYNTAX, plainFlag,
 340     "unrecogflagcomments",
 341     FLG_UNRECOGFLAGCOMMENTS,
 342     "stylized flag comment uses an unrecognized flag",
 343     "Semantic comment attempts to set a flag that is not recognized.",
 344     0, 0
 345   },
 346   {
 347     FK_COMMENTS, FK_SYNTAX, plainFlag,
 348     "continuecomment",
 349     FLG_CONTINUECOMMENT,
 350     "line continuation marker (\\) in comment before */ on same line",
 351     "A line continuation marker (\\) appears inside a comment on the same "
 352     "line as the comment close. Preprocessors should handle this "
 353     "correctly, but it causes problems for some preprocessors.",
 354     0, 0
 355   },
 356   {
 357     FK_COMMENTS, FK_SYNTAX, plainFlag,
 358     "slashslashcomment",
 359     FLG_SLASHSLASHCOMMENT,
 360     "C++ style // comment",
 361     "A C++ style // comment is used here.  This type of comment has been officially supported in C99 and was often allowed by compiler extensions prior to this.  However, some older C89 compilers are not able to handle these comments.",
 362     0, 0
 363   },
 364   {
 365     FK_COMMENTS, FK_SYNTAX, plainFlag,
 366     "nestcomment",
 367     FLG_NESTCOMMENT,
 368     "comment begins inside comment",
 369     "A comment open sequence (/*) appears within a comment.  This usually "
 370     "means an earlier comment was not closed.",
 371     0, 0
 372   },
 373   {
 374     FK_COMMENTS, FK_SUPPRESS, modeFlag,
 375     "tmpcomments",
 376     FLG_TMPCOMMENTS,
 377     "interpret t comments (ignore errors in lines marked with /*@t<n>@*/",
 378     NULL, 0, 0
 379   },
 380   {
 381     FK_COMMENTS, FK_SUPPRESS, plainFlag,
 382     "lintcomments",
 383     FLG_LINTCOMMENTS,
 384     "interpret traditional lint comments (/*FALLTHROUGH*/, /*NOTREACHED*/)",
 385     NULL, 0, 0
 386   },
 387   {
 388     FK_COMMENTS, FK_SUPPRESS, modeFlag,
 389     "warnlintcomments",
 390     FLG_WARNLINTCOMMENTS,
 391     "print a warning and suggest an alternative when a traditional lint "
 392     "comment is used",
 393     "A traditional lint comment is used. Some traditional lint comments "
 394     "are interpreted by LCLint to enable easier checking of legacy "
 395     "code. It is preferable to replace these comments with the "
 396     "suggested LCLint alternative.",
 397     0, 0
 398   },
 399   {
 400     FK_COMPLETE, FK_NONE, modeFlag,
 401     "declundef",
 402     FLG_DECLUNDEF,
 403     "function or variable declared but never defined",
 404     "A function or variable is declared, but not defined in any source code file.",
 405     0, 0
 406   },
 407   {
 408     FK_COMPLETE, FK_SPEC, modeFlag,
 409     "specundef",
 410     FLG_SPECUNDEF,
 411     "function or variable specified but never defined",
 412     "A function or variable is declared in an .lcl file, but not defined in any source code file.",
 413     0, 0
 414   },
 415   {
 416     FK_COMPLETE, FK_SPEC, plainFlag,
 417     "specundecl",
 418     FLG_SPECUNDECL,
 419     "function or variable specified but never declared in a source file",
 420     "A function or variable is declared in an .lcl file, but not declared "
 421     "in any source code file.",
 422     0, 0
 423   },
 424   {
 425     FK_CONTROL, FK_MEMORY, modeFlag,
 426     "loopexec",
 427     FLG_LOOPEXEC,
 428     "assume all loops execute at least once",
 429     NULL, 0, 0
 430   },
 431   {
 432     FK_CONTROL, FK_NONE, plainFlag,
 433     "control",
 434     FLG_CONTROL,
 435     NULL, NULL,
 436     0, 0
 437   },
 438   {
 439     FK_CONTROL, FK_NONE, modeFlag,
 440     "infloops",
 441     FLG_INFLOOPS,
 442     "likely infinite loop is detected",
 443     "This appears to be an infinite loop. Nothing in the body of the "
 444     "loop or the loop test modifies the value of the loop test. "
 445     "Perhaps the specification of a function called in the loop "
 446     "body is missing a modification.",
 447     0, 0
 448   },
 449   {
 450     FK_CONTROL, FK_NONE, modeFlag,
 451     "infloopsuncon",
 452     FLG_INFLOOPSUNCON,
 453     "likely infinite loop is detected (may result from unconstrained function)",
 454     "This appears to be an infinite loop. Nothing in the body of the "
 455     "loop or the loop test modifies the value of the loop test. "
 456     "There may be a modification through a call to an unconstrained "
 457     "function, or an unconstrained function in the loop test may use "
 458     "a global variable modified by the loop body.",
 459     0, 0
 460   },
 461   {
 462     FK_CONTROL, FK_NONE, specialFlag,
 463     "deepbreak",
 464     FLG_DEEPBREAK,
 465     "break inside nested while or for or switch",
 466     "A break statement appears inside the body of a nested while, for or "
 467     "switch statement. Sets looploopbreak, loopswitchbreak, "
 468     "switchloopbreak, switchswitchbreak, and looploopcontinue.",
 469     0, 0
 470   },
 471   {
 472     FK_CONTROL, FK_NONE, modeFlag,
 473     "looploopbreak",
 474     FLG_LOOPLOOPBREAK,
 475     "break inside nested while or for",
 476     "A break statement appears inside the body of a nested while or for "
 477     "statement. This is perfectly reasonable code, but check that "
 478     "the break is intended to break only the inner loop. The "
 479     "break statement may be preceded by /*@innerbreak@*/ to suppress "
 480     "the message for this break only.",
 481     0, 0
 482   },
 483   {
 484     FK_CONTROL, FK_NONE, modeFlag,
 485     "switchloopbreak",
 486     FLG_SWITCHLOOPBREAK,
 487     "break in loop inside switch",
 488     "A break statement appears inside the body of a while or for "
 489     "statement within a switch. This is perfectly reasonable code, but check that "
 490     "the break is intended to break only the inner loop. The "
 491     "break statement may be preceded by /*@loopbreak@*/ to suppress "
 492     "the message for this break only.",
 493     0, 0
 494   },
 495   {
 496     FK_CONTROL, FK_NONE, modeFlag,
 497     "loopswitchbreak",
 498     FLG_LOOPSWITCHBREAK,
 499     "break in switch inside loop",
 500     "A break statement appears inside a switch statement within a while or "
 501     "for loop. This is perfectly reasonable code, but check that "
 502     "the break is intended to break only the inner loop. The "
 503     "break statement may be preceded by /*@switchbreak@*/ to suppress "
 504     "the message for this break only.",
 505     0, 0
 506   },
 507   {
 508     FK_CONTROL, FK_NONE, modeFlag,
 509     "switchswitchbreak",
 510     FLG_SWITCHSWITCHBREAK,
 511     "break in switch inside switch",
 512     "A break statement appears inside a switch statement within another "
 513     "switch statement. This is perfectly reasonable code, but check that "
 514     "the break is intended to break only the inner switch. The "
 515     "break statement may be preceded by /*@innerbreak@*/ to suppress "
 516     "the message for this break only.",
 517     0, 0
 518   },
 519   {
 520     FK_CONTROL, FK_NONE, modeFlag,
 521     "looploopcontinue",
 522     FLG_LOOPLOOPCONTINUE,
 523     "continue inside nested loop",
 524     "A continue statement appears inside a loop within a loop. "
 525     "This is perfectly reasonable code, but check that "
 526     "the continue is intended to continue only the inner loop. The "
 527     "continue statement may be preceded by /*@innercontinue@*/ to suppress "
 528     "the message for this continue only.",
 529     0, 0
 530   },
 531   {
 532     FK_CONTROL, FK_NONE, modeFlag,
 533     "unreachable",
 534     FLG_UNREACHABLE,
 535     "unreachable code detected",
 536     "This code will never be reached on any possible execution.",
 537     0, 0
 538   },
 539   {
 540     FK_CONTROL, FK_NONE, modeFlag,
 541     "whileempty",
 542     FLG_WHILEEMPTY,
 543     "a while statement has no body",
 544     "While statement has no body.",
 545     0, 0
 546   },
 547   {
 548     FK_CONTROL, FK_NONE, modeFlag,
 549     "whileblock",
 550     FLG_WHILEBLOCK,
 551     "the body of a while statement is not a block",
 552     "While body is a single statement, not a compound block.",
 553     0, 0
 554   },
 555   {
 556     FK_CONTROL, FK_NONE, modeFlag,
 557     "forempty",
 558     FLG_FOREMPTY,
 559     "a for statement has no body",
 560     "For statement has no body.",
 561     0, 0
 562   },
 563   {
 564     FK_CONTROL, FK_NONE, modeFlag,
 565     "forblock",
 566     FLG_FORBLOCK,
 567     "the body of a for statement is not a block",
 568     "Loop body is a single statement, not a compound block.",
 569     0, 0
 570   },
 571   {
 572     FK_CONTROL, FK_NONE, modeFlag,
 573     "ifempty",
 574     FLG_IFEMPTY,
 575     "an if statement has no body",
 576     "If statement has no body.",
 577     0, 0
 578   },
 579   {
 580     FK_CONTROL, FK_NONE, modeFlag,
 581     "ifblock",
 582     FLG_IFBLOCK,
 583     "the body of an if statement is not a block",
 584     "If body is a single statement, not a compound block.",
 585     0, 0
 586   },
 587   {
 588     FK_CONTROL, FK_NONE, specialFlag,
 589     "allempty",
 590     FLG_ALLEMPTY,
 591     "an if, while or for statement has no body (sets ifempty, "
 592     "whileempty and forempty",
 593     NULL,
 594     0, 0
 595   },
 596   {
 597     FK_CONTROL, FK_NONE, specialFlag,
 598     "allblock",
 599     FLG_ALLBLOCK,
 600     "the body of an if, while or for statement is not a block "
 601     "(sets ifblock, whileblock and forblock)",
 602     "Body is a single statement, not a compound block.",
 603     0, 0
 604   },
 605   {
 606     FK_CONTROL, FK_NONE, modeFlag,
 607     "elseifcomplete",
 608     FLG_ELSEIFCOMPLETE,
 609     "if ... else if chains must have final else",
 610     "There is no final else following an else if construct.",
 611     0, 0
 612   },
 613   {
 614     FK_CONTROL, FK_NONE, modeFlag,
 615     "noret",
 616     FLG_NORETURN,
 617     "path with no return detected in non-void function",
 618     "There is a path through a function declared to return a value on "
 619     "which there is no return statement. This means the execution "
 620     "may fall through without returning a meaningful result to "
 621     "the caller.",
 622     0, 0
 623   },
 624   {
 625     FK_CONTROL, FK_NONE, modeFlag,
 626     "casebreak",
 627     FLG_CASEBREAK,
 628     "non-empty case in a switch without preceding break",
 629     "Execution falls through from the previous case.", 0, 0
 630   },
 631   {
 632     FK_CONTROL, FK_NONE, modeFlag,
 633     "misscase",
 634     FLG_MISSCASE,
 635     "switch on enum type missing case for some value",
 636     "Not all values in an enumeration are present as cases in the switch.",
 637     0, 0
 638   },
 639   {
 640     FK_CONTROL, FK_NONE, modeFlag,
 641     "firstcase",
 642     FLG_FIRSTCASE,
 643     "first statement in switch is not a case",
 644     "The first statement after a switch is not a case.",
 645     0, 0
 646   },
 647   {
 648     FK_DEBUG, FK_NONE, specialDebugFlag,
 649     "grammar",
 650     FLG_GRAMMAR,
 651     NULL, NULL,
 652     0, 0
 653   },
 654   {
 655     FK_DEBUG, FK_NONE, debugFlag,
 656     "nopp",
 657     FLG_NOPP,
 658     NULL, NULL,
 659     0, 0
 660   },
 661   {
 662     FK_DECL, FK_NONE, modeFlag,
 663     "shadow",
 664     FLG_SHADOW,
 665     "declaration reuses name visible in outer scope",
 666     "An outer declaration is shadowed by the local declaration.",
 667     0, 0
 668   },
 669   {
 670     FK_DECL, FK_LIBS, modeFlag,
 671     "incondefslib",
 672     FLG_INCONDEFSLIB,
 673     "function, variable or constant defined in a library is redefined with inconsistent type",
 674     "A function, variable or constant previously defined in a library is "
 675     "redefined with a different type.",
 676     0, 0
 677   },
 678   {
 679     FK_DECL, FK_LIBS, modeFlag,
 680     "overload",
 681     FLG_WARNOVERLOAD,
 682     "library function overloaded",
 683     "A function, variable or constant defined in the library is redefined "
 684     "with a different type.",
 685     0, 0
 686   },
 687   {
 688     FK_DECL, FK_NONE, modeFlag,
 689     "nestedextern",
 690     FLG_NESTEDEXTERN,
 691     "an extern declaration is inside a function scope",
 692     "An extern declaration is used inside a function scope.",
 693     0, 0
 694   },
 695   {
 696     FK_DECL, FK_NONE, modeFlag,
 697     "redecl",
 698     FLG_REDECL,
 699     "function or variable redeclared",
 700     "A function or variable is declared in more than one place. This is "
 701     "not necessarily a problem, since the declarations are consistent.",
 702     0, 0
 703   },
 704   {
 705     FK_DECL, FK_NONE, plainFlag,
 706     "redef",
 707     FLG_REDEF,
 708     "function or variable redefined",
 709     "A function or variable is redefined. One of the declarations should use extern.",
 710     0, 0
 711   },
 712   {
 713     FK_DECL, FK_TYPE, modeFlag,
 714     "incondefs",
 715     FLG_INCONDEFS,
 716     "function, variable or constant redefined with inconsistent type",
 717     "A function, variable or constant is redefined with a different type.",
 718     0, 0
 719   },
 720   {
 721     FK_DECL, FK_TYPE, modeFlag,
 722     "imptype",
 723     FLG_IMPTYPE,
 724     "variable declaration has unknown (implicitly int) type",
 725     "A variable declaration has no explicit type.  The type is implicitly int.",
 726     0, 0
 727   },
 728   {
 729     FK_DECL, FK_TYPE, modeFlag,
 730     "matchfields",
 731     FLG_MATCHFIELDS,
 732     "struct or enum type redefined with inconsistent fields or members",
 733     "A struct, union or enum type is redefined with inconsistent fields or members.",
 734     0, 0
 735   },
 736   {
 737     FK_DEF, FK_NONE, modeFlag,
 738     "usedef",
 739     FLG_USEDEF,
 740     "use before definition",
 741     "An rvalue is used that may not be initialized to a value on some execution path.",
 742     0, 0
 743   },
 744   {
 745     FK_DEF, FK_IMPLICIT, modeFlag,
 746     "impouts",
 747     FLG_IMPOUTS,
 748     "pointer parameters to unspecified functions may be implicit out parameters",
 749     NULL, 0, 0
 750   },
 751   {
 752     FK_DIRECT, FK_FILES, globalStringFlag,
 753     "tmpdir",
 754     FLG_TMPDIR,
 755     "set directory for writing temp files",
 756     NULL, 0, 0
 757   },
 758   {
 759     FK_DIRECT, FK_FILES, globalStringFlag,
 760     "larchpath",
 761     FLG_LARCHPATH,
 762     "set path for searching for library files (overrides LARCH_PATH environment variable)",
 763     NULL, 0, 0
 764   },
 765   {
 766     FK_DIRECT, FK_FILES, globalStringFlag,
 767     "lclimportdir",
 768     FLG_LCLIMPORTDIR,
 769     "set directory to search for LCL import files (overrides LCLIMPORTDIR)",
 770     NULL, 0, 0
 771   },
 772   {
 773     FK_DIRECT, FK_FILES, globalStringFlag,
 774     "sysdirs",
 775     FLG_SYSTEMDIRS,
 776     "set directories for system files (default /usr/include). Separate "
 777     "directories with path separator (colons in Unix, semi-colons in Windows). "
 778     "Flag settings propagate to files in a system directory. If "
 779     "-sysdirerrors is set, no errors are reported for files in "
 780     "system directories.",
 781     NULL, 0, 0
 782   },
 783   {
 784     FK_DIRECT, FK_FILES, plainFlag,
 785     "skipansiheaders",
 786     FLG_SKIPANSIHEADERS,
 787     "prevent inclusion of header files in a system directory with "
 788     "names that match standard ANSI headers. The symbolic information "
 789     "in the standard library is used instead.  Flag in effect only "
 790     "if a library including the ANSI library is loaded.  The ANSI "
 791     "headers are: assert, ctype, errno, float, limits, locale, math, "
 792     "setjmp, signal, stdarg, stddef, stdio, stdlib, strings, string, "
 793     "time, and wchar.",
 794     NULL, 0, 0
 795   },
 796   {
 797     FK_DIRECT, FK_FILES, plainFlag,
 798     "skipposixheaders",
 799     FLG_SKIPPOSIXHEADERS,
 800     "prevent inclusion of header files in a system directory with "
 801     "names that match standard POSIX headers. The symbolic information "
 802     "in the posix library is used instead.  The POSIX headers are: "
 803     "dirent, fcntl, grp, pwd, termios, sys/stat, sys/times, "
 804     "sys/types, sys/utsname, sys/wait, unistd, and utime.",
 805     NULL, 0, 0
 806   },
 807   {
 808     FK_DIRECT, FK_SUPPRESS, modeFlag,
 809     "sysdirerrors",
 810     FLG_SYSTEMDIRERRORS,
 811     "report errors in files in system directories (set by -sysdirs)",
 812     NULL, 0, 0
 813   },
 814   {
 815     FK_HEADERS, FK_MACROS, plainFlag,
 816     "sysdirexpandmacros",
 817     FLG_SYSTEMDIREXPAND,
 818     "expand macros in system directories regardless of other settings, "
 819     "except for macros corresponding to names defined in a load library",
 820     NULL, 0, 0
 821   },
 822
 823   {
 824     FK_DIRECT, FK_HEADERS, globalExtraArgFlag,
 825     "I<directory>",
 826     FLG_INCLUDEPATH,
 827     "add to C include path",
 828     NULL, 0, 0
 829   },
 830   {
 831     FK_DIRECT, FK_SPEC, globalExtraArgFlag,
 832     "S<directory>",
 833     FLG_SPECPATH,
 834     "add to spec path",
 835     NULL, 0, 0
 836   },
 837   {
 838     FK_DISPLAY, FK_ERRORS, plainFlag,
 839     "quiet",
 840     FLG_QUIET,
 841     "suppress herald and error count",
 842     NULL, 0, 0
 843   },
 844   {
 845     FK_DISPLAY, FK_ERRORS, plainFlag,
 846     "usestderr",
 847     FLG_USESTDERR,
 848     "send error messages to standard error (instead of standard out)",
 849     NULL, 0, 0
 850   },
 851   {
 852     FK_DISPLAY, FK_ERRORS, plainFlag,
 853     "showsummary",
 854     FLG_SHOWSUMMARY,
 855     "show summary of all errors reported and suppressed",
 856     NULL, 0, 0
 857   },
 858   {
 859     FK_DISPLAY, FK_FILES, plainFlag,
 860     "showscan",
 861     FLG_SHOWSCAN,
 862     "show file names are they are processed",
 863     NULL, 0, 0
 864   },
 865   {
 866     FK_DISPLAY, FK_NONE, globalFlag,
 867     "stats",
 868     FLG_STATS,
 869     "display lines processed and time",
 870     NULL, 0, 0
 871   },
 872   {
 873     FK_DISPLAY, FK_NONE, globalFlag,
 874     "timedist",
 875     FLG_TIMEDIST,
 876     "display time distribution",
 877     NULL, 0, 0
 878   },
 879   {
 880     FK_DISPLAY, FK_USE, globalFlag,
 881     "showalluses",
 882     FLG_SHOWUSES,
 883     "show sorted list of uses of all globals",
 884     NULL, 0, 0
 885   },
 886   {
 887     FK_EFFECT, FK_CONTROL, modeFlag,
 888     "noeffect",
 889     FLG_NOEFFECT,
 890     "statement with no effect",
 891     "Statement has no visible effect --- no values are modified.",
 892     0, 0
 893   },
 894   {
 895     FK_EFFECT, FK_CONTROL, modeFlag,
 896     "noeffectuncon",
 897     FLG_NOEFFECTUNCON,
 898     "statement with no effect (except possibly through call to "
 899     "unconstrained function)",
 900     "Statement has no visible effect --- no values are modified. It may "
 901     "modify something through a call to an unconstrained function.",
 902     0, 0
 903   },
 904   {
 905     FK_EXPORT, FK_SPEC, specialFlag,
 906     "exportany",
 907     FLG_EXPORTANY,
 908     "variable, function or type exported but not specified",
 909     "A variable, function or type is exported, but not specified.",
 910     0, 0
 911   },
 912   {
 913     FK_EXPORT, FK_SPEC, modeFlag,
 914     "exportfcn",
 915     FLG_EXPORTFCN,
 916     "function exported but not specified",
 917     "A function is exported, but not specified.", 0, 0
 918   },
 919   {
 920     FK_EXPORT, FK_SPEC, modeFlag,
 921     "exportmacro",
 922     FLG_EXPORTMACRO,
 923     "expanded macro exported but not specified",
 924     "A macro is exported, but not specified.", 0, 0
 925   },
 926   {
 927     FK_EXPORT, FK_SPEC, modeFlag,
 928     "exporttype",
 929     FLG_EXPORTTYPE,
 930     "type definition exported but not specified",
 931     "A type is exported, but not specified.", 0, 0
 932   },
 933   {
 934     FK_EXPORT, FK_SPEC, modeFlag,
 935     "exportvar",
 936     FLG_EXPORTVAR,
 937     "variable exported but not specified",
 938     "A variable is exported, but not specified.", 0, 0
 939   },
 940   {
 941     FK_EXPORT, FK_SPEC, modeFlag,
 942     "exportconst",
 943     FLG_EXPORTCONST,
 944     "constant exported but not specified",
 945     "A constant is exported, but not specified.", 0, 0
 946   },
 947   {
 948     FK_EXPORT, FK_SPEC, modeFlag,
 949     "exportiter",
 950     FLG_EXPORTITER,
 951     "constant exported but not specified",
 952     "A constant is exported, but not specified.", 0, 0
 953   },
 954   {
 955     FK_EXPOSURE, FK_ABSTRACT, specialFlag,
 956     "repexpose",
 957     FLG_REPEXPOSE,
 958     "abstract representation is exposed (sets assignexpose, retexpose, and castexpose)",
 959     "The internal representation of an abstract type is visible to the "
 960     "caller. This means clients may have access to a pointer "
 961     "into the abstract representation.",
 962     0, 0
 963   },
 964   {
 965     FK_EXPOSURE, FK_ABSTRACT, modeFlag,
 966     "retexpose",
 967     FLG_RETEXPOSE,
 968     "abstract representation is exposed (return values only)",
 969     "The return value shares storage with an instance of an abstract "
 970     "type. This means clients may have access to a pointer into "
 971     "the abstract representation. Use the observer qualifier to "
 972     "return exposed storage that may not be modified by the "
 973     "client. Use the exposed qualifier to return modifiable "
 974     "(but not deallocatable) exposed storage (dangerous).",
 975     0, 0
 976   },
 977   {
 978     FK_EXPOSURE, FK_ABSTRACT, modeFlag,
 979     "assignexpose",
 980     FLG_ASSIGNEXPOSE,
 981     "abstract representation is exposed (assignments only)",
 982     "Storage internal to the representation of an abstract type is "
 983     "assigned to an external pointer. This means clients may "
 984     "have access to a pointer into the abstract representation. "
 985     "If the external pointer is a parameter, the exposed qualifier "
 986     "can be used to allow the assignment, however, this is "
 987     "considered dangerous programming practice.",
 988     0, 0
 989   },
 990   {
 991     FK_EXPOSURE, FK_ABSTRACT, modeFlag,
 992     "castexpose",
 993     FLG_CASTEXPOSE,
 994     "abstract representation is exposed through a cast",
 995     "Storage internal to the representation of an abstract type is exposed "
 996     "through a type cast. This means clients may have access to a "
 997     "pointer into the abstract representation.",
 998     0, 0
 999   },
1000
1001   {
1002     FK_FORMAT, FK_DISPLAY, valueFlag,
1003     "linelen",
1004     FLG_LINELEN,
1005     "set length of messages (number of chars)",
1006     NULL, 0, 0
1007   },
1008   {
1009     FK_FORMAT, FK_DISPLAY, valueFlag,
1010     "indentspaces",
1011     FLG_INDENTSPACES,
1012     "set number of spaces to indent sub-messages",
1013     NULL, 0, 0
1014   },
1015   {
1016     FK_FORMAT, FK_DISPLAY, plainFlag,
1017     "showcolumn",
1018     FLG_SHOWCOL,
1019     "show column number where error is found",
1020     NULL, 0, 0
1021   },
1022   {
1023     FK_FORMAT, FK_DISPLAY, plainFlag,
1024     "parenfileformat",
1025     FLG_PARENFILEFORMAT,
1026     "show column number where error is found",
1027     NULL, 0, 0
1028   },
1029   {
1030     FK_FORMAT, FK_NONE, plainFlag,
1031     "showfunc",
1032     FLG_SHOWFUNC,
1033     "show name of function containing error",
1034     NULL, 0, 0
1035   },
1036   {
1037     FK_FORMAT, FK_NONE, plainFlag,
1038     "showallconjs",
1039     FLG_SHOWALLCONJS,
1040     "show all possible types",
1041     "When a library function is declared with multiple possible type, the "
1042     "alternate types are shown only if +showallconjs.",
1043     0, 0
1044   },
1045   {
1046     FK_LIBS, FK_NONE, plainFlag,
1047     "impconj",
1048     FLG_IMPCONJ,
1049     "make all alternate types implicit (useful for making system libraries",
1050     NULL, 0, 0
1051   } ,
1052   {
1053     FK_GLOBAL, FK_ERRORS, globalValueFlag,
1054     "expect",
1055     FLG_EXPECT,
1056     "expect <int> code errors",
1057     NULL, 0, 0
1058   },
1059   {
1060     FK_GLOBAL, FK_ERRORS, globalValueFlag,
1061     "lclexpect",
1062     FLG_LCLEXPECT,
1063     "expect <int> spec errors",
1064     NULL, 0, 0
1065   },
1066   {
1067     FK_GLOBAL, FK_USE, idemSpecialFlag,
1068     "partial",
1069     FLG_PARTIAL,
1070     "check as partial system (-specundef, -declundef, -exportlocal, "
1071     "don't check macros in headers without corresponding .c files)",
1072     NULL, 0, 0
1073   },
1074   {
1075     FK_GLOBALS, FK_SPEC, plainFlag,
1076     "globs",
1077     FLG_GLOBALS,
1078     "undocumented use of a checked global variable",
1079     "A checked global variable is used in the function, but not listed in "
1080     "its globals clause. By default, only globals specified in .lcl "
1081     "files are checked. To check all globals, use +allglobals. To "
1082     "check globals selectively use /*@checked@*/ in the global "
1083     "declaration.",
1084     0, 0
1085   },
1086   {
1087     FK_GLOBALS, FK_SPEC, modeFlag,
1088     "globuse",
1089     FLG_USEALLGLOBS,
1090     "global listed for a function not used",
1091     "A global variable listed in the function's globals list is not used "
1092     "in the body of the function.",
1093     0, 0
1094   },
1095   {
1096     FK_GLOBALS, FK_NONE, modeFlag,
1097     "internalglobs",
1098     FLG_INTERNALGLOBS,
1099     "use of internalState",
1100     "A called function uses internal state, but the globals list for the "
1101     "function being checked does not include internalState",
1102     0, 0
1103   },
1104   {
1105     FK_GLOBALS, FK_NONE, modeFlag,
1106     "internalglobsnoglobs",
1107     FLG_INTERNALGLOBSNOGLOBS,
1108     "use of internalState (in function with no globals list)",
1109     "A called function uses internal state, but the function being checked "
1110     "has no globals list",
1111     0, 0
1112   },
1113   {
1114     FK_GLOBALS, FK_MODIFIES, modeFlag,
1115     "warnmissingglobs",
1116     FLG_WARNMISSINGGLOBALS,
1117     "global variable used in modifies clause is not listed in globals list",
1118     "A global variable is used in the modifies clause, but it not listed in "
1119     "the globals list.  The variable will be added to the globals list.",
1120     0, 0
1121   },
1122
1123   {
1124     FK_GLOBALS, FK_MODIFIES, modeFlag,
1125     "warnmissingglobsnoglobs",
1126     FLG_WARNMISSINGGLOBALSNOGLOBS,
1127     "global variable used in modifies clause in a function with no globals list",
1128     "A global variable is used in the modifies clause, but the function "
1129     "has no globals list.  The variable will be added to the globals list.",
1130     0, 0
1131   },
1132   {
1133     FK_GLOBALS, FK_UNSPEC, modeFlag,
1134     "globnoglobs",
1135     FLG_GLOBUNSPEC,
1136     "use of checked global in a function with no globals list or specification",
1137     "A specified global variable is used in the function, but not listed "
1138     "in its globals list. Without +globnoglobs, only globals "
1139     "declared with /*@checkedstrict@*/ will produce use "
1140     "errors in functions without globals "
1141     "lists. The /*@globals ... @*/ control comment can be used to give "
1142     "a globals list for an unspecified function.",
1143     0, 0
1144   },
1145   {
1146     FK_GLOBALS, FK_IMPLICIT, modeFlag,
1147     "allglobs",
1148     FLG_ALLGLOBALS,
1149     "report use and modification errors for globals not annotated with unchecked",
1150     NULL, 0, 0
1151   },
1152   {
1153     FK_GLOBALS, FK_UNSPEC, modeFlag,
1154     "checkstrictglobs",
1155     FLG_CHECKSTRICTGLOBALS,
1156     "report use and modification errors for checkedstrict globals",
1157     NULL, 0, 0
1158   },
1159   {
1160     FK_GLOBALS, FK_UNSPEC, modeFlag,
1161     "impcheckedspecglobs",
1162     FLG_IMPCHECKEDSPECGLOBALS,
1163     "assume checked qualifier for unqualified global declarations in .lcl files",
1164     NULL, 0, 0
1165   },
1166   {
1167     FK_GLOBALS, FK_UNSPEC, modeFlag,
1168     "impcheckmodspecglobs",
1169     FLG_IMPCHECKMODSPECGLOBALS,
1170     "assume checkmod qualifier for unqualified global declarations in .lcl files",
1171     NULL, 0, 0
1172   },
1173   {
1174     FK_GLOBALS, FK_UNSPEC, modeFlag,
1175     "impcheckedstrictspecglobs",
1176     FLG_IMPCHECKEDSTRICTSPECGLOBALS,
1177     "assume checkmod qualifier for unqualified global declarations in .lcl files",
1178     NULL, 0, 0
1179   },
1180   {
1181     FK_GLOBALS, FK_UNSPEC, modeFlag,
1182     "impcheckedglobs",
1183     FLG_IMPCHECKEDGLOBALS,
1184     "assume checked qualifier for unqualified global declarations",
1185     NULL, 0, 0
1186   },
1187   {
1188     FK_GLOBALS, FK_UNSPEC, modeFlag,
1189     "impcheckmodglobs",
1190     FLG_IMPCHECKMODGLOBALS,
1191     "assume checkmod qualifier for unqualified global declarations",
1192     NULL, 0, 0
1193   },
1194   {
1195     FK_GLOBALS, FK_UNSPEC, modeFlag,
1196     "impcheckedstrictglobs",
1197     FLG_IMPCHECKEDSTRICTGLOBALS,
1198     "assume checkedstrict qualifier for unqualified global declarations",
1199     NULL, 0, 0
1200   },
1201   {
1202     FK_GLOBALS, FK_UNSPEC, modeFlag,
1203     "impcheckedstatics",
1204     FLG_IMPCHECKEDSTATICS,
1205     "assume checked qualifier for unqualified file static declarations",
1206     NULL, 0, 0
1207   },
1208   {
1209     FK_GLOBALS, FK_UNSPEC, modeFlag,
1210     "impcheckmodstatics",
1211     FLG_IMPCHECKMODSTATICS,
1212     "assume checkmod qualifier for unqualified file static declarations",
1213     NULL, 0, 0
1214   },
1215   {
1216     FK_GLOBALS, FK_UNSPEC, modeFlag,
1217     "impcheckmodinternals",
1218     FLG_IMPCHECKMODINTERNALS,
1219     "assume checkmod qualifier for unqualified local "
1220     "static declarations (for internal state modifications)",
1221     NULL, 0, 0
1222   },
1223   {
1224     FK_GLOBALS, FK_UNSPEC, modeFlag,
1225     "impcheckedstrictstatics",
1226     FLG_IMPCHECKEDSTRICTSTATICS,
1227     "assume checkedstrict qualifier for unqualified file static declarations",
1228     NULL, 0, 0
1229   },
1230   {
1231     FK_GLOBALS, FK_MODIFIES, modeFlag,
1232     "modglobs",
1233     FLG_MODGLOBS,
1234     "undocumented modification of a checked global variable",
1235     "A checked global variable is modified by the function, but not listed in "
1236     "its modifies clause.",
1237     0, 0
1238   },
1239   {
1240     FK_GLOBALS, FK_MODIFIES, modeFlag,
1241     "modglobsnomods",
1242     FLG_MODGLOBSUNSPEC,
1243     "undocumented modification of a checked global variable in a function "
1244     "declared with no modifies clause",
1245     "A checked global variable is modified by the function, but not listed in "
1246     "its modifies clause.",
1247     0, 0
1248   },
1249   {
1250     FK_GLOBALS, FK_MODIFIES, modeFlag,
1251     "modstrictglobsnomods",
1252     FLG_MODSTRICTGLOBSUNSPEC,
1253     "undocumented modification of a strict checked global variable in a "
1254     "function declared with no modifies clause",
1255     "A checked global variable is modified by the function, but not listed in "
1256     "its modifies clause.",
1257     0, 0
1258   },
1259   {
1260     FK_GLOBALS, FK_MODIFIES, modeFlag,
1261     "modglobsunchecked",
1262     FLG_MODGLOBSUNCHECKED,
1263     "undocumented modification of an unchecked checked global variable",
1264     "An unchecked global variable is modified by the function, but not listed in "
1265     "its modifies clause.",
1266     0, 0
1267   },
1268   {
1269     FK_HEADERS, FK_DEBUG, debugFlag,
1270     "keep",
1271     FLG_KEEP,
1272     NULL, NULL,
1273     0, 0
1274   },
1275   {
1276     FK_HEADERS, FK_SPEC, globalFlag,
1277     "lh",
1278     FLG_DOLH,
1279     "generate .lh files", NULL,
1280     0, 0
1281   },
1282   {
1283     FK_HEADERS, FK_SPEC, globalFlag,
1284     "lcs",
1285     FLG_DOLCS,
1286     "generate .lcs files", NULL,
1287     0, 0
1288   },
1289   {
1290     FK_HEADERS, FK_SPEED, globalFlag,
1291     "singleinclude",
1292     FLG_SINGLEINCLUDE,
1293     "optimize header inclusion to eliminate redundant includes",
1294     "When checking multiple files, each header file is processed only "
1295     "once. This may change the meaning of the code, if the "
1296     "same header file is included in different contexts (e.g., the "
1297     "header file includes #if directives and the values are "
1298     "different when it is included in different places.)",
1299     0, 0
1300   },
1301   {
1302     FK_HEADERS, FK_SPEED, globalFlag,
1303     "neverinclude",
1304     FLG_NEVERINCLUDE,
1305     "optimize header inclusion to not include any header files",
1306     "Ignore header includes. Only works if relevant information is "
1307     "loaded from a library.",
1308     0, 0
1309   },
1310   {
1311     FK_HEADERS, FK_SPEED, globalFlag,
1312     "skipsysheaders",
1313     FLG_SKIPSYSHEADERS,
1314     "do not include header files in system directories (set by -sysdirs)",
1315     "Do not include header files in system directories (set by -sysdirs)",
1316     0, 0
1317   },
1318   {
1319     FK_HELP, FK_NONE, plainFlag,
1320     "warnflags",
1321     FLG_WARNFLAGS,
1322     "warn when command line sets flag to default value in mode",
1323     NULL, 0, 0
1324   },
1325   {
1326     FK_HELP, FK_NONE, plainFlag,
1327     "warnunixlib",
1328     FLG_WARNUNIXLIB,
1329     "warn when the unix library is used",
1330     NULL, 0, 0
1331   },
1332   {
1333     FK_HELP, FK_NONE, plainFlag,
1334     "badflag",
1335     FLG_BADFLAG,
1336     "warn about bad command line flags",
1337     "A flag is not recognized or used in an incorrect way",
1338     0, 0
1339   },
1340   {
1341     FK_HELP, FK_NONE, plainFlag,
1342     "forcehints",
1343     FLG_FORCEHINTS,
1344     "provide hints for all errors reported",
1345     NULL, 0, 0
1346   },
1347   {
1348     FK_HELP, FK_NONE, globalExtraArgFlag,
1349     "help",
1350     FLG_HELP,
1351     "-help <flags> will describe flags",
1352     NULL, 0, 0
1353   },
1354   {
1355     FK_HELP, FK_FORMAT, plainFlag,
1356     "hints",
1357     FLG_HINTS,
1358     "provide hints on using lclint (hint only reported for first related error)",
1359     NULL, 0, 0
1360   },
1361   {
1362     FK_IGNORERET, FK_NONE, specialFlag,
1363     "retval",
1364     FLG_RETVAL,
1365     "return value ignored (sets retvalint, retvalbool and retvalother)",
1366     "Result returned by function call is not used. If this is intended, "
1367     "cast result to (void) to eliminate message.",
1368     0, 0
1369   },
1370   {
1371     FK_IGNORERET, FK_BOOL, modeFlag,
1372     "retvalother",
1373     FLG_RETVALOTHER,
1374     "return value of type other than bool or int ignored",
1375     "Result returned by function call is not used. If this is intended, "
1376     "can cast result to (void) to eliminate message.",
1377     0, 0
1378   },
1379   {
1380     FK_IGNORERET, FK_BOOL, modeFlag,
1381     "retvalbool",
1382     FLG_RETVALBOOL,
1383     "return value of manifest type bool ignored",
1384     "Result returned by function call is not used. If this is intended, "
1385     "can cast result to (void) to eliminate message.",
1386     0, 0
1387   },
1388   {
1389     FK_IGNORERET, FK_NONE, modeFlag,
1390     "retvalint",
1391     FLG_RETVALINT,
1392     "return value of type int ignored",
1393     "Result returned by function call is not used. If this is intended, "
1394     "can cast result to (void) to eliminate message.",
1395     0, 0
1396   },
1397   {
1398     FK_INIT, FK_FILES, globalExtraArgFlag,
1399     "f",
1400     FLG_OPTF,
1401     "load options file (default ~/.lclintrc not loaded)",
1402     NULL, 0, 0
1403   },
1404   {
1405     FK_INIT, FK_FILES, globalExtraArgFlag,
1406     "i",
1407     FLG_INIT,
1408     "set LCL initilization file",
1409     NULL, 0, 0
1410   },
1411   {
1412     FK_INIT, FK_FILES, globalFlag,
1413     "nof",
1414     FLG_NOF,
1415     "do not read options file",
1416     NULL, 0, 0
1417   },
1418   {
1419     FK_INIT, FK_SPEC, plainFlag,
1420     "needspec",
1421     FLG_NEEDSPEC,
1422     "information in specifications is not also included in syntactic comments",
1423     "There is information in the specification that is not duplicated "
1424     "in syntactic comments. Normally, this is not an "
1425     "error, but it may be useful to detect it to make "
1426     "sure checking incomplete systems without the specifications will "
1427     "still use this information.",
1428     0, 0
1429   },
1430   {
1431     FK_DECL, FK_LIBS, plainFlag,
1432     "newdecl",
1433     FLG_NEWDECL,
1434     "report new global declarations in source files",
1435     "There is a new declaration that is not declared in a loaded library "
1436     "or earlier file.  (Use this flag to check for consistency "
1437     "against a library.)",
1438     0, 0
1439   },
1440   {
1441     FK_ITER, FK_NONE, plainFlag,
1442     "iter",
1443     FLG_ITER,
1444     NULL, NULL,
1445     0, 0
1446   },
1447   {
1448     FK_ITER, FK_NONE, plainFlag,
1449     "hasyield",
1450     FLG_HASYIELD,
1451     "iter declaration has no yield parameters",
1452     "An iterator has been declared with no parameters annotated with "
1453     "yield. This may be what you want, if the iterator is meant "
1454     "to do something a fixed number of times, but returns no "
1455     "information to the calling context. Probably, a parameter "
1456     "is missing the yield annotation to indicate that it is "
1457     "assigned a value in the calling context.",
1458     0, 0
1459   },
1460   {
1461     FK_LIBS, FK_FILES, globalStringFlag,
1462     "dump",
1463     FLG_DUMP,
1464     "save state for merging (default suffix .lcd)",
1465     NULL, 0, 0
1466   },
1467   {
1468     FK_LIBS, FK_FILES, globalStringFlag,
1469     "load",
1470     FLG_MERGE,
1471     "load state from dump file (default suffix .lcd)",
1472     NULL, 0, 0
1473   },
1474   {
1475     FK_LIBS, FK_INIT, idemGlobalFlag,
1476     "nolib",
1477     FLG_NOLIB,
1478     "do not load standard library",
1479     NULL, 0, 0
1480   },
1481   {
1482     FK_LIBS, FK_INIT, globalFlag,
1483     "ansilib",
1484     FLG_ANSILIB,
1485     "use ANSI (ISO) standard library",
1486     "Library based on the ANSI standard library specification is used.",
1487     0, 0
1488   },
1489   {
1490     FK_LIBS, FK_INIT, globalFlag,
1491     "strictlib",
1492     FLG_STRICTLIB,
1493     "interpret standard library strictly",
1494     "Stricter version of the standard library is used. (The default "
1495     "library is standard.lcd;  strict library is strict.lcd.)",
1496     0, 0
1497   },
1498   {
1499     FK_LIBS, FK_INIT, globalFlag,
1500     "unixlib",
1501     FLG_UNIXLIB,
1502     "use UNIX (sort-of) standard library",
1503     "UNIX version of the standard library is used.",
1504     0, 0
1505   },
1506   {
1507     FK_LIBS, FK_INIT, globalFlag,
1508     "unixstrictlib",
1509     FLG_UNIXSTRICTLIB,
1510     "use strict version of UNIX (sort-of) library",
1511     "strict version of the UNIX library is used.",
1512     0, 0
1513   },
1514   {
1515     FK_LIBS, FK_INIT, globalFlag,
1516     "posixlib",
1517     FLG_POSIXLIB,
1518     "use POSIX standard library",
1519     "POSIX version of the standard library is used.",
1520     0, 0
1521   },
1522   {
1523     FK_LIBS, FK_INIT, globalFlag,
1524     "posixstrictlib",
1525     FLG_POSIXSTRICTLIB,
1526     "use strict POSIX standard library",
1527     "POSIX version of the strict standard library is used.",
1528     0, 0
1529   },
1530   {
1531     FK_LIBS, FK_INIT, globalFlag,
1532     "whichlib",
1533     FLG_WHICHLIB,
1534     "show standard library filename",
1535     NULL, 0, 0
1536   },
1537   {
1538     FK_LIBS, FK_FILES, globalStringFlag,
1539     "mts",
1540     FLG_MTSFILE,
1541     "load meta state declaration and corresponding xh file",
1542     NULL, 0, 0
1543   },
1544   {
1545     FK_INIT, FK_COMMENTS, valueFlag,
1546     "commentchar",
1547     FLG_COMMENTCHAR,
1548     "set marker character for syntactic comments (default is '@')",
1549     "Set the marker character for syntactic comments. Comments beginning "
1550     "with /*<char> are interpreted by lclint, where <char> is the "
1551     "comment marker character.",
1552     0, 0
1553   },
1554   {
1555     FK_MACROS, FK_NONE, plainSpecialFlag,
1556     "allmacros",
1557     FLG_ALLMACROS,
1558     "sets fcnmacros and constmacros",
1559     "All macros (not preceded by /*@notfunction@*/) are checked as functions or "
1560     "constants depending on whether or not they have parameter lists.",
1561     0, 0
1562   },
1563   {
1564     FK_MACROS, FK_NONE, plainFlag,
1565     "libmacros",
1566     FLG_LIBMACROS,
1567     "check all macros with declarations in library as functions",
1568     "Every macro declared in the load library is checked.",
1569     0, 0
1570   },
1571   {
1572     FK_MACROS, FK_NONE, plainFlag,
1573     "specmacros",
1574     FLG_SPECMACROS,
1575     "check all macros corresponding to specified functions or constants",
1576     "Every macro declared a specification file is checked.",
1577     0, 0
1578   },
1579   {
1580     FK_MACROS, FK_NONE, plainFlag,
1581     "fcnmacros",
1582     FLG_FCNMACROS,
1583     "check all macros with parameter lists as functions",
1584     "Every parameterized macro (not preceded by /*@notfunction@*/) "
1585     "is checked as a function.",
1586     0, 0
1587   },
1588   {
1589     FK_MACROS, FK_NONE, plainFlag,
1590     "constmacros",
1591     FLG_CONSTMACROS,
1592     "check all macros without parameter lists as constants",
1593     "Every non-parameterized macro (not preceded by /*@notfunction@*/) "
1594     "is checked as a constant.",
1595     0, 0
1596   },
1597   {
1598     FK_MACROS, FK_NONE, modeFlag,
1599     "macromatchname",
1600     FLG_MACROMATCHNAME,
1601     "macro definition does not match iter or constant declaration",
1602     "A iter or constant macro is defined using a different name from the "
1603     "one used in the previous syntactic comment",
1604     0, 0
1605   },
1606   {
1607     FK_MACROS, FK_NONE, plainFlag,
1608     "nextlinemacros",
1609     FLG_MACRONEXTLINE,
1610     "the line after a constant or iter declaration must be a macro definition",
1611     "A constant or iter declaration is not immediately followed by a macro definition.",
1612     0, 0
1613   },
1614   {
1615     FK_MACROS, FK_NONE, modeFlag,
1616     "macrostmt",
1617     FLG_MACROSTMT,
1618     "macro definition is syntactically not equivalent to function",
1619     "A macro is defined in a way that may cause syntactic problems. If the macro returns a value, use commas to separate expressions;  otherwise, use do { <macro body> } while (FALSE) construct.",
1620     0, 0
1621   },
1622   {
1623     FK_MACROS, FK_NONE, modeFlag,
1624     "macroempty",
1625     FLG_MACROEMPTY,
1626     "macro definition for is empty",
1627     "A macro definition has no body.",
1628     0, 0
1629   },
1630   {
1631     FK_MACROS, FK_PARAMS, modeFlag,
1632     "macroparams",
1633     FLG_MACROPARAMS,
1634     "macro parameter not used exactly once",
1635     "A macro parameter is not used exactly once in all possible "
1636     "invocations of the macro. To behave like a function, "
1637     "each macro parameter must be used exactly once on all "
1638     "invocations of the macro so that parameters with "
1639     "side-effects are evaluated exactly once. Use /*@sef@*/ to "
1640     "denote parameters that must be side-effect free.",
1641     0, 0
1642   },
1643   {
1644     FK_MACROS, FK_PARAMS, modeFlag,
1645     "macroassign",
1646     FLG_MACROASSIGN,
1647     "assignment to a macro parameter",
1648     "A macro parameter is used as the left side of an "
1649     "assignment expression. This exhibits behavior that "
1650     "could not be implemented by a function.",
1651     0, 0
1652   },
1653   {
1654     FK_MACROS, FK_PARAMS, modeFlag,
1655     "sefparams",
1656     FLG_SEFPARAMS,
1657     "a parameter with side-effects is passed as a sef parameter",
1658     "An actual parameter corresponding to a sef parameter may have a side-effect.",
1659     0, 0
1660   },
1661   {
1662     FK_MACROS, FK_PARAMS, modeFlag,
1663     "sefuncon",
1664     FLG_SEFUNSPEC,
1665     "a parameter with unconstrained side-effects is passed as a sef parameter",
1666     "An actual parameter corresponding to a sef parameter involves a call "
1667     "to a procedure with no modifies clause that may have a side-effect.",
1668     0, 0
1669   },
1670   {
1671     FK_MACROS, FK_NONE, modeFlag,
1672     "macroparens",
1673     FLG_MACROPARENS,
1674     "macro parameter used without parentheses (in potentially dangerous context)",
1675     "A macro parameter is used without parentheses. This could be "
1676     "dangerous if the macro is invoked with a complex expression "
1677     "and precedence rules will change the evaluation inside the macro.",
1678     0, 0
1679   },
1680   {
1681     FK_MACROS, FK_PROTOS, modeFlag,
1682     "macrodecl",
1683     FLG_MACRODECL,
1684     "macro without prototype or specification (sets macrofcndecl and macroconstdecl)",
1685     "Argument checking cannot be done well for macros without prototypes "
1686     "or specifications, since the types of the arguments are unknown.",
1687     0, 0
1688   },
1689   {
1690     FK_MACROS, FK_PROTOS, modeFlag,
1691     "macrofcndecl",
1692     FLG_MACROFCNDECL,
1693     "parameterized macro without prototype or specification",
1694     "Function macro has no declaration.",
1695     0, 0
1696   },
1697   {
1698     FK_MACROS, FK_PROTOS, modeFlag,
1699     "macroconstdecl",
1700     FLG_MACROCONSTDECL,
1701     "non-parameterized macro without prototype or specification",
1702     "Macro constant has no declaration. Use /*@constant ...@*/ to "
1703     "declare the macro.",
1704     0, 0
1705   },
1706   {
1707     FK_MACROS, FK_NONE, modeFlag,
1708     "macroredef",
1709     FLG_MACROREDEF,
1710     "macro redefined",
1711     "A macro is defined in more than one place.", 0, 0
1712   },
1713   {
1714     FK_MACROS, FK_UNRECOG, modeFlag,
1715     "macrounrecog",
1716     FLG_MACROUNDEF,
1717     "unrecognized identifier in macro",
1718     "An unrecognized identifier appears in a macro. If the identifier "
1719     "is defined before the macro is used, then this is okay.",
1720     0, 0
1721   },
1722   {
1723     FK_MEMORY, FK_DEAD, modeFlag,
1724     "stackref",
1725     FLG_RETSTACK,
1726     "external reference to stack-allocated storage is created",
1727     "A stack reference is pointed to by an external reference when the "
1728     "function returns. The stack-allocated storage is destroyed "
1729     "after the call, leaving a dangling reference.",
1730     0, 0
1731   },
1732   {
1733     FK_MEMORY, FK_DEAD, modeFlag,
1734     "usereleased",
1735     FLG_USERELEASED,
1736     "storage used after release",
1737     "Memory is used after it has been released (either by passing "
1738     "as an only param or assigning to an only global.",
1739     0, 0
1740   },
1741   {
1742     FK_MEMORY, FK_DEAD, modeFlag,
1743     "strictusereleased",
1744     FLG_STRICTUSERELEASED,
1745     "element used after it may have been released",
1746     "Memory (through fetch) is used after it may have been released "
1747     "(either by passing as an only param or assigning to an only global.",
1748     0, 0
1749   },
1750   {
1751     FK_MEMORY, FK_DEF, modeFlag,
1752     "compdef",
1753     FLG_COMPDEF,
1754     "parameter, return value or global completely defined",
1755     "Storage derivable from a parameter, return value or global is "
1756     "not defined. Use /*@out@*/ to denote passed or returned "
1757     "storage which need not be defined.",
1758     0, 0
1759   },
1760   {
1761     FK_MEMORY, FK_DEF, modeFlag,
1762     "compmempass",
1763     FLG_COMPMEMPASS,
1764     "actual parameter matches alias kind of formal parameter completely ",
1765     "Storage derivable from a parameter does not match the alias kind "
1766     "expected for the formal parameter.",
1767     0, 0
1768   },
1769   {
1770     FK_MEMORY, FK_DEF, modeFlag,
1771     "mustdefine",
1772     FLG_MUSTDEFINE,
1773     "out storage not defined before return or scope exit",
1774     "An out parameter or global is not defined before control is transferred.",
1775     0, 0
1776   },
1777   {
1778     FK_MEMORY, FK_DEF, modeFlag,
1779     "uniondef",
1780     FLG_UNIONDEF,
1781     "at least one field of a union must be defined",
1782     "No field of a union is defined. Generally, one field of a union is "
1783     "expected to be defined.",
1784     0, 0
1785   },
1786   {
1787     FK_MEMORY, FK_IMPLICIT, modeFlag,
1788     "memimp",
1789     FLG_MEMIMPLICIT,
1790     "memory errors for unqualified storage",
1791     NULL, 0, 0
1792   },
1793   {
1794     FK_MEMORY, FK_IMPLICIT, plainFlag,
1795     "paramimptemp",
1796     FLG_PARAMIMPTEMP,
1797     "assume unannotated parameter is temp",
1798     NULL, 0, 0
1799   },
1800   {
1801     FK_MEMORY, FK_IMPLICIT, specialFlag,
1802     "allimponly",
1803     FLG_ALLIMPONLY,
1804     "sets globimponly, retimponly, structimponly, specglobimponly, "
1805     "specretimponly and specstructimponly",
1806     NULL, 0, 0
1807   },
1808   {
1809     FK_MEMORY, FK_IMPLICIT, specialFlag,
1810     "codeimponly",
1811     FLG_CODEIMPONLY,
1812     "sets globimponly, retimponly and structimponly",
1813     NULL, 0, 0
1814   },
1815   {
1816     FK_MEMORY, FK_IMPLICIT, specialFlag,
1817     "specimponly",
1818     FLG_SPECALLIMPONLY,
1819     "sets specglobimponly, specretimponly and specstructimponly",
1820     NULL, 0, 0
1821   },
1822   {
1823     FK_MEMORY, FK_IMPLICIT, plainFlag,
1824     "globimponly",
1825     FLG_GLOBIMPONLY,
1826     "assume unannotated global storage is only",
1827     NULL, 0, 0
1828   },
1829   {
1830     FK_MEMORY, FK_IMPLICIT, plainFlag,
1831     "retimponly",
1832     FLG_RETIMPONLY,
1833     "assume unannotated returned storage is only",
1834     NULL, 0, 0
1835   },
1836   {
1837     FK_MEMORY, FK_IMPLICIT, plainFlag,
1838     "structimponly",
1839     FLG_STRUCTIMPONLY,
1840     "assume unannotated structure field is only",
1841     NULL, 0, 0
1842   },
1843   {
1844     FK_MEMORY, FK_IMPLICIT, plainFlag,
1845     "specglobimponly",
1846     FLG_SPECGLOBIMPONLY,
1847     "assume unannotated global storage is only",
1848     NULL, 0, 0
1849   },
1850   {
1851     FK_MEMORY, FK_IMPLICIT, plainFlag,
1852     "specretimponly",
1853     FLG_SPECRETIMPONLY,
1854     "assume unannotated returned storage is only",
1855     NULL, 0, 0
1856   },
1857   {
1858     FK_MEMORY, FK_IMPLICIT, plainFlag,
1859     "specstructimponly",
1860     FLG_SPECSTRUCTIMPONLY,
1861     "assume unannotated structure field is only",
1862     NULL, 0, 0
1863   },
1864   {
1865     FK_MEMORY, FK_ARRAY, modeFlag,
1866     "deparrays",
1867     FLG_DEPARRAYS,
1868     "array elements are dependent storage",
1869     "When an element is fetched from an array, lclint analysis is "
1870     "not able to determine if the same element is reused. "
1871     "If +deparrays, lclint will mark local storage assigned from "
1872     "array fetches as dependent.",
1873     0, 0
1874   },
1875   {
1876     FK_MEMORY, FK_LEAK, modeFlag,
1877     "compdestroy",
1878     FLG_COMPDESTROY,
1879     "all only references derivable from void pointer out only parameter are released",
1880     "A storage leak due to incomplete deallocation of a structure or deep "
1881     "pointer is suspected. Unshared storage that is reachable from "
1882     "a reference that is being deallocated has not yet been deallocated. "
1883     "LCLint assumes when an object is passed "
1884     "as an out only void pointer that the outer object will be "
1885     "deallocated, but the inner objects will not.",
1886     0, 0
1887   },
1888   {
1889     FK_MEMORY, FK_LEAK, modeFlag,
1890     "strictdestroy",
1891     FLG_STRICTDESTROY,
1892     "report complete destruction errors for array elements that "
1893     "may have been released",
1894     NULL,
1895     0, 0
1896   },
1897   {
1898     FK_MEMORY, FK_LEAK, modeFlag,
1899     "mustfree",
1900     FLG_MUSTFREE,
1901     "only storage not released before return or scope exit",
1902     "A memory leak has been detected. Newly-allocated or "
1903     "only-qualified storage is not released before the last "
1904     "reference to it is lost.",
1905     0, 0
1906   },
1907   {
1908     FK_MEMORY, FK_NONE, modeFlag,
1909     "branchstate",
1910     FLG_BRANCHSTATE,
1911     "storage has inconsistent states of alternate paths through a branch",
1912     "The state of a variable is different depending on which branch "
1913     "is taken. This means no annotation can sensibly be applied "
1914     "to the storage.",
1915     0, 0
1916   },
1917   {
1918     FK_MEMORY, FK_NONE, modeFlag,
1919     "strictbranchstate",
1920     FLG_STRICTBRANCHSTATE,
1921     "storage through array fetch has inconsistent states of alternate "
1922     "paths through a branch",
1923     "The state of a variable through an array fetch is different depending "
1924     "on which branch is taken. This means no annotation can sensibly be applied "
1925     "to the storage.",
1926     0, 0
1927   },
1928   {
1929     FK_MEMORY, FK_NONE, specialFlag,
1930     "memchecks",
1931     FLG_MEMCHECKS,
1932     "sets all dynamic memory checking flags (memimplicit, mustfree, mustdefine, "
1933     "mustnotalias, null, memtrans)",
1934     NULL, 0, 0
1935   },
1936   {
1937     FK_MEMORY, FK_NONE, specialFlag,
1938     "memtrans",
1939     FLG_MEMTRANS,
1940     "memory transfer errors (sets all *trans flags)",
1941     "Memory is transferred in a way that violates annotations.",
1942     0, 0
1943   },
1944   {
1945     FK_MEMORY, FK_NONE, modeFlag,
1946     "exposetrans",
1947     FLG_EXPOSETRANS,
1948     "exposure transfer errors",
1949     "Exposed storage is transferred to a non-exposed, non-observer reference.",
1950     0, 0
1951   },
1952   {
1953     FK_MEMORY, FK_NONE, modeFlag,
1954     "observertrans",
1955     FLG_OBSERVERTRANS,
1956     "observer transfer errors",
1957     "Observer storage is transferred to a non-observer reference.",
1958     0, 0
1959   },
1960   {
1961     FK_MEMORY, FK_NONE, modeFlag,
1962     "dependenttrans",
1963     FLG_DEPENDENTTRANS,
1964     "dependent transfer errors",
1965     "Dependent storage is transferred to a non-dependent reference.",
1966     0, 0
1967   },
1968   {
1969     FK_MEMORY, FK_NONE, modeFlag,
1970     "newreftrans",
1971     FLG_NEWREFTRANS,
1972     "new reference transfer to reference counted reference",
1973     "A new reference is transferred to a reference counted reference.",
1974     0, 0
1975   },
1976   {
1977     FK_MEMORY, FK_NONE, modeFlag,
1978     "onlytrans",
1979     FLG_ONLYTRANS,
1980     "only storage transferred to non-only reference (memory leak)",
1981     "The only reference to this storage is transferred to another "
1982     "reference (e.g., by returning it) that does not have the "
1983     "only annotation. This may lead to a memory leak, since the "
1984     "new reference is not necessarily released.",
1985     0, 0
1986   },
1987   {
1988     FK_MEMORY, FK_NONE, modeFlag,
1989     "onlyunqglobaltrans",
1990     FLG_ONLYUNQGLOBALTRANS,
1991     "only storage transferred to an unqualified global or "
1992     "static reference (memory leak)",
1993     "The only reference to this storage is transferred to another "
1994     "reference that does not have an aliasing annotation. "
1995     "This may lead to a memory leak, since the "
1996     "new reference is not necessarily released.",
1997     0, 0
1998   },
1999   {
2000     FK_MEMORY, FK_NONE, modeFlag,
2001     "ownedtrans",
2002     FLG_OWNEDTRANS,
2003     "owned storage transferred to non-owned reference (memory leak)",
2004     "The owned reference to this storage is transferred to another "
2005     "reference (e.g., by returning it) that does not have the "
2006     "owned annotation. This may lead to a memory leak, since the "
2007     "new reference is not necessarily released.",
2008     0, 0
2009   },
2010   {
2011     FK_MEMORY, FK_NONE, modeFlag,
2012     "freshtrans",
2013     FLG_FRESHTRANS,
2014     "fresh storage transferred to non-only reference (memory leak)",
2015     "Fresh storage (newly allocated in this function) is transferred "
2016     "in a way that the obligation to release storage is not "
2017     "propagated.  Use the /*@only@*/ annotation to indicate "
2018     "the a return value is the only reference to the returned "
2019     "storage.",
2020     0, 0
2021   },
2022   {
2023     FK_MEMORY, FK_NONE, modeFlag,
2024     "sharedtrans",
2025     FLG_SHAREDTRANS,
2026     "shared storage transferred to non-shared reference",
2027     "Shared storage is transferred to a non-shared reference. The other "
2028     "reference may release storage needed by this reference.",
2029     0, 0
2030   },
2031   {
2032     FK_MEMORY, FK_NONE, modeFlag,
2033     "temptrans",
2034     FLG_TEMPTRANS,
2035     "temp storage transferred to non-temporary reference",
2036     "Temp storage (associated with a formal parameter) is transferred "
2037     "to a non-temporary reference. The storage may be released "
2038     "or new aliases created.",
2039     0, 0
2040   },
2041   {
2042     FK_MEMORY, FK_NONE, modeFlag,
2043     "kepttrans",
2044     FLG_KEPTTRANS,
2045     "kept storage transferred to non-temporary reference",
2046     "Kept storage is transferred "
2047     "to a non-temporary reference. The storage may be released "
2048     "or new aliases created.",
2049     0, 0
2050   },
2051   {
2052     FK_MEMORY, FK_NONE, modeFlag,
2053     "keeptrans",
2054     FLG_KEEPTRANS,
2055     "keep storage transferred inconsistently",
2056     "Keep storage is transferred inconsistently --- either in a way "
2057     "that may add a new alias to it, or release it.",
2058     0, 0
2059   },
2060   {
2061     FK_MEMORY, FK_NONE, modeFlag,
2062     "immediatetrans",
2063     FLG_IMMEDIATETRANS,
2064     "an immediate address (result of &) is transferred inconsistently",
2065     "An immediate address (result of & operator) is transferred "
2066     "inconsistently.",
2067     0, 0
2068   },
2069   {
2070     FK_MEMORY, FK_NONE, modeFlag,
2071     "refcounttrans",
2072     FLG_REFCOUNTTRANS,
2073     "reference counted storage is transferred in an inconsistent way",
2074     "Reference counted storage is transferred in a way that may not "
2075     "be consistent with the reference count.",
2076     0, 0
2077   },
2078   {
2079     FK_MEMORY, FK_NONE, modeFlag,
2080     "statictrans",
2081     FLG_STATICTRANS,
2082     "static storage is transferred in an inconsistent way",
2083     "Static storage is transferred in an inconsistent way.",
2084     0, 0
2085   },
2086   {
2087     FK_MEMORY, FK_NONE, modeFlag,
2088     "unqualifiedtrans",
2089     FLG_UNKNOWNTRANS,
2090     "unqualified storage is transferred in an inconsistent way",
2091     "Unqualified storage is transferred in an inconsistent way.",
2092     0, 0
2093   },
2094   {
2095     FK_MEMORY, FK_NONE, modeFlag,
2096     "staticinittrans",
2097     FLG_STATICINITTRANS,
2098     "static storage is used as an initial value in an inconsistent way",
2099     "Static storage is used as an initial value in an inconsistent way.",
2100     0, 0
2101   },
2102   {
2103     FK_MEMORY, FK_NONE, modeFlag,
2104     "unqualifiedinittrans",
2105     FLG_UNKNOWNINITTRANS,
2106     "unqualified storage is used as an initial value in an inconsistent way",
2107     "Unqualified storage is used as an initial value in an inconsistent way.",
2108     0, 0
2109   },
2110   {
2111     FK_MEMORY, FK_NONE, modeFlag,
2112     "readonlystrings",
2113     FLG_READONLYSTRINGS,
2114     "string literals are read-only (error if one is modified or released)",
2115     "String literals are read-only (ANSI semantics). An error is reported "
2116     "if a string literal may be modified or released.",
2117     0, 0
2118   },
2119   {
2120     FK_MEMORY, FK_NONE, modeFlag,
2121     "readonlytrans",
2122     FLG_READONLYTRANS,
2123     "report memory transfer errors for initializations to read-only string literals",
2124     "A read-only string literal is assigned to a non-observer reference.",
2125     0, 0
2126   },
2127   {
2128     FK_MEMORY, FK_PARAMS, modeFlag,
2129     "passunknown",
2130     FLG_PASSUNKNOWN,
2131     "passing a value as an un-annotated parameter clears its annotation",
2132     NULL, 0, 0
2133   },
2134   {
2135     FK_MODIFIES, FK_SPEC, plainFlag,
2136     "mods",
2137     FLG_MODIFIES,
2138     "unspecified modification of caller-visible state",
2139     "An externally-visible object is modified by a function, but not "
2140     "listed in its modifies clause.",
2141     0, 0
2142   },
2143   {
2144     FK_MODIFIES, FK_SPEC, modeFlag,
2145     "mustmod",
2146     FLG_MUSTMOD,
2147     "specified modification is not detected",
2148     "An object listed in the modifies clause is not modified by the "
2149     "implementation of the function. The modification may not "
2150     "be detected if it is done through a call to an unspecified "
2151     "function.",
2152     0, 0
2153   },
2154   {
2155     FK_MODIFIES, FK_MEMORY, plainFlag,
2156     "modobserver",
2157     FLG_MODOBSERVER,
2158     "possible modification of observer storage",
2159     "Storage declared with observer is possibly modified. Observer "
2160     "storage may not be modified.",
2161     0, 0
2162   },
2163   {
2164     FK_MODIFIES, FK_MEMORY, modeFlag,
2165     "modobserveruncon",
2166     FLG_MODOBSERVERUNCON,
2167     "possible modification of observer storage through unconstrained call",
2168     "Storage declared with observer may be modified through a call to an "
2169     "unconstrained function.",
2170     0, 0
2171   },
2172   {
2173     FK_MODIFIES, FK_MEMORY, modeFlag,
2174     "modinternalstrict",
2175     FLG_MODINTERNALSTRICT,
2176     "possible modification of internal storage through function call",
2177     "A function that modifies internalState is called from a function that "
2178     "does not list internalState in its modifies clause",
2179     0, 0
2180   },
2181   {
2182     FK_MODIFIES, FK_UNSPEC, modeFlag,
2183     "modfilesys",
2184     FLG_MODFILESYSTEM,
2185     "report undocumented file system modifications (applies to unspecified "
2186     "functions if modnomods is set)",
2187     NULL, 0, 0
2188   },
2189   {
2190     FK_MODIFIES, FK_UNSPEC, specialFlag,
2191     "modunspec",
2192     FLG_MODUNSPEC,
2193     "modification in unspecified functions (sets modnomods, "
2194     "modglobunspec and modstrictglobsunspec)",
2195     NULL, 0, 0
2196   },
2197   {
2198     FK_MODIFIES, FK_UNSPEC, modeFlag,
2199     "modnomods",
2200     FLG_MODNOMODS,
2201     "modification in a function with no modifies clause",
2202     "An externally-visible object is modified by a function with no "
2203     "/*@modifies@*/ comment. The /*@modifies ... @*/ control "
2204     "comment can be used to give a modifies list for an "
2205     "unspecified function.",
2206     0, 0
2207   },
2208   {
2209     FK_MODIFIES, FK_UNSPEC, modeFlag,
2210     "moduncon",
2211     FLG_MODUNCON,
2212     "possible modification through a call to an unconstrained function",
2213     "An unconstrained function is called in a function body where "
2214     "modifications are checked. Since the unconstrained function "
2215     "may modify anything, there may be undetected modifications in "
2216     "the checked function.",
2217     0, 0
2218   },
2219   {
2220     FK_MODIFIES, FK_UNSPEC, modeFlag,
2221     "modunconnomods",
2222     FLG_MODUNCONNOMODS,
2223     "possible modification through a call to an unconstrained function in "
2224     "a function with no modifies clause",
2225     "An unconstrained function is called in a function body where "
2226     "modifications are checked. Since the unconstrained function "
2227     "may modify anything, there may be undetected modifications in "
2228     "the checked function.",
2229     0, 0
2230   },
2231   {
2232     FK_MODIFIES, FK_GLOBALS, modeFlag,
2233     "globsimpmodsnothing",
2234     FLG_GLOBALSIMPMODIFIESNOTHING,
2235     "functions declared with a globals list but no modifies clause are "
2236     "assumed to modify nothing",
2237     "An implicit modifies nothing clause is assumed for a function "
2238     "declared with a globals list but not modifies clause.",
2239     0, 0
2240   },
2241   {
2242     FK_MODIFIES, FK_GLOBALS, modeFlag,
2243     "modsimpnoglobs",
2244     FLG_MODIFIESIMPNOGLOBALS,
2245     "functions declared with a modifies clause but no globals list "
2246     "are assumed to use no globals",
2247     "An implicit empty globals list is assumed for a function "
2248     "declared with a modifies clause but no globals list.",
2249     0, 0
2250   },
2251   {
2252     FK_NAMES, FK_ABSTRACT, plainFlag,
2253     "namechecks",
2254     FLG_NAMECHECKS,
2255     "controls name checking without changing other settings",
2256     NULL, 0, 0
2257   },
2258   {
2259     FK_NAMES, FK_ABSTRACT, specialFlag,
2260     "czech",
2261     FLG_CZECH,
2262     "czech naming convention (sets accessczech, czechfunctions, czechvars, "
2263     "czechconstants, czechenums, and czechmacros)",
2264     "Name is not consistent with Czech naming convention.", 0, 0
2265   },
2266   {
2267     FK_NAMES, FK_ABSTRACT, plainFlag,
2268     "czechfcns",
2269     FLG_CZECHFUNCTIONS,
2270     "czech naming convention violated in a function or iterator declaration",
2271     "Function or iterator name is not consistent with Czech naming convention.", 0, 0
2272   },
2273   {
2274     FK_NAMES, FK_ABSTRACT, plainFlag,
2275     "czechvars",
2276     FLG_CZECHVARS,
2277     "czech naming convention violated in a variable declaration",
2278     "Variable name is not consistent with Czech naming convention.", 0, 0
2279   },
2280   {
2281     FK_NAMES, FK_ABSTRACT, plainFlag,
2282     "czechmacros",
2283     FLG_CZECHMACROS,
2284     "czech naming convention violated in an expanded macro name",
2285     "Expanded macro name is not consistent with Czech naming convention.", 0, 0
2286   },
2287   {
2288     FK_NAMES, FK_ABSTRACT, plainFlag,
2289     "czechconsts",
2290     FLG_CZECHCONSTANTS,
2291     "czech naming convention violated in a constant declaration",
2292     "Constant name is not consistent with Czech naming convention.", 0, 0
2293   },
2294   {
2295     FK_NAMES, FK_ABSTRACT, plainFlag,
2296     "czechtypes",
2297     FLG_CZECHTYPES,
2298     "czech naming convention violated in a user-defined type definition",
2299     "Type name is not consistent with Czech naming convention. Czech type "
2300     "names must not use the underscore character.", 0, 0
2301   },
2302   {
2303     FK_NAMES, FK_ABSTRACT, specialFlag,
2304     "slovak",
2305     FLG_SLOVAK,
2306     "slovak naming convention violated",
2307     "Name is not consistent with Slovak naming convention.", 0, 0
2308   },
2309   {
2310     FK_NAMES, FK_ABSTRACT, plainFlag,
2311     "slovakfcns",
2312     FLG_SLOVAKFUNCTIONS,
2313     "slovak naming convention violated in a function or iterator declaration",
2314     "Function or iterator name is not consistent with Slovak naming convention.", 0, 0
2315   },
2316   {
2317     FK_NAMES, FK_ABSTRACT, plainFlag,
2318     "slovakmacros",
2319     FLG_SLOVAKMACROS,
2320     "slovak naming convention violated in an expanded macro name",
2321     "Expanded macro name is not consistent with Slovak naming convention.", 0, 0
2322   },
2323   {
2324     FK_NAMES, FK_ABSTRACT, plainFlag,
2325     "slovakvars",
2326     FLG_SLOVAKVARS,
2327     "slovak naming convention violated in a variable declaration",
2328     "Variable name is not consistent with Slovak naming convention.", 0, 0
2329   },
2330   {
2331     FK_NAMES, FK_ABSTRACT, plainFlag,
2332     "slovakconsts",
2333     FLG_SLOVAKCONSTANTS,
2334     "slovak naming convention violated in a constant declaration",
2335     "Constant name is not consistent with Slovak naming convention.", 0, 0
2336   },
2337   {
2338     FK_NAMES, FK_ABSTRACT, plainFlag,
2339     "slovaktypes",
2340     FLG_SLOVAKTYPES,
2341     "slovak naming convention violated in a use-defined type definition",
2342     "Type name is not consistent with Slovak naming convention. Slovak type "
2343     "names may not include uppercase letters.", 0, 0
2344   },
2345   {
2346     FK_NAMES, FK_ABSTRACT, specialFlag,
2347     "czechoslovak",
2348     FLG_CZECHOSLOVAK,
2349     "czech or slovak naming convention violated",
2350     "Name is not consistent with either Czech or Slovak naming convention.", 0, 0
2351   },
2352   {
2353     FK_NAMES, FK_ABSTRACT, plainFlag,
2354     "czechoslovakfcns",
2355     FLG_CZECHOSLOVAKFUNCTIONS,
2356     "czechoslovak naming convention violated in a function or iterator declaration",
2357     "Function name is not consistent with Czechoslovak naming convention.", 0, 0
2358   },
2359   {
2360     FK_NAMES, FK_ABSTRACT, plainFlag,
2361     "czechoslovakmacros",
2362     FLG_CZECHOSLOVAKMACROS,
2363     "czechoslovak naming convention violated in an expanded macro name",
2364     "Expanded macro name is not consistent with Czechoslovak naming convention.", 0, 0
2365   },
2366   {
2367     FK_NAMES, FK_ABSTRACT, plainFlag,
2368     "czechoslovakvars",
2369     FLG_CZECHOSLOVAKVARS,
2370     "czechoslovak naming convention violated in a variable declaration",
2371     "Variable name is not consistent with Czechoslovak naming convention.", 0, 0
2372   },
2373   {
2374     FK_NAMES, FK_ABSTRACT, plainFlag,
2375     "czechoslovakconsts",
2376     FLG_CZECHOSLOVAKCONSTANTS,
2377     "czechoslovak naming convention violated in a constant declaration",
2378     "Constant name is not consistent with Czechoslovak naming convention.", 0, 0
2379   },
2380   {
2381     FK_NAMES, FK_ABSTRACT, plainFlag,
2382     "czechoslovaktypes",
2383     FLG_CZECHOSLOVAKTYPES,
2384     "czechoslovak naming convention violated in a user-defined type definition",
2385     "Type name is not consistent with Czechoslovak naming convention. Czechoslovak "
2386     "type names may not include uppercase letters or the underscore character.", 0, 0
2387   },
2388   {
2389     FK_NAMES, FK_ANSI, modeFlag,
2390     "ansireserved",
2391     FLG_ANSIRESERVED,
2392     "external name conflicts with name reserved for system or standard library",
2393     "External name is reserved for system in ANSI standard.",
2394     0, 0
2395   },
2396   {
2397     FK_NAMES, FK_ANSI, modeFlag,
2398     "cppnames",
2399     FLG_CPPNAMES,
2400     "external or internal name is a C++ keyword or reserved word",
2401     "External name is a C++ keyword or reserved word. "
2402     "This could lead to problems if the "
2403     "code is compiled with a C++ compiler.",
2404     0, 0
2405   },
2406   {
2407     FK_NAMES, FK_ANSI, modeFlag,
2408     "ansireservedinternal",
2409     FLG_ANSIRESERVEDLOCAL,
2410     "internal name conflicts with name reserved for system or standard library",
2411     "Internal name is reserved for system in ANSI standard (this should not be necessary unless you are worried about C library implementations that violate the standard and use macros).",
2412     0, 0
2413   },
2414   {
2415     FK_NAMES, FK_ANSI, plainFlag,
2416     "distinctexternalnames",
2417     FLG_DISTINCTEXTERNALNAMES,
2418     "external name is not distinguishable from another external name using "
2419     "the number of significant characters",
2420     "An external name is not distinguishable from another external name "
2421     "using the number of significant characters. According to "
2422     "ANSI Standard (3.1), an implementation may only consider the first 6 "
2423     "characters significant, and ignore alphabetical case "
2424     "distinctions. The "
2425     "+externalnamelen <n> flag may be used to change the number "
2426     "of significant characters, and -externalnamecaseinsensitive to make "
2427     "alphabetical case significant in external names.",
2428     0, 0
2429   },
2430   {
2431     FK_NAMES, FK_ANSI, specialValueFlag,
2432     "externalnamelen",
2433     FLG_EXTERNALNAMELEN,
2434     "set the number of significant characters in an external name",
2435     "Sets the number of significant characters in an external name (ANSI "
2436     "default is 6.)  Sets +distinctexternalnames.",
2437     0, 0
2438   },
2439   {
2440     FK_NAMES, FK_ANSI, plainSpecialFlag,
2441     "externalnamecaseinsensitive",
2442     FLG_EXTERNALNAMECASEINSENSITIVE,
2443     "alphabetic comparisons for external names are case-insensitive",
2444     "Make alphabetic case insignificant in external names. By ANSI "
2445     "standard, case need not be significant in an external name. "
2446     "If +distinctexternalnames is not set, sets "
2447     "+distinctexternalnames with unlimited external name length.",
2448     0, 0
2449   },
2450   {
2451     FK_NAMES, FK_ANSI, plainFlag,
2452     "distinctinternalnames",
2453     FLG_DISTINCTINTERNALNAMES,
2454     "internal name is not distinguishable from another internal name using "
2455     "the number of significant characters",
2456     "An internal name is not distinguishable from another internal name "
2457     "using the number of significant characters. According to "
2458     "ANSI Standard (3.1), an implementation may only consider the first 31 "
2459     "characters significant. The "
2460     "+internalnamelen <n> flag changes the number "
2461     "of significant characters, -internalnamecaseinsensitive to makes "
2462     "alphabetical case significant, and "
2463     "+internalnamelookalike to make similar-looking characters "
2464     "non-distinct.",
2465     0, 0
2466   },
2467   {
2468     FK_NAMES, FK_ANSI, specialValueFlag,
2469     "internalnamelen",
2470     FLG_INTERNALNAMELEN,
2471     "set the number of significant characters in an internal name",
2472     "Sets the number of significant characters in an internal name (ANSI "
2473     "default is 31.)  Sets +distinctinternalnames.",
2474     0, 0
2475   },
2476   {
2477     FK_NAMES, FK_ANSI, plainSpecialFlag,
2478     "internalnamecaseinsensitive",
2479     FLG_INTERNALNAMECASEINSENSITIVE,
2480     "set whether case is significant an internal names "
2481     "(-internalnamecaseinsensitive means case is significant)" ,
2482     "Set whether case is significant an internal names "
2483     "(-internalnamecaseinsensitive "
2484     "means case is significant). By ANSI default, case is not "
2485     "significant.  If +distinctinternalnames is not set, sets "
2486     "+distinctinternalnames with unlimited internal name length.",
2487     0, 0
2488   },
2489   {
2490     FK_NAMES, FK_ANSI, plainSpecialFlag,
2491     "internalnamelookalike",
2492     FLG_INTERNALNAMELOOKALIKE,
2493     "lookalike characters match in internal names",
2494     "Set whether similar looking characters (e.g., \"1\" and \"l\") "
2495     "match in internal names.",
2496     0, 0
2497   },
2498   {
2499     FK_NAMES, FK_PREFIX, idemStringFlag,
2500     "macrovarprefix",
2501     FLG_MACROVARPREFIX,
2502     "set namespace prefix for variables declared in a macro body",
2503     "A variable declared in a macro body does not start with the macrovarprefix.",
2504     0, 0
2505   } ,
2506   {
2507     FK_NAMES, FK_PREFIX, plainFlag,
2508     "macrovarprefixexclude",
2509     FLG_MACROVARPREFIXEXCLUDE,
2510     "the macrovarprefix may not be used for non-macro variables",
2511     "A variable declared outside a macro body starts with the macrovarprefix.",
2512     0, 0
2513   } ,
2514   {
2515     FK_NAMES, FK_PREFIX, idemStringFlag,
2516     "tagprefix",
2517     FLG_TAGPREFIX,
2518     "set namespace prefix for struct, union and enum tags",
2519     "A tag identifier does not start with the tagprefix.",
2520     0, 0
2521   } ,
2522   {
2523     FK_NAMES, FK_PREFIX, plainFlag,
2524     "tagprefixexclude",
2525     FLG_TAGPREFIXEXCLUDE,
2526     "the tagprefix may not be used for non-tag identifiers",
2527     "An identifier that is not a tag starts with the tagprefix.",
2528     0, 0
2529   } ,
2530   {
2531     FK_NAMES, FK_PREFIX, idemStringFlag,
2532     "enumprefix",
2533     FLG_ENUMPREFIX,
2534     "set namespace prefix for enum members",
2535     "An enum member does not start with the enumprefix.",
2536     0, 0
2537   } ,
2538   {
2539     FK_NAMES, FK_PREFIX, plainFlag,
2540     "enumprefixexclude",
2541     FLG_ENUMPREFIXEXCLUDE,
2542     "the enumprefix may not be used for non-enum member identifiers",
2543     "An identifier that is not an enum member starts with the enumprefix.",
2544     0, 0
2545   } ,
2546   {
2547     FK_NAMES, FK_PREFIX, idemStringFlag,
2548     "filestaticprefix",
2549     FLG_FILESTATICPREFIX,
2550     "set namespace prefix for file static declarations",
2551     "A file-static identifier does not start with the filestaticprefix.",
2552     0, 0
2553   } ,
2554   {
2555     FK_NAMES, FK_PREFIX, plainFlag,
2556     "filestaticprefixexclude",
2557     FLG_FILESTATICPREFIXEXCLUDE,
2558     "the filestaticprefix may not be used for identifiers that are not file static",
2559     "An identifier that is not file static starts with the filestaticprefix.",
2560     0, 0
2561   } ,
2562   {
2563     FK_NAMES, FK_PREFIX, idemStringFlag,
2564     "globalprefix",
2565     FLG_GLOBPREFIX,
2566     "set namespace prefix for global variables",
2567     "A global variable does not start with the globalprefix",
2568     0, 0
2569   } ,
2570   {
2571     FK_NAMES, FK_PREFIX, plainFlag,
2572     "globalprefixexclude",
2573     FLG_GLOBPREFIXEXCLUDE,
2574     "the globalprefix may not be used for non-global identifiers",
2575     "An identifier that is not a global variable starts with the globalprefix.",
2576     0, 0
2577   } ,
2578   {
2579     FK_NAMES, FK_PREFIX, idemStringFlag,
2580     "typeprefix",
2581     FLG_TYPEPREFIX,
2582     "set namespace prefix for user-defined types",
2583     "A user-defined type does not start with the typeprefix",
2584     0, 0
2585   } ,
2586   {
2587     FK_NAMES, FK_PREFIX, plainFlag,
2588     "typeprefixexclude",
2589     FLG_TYPEPREFIXEXCLUDE,
2590     "the typeprefix may not be used for identifiers that are not type names",
2591     "An identifier that is not a type name starts with the typeprefix.",
2592     0, 0
2593   } ,
2594   {
2595     FK_NAMES, FK_PREFIX, idemStringFlag,
2596     "externalprefix",
2597     FLG_EXTERNALPREFIX,
2598     "set namespace prefix for external identifiers",
2599     "An external identifier does not start with the externalprefix",
2600     0, 0
2601   } ,
2602   {
2603     FK_NAMES, FK_PREFIX, plainFlag,
2604     "externalprefixexclude",
2605     FLG_EXTERNALPREFIXEXCLUDE,
2606     "the externalprefix may not be used for non-external identifiers",
2607     "An identifier that is not external starts with the externalprefix.",
2608     0, 0
2609   } ,
2610   {
2611     FK_NAMES, FK_PREFIX, idemStringFlag,
2612     "localprefix",
2613     FLG_LOCALPREFIX,
2614     "set namespace prefix for local variables",
2615     "A local variable does not start with the localprefix",
2616     0, 0
2617   } ,
2618   {
2619     FK_NAMES, FK_PREFIX, plainFlag,
2620     "localprefixexclude",
2621     FLG_LOCALPREFIXEXCLUDE,
2622     "the localprefix may not be used for non-local identifiers",
2623     "An identifier that is not a local variable starts with the localprefix.",
2624     0, 0
2625   } ,
2626   {
2627     FK_NAMES, FK_PREFIX, idemStringFlag,
2628     "uncheckedmacroprefix",
2629     FLG_UNCHECKEDMACROPREFIX,
2630     "set namespace prefix for unchecked macros",
2631     "An unchecked macro name does not start with the uncheckedmacroprefix",
2632     0, 0
2633   } ,
2634   {
2635     FK_NAMES, FK_PREFIX, plainFlag,
2636     "uncheckedmacroprefixexclude",
2637     FLG_UNCHECKEDMACROPREFIXEXCLUDE,
2638     "the uncheckmacroprefix may not be used for identifiers that are not "
2639     "unchecked macros",
2640     "An identifier that is not the name of an unchecked macro "
2641     "starts with the uncheckedmacroprefix.",
2642     0, 0
2643   } ,
2644   {
2645     FK_NAMES, FK_PREFIX, idemStringFlag,
2646     "constprefix",
2647     FLG_CONSTPREFIX,
2648     "set namespace prefix for constants",
2649     "A constant does not start with the constantprefix",
2650     0, 0
2651   } ,
2652   {
2653     FK_NAMES, FK_PREFIX, plainFlag,
2654     "constprefixexclude",
2655     FLG_CONSTPREFIXEXCLUDE,
2656     "the constprefix may not be used for non-constant identifiers",
2657     "An identifier that is not a constant starts with the constantprefix.",
2658     0, 0
2659   } ,
2660   {
2661     FK_NAMES, FK_PREFIX, idemStringFlag,
2662     "iterprefix",
2663     FLG_ITERPREFIX,
2664     "set namespace prefix for iterators",
2665     "An iter does not start with the iterator prefix",
2666     0, 0
2667   } ,
2668   {
2669     FK_NAMES, FK_PREFIX, plainFlag,
2670     "iterprefixexclude",
2671     FLG_ITERPREFIXEXCLUDE,
2672     "the iterprefix may not be used for non-iter identifiers",
2673     "An identifier that is not a iter starts with the iterprefix.",
2674     0, 0
2675   } ,
2676   {
2677     FK_NAMES, FK_PREFIX, idemStringFlag,
2678     "protoparamprefix",
2679     FLG_DECLPARAMPREFIX,
2680     "set namespace prefix for parameters in function prototype declarations",
2681     "A parameter name in a function prototype declaration does not start with the "
2682     "declaration parameter prefix",
2683     0, 0
2684   } ,
2685   {
2686     FK_NAMES, FK_PREFIX, modeFlag,
2687     "protoparamname",
2688     FLG_DECLPARAMNAME,
2689     "a parameter in a function prototype has a name",
2690     "A parameter in a function prototype has a name.  This is dangerous, "
2691     "since a macro definition could be visible here.",
2692     0, 0
2693   } ,
2694   {
2695     FK_NAMES, FK_PREFIX, modeFlag,
2696     "protoparammatch",
2697     FLG_DECLPARAMMATCH,
2698     "the name of a parameter in a function prototype and corresponding "
2699     "declaration must match (after removing the protoparamprefix",
2700     "A parameter in a function definition does not have the same name as "
2701     "the corresponding in the declaration of the function after "
2702     "removing the protoparamprefix",
2703     0, 0
2704   } ,
2705   {
2706     FK_NAMES, FK_PREFIX, plainFlag,
2707     "protoparamprefixexclude",
2708     FLG_DECLPARAMPREFIXEXCLUDE,
2709     "the protoparamprefix may not be used for non-declaraction parameter identifiers",
2710     "An identifier that is not a parameter name in a function prototype "
2711     "starts with the protoparamprefix.",
2712     0, 0
2713   } ,
2714   {
2715     FK_LIMITS, FK_ANSI, modeValueFlag,
2716     "controlnestdepth",
2717     FLG_CONTROLNESTDEPTH,
2718     "set maximum nesting depth of compound statements, iteration control "
2719     "structures, and selection control structures (ANSI minimum is 15)",
2720     "Maximum number of control levels exceeded.",
2721     0, 0
2722   },
2723   {
2724     FK_LIMITS, FK_ANSI, modeValueFlag,
2725     "stringliterallen",
2726     FLG_STRINGLITERALLEN,
2727     "set maximum length of string literals (ANSI minimum is 509)",
2728     "Maximum length of string literal exceeded.",
2729     0, 0
2730   },
2731   {
2732     FK_LIMITS, FK_ANSI, modeValueFlag,
2733     "numstructfields",
2734     FLG_NUMSTRUCTFIELDS,
2735     "set maximum number of fields in a struct or union (ANSI minimum is 127)",
2736     "Maximum number of fields in a struct or union exceeded.",
2737     0, 0
2738   },
2739   {
2740     FK_LIMITS, FK_ANSI, modeValueFlag,
2741     "numenummembers",
2742     FLG_NUMENUMMEMBERS,
2743     "set maximum number of members of an enum (ANSI minimum is 127)",
2744     "Limit on maximum number of members of an enum is exceeded.",
2745     0, 0
2746   },
2747   {
2748     FK_LIMITS, FK_ANSI, modeValueFlag,
2749     "includenest",
2750     FLG_INCLUDENEST,
2751     "set maximum number of nested #include files",
2752     "Maximum number of nested #include files exceeded.",
2753     0, 0
2754   },
2755   {
2756     FK_LIMITS, FK_ANSI, specialFlag,
2757     "ansilimits",
2758     FLG_ANSILIMITS,
2759     "check for violations of standard limits (controlnestdepth, "
2760     "stringliterallen, includenest, numstructfields, numenummembers)",
2761     NULL,
2762     0, 0
2763   },
2764   {
2765     FK_NAMES, FK_NONE, plainFlag,
2766     "name",
2767     FLG_NAME,
2768     NULL,
2769     "Naming convention is violated.",
2770     0, 0
2771   },
2772   {
2773     FK_NONE, FK_NONE, plainFlag,
2774     "unclassified",
2775     FLG_UNCLASSIFIED,
2776     NULL, NULL,
2777     0, 0
2778   },
2779   {
2780     FK_NULL, FK_MEMORY, specialFlag,
2781     "null",
2782     FLG_NULL,
2783     "misuses of null pointer",
2784     "A possibly null pointer is misused (sets nullderef, nullpass, "
2785     "nullref, nullassign, and nullstate).",
2786     0, 0
2787   },
2788   {
2789     FK_NT, FK_MEMORY, modeFlag,
2790     "nullterminated",
2791     FLG_NULLTERMINATED,
2792     "misuse of nullterminated allocation",
2793     "A possibly non-nullterminated string/memory is used/referenced as a nullterminated one,  ",
2794     0, 0
2795   },
2796   {
2797     FK_NT, FK_MEMORY, modeFlag,
2798     "arrayread",
2799     FLG_ARRAYREAD,
2800     "possible out of bounds read",
2801     "An array or pointer access references memory beyond the array or buffer,  ",
2802     0, 0
2803   },
2804   {
2805     FK_NT, FK_MEMORY, modeFlag,
2806     "arraywrite",
2807     FLG_ARRAYWRITE,
2808     "possible buffer overflow from an out of bounds write",
2809     "Memory is set past the end of an array or or after the allocated buffer,  ",
2810     0, 0
2811   },
2812
2813   {
2814     FK_NT, FK_MEMORY, modeFlag,
2815     "fcnpost",
2816     FLG_FUNCTIONPOST,
2817     "Function has the post condition",
2818     "LCLint has determined that the following statement is true after the function,  ",
2819     0, 0
2820   },
2821
2822   {
2823     FK_NT, FK_MEMORY, modeFlag,
2824     "parenconstraint",
2825     FLG_PARENCONSTRAINT,
2826     "parenthesize constraint term",
2827     "This flag is for debugging.  This flag causes LCLint to fully parentheses constraints,  ",
2828     0, 0
2829   },
2830
2831   {
2832     FK_NT, FK_MEMORY, modeFlag,
2833     "debugfcnconstraint",
2834     FLG_DEBUGFUNCTIONCONSTRAINT,
2835     "debuging constraint flas",
2836     "This flag is for debuging.  It causes lclint to perform buffer overflow checking even if the errors would be surpressed.  Normally buffer overflow checking will only be performed if the errors would be printed. ",
2837     0, 0
2838   },
2839
2840   {
2841     FK_NT, FK_MEMORY, modeFlag,
2842     "arraybounds",
2843     FLG_ARRAYBOUNDS,
2844     "Possible out-of-bounds store.  Unable to resolve constraint:",
2845     "LCLint was unable to resolve a constraint at the top of the function.  If code is correct consider using explict annotation assertions,  ",
2846     0, 0
2847   },
2848   {
2849     FK_NT, FK_MEMORY, modeFlag,
2850     "arrayboundsread",
2851     FLG_ARRAYBOUNDSREAD,
2852     "Possible out-of-bounds read.  Unable to resolve constraint:",
2853     "LCLint was unable to resolve a constraint at the top of the function.  If code is correct consider using explict annotation assertions,  ",
2854     0, 0
2855   },
2856
2857   {
2858     FK_NT, FK_MEMORY, modeFlag,
2859     "fcnconstraint",
2860     FLG_FUNCTIONCONSTRAINT,
2861     "unresolved constraint",
2862     "LCLint was unable to resolve a constraint at the top of the function.  If code is correct consider using explict annotation assertions,  ",
2863     0, 0
2864   },
2865   /*drl7x added 6/18/01 */
2866   {
2867     FK_NT, FK_MEMORY, modeFlag,
2868     "checkpost",
2869     FLG_CHECKPOST,
2870     "unable to verify ensures annotation",
2871     "LCLint was unable to determine that the function satisfies a post condition given in an ensures annotation,  ",
2872     0, 0
2873   },
2874
2875   {
2876     FK_NT, FK_MEMORY, modeFlag,
2877     "constraintlocation",
2878     FLG_CONSTRAINTLOCATION,
2879     "display full c expression for every constraint generated",
2880     ",  ",
2881     0, 0
2882   },/*drl added flag 4/26/01*/
2883   {
2884     FK_NT, FK_MEMORY, modeFlag,
2885     "implictconstraint",
2886     FLG_IMPLICTCONSTRAINT,
2887     "Try to generate implicit constraints for functions",
2888     ",  ",
2889     0, 0
2890   },
2891   /*drl7x added 4/29/01 */
2892   {
2893     FK_NT, FK_MEMORY, modeFlag,
2894     "orconstraint",
2895     FLG_ORCONSTRAINT,
2896     "Use limited OR expressions to resolve constraints",
2897     ",  ",
2898     0, 0
2899   },
2900
2901   {
2902     FK_NT, FK_MEMORY, modeFlag,
2903     "nullterminated",
2904     FLG_NULLTERMINATEDWARNING,
2905     "misuse of nullterminated allocation",
2906     "WARNING:A user annotated non-nullterminated buffer is used/referenced as a nullterminated one,  ",
2907     0, 0
2908   },
2909   {
2910     FK_NULL, FK_MEMORY, modeFlag,
2911     "nullderef",
2912     FLG_NULLDEREF,
2913     "possible dereferencce of null pointer",
2914     "A possibly null pointer is dereferenced.  Value is "
2915     "either the result of a function which may return null "
2916     "(in which case, code should check it is not null), or a "
2917     "global, parameter or structure field declared with the "
2918     "null qualifier.",
2919     0, 0
2920   },
2921   {
2922     FK_TYPE, FK_NONE, modeFlag,
2923     "fcnderef",
2924     FLG_FCNDEREF,
2925     "dereferencce of a function type",
2926     "A function type is dereferenced.  The ANSI standard allows this "
2927     "because of implicit conversion of function designators, however the "
2928     "dereference is unnecessary.",
2929     0, 0
2930   },
2931   {
2932     FK_NULL, FK_MEMORY, modeFlag,
2933     "nullpass",
2934     FLG_NULLPASS,
2935     "possibly null pointer passed as formal with no null annotation",
2936     "A possibly null pointer is passed as a parameter corresponding to "
2937     "a formal parameter with no /*@null@*/ annotation.  If NULL "
2938     "may be used for this parameter, add a /*@null@*/ annotation "
2939     "to the function parameter declaration.",
2940     0, 0
2941   },
2942   {
2943     FK_NULL, FK_MEMORY, modeFlag,
2944     "nullret",
2945     FLG_NULLRET,
2946     "possibly null pointer returned as result with no null annotation",
2947     "Function returns a possibly null pointer, but is not declared "
2948     "using /*@null@*/ annotation of result.  If function may "
2949     "return NULL, add /*@null@*/ annotation to the return "
2950     "value declaration.",
2951     0, 0
2952   },
2953   {
2954     FK_NULL, FK_MEMORY, modeFlag,
2955     "nullstate",
2956     FLG_NULLSTATE,
2957     "possibly null pointer reachable from a reference with no null annotation",
2958     "A possibly null pointer is reachable from a parameter or global "
2959     "variable that is not declared using a /*@null@*/ annotation.",
2960     0, 0
2961   },
2962   {
2963     FK_NULL, FK_MEMORY, modeFlag,
2964     "nullassign",
2965     FLG_NULLASSIGN,
2966     "inconsistent assignment or initialization involving null pointer",
2967     "A reference with no null annotation is assigned or initialized "
2968     "to NULL.  Use /*@null@*/ to declare the reference as "
2969     "a possibly null pointer.",
2970     0, 0
2971   },
2972   {
2973     FK_OPS, FK_BOOL, modeFlag,
2974     "boolcompare",
2975     FLG_BOOLCOMPARE,
2976     "comparison between bools (dangerous because of multiple TRUE values)",
2977     "Two bool values are compared directly using a C primitive. This "
2978     "may produce unexpected results since all non-zero values are "
2979     "considered TRUE, so different TRUE values may not be equal. "
2980     "The file bool.h (included in lclint/lib) provides bool_equal "
2981     "for safe bool comparisons.", 0, 0
2982   },
2983   {
2984     FK_OPS, FK_NONE, modeFlag,
2985     "realcompare",
2986     FLG_REALCOMPARE,
2987     "dangerous comparison between reals (dangerous because of inexact "
2988     "floating point representations)",
2989     "Two real (float, double, or long double) values are compared "
2990     "directly using a C primitive. "
2991     "This may produce unexpected results since floating point "
2992     "representations are inexact. Instead, compare the difference to "
2993     "FLT_EPSILON or DBL_EPSILON.",
2994     0, 0,
2995   },
2996   {
2997     FK_OPS, FK_NONE, modeFlag,
2998     "unsignedcompare",
2999     FLG_UNSIGNEDCOMPARE,
3000     "comparison using <, <=, >= between an unsigned integral and zero constant",
3001     "An unsigned value is used in a comparison with zero in a way that is either a bug or confusing.",
3002     0, 0,
3003   },
3004   {
3005     FK_OPS, FK_POINTER, modeFlag,
3006     "ptrarith",
3007     FLG_POINTERARITH,
3008     "arithmetic involving pointer and integer",
3009     "Pointer arithmetic using pointer and integer.", 0, 0
3010   },
3011   {
3012     FK_OPS, FK_POINTER, modeFlag,
3013     "nullptrarith",
3014     FLG_NULLPOINTERARITH,
3015     "arithmetic involving possibly null pointer and integer",
3016     "Pointer arithmetic using a possibly null pointer and integer.", 0, 0
3017   },
3018   {
3019     FK_OPS, FK_POINTER, modeFlag,
3020     "ptrcompare",
3021     FLG_PTRNUMCOMPARE,
3022     "comparison between pointer and number",
3023     "A pointer is compared to a number.", 0, 0
3024   },
3025   {
3026     FK_OPS, FK_TYPE, modeFlag,
3027     "strictops",
3028     FLG_STRICTOPS,
3029     "primitive operation does not type check strictly",
3030     "A primitive operation does not type check strictly.", 0, 0
3031   },
3032   {
3033     FK_OPS, FK_TYPE, modeFlag,
3034     "bitwisesigned",
3035     FLG_BITWISEOPS,
3036     "a bitwise logical operator does not have unsigned operands",
3037     "An operand to a bitwise operator is not an unsigned values.  This "
3038     "may have unexpected results depending on the signed "
3039     "representations.", 0, 0
3040   },
3041   {
3042     FK_OPS, FK_TYPE, modeFlag,
3043     "shiftsigned",
3044     FLG_SHIFTSIGNED,
3045     "a shift operator does not have unsigned operands",
3046     "An operand to a shift operator is not unsigned values.  This "
3047     "may have unexpected results depending on the signed "
3048     "representations.", 0, 0
3049   },
3050   {
3051     FK_OPS, FK_BOOL, modeFlag,
3052     "boolops",
3053     FLG_BOOLOPS,
3054     "primitive operation (!, && or ||) does not has a boolean argument",
3055     "The operand of a boolean operator is not a boolean. Use +ptrnegate "
3056     "to allow ! to be used on pointers.",
3057     0, 0
3058   },
3059   {
3060     FK_OPS, FK_POINTER, modeFlag,
3061     "ptrnegate",
3062     FLG_PTRNEGATE,
3063     "allow ! to be used on pointer operand",
3064     "The operand of ! operator is a pointer.", 0, 0
3065   },
3066   {
3067     FK_OPS, FK_TYPE, modeFlag,
3068     "sizeoftype",
3069     FLG_SIZEOFTYPE,
3070     "sizeof operator has a type argument",
3071     "Operand of sizeof operator is a type. (Safer to use expression, "
3072     "int *x = sizeof (*x); instead of sizeof (int).)",
3073     0, 0
3074   },
3075   {
3076     FK_OPS, FK_TYPE, plainFlag,
3077     "sizeofformalarray",
3078     FLG_SIZEOFFORMALARRAY,
3079     "sizeof operator has an array formal parameter argument",
3080     "Operand of a sizeof operator is a function parameter declared as "
3081     "an array.  The value of sizeof will be the size of a pointer to the "
3082     "element type, not the number of elements in the array.",
3083     0, 0
3084   },
3085   {
3086     FK_DECL, FK_TYPE, plainFlag,
3087     "fixedformalarray",
3088     FLG_FIXEDFORMALARRAY,
3089     "formal parameter of type array is declared with size",
3090     "A formal parameter is declared as an array with size.  The size of the array "
3091     "is ignored in this context, since the array formal parameter is treated "
3092     "as a pointer.",
3093     0, 0
3094   },
3095   {
3096     FK_DECL, FK_TYPE, plainFlag,
3097     "incompletetype",
3098     FLG_INCOMPLETETYPE,
3099     "formal parameter has an incomplete type",
3100     "A formal parameter is declared with an incomplete type.",
3101     0, 0
3102   },
3103   {
3104     FK_DECL, FK_TYPE, plainFlag,
3105     "formalarray",
3106     FLG_FORMALARRAY,
3107     "formal parameter is an array",
3108     "A formal parameter is declared as an array.  This can be confusing, since "
3109     "a formal array parameter is treated as a pointer.",
3110     0, 0
3111   },
3112   {
3113     FK_PRED, FK_BOOL, plainFlag,
3114     "predassign",
3115     FLG_PREDASSIGN,
3116     "condition test (if, while or for) is an assignment",
3117     "The condition test is an assignment expression. Probably, you mean "
3118     "to use == instead of =. If an assignment is intended, add an "
3119     "extra parentheses nesting (e.g., if ((a = b)) ...) to suppress "
3120     "this message.",
3121     0, 0
3122   },
3123   {
3124     FK_PRED, FK_BOOL, specialFlag,
3125     "predbool",
3126     FLG_PREDBOOL,
3127     "type of condition test (if, while or for) not bool (sets predboolint, "
3128     "predboolptr and predboolothers)",
3129     "Test expression type is not boolean.", 0, 0
3130   },
3131   {
3132     FK_PRED, FK_BOOL, modeFlag,
3133     "predboolint",
3134     FLG_PREDBOOLINT,
3135     "type of condition test (if, while or for) is an integral type",
3136     "Test expression type is not boolean or int.", 0, 0
3137   },
3138   {
3139     FK_PRED, FK_BOOL, modeFlag,
3140     "predboolothers",
3141     FLG_PREDBOOLOTHERS,
3142     "type of condition test (if, while or for) not bool, int or pointer",
3143     "Test expression type is not boolean.", 0, 0
3144   },
3145   {
3146     FK_PRED, FK_BOOL, modeFlag,
3147     "predboolptr",
3148     FLG_PREDBOOLPTR,
3149     "type of condition test (if, while or for) is a pointer",
3150     "Test expression type is not boolean.", 0, 0
3151   },
3152   {
3153     FK_PREPROC, FK_NONE, globalExtraArgFlag,
3154     "D<initializer>",
3155     FLG_DEFINE,
3156     "passed to pre-processor",
3157     NULL, 0, 0
3158   },
3159   {
3160     FK_PREPROC, FK_NONE, globalExtraArgFlag,
3161     "U<initializer>",
3162     FLG_UNDEFINE,
3163     "passed to pre-processor",
3164     NULL, 0, 0
3165   },
3166   {
3167     FK_GLOBALS, FK_NONE, modeFlag,
3168     "globstate",
3169     FLG_GLOBSTATE,
3170     "returns with global in inconsistent state (null or undefined)",
3171     "A global variable does not satisfy its annotations when control is transferred.",
3172     0, 0
3173   },
3174   {
3175     FK_SUPPRESS, FK_COMMENTS, globalFlag,
3176     "supcounts",
3177     FLG_SUPCOUNTS,
3178     "The number of errors detected does not match number in /*@i<n>@*/.",
3179     NULL, 0, 0
3180   },
3181   {
3182     FK_SUPPRESS, FK_ERRORS, valueFlag,
3183     "limit",
3184     FLG_LIMIT,
3185     "limit <int> consecutive repeated errors",
3186     NULL, 0, 0
3187   },
3188   {
3189     FK_SYNTAX, FK_NONE, plainFlag,
3190     "syntax",
3191     FLG_SYNTAX,
3192     "syntax error in parsing",
3193     "Code cannot be parsed.  For help on parse errors, see lclint -help parseerrors.",
3194     0, 0
3195   },
3196   {
3197     FK_SYNTAX, FK_NONE, plainFlag,
3198     "trytorecover",
3199     FLG_TRYTORECOVER,
3200     "try to recover from parse error",
3201     "Try to recover from parse error.  It really means try --- this doesn't usually work.", 0, 0
3202   },
3203   {
3204     FK_SYNTAX, FK_PREPROC, plainFlag,
3205     "preproc",
3206     FLG_PREPROC,
3207     NULL, NULL,
3208     0, 0
3209   },
3210   {
3211     FK_TYPE, FK_NONE, plainFlag,
3212     "type",
3213     FLG_TYPE,
3214     "type mismatch",
3215     "Types are incompatible.",
3216     0, 0
3217   },
3218   {
3219     FK_TYPE, FK_NONE, plainFlag,
3220     "fullinitblock",
3221     FLG_FULLINITBLOCK,
3222     "initializer sets all fields",
3223     "Initializer does not set every field in the structure.",
3224     0, 0
3225   },
3226   {
3227     FK_TYPE, FK_NONE, plainFlag,
3228     "initallelements",
3229     FLG_INITALLELEMENTS,
3230     "initializer defines all array elements",
3231     "Initializer does not define all elements of a declared array.",
3232     0, 0
3233   },
3234   {
3235     FK_TYPE, FK_NONE, plainFlag,
3236     "initsize",
3237     FLG_INITSIZE,
3238     "initializer defines extra array elements",
3239     "Initializer block contains more elements than the size of a declared array.",
3240     0, 0
3241   },
3242   {
3243     FK_TYPE, FK_NONE, plainFlag,
3244     "stringliteraltoolong",
3245     FLG_STRINGLITTOOLONG,
3246     "string literal too long for character array",
3247     "A string literal is assigned to a char array too small to hold it.",
3248     0, 0
3249   },
3250   {
3251     FK_TYPE, FK_NONE, modeFlag,
3252     "stringliteralnoroom",
3253     FLG_STRINGLITNOROOM,
3254     "string literal leaves no room for null terminator",
3255     "A string literal is assigned to a char array that is not big enough to hold the null terminator.",
3256     0, 0
3257   },
3258   {
3259     FK_TYPE, FK_NONE, modeFlag,
3260     "stringliteralsmaller",
3261     FLG_STRINGLITSMALLER,
3262     "string literal is smaller than the char array it is assigned to",
3263     "A string literal is assigned to a char array that smaller than the string literal needs.",
3264     0, 0
3265   },
3266   {
3267     FK_TYPE, FK_NONE, modeFlag,
3268     "enummembers",
3269     FLG_ENUMMEMBERS,
3270     "enum members must be int values",
3271     "Type of initial values for enum members must be int.",
3272     0, 0
3273   },
3274
3275   {
3276     FK_TYPE, FK_NONE, plainFlag,
3277     "maintype",
3278     FLG_MAINTYPE,
3279     "type of main does not match expected type",
3280     "The function main does not match the expected type.",
3281     0, 0
3282   },
3283   {
3284     FK_TYPE, FK_NONE, plainFlag,
3285     "formattype",
3286     FLG_FORMATTYPE,
3287     "type-mismatch in parameter corresponding to format code in a printf or scanf-like function",
3288     "Type of parameter is not consistent with corresponding code in format string.",
3289     0, 0
3290   },
3291   {
3292     FK_TYPE, FK_NONE, modeFlag,
3293     "formatconst",
3294     FLG_FORMATCONST,
3295     "format parameter is not a string constant (hence variable arguments cannot be typechecked)",
3296     "Format parameter is not known at compile-time.  This can lead to security vulnerabilities because the arguments cannot be type checked.",
3297     0, 0
3298   },
3299   {
3300     FK_TYPE, FK_NONE, plainFlag,
3301     "formatcode",
3302     FLG_FORMATCODE,
3303     "invalid format code in format string for printf or scanf-like function",
3304     "Format code in a format string is not valid.",
3305     0, 0
3306   },
3307   {
3308     FK_TYPEEQ, FK_ABSTRACT, modeFlag,
3309     "forwarddecl",
3310     FLG_FORWARDDECL,
3311     "forward declarations of pointers to abstract representation match abstract type",
3312     NULL, 0, 0
3313   },
3314   {
3315     FK_TYPEEQ, FK_ABSTRACT, modeFlag,
3316     "voidabstract",
3317     FLG_ABSTVOIDP,
3318     "void * matches pointers to abstract types, casting ok (dangerous)",
3319     "A pointer to void is cast to a pointer to an abstract type (or vice versa).",
3320     0, 0
3321   },
3322   {
3323     FK_TYPEEQ, FK_POINTER, plainFlag,
3324     "castfcnptr",
3325     FLG_CASTFCNPTR,
3326     "a pointer to a function is cast to a pointer to void (or vice versa)",
3327     "A pointer to a function is cast to (or used as) a pointer to void (or vice versa).",
3328     0, 0
3329   },
3330   {
3331     FK_TYPEEQ, FK_ARRAY, modeFlag,
3332     "charindex",
3333     FLG_CHARINDEX,
3334     "char can be used to index arrays",
3335     "To allow char types to index arrays, use +charindex.", 0, 0
3336   },
3337   {
3338     FK_TYPEEQ, FK_ARRAY, modeFlag,
3339     "enumindex",
3340     FLG_ENUMINDEX,
3341     "enum can be used to index arrays",
3342     "To allow enum types to index arrays, use +enumindex.", 0, 0
3343   },
3344   {
3345     FK_TYPEEQ, FK_BOOL, modeFlag,
3346     "boolint",
3347     FLG_BOOLINT,
3348     "bool and int are equivalent",
3349     "To make bool and int types equivalent, use +boolint.",
3350     0, 0
3351   },
3352   {
3353     FK_TYPEEQ, FK_NONE, modeFlag,
3354     "charint",
3355     FLG_CHARINT,
3356     "char and int are equivalent",
3357     "To make char and int types equivalent, use +charint.",
3358     0, 0
3359   },
3360   {
3361     FK_TYPEEQ, FK_NONE, modeFlag,
3362     "enumint",
3363     FLG_ENUMINT,
3364     "enum and int are equivalent",
3365     "To make enum and int types equivalent, use +enumint.",
3366     0, 0
3367   },
3368   {
3369     FK_TYPEEQ, FK_NONE, modeFlag,
3370     "floatdouble",
3371     FLG_FLOATDOUBLE,
3372     "float and double are equivalent",
3373     "To make float and double types equivalent, use +floatdouble.",
3374     0, 0
3375   },
3376   {
3377     FK_TYPEEQ, FK_NUMBERS, modeFlag,
3378     "ignorequals",
3379     FLG_IGNOREQUALS,
3380     "ignore type qualifiers (long, short, unsigned)",
3381     "To ignore type qualifiers in type comparisons use +ignorequals.",
3382     0, 0
3383   },
3384   {
3385     FK_TYPEEQ, FK_SYNTAX, plainFlag,
3386     "duplicatequals",
3387     FLG_DUPLICATEQUALS,
3388     "report duplicate type qualifiers (e.g., long long)",
3389     "Duplicate type qualifiers not supported by ANSI. Some "
3390     "compilers (e.g., gcc) do support duplicate qualifiers.",
3391     0, 0
3392   },
3393   {
3394     FK_TYPEEQ, FK_NUMBERS, modeFlag,
3395     "ignoresigns",
3396     FLG_IGNORESIGNS,
3397     "ignore signs in type comparisons (unsigned matches signed)",
3398     "To ignore signs in type comparisons use +ignoresigns",
3399     0, 0
3400   },
3401   {
3402     FK_TYPEEQ, FK_NUMBERS, modeFlag,
3403     "numliteral",
3404     FLG_NUMLITERAL,
3405     "int literals can be reals",
3406     "An int literal is used as any numeric type (including float and long long). Use +numliteral to "
3407     "allow int literals to be used as any numeric type.",
3408     0, 0
3409   },
3410   {
3411     FK_TYPEEQ, FK_NUMBERS, modeFlag,
3412     "charintliteral",
3413     FLG_CHARINTLITERAL,
3414     "character constants (e.g., 'a') can be used as ints",
3415     "A character constant is used as an int. Use +charintliteral to "
3416     "allow character constants to be used as ints.  (This is safe "
3417     "since the actual type of a char constant is int.)",
3418     0, 0
3419   },
3420   {
3421     FK_TYPEEQ, FK_NUMBERS, modeFlag,
3422     "relaxquals",
3423     FLG_RELAXQUALS,
3424     "report qualifier mismatches only if dangerous",
3425     "To allow qualifier mismatches that are not dangerous, use +relaxquals.", 0, 0
3426   },
3427   {
3428     FK_TYPEEQ, FK_NUMBERS, modeFlag,
3429     "relaxtypes",
3430     FLG_RELAXTYPES,
3431     "allow all numeric types to match",
3432     "To allow all numeric types to match, use +relaxtypes.", 0, 0
3433   },
3434   {
3435     FK_TYPEEQ, FK_NONE, modeFlag,
3436     "charunsignedchar",
3437     FLG_CHARUNSIGNEDCHAR,
3438     "allow char and unsigned char types to match",
3439     "To allow char and unsigned char types to match use +charunsignedchar.",
3440     0, 0
3441   },
3442   {
3443     FK_TYPEEQ, FK_NUMBERS, modeFlag,
3444     "matchanyintegral",
3445     FLG_MATCHANYINTEGRAL,
3446     "allow any intergral type to match an arbitrary integral type (e.g., dev_t)",
3447     "To allow arbitrary integral types to match any integral type, use +matchanyintegral.",
3448     0, 0
3449   },
3450   {
3451     FK_TYPEEQ, FK_NUMBERS, modeFlag,
3452     "longunsignedintegral",
3453     FLG_LONGUNSIGNEDINTEGRAL,
3454     "allow long unsigned type to match an arbitrary integral type (e.g., dev_t)",
3455     "To allow arbitrary integral types to match long unsigned, use +longunsignedintegral.",
3456     0, 0
3457   },
3458   {
3459     FK_TYPEEQ, FK_NUMBERS, modeFlag,
3460     "longintegral",
3461     FLG_LONGINTEGRAL,
3462     "allow long type to match an arbitrary integral type (e.g., dev_t)",
3463     "To allow arbitrary integral types to match long unsigned, use +longintegral.",
3464     0, 0
3465   },
3466   {
3467     FK_TYPEEQ, FK_NUMBERS, modeFlag,
3468     "longunsignedunsignedintegral",
3469     FLG_LONGUNSIGNEDUNSIGNEDINTEGRAL,
3470     "allow long unsigned type to match an arbitrary unsigned integral type (e.g., size_t)",
3471     "To allow arbitrary unsigned integral types to match long unsigned, "
3472     "use +longunsignedunsignedintegral.",
3473     0, 0
3474   },
3475   {
3476     FK_TYPEEQ, FK_NUMBERS, modeFlag,
3477     "longsignedintegral",
3478     FLG_LONGSIGNEDINTEGRAL,
3479     "allow long type to match an arbitrary signed integral type (e.g., ssize_t)",
3480     "To allow arbitrary signed integral types to match long unsigned, use +longsignedintegral.",
3481     0, 0
3482   },
3483   {
3484     FK_TYPEEQ, FK_POINTER, plainFlag,
3485     "zeroptr",
3486     FLG_ZEROPTR,
3487     "0 is treated as a pointer",
3488     NULL, 0, 0
3489   },
3490   {
3491     FK_TYPEEQ, FK_BOOL, modeFlag,
3492     "zerobool",
3493     FLG_ZEROBOOL,
3494     "0 is treated as a boolean",
3495     NULL, 0, 0
3496   },
3497   {
3498     FK_UNRECOG, FK_DISPLAY, plainFlag,
3499     "repeatunrecog",
3500     FLG_REPEATUNRECOG,
3501     "do not suppress repeated unrecognized identifier messages (instead of only reporting the first error)",
3502     "Identifier used in code has not been declared. (Message repeated for future uses in this file.)",
3503     0, 0
3504   },
3505   {
3506     FK_UNRECOG, FK_DISPLAY, plainFlag,
3507     "sysunrecog",
3508     FLG_SYSTEMUNRECOG,
3509     "report unrecognized identifiers with system (__) prefix",
3510     "Identifier used in code has not been declared. (Message repeated for "
3511     "future uses in this file.)  Use +gnuextensions to make lclint "
3512     "recognize some keywords that are gnu extensions.",
3513     0, 0
3514   },
3515   {
3516     FK_UNRECOG, FK_NONE, plainFlag,
3517     "unrecog",
3518     FLG_UNRECOG,
3519     "unrecognized identifier",
3520     "Identifier used in code has not been declared.", 0, 0
3521   },
3522   {
3523     FK_USE, FK_COMPLETE, modeFlag,
3524     "topuse",
3525     FLG_TOPUNUSED,
3526     "declaration at top level not used",
3527     "An external declaration not used in any source file.", 0, 0
3528   },
3529   {
3530     FK_USE, FK_EXPORT, modeFlag,
3531     "exportlocal",
3532     FLG_EXPORTLOCAL,
3533     "a declaration is exported but not used outside this module",
3534     "A declaration is exported, but not used outside this module. "
3535     "Declaration can use static qualifier.",
3536     0, 0
3537   },
3538   {
3539     FK_USE, FK_EXPORT, modeFlag,
3540     "exportheader",
3541     FLG_EXPORTHEADER,
3542     "a declaration is exported but does not appear in a header file",
3543     "A declaration is exported, but does not appear in a header file.",
3544     0, 0
3545   },
3546   {
3547     FK_USE, FK_EXPORT, modeFlag,
3548     "exportheadervar",
3549     FLG_EXPORTHEADERVAR,
3550     "a variable declaration is exported but does not appear in a header file",
3551     "A variable declaration is exported, but does not appear in a header "
3552     "file. (Used with exportheader.)",
3553     0, 0
3554   },
3555   {
3556     FK_USE, FK_NONE, modeFlag,
3557     "fielduse",
3558     FLG_FIELDUNUSED,
3559     "field of structure type not used",
3560     "A field is present in a structure type but never used. Use /*@unused@*/ in front of field declaration to suppress message.",
3561     0, 0
3562   },
3563   {
3564     FK_USE, FK_NONE, modeFlag,
3565     "enummemuse",
3566     FLG_ENUMMEMUNUSED,
3567     "member of an enum type not used",
3568     "A member of an enum type is never used.",
3569     0, 0
3570   },
3571   {
3572     FK_USE, FK_NONE, modeFlag,
3573     "constuse",
3574     FLG_CONSTUNUSED,
3575     "constant declared but not used",
3576     "A constant is declared but not used. Use unused in the constant declaration to suppress message.",
3577     0, 0
3578   },
3579   {
3580     FK_USE, FK_NONE, modeFlag,
3581     "fcnuse",
3582     FLG_FUNCUNUSED,
3583     "function declared but not used",
3584     "A function is declared but not used. Use /*@unused@*/ in front of function header to suppress message.",
3585     0, 0
3586   },
3587   {
3588     FK_USE, FK_PARAMS, modeFlag,
3589     "paramuse",
3590     FLG_PARAMUNUSED,
3591     "function parameter not used ",
3592     "A function parameter is not used in the body of the function. If the argument is needed for type compatibility or future plans, use /*@unused@*/ in the argument declaration.",
3593     0, 0
3594   },
3595   {
3596     FK_USE, FK_TYPE, modeFlag,
3597     "typeuse",
3598     FLG_TYPEUNUSED,
3599     "type declared but not used",
3600     "A type is declared but not used. Use /*@unused@*/ in front of typedef to suppress messages.",
3601     0, 0
3602   },
3603   {
3604     FK_USE, FK_NONE, modeFlag,
3605     "varuse",
3606     FLG_VARUNUSED,
3607     "variable declared but not used",
3608     "A variable is declared but never used. Use /*@unused@*/ in front "
3609     "of declaration to suppress message.",
3610     0, 0
3611   },
3612   {
3613     FK_USE, FK_COMPLETE, modeFlag,
3614     "unusedspecial",
3615     FLG_UNUSEDSPECIAL,
3616     "unused declaration in special file (corresponding to .l or .y file)",
3617     NULL, 0, 0
3618   } ,
3619   {
3620     FK_DECL, FK_TYPE, modeFlag,
3621     "redundantsharequal",
3622     FLG_REDUNDANTSHAREQUAL,
3623     "declaration uses observer qualifier that is always true",
3624     "A declaration of an immutable object uses a redundant observer qualifier.",
3625     0, 0
3626   } ,
3627   {
3628     FK_DECL, FK_TYPE, modeFlag,
3629     "misplacedsharequal",
3630     FLG_MISPLACEDSHAREQUAL,
3631     "declaration of unsharable storage uses sharing annotation",
3632     "A declaration of an unsharable object uses a sharing annotation.",
3633     0, 0
3634   } ,
3635   {
3636     FK_DECL, FK_TYPE, plainFlag,
3637     "annotationerror",
3638     FLG_ANNOTATIONERROR,
3639     "annotation is used in inconsistent location",
3640     "A declaration uses an invalid annotation.",
3641     0, 0
3642   } ,
3643   {
3644     FK_DECL, FK_TYPE, plainFlag,
3645     "commenterror",
3646     FLG_COMMENTERROR,
3647     "inconsistent syntactic comment",
3648     "A syntactic comment is used inconsistently.",
3649     0, 0
3650   } ,
3651   {
3652     FK_DEBUG, FK_NONE, debugFlag,
3653     "showsourceloc",
3654     FLG_SHOWSOURCELOC,
3655     NULL, NULL,
3656     0, 0
3657   },
3658   {
3659     FK_DEBUG, FK_NONE, valueFlag,
3660     "bugslimit",
3661     FLG_BUGSLIMIT,
3662     "set maximum number of bugs detected before giving up",
3663     NULL, 0, 0
3664   },
3665
3666   {
3667     FK_HELP, FK_NONE, plainFlag,
3668     "fileextensions",
3669     FLG_FILEEXTENSIONS,
3670     "warn when command line file does not have a recognized extension",
3671     NULL, 0, 0
3672   },
3673   {
3674     FK_DECL, FK_NONE, plainFlag,
3675     "warnuse",
3676     FLG_WARNUSE,
3677     "warn when declaration marked with warn is used",
3678     "Declaration marked with warn clause is used (can be suppresed by more specific flags).",
3679     0, 0
3680   },
3681   {
3682     FK_MEMORY, FK_DEF, modeFlag,
3683     "statetransfer",
3684     FLG_STATETRANSFER,
3685     "storage has been transfered with invalid state",
3686     "Transfer violates user-defined state rules.",
3687     0, 0
3688   },
3689   {
3690     FK_MEMORY, FK_DEF, modeFlag,
3691     "statemerge",
3692     FLG_STATEMERGE,
3693     "control paths merge with storage in incompatible states",
3694     "Control path merge violates user-defined state merge rules.",
3695     0, 0
3696   },
3697
3698   /*
3699   ** The its4 level flags must appear in order.
3700   */
3701
3702   {
3703     FK_WARNUSE, FK_SECURITY, specialFlag,
3704     "its4mostrisky",
3705     FLG_ITS4MOSTRISKY,
3706     "most risky security vulnerabilities (from its4 database)",
3707     "Security vulnerability classified as most risky in its4 database.",
3708     0, 0
3709   },
3710   {
3711     FK_WARNUSE, FK_SECURITY, specialFlag,
3712     "its4veryrisky",
3713     FLG_ITS4VERYRISKY,
3714     "very risky security vulnerabilities (from its4 database)",
3715     "Security vulnerability classified as very risky in its4 database.",
3716     0, 0
3717   },
3718   {
3719     FK_WARNUSE, FK_SECURITY, specialFlag,
3720     "its4risky",
3721     FLG_ITS4RISKY,
3722     "risky security vulnerabilities (from its4 database)",
3723     "Security vulnerability classified as risky in its4 database.",
3724     0, 0
3725   },
3726   {
3727     FK_WARNUSE, FK_SECURITY, specialFlag,
3728     "its4moderate",
3729     FLG_ITS4MODERATERISK,
3730     "moderately risky security vulnerabilities (from its4 database)",
3731     "Security vulnerability classified as moderate risk in its4 database.",
3732     0, 0
3733   },
3734   {
3735     FK_WARNUSE, FK_SECURITY, specialFlag,
3736     "its4low",
3737     FLG_ITS4LOWRISK,
3738     "risky security vulnerabilities (from its4 database)",
3739     "Security vulnerability classified as risky in its4 database.",
3740     0, 0
3741   },
3742
3743   /*
3744   ** End of its4 level flags
3745   */
3746
3747   {
3748     FK_WARNUSE, FK_SECURITY, modeFlag,
3749     "bufferoverflowhigh",
3750     FLG_BUFFEROVERFLOWHIGH,
3751     "likely buffer overflow vulnerability",
3752     "Use of function that may lead to buffer overflow.",
3753     0, 0
3754   },
3755   {
3756     FK_WARNUSE, FK_SECURITY, modeFlag,
3757     "bufferoverflow",
3758     FLG_BUFFEROVERFLOW,
3759     "possible buffer overflow vulnerability",
3760     "Use of function that may lead to buffer overflow.",
3761     0, 0
3762   },
3763   {
3764     FK_WARNUSE, FK_SECURITY, modeFlag,
3765     "toctou",
3766     FLG_TOCTOU,
3767     "possible time of check, time of use vulnerability",
3768     "Possible time of check, time of use vulnerability.",
3769     0, 0
3770   },
3771   {
3772     FK_WARNUSE, FK_SECURITY, modeFlag,
3773     "multithreaded",
3774     FLG_MULTITHREADED,
3775     "function is not reentrant",
3776     "Non-reentrant function should not be used in multithreaded code.",
3777     0, 0
3778   },
3779   {
3780     FK_WARNUSE, FK_SECURITY, modeFlag,
3781     "portability",
3782     FLG_PORTABILITY,
3783     "function may have undefined behavior",
3784     "Use of function that may have implementation-dependent behavior.",
3785     0, 0
3786   },
3787   {
3788     FK_WARNUSE, FK_SECURITY, modeFlag,
3789     "unixstandard",
3790     FLG_UNIXSTANDARD,
3791     "function is not required in Standard UNIX Specification",
3792     "Use of function that need not be provided by UNIX implementations",
3793     0, 0
3794   },
3795   {
3796     FK_WARNUSE, FK_SECURITY, modeFlag,
3797     "superuser",
3798     FLG_SUPERUSER,
3799     "function is restricted to superusers",
3800     "Call to function restricted to superusers.",
3801     0, 0
3802   },
3803   {
3804     FK_WARNUSE, FK_SECURITY, modeFlag,
3805     "implementationoptional",
3806     FLG_IMPLEMENTATIONOPTIONAL,
3807     "declarator is implementation optional (ISO99 does not require an implementation to provide it)",
3808     "Use of a declarator that is implementation optional, not required by ISO99.",
3809     0, 0
3810   },
3811
3812 } ;