src/flags.c

   1 /*
   2 ** Splint - annotation-assisted static program checker
   3 ** Copyright (C) 1994-2003 University of Virginia,
   4 **         Massachusetts Institute of Technology
   5 **
   6 ** This program is free software; you can redistribute it and/or modify it
   7 ** under the terms of the GNU General Public License as published by the
   8 ** Free Software Foundation; either version 2 of the License, or (at your
   9 ** option) any later version.
  10 **
  11 ** This program is distributed in the hope that it will be useful, but
  12 ** WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 ** General Public License for more details.
  15 **
  16 ** The GNU General Public License is available from http://www.gnu.org/ or
  17 ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18 ** MA 02111-1307, USA.
  19 **
  20 ** For information on splint: info@splint.org
  21 ** To report a bug: splint-bug@splint.org
  22 ** For more information: http://www.splint.org
  23 */
  24 /*
  25 ** flags.c
  26 */
  27
  28 # include "splintMacros.nf"
  29 # include "basic.h"
  30 # include "osd.h"
  31 # include "rcfiles.h"
  32 # include "lslinit.h"
  33 # include "llmain.h"
  34
  35 /*
  36 ** from the CC man page:
  37 **
  38 **  -Idir          Search for #include files whose names do not begin with a
  39 **                    slash (/) in the following order: (1) in the directory of
  40 **                    the dir argument, (2) in the directories specified by -I
  41 **                    options, (3) in the standard directory (/usr/include).
  42 */
  43
  44 /* needed for string literals literals */
  45
  46 typedef struct {
  47   flagkind kind;
  48   /*@null@*/ /*@observer@*/ const char *name;
  49   /*@null@*/ /*@observer@*/ const char *describe;
  50 } flagcatinfo;
  51
  52 static flagcatinfo categories[] =
  53 {
  54   { FK_ABSTRACT, "abstract", "abstraction violations, representation access" } ,
  55   { FK_ALIAS, "aliasing", "unexpected or dangerous aliasing" } ,
  56   { FK_USE, "alluse", "all declarations are used" } ,
  57   { FK_ANSI, "ansi", "violations of constraints imposed by ANSI/ISO standard" } ,
  58   { FK_ARRAY, "arrays", "special checking involving arrays" } ,
  59   { FK_BOOL, "booleans", "checking and naming of boolean types" } ,
  60   { FK_COMMENTS, "comments", "warnings about (normal) comments" } ,
  61   { FK_SYNCOMMENTS, "syncomments", "interpretation of annotation comments" } ,
  62   { FK_COMPLETE, "complete", "completely defined, used, or specified system" } ,
  63   { FK_CONTROL, "controlflow", "suspicious control structures" } ,
  64   { FK_DEBUG, "debug", "flags for debugging splint" } ,
  65   { FK_DECL, "declarations", "consistency of declarations" } ,
  66   { FK_DEF, "definition", "undefined storage errors" } ,
  67   { FK_DIRECT, "directories", "set directores" } ,
  68   { FK_DISPLAY, "display", "control what is displayed" } ,
  69   { FK_EFFECT, "effect", "statements with no effects" } ,
  70   { FK_ERRORS, "errors", "control expected errors, summary reporting" } ,
  71   { FK_EXPORT, "export", "control what may be exported" } ,
  72   { FK_EXPOSURE, "exposure", "representation exposure" } ,
  73   { FK_EXTENSIBLE, "extensible", "user-defined checks and annotations" },
  74   { FK_FILES, "files", "control system files" } ,
  75   { FK_FORMAT, "format", "control format of warning messages" } ,
  76   { FK_GLOBALS, "globals", "use of global and file static variables" },
  77   { FK_HEADERS, "headers", "control inclusion and generation of header files" },
  78   { FK_HELP, "help", "on-line help" },
  79   { FK_BOUNDS, "memorybounds", "out-of-bounds memory accesses" },
  80   { FK_HINTS, "hints", "control display of warning hints" },
  81   { FK_SYSTEMFUNCTIONS, "systemfunctions", "special properties of exit and main" },
  82   { FK_IMPLICIT, "implicit", "control implicit annotations and interpretations" } ,
  83   { FK_INIT, "initializations", "initialization files" } ,
  84   { FK_ITER, "iterators", "checking iterator definitions and uses" } ,
  85   { FK_LEAK, "leaks", "memory leaks" } ,
  86   { FK_LIBS, "libraries", "loading and dumping of user and standard libraries" } ,
  87   { FK_LIMITS, "limits", "violations of set limits" } ,
  88   { FK_MACROS, "macros", "expansion, definition and use of macros" },
  89   { FK_MEMORY, "memory", "memory management" } ,
  90   { FK_MODIFIES, "modification", "modification errors" } ,
  91   { FK_NAMES, "names", "naming conventions and limits" } ,
  92   { FK_NULL, "null", "misuses of null pointers" } ,
  93   { FK_NUMBERS, "numbers", "control type-checking of numeric types" } ,
  94   { FK_OPS, "operations", "checking of primitive operations" } ,
  95   { FK_PARAMS, "parameters", "function and macro parameters" } ,
  96   { FK_SPEED, "performance", "speeding up checking" } ,
  97   { FK_POINTER, "pointers", "pointers" } ,
  98   { FK_PRED, "predicates", "condition test expressions" } ,
  99   { FK_PREFIX, "prefixes", "set naming prefixes and control checking" } ,
 100   { FK_PREPROC, "preproc", "defines and undefines for the preprocessor" } ,
 101   { FK_PROTOS, "prototypes", "function prototypes" } ,
 102   { FK_DEAD, "released", "using storage that has been deallocated" } ,
 103   { FK_IGNORERET, "returnvals", "ignored return values" },
 104   { FK_SECURITY, "security", "possible security vulnerability" },
 105   { FK_SPEC, "specifications", "checks involving .lcl specifications" } ,
 106   { FK_SUPPRESS, "suppress", "local and global suppression of messages" } ,
 107   { FK_TYPEEQ, "typeequivalence", "control what types are equivalent" } ,
 108   { FK_BEHAVIOR, "undefined", "code with undefined or implementation-defined behavior" } ,
 109   { FK_UNRECOG, "unrecognized", "unrecognized identifiers" } ,
 110   { FK_UNSPEC, "unconstrained", "checking in the presence of unconstrained functions" } ,
 111   { FK_WARNUSE, "warnuse", "use of possibly problematic function" } ,
 112   { FK_ITS4, "its4", "its4 compatibility flags (report warnings for uses of possibly insecure functions)" } ,
 113   { FK_SYNTAX, NULL, NULL } ,
 114   { FK_TYPE, NULL, NULL } ,
 115   { FK_SECRET, NULL, NULL } ,
 116   { FK_OBSOLETE, NULL, NULL } ,
 117   { FK_NONE, NULL, NULL }  /* must be last */
 118 } ;
 119
 120 typedef enum {
 121   ARG_NONE,
 122   ARG_NUMBER,    /* number */
 123   ARG_CHAR,      /* char */
 124   ARG_STRING,    /* string */
 125   ARG_FILE,      /* filename (also a string) */
 126   ARG_DIRECTORY, /* directory (also a string) */
 127   ARG_PATH,      /* path */
 128   ARG_SPECIAL   /* ? */
 129 } argcode;
 130
 131 static /*@observer@*/ cstring argcode_unparse (argcode arg)
 132 {
 133   switch (arg)
 134     {
 135     case ARG_STRING: return cstring_makeLiteralTemp ("string");
 136     case ARG_FILE: return cstring_makeLiteralTemp ("filename");
 137     case ARG_DIRECTORY: return cstring_makeLiteralTemp ("directory");
 138     case ARG_PATH: return cstring_makeLiteralTemp ("path");
 139     case ARG_NUMBER: return cstring_makeLiteralTemp ("number");
 140     case ARG_CHAR: return cstring_makeLiteralTemp ("character");
 141     default: BADBRANCH; return cstring_undefined;
 142     }
 143 }
 144
 145 typedef struct {
 146   flagkind main;
 147   flagkind sub;
 148   bool isSpecial;  /* setting this flag may set other flags (or values) */
 149   bool isIdem;     /* idempotent - always sets to TRUE */
 150   bool isGlobal;   /* cannot be set locally (using control comments) */
 151   bool isModeFlag; /* set by modes */
 152   argcode argtype;
 153   /*@observer@*/ const char *flag;
 154   flagcode code;
 155   /*@observer@*/ /*@null@*/ const char *desc;
 156   /*@observer@*/ /*@null@*/ const char *hint;
 157   int nreported;
 158   int nsuppressed;
 159 } fflag;
 160
 161 typedef fflag flaglist[];
 162
 163 # include "flags.def"
 164
 165 /*@iter allFlags (yield observer fflag f); @*/
 166 # define allFlags(m_f) \
 167   { /*@+enumint@*/ flagcode m_i; for (m_i = 0; m_i < NUMFLAGS; m_i++) { fflag m_f = flags[m_i]; /*@=enumint@*/
 168 # define end_allFlags }}
 169
 170 static /*@observer@*/ /*@null@*/ const char * mode_names[] =
 171 {
 172   "weak", "standard", "checks", "strict", NULL,
 173 };
 174
 175 /*@iter allModes (yield const char* modename)@*/
 176 # define allModes(m_m) \
 177   { int m_ii = 0; while (mstring_isDefined (mode_names[m_ii])) \
 178       { /*@observer@*/ /*@null@*/ const char* m_m = mode_names[m_ii]; m_ii++;
 179
 180 # define end_allModes }}
 181
 182 /*@+enumint@*/
 183
 184 static cstring getFlagModeSettings (flagcode p_flag) /*@modifies internalState@*/ ;
 185 static cstring describeFlagCode (flagcode p_flag) /*@*/ ;
 186 static cstringSList sortedFlags (void) /*@*/ ;
 187 static /*@observer@*/ cstring categoryName (flagkind p_kind) /*@*/ ;
 188
 189 static flagcode flags_identifyFlagAux (cstring p_s, bool p_quiet) /*@modifies g_warningstream@*/ ;
 190
 191 # if 0
 192 static /*@unused@*/ cstring listModes (void) /*@*/ ;
 193 # endif
 194
 195 bool flagcode_isSpecialFlag (flagcode f)
 196 {
 197   return (flags[f].isSpecial);
 198 }
 199
 200 bool flagcode_isGlobalFlag (flagcode f)
 201 {
 202   return (flags[f].isGlobal);
 203 }
 204
 205 bool flagcode_isIdemFlag (flagcode f)
 206 {
 207   return (flags[f].isIdem);
 208 }
 209
 210 bool flagcode_isModeFlag (flagcode f)
 211 {
 212   return (flags[f].isModeFlag);
 213 }
 214
 215 bool flagcode_isNameChecksFlag (flagcode f)
 216 {
 217   return (flags[f].main == FK_NAMES);
 218 }
 219
 220 bool flagcode_isHelpFlag (flagcode f)
 221 {
 222   return f == FLG_HELP;
 223 }
 224
 225 bool flagcode_isMessageControlFlag (flagcode f)
 226 {
 227   /*
 228   ** True if opt controls the display of messages.
 229   ** These flags must be processed first.
 230   */
 231
 232   return (f == FLG_SHOWSCAN
 233           || f == FLG_WARNRC
 234           || f == FLG_PARENFILEFORMAT
 235           || f == FLG_MESSAGESTREAMSTDERR
 236           || f == FLG_MESSAGESTREAMSTDOUT
 237           || f == FLG_WARNINGSTREAMSTDERR
 238           || f == FLG_WARNINGSTREAMSTDOUT
 239           || f == FLG_ERRORSTREAMSTDERR
 240           || f == FLG_ERRORSTREAMSTDOUT
 241           || f == FLG_MESSAGESTREAM
 242           || f == FLG_WARNINGSTREAM
 243           || f == FLG_ERRORSTREAM
 244           || f == FLG_STREAMOVERWRITE);
 245 }
 246
 247 /*
 248 ** Internal consistency check on the flags.
 249 */
 250
 251 void flags_initMod (void)
 252 {
 253   allFlagCodes (code)
 254     {
 255       /*@+enumint@*/
 256       if (flags[code].code != code)
 257         {
 258           fprintf (stderr,
 259                    "*** ERROR: inconsistent flag %s / %d / %d",
 260                    flags[code].flag,
 261                    flags[code].code, code);
 262
 263           llbug (message ("*** ERROR: inconsistent flag %s / %d / %d",
 264                           cstring_fromChars (flags[code].flag),
 265                           flags[code].code, code));
 266         }
 267       /*@=enumint@*/
 268     } end_allFlagCodes;
 269 }
 270
 271 void
 272 summarizeErrors (void)
 273 {
 274   bool hadOne = FALSE;
 275   int sumrep = 0;
 276   int sumsup = 0;
 277
 278   char *buf = mstring_create (128);
 279
 280   allFlags (f)
 281     {
 282       if (f.nreported > 0 || f.nsuppressed > 0)
 283         {
 284           int nrep = f.nreported;
 285           int nsup = f.nsuppressed;
 286           cstring fs = cstring_fill (cstring_fromChars (f.flag), 23);
 287
 288           if (!hadOne)
 289             {
 290               llmsgplain (cstring_makeLiteral
 291                           ("\nError Type                Reported  Suppressed\n"
 292                            "===================       ========  ========="));
 293               hadOne = TRUE;
 294             }
 295
 296           (void) snprintf (buf, 128, "%s%7d   %9d", cstring_toCharsSafe (fs), nrep, nsup);
 297
 298           sumrep += nrep;
 299           sumsup += nsup;
 300
 301           cstring_free (fs);
 302           llmsg (cstring_copy (cstring_fromChars (buf)));
 303         }
 304     } end_allFlags;
 305
 306   if (hadOne)
 307     {
 308       cstring ts = cstring_fill (cstring_makeLiteralTemp ("Total"), 23);
 309
 310       llmsglit ("                          ========  =========");
 311
 312       (void) snprintf (buf, 128, "%s%7d   %9d", cstring_toCharsSafe (ts), sumrep, sumsup);
 313       cstring_free (ts);
 314       llmsgplain (cstring_copy (cstring_fromChars (buf)));
 315     }
 316
 317   sfree (buf);
 318 }
 319
 320 /*@+enumindex@*/
 321
 322 void
 323 flagcode_recordError (flagcode f)
 324 {
 325   if (f != INVALID_FLAG)
 326     {
 327       if (f == FLG_WARNFLAGS)
 328         {
 329           ; /* don't count these */
 330         }
 331       else
 332         {
 333           flags[f].nreported = flags[f].nreported + 1;
 334         }
 335     }
 336   else
 337     {
 338       llcontbug (message ("flagcode_recordError: invalid flag: %d", (int) f));
 339     }
 340 }
 341
 342 void
 343 flagcode_recordSuppressed (flagcode f)
 344 {
 345   llassertprint (f != INVALID_FLAG, ("flagcode: %s", flagcode_unparse (f)));
 346
 347   flags[f].nsuppressed = flags[f].nsuppressed + 1;
 348 }
 349
 350 int
 351 flagcode_numReported (flagcode f)
 352 {
 353   llassert (f != INVALID_FLAG);
 354
 355   return (flags[f].nreported);
 356 }
 357
 358 /*@observer@*/ cstring
 359 flagcodeHint (flagcode f)
 360 {
 361   llassert (f != INVALID_FLAG);
 362
 363   if (mstring_isDefined (flags[f].hint))
 364     {
 365       return (cstring_fromChars (flags[f].hint));
 366     }
 367   else
 368     {
 369       return (cstring_fromChars (flags[f].desc));
 370     }
 371 }
 372
 373 static int categorySize (flagkind kind) /*@*/
 374 {
 375   int n = 0;
 376
 377
 378   allFlags (f)
 379     {
 380       if (f.main == kind || f.sub == kind)
 381         {
 382                   n++;
 383         }
 384     } end_allFlags;
 385
 386   return n;
 387 }
 388
 389 flagkind identifyCategory (cstring s)
 390 {
 391   int i;
 392
 393   for (i = 0; categories[i].kind != FK_NONE; i++)
 394     {
 395       if (mstring_isDefined (categories[i].name))
 396         {
 397           if (cstring_equalLit (s, categories[i].name))
 398             {
 399               return categories[i].kind;
 400             }
 401         }
 402     }
 403
 404   return FK_NONE;
 405 }
 406
 407 static /*@observer@*/ cstring categoryName (flagkind kind)
 408 {
 409   int i;
 410
 411   for (i = 0; categories[i].kind != FK_NONE; i++)
 412     {
 413       if (categories[i].kind == kind)
 414         {
 415           return (cstring_fromChars (categories[i].name));
 416         }
 417     }
 418
 419   return (cstring_makeLiteralTemp ("<No Category>"));
 420 }
 421
 422 static int categoryIndex (flagkind kind)
 423 {
 424   int i;
 425
 426   for (i = 0; categories[i].kind != FK_NONE; i++)
 427     {
 428       if (categories[i].kind == kind)
 429         {
 430           return i;
 431         }
 432     }
 433
 434   return -1;
 435 }
 436
 437 void printCategory (flagkind kind)
 438 {
 439   int index = categoryIndex (kind);
 440
 441   llassert (index >= 0);
 442   llmsg (message ("%s (%d flags)\n\3%s\n\n",
 443                   cstring_fromChars (categories[index].name),
 444                   categorySize (kind),
 445                   cstring_fromChars (categories[index].describe)));
 446
 447   allFlags (f)
 448     {
 449       if (f.main == kind || f.sub == kind)
 450         {
 451           llmsg (message ("   %s\n\6%q", cstring_fromChars (f.flag),
 452                           describeFlagCode (f.code)));
 453         }
 454     } end_allFlags;
 455 }
 456
 457 void
 458 listAllCategories (void)
 459 {
 460   int i;
 461
 462   for (i = 0; categories[i].kind != FK_NONE; i++)
 463     {
 464       flagkind kind = categories[i].kind ;
 465
 466       if (categories[i].describe != NULL)
 467         {
 468           llmsg (message ("%s (%d flags)\n\3%s",
 469                           categoryName (kind),
 470                           categorySize (kind),
 471                           cstring_fromChars (categories[i].describe)));
 472         }
 473     }
 474 }
 475
 476 void
 477 printAllFlags (bool desc, bool full)
 478 {
 479   if (full)
 480     {
 481       cstringSList fl = sortedFlags ();
 482
 483       cstringSList_elements (fl, el)
 484         {
 485           cstring tmp;
 486           tmp = cstring_copy(el);
 487           llmsg (message ("%q\n\n", describeFlag (tmp)));
 488           cstring_free(tmp);
 489         } end_cstringSList_elements ;
 490
 491       cstringSList_free (fl);
 492     }
 493   else
 494     {
 495       allFlags (f)
 496         {
 497           if (f.code != INVALID_FLAG && f.main != FK_OBSOLETE)
 498             {
 499               if (mstring_isDefined (f.desc))
 500                 {
 501                   if (desc)
 502                     {
 503                       llmsg (message ("%s --- %s", cstring_fromChars (f.flag),
 504                                       cstring_fromChars (f.desc)));
 505                     }
 506                 }
 507             }
 508         } end_allFlags;
 509     }
 510 }
 511
 512 void
 513 printFlagManual (bool html)
 514 {
 515   /*
 516   ** Prints all flags by category, in order they appear in flags.def
 517   */
 518
 519   flagkind lastCategory = FK_NONE;
 520
 521   allFlags (f) {
 522     cstring flagname;
 523     cstring flagtype = cstring_undefined;
 524
 525     if (f.main != lastCategory)
 526       {
 527         if (html)
 528           {
 529             llmsg (message ("\n<h4>%s</h4>\n", categoryName (f.main)));
 530           }
 531         else
 532           {
 533             llmsg (message ("\n%s\n%s\n",
 534                             categoryName (f.main),
 535                             cstring_makeLiteralTemp ("===================================")));
 536           }
 537
 538         lastCategory = f.main;
 539       }
 540
 541     if (f.argtype == ARG_NONE || f.argtype == ARG_SPECIAL)
 542       {
 543         if (html)
 544           {
 545             flagname = message ("<tt>%s</tt>", cstring_fromChars (f.flag));
 546           }
 547         else
 548           {
 549             flagname = cstring_fromCharsNew (f.flag);
 550           }
 551       }
 552     else
 553       {
 554         if (flagcode_hasString (f.code))
 555           {
 556             if (html)
 557               {
 558                 flagname = message ("<tt>%s <em>&lt;%s&gt;</em></tt>",
 559                                     cstring_fromChars (f.flag), argcode_unparse (f.argtype));
 560               }
 561             else
 562               {
 563                 flagname = message ("%s <%s>", cstring_fromChars (f.flag), argcode_unparse (f.argtype));
 564               }
 565
 566             if (cstring_isDefined (context_getString (f.code)))
 567               {
 568                 if (html)
 569                   {
 570                     flagname = message ("%q <font color=\"blue\">[%s]</font>", flagname,
 571                                         context_getString (f.code));
 572                   }
 573                 else
 574                   {
 575                     flagname = message ("%q [%s]", flagname,
 576                                         context_getString (f.code));
 577                   }
 578               }
 579           }
 580         else if (f.argtype == ARG_CHAR)
 581           {
 582             if (html)
 583               {
 584                 flagname = message ("<tt>%s <em>&lt;%s&gt;</em></tt> <font color=\"blue\">[%c]</font>",
 585                                     cstring_fromChars (f.flag), argcode_unparse (f.argtype),
 586                                     (char) context_getValue (f.code));
 587               }
 588             else
 589               {
 590                 flagname = message ("%s <%s> [%c]", cstring_fromChars (f.flag), argcode_unparse (f.argtype),
 591                                     (char) context_getValue (f.code));
 592               }
 593           }
 594         else
 595           {
 596             llassert (f.argtype == ARG_NUMBER);
 597
 598             if (html)
 599               {
 600                 flagname = message ("<tt>%s <em>&lt;%s&gt;</em> <font color=\"blue\">[%d]</font>",
 601                                     cstring_fromChars (f.flag), argcode_unparse (f.argtype),
 602                                     context_getValue (f.code));
 603               }
 604             else
 605               {
 606                 flagname = message ("%s <%s> [%d]", cstring_fromChars (f.flag), argcode_unparse (f.argtype),
 607                                     context_getValue (f.code));
 608               }
 609           }
 610       }
 611
 612     if (f.isIdem)
 613       {
 614         if (html)
 615           {
 616             flagtype = message("%q<font color=\"green\">-</font>", flagtype);
 617           }
 618         else
 619           {
 620             flagtype = message("%q<->", flagtype);
 621           }
 622       }
 623
 624     if (f.isGlobal)
 625       {
 626         if (html)
 627           {
 628             flagtype = message ("%q<font color=\"green\"><em>global</em></font>", flagtype);
 629           }
 630         else
 631           {
 632             flagtype = message ("%q<G>", flagtype);
 633           }
 634       }
 635
 636     if (f.isSpecial)
 637       {
 638         if (html)
 639           {
 640             flagtype = message ("%q<font color=\"orange\"><em>shortcut</em></font>", flagtype);
 641           }
 642         else
 643           {
 644             flagtype = message("%q<S>", flagtype);
 645           }
 646       }
 647
 648     if (f.isModeFlag)
 649       {
 650         if (html)
 651           {
 652             flagtype = message ("%q mode:<tt>%q</tt>>", flagtype, getFlagModeSettings (f.code));
 653           }
 654         else
 655           {
 656             flagtype = message ("%q<M:%q>", flagtype, getFlagModeSettings (f.code));
 657           }
 658       }
 659     else /* its a plain flag */
 660       {
 661         if (html)
 662           {
 663             flagtype = message ("%q plain:<tt>%s</tt>", flagtype,
 664                                 cstring_makeLiteralTemp (context_getFlag (f.code) ? "+" : "-"));
 665           }
 666         else
 667           {
 668             flagtype = message ("%q<P:%s>", flagtype,
 669                                 cstring_makeLiteralTemp (context_getFlag (f.code) ? "+" : "-"));
 670           }
 671       }
 672
 673     llmsg (message ("%s: %s", flagname, flagtype));
 674
 675     if (html)
 676       {
 677         llgenindentmsgnoloc (cstring_makeLiteral ("<blockquote>"));
 678       }
 679
 680     if (mstring_isDefined (f.hint))
 681       {
 682         llgenindentmsgnoloc (cstring_fromCharsNew (f.hint));
 683       }
 684     else
 685       {
 686         llgenindentmsgnoloc (message ("%q.", cstring_capitalize (cstring_fromChars (f.desc))));
 687       }
 688
 689     if (html)
 690       {
 691         llgenindentmsgnoloc (cstring_makeLiteral ("</blockquote>"));
 692       }
 693   } end_allFlags ;
 694 }
 695
 696 cstring
 697 describeMode (cstring mode)
 698 {
 699   cstringSList sflags = sortedFlags ();
 700   cstring res = message ("Predefined mode %s sets: ", mode);
 701
 702   llassert (flags_isModeName (mode));
 703
 704   context_setMode (mode);
 705
 706   cstringSList_elements (sflags, flagname)
 707     {
 708       flagcode code = flags_identifyFlag (flagname);
 709       fflag currentflag = flags[code];
 710
 711       if (mstring_isDefined (currentflag.desc) && flagcode_isModeFlag (code))
 712         {
 713           if (context_getFlag (code))
 714             {
 715               res = message ("%q\n   +%s", res, cstring_fromChars (currentflag.flag));
 716             }
 717           else
 718             {
 719               res = message ("%q\n   -%s", res, cstring_fromChars (currentflag.flag));
 720             }
 721         }
 722     } end_cstringSList_elements;
 723
 724   cstringSList_free (sflags);
 725
 726   res = cstring_appendChar (res, '\n');
 727   return (res);
 728 }
 729
 730 cstring
 731 describeFlagCode (flagcode flag)
 732 {
 733   cstring ret = cstring_undefined;
 734   fflag f;
 735
 736   if (flagcode_isInvalid (flag))
 737     {
 738       return (cstring_makeLiteral ("<invalid>"));
 739     }
 740
 741   if (flagcode_isModeName (flag))
 742     {
 743       return (cstring_makeLiteral ("<mode flag>"));
 744     }
 745
 746   context_resetAllFlags ();
 747
 748   f = flags[flag];
 749   ret = cstring_copy (cstring_fromChars (f.desc));
 750
 751   if (f.sub != FK_NONE)
 752     {
 753       ret = message ("%q\nCategories: %s, %s",
 754                      ret,
 755                      categoryName (f.main),
 756                      categoryName (f.sub));
 757     }
 758   else
 759     {
 760       if (f.main != FK_NONE)
 761         {
 762           cstring cname = categoryName (f.main);
 763
 764           if (cstring_isDefined (cname))
 765             {
 766               ret = message ("%q\nCategory: %s",
 767                              ret, cname);
 768             }
 769         }
 770     }
 771
 772   if (f.isModeFlag)
 773     {
 774       ret = message ("%q\nMode Settings: %q",
 775                      ret, getFlagModeSettings (flag));
 776     }
 777   else
 778     {
 779       ret = message ("%q\nDefault Setting: %s",
 780                      ret,
 781                      cstring_makeLiteralTemp (context_getFlag (flag) ? "+" : "-"));
 782     }
 783
 784   if (f.isGlobal)
 785     {
 786       ret = message("%q\nSet globally only", ret);
 787     }
 788   else
 789     {
 790       ret = message("%q\nSet locally", ret);
 791     }
 792
 793   switch (f.argtype)
 794     {
 795     case ARG_NONE:
 796     case ARG_SPECIAL:
 797       break;
 798     case ARG_NUMBER:
 799       ret = message("%q\nNumeric Argument.  Default: %d",
 800                     ret,
 801                     context_getValue (flag));
 802       break;
 803     case ARG_CHAR:
 804       ret = message("%q\nCharacter Argument.  Default: %h",
 805                     ret, (char) context_getValue (flag));
 806       break;
 807     case ARG_STRING:
 808     case ARG_FILE:
 809     case ARG_PATH:
 810     case ARG_DIRECTORY:
 811       {
 812       if (cstring_isDefined (context_getString (flag)))
 813         {
 814           ret = message("%q\n%q argument.  Default: %s",
 815                         ret,
 816                         cstring_capitalize (argcode_unparse (f.argtype)),
 817                         context_getString (flag));
 818         }
 819       else
 820         {
 821           ret = message("%q\n%s argument.  No default.",
 822                         ret,
 823                         cstring_capitalize (argcode_unparse (f.argtype)));
 824         }
 825       break;
 826       }
 827     }
 828
 829   if (mstring_isDefined (f.hint))
 830     {
 831       ret = message("%q\n\3%s", ret, cstring_fromChars (f.hint));
 832     }
 833
 834   return ret;
 835 }
 836
 837 static cstring getFlagModeSettings (flagcode flag)
 838 {
 839   cstring res = cstring_undefined;
 840
 841   allModes (mname)
 842     {
 843       context_setModeNoWarn (cstring_fromChars (mname));
 844
 845       res = message ("%q%s", res, cstring_makeLiteralTemp (context_getFlag (flag) ? "+" : "-"));
 846     } end_allModes;
 847
 848   return res;
 849 }
 850
 851 cstring
 852 describeFlag (cstring flagname)
 853 {
 854   cstring oflagname = cstring_copy (flagname);
 855   flagcode f = flags_identifyFlag (flagname);
 856
 857   if (flagcode_isSkip (f))
 858     {
 859       cstring_free (oflagname);
 860       return cstring_undefined;
 861     }
 862   else if (flagcode_isValid (f))
 863     {
 864       if (cstring_equal (flagname, oflagname))
 865         {
 866           cstring_free (oflagname);
 867           return (message ("%s\n\3%q", flagname, describeFlagCode (f)));
 868         }
 869       else
 870         {
 871           return (message ("%q (standardized name: %s)\n\3%q",
 872                            oflagname, flagname, describeFlagCode (f)));
 873         }
 874     }
 875   else
 876     {
 877       if (flags_isModeName (flagname))
 878         {
 879           cstring_free (oflagname);
 880           return describeMode (flagname);
 881         }
 882       else
 883         {
 884           return (message ("%q: <invalid flag>", oflagname));
 885         }
 886     }
 887 }
 888
 889 static cstringSList
 890 sortedFlags (void)
 891 {
 892   cstringSList s = cstringSList_new ();
 893
 894   allFlags (f)
 895     {
 896       if (f.desc != NULL)
 897         {
 898           s = cstringSList_add (s, cstring_fromChars (f.flag));
 899         }
 900     } end_allFlags;
 901
 902   cstringSList_alphabetize (s);
 903
 904   return s;
 905 }
 906
 907 void printAlphaFlags (void)
 908 {
 909   cstringSList fl = sortedFlags ();
 910
 911   cstringSList_printSpaced (fl, 3, 1, context_getLineLen () - 25);
 912   cstringSList_free (fl);
 913 }
 914
 915 /*@observer@*/ cstring
 916 flagcode_unparse (flagcode code)
 917 {
 918   if (code == INVALID_FLAG)
 919     {
 920       return cstring_makeLiteralTemp ("<invalid flag>");
 921     }
 922
 923   return cstring_fromChars (flags[code].flag);
 924 }
 925
 926 /*
 927 ** Transforms a flag into its cannonical form.
 928 **
 929 ** The following transformations are made:
 930 **
 931 **    function      -> fcn
 932 **    variable      -> var
 933 **    constant      -> const
 934 **    iterator      -> iter
 935 **    parameter     -> param
 936 **    unrecognized  -> unrecog
 937 **    qualifier     -> qual
 938 **    declaration   -> decl
 939 **    globals       -> globs
 940 **    modifies      -> mods
 941 **    modify        -> mod
 942 **    pointer       -> ptr
 943 **    implies       -> imp
 944 **    implicit      -> imp
 945 **    implied       -> imp
 946 **    unconstrained -> uncon
 947 **    unconst       -> uncon
 948 **    memory        -> mem
 949 **    length        -> len
 950 **    return        -> ret
 951 **    system        -> sys
 952 */
 953
 954 static /*@only@*/ cstring
 955 canonicalizeFlag (cstring s)
 956 {
 957   int i = 0;
 958   cstring res = cstring_copy (s);
 959   static /*@observer@*/ /*@null@*/ const char* transform[] =
 960     {
 961       "function", "fcn",
 962       "variable", "var",
 963       "constant", "const",
 964       "iterator", "iter",
 965       "parameter", "param",
 966       "unrecognized", "unrecog",
 967       "qualifier", "qual",
 968       "declaration", "decl",
 969       "globals", "globs",
 970       "modifies", "mods",
 971       "modify", "mod",
 972       "pointer", "ptr",
 973       "implies", "imp",
 974       "implicit", "imp",
 975       "implied", "imp",
 976       "unconstrained", "uncon",
 977       "unconst", "uncon",
 978       "memory", "mem",
 979       "length", "len",
 980       "return", "ret",
 981       "system", "sys",
 982       NULL
 983       } ;
 984   const char *current;
 985
 986   while ((current = transform[i]) != NULL)
 987     {
 988       if (cstring_containsLit (res, current))
 989         {
 990           cstring_replaceLit (res, current, transform[i+1]);
 991         }
 992       i += 2;
 993     }
 994
 995   /* remove whitespace, -'s, and _'s */
 996   cstring_stripChars (res, " -_");
 997   return res;
 998 }
 999
1000 flagcode
1001 flags_identifyFlag (cstring s)
1002 {
1003   return flags_identifyFlagAux (s, FALSE);
1004 }
1005
1006 flagcode
1007 flags_identifyFlagQuiet (cstring s)
1008 {
1009   return flags_identifyFlagAux (s, TRUE);
1010 }
1011
1012 static flagcode
1013 flags_identifyFlagAux (cstring s, bool quiet)
1014 {
1015   cstring cflag;
1016   flagcode res;
1017
1018   if (cstring_length (s) == 0) {
1019     /* evs 2000-06-25: A malformed flag. */
1020     return INVALID_FLAG;
1021   }
1022
1023   if (cstring_firstChar (s) == 'I')
1024     {
1025       return FLG_INCLUDEPATH; /* no space required after -I */
1026     }
1027
1028   if (cstring_firstChar (s) == 'S')
1029     {
1030       return FLG_SPECPATH;    /* no space required after -S */
1031     }
1032
1033   if (cstring_firstChar (s) == 'D')
1034     {
1035       return FLG_DEFINE;      /* no space required after -D */
1036     }
1037
1038   if (cstring_firstChar (s) == 'U')
1039     {
1040       return FLG_UNDEFINE;    /* no space required after -D */
1041     }
1042
1043   cflag = canonicalizeFlag (s);
1044   res = INVALID_FLAG;
1045
1046   allFlags (f)
1047     {
1048       if (cstring_equal (cstring_fromChars (f.flag), cflag))
1049         {
1050           res = f.code;
1051           break;
1052         }
1053     } end_allFlags;
1054
1055   if (res == INVALID_FLAG)
1056     {
1057       /*
1058       ** Synonyms
1059       */
1060
1061       if (cstring_equalLit (cflag, "pred"))
1062         {
1063           res = FLG_PREDBOOL;
1064         }
1065       else if (cstring_equalLit (cflag, "modobserverstrict"))
1066         {
1067           res = FLG_MODOBSERVERUNCON;
1068         }
1069       else if (cstring_equalLit (cflag, "czechnames"))
1070         {
1071           res = FLG_CZECH;
1072         }
1073       else if (cstring_equalLit (cflag, "slovaknames"))
1074         {
1075           res = FLG_SLOVAK;
1076         }
1077       else if (cstring_equalLit (cflag, "czechoslovaknames"))
1078         {
1079           res = FLG_CZECHOSLOVAK;
1080         }
1081       else if (cstring_equalLit (cflag, "globunspec")
1082                || cstring_equalLit (cflag, "globuncon"))
1083         {
1084           res = FLG_GLOBUNSPEC;
1085         }
1086       else if (cstring_equalLit (cflag, "modglobsunspec")
1087                || cstring_equalLit (cflag, "modglobsuncon")
1088                || cstring_equalLit (cflag, "modglobsnomods"))
1089         {
1090           res = FLG_MODGLOBSUNSPEC;
1091         }
1092       else if (cstring_equalLit (cflag, "export"))
1093         {
1094           res = FLG_EXPORTANY;
1095         }
1096       else if (cstring_equalLit (cflag, "macrospec"))
1097         {
1098           res = FLG_MACRODECL;
1099         }
1100       else if (cstring_equalLit (cflag, "ansireservedlocal"))
1101         {
1102           res = FLG_ISORESERVEDLOCAL;
1103         }
1104       else if (cstring_equalLit (cflag, "warnposix"))
1105         {
1106           res = FLG_WARNPOSIX;
1107         }
1108       else if (cstring_equalLit (cflag, "defuse"))
1109         {
1110           res = FLG_USEDEF;
1111         }
1112       else if (cstring_equalLit (cflag, "macroundef"))
1113         {
1114           res = FLG_MACROUNDEF;
1115         }
1116       else if (cstring_equalLit (cflag, "showcol"))
1117         {
1118           res = FLG_SHOWCOL;
1119         }
1120       else if (cstring_equalLit (cflag, "intbool"))
1121         {
1122           res = FLG_BOOLINT;
1123         }
1124       else if (cstring_equalLit (cflag, "intchar"))
1125         {
1126           res = FLG_CHARINT;
1127         }
1128       else if (cstring_equalLit (cflag, "intenum"))
1129         {
1130           res = FLG_ENUMINT;
1131         }
1132       else if (cstring_equalLit (cflag, "intlong"))
1133         {
1134           res = FLG_LONGINT;
1135         }
1136       else if (cstring_equalLit (cflag, "intshort"))
1137         {
1138           res = FLG_SHORTINT;
1139         }
1140       /*
1141       ** Backwards compatibility for our American friends...
1142       */
1143
1144       else if (cstring_equalLit (cflag, "ansilib"))
1145         {
1146           res = FLG_ANSILIB;
1147         }
1148       else if (cstring_equalLit (cflag, "ansistrictlib"))
1149         {
1150           res = FLG_STRICTLIB;
1151         }
1152       else if (cstring_equalLit (cflag, "skipansiheaders"))
1153         {
1154           res = FLG_SKIPISOHEADERS;
1155         }
1156       else if (cstring_equalLit (cflag, "ansireserved"))
1157         {
1158           res = FLG_ISORESERVED;
1159         }
1160       else if (cstring_equalLit (cflag, "ansireservedinternal"))
1161         {
1162           res = FLG_ISORESERVEDLOCAL;
1163         }
1164
1165       /*
1166       ** Obsolete Flags
1167       */
1168
1169       else if (cstring_equalLit (cflag, "accessunspec"))
1170         {
1171           if (!quiet)
1172             {
1173               llerror_flagWarning
1174                 (cstring_makeLiteral
1175                  ("accessunspec flag is no longer supported.  It has been replaced by accessmodule, accessfile and "
1176                   "accessfunction to provide more precise control of accessibility "
1177                   "of representations.  For more information, "
1178                   "see splint -help accessmodule"));
1179             }
1180
1181           res = SKIP_FLAG;
1182         }
1183       else if (cstring_equalLit (cflag, "ansilimits"))
1184         {
1185           llerror_flagWarning
1186             (cstring_makeLiteral
1187              ("ansilimits flag is no longer supported.  It has been replaced by ansi89limits and "
1188               "iso99limits to select either the lower translation limits imposed by the ANSI89 "
1189               "standard or the typically higher limits prescribed by ISO C99."));
1190
1191           res = SKIP_FLAG;
1192         }
1193       else if (cstring_equalLit (cflag, "staticmods"))
1194         {
1195           if (!quiet)
1196             {
1197               llerror_flagWarning
1198                 (cstring_makeLiteral
1199                  ("staticmods flag is obsolete.  You probably "
1200                   "want impcheckmodstatics.  For more information, "
1201                   "see splint -help impcheckmodstatics"));
1202             }
1203
1204           res = SKIP_FLAG;
1205         }
1206       else if (cstring_equalLit (cflag, "bool"))
1207         {
1208           if (!quiet)
1209             {
1210               llerror_flagWarning
1211                 (cstring_makeLiteral ("bool flag is obsolete.  It never really "
1212                                       "made sense in the first place."));
1213             }
1214
1215           res = SKIP_FLAG;
1216         }
1217       else if (cstring_equalLit (cflag, "shiftsigned"))
1218         {
1219           if (!quiet)
1220             {
1221               llerror_flagWarning
1222                 (cstring_makeLiteral ("shiftsigned flag is obsolete.  You probably "
1223                                       "want bitwisesigned, shiftnegative or shiftimplementation."));
1224             }
1225
1226           res = SKIP_FLAG;
1227         }
1228       else if (cstring_equalLit (cflag, "ansi"))
1229         {
1230           if (!quiet)
1231             {
1232               llerror_flagWarning
1233                 (cstring_makeLiteral ("ansi flag is obsolete.  You probably "
1234                                       "want noparams and/or oldstyle."));
1235             }
1236
1237           res = SKIP_FLAG;
1238         }
1239       else if (cstring_equalLit (cflag, "usestderr"))
1240         {
1241           if (!quiet)
1242             {
1243               llerror_flagWarning
1244                 (cstring_makeLiteral
1245                  ("usestderr flag is obsolete. This has been replaced "
1246                   "by more precise flags for controlling the warning, "
1247                   "status message and fatal error streams independently: message-stream-stdout, "
1248                   "message-stream-stderr, message-stream <file>, "
1249                   "warning-stream-stdout, warning-stream-stderr, warning-stream <file>, "
1250                   "error-stream-stdout, error-stream-stderr, error-stream <file>."));
1251             }
1252
1253           res = SKIP_FLAG;
1254         }
1255
1256       else if (cstring_equalLit (cflag, "stdio"))
1257         {
1258           if (!quiet)
1259             {
1260               llerror_flagWarning
1261                 (cstring_makeLiteral
1262                  ("stdio flag is obsolete.  You may "
1263                   "want strictlib or one of the gloabls "
1264                   "checking flags.  For more information, "
1265                   "see splint -help strictlib or splint -help flags globals"));
1266             }
1267
1268           res = SKIP_FLAG;
1269         }
1270       else if (flags_isModeName (cflag))
1271         {
1272           res = MODENAME_FLAG;
1273         }
1274       else
1275         {
1276           res = INVALID_FLAG;
1277         }
1278     }
1279
1280   cstring_free (cflag);
1281   return res;
1282 }
1283
1284 void flags_setValueFlag (flagcode opt, cstring arg)
1285 {
1286   switch (opt)
1287     {
1288     case FLG_EXPECT:
1289     case FLG_LCLEXPECT:
1290     case FLG_LIMIT:
1291     case FLG_LINELEN:
1292     case FLG_INDENTSPACES:
1293     case FLG_LOCINDENTSPACES:
1294     case FLG_BUGSLIMIT:
1295     case FLG_EXTERNALNAMELEN:
1296     case FLG_INTERNALNAMELEN:
1297     case FLG_CONTROLNESTDEPTH:
1298     case FLG_STRINGLITERALLEN:
1299     case FLG_NUMSTRUCTFIELDS:
1300     case FLG_NUMENUMMEMBERS:
1301     case FLG_INCLUDENEST:
1302       {
1303         int val = cstring_toPosInt (arg);
1304
1305         if (val < 0)
1306           {
1307             llerror
1308               (FLG_BADFLAG,
1309                message
1310                ("Flag %s must be followed by a positive number number.  "
1311                 "Followed by %s",
1312                 flagcode_unparse (opt), arg));
1313           }
1314         else
1315           {
1316             context_setValueAndFlag (opt, val);
1317           }
1318       }
1319       break;
1320     case FLG_COMMENTCHAR:
1321       {
1322         if (cstring_length (arg) != 1)
1323           {
1324             llfatalerrorLoc
1325               (message
1326                ("Flag %s should be followed by a single character.  Followed by %s",
1327                 flagcode_unparse (opt), arg));
1328           }
1329         else
1330           {
1331             context_setCommentMarkerChar (cstring_firstChar (arg));
1332           }
1333       }
1334       break;
1335       BADDEFAULT;
1336     }
1337 }
1338
1339 void flags_setStringFlag (flagcode opt, /*@only@*/ cstring arg)
1340 {
1341   switch (opt)
1342     {
1343     case FLG_TMPDIR:
1344       {
1345         if (cstring_lastChar (arg) == CONNECTCHAR)
1346           {
1347             context_setString (opt, arg);
1348           }
1349         else
1350           {
1351             context_setString (opt, cstring_appendChar (arg, CONNECTCHAR));
1352           }
1353         break;
1354       }
1355     default:
1356       {
1357         context_setString (opt, arg);
1358         break;
1359       }
1360     }
1361 }
1362
1363 cstring
1364 describeModes (void)
1365 {
1366   cstring s = cstring_makeLiteral ("Flag                    ");
1367   cstringSList sflags = sortedFlags ();
1368
1369   allModes (modename)
1370     {
1371       s = message ("%q%9s", s, cstring_fromChars (modename));
1372     } end_allModes;
1373
1374   s = message ("%q\n", s);
1375
1376   cstringSList_elements (sflags, flagname)
1377     {
1378       flagcode code = flags_identifyFlag (flagname);
1379       fflag currentflag = flags[code];
1380
1381       if (mstring_isDefined (currentflag.desc) && flagcode_isModeFlag (code))
1382         {
1383           s = message ("%q\n%27s", s,
1384                        cstring_fromChars (currentflag.flag));
1385
1386           allModes (modename)
1387             {
1388               context_setMode (cstring_fromChars (modename));
1389
1390               if (context_getFlag (code))
1391                 {
1392                   s = message ("%q%9s", s, cstring_makeLiteralTemp ("+"));
1393                 }
1394               else
1395                 {
1396                   s = message ("%q%9s", s, cstring_makeLiteralTemp (" "));
1397                 }
1398
1399               context_resetModeFlags ();
1400             } end_allModes;
1401         }
1402     } end_cstringSList_elements;
1403
1404   cstringSList_free (sflags);
1405
1406   s = cstring_appendChar (s, '\n');
1407
1408   return (s);
1409 }
1410
1411 # if 0
1412 static /*@unused@*/ cstring
1413 listModes (void)
1414 {
1415   cstring s = cstring_makeLiteral ("\t");
1416   int i = 0;
1417
1418   allModes (modename)
1419     {
1420       if (i != 0 && (i % 4 == 0))
1421         {
1422           s = message ("%q\n\t%15s", s, cstring_fromChars (modename));
1423         }
1424       else
1425         {
1426           s = message ("%q%15s", s, cstring_fromChars (modename));
1427         }
1428       i++;
1429     } end_allModes;
1430
1431   return s;
1432 }
1433 # endif
1434
1435 bool
1436 flags_isModeName (cstring s)
1437 {
1438   allModes (modename)
1439     {
1440       if (mstring_isDefined (modename))
1441         {
1442           if (cstring_equalLit (s, modename))
1443             {
1444               return TRUE;
1445             }
1446         }
1447      } end_allModes;
1448
1449   return FALSE;
1450 }
1451
1452 extern bool flagcode_hasArgument (flagcode f)
1453 {
1454   return (flags[f].argtype != ARG_NONE);
1455 }
1456
1457 extern bool flagcode_hasNumber (flagcode f)
1458 {
1459   return (flags[f].argtype == ARG_NUMBER);
1460 }
1461
1462 extern bool flagcode_hasChar (flagcode f)
1463 {
1464   return (flags[f].argtype == ARG_CHAR);
1465 }
1466
1467 extern bool flagcode_hasString (flagcode f)
1468 {
1469   return (flags[f].argtype == ARG_STRING
1470           || flags[f].argtype == ARG_FILE
1471           || flags[f].argtype == ARG_DIRECTORY
1472           || flags[f].argtype == ARG_PATH);
1473 }
1474
1475 extern int flagcode_valueIndex (flagcode f)
1476 {
1477   /*@unchecked@*/ static bool initialized = FALSE;
1478   int i;
1479   /*@unchecked@*/ static flagcode valueFlags[NUMVALUEFLAGS];
1480
1481   if (!initialized)
1482     {
1483       int nv = 0;
1484
1485       allFlagCodes (code)
1486         {
1487           if (flagcode_hasNumber (code) || flagcode_hasChar (code))
1488             {
1489               llassert (nv < NUMVALUEFLAGS);
1490               DPRINTF (("Value flag: %s [%d]", flagcode_unparse (code), (int) code));
1491               valueFlags[nv] = code;
1492               nv++;
1493             }
1494         } end_allFlagCodes;
1495
1496       llassertprint (nv == NUMVALUEFLAGS,
1497                      ("Number of value flags: %d (expected %d)",
1498                       nv, (int) NUMVALUEFLAGS));
1499       initialized = TRUE;
1500     }
1501
1502   for (i = 0; i < NUMVALUEFLAGS; i++)
1503     {
1504       /* static valueFlags must be defined */
1505       /*@-usedef@*/
1506       if (f == valueFlags[i]) /*@=usedef@*/
1507         {
1508           return i;
1509         }
1510     }
1511
1512   fprintf (stderr, "Cannot find value flag: %d", (int) f);
1513   exit (EXIT_FAILURE);
1514   /* Cannot do this...might call recursively...
1515   llfatalbug (message ("Cannot fine value flag: %d", (int) f));
1516   BADEXIT;
1517   */
1518 }
1519
1520 extern int flagcode_stringIndex (flagcode f)
1521 {
1522   /*@unchecked@*/ static bool initialized = FALSE;
1523   /*@unchecked@*/ static flagcode stringFlags[NUMSTRINGFLAGS];
1524   int i;
1525
1526
1527   if (!initialized)
1528     {
1529       int nv = 0;
1530
1531       allFlagCodes (code)
1532         {
1533           if (flagcode_hasString (code))
1534             {
1535               llassertprint (nv < NUMSTRINGFLAGS, ("Incorrect number of string flags: %d (need at least %d)", NUMSTRINGFLAGS, nv));
1536               stringFlags[nv] = code;
1537               nv++;
1538             }
1539         } end_allFlagCodes;
1540
1541       llassertprint (nv == NUMSTRINGFLAGS,
1542                      ("number of string flags: %d (expected %d)",
1543                       nv, NUMSTRINGFLAGS));
1544       initialized = TRUE;
1545     }
1546
1547   for (i = 0; i < NUMSTRINGFLAGS; i++)
1548     {
1549       /*@-usedef@*/ if (f == stringFlags[i]) /*@=usedef@*/
1550         {
1551           return i;
1552         }
1553     }
1554
1555   llbug (message ("Bad string flag: %s", flagcode_unparse (f)));
1556   BADEXIT;
1557 }
1558
1559 bool flagcode_isNamePrefixFlag (flagcode f)
1560 {
1561   switch (f)
1562     {
1563     case FLG_MACROVARPREFIX:
1564     case FLG_TAGPREFIX:
1565     case FLG_ENUMPREFIX:
1566     case FLG_FILESTATICPREFIX:
1567     case FLG_GLOBPREFIX:
1568     case FLG_TYPEPREFIX:
1569     case FLG_EXTERNALPREFIX:
1570     case FLG_LOCALPREFIX:
1571     case FLG_UNCHECKEDMACROPREFIX:
1572     case FLG_CONSTPREFIX:
1573     case FLG_ITERPREFIX:
1574     case FLG_DECLPARAMPREFIX:
1575       return TRUE;
1576     default:
1577       return FALSE;
1578     }
1579 }
1580
1581 static cstring findLarchPathFile (/*@temp@*/ cstring s)
1582 {
1583   cstring pathName;
1584   filestatus status;
1585
1586   status = osd_getPath (context_getLarchPath (), s, &pathName);
1587
1588   if (status == OSD_FILEFOUND)
1589     {
1590       return pathName;
1591     }
1592   else if (status == OSD_FILENOTFOUND)
1593     {
1594       showHerald ();
1595       lldiagmsg (message ("Cannot find file on LARCH_PATH: %s", s));
1596     }
1597   else if (status == OSD_PATHTOOLONG)
1598     {
1599       /* Directory and filename are too long.  Report error. */
1600       llbuglit ("soure_getPath: Filename plus directory from search path too long");
1601     }
1602   else
1603     {
1604       BADBRANCH;
1605     }
1606
1607   return cstring_undefined;
1608 }
1609
1610 static void addFile (fileIdList files, /*@temp@*/ cstring pathName, fileType typ)
1611 {
1612   if (fileTable_exists (context_fileTable (), pathName))
1613     {
1614       showHerald ();
1615       lldiagmsg (message ("File listed multiple times: %s", pathName));
1616     }
1617   else
1618     {
1619       fileIdList_add (files, fileTable_addFile (context_fileTable (), typ, pathName));
1620     }
1621 }
1622
1623 static bool
1624 strIsQuoteOpen (const char * arg)
1625 {
1626   register const char * s;
1627   bool escape, quoted;
1628
1629   llassert (arg != NULL);
1630
1631   s = arg;
1632   escape = FALSE;
1633   quoted = FALSE;
1634   while (*s != '\0')
1635   {
1636     if (!escape)
1637       {
1638         if (*s == '\\')
1639           {
1640             escape = TRUE;
1641           }
1642         else if (*s == '\"')
1643           {
1644             quoted = !quoted;
1645           }
1646       }
1647     else
1648       {
1649         escape = FALSE;
1650       }
1651     ++s;
1652   }
1653
1654   return quoted;
1655 }
1656
1657 void
1658 flags_processFlags (bool inCommandLine,
1659                     fileIdList cfiles,
1660                     fileIdList lclfiles,
1661                     fileIdList mtfiles,
1662                     cstringList *cppArgs,
1663                     int argc, char **argv)
1664 {
1665   int i;
1666   cstringSList fl = cstringSList_undefined;
1667
1668   for (i = 0; i < argc; i++)
1669     {
1670       char *thisarg;
1671
1672       llassert (argv != NULL);
1673       thisarg = argv[i];
1674
1675       DPRINTF (("process thisarg [%d]: %s", i, thisarg));
1676
1677       if (*thisarg == '-' || *thisarg == '+')
1678         {
1679           bool set = (*thisarg == '+');
1680           cstring flagname;
1681           flagcode opt;
1682
1683           if (*thisarg == '-' && *(thisarg + 1) == '-') { /* allow -- before flags */
1684             flagname = cstring_fromChars (thisarg + 2);
1685           } else {
1686             flagname = cstring_fromChars (thisarg + 1);
1687           }
1688
1689           opt = flags_identifyFlag (flagname);
1690           DPRINTF (("Flag [%s]: %s", flagname, flagcode_unparse (opt)));
1691
1692           if (flagcode_isInvalid (opt))
1693             {
1694               DPRINTF (("Error!"));
1695               voptgenerror (FLG_BADFLAG,
1696                             message ("Unrecognized option: %s",
1697                                      cstring_fromChars (thisarg)),
1698                             g_currentloc);
1699             }
1700           else if (flagcode_isHelpFlag (opt))
1701             {
1702               if (inCommandLine)
1703                 {
1704                   voptgenerror (FLG_BADFLAG,
1705                                 message ("Help flag must be first on the command line: %s",
1706                                          cstring_fromChars (thisarg)),
1707                                 g_currentloc);
1708                 }
1709               else
1710                 {
1711                   voptgenerror (FLG_BADFLAG,
1712                                 message ("Help flags can only be used on the command line: %s",
1713                                          cstring_fromChars (thisarg)),
1714                                 g_currentloc);
1715                 }
1716             }
1717           else if (flagcode_isCpp (opt)) /* preprocessor flag: -D, -U or -I */
1718             {
1719               if (*thisarg == '+') /* reject +D, +U or +I */
1720                 {
1721                   voptgenerror
1722                     (FLG_BADFLAG,
1723                      message
1724                      ("Unrecognized option +%c (did you meant -%c?)", *flagname, *flagname),
1725                      g_currentloc);
1726                 }
1727               else if (*(thisarg+1) == '-') /* reject --D, --U or --I */
1728                 {
1729                   voptgenerror
1730                     (FLG_BADFLAG,
1731                      message
1732                      ("Unrecognized option --%c (did you meant -%c?)", *flagname, *flagname),
1733                      g_currentloc);
1734                 }
1735               else if (*(thisarg + 2) == '\0' && flagcode_isCppMacro (opt))
1736                 {
1737                   voptgenerror
1738                     (FLG_BADFLAG,
1739                      message
1740                      ("Flag -%c requires a preprocessor macro merged with it (no separate arguments)", *flagname),
1741                      g_currentloc);
1742                 }
1743               else if (*(thisarg + 2) == '\0' && i+1 >= argc) /* -I allows spaces between itself and argument */
1744                 {
1745                   llassert (opt == FLG_INCLUDEPATH);
1746                   voptgenerror
1747                     (FLG_BADFLAG,
1748                      message ("Flag -I must be followed by a directory name"),
1749                      g_currentloc);
1750                 }
1751               else
1752                 {
1753                   const char *quotcheck;
1754                   if (*(thisarg + 2) != '\0') /* argument is merged with flag */
1755                     {
1756                       quotcheck = thisarg;
1757                     }
1758                   else
1759                     {
1760                       ++i;
1761                       llassert (opt == FLG_INCLUDEPATH && *(thisarg + 2) == '\0' && i < argc);
1762                       quotcheck = argv[i];
1763                     }
1764
1765                   if (strIsQuoteOpen (quotcheck))
1766                     {
1767                       voptgenerror (FLG_BADFLAG,
1768                           message ("Unclosed quote in flag: %s", quotcheck),
1769                           g_currentloc);
1770                     }
1771                   else
1772                     {
1773                       cstring newCppArg = cstring_undefined;
1774
1775                       if (*(thisarg + 2) != '\0') /* argument is merged with flag */
1776                         {
1777                           newCppArg = cstring_fromCharsNew (thisarg + 1);
1778                         }
1779                       else /* use next argument */
1780                         {
1781                           newCppArg = cstring_prependChar ('I', cstring_fromChars (argv[i]));
1782                         }
1783
1784                       *cppArgs = cstringList_add (*cppArgs, newCppArg);
1785                     }
1786                 }
1787             }
1788           else if (opt == FLG_SPECPATH)
1789             {
1790               char* dir = thisarg + 2; /* skip over -S */
1791
1792               if (*dir == '\0') {
1793                 DPRINTF (("space after directory: "));
1794                 if (++i < argc) {
1795                   DPRINTF (("use next argument, argv[%d] : %s", i, argv[i]));
1796                   dir = argv[i];
1797                 } else {
1798                   voptgenerror
1799                     (FLG_BADFLAG,
1800                      message
1801                      ("Flag %s must be followed by a directory name",
1802                       flagcode_unparse (opt)),
1803                      g_currentloc);
1804                   /* TODO: do we really want to add an empty path? */
1805                 }
1806               }
1807               DPRINTF (("Got directory: [%s]", dir));
1808
1809               /*@-mustfree@*/
1810               /* TODO: why aren't we freeing the intermediary g_localSpecPath? */
1811               g_localSpecPath = cstring_toCharsSafe
1812                   (osd_pathListConcat (g_localSpecPath, dir));
1813               /*@=mustfree@*/
1814             }
1815           else if (flagcode_isModeName (opt))
1816             {
1817               context_setMode (flagname);
1818             }
1819           else if (inCommandLine && flagcode_isMessageControlFlag (opt))
1820             {
1821               /*
1822               ** Processed on first pass
1823               */
1824
1825               if (flagcode_hasArgument (opt))
1826                 {
1827                   ++i;
1828                 }
1829             }
1830           else
1831             {
1832               /*
1833               ** A normal control flag
1834               */
1835
1836               context_userSetFlag (opt, set);
1837
1838               if (flagcode_hasArgument (opt))
1839                 {
1840                   if (flagcode_hasNumber (opt))
1841                     {
1842                       if (++i < argc)
1843                         {
1844                           flags_setValueFlag (opt, cstring_fromCharsNew (argv[i]));
1845                         }
1846                       else
1847                         {
1848                           voptgenerror
1849                             (FLG_BADFLAG,
1850                              message
1851                              ("Flag %s must be followed by a number",
1852                               flagcode_unparse (opt)),
1853                              g_currentloc);
1854                         }
1855                     }
1856                   else if (flagcode_hasChar (opt))
1857                     {
1858                       if (++i < argc)
1859                         {
1860                           flags_setValueFlag (opt, cstring_fromCharsNew (argv[i]));
1861                         }
1862                       else
1863                         {
1864                           voptgenerror
1865                             (FLG_BADFLAG,
1866                              message
1867                              ("Flag %s must be followed by a character",
1868                               flagcode_unparse (opt)),
1869                              g_currentloc);
1870                         }
1871                     }
1872                   else if (flagcode_hasString (opt)
1873                            || opt == FLG_INIT || opt == FLG_OPTF)
1874                     {
1875                       if (++i < argc)
1876                         {
1877                           /*drl 10/21/2002
1878                             Changed this because arg can be freed when it's passed to
1879                             lslinit_setInitFile and freeing argv[i] causes a seg fault
1880                           */
1881                           cstring arg =  cstring_fromCharsNew (argv[i]);
1882
1883                           /* FIXME: memory leak; for opt == FLG_INIT,
1884                            * inputStream_create() will take ownership of arg;
1885                            * for the rest, the code above just introduced a leak. */
1886
1887                           if (opt == FLG_OPTF)
1888                             {
1889                               if (inCommandLine)
1890                                 {
1891                                   ; /* -f already processed */
1892                                 }
1893                               else
1894                                 {
1895                                   (void) rcfiles_read (arg, cppArgs, TRUE);
1896                                 }
1897                             }
1898                           else if (opt == FLG_INIT)
1899                             {
1900                               lslinit_setInitFile (inputStream_create
1901                                                    (arg,
1902                                                     cstring_makeLiteralTemp (LCLINIT_SUFFIX),
1903                                                     FALSE));
1904                               break;
1905                             }
1906                           else
1907                             {
1908                               DPRINTF (("String flag: %s / %s",
1909                                         flagcode_unparse (opt), arg));
1910                               if (opt == FLG_MTSFILE)
1911                                 {
1912                                   /*
1913                                   ** arg identifies mts files
1914                                   */
1915                                   cstring tmp;
1916                                   cstring pathName;
1917
1918                                   tmp =  cstring_concat (arg, MTS_EXTENSION);
1919                                   pathName = findLarchPathFile (tmp);
1920                                   cstring_free (tmp);
1921                                   if (cstring_isDefined (pathName))
1922                                     addFile (mtfiles, pathName, FILE_METASTATE);
1923                                   cstring_free (pathName);
1924
1925                                   tmp = cstring_concat (arg, XH_EXTENSION);
1926                                   pathName = findLarchPathFile (tmp);
1927                                   cstring_free (tmp);
1928                                   if (cstring_isDefined (pathName))
1929                                     addFile (cfiles, pathName, FILE_XH);
1930                                   cstring_free (pathName);
1931                                 }
1932                               else
1933                                 {
1934                                   flags_setStringFlag (opt, cstring_copy (arg));
1935                                 }
1936                             }
1937                         }
1938                       else
1939                         {
1940                           voptgenerror
1941                             (FLG_BADFLAG,
1942                              message
1943                              ("Flag %s must be followed by a string",
1944                               flagcode_unparse (opt)),
1945                              g_currentloc);
1946                         }
1947                     }
1948                   else
1949                     {
1950                       /* no argument */
1951                     }
1952                 }
1953             }
1954         }
1955       else /* its a filename */
1956         {
1957           DPRINTF (("Adding filename: %s", thisarg));
1958           fl = cstringSList_add (fl, cstring_fromChars (thisarg));
1959         }
1960     }
1961
1962   /*
1963   ** create lists of C and LCL files
1964   */
1965
1966   if (inCommandLine)
1967     {
1968       cstringSList_elements (fl, current)
1969         {
1970           cstring ext = fileLib_getExtension (current);
1971
1972           if (cstring_isUndefined (ext))
1973             {
1974               /* no extension --- both C and LCL with default extensions */
1975               cstring pathName;
1976
1977               pathName = cstring_concat (current, C_EXTENSION);
1978               addFile (cfiles, pathName, FILE_NORMAL);
1979               cstring_free (pathName);
1980
1981               pathName = cstring_concat (current, LCL_EXTENSION);
1982               addFile (lclfiles, pathName, FILE_LCL);
1983               cstring_free (pathName);
1984             }
1985           else if (cstring_equal (ext, PP_EXTENSION))
1986             {
1987               if (!context_getFlag (FLG_NOPP))
1988                 {
1989                   voptgenerror
1990                     (FLG_FILEEXTENSIONS,
1991                      message ("File extension %s used without +nopp flag (will be processed as C source code): %s",
1992                               ext, current),
1993                      g_currentloc);
1994
1995                   addFile (cfiles, current, FILE_NORMAL);
1996                 }
1997               else
1998                 {
1999                   addFile (cfiles, current, FILE_PP);
2000                 }
2001             }
2002           else if (cstring_equal (ext, LCL_EXTENSION))
2003             {
2004               addFile (lclfiles, current, FILE_LCL);
2005             }
2006           else if (cstring_equal (ext, MTS_EXTENSION))
2007             {
2008               cstring pathName;
2009               pathName = findLarchPathFile (current);
2010               if (cstring_isDefined (pathName))
2011                 addFile (mtfiles, pathName, FILE_METASTATE);
2012               cstring_free (pathName);
2013             }
2014           /* fileLib_isCExtension(XH_EXTENSION) is true */
2015           else if (cstring_equal (ext, XH_EXTENSION))
2016             {
2017               cstring pathName;
2018               pathName = findLarchPathFile (current);
2019               if (cstring_isDefined (pathName))
2020                 addFile (cfiles, pathName, FILE_XH);
2021               cstring_free (pathName);
2022             }
2023           else if (fileLib_isCExtension (ext))
2024             {
2025               addFile (cfiles, current, FILE_NORMAL);
2026             }
2027           else
2028             {
2029               voptgenerror
2030                 (FLG_FILEEXTENSIONS,
2031                  message ("Unrecognized file extension: %s (assuming %s is C source code)",
2032                           current, ext),
2033                  g_currentloc);
2034
2035               addFile (cfiles, current, FILE_NORMAL);
2036             }
2037         } end_cstringSList_elements;
2038     }
2039   else
2040     {
2041       if (cstringSList_size (fl) != 0)
2042         {
2043           /* Cannot list files in .splintrc files */
2044           voptgenerror (FLG_BADFLAG,
2045                         message ("Cannot list files in .splintrc files: %s (probable missing + or -)",
2046                                  cstringSList_unparse (fl)),
2047                         g_currentloc);
2048         }
2049     }
2050
2051   cstringSList_free (fl); /* evans 2002-07-12: why wasn't this reported!?? */
2052 }
2053
2054 int flagcode_priority (/*@unused@*/ flagcode code)
2055 {
2056   /*
2057   ** For now, we do a really simple prioritization: all are 1
2058   */
2059
2060   return 1;
2061 }