src/cscannerHelp.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 ** cscannerHelp.c - procedures for scanning C
  26 **
  27 ** Most of this code was in cscanner.l, but moved here to separate it
  28 ** from the flex-generated code.
  29 */
  30
  31 # include "splintMacros.nf"
  32 # include "basic.h"
  33 # include "cscannerHelp.h"
  34 # include "cscanner.h"
  35 # include "cgrammar.h"
  36 # include "osd.h"
  37
  38 static int lminput (void);
  39 static int s_tokLength = 0;
  40
  41 static /*@owned@*/ cstring s_lastidprocessed = cstring_undefined;
  42 static bool s_inSpecPart = FALSE;
  43 static int s_whichSpecPart;
  44 static char s_savechar = '\0';
  45 static bool s_expectingMetaStateName = FALSE;
  46 static bool s_expectingTypeName = TRUE;
  47
  48 struct skeyword
  49 {
  50   /*@null@*/ /*@observer@*/ char *name;
  51   int token;
  52 } ;
  53
  54 /*
  55 ** These tokens are followed by syntax that is parsed by the
  56 ** grammar proper.
  57 */
  58
  59 static struct skeyword s_parsetable[] = {
  60   { "modifies", QMODIFIES } ,
  61   { "globals", QGLOBALS } ,
  62   { "alt", QALT } ,
  63   { "warn", QWARN } ,
  64   { "constant", QCONSTANT } ,
  65   { "function", QFUNCTION } ,
  66   { "iter", QITER } ,
  67   { "defines", QDEFINES } ,
  68   { "uses", QUSES } ,
  69   { "allocates", QALLOCATES } ,
  70   { "sets", QSETS } ,
  71   { "releases", QRELEASES } ,
  72   { "pre", QPRECLAUSE } ,
  73   { "post", QPOSTCLAUSE } ,
  74   { "setBufferSize", QSETBUFFERSIZE},
  75   { "setStringLength", QSETSTRINGLENGTH},
  76   { "testinRange", QTESTINRANGE},
  77   { "requires", QPRECLAUSE } ,
  78   { "ensures", QPOSTCLAUSE } ,
  79   { "invariant", QINVARIANT} ,
  80   { NULL, BADTOK }
  81 } ;
  82
  83 /*
  84 ** These tokens are either stand-alone tokens, or followed by
  85 ** token-specific text.
  86 */
  87
  88 static struct skeyword s_keytable[] = {
  89   { "anytype", QANYTYPE } ,
  90   { "integraltype", QINTEGRALTYPE } ,
  91   { "unsignedintegraltype", QUNSIGNEDINTEGRALTYPE } ,
  92   { "signedintegraltype", QSIGNEDINTEGRALTYPE } ,
  93   { "out", QOUT } ,
  94   { "in", QIN } ,
  95   { "only", QONLY } ,
  96   { "owned", QOWNED } ,
  97   { "dependent", QDEPENDENT } ,
  98   { "partial", QPARTIAL } ,
  99   { "special", QSPECIAL } ,
 100   { "truenull", QTRUENULL } ,
 101   { "falsenull", QFALSENULL } ,
 102   { "nullwhentrue", QTRUENULL } ,
 103   { "falsewhennull", QFALSENULL } ,
 104   { "keep", QKEEP } ,
 105   { "kept", QKEPT } ,
 106   { "notnull", QNOTNULL } ,
 107   { "abstract", QABSTRACT } ,
 108   { "numabstract", QNUMABSTRACT } ,
 109   { "concrete", QCONCRETE } ,
 110   { "mutable", QMUTABLE } ,
 111   { "immutable", QIMMUTABLE } ,
 112   { "unused", QUNUSED } ,
 113   { "external", QEXTERNAL } ,
 114   { "sef", QSEF } ,
 115   { "unique", QUNIQUE } ,
 116   { "returned", QRETURNED } ,
 117   { "exposed", QEXPOSED } ,
 118   { "refcounted", QREFCOUNTED } ,
 119   { "refs", QREFS } ,
 120   { "newref", QNEWREF } ,
 121   { "tempref", QTEMPREF } ,
 122   { "killref", QKILLREF } ,
 123   { "null", QNULL } ,
 124   { "relnull", QRELNULL } ,
 125   { "nullterminated", QNULLTERMINATED },
 126   { "setBufferSize", QSETBUFFERSIZE },
 127   { "testInRange", QTESTINRANGE},
 128   { "isnull", QISNULL },
 129   { "MaxSet", QMAXSET},
 130   { "MaxRead", QMAXREAD},
 131   { "maxSet", QMAXSET},
 132   { "maxRead", QMAXREAD},
 133   { "reldef", QRELDEF } ,
 134   { "observer", QOBSERVER } ,
 135   { "exits", QEXITS } ,
 136   { "noreturn", QEXITS } ,
 137   { "mayexit", QMAYEXIT } ,
 138   { "maynotreturn", QMAYEXIT } ,
 139   { "trueexit", QTRUEEXIT } ,
 140   { "falseexit", QFALSEEXIT } ,
 141   { "noreturnwhentrue", QTRUEEXIT } ,
 142   { "noreturnwhenfalse", QFALSEEXIT } ,
 143   { "neverexit", QNEVEREXIT } ,
 144   { "alwaysreturns", QNEVEREXIT } ,
 145   { "temp", QTEMP } ,
 146   { "shared", QSHARED } ,
 147   { "ref", QREF } ,
 148   { "unchecked", QUNCHECKED } ,
 149   { "checked", QCHECKED } ,
 150   { "checkmod", QCHECKMOD } ,
 151   { "checkedstrict", QCHECKEDSTRICT } ,
 152   { "innercontinue", QINNERCONTINUE } ,
 153   { "innerbreak", QINNERBREAK } ,
 154   { "loopbreak", QLOOPBREAK } ,
 155   { "switchbreak", QSWITCHBREAK } ,
 156   { "safebreak", QSAFEBREAK } ,
 157   { "fallthrough", QFALLTHROUGH } ,
 158   { "l_fallthrou", QLINTFALLTHROUGH } ,
 159   { "l_fallth", QLINTFALLTHRU } ,
 160   { "notreached", QNOTREACHED } ,
 161   { "l_notreach", QLINTNOTREACHED } ,
 162   { "printflike", QPRINTFLIKE } ,
 163   { "l_printfli", QLINTPRINTFLIKE } ,
 164   { "scanflike", QSCANFLIKE } ,
 165   { "messagelike", QMESSAGELIKE } ,
 166   { "l_argsus", QARGSUSED } ,
 167   { NULL, BADTOK }
 168 } ;
 169
 170 static bool cscannerHelp_isConstraintToken (int p_tok) /*@*/ ;
 171 static void cscannerHelp_advanceLine (void) /*@modifies g_currentloc, internalState@*/ ;
 172
 173 /*
 174 ** would be better if these weren't hard coded...
 175 */
 176
 177 static bool isArtificial (cstring s)
 178 {
 179   return (cstring_equalLit (s, "modifies")
 180           || cstring_equalLit (s, "globals")
 181           || cstring_equalLit (s, "warn")
 182           || cstring_equalLit (s, "alt"));
 183 }
 184
 185 void cscannerHelp_swallowMacro (void)
 186 {
 187   int i;
 188   bool skipnext = FALSE;
 189
 190   while ((i = lminput ()) != EOF)
 191     {
 192       char c = (char) i;
 193
 194       if (c == '\\')
 195         {
 196           skipnext = TRUE;
 197         }
 198       else if (c == '\n')
 199         {
 200           if (skipnext)
 201             {
 202               skipnext = FALSE;
 203             }
 204           else
 205             {
 206               reader_checkUngetc (i, c_in);
 207               return;
 208             }
 209         }
 210       else
 211         {
 212           ;
 213         }
 214     }
 215
 216   if (i != EOF)
 217     {
 218       reader_checkUngetc (i, c_in);
 219     }
 220 }
 221
 222 static int commentMarkerToken (cstring s)
 223 {
 224   int i = 0;
 225
 226   while (s_parsetable[i].name != NULL)
 227     {
 228       DPRINTF (("Try :%s:%s:", s, s_parsetable[i].name));
 229
 230       if (cstring_equalLit (s, s_parsetable[i].name))
 231         {
 232           return s_parsetable[i].token;
 233         }
 234
 235       i++;
 236     }
 237
 238   return BADTOK;
 239 }
 240
 241 static int tokenMacroCode (cstring s)
 242 {
 243   int i = 0;
 244
 245   while (s_keytable[i].name != NULL)
 246     {
 247       if (cstring_equalLit (s, s_keytable[i].name))
 248         {
 249           if (s_keytable[i].token == QLINTFALLTHROUGH)
 250             {
 251               voptgenerror
 252                 (FLG_WARNLINTCOMMENTS,
 253                  cstring_makeLiteral
 254                  ("Traditional lint comment /*FALLTHROUGH*/ used. "
 255                   "Splint interprets this in the same way as most Unix lints, but it is "
 256                   "preferable to replace it with the /*@fallthrough@*/ "
 257                   "semantic comment"),
 258                  g_currentloc);
 259               return QFALLTHROUGH;
 260             }
 261           else if (s_keytable[i].token == QLINTFALLTHRU)
 262             {
 263               voptgenerror
 264                 (FLG_WARNLINTCOMMENTS,
 265                  cstring_makeLiteral
 266                  ("Traditional lint comment /*FALLTHRU*/ used. "
 267                   "Splint interprets this in the same way as most Unix lints, but it is "
 268                   "preferable to replace it with the /*@fallthrough@*/ "
 269                   "semantic comment"),
 270                  g_currentloc);
 271               return QFALLTHROUGH;
 272             }
 273           else if (s_keytable[i].token == QLINTNOTREACHED)
 274             {
 275               voptgenerror
 276                 (FLG_WARNLINTCOMMENTS,
 277                  cstring_makeLiteral
 278                  ("Traditional lint comment /*NOTREACHED*/ used. "
 279                   "Splint interprets this in the same way as most Unix lints, but it is "
 280                   "preferable to replace it with the /*@notreached@*/ "
 281                   "semantic comment."),
 282                  g_currentloc);
 283
 284               return QNOTREACHED;
 285             }
 286           else if (s_keytable[i].token == QPRINTFLIKE)
 287             {
 288               setSpecialFunction (qual_createPrintfLike ());
 289               return SKIPTOK;
 290             }
 291           else if (s_keytable[i].token == QLINTPRINTFLIKE)
 292             {
 293               voptgenerror
 294                 (FLG_WARNLINTCOMMENTS,
 295                  cstring_makeLiteral
 296                  ("Traditional lint comment /*PRINTFLIKE*/ used. "
 297                   "Splint interprets this in the same way as most Unix lints, but it is "
 298                   "preferable to replace it with either /*@printflike@*/, "
 299                   "/*@scanflike@*/ or /*@messagelike@*/."),
 300                  g_currentloc);
 301
 302               setSpecialFunction (qual_createPrintfLike ());
 303               return SKIPTOK;
 304             }
 305           else if (s_keytable[i].token == QSCANFLIKE)
 306             {
 307               setSpecialFunction (qual_createScanfLike ());
 308               return SKIPTOK;
 309             }
 310           else if (s_keytable[i].token == QMESSAGELIKE)
 311             {
 312               setSpecialFunction (qual_createMessageLike ());
 313               return SKIPTOK;
 314             }
 315           else if (s_keytable[i].token == QARGSUSED)
 316             {
 317               voptgenerror
 318                 (FLG_WARNLINTCOMMENTS,
 319                  cstring_makeLiteral
 320                  ("Traditional lint comment /*ARGSUSED*/ used. "
 321                   "Splint interprets this in the same way as most Unix lints, but it is "
 322                   "preferable to use /*@unused@*/ annotations on "
 323                   "the unused parameters."),
 324                  g_currentloc);
 325
 326               setArgsUsed ();
 327               return SKIPTOK;
 328             }
 329           else
 330             {
 331               return s_keytable[i].token;
 332             }
 333         }
 334
 335       i++;
 336     }
 337
 338   return BADTOK;
 339 }
 340
 341 static int lminput (void)
 342 {
 343   if (s_savechar == '\0')
 344     {
 345       incColumn ();
 346       return (cscanner_input ());
 347     }
 348   else
 349     {
 350       int save = (int) s_savechar;
 351       s_savechar = '\0';
 352       return save;
 353     }
 354 }
 355
 356 static void lmsavechar (char c)
 357 {
 358   if (s_savechar == '\0')
 359     {
 360       s_savechar = c;
 361     }
 362   else
 363     {
 364       llbuglit ("lmsavechar: override");
 365     }
 366 }
 367
 368 int cscannerHelp_ninput (void)
 369 {
 370   int c = lminput ();
 371
 372   if (c != EOF && ((char)c == '\n'))
 373     {
 374       context_incLineno ();
 375     }
 376
 377   return c;
 378 }
 379
 380 static char macro_nextChar (void)
 381 {
 382   static bool in_quote = FALSE, in_escape = FALSE, in_char = FALSE;
 383   int ic;
 384   char c;
 385
 386   ic = lminput ();
 387   c = char_fromInt (ic);
 388
 389   if (!in_quote && !in_char && (c == '\\' || c == BEFORE_COMMENT_MARKER[0]))
 390     {
 391       if (c == '\\')
 392         {
 393           while ((c = char_fromInt (lminput ())) != '\0' && c != '\n')
 394             {
 395               ; /* skip to newline */
 396             }
 397
 398           context_incLineno ();
 399
 400           if (c != '\0')
 401             {
 402               return macro_nextChar ();
 403             }
 404           else
 405             {
 406               return c;
 407             }
 408         }
 409       else /* if (c == '@') */
 410         {
 411           llassert (FALSE);
 412
 413           if (cscannerHelp_handleLlSpecial () != BADTOK)
 414             {
 415               llerrorlit (FLG_SYNTAX, "Macro cannot use special syntax");
 416             }
 417
 418           return macro_nextChar ();
 419         }
 420     }
 421   else if (!in_escape && c == '\"')
 422     {
 423       in_quote = !in_quote;
 424     }
 425   else if (!in_escape && c == '\'')
 426     {
 427       in_char = !in_char;
 428     }
 429   else if ((in_quote || in_char) && c == '\\')
 430     {
 431       in_escape = !in_escape;
 432     }
 433   else if ((in_quote || in_char) && in_escape)
 434     {
 435       in_escape = FALSE;
 436     }
 437   else if (!in_quote && c == '/')
 438     {
 439       char c2;
 440
 441       if ((c2 = char_fromInt (lminput ())) == '*')
 442         {
 443           while (c2 != '\0')
 444             {
 445               while ((c2 = char_fromInt (lminput ())) != '\0'
 446                      && c2 != '\n' && c2 != '*')
 447                 {
 448                   ;
 449                 }
 450
 451               if (c2 == '*')
 452                 {
 453                   while ((c2 = char_fromInt (lminput ())) != '\0'
 454                          && c2 == '*')
 455                     {
 456                       ;
 457                     }
 458
 459                   if (c2 == '/')
 460                     {
 461                       goto outofcomment;
 462                     }
 463                 }
 464               else
 465                 {
 466                   llfatalerror (cstring_makeLiteral ("Macro: bad comment!"));
 467                 }
 468             }
 469         outofcomment:
 470           return macro_nextChar ();
 471         }
 472       else
 473         {
 474           /*** putchar does not work!  why?  puts to stdio...??! ***/
 475           lmsavechar (c2);
 476         }
 477     }
 478   else
 479     {
 480       ;
 481     }
 482
 483   return c;
 484 }
 485
 486 /*
 487 ** keeps semantic comments
 488 */
 489
 490 static char macro_nextCharC (void)
 491 {
 492   static bool in_quote = FALSE, in_escape = FALSE, in_char = FALSE;
 493   char c;
 494
 495   c = char_fromInt (lminput ());
 496
 497   if (!in_quote && !in_char && c == '\\')
 498     {
 499       while ((c = char_fromInt (lminput ())) != '\0' && c != '\n')
 500         {
 501           ; /* skip to newline */
 502         }
 503
 504       context_incLineno ();
 505
 506       if (c != '\0')
 507         {
 508           return macro_nextCharC ();
 509         }
 510       else
 511         {
 512           return c;
 513         }
 514     }
 515   else if (!in_escape && c == '\"')
 516     {
 517       in_quote = !in_quote;
 518     }
 519   else if (!in_escape && c == '\'')
 520     {
 521       in_char = !in_char;
 522     }
 523   else if ((in_quote || in_char) && c == '\\')
 524     {
 525       in_escape = !in_escape;
 526     }
 527   else if ((in_quote || in_char) && in_escape)
 528     {
 529       in_escape = FALSE;
 530     }
 531   else if (!in_quote && c == '/')
 532     {
 533       char c2;
 534
 535       if ((c2 = char_fromInt (lminput ())) == '*')
 536         {
 537           while (c2 != '\0')
 538             {
 539               while ((c2 = char_fromInt (lminput ())) != '\0'
 540                      && c2 != '\n' && c2 != '*')
 541                 {
 542                   ;
 543                 }
 544
 545               if (c2 == '*')
 546                 {
 547                   while ((c2 = char_fromInt (lminput ())) != '\0'
 548                          && c2 == '*')
 549                     {
 550                       ;
 551                     }
 552
 553                   if (c2 == '/')
 554                     {
 555                       goto outofcomment;
 556                     }
 557                 }
 558               else
 559                 {
 560                   llfatalerror (cstring_makeLiteral ("Macro: bad comment!"));
 561                 }
 562             }
 563         outofcomment:
 564           return macro_nextCharC ();
 565         }
 566       else
 567         {
 568           lmsavechar (c2);
 569         }
 570     }
 571   else /* normal character */
 572     {
 573       ;
 574     }
 575
 576   return c;
 577 }
 578
 579 /*
 580 ** skips whitespace (handles line continuations)
 581 ** returns first non-whitespace character
 582 */
 583
 584 static char skip_whitespace (void)
 585 {
 586   char c;
 587
 588   while ((c = macro_nextChar ()) == ' ' || c == '\t')
 589     {
 590       ;
 591     }
 592
 593   return c;
 594 }
 595
 596 void cscannerHelp_handleMacro (void)
 597 {
 598   cstring mac = cstring_undefined;
 599   int macrocode;
 600   char c;
 601
 602   while (currentColumn () > 2)
 603     {
 604       mac = cstring_appendChar (mac, ' ');
 605       cscannerHelp_setTokLength (-1);
 606     }
 607
 608   c = macro_nextCharC ();
 609
 610   if (c >= '0' && c <= '9')
 611     {
 612       int i;
 613
 614       for (i = 0; i < (((int) (c - '0')) + 1); i++)
 615         {
 616           mac = cstring_appendChar (mac, ' ');
 617         }
 618     }
 619   else
 620     {
 621       BADBRANCH;
 622     }
 623
 624   while (((c = macro_nextCharC ()) != '\0') && (c != '\n'))
 625     {
 626       mac = cstring_appendChar (mac, c);
 627     }
 628
 629
 630   macrocode = tokenMacroCode (mac);
 631
 632   if (macrocode == BADTOK && !isArtificial (mac))
 633     {
 634       context_addMacroCache (mac);
 635     }
 636   else
 637     {
 638       cstring_free (mac);
 639     }
 640
 641   if (c == '\n')
 642     {
 643       context_incLineno ();
 644     }
 645 }
 646
 647 bool cscannerHelp_handleSpecial (char *text)
 648 {
 649   char *l; /* !!  = mstring_create (MAX_NAME_LENGTH); */
 650   int lineno = 0;
 651   char c;
 652   char *ol;
 653   cstring olc;
 654
 655   l = mstring_copy (text + 1);
 656
 657   while ((c = char_fromInt (lminput ())) != '\n' && c != '\0')
 658     {
 659       l = mstring_append(l, c);
 660     }
 661
 662   ol = l;
 663
 664   olc = cstring_fromChars (ol);
 665
 666   if (cstring_equalPrefixLit (olc, "pragma"))
 667     {
 668       char *pname = mstring_create (size_fromInt (MAX_PRAGMA_LEN));
 669       char *opname = pname;
 670       char *ptr = ol + 6; /* pragma is six characters, plus space */
 671       int len = 0;
 672
 673
 674       /* skip whitespace */
 675       while (((c = *ptr) != '\0') && isspace (c))
 676         {
 677           ptr++;
 678         }
 679
 680
 681       while (((c = *ptr) != '\0') && !isspace (c))
 682         {
 683           len++;
 684
 685           if (len > MAX_PRAGMA_LEN)
 686             {
 687               break;
 688             }
 689
 690           ptr++;
 691           *pname++ = c;
 692         }
 693
 694       *pname = '\0';
 695
 696       if (len == PRAGMA_LEN_EXPAND
 697           && mstring_equal (opname, PRAGMA_EXPAND))
 698         {
 699           cstring exname = cstring_undefined;
 700           uentry ue;
 701
 702           ptr++;
 703           while (((c = *ptr) != '\0') && !isspace (c))
 704             {
 705               exname = cstring_appendChar (exname, c);
 706               ptr++;
 707             }
 708
 709
 710           ue = usymtab_lookupExposeGlob (exname);
 711
 712           if (uentry_isExpandedMacro (ue))
 713             {
 714               if (fileloc_isPreproc (uentry_whereDefined (ue)))
 715                 {
 716                   fileloc_setColumn (g_currentloc, 1);
 717                   uentry_setDefined (ue, g_currentloc);
 718                 }
 719             }
 720
 721           cstring_free (exname);
 722         }
 723
 724       (void) cscannerHelp_handleNewLine (); /* evans 2003-10-27: pragment increments line */
 725     }
 726   else if (cstring_equalPrefixLit (olc, "ident"))
 727     {
 728       /* Some pre-processors will leave these in the code.  Ignore rest of line */
 729       (void) cscannerHelp_handleNewLine (); /* evans 2003-10-27: ident increments line */
 730     }
 731
 732   /*
 733   ** Yuk...Win32 filenames can have spaces in them...we need to read
 734   ** to the matching end quote.
 735   */
 736   else if ((sscanf (ol, "line %d \"", &lineno) == 1)
 737            || (sscanf (ol, " %d \"", &lineno) == 1))
 738     {
 739       char *tmp = ol;
 740       cstring fname;
 741       fileId fid;
 742
 743       /*@access cstring@*/
 744       while (*tmp != '\"' && *tmp != '\0')
 745         {
 746           tmp++;
 747         }
 748
 749       llassert (*tmp == '\"');
 750       tmp++;
 751       fname = tmp;
 752
 753       while (*tmp != '\"' && *tmp != '\0')
 754         {
 755           tmp++;
 756         }
 757
 758       llassert (*tmp == '\"');
 759       *tmp = '\0';
 760
 761 # if defined(OS2) || defined(WIN32)
 762
 763       /*
 764       ** DOS-like path delimiters get delivered in pairs, something like
 765       ** \"..\\\\file.h\", so we have to make it normal again. We do NOT
 766       ** remove the pre dirs yet as we usually specify tmp paths relative
 767       ** to the current directory, so tmp files would not get found in
 768       ** the hash table.  If this method fails we try it again later.
 769       */
 770
 771       {
 772         char *stmp = fname;
 773
 774         /*
 775         ** Skip past the drive marker.
 776         */
 777
 778         if (strchr (stmp, ':') != NULL)
 779           {
 780             stmp = strchr (stmp, ':') + 1;
 781           }
 782
 783         while ((stmp = strchr (stmp, CONNECTCHAR)) != NULL )
 784           {
 785             if (*(stmp+1) == CONNECTCHAR)
 786               {
 787                 memmove (stmp, stmp+1, strlen (stmp));
 788               }
 789
 790             stmp++;
 791           }
 792
 793         fid = fileTable_lookupBase (context_fileTable (), fname);
 794         if (!(fileId_isValid (fid)))
 795           {
 796             fname = osd_removePreDirs (fname);
 797             fid = fileTable_lookupBase (context_fileTable (), fname);
 798           }
 799       }
 800 # else
 801       fname = osd_removePreDirs (fname);
 802       fid = fileTable_lookupBase (context_fileTable (), fname);
 803 # endif
 804
 805       if (!(fileId_isValid (fid)))
 806         {
 807           fileType ftype;
 808
 809           if (context_inXHFile ())
 810           {
 811             ftype = FILE_XH; /* Files included by XH files are also XH files */
 812           }
 813           else if (isHeaderFile (fname))
 814           {
 815             ftype = FILE_HEADER;
 816           }
 817           else
 818           {
 819             ftype = FILE_NORMAL;
 820           }
 821
 822           fid = fileTable_addFile (context_fileTable (), ftype, fname);
 823         }
 824
 825       setFileLine (fid, lineno);
 826       /*@noaccess cstring@*/
 827     }
 828   else if ((sscanf (ol, "line %d", &lineno) == 1)
 829            || (sscanf (ol, " %d", &lineno) == 1))
 830     {
 831       setLine (lineno); /* next line is <cr> */
 832     }
 833   else
 834     {
 835       if (mstring_equal (ol, "")) {
 836         DPRINTF (("Empty pp command!"));
 837         /*
 838         ** evs 2000-05-16: This is a horrible kludge, to get around a bug (well, difficulty) in the pre-processor.
 839         ** We handle a plain # in the input file, by echoing it, and ignoring it in the post-pp-file.
 840         */
 841         mstring_free (ol);
 842         (void) cscannerHelp_handleNewLine (); /* evans 2003-10-27: increments line */
 843         return FALSE;
 844       } else {
 845         voptgenerror
 846           (FLG_UNRECOGDIRECTIVE,
 847            message ("Unrecognized pre-processor directive: #%s",
 848                     cstring_fromChars (ol)),
 849            g_currentloc);
 850         (void) cscannerHelp_handleNewLine (); /* evans 2003-10-27: increments line */
 851       }
 852
 853       sfree (ol);
 854       return FALSE; /* evans 2001-12-30: was: TRUE; */
 855     }
 856
 857   sfree (ol);
 858   return FALSE;
 859 }
 860
 861 int cscannerHelp_handleLlSpecial (void)
 862 {
 863   bool hasnl = FALSE;
 864   int ic;
 865   char c;
 866   char *s = mstring_createEmpty ();
 867   char *os;
 868   int tok;
 869   int charsread = 0;
 870   fileloc loc;
 871
 872   loc = fileloc_copy (g_currentloc);
 873   DPRINTF (("Handle special: %s", fileloc_unparse (loc)));
 874
 875   while (((ic = cscannerHelp_ninput ()) != 0) && isalpha (ic))
 876     {
 877       c = (char) ic;
 878       s = mstring_append (s, c);
 879       charsread++;
 880     }
 881
 882   DPRINTF (("Read: %s / %s", s, fileloc_unparse (g_currentloc)));
 883   os = s;
 884
 885   if (charsread == 0 && ic == (int) AFTER_COMMENT_MARKER[0])
 886     {
 887       ic = cscannerHelp_ninput ();
 888
 889       llassert (ic == (int) AFTER_COMMENT_MARKER[1]);
 890
 891       if (*s == '\0')
 892         {
 893           sfree (os);
 894           fileloc_free (loc);
 895           return QNOMODS; /* special token no modifications token */
 896         }
 897     }
 898
 899   DPRINTF (("Coment marker: %s", os));
 900   tok = commentMarkerToken (cstring_fromChars (os));
 901
 902   if (tok != BADTOK)
 903     {
 904       s_tokLength = charsread;
 905       sfree (os);
 906       s_inSpecPart = TRUE;
 907       s_whichSpecPart = tok;
 908       fileloc_free (loc);
 909       return tok;
 910     }
 911
 912   DPRINTF (("Not a comment marker..."));
 913   /* Add rest of the comment */
 914
 915   if (ic != 0 && ic != EOF)
 916     {
 917       c = (char) ic;
 918
 919       s = mstring_append (s, c);
 920       charsread++;
 921
 922       while (((ic = cscannerHelp_ninput ()) != 0) && (ic != EOF)
 923              && (ic != (int) AFTER_COMMENT_MARKER[0]))
 924         {
 925           c = (char) ic;
 926
 927           /* evans 2001-09-01 added to prevent assertion failures for uncloses syntactic comments */
 928
 929           if (c == '\n') {
 930             hasnl = TRUE; /* This prevents tokLength from being set later. */
 931             s_tokLength = 0;
 932
 933             voptgenerror
 934               (FLG_SYNTAX,
 935                message ("Likely parse error: syntactic comment token spans multiple lines: %s",
 936                         cstring_fromChars (s)),
 937                loc);
 938           }
 939
 940           s = mstring_append (s, c);
 941           charsread++;
 942         }
 943       /*@-branchstate@*/
 944     } /* spurious (?) warnings about s */
 945   /*@=branchstate@*/
 946
 947   DPRINTF (("Read: %s / %s", s, fileloc_unparse (g_currentloc)));
 948
 949   if (ic == (int) AFTER_COMMENT_MARKER[0])
 950     {
 951       int nc = cscannerHelp_ninput ();
 952       llassert ((char) nc ==  AFTER_COMMENT_MARKER[1]);
 953       charsread++;
 954     }
 955
 956   os = s;
 957
 958   while (*s == ' ' || *s == '\t' || *s == '\n')
 959     {
 960       s++;
 961     }
 962
 963   if (*s == '-' || *s == '+' || *s == '=') /* setting flags */
 964     {
 965       c = *s;
 966
 967       while (c == '-' || c == '+' || c == '=')
 968         {
 969           ynm set = ynm_fromCodeChar (c);
 970           cstring thisflag;
 971
 972           s++;
 973
 974           thisflag = cstring_fromChars (s);
 975
 976           while ((c = *s) != '\0' && (c != '-') && (c != '=')
 977                  && (c != '+') && (c != ' ') && (c != '\t') && (c != '\n'))
 978             {
 979               s++;
 980             }
 981
 982           *s = '\0';
 983
 984           if (!context_getFlag (FLG_NOCOMMENTS))
 985             {
 986               cstring flagname = thisflag;
 987               flagcode fflag = flags_identifyFlag (flagname);
 988
 989               if (flagcode_isSkip (fflag))
 990                 {
 991                   ;
 992                 }
 993               else if (flagcode_isModeName (fflag))
 994                 {
 995                   if (ynm_isMaybe (set))
 996                     {
 997                       llerror
 998                         (FLG_BADFLAG,
 999                          message
1000                          ("Semantic comment attempts to restore flag %s.  "
1001                           "A mode flag cannot be restored.",
1002                           flagname));
1003                     }
1004                   else
1005                     {
1006                       context_setMode (flagname);
1007                     }
1008                 }
1009               else if (flagcode_isInvalid (fflag))
1010                 {
1011                   voptgenerror
1012                     (FLG_UNRECOGFLAGCOMMENTS,
1013                      message ("Unrecognized option in semantic comment: %s",
1014                               flagname),
1015                      loc);
1016                 }
1017               else if (flagcode_isGlobalFlag (fflag))
1018                 {
1019                   voptgenerror
1020                     (FLG_BADFLAG,
1021                      message
1022                      ("Semantic comment attempts to set global flag %s.  "
1023                       "A global flag cannot be set locally.",
1024                       flagname),
1025                      loc);
1026                 }
1027               else
1028                 {
1029                   context_fileSetFlag (fflag, set, loc);
1030
1031                   if (flagcode_hasArgument (fflag))
1032                     {
1033                       if (ynm_isMaybe (set))
1034                         {
1035                           voptgenerror
1036                             (FLG_BADFLAG,
1037                              message
1038                              ("Semantic comment attempts to restore flag %s.  "
1039                               "A flag for setting a value cannot be restored.",
1040                               flagname),
1041                              loc);
1042                         }
1043                       else
1044                         { /* cut-and-pastied from llmain...blecch */
1045                           cstring extra = cstring_undefined;
1046                           char *rest;
1047                           char *orest;
1048                           char rchar;
1049
1050                           *s = c;
1051                           rest = mstring_copy (s);
1052                           orest = rest;
1053                           *s = '\0';
1054
1055                           while ((rchar = *rest) != '\0'
1056                                  && (isspace (rchar)))
1057                             {
1058                               rest++;
1059                               s++;
1060                             }
1061
1062                           while ((rchar = *rest) != '\0'
1063                                  && !isspace (rchar))
1064                             {
1065                               extra = cstring_appendChar (extra, rchar);
1066                               rest++;
1067                               s++;
1068                             }
1069                           s--; /* evans 2002-07-12: this was previously only in the else branch.
1070                                   Leads to an invalid read on the true branch.
1071                                */
1072
1073                           sfree (orest);
1074
1075                           if (cstring_isUndefined (extra))
1076                             {
1077                               llerror
1078                                 (FLG_BADFLAG,
1079                                  message
1080                                  ("Flag %s (in semantic comment) must be followed by an argument",
1081                                   flagcode_unparse (fflag)));
1082
1083                               cstring_free (extra);
1084                             }
1085                           else
1086                             {
1087                               if (flagcode_hasNumber (fflag))
1088                                 {
1089                                   flags_setValueFlag (fflag, extra);
1090                                 }
1091                               else if (flagcode_hasChar (fflag))
1092                                 {
1093                                   flags_setValueFlag (fflag, extra);
1094                                 }
1095                               else if (flagcode_hasString (fflag))
1096                                 {
1097                                   flags_setStringFlag (fflag, extra);
1098                                 }
1099                               else
1100                                 {
1101                                   cstring_free (extra);
1102                                   BADEXIT;
1103                                 }
1104                             }
1105                         }
1106                     }
1107                 }
1108             }
1109           else
1110             {
1111               ;
1112             }
1113
1114           *s = c;
1115           while ((c == ' ') || (c == '\t') || (c == '\n'))
1116             {
1117               c = *(++s);
1118             }
1119         }
1120
1121       if (context_inHeader () && !isArtificial (cstring_fromChars (os)))
1122         {
1123           DPRINTF (("Here adding comment: %s", os));
1124           context_addComment (cstring_fromCharsNew (os), loc);
1125         }
1126       else
1127         {
1128           ;
1129         }
1130     }
1131   else
1132     {
1133       char *t = s;
1134       int macrocode;
1135       char tchar = '\0';
1136       annotationInfo ainfo;
1137
1138       while (*s != '\0' && *s != ' ' && *s != '\t' && *s != '\n')
1139         {
1140           s++;
1141         }
1142
1143       if (*s != '\0')
1144         {
1145           tchar = *s;
1146           *s = '\0';
1147           s++;
1148         }
1149
1150       t = cstring_toCharsSafe (cstring_downcase (cstring_fromChars (t)));
1151       macrocode = tokenMacroCode (cstring_fromChars (t));
1152
1153       if (macrocode != BADTOK)
1154         {
1155           s_tokLength = hasnl ? 0 : size_toInt (mstring_length (t));
1156
1157           sfree (t);
1158           sfree (os);
1159           fileloc_free (loc);
1160
1161           if (macrocode == SKIPTOK)
1162             {
1163               return BADTOK;
1164             }
1165
1166           return macrocode;
1167         }
1168
1169       ainfo = context_lookupAnnotation (cstring_fromChars (os));
1170
1171       if (annotationInfo_isDefined (ainfo)) {
1172         DPRINTF (("Found annotation: %s", annotationInfo_unparse (ainfo)));
1173         c_lval.annotation = ainfo;
1174         s_tokLength = 0;
1175         sfree (os);
1176         sfree (t);
1177         fileloc_free (loc);
1178         return CANNOTATION;
1179       }
1180
1181       if (context_inHeader ())
1182         {
1183           if (tchar != '\0')
1184             {
1185               *(s-1) = tchar;
1186             }
1187
1188           if ((context_inMacro () || context_inGlobalContext ())
1189               && macrocode != SKIPTOK
1190               && !isArtificial (cstring_fromChars (os)))
1191             {
1192               if (context_processingMacros ())
1193                 {
1194                   /* evans 2002-02-24: don't add comments when procssing macros */
1195                 }
1196               else
1197                 {
1198                   context_addComment (cstring_fromCharsNew (os), loc);
1199                 }
1200             }
1201           else
1202             {
1203               ;
1204             }
1205
1206           if (tchar != '\0')
1207             {
1208               *(s-1) = '\0';
1209             }
1210         }
1211
1212       if (mstring_equal (t, "ignore"))
1213         {
1214           if (!context_getFlag (FLG_NOCOMMENTS))
1215             {
1216               context_enterSuppressRegion (loc);
1217             }
1218         }
1219       else if ((*t == 'i' || *t == 't')
1220                && (*(t + 1) == '\0'))
1221         {
1222           if (!context_getFlag (FLG_NOCOMMENTS)
1223               && (*t == 'i' || context_getFlag (FLG_TMPCOMMENTS)))
1224             {
1225               context_enterSuppressLine (-1, loc); /* infinite suppression */
1226             }
1227         }
1228       else if (((*t == 'i') || (*t == 't'))
1229                && ((*(t + 1) >= '0' && *(t + 1) <= '9')))
1230         {
1231           bool tmpcomment = (*t == 't');
1232           int val = -1;
1233           char *tt = t; /* don't mangle t, since it is free'd */
1234           char lc = *(++tt);
1235
1236           if (lc >= '0' && lc <= '9')
1237             {
1238               val = (int)(lc - '0');
1239
1240               lc = *(++tt);
1241               while (lc >= '0' && lc <= '9')
1242                 {
1243                   val *= 10;
1244                   val += (int) (lc - '0');
1245                   lc = *(++tt);
1246                 }
1247             }
1248
1249           if (!context_getFlag (FLG_NOCOMMENTS)
1250               && (!tmpcomment || context_getFlag (FLG_TMPCOMMENTS)))
1251             {
1252               DPRINTF (("Here: enter suppress: %s", fileloc_unparse (loc)));
1253               context_enterSuppressLine (val, loc);
1254             }
1255         }
1256       else if (mstring_equal (t, "end"))
1257         {
1258           if (!context_getFlag (FLG_NOCOMMENTS))
1259             {
1260               context_exitSuppressRegion (loc);
1261             }
1262         }
1263       else if (mstring_equal (t, "notfunction"))
1264         {
1265          ; /* handled by pcpp */
1266         }
1267       else if (mstring_equal (t, "access"))
1268         {
1269           cstring tname;
1270
1271           while (TRUE)
1272             {
1273               while (((c = *s) != '\0') && (c == ' ' || c == '\t' || c == '\n'))
1274                 {
1275                   s++;
1276                 }
1277
1278               if (c == '\0')
1279                 {
1280                    break;
1281                 }
1282
1283               tname = cstring_fromChars (s);
1284
1285               while ((c = *s) != '\0' && c != ' '
1286                      && c != '\t' && c != '\n' && c != ',')
1287                 {
1288                   s++;
1289                 }
1290
1291               *s = '\0';
1292
1293               DPRINTF (("Access %s", tname));
1294
1295               if (!context_getFlag (FLG_NOCOMMENTS)
1296                   && !context_getFlag (FLG_NOACCESS))
1297                 {
1298                   if (usymtab_existsType (tname))
1299                     {
1300                       typeId uid = usymtab_getTypeId (tname);
1301                       uentry ue = usymtab_getTypeEntry (uid);
1302
1303                       if (uentry_isAbstractDatatype (ue))
1304                         {
1305                           context_addFileAccessType (uid);
1306                           DPRINTF (("Adding access to: %s / %d", tname, uid));
1307                         }
1308                       else
1309                         {
1310                           voptgenerror
1311                             (FLG_COMMENTERROR,
1312                              message
1313                              ("Non-abstract type %s used in access comment",
1314                               tname),
1315                              loc);
1316                         }
1317                     }
1318                   else
1319                     {
1320                       if (!(context_inSuppressRegion ()
1321                             || context_inSuppressZone (loc)))
1322                         {
1323                           voptgenerror
1324                             (FLG_COMMENTERROR,
1325                              message
1326                              ("Unrecognized type %s used in access comment",
1327                               tname),
1328                              loc);
1329                         }
1330                     }
1331                 }
1332
1333               if (c != '\0')
1334                 {
1335                   s++;
1336                 }
1337
1338               if (c != ',' && c != ' ')
1339                 {
1340                   break;
1341                 }
1342             }
1343         }
1344       else if (mstring_equal (t, "noaccess"))
1345         {
1346           cstring tname;
1347           char lc;
1348
1349           while (TRUE)
1350             {
1351               while (((lc = *s) != '\0') && (lc == ' ' || lc == '\t' || lc == '\n'))
1352                 {
1353                   s++;
1354                 }
1355
1356               if (lc == '\0')
1357                 {
1358                  break;
1359                 }
1360
1361               tname = cstring_fromChars (s);
1362
1363               while ((lc = *s) != '\0' && lc != ' ' && lc != '\t'
1364                      && lc != '\n' && lc != ',')
1365                 {
1366                   s++;
1367                 }
1368
1369               *s = '\0';
1370
1371               if (!context_getFlag (FLG_NOCOMMENTS)
1372                   && !context_getFlag (FLG_NOACCESS))
1373                 {
1374                   if (usymtab_existsType (tname))
1375                     {
1376                       typeId tuid = usymtab_getTypeId (tname);
1377
1378                       if (context_couldHaveAccess (tuid))
1379                         {
1380                           DPRINTF (("Removing access: %s", tname));
1381                           context_removeFileAccessType (tuid);
1382                         }
1383                       else
1384                         {
1385                           if (!(context_inSuppressRegion ()
1386                                 || context_inSuppressZone (loc)))
1387                             {
1388                               uentry ue = usymtab_getTypeEntry (tuid);
1389
1390                               if (uentry_isAbstractDatatype (ue))
1391                                 {
1392                                   voptgenerror
1393                                     (FLG_COMMENTERROR,
1394                                      message
1395                                      ("Non-accessible abstract type %s used in noaccess comment",
1396                                       tname),
1397                                      loc);
1398                                 }
1399                               else
1400                                 {
1401                                   voptgenerror
1402                                     (FLG_COMMENTERROR,
1403                                      message
1404                                      ("Non-abstract type %s used in noaccess comment",
1405                                       tname),
1406                                      loc);
1407                                 }
1408                             }
1409                         }
1410                     }
1411                   else
1412                     {
1413                       if (!(context_inSuppressRegion ()
1414                             || context_inSuppressZone (loc)))
1415                         {
1416                           voptgenerror
1417                             (FLG_COMMENTERROR,
1418                              message
1419                              ("Unrecognized type %s used in noaccess comment",
1420                               tname),
1421                              loc);
1422                         }
1423                     }
1424                 }
1425
1426               if (lc != '\0')
1427                 {
1428                   s++;
1429                 }
1430
1431               if (lc != ',' && lc != ' ')
1432                 {
1433                   break;
1434                 }
1435             }
1436         }
1437       else
1438         {
1439           voptgenerror (FLG_UNRECOGCOMMENTS,
1440                         message ("Semantic comment unrecognized: %s",
1441                                  cstring_fromChars (os)),
1442                         loc);
1443           /*@-branchstate@*/
1444         } /* spurious (?) warning about t */
1445       /*@=branchstate@*/
1446
1447       sfree (t);
1448     }
1449
1450   sfree (os);
1451   fileloc_free (loc);
1452   return BADTOK;
1453 }
1454
1455 /*@only@*/ cstring cscannerHelp_makeIdentifier (char *s)
1456 {
1457   char *c = mstring_create (strlen (s));
1458   cstring id = cstring_fromChars (c);
1459
1460   while (isalnum (*s) || (*s == '_') || (*s == '$'))
1461     {
1462       *c++ = *s++;
1463     }
1464
1465   *c = '\0';
1466   return (id);
1467 }
1468
1469 /*@observer@*/ /*@dependent@*/ uentry cscannerHelp_coerceId (cstring cn)
1470 {
1471   if (!(usymtab_exists (cn)))
1472     {
1473       fileloc loc = fileloc_createExternal ();
1474
1475       /*
1476       ** We need to put this in a global scope, otherwise the sRef will be deallocated.
1477       */
1478
1479       uentry ce = uentry_makeUnrecognized (cn, loc);
1480
1481       if (!context_inIterEnd ())
1482         {
1483           voptgenerror
1484             (FLG_SYSTEMUNRECOG,
1485              message ("Unrecognized (possibly system) identifier: %q",
1486                       uentry_getName (ce)),
1487              g_currentloc);
1488         }
1489
1490       return ce;
1491     }
1492
1493   return (usymtab_lookup (cn));
1494 }
1495
1496 /*
1497 ** like, cscannerHelp_coerceId, but doesn't supercede for iters
1498 */
1499
1500 /*@observer@*/ uentry cscannerHelp_coerceIterId (cstring cn)
1501 {
1502   if (!(usymtab_exists (cn)))
1503     {
1504       return uentry_undefined;
1505     }
1506
1507   return (usymtab_lookup (cn));
1508 }
1509
1510 /*
1511 ** Need to keep this in case there is a declaration that isn't processed until
1512 ** the scope exits.  Would be good to rearrange the symbol table so this doesn't
1513 ** happen, and save all the cstring copying.
1514 */
1515
1516 /*@observer@*/ cstring cscannerHelp_observeLastIdentifier (void)
1517 {
1518   cstring res = s_lastidprocessed;
1519   return res;
1520 }
1521
1522 static void cscanner_setLastIdentifier (/*@keep@*/ cstring id) /*@modifies s_lastidprocessed@*/
1523 {
1524   if (cstring_isDefined (s_lastidprocessed))
1525     {
1526       cstring_free (s_lastidprocessed);
1527     }
1528
1529   s_lastidprocessed = id;
1530 }
1531
1532 static int
1533 cscannerHelp_processIdentifier (/*@only@*/ cstring id)
1534   /*@modifies internalState@*/
1535 {
1536   uentry le;
1537
1538   if (context_getFlag (FLG_GRAMMAR))
1539     {
1540       lldiagmsg (message ("Process identifier: %s", id));
1541     }
1542
1543   context_clearJustPopped ();
1544   cscanner_setLastIdentifier (id);
1545
1546   DPRINTF (("Context: %s", context_unparse ()));
1547
1548   if (context_inFunctionHeader ())
1549     {
1550       int tok = commentMarkerToken (id);
1551       DPRINTF (("in function decl: %s", id));
1552
1553       if (tok != BADTOK)
1554         {
1555           return tok;
1556         }
1557       else
1558         {
1559           tok = tokenMacroCode (id);
1560
1561           if (tok != BADTOK)
1562             {
1563               return tok;
1564             }
1565           else
1566             {
1567               annotationInfo ainfo;
1568
1569               if (s_expectingMetaStateName)
1570                 {
1571                   metaStateInfo msinfo = context_lookupMetaStateInfo (id);
1572
1573                   if (metaStateInfo_isDefined (msinfo))
1574                     {
1575                       c_lval.msinfo = msinfo;
1576                       return METASTATE_NAME;
1577                     }
1578                   else
1579                     {
1580                       DPRINTF (("Not meta state name: %s", cstring_toCharsSafe (id)));
1581                     }
1582                 }
1583
1584               ainfo = context_lookupAnnotation (id);
1585
1586               if (annotationInfo_isDefined (ainfo))
1587                 {
1588                   DPRINTF (("Found annotation: %s", annotationInfo_unparse (ainfo)));
1589                   c_lval.annotation = ainfo;
1590                   return CANNOTATION;
1591                 }
1592               else
1593                 {
1594                   DPRINTF (("Not annotation: %s", id));
1595                 }
1596             }
1597         }
1598     }
1599
1600   DPRINTF (("Here!"));
1601
1602   /* Consider handling: Defined by C99 as static const char __func__[] */
1603
1604   if (context_getFlag (FLG_GNUEXTENSIONS))
1605     {
1606       int tok = BADTOK;
1607
1608       if (cstring_equalLit (id, "__stdcall")
1609           || cstring_equalLit (id, "__cdecl")
1610           || cstring_equalLit (id, "__extension__"))
1611         {
1612           return BADTOK;
1613         }
1614       else if (cstring_equalLit (id, "__volatile__"))
1615         {
1616           tok = QVOLATILE;
1617         }
1618       else if (cstring_equalLit (id, "__signed"))
1619         {
1620           tok = QSIGNED;
1621         }
1622       else if (cstring_equalLit (id, "__unsigned"))
1623         {
1624           tok = QUNSIGNED;
1625         }
1626       else if (cstring_equalLit (id, "__const__"))
1627         {
1628           tok = QCONST;
1629         }
1630       else if (cstring_equalLit (id, "__alignof__"))
1631         {
1632           tok = CALIGNOF; /* alignof is parsed like sizeof */
1633         }
1634       else if (cstring_equalLit (id, "__typeof__"))
1635         {
1636           tok = CTYPEOF;
1637         }
1638       else if (cstring_equalLit (id, "typeof"))
1639         {
1640           tok = CTYPEOF;
1641         }
1642       else if (cstring_equalLit (id, "__FUNCTION__")
1643                || cstring_equalLit (id, "__PRETTY_FUNCTION__"))
1644         {
1645           /* These tokens hold the name of the current function as strings */
1646           /* evans 2001-12-30: changed from exprNode_stringLiteral; bug reported by Jim Zelenka. */
1647           c_lval.expr = exprNode_makeConstantString (id, fileloc_copy (g_currentloc));
1648           s_tokLength = 0;
1649           tok = CCONSTANT;
1650           return tok;
1651         }
1652       else if (cstring_equalLit (id, "__attribute__")
1653                || cstring_equalLit (id, "__asm__")
1654                || cstring_equalLit (id, "_asm")
1655                || cstring_equalLit (id, "__asm")
1656                || cstring_equalLit (id, "__declspec"))
1657         {
1658           int depth = 0;
1659           bool useparens = FALSE;
1660           bool usebraces = FALSE;
1661           bool inquote = FALSE;
1662           bool inescape = FALSE;
1663           int ic;
1664
1665           while ((ic = cscanner_input ()) != EOF)
1666             {
1667               char cc = (char) ic;
1668
1669               if (inescape)
1670                 {
1671                   inescape = FALSE;
1672                 }
1673               else if (cc == '\\')
1674                 {
1675                   inescape = TRUE;
1676                 }
1677               else if (cc == '\"')
1678                 {
1679                   inquote = !inquote;
1680                 }
1681               else if (!inquote)
1682                 {
1683                   if (cc == '(')
1684                     {
1685                       if (!useparens)
1686                         {
1687                           if (!usebraces)
1688                             {
1689                               useparens = TRUE;
1690                             }
1691                         }
1692
1693                       if (useparens)
1694                         {
1695                           depth++;
1696                         }
1697                     }
1698                   else if (cc == '{')
1699                     {
1700                       if (!usebraces)
1701                         {
1702                           if (!useparens)
1703                             {
1704                               usebraces = TRUE;
1705                             }
1706                         }
1707
1708                       if (usebraces)
1709                         {
1710                           depth++;
1711                         }
1712                     }
1713                   else if (cc == ')' && useparens)
1714                     {
1715                       depth--;
1716                       if (depth == 0) break;
1717                     }
1718                   else if (cc == '}' && usebraces)
1719                     {
1720                       depth--;
1721                       if (depth == 0) break;
1722                     }
1723                   else if (cc == '}'
1724                            && !usebraces && !useparens
1725                            && cstring_equalLit (id, "__asm"))
1726                     {
1727                       /*
1728                       ** We need this because some MS VC++ include files
1729                       ** have __asm mov ... }
1730                       ** Its a kludge, but otherwise would need to parse
1731                       ** the asm code!
1732                       */
1733                       return TRBRACE;
1734                     }
1735                   else
1736                     {
1737                       ;
1738                     }
1739                 }
1740               else
1741                 {
1742                   ;
1743                 }
1744
1745               if (cc == '\n')
1746                 {
1747                   context_incLineno ();
1748
1749                   if (cstring_equalLit (id, "__asm")
1750                       && !useparens && !usebraces)
1751                     {
1752                       break;
1753                     }
1754                 }
1755             }
1756
1757           llassert ((useparens && ic == (int) ')')
1758                     || (usebraces && ic == (int) '}')
1759                     || (!useparens && !usebraces));
1760
1761           return BADTOK;
1762         }
1763       else if (cstring_equalLit (id, "inline")
1764                || cstring_equalLit (id, "__inline")
1765                || cstring_equalLit (id, "_inline")
1766                || cstring_equalLit (id, "__inline__"))
1767         {
1768           tok = QINLINE;
1769         }
1770       else
1771         {
1772           ;
1773         }
1774
1775       if (tok != BADTOK)
1776         {
1777           return (cscannerHelp_returnToken (tok));
1778         }
1779     }
1780
1781   le = usymtab_lookupSafe (id);
1782
1783   /*@-dependenttrans@*/
1784
1785   if (uentry_isIter (le))
1786     {
1787       c_lval.entry = le;
1788       return (ITER_NAME);
1789     }
1790   else if (uentry_isEndIter (le))
1791     {
1792       c_lval.entry = le;
1793       return (ITER_ENDNAME);
1794     }
1795   else if (uentry_isUndefined (le))
1796     {
1797       c_lval.cname = cstring_copy (id);
1798
1799       /* avoid parse errors for certain system built ins */
1800
1801       if (s_expectingTypeName && (cstring_firstChar (id) == '_')
1802           && (cstring_secondChar (id) == '_'))
1803         {
1804           return (TYPE_NAME_OR_ID);
1805         }
1806
1807       return (NEW_IDENTIFIER);
1808     }
1809   else if (!uentry_isDeclared (le) && !uentry_isCodeDefined (le))
1810     {
1811       if (uentry_isDatatype (le))
1812         {
1813           c_lval.cname = cstring_copy (id);
1814           return (NEW_IDENTIFIER);
1815         }
1816       else
1817         {
1818           c_lval.entry = le;
1819           return (IDENTIFIER);
1820         }
1821     }
1822   else if (uentry_isDatatype (le))
1823     {
1824       if (!s_expectingTypeName)
1825         {
1826           c_lval.cname = cstring_copy (id);
1827
1828           return (NEW_IDENTIFIER);
1829         }
1830       else
1831         {
1832           c_lval.ctyp = uentry_getAbstractType (le);
1833
1834           uentry_setUsed (le, g_currentloc);
1835           return (TYPE_NAME);
1836         }
1837     }
1838   else
1839     {
1840       c_lval.entry = le;
1841       return (IDENTIFIER);
1842     }
1843
1844   /*@=dependenttrans@*/
1845 }
1846
1847 bool cscannerHelp_processHashIdentifier (/*@only@*/ cstring id)
1848 {
1849   if (context_inMacro () || context_inIterDef () ||
1850       context_inIterEnd ())
1851     {
1852       uentry le;
1853
1854       context_clearJustPopped ();
1855
1856       le = usymtab_lookupSafe (id);
1857       cscanner_setLastIdentifier (id);
1858
1859       if (uentry_isParam (le) || uentry_isRefParam (le))
1860         {
1861           return TRUE;
1862         }
1863       else
1864         {
1865           return FALSE;
1866         }
1867     }
1868   else
1869     {
1870       /*
1871       ** Will be handled by handleLlSpecial
1872       */
1873
1874       cstring_free (id);
1875       return FALSE;
1876     }
1877 }
1878
1879 /*@only@*/ exprNode cscannerHelp_processString (void)
1880 {
1881   exprNode res;
1882   fileloc loc;
1883   char *nl = strchr (c_text, '\n');
1884   cstring ns = cstring_fromCharsNew (c_text);
1885
1886   if (nl == NULL)
1887     {
1888       loc = fileloc_copy (g_currentloc);
1889       addColumn (size_toInt (cstring_length (ns)));
1890     }
1891   else
1892     {
1893       loc = fileloc_copy (g_currentloc);
1894
1895       context_incLineno ();
1896
1897       while ((nl = strchr ((nl + 1), '\n')) != NULL)
1898         {
1899           context_incLineno ();
1900         }
1901     }
1902
1903
1904   res = exprNode_stringLiteral (ns, loc);
1905   return (res);
1906 }
1907
1908 /*
1909 ** process a wide character string L"...."
1910 */
1911
1912 /*@only@*/ exprNode cscannerHelp_processWideString (void)
1913 {
1914   exprNode res;
1915   fileloc loc;
1916   char *nl = strchr (c_text, '\n');
1917   cstring ns;
1918
1919   llassert (*c_text == 'L');
1920   c_text++;
1921
1922   ns = cstring_fromCharsNew (c_text);
1923
1924   if (nl == NULL)
1925     {
1926       loc = fileloc_copy (g_currentloc);
1927       addColumn (size_toInt (cstring_length (ns)));
1928     }
1929   else
1930     {
1931       loc = fileloc_copy (g_currentloc);
1932
1933       context_incLineno ();
1934
1935       while ((nl = strchr ((nl + 1), '\n')) != NULL)
1936         {
1937           context_incLineno ();
1938         }
1939     }
1940
1941   res = exprNode_wideStringLiteral (ns, loc);
1942   return (res);
1943 }
1944
1945 char cscannerHelp_processChar (void)
1946 {
1947   char fchar;
1948   char next;
1949
1950   llassert (*c_text != '\0');
1951   fchar = *(c_text + 1);
1952   if (fchar != '\\') return fchar;
1953
1954   next = *(c_text + 2);
1955
1956   switch (next)
1957     {
1958     case 'n': return '\n';
1959     case 't': return '\t';
1960     case '\"': return '\"';
1961     case '\'': return '\'';
1962     case '\\': return '\\';
1963     default: return '\0';
1964     }
1965 }
1966
1967 double cscannerHelp_processFloat (void)
1968 {
1969   double ret = atof (c_text);
1970
1971     return (ret);
1972 }
1973
1974 long cscannerHelp_processHex (void)
1975 {
1976   int index = 2;
1977   long val = 0;
1978
1979   llassert (c_text[0] == '0'
1980             && (c_text[1] == 'X' || c_text[1] == 'x'));
1981
1982   while (c_text[index] != '\0') {
1983     int tval;
1984     char c = c_text[index];
1985
1986     if (c >= '0' && c <= '9') {
1987       tval = (int) c - (int) '0';
1988     } else if (c >= 'A' && c <= 'F') {
1989       tval = (int) c - (int) 'A' + 10;
1990     } else if (c >= 'a' && c <= 'f') {
1991       tval = (int) c - (int) 'a' + 10;
1992     } else if (c == 'U' || c == 'L' || c == 'u' || c == 'l') {
1993       index++;
1994       while (c_text[index] != '\0') {
1995         if (c == 'U' || c == 'L' || c == 'u' || c == 'l') {
1996           ;
1997         } else {
1998           voptgenerror
1999             (FLG_SYNTAX,
2000              message ("Invalid character (%c) following specifier in hex constant: %s",
2001                       c, cstring_fromChars (c_text)),
2002              g_currentloc);
2003         }
2004         index++;
2005       }
2006
2007       break;
2008     } else {
2009       voptgenerror
2010         (FLG_SYNTAX,
2011          message ("Invalid character (%c) in hex constant: %s",
2012                   c, cstring_fromChars (c_text)),
2013          g_currentloc);
2014       break;
2015     }
2016
2017     val = (val * 16) + tval;
2018     index++;
2019   }
2020
2021   DPRINTF (("Hex constant: %s = %ld", c_text, val));
2022   return val;
2023 }
2024
2025 long cscannerHelp_processOctal (void)
2026 {
2027   int index = 1;
2028   long val = 0;
2029
2030   llassert (c_text[0] == '0' && c_text[1] != 'X' && c_text[1] != 'x');
2031
2032   while (c_text[index] != '\0') {
2033     int tval;
2034     char c = c_text[index];
2035
2036     if (c >= '0' && c <= '7') {
2037       tval = (int) c - (int) '0';
2038     } else if (c == 'U' || c == 'L' || c == 'u' || c == 'l') {
2039       index++;
2040       while (c_text[index] != '\0') {
2041         if (c == 'U' || c == 'L' || c == 'u' || c == 'l') {
2042           ;
2043         } else {
2044           voptgenerror
2045             (FLG_SYNTAX,
2046              message ("Invalid character (%c) following specifier in octal constant: %s",
2047                       c, cstring_fromChars (c_text)),
2048              g_currentloc);
2049         }
2050         index++;
2051       }
2052
2053       break;
2054     } else {
2055       voptgenerror
2056         (FLG_SYNTAX,
2057          message ("Invalid character (%c) in octal constant: %s",
2058                   c, cstring_fromChars (c_text)),
2059          g_currentloc);
2060       break;
2061     }
2062
2063     val = (val * 8) + tval;
2064     index++;
2065   }
2066
2067   DPRINTF (("Octal constant: %s = %ld", c_text, val));
2068   return val;
2069 }
2070
2071 long cscannerHelp_processDec (void)
2072 {
2073   return (atol (c_text));
2074 }
2075
2076 int cscannerHelp_processSpec (int tok)
2077 {
2078   size_t length = strlen (c_text);
2079
2080   if (s_inSpecPart)
2081     {
2082
2083       /*drl 12/11/2002
2084         patched to fix assert failures in constraint code.
2085         Added the else if test so that splint does not treat MaxSet and MaxRead
2086         as identifies*/
2087
2088       if (s_whichSpecPart == QMODIFIES
2089           || s_whichSpecPart == QDEFINES
2090           || s_whichSpecPart == QUSES
2091           || s_whichSpecPart == QALLOCATES
2092           || s_whichSpecPart == QSETS
2093           || s_whichSpecPart == QRELEASES)
2094
2095         {
2096           DPRINTF((message("Treating specification keyword %s as an identifier.  (This corresponds to"
2097                            " token %d and we're in the  specification denoted by %d)",
2098                            c_text, tok, s_whichSpecPart)
2099                    ));
2100
2101           ; /* Allow specificiation keywords to be used as identifiers in these contexts. */
2102         }
2103       else if ((s_whichSpecPart == QPRECLAUSE
2104                  || s_whichSpecPart == QPOSTCLAUSE
2105                  || s_whichSpecPart == QINVARIANT )
2106                 &&  (!cscannerHelp_isConstraintToken(tok))
2107               )
2108         {
2109           DPRINTF((message("Treating specification keyword %s as an identifier.  (This corresponds to"
2110                            " token %d and we're in the  specification denoted by %d)",
2111                            c_text, tok, s_whichSpecPart)
2112                    ));
2113
2114           /* Allow specificiation keywords to be used as identifiers in these contexts. */
2115         }
2116       else
2117         {
2118           cscannerHelp_setTokLengthT (length);
2119           return cscannerHelp_returnToken (tok);
2120         }
2121     }
2122
2123   context_saveLocation ();
2124   cscannerHelp_setTokLengthT (length);
2125   return (cscannerHelp_processIdentifier (cscannerHelp_makeIdentifier (c_text)));
2126 }
2127
2128 void cscannerHelp_expectingMetaStateName (void)
2129 {
2130   llassert (!s_expectingMetaStateName);
2131   llassert (context_inFunctionHeader ());
2132   s_expectingMetaStateName = TRUE;
2133 }
2134
2135 void cscannerHelp_clearExpectingMetaStateName (void)
2136 {
2137   llassert (s_expectingMetaStateName);
2138   s_expectingMetaStateName = FALSE;
2139 }
2140
2141 static bool cscannerHelp_isConstraintToken (int tok)
2142    /* drl added 12/11/2002
2143       Tell whether a token has special meaning
2144       within a function constraint
2145    */
2146 {
2147   return (tok == QMAXSET || tok == QMAXREAD);
2148           /* || tok == QMINREAD || tok == QMINSET */
2149   /* uncomment the additional if statement tests when minSet and minRead are supported */
2150 }
2151
2152 bool cscannerHelp_processMacro (void)
2153 {
2154   uentry e2;
2155   ctype ct;
2156   int noparams = 0;
2157   cstring fname = cstring_undefined;
2158   bool res = TRUE;
2159   bool isspecfcn = FALSE;
2160   bool isiter = FALSE;
2161   bool skipparam = FALSE;
2162   bool unknownm = FALSE;
2163   bool hasParams = FALSE;
2164   bool emptyMacro = FALSE;
2165   char c = skip_whitespace ();
2166   fileloc loc = fileloc_noColumn (g_currentloc);
2167
2168   /* are both of these necessary?  what do they mean? */
2169   uentryList specparams = uentryList_undefined;
2170   uentryList pn = uentryList_undefined;
2171
2172   context_resetMacroMissingParams ();
2173
2174   if (c == '\0' || c == '\n')
2175     {
2176       llcontbug (cstring_makeLiteral ("Bad macro"));
2177       fileloc_free (loc);
2178       return FALSE;
2179     }
2180
2181   fname = cstring_appendChar (fname, c);
2182
2183   while ((c = macro_nextChar ()) != '(' && c != '\0'
2184          && c != ' ' && c != '\t' && c != '\n')
2185     {
2186       fname = cstring_appendChar (fname, c);
2187     }
2188
2189   if (c == ' ' || c == '\t' || c == '\n')
2190     {
2191       char oldc = c;
2192
2193       if (c != '\n')
2194         {
2195           while (c == ' ' || c == '\t')
2196             {
2197               c = macro_nextChar ();
2198             }
2199           cscanner_unput ((int) c);
2200         }
2201
2202       if (c == '\n')
2203         {
2204           emptyMacro = TRUE;
2205           cscanner_unput ((int) c);
2206         }
2207
2208       c = oldc;
2209     }
2210
2211   hasParams = (c == '(');
2212
2213   if (usymtab_exists (fname))
2214     {
2215       e2 = usymtab_lookupExpose (fname);
2216       ct = uentry_getType (e2);
2217
2218       if (uentry_isCodeDefined (e2)
2219           && fileloc_isUser (uentry_whereDefined (e2)))
2220         {
2221           if (optgenerror
2222               (FLG_MACROREDEF,
2223                message ("Macro %s already defined", fname),
2224                loc))
2225             {
2226               uentry_showWhereDefined (e2);
2227               uentry_clearDefined (e2);
2228             }
2229
2230           if (uentry_isFunction (e2))
2231             {
2232               uentry_setType (e2, ctype_unknown);
2233               ct = ctype_unknown;
2234               unknownm = TRUE;
2235               context_enterUnknownMacro (e2);
2236             }
2237           else
2238             {
2239               context_enterConstantMacro (e2);
2240             }
2241         }
2242       else if (uentry_isForward (e2) && uentry_isFunction (e2))
2243         {
2244           unknownm = TRUE;
2245
2246           voptgenerror
2247             (FLG_MACROFCNDECL,
2248              message
2249              ("Parameterized macro has no prototype or specification: %s ",
2250               fname),
2251              loc);
2252
2253           ct = ctype_unknown;
2254           uentry_setType (e2, ctype_unknown);
2255           uentry_setFunctionDefined (e2, loc);
2256           uentry_setUsed (e2, fileloc_undefined);
2257           context_enterUnknownMacro (e2);
2258         }
2259       else if (uentry_isIter (e2))
2260         {
2261           isiter = TRUE;
2262           specparams = uentry_getParams (e2);
2263           noparams = uentryList_size (specparams);
2264           uentry_setDefined (e2, loc);
2265           context_enterIterDef (e2);
2266         }
2267       else if (uentry_isEndIter (e2))
2268         {
2269           uentry_setDefined (e2, loc);
2270           context_enterIterEnd (e2); /* don't care about it now */
2271           /* but should parse like an iter! */
2272         }
2273       else if (uentry_isConstant (e2))
2274         {
2275           if (hasParams)
2276             {
2277               voptgenerror
2278                 (FLG_INCONDEFS,
2279                  message ("Constant %s implemented as parameterized macro",
2280                           fname),
2281                  g_currentloc);
2282
2283               uentry_showWhereSpecified (e2);
2284               uentry_setType (e2, ctype_unknown);
2285               uentry_makeConstantFunction (e2);
2286               uentry_setDefined (e2, g_currentloc);
2287               uentry_setFunctionDefined (e2, g_currentloc);
2288               context_enterUnknownMacro (e2);
2289             }
2290           else
2291             {
2292               if (!uentry_isSpecified (e2))
2293                 {
2294                   fileloc oloc = uentry_whereDeclared (e2);
2295
2296                   if (fileloc_isLib (oloc))
2297                     {
2298                       ;
2299                     }
2300                   else if (fileloc_isUndefined (oloc)
2301                            || fileloc_isPreproc (oloc))
2302                     {
2303                       if (!emptyMacro)
2304                         {
2305                           voptgenerror
2306                             (FLG_MACROCONSTDECL,
2307                              message
2308                              ("Macro constant %q not declared",
2309                               uentry_getName (e2)),
2310                              loc);
2311                         }
2312                     }
2313                   else if (!fileloc_withinLines (oloc, loc, 2))
2314                     { /* bogus!  will give errors if there is too much whitespace */
2315                       voptgenerror
2316                         (FLG_MACROCONSTDIST,
2317                          message
2318                          ("Macro constant name %s matches name in "
2319                           "distant constant declaration.  This constant "
2320                           "is declared at %q", fname,
2321                           fileloc_unparse (oloc)),
2322                          loc);
2323                     }
2324                   else
2325                     {
2326                       /* No warning */
2327                     }
2328                 }
2329
2330               context_enterConstantMacro (e2);
2331               cstring_free (fname);
2332               fileloc_free (loc);
2333               return res;
2334             }
2335         }
2336       else if (ctype_isFunction (ct))
2337         {
2338           isspecfcn = TRUE;
2339           specparams = ctype_argsFunction (ct);
2340           noparams = uentryList_size (specparams);
2341
2342           uentry_setFunctionDefined (e2, loc);
2343           context_enterMacro (e2);
2344         }
2345       else if (uentry_isVar (e2))
2346         {
2347           if (hasParams)
2348             {
2349               voptgenerror
2350                 (FLG_INCONDEFS,
2351                  message ("Variable %s implemented as parameterized macro",
2352                           fname),
2353                  loc);
2354
2355               uentry_showWhereSpecified (e2);
2356               uentry_setType (e2, ctype_unknown);
2357               uentry_makeVarFunction (e2);
2358               uentry_setDefined (e2, g_currentloc);
2359               uentry_setFunctionDefined (e2, g_currentloc);
2360               context_enterUnknownMacro (e2);
2361             }
2362           else
2363             {
2364               uentry ucons = uentry_makeConstant (fname,
2365                                                   ctype_unknown,
2366                                                   loc);
2367               if (uentry_isExpandedMacro (e2))
2368                 {
2369                   ; /* okay */
2370                 }
2371               else
2372                 {
2373                   if (optgenerror
2374                       (FLG_INCONDEFS,
2375                        message ("Variable %s implemented by a macro",
2376                                 fname),
2377                        loc))
2378                     {
2379                       uentry_showWhereSpecified (e2);
2380                     }
2381                 }
2382
2383               uentry_setDefined (e2, loc);
2384               uentry_setUsed (ucons, loc);
2385
2386               context_enterConstantMacro (ucons);
2387               uentry_markOwned (ucons);
2388               cstring_free (fname);
2389               return res;
2390             }
2391         }
2392       else if (uentry_isDatatype (e2))
2393         {
2394           vgenhinterror
2395             (FLG_SYNTAX,
2396              message ("Type implemented as macro: %x",
2397                       uentry_getName (e2)),
2398              message ("A type is implemented using a macro definition.  A "
2399                       "typedef should be used instead."),
2400              g_currentloc);
2401
2402           cscannerHelp_swallowMacro ();
2403           /* Must exit scope (not sure why a new scope was entered?) */
2404           usymtab_quietExitScope (g_currentloc);
2405           uentry_setDefined (e2, g_currentloc);
2406           res = FALSE;
2407         }
2408       else
2409         {
2410           llcontbug
2411             (message ("Unexpanded macro not function or constant: %q",
2412                       uentry_unparse (e2)));
2413           uentry_setType (e2, ctype_unknown);
2414
2415           if (hasParams)
2416             {
2417               uentry_makeVarFunction (e2);
2418               uentry_setDefined (e2, g_currentloc);
2419               uentry_setFunctionDefined (e2, g_currentloc);
2420               context_enterUnknownMacro (e2);
2421             }
2422         }
2423     }
2424   else
2425     {
2426       uentry ce;
2427
2428       /* evans 2001-09-09 - if it has params, assume a function */
2429       if (hasParams)
2430         {
2431           voptgenerror
2432             (FLG_MACROMATCHNAME,
2433              message ("Unexpanded macro %s does not match name of a declared "
2434                       "function. The name used in the control "
2435                       "comment on the previous line should match.",
2436                       fname),
2437              loc);
2438
2439           ce = uentry_makeFunction (fname, ctype_unknown,
2440                                     typeId_invalid,
2441                                     globSet_undefined,
2442                                     sRefSet_undefined,
2443                                     warnClause_undefined,
2444                                     fileloc_undefined);
2445           uentry_setUsed (ce, loc); /* perhaps bogus? */
2446           e2 = usymtab_supEntryReturn (ce);
2447           context_enterUnknownMacro (e2);
2448         }
2449       else
2450         {
2451           voptgenerror
2452             (FLG_MACROMATCHNAME,
2453              message ("Unexpanded macro %s does not match name of a constant "
2454                       "or iter declaration.  The name used in the control "
2455                       "comment on the previous line should match.  "
2456                       "(Assuming macro defines a constant.)",
2457                       fname),
2458              loc);
2459
2460           ce = uentry_makeConstant (fname, ctype_unknown, fileloc_undefined);
2461           uentry_setUsed (ce, loc); /* perhaps bogus? */
2462           e2 = usymtab_supEntryReturn (ce);
2463
2464           context_enterConstantMacro (e2);
2465           cstring_free (fname);
2466           fileloc_free (loc);
2467           return res;
2468         }
2469     }
2470
2471   /* in macros, ( must follow immediatetly after name */
2472
2473   if (hasParams)
2474     {
2475       int paramno = 0;
2476
2477       c = skip_whitespace ();
2478
2479       while (c != ')' && c != '\0')
2480         {
2481           uentry  param;
2482           bool    suppress = context_inSuppressRegion ();
2483           cstring paramname = cstring_undefined;
2484
2485           /*
2486           ** save the parameter location
2487           */
2488
2489           decColumn ();
2490           context_saveLocation ();
2491           incColumn ();
2492
2493           while (c != ' ' && c != '\t' && c != ',' && c != '\0' && c != ')')
2494             {
2495               paramname = cstring_appendChar (paramname, c);
2496               c = macro_nextChar ();
2497             }
2498
2499           if (c == ' ' || c == '\t') c = skip_whitespace ();
2500
2501           if (c == ',')
2502             {
2503               c = macro_nextChar ();
2504               if (c == ' ' || c == '\t') c = skip_whitespace ();
2505             }
2506
2507           if (c == '\0')
2508             {
2509               llfatalerror (cstring_makeLiteral
2510                             ("Bad macro syntax: uentryList"));
2511             }
2512
2513           if ((isspecfcn || isiter) && (paramno < noparams)
2514               && !uentry_isElipsisMarker (uentryList_getN
2515                                           (specparams, paramno)))
2516             {
2517               fileloc sloc = context_getSaveLocation ();
2518               uentry decl = uentryList_getN (specparams, paramno);
2519               sRef sr;
2520
2521               param = uentry_nameCopy (paramname, decl);
2522
2523               uentry_setParam (param);
2524               sr = sRef_makeParam (paramno, uentry_getType (param),
2525                                    stateInfo_makeLoc (sloc, SA_DECLARED));
2526
2527               if (sRef_getNullState (sr) == NS_ABSNULL)
2528                 {
2529                   ctype pt = ctype_realType (uentry_getType (param));
2530
2531                   if (ctype_isUser (pt))
2532                     {
2533                       uentry te = usymtab_getTypeEntrySafe (ctype_typeId (pt));
2534
2535                       if (uentry_isValid (te))
2536                         {
2537                           sRef_setStateFromUentry (sr, te);
2538                         }
2539                     }
2540                   else
2541                     {
2542                       sRef_setNullState (sr, NS_UNKNOWN, sloc);
2543                     }
2544                 }
2545
2546               uentry_setSref (param, sr);
2547               uentry_setDeclaredForceOnly (param, sloc);
2548
2549               skipparam = isiter && uentry_isOut (uentryList_getN (specparams, paramno));
2550             }
2551           else
2552             {
2553               fileloc sloc = context_getSaveLocation ();
2554
2555               param = uentry_makeVariableSrefParam
2556                 (paramname, ctype_unknown, fileloc_copy (sloc),
2557                  sRef_makeParam (paramno, ctype_unknown,
2558                                  stateInfo_makeLoc (sloc, SA_DECLARED)));
2559               DPRINTF (("Unknown param: %s", uentry_unparseFull (param)));
2560               cstring_free (paramname);
2561
2562               sRef_setPosNull  (uentry_getSref (param), sloc);
2563               uentry_setDeclaredForce (param, sloc);
2564
2565               skipparam = FALSE;
2566               fileloc_free (sloc);
2567             }
2568
2569           if (!skipparam)
2570             {
2571               llassert (!uentry_isElipsisMarker (param));
2572
2573               if (!suppress)
2574                 {
2575                   sRef_makeUnsafe (uentry_getSref (param));
2576                 }
2577
2578               pn = uentryList_add (pn, uentry_copy (param));
2579               usymtab_supEntry (param);
2580             }
2581           else
2582             {
2583               /* don't add param */
2584               uentry_free (param);
2585             }
2586
2587           if (c == ',')
2588             {
2589               (void) macro_nextChar ();
2590               c = skip_whitespace ();
2591             }
2592
2593           paramno++;
2594         }
2595
2596       if (c == ')')
2597         {
2598           if (isspecfcn || isiter)
2599             {
2600               if (paramno != noparams && noparams >= 0)
2601                 {
2602                   cscannerHelp_advanceLine ();
2603
2604                   voptgenerror
2605                     (FLG_INCONDEFS,
2606                      message ("Macro %s specified with %d args, defined with %d",
2607                               fname, noparams, paramno),
2608                      g_currentloc);
2609
2610                   uentry_showWhereSpecified (e2);
2611                   uentry_resetParams (e2, pn);
2612                 }
2613             }
2614           else
2615             {
2616               uentry_resetParams (e2, pn);
2617             }
2618         }
2619     }
2620   else
2621     {
2622       /*
2623       ** the form should be:
2624       **
2625       ** # define newname oldname
2626       ** where oldname refers to a function matching the specification
2627       ** of newname.
2628       */
2629
2630       if (unknownm)
2631         {
2632           sRef_setGlobalScope ();
2633           usymtab_supGlobalEntry (uentry_makeVariableLoc (fname, ctype_unknown));
2634           sRef_clearGlobalScope ();
2635         }
2636       else
2637         {
2638           context_setMacroMissingParams ();
2639         }
2640     }
2641
2642
2643   /* context_setuentryList (pn); */
2644   usymtab_enterScope ();
2645
2646   fileloc_free (loc);
2647   cstring_free (fname);
2648
2649   return res;
2650 }
2651
2652 void cscannerHelp_setTokLength (int len)
2653 {
2654   addColumn (len);
2655   s_tokLength = len;
2656   DPRINTF (("Set tok length: %d", len));
2657 }
2658
2659 void cscannerHelp_setTokLengthT (size_t len)
2660 {
2661   cscannerHelp_setTokLength (size_toInt (len));
2662 }
2663
2664 static void cscannerHelp_advanceLine (void)
2665 {
2666   s_tokLength = 0;
2667   beginLine ();
2668 }
2669
2670 int cscannerHelp_returnToken (int t)
2671 {
2672   if (s_tokLength > fileloc_column (g_currentloc)) {
2673     c_lval.tok = lltok_create (t, fileloc_copy (g_currentloc));
2674   } else {
2675     c_lval.tok = lltok_create (t, fileloc_decColumn (g_currentloc, s_tokLength));
2676   }
2677
2678   s_tokLength = 0;
2679   return (t);
2680 }
2681
2682 int cscannerHelp_returnTokenLength (int t, int length)
2683 {
2684   cscannerHelp_setTokLength (length);
2685   return cscannerHelp_returnToken (t);
2686 }
2687
2688 int cscannerHelp_returnString (cstring s)
2689 {
2690   c_lval.expr = exprNode_stringLiteral (s, fileloc_decColumn (g_currentloc, s_tokLength));
2691   s_tokLength = 0;
2692   return (CCONSTANT);
2693 }
2694
2695 int cscannerHelp_returnInt (ctype ct, long val)
2696 {
2697   ctype c = ct;
2698
2699   if (ctype_equal (ct, ctype_int))
2700     {
2701       if (val == 0)
2702         {
2703           c = context_typeofZero ();
2704         }
2705       else if (val == 1)
2706         {
2707           c = context_typeofOne ();
2708         }
2709       else
2710         {
2711           ;
2712         }
2713     }
2714
2715   c_lval.expr = exprNode_numLiteral (c, cstring_fromChars (c_text),
2716                                      fileloc_decColumn (g_currentloc, s_tokLength),
2717                                      val);
2718   s_tokLength = 0;
2719   return (CCONSTANT);
2720 }
2721
2722 int cscannerHelp_returnFloat (ctype ct, double f)
2723 {
2724   c_lval.expr = exprNode_floatLiteral (f, ct, cstring_fromChars (c_text),
2725                                        fileloc_decColumn (g_currentloc, s_tokLength));
2726   s_tokLength = 0;
2727   return (CCONSTANT);
2728 }
2729
2730 int cscannerHelp_returnChar (char c)
2731 {
2732   c_lval.expr = exprNode_charLiteral (c, cstring_fromChars (c_text),
2733                                       fileloc_decColumn (g_currentloc, s_tokLength));
2734   s_tokLength = 0;
2735   return (CCONSTANT);
2736 }
2737
2738 int cscannerHelp_returnType (int tok, ctype ct)
2739 {
2740   c_lval.ctyp = ct;
2741   s_tokLength = 0;
2742   return tok;
2743 }
2744
2745 int cscannerHelp_returnExpr (exprNode e)
2746 {
2747   c_lval.expr = e;
2748   s_tokLength = 0;
2749   return (CCONSTANT);
2750 }
2751
2752 void cscannerHelp_setExpectingTypeName (void)
2753 {
2754   s_expectingTypeName = TRUE;
2755 }
2756
2757 void cscannerHelp_clearExpectingTypeName (void)
2758 {
2759   s_expectingTypeName = FALSE;
2760 }
2761
2762 # ifdef DEADCODE
2763 bool cscannerHelp_isExpectingTypeName (void)
2764 {
2765   return s_expectingTypeName;
2766 }
2767 # endif /* DEADCODE */
2768
2769 int cscannerHelp_processTextIdentifier (char *text)
2770 {
2771   context_saveLocation ();
2772   cscannerHelp_setTokLength (size_toInt (mstring_length (text)));
2773   return cscannerHelp_processIdentifier (cscannerHelp_makeIdentifier (text));
2774 }
2775
2776 static bool s_continueLine = FALSE;
2777
2778 int cscannerHelp_handleNewLine (void)
2779 {
2780   context_incLineno ();
2781
2782   if (s_tokLength != 0) {
2783     s_tokLength = 0;
2784     /* No error to report
2785        voptgenerror
2786        (FLG_SYNTAX,
2787        message ("Likely parse error: token spans multiple lines."),
2788        g_currentloc);
2789     */
2790   }
2791
2792   if (s_continueLine)
2793     {
2794       s_continueLine = FALSE;
2795     }
2796   else
2797     {
2798       if (context_inMacro ())
2799         {
2800           /* Don't use return cscannerHelp_returnToken */
2801           /* !!! evans 2002-03-13 */
2802           c_lval.tok = lltok_create (TENDMACRO, fileloc_copy (g_currentloc));
2803           return TENDMACRO;
2804         }
2805     }
2806
2807   return BADTOK;
2808 }
2809
2810 void cscannerHelp_setContinueLine (void)
2811 {
2812   s_continueLine = TRUE;
2813 }
2814
2815 void cscannerHelp_exitSpecPart (void)
2816 {
2817   llassert (s_inSpecPart);
2818   s_inSpecPart = FALSE;
2819   s_whichSpecPart = BADTOK;
2820 }