Main Page   Alphabetical List   Compound List   File List   Compound Members   File Members  

scanline.c

Go to the documentation of this file.
00001 /*
00002 ** LCLint - annotation-assisted static program checker
00003 ** Copyright (C) 1994-2000 University of Virginia,
00004 **         Massachusetts Institute of Technology
00005 **
00006 ** This program is free software; you can redistribute it and/or modify it
00007 ** under the terms of the GNU General Public License as published by the
00008 ** Free Software Foundation; either version 2 of the License, or (at your
00009 ** option) any later version.
00010 ** 
00011 ** This program is distributed in the hope that it will be useful, but
00012 ** WITHOUT ANY WARRANTY; without even the implied warranty of
00013 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014 ** General Public License for more details.
00015 ** 
00016 ** The GNU General Public License is available from http://www.gnu.org/ or
00017 ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00018 ** MA 02111-1307, USA.
00019 **
00020 ** For information on lclint: lclint-request@cs.virginia.edu
00021 ** To report a bug: lclint-bug@cs.virginia.edu
00022 ** For more information: http://lclint.cs.virginia.edu
00023 */
00024 /*
00025 ** scanline.c
00026 **
00027 ** Scan one line of Larch SL input at a time.
00028 **
00029 **      The input is source text, line at a time.   The output is a sequence
00030 **      of tokens, reported by call-out LSLScanFreshToken.
00031 **
00032 **      This organization allows implementation of line-at-a-time
00033 **      incremental scanning.  The incremental mechanism is in the
00034 **      driving module scan.c, which can save and replay tokens for
00035 **      unchanged lines.  This module works either way.
00036 **
00037 **      The main loop of the scanner keys on the leading character.
00038 **      Actions within the loop collect the token starting with the
00039 **      and determine its kind.
00040 */
00041 
00042 # include "lclintMacros.nf"
00043 # include "llbasic.h"
00044 # include "signature.h"
00045 # include "signature2.h"
00046 # include "scan.h"
00047 # include "scanline.h"
00048 # include "tokentable.h"
00049 # include "syntable.h"
00050 
00051 /*@notfunction@*/
00052 # define MOVECHAR()   do { *bufptr++ = c; c = *currentLine++; colNumber++; } while (FALSE) 
00053 
00054 /*@constant static int MAXCHAR;@*/
00055 # define MAXCHAR 512      
00056 
00057 /*@constant static int TABSIZE;@*/
00058 # define TABSIZE 8      
00059 
00060 static void LocalUserError (/*@temp@*/ char *p_msg);
00061 
00062 static charClassData charClass[LASTCHAR + 1];
00063 
00064 static unsigned int colNumber; 
00065 static unsigned int startCol;   
00066 static bool reportEOL;          
00067 static bool reportComments;     
00068 
00069 static char tokenBuffer[MAXCHAR];
00070 
00071 static const charClassData charClassDef[] =
00072 {
00073   /* Control characters                                  */
00074 
00075   { CHC_NULL, TRUE },      /*  0 NULL            */
00076   { SINGLECHAR, FALSE },        /*  1 CTRL-A             */
00077   { SINGLECHAR, FALSE },        /*  2 CTRL-B             */
00078   { SINGLECHAR, FALSE },        /*  3 CTRL-C             */
00079   { SINGLECHAR, FALSE },        /*  4 CTRL-D             */
00080   { SINGLECHAR, FALSE },        /*  5 CTRL-E             */
00081   { SINGLECHAR, FALSE },        /*  6 CTRL-F             */
00082   { SINGLECHAR, FALSE },        /*  7 CTRL-G             */
00083   { SINGLECHAR, FALSE },        /*  8 CTRL-H             */
00084 
00085   /* defined formatting characters                       */
00086 
00087   { WHITECHAR, FALSE },         /*  9 CTRL-I   TAB       */
00088   { WHITECHAR, TRUE },          /* 10 CTRL-J   EOL       */
00089 
00090   /* more control characters                             */
00091 
00092   { SINGLECHAR, FALSE },        /* 11 CTRL-K             */
00093   { SINGLECHAR, FALSE },        /* 12 CTRL-L             */
00094   { SINGLECHAR, FALSE },        /* 13 CTRL-M             */
00095   { SINGLECHAR, FALSE },        /* 14 CTRL-N             */
00096   { SINGLECHAR, FALSE },        /* 15 CTRL-O             */
00097   { SINGLECHAR, FALSE },        /* 16 CTRL-P             */
00098   { SINGLECHAR, FALSE },        /* 17 CTRL-Q             */
00099   { SINGLECHAR, FALSE },        /* 18 CTRL-R             */
00100   { SINGLECHAR, FALSE },        /* 19 CTRL-S             */
00101   { SINGLECHAR, FALSE },        /* 20 CTRL-T             */
00102   { SINGLECHAR, FALSE },        /* 21 CTRL-U             */
00103   { SINGLECHAR, FALSE },        /* 22 CTRL-V             */
00104   { SINGLECHAR, FALSE },        /* 23 CTRL-W             */
00105   { SINGLECHAR, FALSE },        /* 24 CTRL-X             */
00106   { SINGLECHAR, FALSE },        /* 25 CTRL-Y             */
00107   { SINGLECHAR, FALSE },        /* 26 CTRL-Z             */
00108   { SINGLECHAR, FALSE },        /* 27 CTRL-[   ESC       */
00109   { SINGLECHAR, FALSE },        /* 28 CTRL-slash         */
00110   { SINGLECHAR, FALSE },        /* 29 CTRL-]   GS        */
00111   { SINGLECHAR, FALSE },        /* 30 CTRL-^   RS        */
00112   { SINGLECHAR, FALSE },        /* 31 CTRL-_   US        */
00113 
00114   /* Special printing characters                         */
00115 
00116   { WHITECHAR, FALSE },         /* 32 space              */
00117   { SINGLECHAR, FALSE },        /* 33 !                  */
00118   { SINGLECHAR, FALSE },        /* 34 "                  */
00119   { SINGLECHAR, FALSE },        /* 35 #                  */
00120   { SINGLECHAR, FALSE },        /* 36 $                  */
00121   { SINGLECHAR, FALSE },        /* 37 %                  */
00122   { SINGLECHAR, FALSE },        /* 38 &                  */
00123   { SINGLECHAR, FALSE },        /* 39 '                  */
00124 
00125   /* Reserved characters                                 */
00126 
00127   { PERMCHAR, FALSE },          /* 40 (                  */
00128   { PERMCHAR, FALSE },          /* 41 )                  */
00129   { OPCHAR, FALSE },            /* 42 *                  */
00130   { OPCHAR, FALSE },            /* 43 +                  */
00131   { PERMCHAR, FALSE },          /* 44 ,                  */
00132   { OPCHAR, FALSE },            /* 45 -                  */
00133   { OPCHAR, FALSE },            /* 46 .                  */
00134   { SLASHCHAR, FALSE },         /* 47 /                  */
00135 
00136   /* Numbers                                             */
00137 
00138   { IDCHAR, FALSE },            /* 48 0                  */
00139   { IDCHAR, FALSE },            /* 49 1                  */
00140   { IDCHAR, FALSE },            /* 50 2                  */
00141   { IDCHAR, FALSE },            /* 51 3                  */
00142   { IDCHAR, FALSE },            /* 52 4                  */
00143   { IDCHAR, FALSE },            /* 53 5                  */
00144   { IDCHAR, FALSE },            /* 54 6                  */
00145   { IDCHAR, FALSE },            /* 55 7                  */
00146   { IDCHAR, FALSE },            /* 56 8                  */
00147   { IDCHAR, FALSE },            /* 57 9                  */
00148 
00149   /* More reserved and special printing characters       */
00150 
00151   { PERMCHAR, FALSE },          /* 58 :                  */
00152   { SINGLECHAR, FALSE },        /* 59;                   */
00153   { OPCHAR, FALSE },            /* 60 <                  */
00154   { OPCHAR, FALSE },            /* 61 =                  */
00155   { OPCHAR, FALSE },            /* 62 >                  */
00156   { SINGLECHAR, FALSE },        /* 63 ?                  */
00157   { SINGLECHAR, FALSE },        /* 64 @                  */
00158 
00159   /* Uppercase Alphabetics                               */
00160 
00161   { IDCHAR, FALSE },            /* 65 A                  */
00162   { IDCHAR, FALSE },            /* 66 B                  */
00163   { IDCHAR, FALSE },            /* 67 C                  */
00164   { IDCHAR, FALSE },            /* 68 D                  */
00165   { IDCHAR, FALSE },            /* 69 E                  */
00166   { IDCHAR, FALSE },            /* 70 F                  */
00167   { IDCHAR, FALSE },            /* 71 G                  */
00168   { IDCHAR, FALSE },            /* 72 H                  */
00169   { IDCHAR, FALSE },            /* 73 I                  */
00170   { IDCHAR, FALSE },            /* 74 J                  */
00171   { IDCHAR, FALSE },            /* 75 K                  */
00172   { IDCHAR, FALSE },            /* 76 L                  */
00173   { IDCHAR, FALSE },            /* 77 M                  */
00174   { IDCHAR, FALSE },            /* 78 N                  */
00175   { IDCHAR, FALSE },            /* 79 O                  */
00176   { IDCHAR, FALSE },            /* 80 P                  */
00177   { IDCHAR, FALSE },            /* 81 Q                  */
00178   { IDCHAR, FALSE },            /* 82 R                  */
00179   { IDCHAR, FALSE },            /* 83 S                  */
00180   { IDCHAR, FALSE },            /* 84 T                  */
00181   { IDCHAR, FALSE },            /* 85 U                  */
00182   { IDCHAR, FALSE },            /* 86 V                  */
00183   { IDCHAR, FALSE },            /* 87 W                  */
00184   { IDCHAR, FALSE },            /* 88 X                  */
00185   { IDCHAR, FALSE },            /* 89 Y                  */
00186   { IDCHAR, FALSE },            /* 90 Z                  */
00187 
00188   /* Still more reserved and special printing characters */
00189 
00190   { SINGLECHAR, FALSE },        /* 91 [                  */
00191   { CHC_EXTENSION, FALSE },     /* 92 slash              */
00192   { SINGLECHAR, FALSE },        /* 93 ]                  */
00193   { SINGLECHAR, FALSE },        /* 94 ^                  */
00194   { IDCHAR, FALSE },            /* 95 _                  */
00195   { SINGLECHAR, FALSE },        /* 96 `                  */
00196   
00197   /* Lowercase alphabetics                               */
00198 
00199   { IDCHAR, FALSE },            /* 97 a                  */
00200   { IDCHAR, FALSE },            /* 98 b                  */
00201   { IDCHAR, FALSE },            /* 99 c                  */
00202   { IDCHAR, FALSE },            /* 100 d                 */
00203   { IDCHAR, FALSE },            /* 101 e                 */
00204   { IDCHAR, FALSE },            /* 102 f                 */
00205   { IDCHAR, FALSE },            /* 103 g                 */
00206   { IDCHAR, FALSE },            /* 104 h                 */
00207   { IDCHAR, FALSE },            /* 105 i                 */
00208   { IDCHAR, FALSE },            /* 106 j                 */
00209   { IDCHAR, FALSE },            /* 107 k                 */
00210   { IDCHAR, FALSE },            /* 108 l                 */
00211   { IDCHAR, FALSE },            /* 109 m                 */
00212   { IDCHAR, FALSE },            /* 110 n                 */
00213   { IDCHAR, FALSE },            /* 111 o                 */
00214   { IDCHAR, FALSE },            /* 112 p                 */
00215   { IDCHAR, FALSE },            /* 113 q                 */
00216   { IDCHAR, FALSE },            /* 114 r                 */
00217   { IDCHAR, FALSE },            /* 115 s                 */
00218   { IDCHAR, FALSE },            /* 116 t                 */
00219   { IDCHAR, FALSE },            /* 117 u                 */
00220   { IDCHAR, FALSE },            /* 118 v                 */
00221   { IDCHAR, FALSE },            /* 119 w                 */
00222   { IDCHAR, FALSE },            /* 120 x                 */
00223   { IDCHAR, FALSE },            /* 121 y                 */
00224   { IDCHAR, FALSE },            /* 122 z                 */
00225 
00226   { SINGLECHAR, FALSE },        /* 123 {                 */
00227   { SINGLECHAR, FALSE },        /* 124 |                 */
00228   { SINGLECHAR, FALSE },        /* 125 }                 */
00229   { SINGLECHAR, FALSE },        /* 126 ~                 */
00230   { SINGLECHAR, FALSE },        /* 127 DEL               */
00231 
00232   /* MCS - unused in English                             */
00233 
00234   { SINGLECHAR, FALSE },        /* 128                   */
00235   { SINGLECHAR, FALSE },        /* 129                   */
00236   { SINGLECHAR, FALSE },        /* 130                   */
00237   { SINGLECHAR, FALSE },        /* 131                   */
00238   { SINGLECHAR, FALSE },        /* 132                   */
00239   { SINGLECHAR, FALSE },        /* 133                   */
00240   { SINGLECHAR, FALSE },        /* 134                   */
00241   { SINGLECHAR, FALSE },        /* 135                   */
00242   { SINGLECHAR, FALSE },        /* 136                   */
00243   { SINGLECHAR, FALSE },        /* 137                   */
00244   { SINGLECHAR, FALSE },        /* 138                   */
00245   { SINGLECHAR, FALSE },        /* 139                   */
00246   { SINGLECHAR, FALSE },        /* 140                   */
00247   { SINGLECHAR, FALSE },        /* 141                   */
00248   { SINGLECHAR, FALSE },        /* 142                   */
00249   { SINGLECHAR, FALSE },        /* 143                   */
00250   { SINGLECHAR, FALSE },        /* 144                   */
00251   { SINGLECHAR, FALSE },        /* 145                   */
00252   { SINGLECHAR, FALSE },        /* 146                   */
00253   { SINGLECHAR, FALSE },        /* 147                   */
00254   { SINGLECHAR, FALSE },        /* 148                   */
00255   { SINGLECHAR, FALSE },        /* 149                   */
00256   { SINGLECHAR, FALSE },        /* 150                   */
00257   { SINGLECHAR, FALSE },        /* 151                   */
00258   { SINGLECHAR, FALSE },        /* 152                   */
00259   { SINGLECHAR, FALSE },        /* 153                   */
00260   { SINGLECHAR, FALSE },        /* 154                   */
00261   { SINGLECHAR, FALSE },        /* 155                   */
00262   { SINGLECHAR, FALSE },        /* 156                   */
00263   { SINGLECHAR, FALSE },        /* 157                   */
00264   { SINGLECHAR, FALSE },        /* 158                   */
00265   { SINGLECHAR, FALSE },        /* 159                   */
00266   { SINGLECHAR, FALSE },        /* 160                   */
00267   { SINGLECHAR, FALSE },        /* 161                   */
00268   { SINGLECHAR, FALSE },        /* 162                   */
00269   { SINGLECHAR, FALSE },        /* 163                   */
00270   { SINGLECHAR, FALSE },        /* 164                   */
00271   { SINGLECHAR, FALSE },        /* 165                   */
00272   { SINGLECHAR, FALSE },        /* 166                   */
00273   { SINGLECHAR, FALSE },        /* 167                   */
00274   { SINGLECHAR, FALSE },        /* 168                   */
00275   { SINGLECHAR, FALSE },        /* 169                   */
00276   { SINGLECHAR, FALSE },        /* 170                   */
00277   { SINGLECHAR, FALSE },        /* 171                   */
00278   { SINGLECHAR, FALSE },        /* 172                   */
00279   { SINGLECHAR, FALSE },        /* 173                   */
00280   { SINGLECHAR, FALSE },        /* 174                   */
00281   { SINGLECHAR, FALSE },        /* 175                   */
00282   { SINGLECHAR, FALSE },        /* 176                   */
00283   { SINGLECHAR, FALSE },        /* 177                   */
00284   { SINGLECHAR, FALSE },        /* 178                   */
00285   { SINGLECHAR, FALSE },        /* 179                   */
00286   { SINGLECHAR, FALSE },        /* 180                   */
00287   { SINGLECHAR, FALSE },        /* 181                   */
00288   { SINGLECHAR, FALSE },        /* 182                   */
00289   { SINGLECHAR, FALSE },        /* 183                   */
00290   { SINGLECHAR, FALSE },        /* 184                   */
00291   { SINGLECHAR, FALSE },        /* 185                   */
00292   { SINGLECHAR, FALSE },        /* 186                   */
00293   { SINGLECHAR, FALSE },        /* 187                   */
00294   { SINGLECHAR, FALSE },        /* 188                   */
00295   { SINGLECHAR, FALSE },        /* 189                   */
00296   { SINGLECHAR, FALSE },        /* 190                   */
00297   { SINGLECHAR, FALSE },        /* 191                   */
00298   { SINGLECHAR, FALSE },        /* 192                   */
00299   { SINGLECHAR, FALSE },        /* 193                   */
00300   { SINGLECHAR, FALSE },        /* 194                   */
00301   { SINGLECHAR, FALSE },        /* 195                   */
00302   { SINGLECHAR, FALSE },        /* 196                   */
00303   { SINGLECHAR, FALSE },        /* 197                   */
00304   { SINGLECHAR, FALSE },        /* 198                   */
00305   { SINGLECHAR, FALSE },        /* 199                   */
00306   { SINGLECHAR, FALSE },        /* 200                   */
00307   { SINGLECHAR, FALSE },        /* 201                   */
00308   { SINGLECHAR, FALSE },        /* 202                   */
00309   { SINGLECHAR, FALSE },        /* 203                   */
00310   { SINGLECHAR, FALSE },        /* 204                   */
00311   { SINGLECHAR, FALSE },        /* 205                   */
00312   { SINGLECHAR, FALSE },        /* 206                   */
00313   { SINGLECHAR, FALSE },        /* 207                   */
00314   { SINGLECHAR, FALSE },        /* 208                   */
00315   { SINGLECHAR, FALSE },        /* 209                   */
00316   { SINGLECHAR, FALSE },        /* 210                   */
00317   { SINGLECHAR, FALSE },        /* 211                   */
00318   { SINGLECHAR, FALSE },        /* 212                   */
00319   { SINGLECHAR, FALSE },        /* 213                   */
00320   { SINGLECHAR, FALSE },        /* 214                   */
00321   { SINGLECHAR, FALSE },        /* 215                   */
00322   { SINGLECHAR, FALSE },        /* 216                   */
00323   { SINGLECHAR, FALSE },        /* 217                   */
00324   { SINGLECHAR, FALSE },        /* 218                   */
00325   { SINGLECHAR, FALSE },        /* 219                   */
00326   { SINGLECHAR, FALSE },        /* 220                   */
00327   { SINGLECHAR, FALSE },        /* 221                   */
00328   { SINGLECHAR, FALSE },        /* 222                   */
00329   { SINGLECHAR, FALSE },        /* 223                   */
00330   { SINGLECHAR, FALSE },        /* 224                   */
00331   { SINGLECHAR, FALSE },        /* 225                   */
00332   { SINGLECHAR, FALSE },        /* 226                   */
00333   { SINGLECHAR, FALSE },        /* 227                   */
00334   { SINGLECHAR, FALSE },        /* 228                   */
00335   { SINGLECHAR, FALSE },        /* 229                   */
00336   { SINGLECHAR, FALSE },        /* 230                   */
00337   { SINGLECHAR, FALSE },        /* 231                   */
00338   { SINGLECHAR, FALSE },        /* 232                   */
00339   { SINGLECHAR, FALSE },        /* 233                   */
00340   { SINGLECHAR, FALSE },        /* 234                   */
00341   { SINGLECHAR, FALSE },        /* 235                   */
00342   { SINGLECHAR, FALSE },        /* 236                   */
00343   { SINGLECHAR, FALSE },        /* 237                   */
00344   { SINGLECHAR, FALSE },        /* 238                   */
00345   { SINGLECHAR, FALSE },        /* 239                   */
00346   { SINGLECHAR, FALSE },        /* 240                   */
00347   { SINGLECHAR, FALSE },        /* 241                   */
00348   { SINGLECHAR, FALSE },        /* 242                   */
00349   { SINGLECHAR, FALSE },        /* 243                   */
00350   { SINGLECHAR, FALSE },        /* 244                   */
00351   { SINGLECHAR, FALSE },        /* 245                   */
00352   { SINGLECHAR, FALSE },        /* 246                   */
00353   { SINGLECHAR, FALSE },        /* 247                   */
00354   { SINGLECHAR, FALSE },        /* 248                   */
00355   { SINGLECHAR, FALSE },        /* 249                   */
00356   { SINGLECHAR, FALSE },        /* 250                   */
00357   { SINGLECHAR, FALSE },        /* 251                   */
00358   { SINGLECHAR, FALSE },        /* 252                   */
00359   { SINGLECHAR, FALSE },        /* 253                   */
00360   { SINGLECHAR, FALSE },        /* 254                   */
00361   { SINGLECHAR, FALSE }         /* 255                   */
00362 };
00363 
00364 /*
00365 **++
00366 **  FUNCTION NAME:
00367 **
00368 **      lscanline ()
00369 **
00370 **  FORMAL PARAMETERS:
00371 **
00372 **      None
00373 **
00374 **  RETURN VALUE:
00375 **
00376 **      None
00377 **
00378 **  INVARIANTS:
00379 **
00380 **      [@description or none@]
00381 **
00382 **  DESCRIPTION:
00383 **
00384 **      One line of text is processed.
00385 **      Tokens are delivered via the call LSLScanFreshToken ().
00386 **
00387 **  EXCEPTIONS:
00388 **
00389 **--
00390 */
00391 
00392 void
00393 lscanLine (char *currentLine)
00394 {
00395   ltokenCode cod;        
00396   lsymbol sym;          
00397   register char c;      
00398   register char *bufptr;
00399   ltoken newToken;      
00400 
00401   c = *currentLine++;   
00402   colNumber = 0;        
00403 
00404   for (;;)
00405     {                   
00406       bufptr = &tokenBuffer[0]; 
00407       startCol = colNumber;     
00408 
00409       /*@-loopswitchbreak@*/
00410       switch (lscanCharClass (c))
00411         {                       
00412 
00413         case CHC_NULL:  
00414           sym = lsymbol_fromChars ("E O L");
00415           cod = LST_EOL;
00416           break;
00417           
00418          /* Identifiers */
00419 
00420         case IDCHAR:
00421 
00422           while (lscanCharClass (c) == IDCHAR)
00423             {                   
00424               MOVECHAR ();
00425             }
00426 
00427           *bufptr = '\0';       
00428           sym = lsymbol_fromChars (&tokenBuffer[0]);
00429           cod = LST_SIMPLEID;
00430           break;
00431 
00432          /* One-character tokens */
00433 
00434         case SINGLECHAR:
00435         case PERMCHAR:          
00436           MOVECHAR ();
00437           *bufptr = '\0';       
00438           sym = lsymbol_fromChars (&tokenBuffer[0]);
00439           cod = LST_SIMPLEOP;
00440           break;
00441 
00442         case SLASHCHAR:
00443           if (*currentLine == '\\')
00444             {
00445               MOVECHAR ();
00446               MOVECHAR ();
00447               *bufptr = '\0';
00448               sym = lsymbol_fromChars (&tokenBuffer[0]);
00449               cod = LST_SIMPLEOP;
00450               break;
00451             }
00452           MOVECHAR ();
00453           /* We fall through to next case if we have / followed  */
00454           /* by anything else.                                   */
00455           /*@fallthrough@*/
00456         case OPCHAR: 
00457 
00458          /* Operator symbols */
00459 
00460          /* possible multi character */
00461           while (lscanCharClass (c) == OPCHAR)
00462             {                   
00463               MOVECHAR ();
00464             }
00465 
00466           *bufptr = '\0';       /* null terminate in buffer */
00467           sym = lsymbol_fromChars (&tokenBuffer[0]);
00468           cod = LST_SIMPLEOP;
00469           break;
00470 
00471          /* White space */
00472         case WHITECHAR:
00473           /*@-switchswitchbreak@*/
00474           switch (c)
00475             {
00476             case '\t':
00477               MOVECHAR ();
00478               colNumber--;
00479               colNumber += TABSIZE;
00480               colNumber -= (colNumber % TABSIZE);
00481               break;
00482 
00483             case '\v':
00484             case '\f':
00485               MOVECHAR ();
00486               colNumber--;
00487               break;
00488 
00489             default:
00490               MOVECHAR ();
00491               break;
00492             }
00493           *bufptr = '\0';       
00494           sym = lsymbol_fromChars (&tokenBuffer[0]);
00495           cod = LST_WHITESPACE;
00496           break;
00497 
00498         case CHC_EXTENSION:     
00499           MOVECHAR ();
00500 
00501           switch (c)
00502             {                   
00503 
00504              /* open and close */
00505             case '(':           
00506               MOVECHAR ();
00507               while (lscanCharClass (c) == IDCHAR)
00508                 {               
00509                   MOVECHAR ();
00510                 }
00511               *bufptr = '\0';   
00512               sym = lsymbol_fromChars (&tokenBuffer[0]);
00513               cod = LST_OPENSYM;
00514               break;
00515 
00516             case ')':           
00517               MOVECHAR ();
00518               while (lscanCharClass (c) == IDCHAR)
00519                 {               
00520                   MOVECHAR ();
00521                 }
00522               *bufptr = '\0';   
00523               sym = lsymbol_fromChars (&tokenBuffer[0]);
00524               cod = LST_CLOSESYM;
00525               break;
00526 
00527              /* separator */
00528             case ',':           
00529               MOVECHAR ();
00530               while (lscanCharClass (c) == IDCHAR)
00531                 {               
00532                   MOVECHAR ();
00533                 }
00534               *bufptr = '\0';   
00535               sym = lsymbol_fromChars (&tokenBuffer[0]);
00536               cod = LST_SEPSYM;
00537               break;
00538 
00539               /* simpleid */
00540             case ':':           
00541               MOVECHAR ();
00542               while (lscanCharClass (c) == IDCHAR)
00543                 {               
00544                   MOVECHAR ();
00545                 }
00546               *bufptr = '\0';   
00547               sym = lsymbol_fromChars (&tokenBuffer[0]);
00548               cod = LST_SIMPLEID;
00549               break;
00550 
00551             default:            
00552               if (lscanCharClass (c) == IDCHAR)
00553                 {
00554                   do
00555                     {
00556                       MOVECHAR ();
00557                     }
00558                   while (lscanCharClass (c) == IDCHAR);
00559                   *bufptr = '\0';
00560                   sym = lsymbol_fromChars (&tokenBuffer[0]);
00561                   cod = LST_SIMPLEOP;
00562                 }
00563               else
00564                 {
00565                   /*
00566                   ** Meets none of the above.  Take the extension           
00567                   ** character and the character following and treat        
00568                   ** together as a SINGLECHAR.  SINGLECHARs tranlate into 
00569                   ** SIMPLEOPs.                                     
00570                   */
00571 
00572                   MOVECHAR ();
00573                   *bufptr = '\0';       
00574                   sym = lsymbol_fromChars (&tokenBuffer[0]);
00575                   cod = LST_SIMPLEOP;
00576                 }
00577               break;
00578             }
00579           /*@switchbreak@*/ break;      
00580           /*@=switchswitchbreak@*/
00581         default:
00582 
00583           LocalUserError ("unexpected character in input");
00584           return;
00585         }
00586       /*@=loopswitchbreak@*/
00587 
00588       /*
00589       ** Above code only "guessed" at token type.  Insert it into the    
00590       ** TokenTable.  If the token already exists, it is returned as
00591       ** previously defined.  If it does not exist, it is inserted as the 
00592       ** token code computed above.
00593       */
00594 
00595       newToken = LSLInsertToken (cod, sym, 0, FALSE);
00596 
00597       if (LSLIsSyn (ltoken_getText (newToken)))
00598         {
00599           /* 
00600           ** Token is a synonym.  Get the actual token and set the raw    
00601           ** text to the synonym name.                              
00602           */
00603 
00604           newToken = LSLGetTokenForSyn (ltoken_getText (newToken));
00605           ltoken_setRawText (newToken, sym);
00606         }
00607 
00608       ltoken_setCol (newToken, startCol);
00609       ltoken_setLine (newToken, tsource_thisLineNumber (LSLScanSource ()));
00610       ltoken_setFileName (newToken, tsource_fileName (LSLScanSource ()));
00611       
00612       if (ltoken_getCode (newToken) == LST_COMMENTSYM)
00613         {
00614           bufptr = &tokenBuffer[0];
00615 
00616           while (!LSLIsEndComment (c))
00617             {
00618               MOVECHAR ();
00619             }
00620           if (lscanCharClass (c) != CHC_NULL)
00621             {
00622               MOVECHAR ();
00623             }
00624           if (reportComments)
00625             {
00626               *bufptr = '\0';
00627               ltoken_setRawText (newToken, lsymbol_fromChars (&tokenBuffer[0]));
00628               LSLScanFreshToken (newToken);
00629             }
00630         }
00631       else if (ltoken_getCode (newToken) == LST_EOL)
00632         {
00633           if (reportEOL)
00634             {
00635               LSLScanFreshToken (newToken);
00636             }
00637           return;
00638         }
00639       else 
00640         {
00641           if (cod != LST_WHITESPACE)
00642             {
00643               LSLScanFreshToken (newToken);
00644             }
00645         }
00646     }
00647 }
00648 
00649 ltoken
00650 LSLScanEofToken (void)
00651 {
00652   ltoken t = ltoken_copy (LSLInsertToken (LEOFTOKEN, 
00653                                           lsymbol_fromChars ("E O F"),
00654                                           0, TRUE));
00655   ltoken_setCol (t, colNumber);
00656   ltoken_setLine (t, tsource_thisLineNumber (LSLScanSource ()));
00657   ltoken_setFileName (t, tsource_fileName (LSLScanSource ()));
00658   return t;
00659 }
00660 
00661 void
00662 LSLReportEolTokens (bool setting)
00663 {
00664   reportEOL = setting;
00665 }
00666 
00667 static void
00668   LocalUserError (char *msg)
00669 {
00670   tsource *s = LSLScanSource ();
00671   llfatalerror (message ("%s:%u,%u: %s", 
00672                          cstring_fromChars (tsource_fileName (s)), 
00673                          tsource_thisLineNumber (s), colNumber, 
00674                          cstring_fromChars (msg)));
00675 }
00676 
00677 /*
00678 **++
00679 **  FUNCTION NAME:
00680 **
00681 **      lscanLineInit ()
00682 **
00683 **  FORMAL PARAMETERS:
00684 **
00685 **      None
00686 **
00687 **  RETURN VALUE:
00688 **
00689 **      None
00690 **
00691 **  INVARIANTS:
00692 **
00693 **      [@description or none@]
00694 **
00695 **  DESCRIPTION:
00696 **
00697 **      Initialize this module (should only be called once).
00698 **
00699 **  IMPLICIT INPUTS/OUTPUT:
00700 **
00701 **      GetNextLine - (output) initialized
00702 **      NullToken   - (output) initialized
00703 **      PrintName   - (output) array contents initialized
00704 **
00705 **  EXCEPTIONS:
00706 **
00707 **      None
00708 **--
00709 */
00710 
00711 void
00712 lscanLineInit (void)
00713 {
00714   int i;
00715 
00716   reportEOL = FALSE;
00717   reportComments = FALSE;
00718 
00719   for (i = 0; i <= LASTCHAR; i++)
00720     {
00721       charClass[i] = charClassDef[i];
00722     }
00723 
00724  /*
00725  ** NOTE: The following line ensures that all tokens have nonzero
00726  ** handles, so that a handle of zero can be used to indicate that a
00727  ** token does not have a synonym.
00728  */
00729 
00730   (void) LSLReserveToken (LST_SIMPLEID, "dummy token");
00731 
00732   ltoken_forall = LSLReserveToken (LST_QUANTIFIERSYM, "\\forall");
00733   ltoken_true = LSLReserveToken (LST_SIMPLEID, "true");
00734   ltoken_false = LSLReserveToken (LST_SIMPLEID, "false");
00735   ltoken_not = LSLReserveToken (LST_SIMPLEOP, "\\not");
00736   ltoken_and = LSLReserveToken (LST_LOGICALOP, "\\and");
00737   ltoken_or = LSLReserveToken (LST_LOGICALOP, "\\or");
00738   ltoken_implies = LSLReserveToken (LST_LOGICALOP, "\\implies");
00739 
00740   ltoken_eq = LSLReserveToken (LST_EQOP, "\\eq");
00741   ltoken_neq = LSLReserveToken (LST_EQOP, "\\neq");
00742 
00743   ltoken_equals = LSLReserveToken (LST_EQUATIONSYM, "\\equals");
00744   ltoken_eqsep = LSLReserveToken (LST_EQSEPSYM, "\\eqsep");
00745   ltoken_select = LSLReserveToken (LST_SELECTSYM, "\\select");
00746   ltoken_open = LSLReserveToken (LST_OPENSYM, "\\open");
00747   ltoken_sep = LSLReserveToken (LST_SEPSYM, "\\,");
00748   ltoken_close = LSLReserveToken (LST_CLOSESYM, "\\close");
00749   ltoken_id = LSLReserveToken (LST_SIMPLEID, "\\:");
00750   ltoken_arrow = LSLReserveToken (LST_MAPSYM, "\\arrow");
00751   ltoken_farrow = LSLReserveToken (LST_FIELDMAPSYM, "\\field_arrow");
00752 
00753   ltoken_marker = LSLReserveToken (LST_MARKERSYM, "\\marker");
00754   ltoken_comment = LSLReserveToken (LST_COMMENTSYM, "\\comment");
00755   ltoken_compose = LSLReserveToken (LST_COMPOSESYM, "\\composeSort");
00756   ltoken_if = LSLReserveToken (LST_ifTOKEN, "if");
00757 
00758   (void) LSLReserveToken (LST_LPAR, "(");
00759   (void) LSLReserveToken (LST_RPAR, ")");
00760   (void) LSLReserveToken (LST_COMMA, ",");
00761   (void) LSLReserveToken (LST_COLON, ":");
00762 
00763   (void) LSLReserveToken (LST_LBRACKET, "[");
00764   (void) LSLReserveToken (LST_RBRACKET, "]");
00765 
00766   (void) LSLReserveToken (LST_WHITESPACE, " ");
00767   (void) LSLReserveToken (LST_WHITESPACE, "\t");
00768   (void) LSLReserveToken (LST_WHITESPACE, "\n");
00769 
00770   (void) LSLReserveToken (LEOFTOKEN, "E O F");
00771   (void) LSLReserveToken (LST_EOL, "E O L");
00772 
00773   (void) LSLReserveToken (LST_assertsTOKEN, "asserts");
00774   (void) LSLReserveToken (LST_assumesTOKEN, "assumes");
00775   (void) LSLReserveToken (LST_byTOKEN, "by");
00776   (void) LSLReserveToken (LST_convertsTOKEN, "converts");
00777   (void) LSLReserveToken (LST_elseTOKEN, "else");
00778   (void) LSLReserveToken (LST_enumerationTOKEN, "enumeration");
00779   (void) LSLReserveToken (LST_equationsTOKEN, "equations");
00780   (void) LSLReserveToken (LST_exemptingTOKEN, "exempting");
00781   (void) LSLReserveToken (LST_forTOKEN, "for");
00782   (void) LSLReserveToken (LST_generatedTOKEN, "generated");
00783   (void) LSLReserveToken (LST_impliesTOKEN, "implies");
00784   (void) LSLReserveToken (LST_includesTOKEN, "includes");
00785   (void) LSLReserveToken (LST_introducesTOKEN, "introduces");
00786   (void) LSLReserveToken (LST_ofTOKEN, "of");
00787   (void) LSLReserveToken (LST_partitionedTOKEN, "partitioned");
00788   (void) LSLReserveToken (LST_thenTOKEN, "then");
00789   (void) LSLReserveToken (LST_traitTOKEN, "trait");
00790   (void) LSLReserveToken (LST_tupleTOKEN, "tuple");
00791   (void) LSLReserveToken (LST_unionTOKEN, "union");
00792 }
00793 
00794 void
00795 lscanLineReset (void)
00796 {
00797 }
00798 
00799 void
00800 lscanLineCleanup (void)
00801 {
00802 }
00803 
00804 charCode lscanCharClass (char c)
00805 {
00806   return charClass[(int)(c)].code;
00807 }
00808 
00809 bool LSLIsEndComment (char c)
00810 {
00811   return charClass[(int)(c)].endCommentChar;
00812 }
00813 
00814 void lsetCharClass (char c, charCode cod)
00815 {
00816   charClass[(int)(c)].code = cod;
00817 }
00818 
00819 void lsetEndCommentChar (char c, bool flag)
00820 {
00821   charClass[(int)(c)].endCommentChar = flag;
00822 }
Generated at Fri Nov 3 18:57:43 2000 for LCLint by doxygen1.2.3 written by Dimitri van Heesch, © 1997-2000