?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Some consistency changes to library & headers flags.
[splint-patched.git] / src / lslscanline.c
blobfeb78f2d89f2c84b48d8b519780f5e98a6a6da6d
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 ** lslscanline.c
26 **
27 ** Scan one line of Larch SL input at a time.
28 **
29 ** The input is source text, line at a time. The output is a sequence
30 ** of tokens, reported by call-out LSLScanFreshToken.
31 **
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.
36 **
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.
40 */
41
42 # include "splintMacros.nf"
43 # include "basic.h"
44
45 # include "lslgrammar.h"
46 # include "lslscan.h"
47 # include "lslscanline.h"
48 # include "lsltokentable.h"
49 # include "lslsyntable.h"
50
51 /*@notfunction@*/
52 # define MOVECHAR() do { *bufptr++ = c; c = *currentLine++; colNumber++; } while (FALSE)
53
54 /* evans 2003-04-21: changed name to avoid conflict with MS VC++ */
55 /*@constant static int SCANMAXCHAR;@*/
56 # define SCANMAXCHAR 512
57
58 /*@constant static int TABSIZE;@*/
59 # define TABSIZE 8
60
61 static void LocalUserError (/*@temp@*/ char *p_msg);
62
63 static charClassData charClass[LASTCHAR + 1];
64
65 static int colNumber;
66 static int startCol;
67 static bool reportEOL;
68 static bool reportComments;
69
70 static char tokenBuffer[SCANMAXCHAR];
71
72 static const charClassData charClassDef[] =
73 {
74 /* Control characters */
75
76 { CHC_NULL, TRUE }, /* 0 NULL */
77 { SINGLECHAR, FALSE }, /* 1 CTRL-A */
78 { SINGLECHAR, FALSE }, /* 2 CTRL-B */
79 { SINGLECHAR, FALSE }, /* 3 CTRL-C */
80 { SINGLECHAR, FALSE }, /* 4 CTRL-D */
81 { SINGLECHAR, FALSE }, /* 5 CTRL-E */
82 { SINGLECHAR, FALSE }, /* 6 CTRL-F */
83 { SINGLECHAR, FALSE }, /* 7 CTRL-G */
84 { SINGLECHAR, FALSE }, /* 8 CTRL-H */
85
86 /* defined formatting characters */
87
88 { WHITECHAR, FALSE }, /* 9 CTRL-I TAB */
89 { WHITECHAR, TRUE }, /* 10 CTRL-J EOL */
90
91 /* more control characters */
92
93 { SINGLECHAR, FALSE }, /* 11 CTRL-K */
94 { SINGLECHAR, FALSE }, /* 12 CTRL-L */
95 { SINGLECHAR, FALSE }, /* 13 CTRL-M */
96 { SINGLECHAR, FALSE }, /* 14 CTRL-N */
97 { SINGLECHAR, FALSE }, /* 15 CTRL-O */
98 { SINGLECHAR, FALSE }, /* 16 CTRL-P */
99 { SINGLECHAR, FALSE }, /* 17 CTRL-Q */
100 { SINGLECHAR, FALSE }, /* 18 CTRL-R */
101 { SINGLECHAR, FALSE }, /* 19 CTRL-S */
102 { SINGLECHAR, FALSE }, /* 20 CTRL-T */
103 { SINGLECHAR, FALSE }, /* 21 CTRL-U */
104 { SINGLECHAR, FALSE }, /* 22 CTRL-V */
105 { SINGLECHAR, FALSE }, /* 23 CTRL-W */
106 { SINGLECHAR, FALSE }, /* 24 CTRL-X */
107 { SINGLECHAR, FALSE }, /* 25 CTRL-Y */
108 { SINGLECHAR, FALSE }, /* 26 CTRL-Z */
109 { SINGLECHAR, FALSE }, /* 27 CTRL-[ ESC */
110 { SINGLECHAR, FALSE }, /* 28 CTRL-slash */
111 { SINGLECHAR, FALSE }, /* 29 CTRL-] GS */
112 { SINGLECHAR, FALSE }, /* 30 CTRL-^ RS */
113 { SINGLECHAR, FALSE }, /* 31 CTRL-_ US */
114
115 /* Special printing characters */
116
117 { WHITECHAR, FALSE }, /* 32 space */
118 { SINGLECHAR, FALSE }, /* 33 ! */
119 { SINGLECHAR, FALSE }, /* 34 " */
120 { SINGLECHAR, FALSE }, /* 35 # */
121 { SINGLECHAR, FALSE }, /* 36 $ */
122 { SINGLECHAR, FALSE }, /* 37 % */
123 { SINGLECHAR, FALSE }, /* 38 & */
124 { SINGLECHAR, FALSE }, /* 39 ' */
125
126 /* Reserved characters */
127
128 { PERMCHAR, FALSE }, /* 40 ( */
129 { PERMCHAR, FALSE }, /* 41 ) */
130 { OPCHAR, FALSE }, /* 42 * */
131 { OPCHAR, FALSE }, /* 43 + */
132 { PERMCHAR, FALSE }, /* 44 , */
133 { OPCHAR, FALSE }, /* 45 - */
134 { OPCHAR, FALSE }, /* 46 . */
135 { SLASHCHAR, FALSE }, /* 47 / */
136
137 /* Numbers */
138
139 { IDCHAR, FALSE }, /* 48 0 */
140 { IDCHAR, FALSE }, /* 49 1 */
141 { IDCHAR, FALSE }, /* 50 2 */
142 { IDCHAR, FALSE }, /* 51 3 */
143 { IDCHAR, FALSE }, /* 52 4 */
144 { IDCHAR, FALSE }, /* 53 5 */
145 { IDCHAR, FALSE }, /* 54 6 */
146 { IDCHAR, FALSE }, /* 55 7 */
147 { IDCHAR, FALSE }, /* 56 8 */
148 { IDCHAR, FALSE }, /* 57 9 */
149
150 /* More reserved and special printing characters */
151
152 { PERMCHAR, FALSE }, /* 58 : */
153 { SINGLECHAR, FALSE }, /* 59; */
154 { OPCHAR, FALSE }, /* 60 < */
155 { OPCHAR, FALSE }, /* 61 = */
156 { OPCHAR, FALSE }, /* 62 > */
157 { SINGLECHAR, FALSE }, /* 63 ? */
158 { SINGLECHAR, FALSE }, /* 64 @ */
159
160 /* Uppercase Alphabetics */
161
162 { IDCHAR, FALSE }, /* 65 A */
163 { IDCHAR, FALSE }, /* 66 B */
164 { IDCHAR, FALSE }, /* 67 C */
165 { IDCHAR, FALSE }, /* 68 D */
166 { IDCHAR, FALSE }, /* 69 E */
167 { IDCHAR, FALSE }, /* 70 F */
168 { IDCHAR, FALSE }, /* 71 G */
169 { IDCHAR, FALSE }, /* 72 H */
170 { IDCHAR, FALSE }, /* 73 I */
171 { IDCHAR, FALSE }, /* 74 J */
172 { IDCHAR, FALSE }, /* 75 K */
173 { IDCHAR, FALSE }, /* 76 L */
174 { IDCHAR, FALSE }, /* 77 M */
175 { IDCHAR, FALSE }, /* 78 N */
176 { IDCHAR, FALSE }, /* 79 O */
177 { IDCHAR, FALSE }, /* 80 P */
178 { IDCHAR, FALSE }, /* 81 Q */
179 { IDCHAR, FALSE }, /* 82 R */
180 { IDCHAR, FALSE }, /* 83 S */
181 { IDCHAR, FALSE }, /* 84 T */
182 { IDCHAR, FALSE }, /* 85 U */
183 { IDCHAR, FALSE }, /* 86 V */
184 { IDCHAR, FALSE }, /* 87 W */
185 { IDCHAR, FALSE }, /* 88 X */
186 { IDCHAR, FALSE }, /* 89 Y */
187 { IDCHAR, FALSE }, /* 90 Z */
188
189 /* Still more reserved and special printing characters */
190
191 { SINGLECHAR, FALSE }, /* 91 [ */
192 { CHC_EXTENSION, FALSE }, /* 92 slash */
193 { SINGLECHAR, FALSE }, /* 93 ] */
194 { SINGLECHAR, FALSE }, /* 94 ^ */
195 { IDCHAR, FALSE }, /* 95 _ */
196 { SINGLECHAR, FALSE }, /* 96 ` */
197
198 /* Lowercase alphabetics */
199
200 { IDCHAR, FALSE }, /* 97 a */
201 { IDCHAR, FALSE }, /* 98 b */
202 { IDCHAR, FALSE }, /* 99 c */
203 { IDCHAR, FALSE }, /* 100 d */
204 { IDCHAR, FALSE }, /* 101 e */
205 { IDCHAR, FALSE }, /* 102 f */
206 { IDCHAR, FALSE }, /* 103 g */
207 { IDCHAR, FALSE }, /* 104 h */
208 { IDCHAR, FALSE }, /* 105 i */
209 { IDCHAR, FALSE }, /* 106 j */
210 { IDCHAR, FALSE }, /* 107 k */
211 { IDCHAR, FALSE }, /* 108 l */
212 { IDCHAR, FALSE }, /* 109 m */
213 { IDCHAR, FALSE }, /* 110 n */
214 { IDCHAR, FALSE }, /* 111 o */
215 { IDCHAR, FALSE }, /* 112 p */
216 { IDCHAR, FALSE }, /* 113 q */
217 { IDCHAR, FALSE }, /* 114 r */
218 { IDCHAR, FALSE }, /* 115 s */
219 { IDCHAR, FALSE }, /* 116 t */
220 { IDCHAR, FALSE }, /* 117 u */
221 { IDCHAR, FALSE }, /* 118 v */
222 { IDCHAR, FALSE }, /* 119 w */
223 { IDCHAR, FALSE }, /* 120 x */
224 { IDCHAR, FALSE }, /* 121 y */
225 { IDCHAR, FALSE }, /* 122 z */
226
227 { SINGLECHAR, FALSE }, /* 123 { */
228 { SINGLECHAR, FALSE }, /* 124 | */
229 { SINGLECHAR, FALSE }, /* 125 } */
230 { SINGLECHAR, FALSE }, /* 126 ~ */
231 { SINGLECHAR, FALSE }, /* 127 DEL */
232
233 /* MCS - unused in English */
234
235 { SINGLECHAR, FALSE }, /* 128 */
236 { SINGLECHAR, FALSE }, /* 129 */
237 { SINGLECHAR, FALSE }, /* 130 */
238 { SINGLECHAR, FALSE }, /* 131 */
239 { SINGLECHAR, FALSE }, /* 132 */
240 { SINGLECHAR, FALSE }, /* 133 */
241 { SINGLECHAR, FALSE }, /* 134 */
242 { SINGLECHAR, FALSE }, /* 135 */
243 { SINGLECHAR, FALSE }, /* 136 */
244 { SINGLECHAR, FALSE }, /* 137 */
245 { SINGLECHAR, FALSE }, /* 138 */
246 { SINGLECHAR, FALSE }, /* 139 */
247 { SINGLECHAR, FALSE }, /* 140 */
248 { SINGLECHAR, FALSE }, /* 141 */
249 { SINGLECHAR, FALSE }, /* 142 */
250 { SINGLECHAR, FALSE }, /* 143 */
251 { SINGLECHAR, FALSE }, /* 144 */
252 { SINGLECHAR, FALSE }, /* 145 */
253 { SINGLECHAR, FALSE }, /* 146 */
254 { SINGLECHAR, FALSE }, /* 147 */
255 { SINGLECHAR, FALSE }, /* 148 */
256 { SINGLECHAR, FALSE }, /* 149 */
257 { SINGLECHAR, FALSE }, /* 150 */
258 { SINGLECHAR, FALSE }, /* 151 */
259 { SINGLECHAR, FALSE }, /* 152 */
260 { SINGLECHAR, FALSE }, /* 153 */
261 { SINGLECHAR, FALSE }, /* 154 */
262 { SINGLECHAR, FALSE }, /* 155 */
263 { SINGLECHAR, FALSE }, /* 156 */
264 { SINGLECHAR, FALSE }, /* 157 */
265 { SINGLECHAR, FALSE }, /* 158 */
266 { SINGLECHAR, FALSE }, /* 159 */
267 { SINGLECHAR, FALSE }, /* 160 */
268 { SINGLECHAR, FALSE }, /* 161 */
269 { SINGLECHAR, FALSE }, /* 162 */
270 { SINGLECHAR, FALSE }, /* 163 */
271 { SINGLECHAR, FALSE }, /* 164 */
272 { SINGLECHAR, FALSE }, /* 165 */
273 { SINGLECHAR, FALSE }, /* 166 */
274 { SINGLECHAR, FALSE }, /* 167 */
275 { SINGLECHAR, FALSE }, /* 168 */
276 { SINGLECHAR, FALSE }, /* 169 */
277 { SINGLECHAR, FALSE }, /* 170 */
278 { SINGLECHAR, FALSE }, /* 171 */
279 { SINGLECHAR, FALSE }, /* 172 */
280 { SINGLECHAR, FALSE }, /* 173 */
281 { SINGLECHAR, FALSE }, /* 174 */
282 { SINGLECHAR, FALSE }, /* 175 */
283 { SINGLECHAR, FALSE }, /* 176 */
284 { SINGLECHAR, FALSE }, /* 177 */
285 { SINGLECHAR, FALSE }, /* 178 */
286 { SINGLECHAR, FALSE }, /* 179 */
287 { SINGLECHAR, FALSE }, /* 180 */
288 { SINGLECHAR, FALSE }, /* 181 */
289 { SINGLECHAR, FALSE }, /* 182 */
290 { SINGLECHAR, FALSE }, /* 183 */
291 { SINGLECHAR, FALSE }, /* 184 */
292 { SINGLECHAR, FALSE }, /* 185 */
293 { SINGLECHAR, FALSE }, /* 186 */
294 { SINGLECHAR, FALSE }, /* 187 */
295 { SINGLECHAR, FALSE }, /* 188 */
296 { SINGLECHAR, FALSE }, /* 189 */
297 { SINGLECHAR, FALSE }, /* 190 */
298 { SINGLECHAR, FALSE }, /* 191 */
299 { SINGLECHAR, FALSE }, /* 192 */
300 { SINGLECHAR, FALSE }, /* 193 */
301 { SINGLECHAR, FALSE }, /* 194 */
302 { SINGLECHAR, FALSE }, /* 195 */
303 { SINGLECHAR, FALSE }, /* 196 */
304 { SINGLECHAR, FALSE }, /* 197 */
305 { SINGLECHAR, FALSE }, /* 198 */
306 { SINGLECHAR, FALSE }, /* 199 */
307 { SINGLECHAR, FALSE }, /* 200 */
308 { SINGLECHAR, FALSE }, /* 201 */
309 { SINGLECHAR, FALSE }, /* 202 */
310 { SINGLECHAR, FALSE }, /* 203 */
311 { SINGLECHAR, FALSE }, /* 204 */
312 { SINGLECHAR, FALSE }, /* 205 */
313 { SINGLECHAR, FALSE }, /* 206 */
314 { SINGLECHAR, FALSE }, /* 207 */
315 { SINGLECHAR, FALSE }, /* 208 */
316 { SINGLECHAR, FALSE }, /* 209 */
317 { SINGLECHAR, FALSE }, /* 210 */
318 { SINGLECHAR, FALSE }, /* 211 */
319 { SINGLECHAR, FALSE }, /* 212 */
320 { SINGLECHAR, FALSE }, /* 213 */
321 { SINGLECHAR, FALSE }, /* 214 */
322 { SINGLECHAR, FALSE }, /* 215 */
323 { SINGLECHAR, FALSE }, /* 216 */
324 { SINGLECHAR, FALSE }, /* 217 */
325 { SINGLECHAR, FALSE }, /* 218 */
326 { SINGLECHAR, FALSE }, /* 219 */
327 { SINGLECHAR, FALSE }, /* 220 */
328 { SINGLECHAR, FALSE }, /* 221 */
329 { SINGLECHAR, FALSE }, /* 222 */
330 { SINGLECHAR, FALSE }, /* 223 */
331 { SINGLECHAR, FALSE }, /* 224 */
332 { SINGLECHAR, FALSE }, /* 225 */
333 { SINGLECHAR, FALSE }, /* 226 */
334 { SINGLECHAR, FALSE }, /* 227 */
335 { SINGLECHAR, FALSE }, /* 228 */
336 { SINGLECHAR, FALSE }, /* 229 */
337 { SINGLECHAR, FALSE }, /* 230 */
338 { SINGLECHAR, FALSE }, /* 231 */
339 { SINGLECHAR, FALSE }, /* 232 */
340 { SINGLECHAR, FALSE }, /* 233 */
341 { SINGLECHAR, FALSE }, /* 234 */
342 { SINGLECHAR, FALSE }, /* 235 */
343 { SINGLECHAR, FALSE }, /* 236 */
344 { SINGLECHAR, FALSE }, /* 237 */
345 { SINGLECHAR, FALSE }, /* 238 */
346 { SINGLECHAR, FALSE }, /* 239 */
347 { SINGLECHAR, FALSE }, /* 240 */
348 { SINGLECHAR, FALSE }, /* 241 */
349 { SINGLECHAR, FALSE }, /* 242 */
350 { SINGLECHAR, FALSE }, /* 243 */
351 { SINGLECHAR, FALSE }, /* 244 */
352 { SINGLECHAR, FALSE }, /* 245 */
353 { SINGLECHAR, FALSE }, /* 246 */
354 { SINGLECHAR, FALSE }, /* 247 */
355 { SINGLECHAR, FALSE }, /* 248 */
356 { SINGLECHAR, FALSE }, /* 249 */
357 { SINGLECHAR, FALSE }, /* 250 */
358 { SINGLECHAR, FALSE }, /* 251 */
359 { SINGLECHAR, FALSE }, /* 252 */
360 { SINGLECHAR, FALSE }, /* 253 */
361 { SINGLECHAR, FALSE }, /* 254 */
362 { SINGLECHAR, FALSE } /* 255 */
363 };
364
365 /*
366 **++
367 ** FUNCTION NAME:
368 **
369 ** lscanline ()
370 **
371 ** FORMAL PARAMETERS:
372 **
373 ** None
374 **
375 ** RETURN VALUE:
376 **
377 ** None
378 **
379 ** INVARIANTS:
380 **
381 ** [@description or none@]
382 **
383 ** DESCRIPTION:
384 **
385 ** One line of text is processed.
386 ** Tokens are delivered via the call LSLScanFreshToken ().
387 **
388 ** EXCEPTIONS:
389 **
390 **--
391 */
392
393 void
394 lscanLine (char *currentLine)
395 {
396 ltokenCode cod;
397 lsymbol sym;
398 register char c;
399 register char *bufptr;
400 ltoken newToken;
401
402 c = *currentLine++;
403 colNumber = 0;
404
405 for (;;)
406 {
407 bufptr = &tokenBuffer[0];
408 startCol = colNumber;
409
410 /*@-loopswitchbreak@*/
411 switch (lscanCharClass (c))
412 {
413
414 case CHC_NULL:
415 sym = lsymbol_fromChars ("E O L");
416 cod = LST_EOL;
417 break;
418
419 /* Identifiers */
420
421 case IDCHAR:
422
423 while (lscanCharClass (c) == IDCHAR)
424 {
425 MOVECHAR ();
426 }
427
428 *bufptr = '\0';
429 sym = lsymbol_fromChars (&tokenBuffer[0]);
430 cod = LST_SIMPLEID;
431 break;
432
433 /* One-character tokens */
434
435 case SINGLECHAR:
436 case PERMCHAR:
437 MOVECHAR ();
438 *bufptr = '\0';
439 sym = lsymbol_fromChars (&tokenBuffer[0]);
440 cod = LST_SIMPLEOP;
441 break;
442
443 case SLASHCHAR:
444 if (*currentLine == '\\')
445 {
446 MOVECHAR ();
447 MOVECHAR ();
448 *bufptr = '\0';
449 sym = lsymbol_fromChars (&tokenBuffer[0]);
450 cod = LST_SIMPLEOP;
451 break;
452 }
453 MOVECHAR ();
454 /* We fall through to next case if we have / followed */
455 /* by anything else. */
456 /*@fallthrough@*/
457 case OPCHAR:
458
459 /* Operator symbols */
460
461 /* possible multi character */
462 while (lscanCharClass (c) == OPCHAR)
463 {
464 MOVECHAR ();
465 }
466
467 *bufptr = '\0'; /* null terminate in buffer */
468 sym = lsymbol_fromChars (&tokenBuffer[0]);
469 cod = LST_SIMPLEOP;
470 break;
471
472 /* White space */
473 case WHITECHAR:
474 /*@-switchswitchbreak@*/
475 switch (c)
476 {
477 case '\t':
478 MOVECHAR ();
479 colNumber--;
480 colNumber += TABSIZE;
481 colNumber -= (colNumber % TABSIZE);
482 break;
483
484 case '\v':
485 case '\f':
486 MOVECHAR ();
487 colNumber--;
488 break;
489
490 default:
491 MOVECHAR ();
492 break;
493 }
494 *bufptr = '\0';
495 sym = lsymbol_fromChars (&tokenBuffer[0]);
496 cod = LST_WHITESPACE;
497 break;
498
499 case CHC_EXTENSION:
500 MOVECHAR ();
501
502 switch (c)
503 {
504
505 /* open and close */
506 case '(':
507 MOVECHAR ();
508 while (lscanCharClass (c) == IDCHAR)
509 {
510 MOVECHAR ();
511 }
512 *bufptr = '\0';
513 sym = lsymbol_fromChars (&tokenBuffer[0]);
514 cod = LST_OPENSYM;
515 break;
516
517 case ')':
518 MOVECHAR ();
519 while (lscanCharClass (c) == IDCHAR)
520 {
521 MOVECHAR ();
522 }
523 *bufptr = '\0';
524 sym = lsymbol_fromChars (&tokenBuffer[0]);
525 cod = LST_CLOSESYM;
526 break;
527
528 /* separator */
529 case ',':
530 MOVECHAR ();
531 while (lscanCharClass (c) == IDCHAR)
532 {
533 MOVECHAR ();
534 }
535 *bufptr = '\0';
536 sym = lsymbol_fromChars (&tokenBuffer[0]);
537 cod = LST_SEPSYM;
538 break;
539
540 /* simpleid */
541 case ':':
542 MOVECHAR ();
543 while (lscanCharClass (c) == IDCHAR)
544 {
545 MOVECHAR ();
546 }
547 *bufptr = '\0';
548 sym = lsymbol_fromChars (&tokenBuffer[0]);
549 cod = LST_SIMPLEID;
550 break;
551
552 default:
553 if (lscanCharClass (c) == IDCHAR)
554 {
555 do
556 {
557 MOVECHAR ();
558 }
559 while (lscanCharClass (c) == IDCHAR);
560 *bufptr = '\0';
561 sym = lsymbol_fromChars (&tokenBuffer[0]);
562 cod = LST_SIMPLEOP;
563 }
564 else
565 {
566 /*
567 ** Meets none of the above. Take the extension
568 ** character and the character following and treat
569 ** together as a SINGLECHAR. SINGLECHARs tranlate into
570 ** SIMPLEOPs.
571 */
572
573 MOVECHAR ();
574 *bufptr = '\0';
575 sym = lsymbol_fromChars (&tokenBuffer[0]);
576 cod = LST_SIMPLEOP;
577 }
578 break;
579 }
580 /*@switchbreak@*/ break;
581 /*@=switchswitchbreak@*/
582 default:
583
584 LocalUserError ("unexpected character in input");
585 return;
586 }
587 /*@=loopswitchbreak@*/
588
589 /*
590 ** Above code only "guessed" at token type. Insert it into the
591 ** TokenTable. If the token already exists, it is returned as
592 ** previously defined. If it does not exist, it is inserted as the
593 ** token code computed above.
594 */
595
596 newToken = LSLInsertToken (cod, sym, 0, FALSE);
597
598 if (LSLIsSyn (ltoken_getText (newToken)))
599 {
600 /*
601 ** Token is a synonym. Get the actual token and set the raw
602 ** text to the synonym name.
603 */
604
605 newToken = LSLGetTokenForSyn (ltoken_getText (newToken));
606 ltoken_setRawText (newToken, sym);
607 }
608
609 ltoken_setCol (newToken, startCol);
610 ltoken_setLine (newToken, inputStream_thisLineNumber (LSLScanSource ()));
611 ltoken_setFileName (newToken, inputStream_fileName (LSLScanSource ()));
612
613 if (ltoken_getCode (newToken) == LST_COMMENTSYM)
614 {
615 bufptr = &tokenBuffer[0];
616
617 while (!LSLIsEndComment (c))
618 {
619 MOVECHAR ();
620 }
621 if (lscanCharClass (c) != CHC_NULL)
622 {
623 MOVECHAR ();
624 }
625 if (reportComments)
626 {
627 *bufptr = '\0';
628 ltoken_setRawText (newToken, lsymbol_fromChars (&tokenBuffer[0]));
629 LSLScanFreshToken (newToken);
630 }
631 }
632 else if (ltoken_getCode (newToken) == LST_EOL)
633 {
634 if (reportEOL)
635 {
636 LSLScanFreshToken (newToken);
637 }
638 return;
639 }
640 else
641 {
642 if (cod != LST_WHITESPACE)
643 {
644 LSLScanFreshToken (newToken);
645 }
646 }
647 }
648 }
649
650 ltoken
651 LSLScanEofToken (void)
652 {
653 ltoken t = ltoken_copy (LSLInsertToken (LEOFTOKEN,
654 lsymbol_fromChars ("E O F"),
655 0, TRUE));
656 ltoken_setCol (t, colNumber);
657 ltoken_setLine (t, inputStream_thisLineNumber (LSLScanSource ()));
658 ltoken_setFileName (t, inputStream_fileName (LSLScanSource ()));
659 return t;
660 }
661
662 void
663 LSLReportEolTokens (bool setting)
664 {
665 reportEOL = setting;
666 }
667
668 static void
669 LocalUserError (char *msg)
670 {
671 inputStream s = LSLScanSource ();
672 llfatalerror (message ("%s:%d,%d: %s",
673 inputStream_fileName (s),
674 inputStream_thisLineNumber (s), colNumber,
675 cstring_fromChars (msg)));
676 }
677
678 /*
679 **++
680 ** FUNCTION NAME:
681 **
682 ** lscanLineInit ()
683 **
684 ** FORMAL PARAMETERS:
685 **
686 ** None
687 **
688 ** RETURN VALUE:
689 **
690 ** None
691 **
692 ** INVARIANTS:
693 **
694 ** [@description or none@]
695 **
696 ** DESCRIPTION:
697 **
698 ** Initialize this module (should only be called once).
699 **
700 ** IMPLICIT INPUTS/OUTPUT:
701 **
702 ** GetNextLine - (output) initialized
703 ** NullToken - (output) initialized
704 ** PrintName - (output) array contents initialized
705 **
706 ** EXCEPTIONS:
707 **
708 ** None
709 **--
710 */
711
712 void
713 lscanLineInit (void)
714 {
715 int i;
716
717 reportEOL = FALSE;
718 reportComments = FALSE;
719
720 for (i = 0; i <= LASTCHAR; i++)
721 {
722 charClass[i] = charClassDef[i];
723 }
724
725 /*
726 ** NOTE: The following line ensures that all tokens have nonzero
727 ** handles, so that a handle of zero can be used to indicate that a
728 ** token does not have a synonym.
729 */
730
731 (void) LSLReserveToken (LST_SIMPLEID, "dummy token");
732
733 ltoken_forall = LSLReserveToken (LST_QUANTIFIERSYM, "\\forall");
734 ltoken_true = LSLReserveToken (LST_SIMPLEID, "true");
735 ltoken_false = LSLReserveToken (LST_SIMPLEID, "false");
736 ltoken_not = LSLReserveToken (LST_SIMPLEOP, "\\not");
737 ltoken_and = LSLReserveToken (LST_LOGICALOP, "\\and");
738 ltoken_or = LSLReserveToken (LST_LOGICALOP, "\\or");
739 ltoken_implies = LSLReserveToken (LST_LOGICALOP, "\\implies");
740
741 ltoken_eq = LSLReserveToken (LST_EQOP, "\\eq");
742 ltoken_neq = LSLReserveToken (LST_EQOP, "\\neq");
743
744 ltoken_equals = LSLReserveToken (LST_EQUATIONSYM, "\\equals");
745 ltoken_eqsep = LSLReserveToken (LST_EQSEPSYM, "\\eqsep");
746 ltoken_select = LSLReserveToken (LST_SELECTSYM, "\\select");
747 ltoken_open = LSLReserveToken (LST_OPENSYM, "\\open");
748 ltoken_sep = LSLReserveToken (LST_SEPSYM, "\\,");
749 ltoken_close = LSLReserveToken (LST_CLOSESYM, "\\close");
750 ltoken_id = LSLReserveToken (LST_SIMPLEID, "\\:");
751 ltoken_arrow = LSLReserveToken (LST_MAPSYM, "\\arrow");
752 ltoken_farrow = LSLReserveToken (LST_FIELDMAPSYM, "\\field_arrow");
753
754 ltoken_marker = LSLReserveToken (LST_MARKERSYM, "\\marker");
755 ltoken_comment = LSLReserveToken (LST_COMMENTSYM, "\\comment");
756 ltoken_compose = LSLReserveToken (LST_COMPOSESYM, "\\composeSort");
757 ltoken_if = LSLReserveToken (LST_ifTOKEN, "if");
758
759 (void) LSLReserveToken (LST_LPAR, " (");
760 (void) LSLReserveToken (LST_RPAR, ")");
761 (void) LSLReserveToken (LST_COMMA, ",");
762 (void) LSLReserveToken (LST_COLON, ":");
763
764 (void) LSLReserveToken (LST_LBRACKET, "[");
765 (void) LSLReserveToken (LST_RBRACKET, "]");
766
767 (void) LSLReserveToken (LST_WHITESPACE, " ");
768 (void) LSLReserveToken (LST_WHITESPACE, "\t");
769 (void) LSLReserveToken (LST_WHITESPACE, "\n");
770
771 (void) LSLReserveToken (LEOFTOKEN, "E O F");
772 (void) LSLReserveToken (LST_EOL, "E O L");
773
774 (void) LSLReserveToken (LST_assertsTOKEN, "asserts");
775 (void) LSLReserveToken (LST_assumesTOKEN, "assumes");
776 (void) LSLReserveToken (LST_byTOKEN, "by");
777 (void) LSLReserveToken (LST_convertsTOKEN, "converts");
778 (void) LSLReserveToken (LST_elseTOKEN, "else");
779 (void) LSLReserveToken (LST_enumerationTOKEN, "enumeration");
780 (void) LSLReserveToken (LST_equationsTOKEN, "equations");
781 (void) LSLReserveToken (LST_exemptingTOKEN, "exempting");
782 (void) LSLReserveToken (LST_forTOKEN, "for");
783 (void) LSLReserveToken (LST_generatedTOKEN, "generated");
784 (void) LSLReserveToken (LST_impliesTOKEN, "implies");
785 (void) LSLReserveToken (LST_includesTOKEN, "includes");
786 (void) LSLReserveToken (LST_introducesTOKEN, "introduces");
787 (void) LSLReserveToken (LST_ofTOKEN, "of");
788 (void) LSLReserveToken (LST_partitionedTOKEN, "partitioned");
789 (void) LSLReserveToken (LST_thenTOKEN, "then");
790 (void) LSLReserveToken (LST_traitTOKEN, "trait");
791 (void) LSLReserveToken (LST_tupleTOKEN, "tuple");
792 (void) LSLReserveToken (LST_unionTOKEN, "union");
793 }
794
795 void
796 lscanLineReset (void)
797 {
798 }
799
800 void
801 lscanLineCleanup (void)
802 {
803 }
804
805 charCode lscanCharClass (char c)
806 {
807 return charClass[ (int) (c)].code;
808 }
809
810 bool LSLIsEndComment (char c)
811 {
812 return charClass[ (int) (c)].endCommentChar;
813 }
814
815 void lsetCharClass (char c, charCode cod)
816 {
817 charClass[ (int) (c)].code = cod;
818 }
819
820 void lsetEndCommentChar (char c, bool flag)
821 {
822 charClass[ (int) (c)].endCommentChar = flag;
823 }
Patched version for SPLint (Secure Programming Lint)