2 ** Splint - annotation-assisted static program checker
3 ** Copyright (C) 1994-2002 University of Virginia,
4 ** Massachusetts Institute of Technology
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.
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.
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.
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
27 ** Scan one line of Larch SL input at a time.
29 ** The input is source text, line at a time. The output is a sequence
30 ** of tokens, reported by call-out LSLScanFreshToken.
32 ** This organization allows implementation of line-at-a-time
33 ** incremental scanning. The incremental mechanism is in the
34 ** driving module scan.c, which can save and replay tokens for
35 ** unchanged lines. This module works either way.
37 ** The main loop of the scanner keys on the leading character.
38 ** Actions within the loop collect the token starting with the
39 ** and determine its kind.
42 # include "splintMacros.nf"
44 # include "signature.h"
45 # include "signature2.h"
47 # include "scanline.h"
48 # include "tokentable.h"
49 # include "syntable.h"
52 # define MOVECHAR() do { *bufptr++ = c; c = *currentLine++; colNumber++; } while (FALSE)
54 /*@constant static int MAXCHAR;@*/
57 /*@constant static int TABSIZE;@*/
60 static void LocalUserError (/*@temp@*/ char *p_msg);
62 static charClassData charClass[LASTCHAR + 1];
66 static bool reportEOL;
67 static bool reportComments;
69 static char tokenBuffer[MAXCHAR];
71 static const charClassData charClassDef[] =
73 /* Control characters */
75 { CHC_NULL, TRUE }, /* 0 NULL */
76 { SINGLECHAR, FALSE }, /* 1 CTRL-A */
77 { SINGLECHAR, FALSE }, /* 2 CTRL-B */
78 { SINGLECHAR, FALSE }, /* 3 CTRL-C */
79 { SINGLECHAR, FALSE }, /* 4 CTRL-D */
80 { SINGLECHAR, FALSE }, /* 5 CTRL-E */
81 { SINGLECHAR, FALSE }, /* 6 CTRL-F */
82 { SINGLECHAR, FALSE }, /* 7 CTRL-G */
83 { SINGLECHAR, FALSE }, /* 8 CTRL-H */
85 /* defined formatting characters */
87 { WHITECHAR, FALSE }, /* 9 CTRL-I TAB */
88 { WHITECHAR, TRUE }, /* 10 CTRL-J EOL */
90 /* more control characters */
92 { SINGLECHAR, FALSE }, /* 11 CTRL-K */
93 { SINGLECHAR, FALSE }, /* 12 CTRL-L */
94 { SINGLECHAR, FALSE }, /* 13 CTRL-M */
95 { SINGLECHAR, FALSE }, /* 14 CTRL-N */
96 { SINGLECHAR, FALSE }, /* 15 CTRL-O */
97 { SINGLECHAR, FALSE }, /* 16 CTRL-P */
98 { SINGLECHAR, FALSE }, /* 17 CTRL-Q */
99 { SINGLECHAR, FALSE }, /* 18 CTRL-R */
100 { SINGLECHAR, FALSE }, /* 19 CTRL-S */
101 { SINGLECHAR, FALSE }, /* 20 CTRL-T */
102 { SINGLECHAR, FALSE }, /* 21 CTRL-U */
103 { SINGLECHAR, FALSE }, /* 22 CTRL-V */
104 { SINGLECHAR, FALSE }, /* 23 CTRL-W */
105 { SINGLECHAR, FALSE }, /* 24 CTRL-X */
106 { SINGLECHAR, FALSE }, /* 25 CTRL-Y */
107 { SINGLECHAR, FALSE }, /* 26 CTRL-Z */
108 { SINGLECHAR, FALSE }, /* 27 CTRL-[ ESC */
109 { SINGLECHAR, FALSE }, /* 28 CTRL-slash */
110 { SINGLECHAR, FALSE }, /* 29 CTRL-] GS */
111 { SINGLECHAR, FALSE }, /* 30 CTRL-^ RS */
112 { SINGLECHAR, FALSE }, /* 31 CTRL-_ US */
114 /* Special printing characters */
116 { WHITECHAR, FALSE }, /* 32 space */
117 { SINGLECHAR, FALSE }, /* 33 ! */
118 { SINGLECHAR, FALSE }, /* 34 " */
119 { SINGLECHAR, FALSE }, /* 35 # */
120 { SINGLECHAR, FALSE }, /* 36 $ */
121 { SINGLECHAR, FALSE }, /* 37 % */
122 { SINGLECHAR, FALSE }, /* 38 & */
123 { SINGLECHAR, FALSE }, /* 39 ' */
125 /* Reserved characters */
127 { PERMCHAR, FALSE }, /* 40 ( */
128 { PERMCHAR, FALSE }, /* 41 ) */
129 { OPCHAR, FALSE }, /* 42 * */
130 { OPCHAR, FALSE }, /* 43 + */
131 { PERMCHAR, FALSE }, /* 44 , */
132 { OPCHAR, FALSE }, /* 45 - */
133 { OPCHAR, FALSE }, /* 46 . */
134 { SLASHCHAR, FALSE }, /* 47 / */
138 { IDCHAR, FALSE }, /* 48 0 */
139 { IDCHAR, FALSE }, /* 49 1 */
140 { IDCHAR, FALSE }, /* 50 2 */
141 { IDCHAR, FALSE }, /* 51 3 */
142 { IDCHAR, FALSE }, /* 52 4 */
143 { IDCHAR, FALSE }, /* 53 5 */
144 { IDCHAR, FALSE }, /* 54 6 */
145 { IDCHAR, FALSE }, /* 55 7 */
146 { IDCHAR, FALSE }, /* 56 8 */
147 { IDCHAR, FALSE }, /* 57 9 */
149 /* More reserved and special printing characters */
151 { PERMCHAR, FALSE }, /* 58 : */
152 { SINGLECHAR, FALSE }, /* 59; */
153 { OPCHAR, FALSE }, /* 60 < */
154 { OPCHAR, FALSE }, /* 61 = */
155 { OPCHAR, FALSE }, /* 62 > */
156 { SINGLECHAR, FALSE }, /* 63 ? */
157 { SINGLECHAR, FALSE }, /* 64 @ */
159 /* Uppercase Alphabetics */
161 { IDCHAR, FALSE }, /* 65 A */
162 { IDCHAR, FALSE }, /* 66 B */
163 { IDCHAR, FALSE }, /* 67 C */
164 { IDCHAR, FALSE }, /* 68 D */
165 { IDCHAR, FALSE }, /* 69 E */
166 { IDCHAR, FALSE }, /* 70 F */
167 { IDCHAR, FALSE }, /* 71 G */
168 { IDCHAR, FALSE }, /* 72 H */
169 { IDCHAR, FALSE }, /* 73 I */
170 { IDCHAR, FALSE }, /* 74 J */
171 { IDCHAR, FALSE }, /* 75 K */
172 { IDCHAR, FALSE }, /* 76 L */
173 { IDCHAR, FALSE }, /* 77 M */
174 { IDCHAR, FALSE }, /* 78 N */
175 { IDCHAR, FALSE }, /* 79 O */
176 { IDCHAR, FALSE }, /* 80 P */
177 { IDCHAR, FALSE }, /* 81 Q */
178 { IDCHAR, FALSE }, /* 82 R */
179 { IDCHAR, FALSE }, /* 83 S */
180 { IDCHAR, FALSE }, /* 84 T */
181 { IDCHAR, FALSE }, /* 85 U */
182 { IDCHAR, FALSE }, /* 86 V */
183 { IDCHAR, FALSE }, /* 87 W */
184 { IDCHAR, FALSE }, /* 88 X */
185 { IDCHAR, FALSE }, /* 89 Y */
186 { IDCHAR, FALSE }, /* 90 Z */
188 /* Still more reserved and special printing characters */
190 { SINGLECHAR, FALSE }, /* 91 [ */
191 { CHC_EXTENSION, FALSE }, /* 92 slash */
192 { SINGLECHAR, FALSE }, /* 93 ] */
193 { SINGLECHAR, FALSE }, /* 94 ^ */
194 { IDCHAR, FALSE }, /* 95 _ */
195 { SINGLECHAR, FALSE }, /* 96 ` */
197 /* Lowercase alphabetics */
199 { IDCHAR, FALSE }, /* 97 a */
200 { IDCHAR, FALSE }, /* 98 b */
201 { IDCHAR, FALSE }, /* 99 c */
202 { IDCHAR, FALSE }, /* 100 d */
203 { IDCHAR, FALSE }, /* 101 e */
204 { IDCHAR, FALSE }, /* 102 f */
205 { IDCHAR, FALSE }, /* 103 g */
206 { IDCHAR, FALSE }, /* 104 h */
207 { IDCHAR, FALSE }, /* 105 i */
208 { IDCHAR, FALSE }, /* 106 j */
209 { IDCHAR, FALSE }, /* 107 k */
210 { IDCHAR, FALSE }, /* 108 l */
211 { IDCHAR, FALSE }, /* 109 m */
212 { IDCHAR, FALSE }, /* 110 n */
213 { IDCHAR, FALSE }, /* 111 o */
214 { IDCHAR, FALSE }, /* 112 p */
215 { IDCHAR, FALSE }, /* 113 q */
216 { IDCHAR, FALSE }, /* 114 r */
217 { IDCHAR, FALSE }, /* 115 s */
218 { IDCHAR, FALSE }, /* 116 t */
219 { IDCHAR, FALSE }, /* 117 u */
220 { IDCHAR, FALSE }, /* 118 v */
221 { IDCHAR, FALSE }, /* 119 w */
222 { IDCHAR, FALSE }, /* 120 x */
223 { IDCHAR, FALSE }, /* 121 y */
224 { IDCHAR, FALSE }, /* 122 z */
226 { SINGLECHAR, FALSE }, /* 123 { */
227 { SINGLECHAR, FALSE }, /* 124 | */
228 { SINGLECHAR, FALSE }, /* 125 } */
229 { SINGLECHAR, FALSE }, /* 126 ~ */
230 { SINGLECHAR, FALSE }, /* 127 DEL */
232 /* MCS - unused in English */
234 { SINGLECHAR, FALSE }, /* 128 */
235 { SINGLECHAR, FALSE }, /* 129 */
236 { SINGLECHAR, FALSE }, /* 130 */
237 { SINGLECHAR, FALSE }, /* 131 */
238 { SINGLECHAR, FALSE }, /* 132 */
239 { SINGLECHAR, FALSE }, /* 133 */
240 { SINGLECHAR, FALSE }, /* 134 */
241 { SINGLECHAR, FALSE }, /* 135 */
242 { SINGLECHAR, FALSE }, /* 136 */
243 { SINGLECHAR, FALSE }, /* 137 */
244 { SINGLECHAR, FALSE }, /* 138 */
245 { SINGLECHAR, FALSE }, /* 139 */
246 { SINGLECHAR, FALSE }, /* 140 */
247 { SINGLECHAR, FALSE }, /* 141 */
248 { SINGLECHAR, FALSE }, /* 142 */
249 { SINGLECHAR, FALSE }, /* 143 */
250 { SINGLECHAR, FALSE }, /* 144 */
251 { SINGLECHAR, FALSE }, /* 145 */
252 { SINGLECHAR, FALSE }, /* 146 */
253 { SINGLECHAR, FALSE }, /* 147 */
254 { SINGLECHAR, FALSE }, /* 148 */
255 { SINGLECHAR, FALSE }, /* 149 */
256 { SINGLECHAR, FALSE }, /* 150 */
257 { SINGLECHAR, FALSE }, /* 151 */
258 { SINGLECHAR, FALSE }, /* 152 */
259 { SINGLECHAR, FALSE }, /* 153 */
260 { SINGLECHAR, FALSE }, /* 154 */
261 { SINGLECHAR, FALSE }, /* 155 */
262 { SINGLECHAR, FALSE }, /* 156 */
263 { SINGLECHAR, FALSE }, /* 157 */
264 { SINGLECHAR, FALSE }, /* 158 */
265 { SINGLECHAR, FALSE }, /* 159 */
266 { SINGLECHAR, FALSE }, /* 160 */
267 { SINGLECHAR, FALSE }, /* 161 */
268 { SINGLECHAR, FALSE }, /* 162 */
269 { SINGLECHAR, FALSE }, /* 163 */
270 { SINGLECHAR, FALSE }, /* 164 */
271 { SINGLECHAR, FALSE }, /* 165 */
272 { SINGLECHAR, FALSE }, /* 166 */
273 { SINGLECHAR, FALSE }, /* 167 */
274 { SINGLECHAR, FALSE }, /* 168 */
275 { SINGLECHAR, FALSE }, /* 169 */
276 { SINGLECHAR, FALSE }, /* 170 */
277 { SINGLECHAR, FALSE }, /* 171 */
278 { SINGLECHAR, FALSE }, /* 172 */
279 { SINGLECHAR, FALSE }, /* 173 */
280 { SINGLECHAR, FALSE }, /* 174 */
281 { SINGLECHAR, FALSE }, /* 175 */
282 { SINGLECHAR, FALSE }, /* 176 */
283 { SINGLECHAR, FALSE }, /* 177 */
284 { SINGLECHAR, FALSE }, /* 178 */
285 { SINGLECHAR, FALSE }, /* 179 */
286 { SINGLECHAR, FALSE }, /* 180 */
287 { SINGLECHAR, FALSE }, /* 181 */
288 { SINGLECHAR, FALSE }, /* 182 */
289 { SINGLECHAR, FALSE }, /* 183 */
290 { SINGLECHAR, FALSE }, /* 184 */
291 { SINGLECHAR, FALSE }, /* 185 */
292 { SINGLECHAR, FALSE }, /* 186 */
293 { SINGLECHAR, FALSE }, /* 187 */
294 { SINGLECHAR, FALSE }, /* 188 */
295 { SINGLECHAR, FALSE }, /* 189 */
296 { SINGLECHAR, FALSE }, /* 190 */
297 { SINGLECHAR, FALSE }, /* 191 */
298 { SINGLECHAR, FALSE }, /* 192 */
299 { SINGLECHAR, FALSE }, /* 193 */
300 { SINGLECHAR, FALSE }, /* 194 */
301 { SINGLECHAR, FALSE }, /* 195 */
302 { SINGLECHAR, FALSE }, /* 196 */
303 { SINGLECHAR, FALSE }, /* 197 */
304 { SINGLECHAR, FALSE }, /* 198 */
305 { SINGLECHAR, FALSE }, /* 199 */
306 { SINGLECHAR, FALSE }, /* 200 */
307 { SINGLECHAR, FALSE }, /* 201 */
308 { SINGLECHAR, FALSE }, /* 202 */
309 { SINGLECHAR, FALSE }, /* 203 */
310 { SINGLECHAR, FALSE }, /* 204 */
311 { SINGLECHAR, FALSE }, /* 205 */
312 { SINGLECHAR, FALSE }, /* 206 */
313 { SINGLECHAR, FALSE }, /* 207 */
314 { SINGLECHAR, FALSE }, /* 208 */
315 { SINGLECHAR, FALSE }, /* 209 */
316 { SINGLECHAR, FALSE }, /* 210 */
317 { SINGLECHAR, FALSE }, /* 211 */
318 { SINGLECHAR, FALSE }, /* 212 */
319 { SINGLECHAR, FALSE }, /* 213 */
320 { SINGLECHAR, FALSE }, /* 214 */
321 { SINGLECHAR, FALSE }, /* 215 */
322 { SINGLECHAR, FALSE }, /* 216 */
323 { SINGLECHAR, FALSE }, /* 217 */
324 { SINGLECHAR, FALSE }, /* 218 */
325 { SINGLECHAR, FALSE }, /* 219 */
326 { SINGLECHAR, FALSE }, /* 220 */
327 { SINGLECHAR, FALSE }, /* 221 */
328 { SINGLECHAR, FALSE }, /* 222 */
329 { SINGLECHAR, FALSE }, /* 223 */
330 { SINGLECHAR, FALSE }, /* 224 */
331 { SINGLECHAR, FALSE }, /* 225 */
332 { SINGLECHAR, FALSE }, /* 226 */
333 { SINGLECHAR, FALSE }, /* 227 */
334 { SINGLECHAR, FALSE }, /* 228 */
335 { SINGLECHAR, FALSE }, /* 229 */
336 { SINGLECHAR, FALSE }, /* 230 */
337 { SINGLECHAR, FALSE }, /* 231 */
338 { SINGLECHAR, FALSE }, /* 232 */
339 { SINGLECHAR, FALSE }, /* 233 */
340 { SINGLECHAR, FALSE }, /* 234 */
341 { SINGLECHAR, FALSE }, /* 235 */
342 { SINGLECHAR, FALSE }, /* 236 */
343 { SINGLECHAR, FALSE }, /* 237 */
344 { SINGLECHAR, FALSE }, /* 238 */
345 { SINGLECHAR, FALSE }, /* 239 */
346 { SINGLECHAR, FALSE }, /* 240 */
347 { SINGLECHAR, FALSE }, /* 241 */
348 { SINGLECHAR, FALSE }, /* 242 */
349 { SINGLECHAR, FALSE }, /* 243 */
350 { SINGLECHAR, FALSE }, /* 244 */
351 { SINGLECHAR, FALSE }, /* 245 */
352 { SINGLECHAR, FALSE }, /* 246 */
353 { SINGLECHAR, FALSE }, /* 247 */
354 { SINGLECHAR, FALSE }, /* 248 */
355 { SINGLECHAR, FALSE }, /* 249 */
356 { SINGLECHAR, FALSE }, /* 250 */
357 { SINGLECHAR, FALSE }, /* 251 */
358 { SINGLECHAR, FALSE }, /* 252 */
359 { SINGLECHAR, FALSE }, /* 253 */
360 { SINGLECHAR, FALSE }, /* 254 */
361 { SINGLECHAR, FALSE } /* 255 */
370 ** FORMAL PARAMETERS:
380 ** [@description or none@]
384 ** One line of text is processed.
385 ** Tokens are delivered via the call LSLScanFreshToken ().
393 lscanLine (char *currentLine)
398 register char *bufptr;
406 bufptr = &tokenBuffer[0];
407 startCol = colNumber;
409 /*@-loopswitchbreak@*/
410 switch (lscanCharClass (c))
414 sym = lsymbol_fromChars ("E O L");
422 while (lscanCharClass (c) == IDCHAR)
428 sym = lsymbol_fromChars (&tokenBuffer[0]);
432 /* One-character tokens */
438 sym = lsymbol_fromChars (&tokenBuffer[0]);
443 if (*currentLine == '\\')
448 sym = lsymbol_fromChars (&tokenBuffer[0]);
453 /* We fall through to next case if we have / followed */
454 /* by anything else. */
458 /* Operator symbols */
460 /* possible multi character */
461 while (lscanCharClass (c) == OPCHAR)
466 *bufptr = '\0'; /* null terminate in buffer */
467 sym = lsymbol_fromChars (&tokenBuffer[0]);
473 /*@-switchswitchbreak@*/
479 colNumber += TABSIZE;
480 colNumber -= (colNumber % TABSIZE);
494 sym = lsymbol_fromChars (&tokenBuffer[0]);
495 cod = LST_WHITESPACE;
507 while (lscanCharClass (c) == IDCHAR)
512 sym = lsymbol_fromChars (&tokenBuffer[0]);
518 while (lscanCharClass (c) == IDCHAR)
523 sym = lsymbol_fromChars (&tokenBuffer[0]);
530 while (lscanCharClass (c) == IDCHAR)
535 sym = lsymbol_fromChars (&tokenBuffer[0]);
542 while (lscanCharClass (c) == IDCHAR)
547 sym = lsymbol_fromChars (&tokenBuffer[0]);
552 if (lscanCharClass (c) == IDCHAR)
558 while (lscanCharClass (c) == IDCHAR);
560 sym = lsymbol_fromChars (&tokenBuffer[0]);
566 ** Meets none of the above. Take the extension
567 ** character and the character following and treat
568 ** together as a SINGLECHAR. SINGLECHARs tranlate into
574 sym = lsymbol_fromChars (&tokenBuffer[0]);
579 /*@switchbreak@*/ break;
580 /*@=switchswitchbreak@*/
583 LocalUserError ("unexpected character in input");
586 /*@=loopswitchbreak@*/
589 ** Above code only "guessed" at token type. Insert it into the
590 ** TokenTable. If the token already exists, it is returned as
591 ** previously defined. If it does not exist, it is inserted as the
592 ** token code computed above.
595 newToken = LSLInsertToken (cod, sym, 0, FALSE);
597 if (LSLIsSyn (ltoken_getText (newToken)))
600 ** Token is a synonym. Get the actual token and set the raw
601 ** text to the synonym name.
604 newToken = LSLGetTokenForSyn (ltoken_getText (newToken));
605 ltoken_setRawText (newToken, sym);
608 ltoken_setCol (newToken, startCol);
609 ltoken_setLine (newToken, inputStream_thisLineNumber (LSLScanSource ()));
610 ltoken_setFileName (newToken, inputStream_fileName (LSLScanSource ()));
612 if (ltoken_getCode (newToken) == LST_COMMENTSYM)
614 bufptr = &tokenBuffer[0];
616 while (!LSLIsEndComment (c))
620 if (lscanCharClass (c) != CHC_NULL)
627 ltoken_setRawText (newToken, lsymbol_fromChars (&tokenBuffer[0]));
628 LSLScanFreshToken (newToken);
631 else if (ltoken_getCode (newToken) == LST_EOL)
635 LSLScanFreshToken (newToken);
641 if (cod != LST_WHITESPACE)
643 LSLScanFreshToken (newToken);
650 LSLScanEofToken (void)
652 ltoken t = ltoken_copy (LSLInsertToken (LEOFTOKEN,
653 lsymbol_fromChars ("E O F"),
655 ltoken_setCol (t, colNumber);
656 ltoken_setLine (t, inputStream_thisLineNumber (LSLScanSource ()));
657 ltoken_setFileName (t, inputStream_fileName (LSLScanSource ()));
662 LSLReportEolTokens (bool setting)
668 LocalUserError (char *msg)
670 inputStream s = LSLScanSource ();
671 llfatalerror (message ("%s:%d,%d: %s",
672 inputStream_fileName (s),
673 inputStream_thisLineNumber (s), colNumber,
674 cstring_fromChars (msg)));
683 ** FORMAL PARAMETERS:
693 ** [@description or none@]
697 ** Initialize this module (should only be called once).
699 ** IMPLICIT INPUTS/OUTPUT:
701 ** GetNextLine - (output) initialized
702 ** NullToken - (output) initialized
703 ** PrintName - (output) array contents initialized
717 reportComments = FALSE;
719 for (i = 0; i <= LASTCHAR; i++)
721 charClass[i] = charClassDef[i];
725 ** NOTE: The following line ensures that all tokens have nonzero
726 ** handles, so that a handle of zero can be used to indicate that a
727 ** token does not have a synonym.
730 (void) LSLReserveToken (LST_SIMPLEID, "dummy token");
732 ltoken_forall = LSLReserveToken (LST_QUANTIFIERSYM, "\\forall");
733 ltoken_true = LSLReserveToken (LST_SIMPLEID, "true");
734 ltoken_false = LSLReserveToken (LST_SIMPLEID, "false");
735 ltoken_not = LSLReserveToken (LST_SIMPLEOP, "\\not");
736 ltoken_and = LSLReserveToken (LST_LOGICALOP, "\\and");
737 ltoken_or = LSLReserveToken (LST_LOGICALOP, "\\or");
738 ltoken_implies = LSLReserveToken (LST_LOGICALOP, "\\implies");
740 ltoken_eq = LSLReserveToken (LST_EQOP, "\\eq");
741 ltoken_neq = LSLReserveToken (LST_EQOP, "\\neq");
743 ltoken_equals = LSLReserveToken (LST_EQUATIONSYM, "\\equals");
744 ltoken_eqsep = LSLReserveToken (LST_EQSEPSYM, "\\eqsep");
745 ltoken_select = LSLReserveToken (LST_SELECTSYM, "\\select");
746 ltoken_open = LSLReserveToken (LST_OPENSYM, "\\open");
747 ltoken_sep = LSLReserveToken (LST_SEPSYM, "\\,");
748 ltoken_close = LSLReserveToken (LST_CLOSESYM, "\\close");
749 ltoken_id = LSLReserveToken (LST_SIMPLEID, "\\:");
750 ltoken_arrow = LSLReserveToken (LST_MAPSYM, "\\arrow");
751 ltoken_farrow = LSLReserveToken (LST_FIELDMAPSYM, "\\field_arrow");
753 ltoken_marker = LSLReserveToken (LST_MARKERSYM, "\\marker");
754 ltoken_comment = LSLReserveToken (LST_COMMENTSYM, "\\comment");
755 ltoken_compose = LSLReserveToken (LST_COMPOSESYM, "\\composeSort");
756 ltoken_if = LSLReserveToken (LST_ifTOKEN, "if");
758 (void) LSLReserveToken (LST_LPAR, " (");
759 (void) LSLReserveToken (LST_RPAR, ")");
760 (void) LSLReserveToken (LST_COMMA, ",");
761 (void) LSLReserveToken (LST_COLON, ":");
763 (void) LSLReserveToken (LST_LBRACKET, "[");
764 (void) LSLReserveToken (LST_RBRACKET, "]");
766 (void) LSLReserveToken (LST_WHITESPACE, " ");
767 (void) LSLReserveToken (LST_WHITESPACE, "\t");
768 (void) LSLReserveToken (LST_WHITESPACE, "\n");
770 (void) LSLReserveToken (LEOFTOKEN, "E O F");
771 (void) LSLReserveToken (LST_EOL, "E O L");
773 (void) LSLReserveToken (LST_assertsTOKEN, "asserts");
774 (void) LSLReserveToken (LST_assumesTOKEN, "assumes");
775 (void) LSLReserveToken (LST_byTOKEN, "by");
776 (void) LSLReserveToken (LST_convertsTOKEN, "converts");
777 (void) LSLReserveToken (LST_elseTOKEN, "else");
778 (void) LSLReserveToken (LST_enumerationTOKEN, "enumeration");
779 (void) LSLReserveToken (LST_equationsTOKEN, "equations");
780 (void) LSLReserveToken (LST_exemptingTOKEN, "exempting");
781 (void) LSLReserveToken (LST_forTOKEN, "for");
782 (void) LSLReserveToken (LST_generatedTOKEN, "generated");
783 (void) LSLReserveToken (LST_impliesTOKEN, "implies");
784 (void) LSLReserveToken (LST_includesTOKEN, "includes");
785 (void) LSLReserveToken (LST_introducesTOKEN, "introduces");
786 (void) LSLReserveToken (LST_ofTOKEN, "of");
787 (void) LSLReserveToken (LST_partitionedTOKEN, "partitioned");
788 (void) LSLReserveToken (LST_thenTOKEN, "then");
789 (void) LSLReserveToken (LST_traitTOKEN, "trait");
790 (void) LSLReserveToken (LST_tupleTOKEN, "tuple");
791 (void) LSLReserveToken (LST_unionTOKEN, "union");
795 lscanLineReset (void)
800 lscanLineCleanup (void)
804 charCode lscanCharClass (char c)
806 return charClass[ (int) (c)].code;
809 bool LSLIsEndComment (char c)
811 return charClass[ (int) (c)].endCommentChar;
814 void lsetCharClass (char c, charCode cod)
816 charClass[ (int) (c)].code = cod;
819 void lsetEndCommentChar (char c, bool flag)
821 charClass[ (int) (c)].endCommentChar = flag;