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