src/lslinit.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 ** lslinit.c
  26 **
  27 ** Processor for Larch Shared Language Init Files
  28 */
  29
  30 # include "splintMacros.nf"
  31 # include "basic.h"
  32
  33 # include "lslgrammar.h"
  34 # include "lslscan.h"
  35 # include "lslscanline.h"
  36 # include "lsltokentable.h"
  37 # include "lslsyntable.h"
  38 # include "lslinit.h"
  39
  40 # include "lclinit.h"
  41 # include "lclscan.h"
  42 # include "lclscanline.h"
  43 # include "lclsyntable.h"
  44 # include "lcltokentable.h"
  45
  46 /* needed to parse init files */
  47 # include "shift.h"
  48
  49 #define TRACING 0
  50 #if TRACING == 1
  51 /*@notfunction@*/
  52 # define LTRACE(rule) printf ("Reducing: %s\n", rule)
  53 #else
  54 /*@notfunction@*/
  55 # define LTRACE(rule)
  56 #endif
  57
  58 static void LocalUserError (ltoken p_t, /*@temp@*/ char *p_msg)
  59   /*@modifies *g_warningstream@*/;
  60
  61 static /*@only@*/ ltoken nextToken;
  62
  63 static /*@only@*/ /*@null@*/ inputStream s_initFile = inputStream_undefined;
  64
  65 static void InitFile (void) /*@modifies nextToken@*/ ;
  66 static void InitLines (void) /*@modifies nextToken@*/ ;
  67 static void InitLine (void) /*@modifies nextToken@*/ ;
  68 static void Classification (void) /*@modifies nextToken@*/ ;
  69 static void CharClass (void) /*@modifies nextToken@*/ ;
  70
  71 static void EndCommentChars (void) /*@modifies nextToken@*/ ;
  72 static void IdChars (void) /*@modifies nextToken@*/ ;
  73 static void OpChars (void) /*@modifies nextToken@*/ ;
  74 static void ExtensionChar (void) /*@modifies nextToken@*/ ;
  75 static void SingChars (void) /*@modifies nextToken@*/ ;
  76 static void WhiteChars (void) /*@modifies nextToken@*/ ;
  77 static void EndCommentChar (void) /*@modifies nextToken@*/ ;
  78 static void IdChar (void) /*@modifies nextToken@*/ ;
  79 static void OpChar (void) /*@modifies nextToken@*/ ;
  80 static void SingChar (void) /*@modifies nextToken@*/ ;
  81 static void WhiteChar (void) /*@modifies nextToken@*/ ;
  82
  83 static void TokenClass (void) /*@modifies nextToken@*/ ;
  84 static void QuantifierSymToks (void) /*@modifies nextToken@*/ ;
  85 static void LogicalOpToks (void) /*@modifies nextToken@*/ ;
  86 static void EqOpToks (void) /*@modifies nextToken@*/ ;
  87 static void EquationSymToks (void) /*@modifies nextToken@*/ ;
  88 static void EqSepSymToks (void) /*@modifies nextToken@*/ ;
  89 static void SelectSymToks (void) /*@modifies nextToken@*/ ;
  90 static void OpenSymToks (void) /*@modifies nextToken@*/ ;
  91 static void SepSymToks (void) /*@modifies nextToken@*/ ;
  92 static void CloseSymToks (void) /*@modifies nextToken@*/ ;
  93 static void SimpleIdToks (void) /*@modifies nextToken@*/ ;
  94 static void MapSymToks (void) /*@modifies nextToken@*/ ;
  95 static void MarkerSymToks (void) /*@modifies nextToken@*/ ;
  96 static void CommentSymToks (void) /*@modifies nextToken@*/ ;
  97 static void QuantifierSymTok (void) /*@modifies nextToken@*/ ;
  98 static void LogicalOpTok (void) /*@modifies nextToken@*/ ;
  99 static void EqOpTok (void) /*@modifies nextToken@*/ ;
 100 static void EquationSymTok (void) /*@modifies nextToken@*/ ;
 101 static void EqSepSymTok (void) /*@modifies nextToken@*/ ;
 102 static void SelectSymTok (void) /*@modifies nextToken@*/ ;
 103 static void OpenSymTok (void) /*@modifies nextToken@*/ ;
 104 static void SepSymTok (void) /*@modifies nextToken@*/ ;
 105 static void CloseSymTok (void) /*@modifies nextToken@*/ ;
 106 static void SimpleIdTok (void) /*@modifies nextToken@*/ ;
 107 static void MapSymTok (void) /*@modifies nextToken@*/ ;
 108 static void MarkerSymTok (void) /*@modifies nextToken@*/ ;
 109 static void CommentSymTok (void) /*@modifies nextToken@*/ ;
 110 static void SynClass (void) /*@modifies nextToken@*/ ;
 111 static void OldToken (void) /*@modifies nextToken@*/ ;
 112 static void NewToken (void) /*@modifies nextToken@*/ ;
 113 static void Token (void) /*@modifies nextToken@*/ ;
 114
 115 static void InitReduce (LSLInitRuleCode p_rule) /*@modifies nextToken@*/ ;
 116 static void UpdateXCharKeywords (charCode) /*@modifies nextToken@*/ ;
 117 static void ProcessExtensionChar (void) /*@modifies nextToken@*/ ;
 118 static void ProcessEndCommentChar (void) /*@modifies nextToken@*/ ;
 119 static void ProcessSingleChar (charCode p_code) /*@modifies nextToken@*/ ;
 120 static void ProcessToken (ltokenCode p_code) /*@modifies nextToken@*/ ;
 121 static void ProcessSynonym (void) /*@modifies nextToken@*/ ;
 122
 123 /* If TRUE character has been redefined as a singleChar. */
 124 static bool defineSingleChar[LASTCHAR + 1];
 125
 126 static charCode currentExtensionChar;
 127
 128 /* LSL init file keyword tokens.  */
 129
 130 static /*@dependent@*/ ltoken endCommentCharToken;
 131 static /*@dependent@*/ ltoken idCharToken;
 132 static /*@dependent@*/ ltoken opCharToken;
 133 static /*@dependent@*/ ltoken extensionCharToken;
 134 static /*@dependent@*/ ltoken singleCharToken;
 135 static /*@dependent@*/ ltoken whiteCharToken;
 136 static /*@dependent@*/ ltoken quantifierSymToken;
 137 static /*@dependent@*/ ltoken logicalOpToken;
 138 static /*@dependent@*/ ltoken eqOpToken;
 139 static /*@dependent@*/ ltoken equationSymToken;
 140 static /*@dependent@*/ ltoken eqSepSymToken;
 141 static /*@dependent@*/ ltoken selectSymToken;
 142 static /*@dependent@*/ ltoken openSymToken;
 143 static /*@dependent@*/ ltoken sepSymToken;
 144 static /*@dependent@*/ ltoken closeSymToken;
 145 static /*@dependent@*/ ltoken simpleIdToken;
 146 static /*@dependent@*/ ltoken mapSymToken;
 147 static /*@dependent@*/ ltoken markerSymToken;
 148 static /*@dependent@*/ ltoken commentSymToken;
 149 static /*@dependent@*/ ltoken synonymToken;
 150
 151 static bool
 152 hasFirstChar (ltoken tok)
 153 {
 154   return (ltoken_isChar (tok)
 155           && lscanCharClass (cstring_firstChar (ltoken_unparse (tok))) == SINGLECHAR);
 156 }
 157
 158 void
 159 lslinit_setInitFile (inputStream s)
 160 {
 161   llassert (inputStream_isUndefined (s_initFile));
 162   s_initFile = s;
 163 }
 164
 165 /*
 166 **
 167 **  Parsing functions for init file processing, in the same order as the
 168 **  grammar file lslinit.cfg.  This is top-down order, as much as possible.
 169 **
 170 */
 171
 172 static void lslinit_processInitFile (void)
 173 {
 174   InitLines ();
 175   InitReduce (INITFILE1);
 176
 177   if (ltoken_getCode (nextToken) != LEOFTOKEN)
 178     {
 179       LocalUserError (nextToken, "unexpected tokens after end-of-file");
 180     }
 181 }
 182
 183 static void
 184 InitLines (void)
 185 {
 186   InitReduce (INITLINES1);
 187
 188   if (ltoken_getCode (nextToken) != LEOFTOKEN)
 189     {
 190       InitLine ();
 191       InitReduce (INITLINES2);
 192     }
 193
 194   while (ltoken_getCode (nextToken) != LEOFTOKEN)
 195     {
 196       InitLine ();
 197       InitReduce (INITLINES3);
 198     }
 199
 200 }
 201
 202 static void
 203 InitLine (void)
 204 {
 205   if (ltoken_getCode (nextToken) == LST_EOL)
 206     {
 207      /* Nothing on line. */
 208       InitReduce (INITLINE1);
 209     }
 210   else
 211     {
 212       Classification ();
 213       InitReduce (INITLINE2);
 214     }
 215
 216   if (ltoken_getCode (nextToken) != LST_EOL)
 217     {
 218       LocalUserError (nextToken, "Unexpected tokens on line");
 219     }
 220
 221   ltoken_free (nextToken);
 222   nextToken = LSLScanNextToken ();
 223 }
 224
 225 static void
 226 Classification (void)
 227 {
 228   if (ltoken_getRawText (nextToken) == ltoken_getText (endCommentCharToken)
 229       || ltoken_getRawText (nextToken) == ltoken_getText (idCharToken)
 230       || ltoken_getRawText (nextToken) == ltoken_getText (opCharToken)
 231       || ltoken_getRawText (nextToken) == ltoken_getText (extensionCharToken)
 232       || ltoken_getRawText (nextToken) == ltoken_getText (singleCharToken)
 233       || ltoken_getRawText (nextToken) == ltoken_getText (whiteCharToken))
 234     {
 235       CharClass ();
 236       InitReduce (CLASSIFICATION1);
 237     }
 238   else if (ltoken_getRawText (nextToken) == ltoken_getText (quantifierSymToken)
 239            || ltoken_getRawText (nextToken) == ltoken_getText (logicalOpToken)
 240            || ltoken_getRawText (nextToken) == ltoken_getText (eqOpToken)
 241            || ltoken_getRawText (nextToken) == ltoken_getText (equationSymToken)
 242            || ltoken_getRawText (nextToken) == ltoken_getText (eqSepSymToken)
 243            || ltoken_getRawText (nextToken) == ltoken_getText (selectSymToken)
 244            || ltoken_getRawText (nextToken) == ltoken_getText (openSymToken)
 245            || ltoken_getRawText (nextToken) == ltoken_getText (sepSymToken)
 246            || ltoken_getRawText (nextToken) == ltoken_getText (closeSymToken)
 247            || ltoken_getRawText (nextToken) == ltoken_getText (simpleIdToken)
 248            || ltoken_getRawText (nextToken) == ltoken_getText (mapSymToken)
 249            || ltoken_getRawText (nextToken) == ltoken_getText (markerSymToken)
 250            || ltoken_getRawText (nextToken) == ltoken_getText (commentSymToken))
 251     {
 252       TokenClass ();
 253       InitReduce (CLASSIFICATION2);
 254     }
 255   else if (ltoken_getRawText (nextToken) == ltoken_getText (synonymToken))
 256     {
 257       SynClass ();
 258       InitReduce (CLASSIFICATION3);
 259     }
 260   else
 261     {
 262       LocalUserError (nextToken,
 263                       "expected character, token, or synonym classification");
 264     }
 265 }
 266
 267 static void
 268 CharClass (void)
 269 {
 270   ltoken charClassToken;
 271
 272   charClassToken = nextToken;
 273
 274   nextToken = LSLScanNextToken ();              /* Discard char class keyword. */
 275
 276   if (ltoken_getRawText (charClassToken) == ltoken_getText (endCommentCharToken))
 277     {
 278       EndCommentChars ();
 279       InitReduce (CHARCLASS1);
 280     }
 281   else if (ltoken_getRawText (charClassToken) == ltoken_getText (idCharToken))
 282     {
 283       IdChars ();
 284       InitReduce (CHARCLASS2);
 285     }
 286   else if (ltoken_getRawText (charClassToken) == ltoken_getText (opCharToken))
 287     {
 288       OpChars ();
 289       InitReduce (CHARCLASS3);
 290     }
 291   else if (ltoken_getRawText (charClassToken)
 292            == ltoken_getText (extensionCharToken))
 293     {
 294       ExtensionChar ();
 295       InitReduce (CHARCLASS4);
 296     }
 297   else if (ltoken_getRawText (charClassToken) == ltoken_getText (singleCharToken))
 298     {
 299       SingChars ();
 300       InitReduce (CHARCLASS5);
 301     }
 302   else if (ltoken_getRawText (charClassToken) == ltoken_getText (whiteCharToken))
 303     {
 304       WhiteChars ();
 305       InitReduce (CHARCLASS6);
 306     }
 307   else
 308     {
 309       LocalUserError (nextToken, "expected character classification");
 310     }
 311
 312   ltoken_free (charClassToken);
 313 }
 314
 315 static void
 316 EndCommentChars (void)
 317 {
 318   EndCommentChar ();
 319   InitReduce (LRC_ENDCOMMENT1);
 320
 321   while (ltoken_getCode (nextToken) != LST_EOL)
 322     {
 323       EndCommentChar ();
 324       InitReduce (LRC_ENDCOMMENT2);
 325     }
 326
 327 }
 328
 329 static void
 330 IdChars (void)
 331 {
 332   IdChar ();
 333   InitReduce (IDCHARS1);
 334
 335   while (ltoken_getCode (nextToken) != LST_EOL)
 336     {
 337       IdChar ();
 338       InitReduce (IDCHARS2);
 339     }
 340 }
 341
 342 static void
 343 OpChars (void)
 344 {
 345   OpChar ();
 346   InitReduce (OPCHARS1);
 347
 348   while (ltoken_getCode (nextToken) != LST_EOL)
 349     {
 350       OpChar ();
 351       InitReduce (OPCHARS2);
 352     }
 353 }
 354
 355 static void
 356 ExtensionChar (void)
 357 {
 358   if (ltoken_isChar (nextToken)
 359       && lscanCharClass (cstring_firstChar (ltoken_unparse (nextToken))) == SINGLECHAR)
 360     {
 361       LSLGenShiftOnly (nextToken);
 362       nextToken = LSLScanNextToken ();
 363       InitReduce (LRC_EXTENSIONCHAR1);
 364     }
 365   else
 366     {
 367       LocalUserError (nextToken, "expected only one character");
 368     }
 369 }
 370
 371 static void
 372 SingChars (void)
 373 {
 374   SingChar ();
 375   InitReduce (SINGCHARS1);
 376
 377   while (ltoken_getCode (nextToken) != LST_EOL)
 378     {
 379       SingChar ();
 380       InitReduce (SINGCHARS2);
 381     }
 382 }
 383
 384 static void
 385 WhiteChars (void)
 386 {
 387   WhiteChar ();
 388   InitReduce (WHITECHARS1);
 389
 390   while (ltoken_getCode (nextToken) != LST_EOL)
 391     {
 392       WhiteChar ();
 393       InitReduce (WHITECHARS2);
 394     }
 395 }
 396
 397 static void
 398 EndCommentChar (void)
 399 {
 400   if (ltoken_isChar (nextToken))
 401     {
 402       LSLGenShiftOnly (nextToken);
 403       nextToken = LSLScanNextToken ();
 404       InitReduce (LRC_ENDCOMMENTCHAR1);
 405     }
 406   else
 407     {
 408       LocalUserError (nextToken, "expected only one character");
 409     }
 410 }
 411
 412 static void
 413 IdChar (void)
 414 {
 415   if (hasFirstChar (nextToken))
 416     {
 417       LSLGenShiftOnly (nextToken);
 418       nextToken = LSLScanNextToken ();
 419       InitReduce (IDCHAR1);
 420     }
 421   else
 422     {
 423       LocalUserError (nextToken, "character is already defined, cannot redefine");
 424     }
 425 }
 426
 427 static void
 428 OpChar (void)
 429 {
 430   if (hasFirstChar (nextToken))
 431     {
 432       LSLGenShiftOnly (nextToken);
 433       nextToken = LSLScanNextToken ();
 434       InitReduce (OPCHAR1);
 435     }
 436   else
 437     {
 438       LocalUserError (nextToken, "character is already defined, cannot redefine");
 439     }
 440 }
 441
 442 static void
 443 SingChar (void)
 444 {
 445   if (hasFirstChar (nextToken))
 446     {
 447       LSLGenShiftOnly (nextToken);
 448       nextToken = LSLScanNextToken ();
 449       InitReduce (SINGCHAR1);
 450     }
 451   else
 452     {
 453       LocalUserError (nextToken, "character is already defined, cannot redefine");
 454     }
 455 }
 456
 457 static void
 458 WhiteChar (void)
 459 {
 460   if (hasFirstChar (nextToken))
 461     {
 462       LSLGenShiftOnly (nextToken);
 463       nextToken = LSLScanNextToken ();
 464       InitReduce (WHITECHAR1);
 465     }
 466   else
 467     {
 468       LocalUserError (nextToken, "character is already defined, cannot redefine");
 469     }
 470 }
 471
 472 static void
 473 TokenClass (void)
 474 {
 475   ltoken tokenClassToken;
 476
 477   tokenClassToken = nextToken;
 478
 479   nextToken = LSLScanNextToken ();
 480
 481   if (ltoken_getRawText (tokenClassToken) == ltoken_getText (quantifierSymToken))
 482     {
 483       QuantifierSymToks ();
 484       InitReduce (TOKENCLASS1);
 485     }
 486   else if (ltoken_getRawText (tokenClassToken) == ltoken_getText (logicalOpToken))
 487     {
 488       LogicalOpToks ();
 489       InitReduce (TOKENCLASS2);
 490     }
 491   else if (ltoken_getRawText (tokenClassToken) == ltoken_getText (eqOpToken))
 492     {
 493       EqOpToks ();
 494       InitReduce (TOKENCLASS3);
 495     }
 496   else if (ltoken_getRawText (tokenClassToken)
 497            == ltoken_getText (equationSymToken))
 498     {
 499       EquationSymToks ();
 500       InitReduce (TOKENCLASS4);
 501     }
 502   else if (ltoken_getRawText (tokenClassToken) == ltoken_getText (eqSepSymToken))
 503     {
 504       EqSepSymToks ();
 505       InitReduce (TOKENCLASS5);
 506     }
 507   else if (ltoken_getRawText (tokenClassToken) == ltoken_getText (selectSymToken))
 508     {
 509       SelectSymToks ();
 510       InitReduce (TOKENCLASS6);
 511     }
 512   else if (ltoken_getRawText (tokenClassToken) == ltoken_getText (openSymToken))
 513     {
 514       OpenSymToks ();
 515       InitReduce (TOKENCLASS7);
 516     }
 517   else if (ltoken_getRawText (tokenClassToken) == ltoken_getText (sepSymToken))
 518     {
 519       SepSymToks ();
 520       InitReduce (TOKENCLASS8);
 521     }
 522   else if (ltoken_getRawText (tokenClassToken) == ltoken_getText (closeSymToken))
 523     {
 524       CloseSymToks ();
 525       InitReduce (TOKENCLASS9);
 526     }
 527   else if (ltoken_getRawText (tokenClassToken) == ltoken_getText (simpleIdToken))
 528     {
 529       SimpleIdToks ();
 530       InitReduce (TOKENCLASS10);
 531     }
 532   else if (ltoken_getRawText (tokenClassToken) == ltoken_getText (mapSymToken))
 533     {
 534       MapSymToks ();
 535       InitReduce (TOKENCLASS11);
 536     }
 537   else if (ltoken_getRawText (tokenClassToken) == ltoken_getText (markerSymToken))
 538     {
 539       MarkerSymToks ();
 540       InitReduce (TOKENCLASS12);
 541     }
 542   else if (ltoken_getRawText (tokenClassToken)
 543            == ltoken_getText (commentSymToken))
 544     {
 545       CommentSymToks ();
 546       InitReduce (TOKENCLASS13);
 547     }
 548   else
 549     {
 550       LocalUserError (nextToken, "expected token classification");
 551     }
 552
 553   ltoken_free (tokenClassToken);
 554 }
 555
 556 static void
 557 QuantifierSymToks (void)
 558 {
 559   QuantifierSymTok ();
 560   InitReduce (QUANTIFIERSYMTOKS1);
 561
 562   while (ltoken_getCode (nextToken) != LST_EOL)
 563     {
 564       QuantifierSymTok ();
 565       InitReduce (QUANTIFIERSYMTOKS2);
 566     }
 567 }
 568
 569 static void
 570 LogicalOpToks (void)
 571 {
 572   LogicalOpTok ();
 573   InitReduce (LOGICALOPTOKS1);
 574
 575   while (ltoken_getCode (nextToken) != LST_EOL)
 576     {
 577       LogicalOpTok ();
 578       InitReduce (LOGICALOPTOKS2);
 579     }
 580 }
 581
 582 static void
 583 EqOpToks (void)
 584 {
 585   EqOpTok ();
 586   InitReduce (LRC_EQOPTOKS1);
 587
 588   while (ltoken_getCode (nextToken) != LST_EOL)
 589     {
 590       EqOpTok ();
 591       InitReduce (LRC_EQOPTOKS2);
 592     }
 593 }
 594
 595 static void
 596 EquationSymToks (void)
 597 {
 598   EquationSymTok ();
 599   InitReduce (LRC_EQUATIONSYMTOKS1);
 600
 601   while (ltoken_getCode (nextToken) != LST_EOL)
 602     {
 603       EquationSymTok ();
 604       InitReduce (LRC_EQUATIONSYMTOKS2);
 605     }
 606 }
 607
 608 static void
 609 EqSepSymToks (void)
 610 {
 611   EqSepSymTok ();
 612   InitReduce (LRC_EQSEPSYMTOKS1);
 613
 614   while (ltoken_getCode (nextToken) != LST_EOL)
 615     {
 616       EqSepSymTok ();
 617       InitReduce (LRC_EQSEPSYMTOKS2);
 618     }
 619 }
 620
 621 static void
 622 SelectSymToks (void)
 623 {
 624   SelectSymTok ();
 625   InitReduce (SELECTSYMTOKS1);
 626
 627   while (ltoken_getCode (nextToken) != LST_EOL)
 628     {
 629       SelectSymTok ();
 630       InitReduce (SELECTSYMTOKS2);
 631     }
 632 }
 633
 634 static void
 635 OpenSymToks (void)
 636 {
 637   OpenSymTok ();
 638   InitReduce (OPENSYMTOKS1);
 639
 640   while (ltoken_getCode (nextToken) != LST_EOL)
 641     {
 642       OpenSymTok ();
 643       InitReduce (OPENSYMTOKS2);
 644     }
 645 }
 646
 647 static void
 648 SepSymToks (void)
 649 {
 650   SepSymTok ();
 651   InitReduce (SEPSYMTOKS1);
 652
 653   while (ltoken_getCode (nextToken) != LST_EOL)
 654     {
 655       SepSymTok ();
 656       InitReduce (SEPSYMTOKS2);
 657     }
 658 }
 659
 660 static void
 661 CloseSymToks (void)
 662 {
 663   CloseSymTok ();
 664   InitReduce (CLOSESYMTOKS1);
 665
 666   while (ltoken_getCode (nextToken) != LST_EOL)
 667     {
 668       CloseSymTok ();
 669       InitReduce (CLOSESYMTOKS2);
 670     }
 671 }
 672
 673 static void
 674 SimpleIdToks (void)
 675 {
 676   SimpleIdTok ();
 677   InitReduce (SIMPLEIDTOKS1);
 678
 679   while (ltoken_getCode (nextToken) != LST_EOL)
 680     {
 681       SimpleIdTok ();
 682       InitReduce (SIMPLEIDTOKS2);
 683     }
 684 }
 685
 686 static void
 687 MapSymToks (void)
 688 {
 689   MapSymTok ();
 690   InitReduce (MAPSYMTOKS1);
 691
 692   while (ltoken_getCode (nextToken) != LST_EOL)
 693     {
 694       MapSymTok ();
 695       InitReduce (MAPSYMTOKS2);
 696     }
 697 }
 698
 699 static void
 700 MarkerSymToks (void)
 701 {
 702   MarkerSymTok ();
 703   InitReduce (MARKERSYMTOKS1);
 704
 705   while (ltoken_getCode (nextToken) != LST_EOL)
 706     {
 707       MarkerSymTok ();
 708       InitReduce (MARKERSYMTOKS2);
 709     }
 710 }
 711
 712 static void
 713 CommentSymToks (void)
 714 {
 715   CommentSymTok ();
 716   InitReduce (COMMENTSYMTOKS1);
 717
 718   while (ltoken_getCode (nextToken) != LST_EOL)
 719     {
 720       CommentSymTok ();
 721       InitReduce (COMMENTSYMTOKS2);
 722     }
 723 }
 724
 725 static void
 726 QuantifierSymTok (void)
 727 {
 728   Token ();
 729   InitReduce (QUANTIFIERSYMTOK1);
 730 }
 731
 732 static void
 733 LogicalOpTok (void)
 734 {
 735   Token ();
 736   InitReduce (LOGICALOPTOK1);
 737 }
 738
 739 static void
 740 EqOpTok (void)
 741 {
 742   Token ();
 743   InitReduce (LRC_EQOPTOK1);
 744 }
 745
 746 static void
 747 EquationSymTok (void)
 748 {
 749  /* ### EquationSymTok (); ### */
 750   Token ();
 751   InitReduce (LRC_EQUATIONSYMTOK1);
 752 }
 753
 754 static void
 755 EqSepSymTok (void)
 756 {
 757   Token ();
 758   InitReduce (LRC_EQSEPSYMTOK1);
 759
 760 }
 761
 762 static void
 763 SelectSymTok (void)
 764 {
 765   Token ();
 766   InitReduce (SELECTSYMTOK1);
 767 }
 768
 769 static void
 770 OpenSymTok (void)
 771 {
 772   Token ();
 773   InitReduce (OPENSYMTOK1);
 774 }
 775
 776 static void
 777 SepSymTok (void)
 778 {
 779   Token ();
 780   InitReduce (SEPSYMTOK1);
 781 }
 782
 783 static void
 784 CloseSymTok (void)
 785 {
 786   Token ();
 787   InitReduce (CLOSESYMTOK1);
 788 }
 789
 790 static void
 791 SimpleIdTok (void)
 792 {
 793   Token ();
 794   InitReduce (SIMPLEIDTOK1);
 795 }
 796
 797 static void
 798 MapSymTok (void)
 799 {
 800   Token ();
 801   InitReduce (MAPSYMTOK1);
 802 }
 803
 804 static void
 805 MarkerSymTok (void)
 806 {
 807   Token ();
 808   InitReduce (MARKERSYMTOK1);
 809
 810 }
 811
 812 static void
 813 CommentSymTok (void)
 814 {
 815   Token ();
 816   InitReduce (COMMENTSYMTOK1);
 817 }
 818
 819
 820 static void
 821 SynClass (void)
 822 {
 823   if (ltoken_getRawText (nextToken) == ltoken_getText (synonymToken))
 824     {
 825       ltoken_free (nextToken);
 826       nextToken = LSLScanNextToken ();
 827
 828       OldToken ();
 829       NewToken ();
 830
 831       InitReduce (SYNCLASS1);
 832     }
 833   else
 834     {
 835       LocalUserError (nextToken, "expected synonym classification");
 836     }
 837
 838 }
 839
 840 static void
 841 OldToken (void)
 842 {
 843   Token ();
 844   InitReduce (OLDTOKEN1);
 845
 846 }
 847
 848 static void
 849 NewToken (void)
 850 {
 851   Token ();
 852   InitReduce (NEWTOKEN1);
 853
 854 }
 855
 856 static void
 857 Token (void)
 858 {
 859   if (ltoken_getCode (nextToken) == LST_EOL
 860       || ltoken_getCode (nextToken) == LEOFTOKEN)
 861     {
 862       LocalUserError (nextToken, "unexpected end-of-line or end-of-file");
 863     }
 864   else
 865     {
 866       LSLGenShiftOnly (nextToken);
 867       nextToken = LSLScanNextToken ();
 868     }
 869 }
 870
 871 /*
 872 ** Init File Processing Routines, these routines use the shift-reduce sequence
 873 ** produced by the init file parser and update the necessary tables for the
 874 ** scanner.
 875 **
 876 ** The same shift stack is used that LSL parser uses.  A different reduce
 877 ** procedure is used because the init file grammar is different from the LSL
 878 ** grammar.
 879 **
 880 */
 881
 882 static void
 883 InitReduce (LSLInitRuleCode rule)
 884 {
 885   switch (rule)
 886     {
 887       case INITFILE1:
 888       LTRACE ("INITFILE1");
 889       break;
 890
 891     case INITLINES1:
 892       LTRACE ("INITLINES1");
 893       break;
 894
 895     case INITLINES2:
 896       LTRACE ("INITLINES2");
 897       break;
 898
 899     case INITLINES3:
 900       LTRACE ("INITLINES3");
 901       break;
 902
 903     case INITLINE1:
 904       LTRACE ("INITLINE1");
 905       break;
 906
 907     case INITLINE2:
 908       LTRACE ("INITLINE2");
 909       break;
 910
 911     case CLASSIFICATION1:
 912       LTRACE ("CLASSIFICATION1");
 913       break;
 914
 915     case CLASSIFICATION2:
 916       LTRACE ("CLASSIFICATION2");
 917       break;
 918
 919     case CLASSIFICATION3:
 920       LTRACE ("CLASSIFICATION3");
 921       break;
 922
 923     case CHARCLASS1:
 924       LTRACE ("CHARCLASS1");
 925       break;
 926
 927     case CHARCLASS2:
 928       LTRACE ("CHARCLASS2");
 929       break;
 930
 931     case CHARCLASS3:
 932       LTRACE ("CHARCLASS3");
 933       break;
 934
 935     case CHARCLASS4:
 936       LTRACE ("CHARCLASS4");
 937       break;
 938
 939     case CHARCLASS5:
 940       LTRACE ("CHARCLASS5");
 941       break;
 942
 943     case CHARCLASS6:
 944       LTRACE ("CHARCLASS6");
 945       break;
 946
 947     case LRC_ENDCOMMENT1:
 948       LTRACE ("LRC_ENDCOMMENT1");
 949       break;
 950
 951     case LRC_ENDCOMMENT2:
 952       LTRACE ("LRC_ENDCOMMENT2");
 953       break;
 954
 955     case IDCHARS1:
 956       LTRACE ("IDCHARS1");
 957       break;
 958
 959     case IDCHARS2:
 960       LTRACE ("IDCHARS2");
 961       break;
 962
 963     case OPCHARS1:
 964       LTRACE ("OPCHARS1");
 965       break;
 966
 967     case OPCHARS2:
 968       LTRACE ("OPCHARS2");
 969       break;
 970
 971     case LRC_EXTENSIONCHAR1:
 972       LTRACE ("LRC_EXTENSIONCHAR1");
 973       ProcessExtensionChar ();
 974       break;
 975
 976     case SINGCHARS1:
 977       LTRACE ("SINGCHARS1");
 978       break;
 979
 980     case SINGCHARS2:
 981       LTRACE ("SINGCHARS2");
 982       break;
 983
 984     case WHITECHARS1:
 985       LTRACE ("WHITECHARS1");
 986       break;
 987
 988     case WHITECHARS2:
 989       LTRACE ("WHITECHARS2");
 990       break;
 991
 992     case LRC_ENDCOMMENTCHAR1:
 993       LTRACE ("LRC_ENDCOMMENTCHAR1");
 994       ProcessEndCommentChar ();
 995       break;
 996
 997     case IDCHAR1:
 998       LTRACE ("IDCHAR1");
 999       ProcessSingleChar (IDCHAR);
1000       break;
1001
1002     case OPCHAR1:
1003       LTRACE ("OPCHAR1");
1004       ProcessSingleChar (OPCHAR);
1005       break;
1006
1007     case SINGCHAR1:
1008       LTRACE ("SINGCHAR1");
1009       ProcessSingleChar (SINGLECHAR);
1010       break;
1011
1012     case WHITECHAR1:
1013       LTRACE ("CHAR1");
1014       ProcessSingleChar (WHITECHAR);
1015       break;
1016
1017     case TOKENCLASS1:
1018       LTRACE ("TOKENCLASS1");
1019       break;
1020
1021     case TOKENCLASS2:
1022       LTRACE ("TOKENCLASS2");
1023       break;
1024
1025     case TOKENCLASS3:
1026       LTRACE ("TOKENCLASS3");
1027       break;
1028
1029     case TOKENCLASS4:
1030       LTRACE ("TOKENCLASS4");
1031       break;
1032
1033     case TOKENCLASS5:
1034       LTRACE ("TOKENCLASS5");
1035       break;
1036
1037     case TOKENCLASS6:
1038       LTRACE ("TOKENCLASS6");
1039       break;
1040
1041     case TOKENCLASS7:
1042       LTRACE ("TOKENCLASS7");
1043       break;
1044
1045     case TOKENCLASS8:
1046       LTRACE ("TOKENCLASS8");
1047       break;
1048
1049     case TOKENCLASS9:
1050       LTRACE ("TOKENCLASS9");
1051       break;
1052
1053     case TOKENCLASS10:
1054       LTRACE ("TOKENCLASS10");
1055       break;
1056
1057     case TOKENCLASS11:
1058       LTRACE ("TOKENCLASS11");
1059       break;
1060
1061     case TOKENCLASS12:
1062       LTRACE ("TOKENCLASS12");
1063       break;
1064
1065     case TOKENCLASS13:
1066       LTRACE ("TOKENCLASS13");
1067       break;
1068
1069     case QUANTIFIERSYMTOKS1:
1070       LTRACE ("QUALIFERSYMTOKS1");
1071       break;
1072
1073     case QUANTIFIERSYMTOKS2:
1074       LTRACE ("QUANTIFIERSYMTOKS2");
1075       break;
1076
1077     case LOGICALOPTOKS1:
1078       LTRACE ("LOGICALOPTOKS1");
1079       break;
1080
1081     case LOGICALOPTOKS2:
1082       LTRACE ("LOGICALOPTOKS2");
1083       break;
1084
1085     case LRC_EQOPTOKS1:
1086       LTRACE ("LRC_EQOPTOKS1");
1087       break;
1088
1089     case LRC_EQOPTOKS2:
1090       LTRACE ("LRC_EQOPTOKS2");
1091       break;
1092
1093     case LRC_EQUATIONSYMTOKS1:
1094       LTRACE ("LRC_EQUATIONSYMTOKS1");
1095       break;
1096
1097     case LRC_EQUATIONSYMTOKS2:
1098       LTRACE ("LRC_EQUATIONSYMTOKS2");
1099       break;
1100
1101     case LRC_EQSEPSYMTOKS1:
1102       LTRACE ("LRC_EQSEPSYMTOKS1");
1103       break;
1104
1105     case LRC_EQSEPSYMTOKS2:
1106       LTRACE ("LRC_EQSEPSYMTOKS2");
1107       break;
1108
1109     case SELECTSYMTOKS1:
1110       LTRACE ("SELECTSYMTOKS1");
1111       break;
1112
1113     case SELECTSYMTOKS2:
1114       LTRACE ("SELECTSYMTOKS2");
1115       break;
1116
1117     case OPENSYMTOKS1:
1118       LTRACE ("OPENSYMTOKS1");
1119       break;
1120
1121     case OPENSYMTOKS2:
1122       LTRACE ("OPENSYMTOKS2");
1123       break;
1124
1125     case SEPSYMTOKS1:
1126       LTRACE ("SEPSYMTOKS1");
1127       break;
1128
1129     case SEPSYMTOKS2:
1130       LTRACE ("SEPSYMTOKS2");
1131       break;
1132
1133     case CLOSESYMTOKS1:
1134       LTRACE ("CLOSESYMTOKS1");
1135       break;
1136
1137     case CLOSESYMTOKS2:
1138       LTRACE ("CLOSESYMTOKS2");
1139       break;
1140
1141     case SIMPLEIDTOKS1:
1142       LTRACE ("SIMPLEIDTOKS1");
1143       break;
1144
1145     case SIMPLEIDTOKS2:
1146       LTRACE ("SIMPLEIDTOKS2");
1147       break;
1148
1149     case MAPSYMTOKS1:
1150       LTRACE ("MAPSYMTOKS1");
1151       break;
1152
1153     case MAPSYMTOKS2:
1154       LTRACE ("MAPSYMTOKS2");
1155       break;
1156
1157     case MARKERSYMTOKS1:
1158       LTRACE ("MARKERSYMTOKS1");
1159       break;
1160
1161     case MARKERSYMTOKS2:
1162       LTRACE ("MARKERSYMTOKS2");
1163       break;
1164
1165     case COMMENTSYMTOKS1:
1166       LTRACE ("COMMENTSYMTOKS1");
1167       break;
1168
1169     case COMMENTSYMTOKS2:
1170       LTRACE ("COMMENTSYMTOKS2");
1171       break;
1172
1173     case QUANTIFIERSYMTOK1:
1174       LTRACE ("QUANTIFERSYMTOK1");
1175       ProcessToken (LST_QUANTIFIERSYM);
1176       break;
1177
1178     case LOGICALOPTOK1:
1179       LTRACE ("LOGICALOPTOK1");
1180       ProcessToken (LST_LOGICALOP);
1181       break;
1182
1183     case LRC_EQOPTOK1:
1184       LTRACE ("LRC_EQOPTOK1");
1185       ProcessToken (LST_EQOP);
1186       break;
1187
1188     case LRC_EQUATIONSYMTOK1:
1189       LTRACE ("LRC_EQUATIONSYMTOK1");
1190       ProcessToken (LST_EQUATIONSYM);
1191       break;
1192
1193     case LRC_EQSEPSYMTOK1:
1194       LTRACE ("LRC_EQSEPSYMTOK1");
1195       ProcessToken (LST_EQSEPSYM);
1196       break;
1197
1198     case SELECTSYMTOK1:
1199       LTRACE ("SELECTSYMTOK1");
1200       ProcessToken (LST_SELECTSYM);
1201       break;
1202
1203     case OPENSYMTOK1:
1204       LTRACE ("OPENSYMTOK1");
1205       ProcessToken (LST_OPENSYM);
1206       break;
1207
1208     case SEPSYMTOK1:
1209       LTRACE ("SEPSYMTOK1");
1210       ProcessToken (LST_SEPSYM);
1211       break;
1212
1213     case CLOSESYMTOK1:
1214       LTRACE ("CLOSESYMTOK1");
1215       ProcessToken (LST_CLOSESYM);
1216       break;
1217
1218     case SIMPLEIDTOK1:
1219       LTRACE ("SIMPLEIDTOK1");
1220       ProcessToken (LST_SIMPLEID);
1221       break;
1222
1223     case MAPSYMTOK1:
1224       LTRACE ("MAPSYMTOK1");
1225       ProcessToken (LST_MAPSYM);
1226       break;
1227
1228     case MARKERSYMTOK1:
1229       LTRACE ("MARKERSYMTOK1");
1230       ProcessToken (LST_MARKERSYM);
1231       break;
1232
1233     case COMMENTSYMTOK1:
1234       LTRACE ("COMMENTSYMTOK1");
1235       ProcessToken (LST_COMMENTSYM);
1236       break;
1237
1238     case SYNCLASS1:
1239       LTRACE ("SYNCLASS1");
1240       ProcessSynonym ();
1241       break;
1242
1243     case OLDTOKEN1:
1244       LTRACE ("OLDTOKEN1");
1245       break;
1246
1247     case NEWTOKEN1:
1248       LTRACE ("NEWTOKEN1");
1249       break;
1250
1251     default:
1252       llcontbuglit ("InitReduce: bad switch");
1253       break;
1254
1255     }                           /* end switch       */
1256 }                               /* end InitReduce () */
1257
1258
1259
1260 /* Reset the first character of the predefined extensionChar keywords when  */
1261 /* the extensionChar changes.  e.g. "extensionChar @" changes "forall" to   */
1262 /* "@forall".                                                               */
1263
1264 static void
1265 UpdateXCharKeywords (charCode xCharCode)
1266 {
1267   char xChar = (char) xCharCode;
1268   char *str;
1269
1270   str = ltoken_getTextChars (ltoken_forall);
1271   *str = xChar;
1272
1273   str = ltoken_getTextChars (ltoken_and);
1274   *str = xChar;
1275
1276   str = ltoken_getTextChars (ltoken_or);
1277   *str = xChar;
1278
1279   str = ltoken_getTextChars (ltoken_implies);
1280   *str = xChar;
1281
1282   str = ltoken_getTextChars (ltoken_eq);
1283   *str = xChar;
1284
1285   str = ltoken_getTextChars (ltoken_neq);
1286   *str = xChar;
1287
1288   str = ltoken_getTextChars (ltoken_equals);
1289   *str = xChar;
1290
1291   str = ltoken_getTextChars (ltoken_eqsep);
1292   *str = xChar;
1293
1294   str = ltoken_getTextChars (ltoken_select);
1295   *str = xChar;
1296
1297   str = ltoken_getTextChars (ltoken_open);
1298   *str = xChar;
1299
1300   str = ltoken_getTextChars (ltoken_sep);
1301   *str = xChar;
1302
1303   str = ltoken_getTextChars (ltoken_close);
1304   *str = xChar;
1305
1306   str = ltoken_getTextChars (ltoken_id);
1307   *str = xChar;
1308
1309   str = ltoken_getTextChars (ltoken_arrow);
1310   *str = xChar;
1311
1312   str = ltoken_getTextChars (ltoken_marker);
1313   *str = xChar;
1314
1315   str = ltoken_getTextChars (ltoken_comment);
1316   *str = xChar;
1317
1318 }
1319
1320 /* Different from ProcessCharClass because only allow one extension         */
1321 /* character. Therefore, the present extension character must be set to a   */
1322 /* singleChar.                                                              */
1323
1324 static void
1325 ProcessExtensionChar (void)
1326 {
1327   ltoken stackToken = LSLGenTopPopShiftStack ();
1328   char firstChar = cstring_firstChar (ltoken_unparse (stackToken));
1329
1330   if (!defineSingleChar[(int)firstChar]
1331       && lscanCharClass (firstChar) == SINGLECHAR)
1332     {
1333      /* Is a single character that has not been defined before.     */
1334      /* Can only have one extension char.  Release old one. */
1335       lsetCharClass (firstChar, CHC_EXTENSION);
1336
1337       /* this is a (bogus) type bug! caught by splint */
1338       /* lsetCharClass (currentExtensionChar, SINGLECHAR); */
1339
1340       lsetCharClass ((char) currentExtensionChar, SINGLECHAR);
1341
1342       currentExtensionChar = (charCode) firstChar;
1343       UpdateXCharKeywords (currentExtensionChar);
1344     }
1345   else
1346     {
1347      /* Already redefined.  Don't allow to be redefined. */
1348       LocalUserError (stackToken, "character is already defined, cannot redefine");
1349     }
1350   ltoken_free (stackToken);
1351 }
1352
1353 /* Different from ProcessSingleChar because allow any characters to be      */
1354 /* endCommentChar and also set a different part of the scanner structure.   */
1355
1356 static void
1357 ProcessEndCommentChar (void)
1358 {
1359   ltoken stackToken = LSLGenTopPopShiftStack ();
1360   char firstChar = cstring_firstChar (ltoken_unparse (stackToken));
1361
1362   if (LSLIsEndComment (firstChar))
1363     {
1364       LocalUserError (stackToken,
1365                     "already defined as a endCommentChar, cannot redefine");
1366     }
1367   else
1368     {
1369       lsetEndCommentChar (firstChar, TRUE);
1370     }
1371   ltoken_free (stackToken);
1372 }
1373
1374 static void
1375 ProcessSingleChar (charCode code)
1376 {
1377   ltoken stackToken = LSLGenTopPopShiftStack ();
1378   char firstChar = cstring_firstChar (ltoken_unparse (stackToken));
1379
1380   if (!defineSingleChar[(int)firstChar]
1381       && lscanCharClass (firstChar) == SINGLECHAR)
1382     {
1383       /* Is a single character that has not been defined before.            */
1384       /* It's OK to redefine once. */
1385       lsetCharClass (firstChar, code);
1386       /* OK to mark as a defined singleChar even if not.  Only check        */
1387       /* defineSingleChar[] if defining a singleChar.                       */
1388       defineSingleChar[(int)firstChar] = TRUE;
1389     }
1390   else
1391     {
1392       LocalUserError (stackToken, "character is already defined, cannot redefine");
1393     }
1394   ltoken_free (stackToken);
1395 }
1396
1397 static void
1398 PrintToken (ltoken tok)
1399 {
1400   char *codStr;
1401
1402   switch (ltoken_getCode (tok))
1403     {
1404     case NOTTOKEN:          codStr = "*** NOTTOKEN ***"; break;
1405     case LST_QUANTIFIERSYM: codStr = "QUANTIFIERSYM"; break;
1406     case LST_LOGICALOP:     codStr = "LOGICALOP: "; break;
1407     case LST_SELECTSYM:     codStr = "LST_SELECTSYM"; break;
1408     case LST_OPENSYM:       codStr = "LST_OPENSYM"; break;
1409     case LST_SEPSYM:        codStr = "SEPSYM"; break;
1410     case LST_CLOSESYM:      codStr = "LST_CLOSESYM"; break;
1411     case LST_SIMPLEID:      codStr = "LST_SIMPLEID"; break;
1412     case LST_MAPSYM:        codStr = "MAPSYM"; break;
1413     case LST_MARKERSYM:     codStr = "LST_MARKERSYM"; break;
1414     case LST_COMMENTSYM:    codStr = "COMMENTSYM"; break;
1415     case LST_SIMPLEOP:      codStr = "SIMPLEOP"; break;
1416     case LST_COLON:         codStr = "LST_COLON"; break;
1417     case LST_COMMA:         codStr = "COMMA"; break;
1418     case LST_LBRACKET:      codStr = "LST_LBRACKET"; break;
1419     case LST_LPAR:          codStr = "LST_LPAR"; break;
1420     case LST_RBRACKET:      codStr = "LST_RBRACKET"; break;
1421     case LST_RPAR:          codStr = "LST_RPAR"; break;
1422     case LST_EQOP:          codStr = "LST_EQOP"; break;
1423     case LST_WHITESPACE:    codStr = "WHITESPACE,"; break;
1424     case LST_EOL:           codStr = "LST_EOL"; break;
1425     case LST_elseTOKEN:     codStr = "elseTOKEN"; break;
1426     case LST_ifTOKEN:       codStr = "ifTOKEN"; break;
1427     case LST_thenTOKEN:     codStr = "thenTOKEN"; break;
1428     case LST_BADTOKEN:      codStr = "*** BADTOKEN ***"; break;
1429     case LEOFTOKEN: /* can't reach LEOFTOKEN easily */
1430       codStr = "LEOFTOKEN"; break;
1431     default:
1432       codStr = "*** invalid token code ***";
1433       break;
1434     } /* end switch */
1435
1436   /* only used for debugging */
1437   printf ("%u:%u: Token Code (%u): %s",
1438           ltoken_getLine (tok), ltoken_getCol (tok),
1439           ltoken_getCode (tok), codStr);
1440   if (ltoken_getRawText (tok) != 0)
1441     {
1442       printf (", Token String (%lu): %s\n",
1443               ltoken_getRawText (tok), ltoken_getRawTextChars (tok));
1444     }
1445   else printf ("\n");
1446 }
1447
1448 static void
1449 ProcessToken (ltokenCode code)
1450 {
1451   ltoken stackToken, temp;
1452   lsymbol sym;
1453
1454   stackToken = LSLGenTopPopShiftStack ();
1455   sym = ltoken_getText (stackToken);
1456
1457   if (LSLIsSyn (sym))
1458     {
1459       LocalUserError (stackToken,
1460                       "already defined as a synonym, cannot redefine");
1461     }
1462
1463   /* Get the token from the token table, so can check if the token    */
1464   /* was updated by a previous token.                               */
1465   temp = LSLGetToken (sym);
1466
1467   if (ltoken_isStateDefined (temp))
1468     {
1469       if ((code == LST_OPENSYM && sym == lsymbol_fromChars ("[")) ||
1470           (code == LST_CLOSESYM && sym == lsymbol_fromChars ("]")))
1471         {
1472           /* ignore "openSym [" and "closeSym ]" TokenClass */
1473           ltoken_free (stackToken);
1474           return;
1475         }
1476       else
1477         {
1478           LocalUserError (stackToken, "already defined, cannot redefine");
1479           PrintToken (temp);
1480         }
1481     }
1482
1483   LSLUpdateToken (code, ltoken_getText (stackToken), TRUE);
1484   ltoken_free (stackToken);
1485 }
1486
1487
1488 static void
1489 ProcessSynonym (void)
1490 {
1491   ltoken newtok;
1492   ltoken oldtok;
1493
1494   newtok = LSLGenTopPopShiftStack ();
1495   oldtok = LSLGenTopPopShiftStack ();
1496
1497   if (ltoken_wasSyn (newtok))
1498     {
1499      /* The token has a synonym.  This means that the synonym was in the */
1500      /* init file, so complain about redefining as a synonym again          */
1501       LocalUserError (newtok, "newtok already is a synonym, cannot redefine");
1502     }
1503
1504   if (ltoken_hasSyn (newtok))
1505     {
1506       /*
1507       ** newtok already has a synonym defined for it.  Do not allow
1508       ** synonyms to be chained.
1509       */
1510
1511       LocalUserError (newtok,
1512                       "newtok already has a synonym, cannot chain synonyms");
1513     }
1514
1515   if (ltoken_isStateDefined (newtok))
1516     {
1517       LocalUserError (newtok, "newtok already defined, cannot redefine");
1518     }
1519
1520   LSLAddSyn (ltoken_getText (newtok), ltoken_getText (oldtok));
1521   ltoken_free (oldtok);
1522   ltoken_free (newtok);
1523 }
1524
1525
1526 /*
1527  * Utilities, in alphabetical order
1528  */
1529
1530 static void
1531 LocalUserError (ltoken t, /*@temp@*/ char *msg)
1532 {
1533   lldiagmsg (message ("%s %s in the LSL init file:",
1534                       ltoken_unparse (t), cstring_fromChars (msg)));
1535
1536   ltoken_free (nextToken);
1537   nextToken = LSLScanNextToken ();
1538
1539   while (ltoken_getCode (nextToken) != LST_EOL)
1540     {
1541       ltoken_free (nextToken);
1542       nextToken = LSLScanNextToken ();
1543     }
1544 }
1545
1546 /*
1547 **  Required initialization and cleanup routines
1548 */
1549
1550 static /*@exposed@*/ ltoken insertSimpleToken (char *text)
1551   /*@modifies internalState@*/
1552 {
1553   return (LSLInsertToken (LST_SIMPLEID, lsymbol_fromChars (text), 0, FALSE));
1554 }
1555
1556 static void
1557 lslinit_initProcessInitFile (void)
1558 {
1559   int i;
1560
1561   LSLGenInit (TRUE);            /* parsing LSLinit not LCLinit */
1562
1563   /*
1564   ** Insert the init file keywords into the token table as undefined
1565   ** SIMPLEIDs.  They are defined as simpleIds since they must be treated
1566   ** that way if they do not appear as the first token on a line, and
1567   ** they must be treated that way for the actual LSL parsing. Save the
1568   ** tokens so can recognize as init file keywords when necessary.
1569   */
1570
1571   endCommentCharToken = insertSimpleToken ("endCommentChar");
1572   idCharToken = insertSimpleToken ("idChar");
1573   opCharToken = insertSimpleToken ("opChar");
1574   extensionCharToken = insertSimpleToken ("extensionChar");
1575   singleCharToken = insertSimpleToken ("singleChar");
1576   whiteCharToken = insertSimpleToken ("whiteChar");
1577
1578   quantifierSymToken = insertSimpleToken ("quantifierSym");
1579   logicalOpToken = insertSimpleToken ("logicalOp");
1580   eqOpToken = insertSimpleToken ("eqOp");
1581   equationSymToken = insertSimpleToken ("equationSym");
1582   eqSepSymToken = insertSimpleToken ("eqSepSym");
1583   selectSymToken = insertSimpleToken ("selectSym");
1584   openSymToken = insertSimpleToken ("openSym");
1585   sepSymToken = insertSimpleToken ("sepSym");
1586   closeSymToken = insertSimpleToken ("closeSym");
1587   simpleIdToken = insertSimpleToken ("simpleId");
1588   mapSymToken = insertSimpleToken ("mapSym");
1589   markerSymToken = insertSimpleToken ("markerSym");
1590   commentSymToken = insertSimpleToken ("commentSym");
1591   synonymToken = insertSimpleToken ("synonym");
1592
1593   for (i = 0; i <= LASTCHAR; i++)
1594     {
1595       defineSingleChar[i] = FALSE;
1596     }
1597
1598   /*
1599   ** Record the current extension character so can redefine back to
1600   ** singleChar if a new extension character is redefined.
1601   */
1602
1603   currentExtensionChar = (charCode) CHAREXTENDER;
1604
1605   LSLReportEolTokens (TRUE);
1606   ltoken_free (nextToken);
1607   nextToken = LSLScanNextToken ();
1608 }
1609
1610 void lslinit_process (void)
1611   /*@globals undef g_symtab; @*/
1612   /*@modifies g_symtab, internalState, fileSystem; @*/
1613 {
1614   /*
1615   ** Open init file provided by user, or use the default LCL init file
1616   */
1617
1618   cstring larchpath = context_getLarchPath ();
1619   inputStream initstream = inputStream_undefined;
1620
1621   setCodePoint ();
1622
1623   if (inputStream_isUndefined (s_initFile))
1624     {
1625       s_initFile = inputStream_create (cstring_makeLiteral (INITFILENAME),
1626                                        cstring_makeLiteralTemp (LCLINIT_SUFFIX),
1627                                        FALSE);
1628
1629       if (!inputStream_getPath (larchpath, s_initFile))
1630         {
1631           lldiagmsg (message ("Continuing without LCL init file: %s",
1632                               inputStream_fileName (s_initFile)));
1633         }
1634       else
1635         {
1636           if (!inputStream_open (s_initFile))
1637             {
1638               lldiagmsg (message ("Continuing without LCL init file: %s",
1639                                   inputStream_fileName (s_initFile)));
1640             }
1641         }
1642     }
1643   else
1644     {
1645       if (!inputStream_open (s_initFile))
1646         {
1647           lldiagmsg (message ("Continuing without LCL init file: %s",
1648                               inputStream_fileName (s_initFile)));
1649         }
1650     }
1651
1652   /* Initialize checker */
1653
1654   lsymbol_initMod ();
1655   LCLSynTableInit ();
1656
1657   setCodePoint ();
1658
1659   LCLSynTableReset ();
1660   LCLTokenTableInit ();
1661
1662   setCodePoint ();
1663
1664   LCLScanLineInit ();
1665   setCodePoint ();
1666   LCLScanLineReset ();
1667   setCodePoint ();
1668   LCLScanInit ();
1669
1670   setCodePoint ();
1671
1672   /* need this to initialize LCL checker */
1673
1674   llassert (inputStream_isDefined (s_initFile));
1675   if (inputStream_isOpen (s_initFile))
1676     {
1677       setCodePoint ();
1678
1679       LCLScanReset (s_initFile);
1680       lclinit_initMod ();
1681       lclinit_reset ();
1682
1683       setCodePoint ();
1684       lclinit_process ();
1685       lclinit_cleanup ();
1686
1687       setCodePoint ();
1688       check (inputStream_close (s_initFile));
1689     }
1690
1691   /* Initialize LSL init files, for parsing LSL signatures from LSL */
1692
1693   initstream = inputStream_create (cstring_makeLiteral ("lslinit.lsi"),
1694                                     cstring_makeLiteralTemp (".lsi"),
1695                                     FALSE);
1696
1697   if (!inputStream_getPath (larchpath, initstream))
1698     {
1699       lldiagmsg (message ("Continuing without LSL init file: %s",
1700                           inputStream_fileName (initstream)));
1701     }
1702   else
1703     {
1704       if (!inputStream_open (initstream))
1705         {
1706           lldiagmsg (message ("Continuing without LSL init file: %s",
1707                               inputStream_fileName (initstream)));
1708         }
1709     }
1710
1711   setCodePoint ();
1712   lsynTableInit ();
1713   lsynTableReset ();
1714
1715   setCodePoint ();
1716   ltokenTableInit ();
1717
1718   setCodePoint ();
1719   lscanLineInit ();
1720   lscanLineReset ();
1721   LSLScanInit ();
1722
1723   if (inputStream_isOpen (initstream))
1724     {
1725       setCodePoint ();
1726       LSLScanReset (initstream);
1727       lslinit_initProcessInitFile ();
1728       lslinit_processInitFile ();
1729       check (inputStream_close (initstream));
1730     }
1731
1732   inputStream_free (initstream);
1733
1734   if (lclHadError ())
1735     {
1736       lclplainerror
1737         (cstring_makeLiteral ("LSL init file error.  Attempting to continue."));
1738     }
1739
1740   setCodePoint ();
1741   g_symtab = symtable_new ();
1742
1743   /*
1744   ** sort_init must come after symtab has been initialized
1745   */
1746   sort_init ();
1747   abstract_init ();
1748   setCodePoint ();
1749
1750   /*
1751   ** Equivalent to importing old spec_csupport.lcl
1752   ** define immutable LCL type "bool" and bool constants TRUE and FALSE
1753   ** and initialized them to be equal to LSL's "true" and "false".
1754   **
1755   ** Reads in CTrait.syms (derived from CTrait.lsl) on LARCH_PATH.
1756   */
1757
1758   LCLBuiltins ();
1759   LCLReportEolTokens (FALSE);
1760 }