![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rcslex.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / rcs / src|
Return to rcslex.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / rcs / src |
1.1 root 1: /*
2: * RCS file input
3: */
4: static char rcsid[]=
5: "$Header: /usr/wft/RCS/SRC/RCS/rcslex.c,v 3.3 82/12/10 16:22:37 wft Exp $ Purdue CS";
6: /*********************************************************************************
7: * Lexical Analysis.
8: * Character mapping table,
9: * hashtable, Lexinit, nextlex, getlex, getkey,
10: * getid, getnum, readstring, printstring, savestring,
11: * checkid, serror, fatserror, error, faterror, warn, diagnose
12: * fflsbuf, puts, fprintf
13: * Testprogram: define LEXDB
14: *********************************************************************************
15: *
16: * Copyright (C) 1982 by Walter F. Tichy
17: * Purdue University
18: * Computer Science Department
19: * West Lafayette, IN 47907
20: *
21: * All rights reserved. No part of this software may be sold or distributed
22: * in any form or by any means without the prior written permission of the
23: * author.
24: * Report problems and direct all inquiries to Tichy@purdue (ARPA net).
25: */
26:
27: /* $Log: rcslex.c,v $
28: * Revision 3.3 82/12/10 16:22:37 wft
29: * Improved error messages, changed exit status on error to 1.
30: *
31: * Revision 3.2 82/11/28 21:27:10 wft
32: * Renamed ctab to map and included EOFILE; ctab is now a macro in rcsbase.h.
33: * Added fflsbuf(), fputs(), and fprintf(), which abort the RCS operations
34: * properly in case there is an IO-error (e.g., file system full).
35: *
36: * Revision 3.1 82/10/11 19:43:56 wft
37: * removed unused label out:;
38: * made sure all calls to getc() return into an integer, not a char.
39: */
40:
41:
42: /*
43: #define LEXDB
44: /* version LEXDB is for testing the lexical analyzer. The testprogram
45: * reads a stream of lexemes, enters the revision numbers into the
46: * hashtable, and prints the recognized tokens. Keywords are recognized
47: * as identifiers.
48: */
49:
50:
51:
52: #include "rcsbase.h"
53:
54:
55:
56: /* character mapping table */
57: enum tokens map[] = {
58: EOFILE, /* this will end up at ctab[-1] */
59: UNKN, INSERT, UNKN, UNKN, UNKN, UNKN, UNKN, UNKN,
60: UNKN, SPACE, NEWLN, UNKN, SPACE, UNKN, UNKN, UNKN,
61: UNKN, UNKN, UNKN, UNKN, UNKN, UNKN, UNKN, UNKN,
62: UNKN, UNKN, UNKN, UNKN, UNKN, UNKN, UNKN, UNKN,
63: SPACE, EXCLA, DQUOTE, HASH, DOLLAR, PERCNT, AMPER, SQUOTE,
64: LPARN, RPARN, TIMES, PLUS, COMMA, MINUS, PERIOD, DIVIDE,
65: DIGIT, DIGIT, DIGIT, DIGIT, DIGIT, DIGIT, DIGIT, DIGIT,
66: DIGIT, DIGIT, COLON, SEMI, LESS, EQUAL, GREAT, QUEST,
67: AT, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER,
68: LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER,
69: LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER,
70: LETTER, LETTER, LETTER, LBRACK, BACKSL, RBRACK, UPARR, UNDER,
71: ACCENT, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER,
72: LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER,
73: LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER, LETTER,
74: LETTER, LETTER, LETTER, LBRACE, BAR, RBRACE, TILDE, UNKN
75: };
76:
77:
78:
79:
80: struct hshentry * nexthsh; /*pointer to next hashtable-entry, set by lookup*/
81:
82: enum tokens nexttok; /*next token, set by nextlex */
83:
84: int hshenter /*if true, next suitable lexeme will be entered */
85: = true; /*into the symbol table. Handle with care. */
86: int nextc; /*next input character, initialized by Lexinit */
87:
88: int eof /*end-of-file indicator, set to >0 on end of file*/
89: = 0;
90: int line /*current line-number of input */
91: = 1;
92: int nerror /*counter for errors */
93: = 0;
94: int nwarn /*counter for warnings */
95: = 0;
96: char * cmdid /*command identification for error messages */
97: = nil;
98: int quietflag /*indicates quiet mode */
99: = false;
100: FILE * finptr; /*input file descriptor */
101:
102: FILE * frewrite; /*file descriptor for echoing input */
103:
104: int rewriteflag;/*indicates whether to echo to frewrite */
105:
106: char StringTab[strtsize]; /* string table and heap */
107:
108: char * NextString /*pointer to next identifier in StringTab*/
109: = nil;
110: char * Topchar /*pointer to next free byte in StringTab*/
111: = &StringTab[0]; /*set by nextlex, lookup */
112: struct hshentry hshtab[hshsize]; /*hashtable */
113:
114:
115:
116:
117:
118: lookup() {
119:
120: /* Function: Looks up the character string pointed to by NextString in the
121: * hashtable. If the string is not present, a new entry for it is created.
122: * If the string is present, TopChar is moved back to save the space for
123: * the string, and NextString is set to point to the original string.
124: * In any case, the address of the corresponding hashtable entry is placed
125: * into nexthsh.
126: * Algorithm: Quadratic hash, covering all entries.
127: * Assumptions: NextString points at the first character of the string.
128: * Topchar points at the first empty byte after the string.
129: */
130:
131: register int ihash; /* index into hashtable */
132: register char * sp, * np;
133: int c, delta, final, FirstScan; /*loop control*/
134:
135: /* calculate hash code */
136: sp = NextString;
137: ihash = 0;
138: while (*sp) ihash += *sp++;
139:
140: /* set up first search loop (c=0,step=1,until (hshsiz-1)/2 */
141: c=0;delta=1;final=(hshsize-1)/2;
142: FirstScan=true; /*first loop */
143:
144: for (;;) {
145: ihash = (ihash+c)%hshsize; /*next index*/
146:
147: if (hshtab[ihash].num == nil) {
148: /*empty slot found*/
149: hshtab[ihash].num = NextString;
150: nexthsh= &hshtab[ihash];/*save hashtable address*/
151: # ifdef LEXDB
152: printf("\nEntered: %s at %d ",nexthsh->num, ihash);
153: # endif
154: return;
155: }
156: /* compare strings */
157: sp=NextString;np=hshtab[ihash].num;
158: while (*sp == *np++) {
159: if (*sp == 0) {
160: /* match found */
161: nexthsh= &hshtab[ihash];
162: Topchar = NextString;
163: NextString = nexthsh->num;
164: return;
165: } else sp++;
166: }
167:
168: /* neither empty slot nor string found */
169: /* calculate next index and repeat */
170: if (c != final)
171: c += delta;
172: else {
173: if (FirstScan) {
174: /*set up second sweep*/
175: delta = -1; final = 1; FirstScan= false;
176: } else {
177: fatserror("Hashtable overflow");
178: }
179: }
180: }
181: };
182:
183:
184:
185:
186:
187:
188: Lexinit()
189: /* Function: Initialization of lexical analyzer:
190: * initializes the hastable,
191: * initializes nextc, nexttok if finptr != NULL
192: */
193: { register int i;
194:
195: for (i=hshsize-1; i>=0; i--) {
196: hshtab[i].num = nil;
197: }
198:
199: hshenter=true; eof=0; line=1; nerror=0; nwarn=0;
200: NextString=nil; Topchar = &StringTab[0];
201: if (finptr) {
202: nextc = GETC(finptr,frewrite,rewriteflag); /*initial character*/
203: nextlex(); /*initial token*/
204: } else {
205: nextc = '\0';
206: nexttok=EOFILE;
207: }
208: }
209:
210:
211:
212:
213:
214:
215:
216: nextlex()
217:
218: /* Function: Reads the next token and sets nexttok to the next token code.
219: * Only if the hshenter==true, a revision number is entered into the
220: * hashtable and a pointer to it is placed into nexthsh.
221: * This is useful for avoiding that dates are placed into the hashtable.
222: * For ID's and NUM's, NextString is set to the character string in the
223: * string table. Assumption: nextc contains the next character.
224: */
225: { register c;
226: register char * sp;
227: register enum tokens d;
228:
229: if (eof) {
230: nexttok=EOFILE;
231: return;
232: }
233: loop:
234: switch(nexttok=ctab[nextc]) {
235:
236: case UNKN:
237: case IDCHAR:
238: case PERIOD:
239: serror("unknown Character: %c",nextc);
240: nextc=GETC(finptr,frewrite,rewriteflag);
241: goto loop;
242:
243: case NEWLN:
244: line++;
245: # ifdef LEXDB
246: putchar('\n');
247: # endif
248: /* Note: falls into next case */
249:
250: case SPACE:
251: nextc=GETC(finptr,frewrite,rewriteflag);
252: goto loop;
253:
254: case EOFILE:
255: eof++;
256: nexttok=EOFILE;
257: return;
258:
259: case DIGIT:
260: NextString = sp = Topchar;
261: *sp++ = nextc;
262: while ((d=ctab[c=GETC(finptr,frewrite,rewriteflag)])==DIGIT ||
263: d==PERIOD) {
264: *sp++ = c; /* 1.2. and 1.2 are different */
265: }
266: *sp++ = '\0';
267: if (sp >= StringTab+strtsize) {
268: /*may have written outside stringtable already*/
269: fatserror("Stringtable overflow");
270: }
271: Topchar = sp;
272: nextc = c;
273: if (hshenter == true)
274: lookup(); /* lookup updates NextString, Topchar*/
275: nexttok = NUM;
276: return;
277:
278:
279: case LETTER:
280: NextString = sp = Topchar;
281: *sp++ = nextc;
282: while ((d=ctab[c=GETC(finptr,frewrite,rewriteflag)])==LETTER ||
283: d==DIGIT || d==IDCHAR) {
284: *sp++ = c;
285: }
286: *sp++ = '\0';
287: if (sp >= StringTab+strtsize) {
288: /*may have written outside stringtable already*/
289: fatserror("Stringtable overflow");
290: }
291: Topchar = sp;
292: nextc = c;
293: nexttok = ID; /* may be ID or keyword */
294: return;
295:
296: case SBEGIN: /* long string */
297: nexttok = STRING;
298: /* note: only the initial SBEGIN has been read*/
299: /* read the string, and reset nextc afterwards*/
300: return;
301:
302: default:
303: nextc=GETC(finptr,frewrite,rewriteflag);
304: return;
305: }
306: }
307:
308:
309: int getlex(token)
310: enum tokens token;
311: /* Function: Checks if nexttok is the same as token. If so,
312: * advances the input by calling nextlex and returns true.
313: * otherwise returns false.
314: * Doesn't work for strings and keywords; loses the character string for ids.
315: */
316: {
317: if (nexttok==token) {
318: nextlex();
319: return(true);
320: } else return(false);
321: }
322:
323: int getkey (key)
324: char * key;
325: /* Function: If the current token is a keyword identical to key,
326: * getkey advances the input by calling nextlex and returns true;
327: * otherwise returns false.
328: */
329: {
330: register char *s1,*s2;
331:
332: if (nexttok==ID) {
333: s1=key; s2=NextString;
334: while(*s1 == *s2++)
335: if (*s1++ == '\0') {
336: /* match found */
337: Topchar = NextString; /*reset Topchar */
338: nextlex();
339: return(true);
340: }
341: }
342: return(false);
343: }
344:
345:
346:
347: char * getid()
348: /* Function: Checks if nexttok is an identifier. If so,
349: * advances the input by calling nextlex and returns a pointer
350: * to the identifier; otherwise returns nil.
351: * Treats keywords as identifiers.
352: */
353: {
354: register char * name;
355: if (nexttok==ID) {
356: name = NextString;
357: nextlex();
358: return name;
359: } else return nil;
360: }
361:
362:
363: struct hshentry * getnum()
364: /* Function: Checks if nexttok is a number. If so,
365: * advances the input by calling nextlex and returns a pointer
366: * to the hashtable entry. Otherwise returns nil.
367: * Doesn't work if hshenter is false.
368: */
369: {
370: register struct hshentry * num;
371: if (nexttok==NUM) {
372: num=nexthsh;
373: nextlex();
374: return num;
375: } else return nil;
376: }
377:
378:
379: readstring()
380: /* skip over characters until terminating single SDELIM */
381: /* if rewriteflag==true, copy every character read to frewrite.*/
382: /* Does not advance nextlex at the end. */
383: { register c;
384: if (rewriteflag) {
385: /* copy string verbatim to frewrite */
386: while ((c=putc(getc(finptr),frewrite)) != EOF) {
387: if (c==SDELIM) {
388: if ((c=putc(getc(finptr),frewrite)) != SDELIM) {
389: /* end of string */
390: nextc=c;
391: return;
392: }
393: }
394: }
395: } else {
396: /* skip string */
397: while ((c=getc(finptr)) != EOF) {
398: if (c==SDELIM) {
399: if ((c=getc(finptr)) != SDELIM) {
400: /* end of string */
401: nextc=c;
402: return;
403: }
404: }
405: }
406: }
407: nextc = c;
408: error("Unterminated string");
409: }
410:
411:
412: printstring()
413: /* Function: copy a string to stdout, until terminated with a single SDELIM.
414: * Does not advance nextlex at the end.
415: */
416: {
417: register c;
418: while ((c=getc(finptr)) != EOF) {
419: if (c==SDELIM) {
420: if ((c=getc(finptr)) != SDELIM) {
421: /* end of string */
422: nextc=c;
423: return;
424: }
425: }
426: putchar(c);
427: }
428: nextc = c;
429: error("Unterminated string");
430: }
431:
432:
433:
434: int savestring(target,length)
435: char * target; int length;
436: /* copies a string terminated with SDELIM from file finptr to buffer target,
437: * but not more than length bytes. If the string is longer than length,
438: * the extra characters are skipped. The string may be empty, in which
439: * case a '\0' is placed into target.
440: * Double SDELIM is replaced with SDELIM.
441: * If rewriteflag==true, the string is also copied unchanged to frewrite.
442: * Returns the length of the saved string.
443: * Does not advance nextlex at the end.
444: */
445: {
446: register char * tp, * max;
447: register c;
448:
449: tp=target; max= target+length; /*max is one too large*/
450: while ((c=GETC(finptr,frewrite,rewriteflag))!=EOF) {
451: *tp++ =c;
452: if (c== SDELIM) {
453: if ((c=GETC(finptr,frewrite,rewriteflag))!=SDELIM) {
454: /* end of string */
455: *(tp-1)='\0';
456: nextc=c;
457: return tp-target;
458: }
459: }
460: if (tp >= max) {
461: /* overflow */
462: error("string buffer overflow -- truncating string");
463: target[length-1]='\0';
464: /* skip rest of string */
465: while ((c=GETC(finptr,frewrite,rewriteflag))!=EOF) {
466: if ((c==SDELIM) && ((c=GETC(finptr,frewrite,rewriteflag))!=SDELIM)) {
467: /* end of string */
468: nextc=c;
469: return length;
470: }
471: }
472: nextc = c;
473: error("Can't find %c to terminate string before end of file",SDELIM);
474: return length;
475: }
476: }
477: nextc = c;
478: error("Can't find %c to terminate string before end of file",SDELIM);
479: return length;
480: }
481:
482:
483: char *checkid(id, delim)
484: char *id, delim;
485: /* Function: check whether the string starting at id is an */
486: /* identifier and return a pointer to the last char*/
487: /* of the identifer. White space, delim and '\0' */
488: /* are legal delimeters. Aborts the program if not */
489: /* a legal identifier. Useful for checking commands*/
490: {
491: register enum tokens d;
492: register char *temp;
493: register char c,tc;
494:
495: temp = id;
496: if ( ctab[*id] == LETTER ) {
497: while( (d=ctab[c=(*++id)]) == LETTER || d==DIGIT || d==IDCHAR) ;
498: if ( c!=' ' && c!='\t' && c!='\n' && c!='\0' && c!=delim) {
499: /* append \0 to end of id before error message */
500: tc = c;
501: while( (c=(*++id))!=' ' && c!='\t' && c!='\n' && c!='\0' && c!=delim) ;
502: *id = '\0';
503: faterror("Invalid character %c in identifier %s",tc,temp);
504: return nil ;
505: } else
506: return id;
507: } else {
508: /* append \0 to end of id before error message */
509: while( (c=(*++id))!=' ' && c!='\t' && c!='\n' && c!='\0' && c!=delim) ;
510: *id = '\0';
511: faterror("Identifier %s does not start with letter",temp);
512: return nil;
513: }
514: }
515:
516:
517: serror(e,e1,e2,e3,e4,e5)
518: char * e, * e1;
519: /* non-fatal syntax error */
520: { nerror++;
521: fprintf(stderr,"%s error, line %d: ", cmdid, line);
522: fprintf(stderr,e, e1, e2, e3, e4, e5);
523: putc('\n',stderr);
524: }
525:
526: error(e,e1,e2,e3,e4,e5)
527: char * e, * e1;
528: /* non-fatal error */
529: { nerror++;
530: fprintf(stderr,"%s error: ",cmdid);
531: fprintf(stderr,e, e1, e2, e3, e4, e5);
532: putc('\n',stderr);
533: }
534:
535: fatserror(e,e1,e2,e3,e4,e5)
536: char * e, * e1;
537: /* fatal syntax error */
538: { nerror++;
539: fprintf(stderr,"%s error, line %d: ", cmdid,line);
540: fprintf(stderr,e, e1, e2, e3, e4, e5);
541: fprintf(stderr,"\n%s aborted\n",cmdid);
542: cleanup();
543: exit(1);
544: }
545:
546: faterror(e,e1,e2,e3,e4,e5)
547: char * e, * e1;
548: /* fatal error, terminates program after cleanup */
549: { nerror++;
550: fprintf(stderr,"%s error: ",cmdid);
551: fprintf(stderr,e, e1, e2, e3, e4, e5);
552: fprintf(stderr,"\n%s aborted\n",cmdid);
553: cleanup();
554: exit(1);
555: }
556:
557: warn(e,e1,e2,e3,e4,e5)
558: char * e, * e1;
559: /* prints a warning message */
560: { nwarn++;
561: fprintf(stderr,"%s warning: ",cmdid);
562: fprintf(stderr,e, e1, e2, e3, e4, e5);
563: putc('\n',stderr);
564: }
565:
566:
567: diagnose(e,e1,e2,e3,e4,e5)
568: char * e, * e1;
569: /* prints a diagnostic message */
570: {
571: if (!quietflag) {
572: fprintf(stderr,e, e1, e2, e3, e4, e5);
573: putc('\n',stderr);
574: }
575: }
576:
577:
578:
579: fflsbuf(c, iop)
580: int c; register FILE * iop;
581: /* Function: Flush iop.
582: * Same routine as _flsbuf in stdio, but aborts program on error.
583: */
584: { register result;
585: if ((result=_flsbuf(c,iop))==EOF)
586: faterror("write error");
587: return result;
588: }
589:
590:
591: fputs(s, iop)
592: register char *s;
593: register FILE *iop;
594: /* Function: Put string s on file iop, abort on error.
595: * Same as puts in stdio, but with different putc macro.
596: */
597: {
598: register r;
599: register c;
600:
601: while (c = *s++)
602: r = putc(c, iop);
603: return(r);
604: }
605:
606:
607:
608: fprintf(iop, fmt, args)
609: FILE *iop;
610: char *fmt;
611: /* Function: formatted output. Same as fprintf in stdio,
612: * but aborts program on error
613: */
614: {
615: _doprnt(fmt, &args, iop);
616: if (ferror(iop)) {
617: faterror("write error");
618: return EOF;
619: } else return 0;
620: }
621:
622:
623:
624: #ifdef LEXDB
625: /* test program reading a stream of lexems and printing the tokens.
626: */
627:
628:
629:
630: main(argc,argv)
631: int argc; char * argv[];
632: {
633: cmdid="lextest";
634: if (argc<2) {
635: fputs("No input file\n",stderr);
636: exit(1);
637: }
638: if ((finptr=fopen(argv[1], "r")) == NULL) {
639: faterror("Can't open input file %s\n",argv[1]);
640: }
641: Lexinit();
642: rewriteflag=false;
643: while (nexttok != EOFILE) {
644: switch (nexttok) {
645:
646: case ID:
647: printf("ID: %s",NextString);
648: break;
649:
650: case NUM:
651: if (hshenter==true)
652: printf("NUM: %s, index: %d",nexthsh->num, nexthsh-hshtab);
653: else
654: printf("NUM, unentered: %s",NextString);
655: hshenter = !hshenter; /*alternate between dates and numbers*/
656: break;
657:
658: case COLON:
659: printf("COLON"); break;
660:
661: case SEMI:
662: printf("SEMI"); break;
663:
664: case STRING:
665: readstring();
666: printf("STRING"); break;
667:
668: case UNKN:
669: printf("UNKN"); break;
670:
671: default:
672: printf("DEFAULT"); break;
673: }
674: printf(" | ");
675: nextlex();
676: }
677: printf("\nEnd of lexical analyzer test\n");
678: }
679:
680: cleanup()
681: /* dummy */
682: {}
683:
684:
685: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.