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