![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ecomp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / emacs|
Return to ecomp.c CVS log | Up to [Research Unix] / researchv9 / cmd / emacs |
1.1 ! root 1: #include <stdio.h> ! 2: #ifdef PC ! 3: #include "../pcompile/adapt.h" ! 4: #define setbin(file) _isbin[file->_file] = 1; ! 5: #undef getchar ! 6: #undef putchar ! 7: #define getchar() fgetc(stdin) ! 8: #define putchar(x) fputc((x), stdout) ! 9: #endif ! 10: extern char *getenv(); ! 11: ! 12: #define CTRLX 030 ! 13: #define CMENT 034 ! 14: #define META(x) (x+0200) ! 15: #define CTRL(x) (x^0100) ! 16: ! 17: #define BAD 0 ! 18: #define SIMPLE 1 ! 19: #define SDCL 2 ! 20: #define CASE 3 ! 21: #define COND 4 ! 22: #define BEGIN 5 ! 23: #define WHILE 6 ! 24: #define PSTRING 7 ! 25: #define NUMBER 8 ! 26: #define BINARY 9 ! 27: #define UNARY 10 ! 28: #define QUOTE 11 ! 29: #define INSERT 12 ! 30: #define XSTRING 13 ! 31: #define DCL 14 ! 32: #define LOCAL 15 ! 33: #define CHAR 16 ! 34: #define MAP 17 ! 35: #define GLOBAL 18 ! 36: #define SGLOBAL 19 ! 37: #define SVAL 256 /* Returns string value */ ! 38: #define DOUBLE 512 /* Command is really 2 base commands */ ! 39: ! 40: #ifndef PC ! 41: char *defdir = SDIR; ! 42: #define DEFILE "emacs_defs" ! 43: #endif ! 44: ! 45: int line = 1; ! 46: int DEBUG = 0; ! 47: char *typetable[] = { ! 48: "BAD","SIMPLE","SDCL","CASE","COND","BEGIN","WHILE", ! 49: "SSTRING","NUMBER","BINARY","UNARY","QUOTE","INSERT", ! 50: "STRING","DCL","LOCAL","CHAR","MAP","GLOBAL","SGLOBAL",NULL, ! 51: }; ! 52: ! 53: #define NHOOKS 10 ! 54: char *hooks[NHOOKS] = { ! 55: "No_Hook", ! 56: "Pre_Read_Hook", ! 57: "Post_Read_Hook", ! 58: "Pre_Write_Hook", ! 59: "Load_Macro_Hook", ! 60: "Read_Line_Hook", ! 61: "Mode_Line_Hook", ! 62: "Exit_Emacs_Hook", ! 63: "Leave_Buffer_Hook", ! 64: "Enter_Buffer_Hook", ! 65: }; ! 66: ! 67: extern char *malloc(); ! 68: struct defblk { ! 69: struct defblk *next; ! 70: char *name; ! 71: int type; ! 72: char *body; ! 73: }; ! 74: ! 75: /* Definitions for expression contexts */ ! 76: ! 77: #define CARG 1 /* function argument */ ! 78: #define CSINGLE 2 /* Must produce single command */ ! 79: #define CSTRING 4 /* Argument to string type function */ ! 80: ! 81: #define CCONT 8 /* Must generate pass-last-result after command */ ! 82: #define CCLOSE 16 /* Must generate a closing brace */ ! 83: ! 84: #define NLOCAL 10 ! 85: char *locals[NLOCAL]; ! 86: int nlocal=NLOCAL; ! 87: ! 88: #define NHASH 256 ! 89: struct defblk *hashtable[NHASH]; ! 90: ! 91: char symbuf[128]; ! 92: ! 93: char * ! 94: mstrcpy(cp,cp1) ! 95: ! 96: /* Keywords: assignment string-handling */ ! 97: register char *cp; ! 98: register char *cp1; ! 99: { ! 100: while (*cp++ = *cp1++); ! 101: return(cp-1); ! 102: } ! 103: ! 104: wrdchr(c) ! 105: int c; ! 106: { ! 107: if ((c>='a') && (c <= 'z')) return(1); ! 108: if ((c>='A') && (c <= 'Z')) return(1); ! 109: if ((c>='0') && (c <= '9')) return(1); ! 110: return(0); ! 111: } ! 112: ! 113: char * ! 114: expenv(str) ! 115: register char *str; ! 116: /* Keywords: environment-variables unix-interface user-interface:20 shell-escape:10 */ ! 117: { ! 118: char strtemp[128]; ! 119: char vartemp [64]; ! 120: register char *cp1; ! 121: char *cp2; ! 122: register int c; ! 123: int oc; ! 124: ! 125: if (str == NULL) return(NULL); ! 126: ! 127: cp1 = strtemp; ! 128: cp2 = str; ! 129: while (*cp1++ = *str) { ! 130: if ((*str== '`')||(*str=='*')||(*str=='{')||(*str=='[')||((*str++)=='?')) { ! 131: return("Error"); ! 132: } ! 133: } ! 134: cp1 = strtemp; ! 135: str = symbuf; /* always copy back into file name */ ! 136: while (c = *cp1++) { ! 137: if ((c == '$')|| (c == '~')) { ! 138: ! 139: /* Environment variable */ ! 140: ! 141: oc = c; ! 142: cp2 = vartemp; ! 143: while (wrdchr(c=((*cp1++)&0377))) { ! 144: *cp2++ = c; ! 145: } ! 146: cp1--; /* backspace pointer */ ! 147: *cp2 = 0; ! 148: if (oc == '$') { ! 149: cp2 = getenv(vartemp); /* environment variable */ ! 150: } else { ! 151: /* Home Directory */ ! 152: ! 153: if (*vartemp == 0) { ! 154: cp2 = getenv("HOME"); /* Bare ~ means home */ ! 155: } else if ((strcmp(vartemp,"exptools")==0) && ! 156: (cp2 = getenv("TOOLS")) && *cp2) { ! 157: ; ! 158: } else { ! 159: return("Error"); /* Can't do it */ ! 160: ! 161: } ! 162: } ! 163: if (cp2 != NULL) { ! 164: str = mstrcpy(str,cp2); ! 165: } else { ! 166: *str++ = oc; ! 167: str = mstrcpy(str,vartemp); ! 168: } ! 169: } else { ! 170: *str++ = c; ! 171: } ! 172: } ! 173: *str++ = 0; ! 174: return(symbuf); ! 175: } ! 176: char macb[128]; ! 177: char * ! 178: macbody(name) ! 179: char *name; ! 180: { ! 181: char *bp; ! 182: bp = macb; ! 183: *bp++ = META('x'); ! 184: while (*name) *bp++ = *name++; ! 185: *bp++ = '\n'; ! 186: *bp++ = 0; ! 187: return(macb); ! 188: } ! 189: struct defblk * ! 190: getname(name) ! 191: ! 192: char *name; ! 193: { ! 194: int hash; ! 195: char *np; ! 196: struct defblk *defp; ! 197: ! 198: np = name; ! 199: hash = 0; ! 200: while (*np) hash += *np++; ! 201: hash = hash %NHASH; ! 202: defp = hashtable[hash]; ! 203: while (defp && strcmp(name,defp->name)) defp = defp->next; ! 204: if (defp == NULL) { ! 205: defp = ((struct defblk *) malloc(sizeof(*defp))); ! 206: defp->next = hashtable[hash]; ! 207: hashtable[hash] = defp; ! 208: defp->name = malloc(strlen(name)+1); ! 209: strcpy(defp->name,name); ! 210: if ((*name == '-') || ((*name>='0') && (*name <= '9'))) { ! 211: defp->type = NUMBER; ! 212: defp->body = malloc(strlen(name)+1); ! 213: defp->body[0] = defp->name[0]+0200; ! 214: strcpy(defp->body+1,defp->name+1); ! 215: } else if ((*name == '\'') && (name[2] == '\'') && (name[3] == 0)) { ! 216: defp->type = SIMPLE; ! 217: defp->body = malloc(3); ! 218: defp->body[0] = META(CTRL('Q')); ! 219: defp->body[1] = name[1]; ! 220: defp->body[2] = 0; ! 221: } else { ! 222: fprintf(stderr,"Undefined command name %s at line %d, assumed external\n",name,line); ! 223: defp->type = SIMPLE; ! 224: name = macbody(name); ! 225: defp->body = malloc(strlen(name)); ! 226: strcpy(defp->body,name); ! 227: } ! 228: } ! 229: return(defp); ! 230: } ! 231: ! 232: lookhook(name) ! 233: char *name; ! 234: { ! 235: register int i; ! 236: for (i = 1; i < NHOOKS; i++) if(strcmp(name,hooks[i]) == 0) return(i); ! 237: return(0); ! 238: } ! 239: undefine(name) ! 240: ! 241: char *name; ! 242: { ! 243: int hash; ! 244: char *np; ! 245: struct defblk *defp; ! 246: struct defblk *odefp; ! 247: np = name; ! 248: hash = 0; ! 249: while (*np) hash += *np++; ! 250: hash = hash %NHASH; ! 251: defp = hashtable[hash]; ! 252: odefp = ((struct defblk *) &hashtable[hash]); ! 253: while (defp && strcmp(name,defp->name)) { ! 254: odefp = defp; ! 255: defp = defp->next; ! 256: } ! 257: if (defp) odefp->next = defp->next; ! 258: else { ! 259: fprintf(stderr,"Internal error undefining symbol %s\n",name); ! 260: } ! 261: } ! 262: define(name,type,body) ! 263: ! 264: char *name; ! 265: char *body; ! 266: int type; ! 267: { ! 268: int hash; ! 269: char *np; ! 270: struct defblk *defp; ! 271: ! 272: np = name; ! 273: hash = 0; ! 274: while (*np) hash += *np++; ! 275: hash = hash %NHASH; ! 276: defp = hashtable[hash]; ! 277: while (defp && strcmp(name,defp->name)) defp = defp->next; ! 278: if (defp == NULL) { ! 279: defp = ((struct defblk *) malloc(sizeof(*defp))); ! 280: defp->next = hashtable[hash]; ! 281: hashtable[hash] = defp; ! 282: defp->name = malloc(strlen(name)+1); ! 283: strcpy(defp->name,name); ! 284: } ! 285: defp->type = type; ! 286: defp->body = malloc(strlen(body)+1); ! 287: strcpy(defp->body,body); ! 288: } ! 289: ! 290: definit() ! 291: { ! 292: int i; ! 293: for (i = 0; i < NHASH; i++) { ! 294: hashtable[i] = NULL; ! 295: } ! 296: } ! 297: ! 298: ! 299: char * ! 300: symbol() ! 301: { ! 302: char *sp; ! 303: int c; ! 304: ! 305: sp = symbuf; ! 306: c = nonblank(1); ! 307: ungetc(c,stdin); ! 308: while (1) { ! 309: c = gochar(); ! 310: if ((c == EOF) || (c == ' ')|| (c == ' ')|| (c == ')') || ! 311: (c == '(') || (c == '\n')) break; ! 312: *sp++ = c; ! 313: } ! 314: ungetc(c,stdin); ! 315: if (c == '\n') line--; /* Uncount newline */ ! 316: *sp = 0; ! 317: return(symbuf); ! 318: } ! 319: ! 320: read_defs() ! 321: { ! 322: FILE *fp; ! 323: char name[128]; ! 324: int type; ! 325: char body[128]; ! 326: char *cp; ! 327: int c; ! 328: ! 329: #ifdef PC ! 330: fp = fopen ("edefs.dat","r"); ! 331: if (fp == NULL) fp = fopen ("a:edefs.dat","r"); ! 332: if (fp == NULL) fp = fopen ("b:edefs.dat","r"); ! 333: if (fp == NULL) fp = fopen ("c:edefs.dat","r"); ! 334: if (fp == NULL) { ! 335: printf ("Can't find definitions file edefs.dat\n"); ! 336: exit(0); ! 337: } ! 338: setbin(fp); ! 339: #else ! 340: cp = expenv(defdir); ! 341: sprintf(name,"%s/%s",cp,DEFILE); ! 342: fp = fopen (name,"r"); ! 343: if (fp == NULL) { ! 344: fprintf(stderr,"Can't open definitions file: %s\n",name); ! 345: fprintf(stderr,"Please contact your local emacs maintainer\n"); ! 346: exit(-1); ! 347: } ! 348: #endif ! 349: while ((c = fgetc(fp)) != EOF) { ! 350: if (c != '(') fprintf(stderr,"Internal error, bad def file format %c\n",c); ! 351: symbin(fp,name); ! 352: symbin(fp,body); ! 353: type = gtype(body); ! 354: if ((type&0377) == BAD) fprintf(stderr,"Internal error, Bad type %s for symbol %s in defs file\n",body,name); ! 355: symbin(fp,body); ! 356: while ((c = fgetc(fp)) != '\n'); ! 357: define(name,type,body); ! 358: } ! 359: fclose(fp); ! 360: } ! 361: ! 362: gtype(name) ! 363: ! 364: /* Returns type of name is a type definition, 0 otherwise */ ! 365: ! 366: char *name; ! 367: { ! 368: int c; ! 369: int type; ! 370: ! 371: type = BAD; ! 372: if (*name == '$') { ! 373: type |= SVAL; ! 374: name++; ! 375: } ! 376: c = 0; ! 377: while (typetable[c]) if (strcmp(typetable[c],name) == 0) { ! 378: type |= c; ! 379: break; ! 380: } else c++; ! 381: return(type); ! 382: } ! 383: ! 384: symbin(fp,xp) ! 385: FILE *fp; ! 386: char *xp; ! 387: { ! 388: int c; ! 389: do { ! 390: c = fgetc(fp); ! 391: } while ((c == ' ') || (c == '\n')); ! 392: ungetc(c,fp); ! 393: while (1) { ! 394: c = fgetc(fp); ! 395: if ((c == EOF) || (c == ' ') || (c == ')') || ! 396: (c == '(') || (c == '\n')) break; ! 397: if (c == '\\') { ! 398: c = fgetc(fp)-'0'; ! 399: c = c * 8 + (fgetc(fp)-'0'); ! 400: c = c * 8 + (fgetc(fp)-'0'); ! 401: } ! 402: *xp++ = c; ! 403: } ! 404: ungetc(c,fp); ! 405: *xp = 0; ! 406: } ! 407: ! 408: ! 409: main(argc, argv) ! 410: ! 411: int argc; ! 412: char *argv []; ! 413: ! 414: { ! 415: int c; ! 416: ! 417: if (argc>1) { ! 418: char buf[256]; ! 419: int x; ! 420: strcpy(buf,argv[1]); ! 421: x = strlen(buf); ! 422: if ((buf[x-2] != '.') || (buf[x-1] != 'e')) { ! 423: buf[x++]= '.'; ! 424: buf[x++] = 'e'; ! 425: buf[x]=0; ! 426: } ! 427: if (freopen(buf,"r",stdin) == NULL) { ! 428: fprintf(stderr,"Can't open input file %s\n",buf); ! 429: exit(-1); ! 430: } ! 431: buf[x-2]=0; ! 432: if (freopen(buf,"w",stdout) == NULL) { ! 433: fprintf(stderr,"Can't open output file %s\n",buf); ! 434: exit(-1); ! 435: } ! 436: #ifdef PC ! 437: setbin(stdout); ! 438: #endif ! 439: } ! 440: definit(); ! 441: read_defs(); ! 442: c = getchar(); ! 443: if (c == '#') { ! 444: DEBUG=1; ! 445: } else { ! 446: ungetc(c,stdin); ! 447: } ! 448: while ((c = nonblank(0)) != EOF) { ! 449: if (c == '(' ) function(); ! 450: } ! 451: } ! 452: ! 453: ! 454: char * ! 455: glob(name,body,arg) ! 456: char *name; ! 457: char *body; ! 458: int arg; ! 459: { ! 460: char *bp; ! 461: bp = macb; ! 462: *bp++ = CTRL('X'); ! 463: *bp++ = '<'; ! 464: while (*name) *bp++ = *name++; ! 465: *bp++ = '\n'; ! 466: *bp++ = arg; ! 467: while (*body) *bp++ = *body++; ! 468: *bp=0; ! 469: return(macb); ! 470: } ! 471: ! 472: ! 473: function() ! 474: { ! 475: char *name; ! 476: ! 477: int c; ! 478: int type; ! 479: int nobind; ! 480: ! 481: c = nonblank(0); ! 482: if (c == '(') { ! 483: c = gochar(); ! 484: while (c != ')') { ! 485: if (c == EOF) { ! 486: fprintf(stderr,"Error, macro binding sequence does not terminate\n"); ! 487: return; ! 488: } ! 489: putchar(c); ! 490: c = gochar(); ! 491: nobind = 0; ! 492: } ! 493: } else { ! 494: ungetc(c,stdin); ! 495: nobind=1; ! 496: } ! 497: ! 498: name = symbol(); ! 499: if (type=gtype(name)) { /* Name is a symbol declaration */ ! 500: name = symbol(); /* Now get real symbol */ ! 501: } else type = SIMPLE; /* Defaults to simple macro */ ! 502: if (nobind) { ! 503: nobind = lookhook(name); ! 504: putchar(CTRL('Z')); ! 505: putchar(nobind); ! 506: } ! 507: putchar (CMENT); /* ^/ */ ! 508: PUTS(name); ! 509: define(name,type,macbody(name)); ! 510: putchar (' '); ! 511: c = nonblank(0); ! 512: if (c != '(') fprintf(stderr,"Bad syntax for macro definition at line %d\n",line); ! 513: while ((c = getchar()) != ')') { ! 514: if (c == EOF) break; ! 515: putchar(c); ! 516: if (c == '\n') { ! 517: putchar(CMENT); ! 518: line++; ! 519: } ! 520: } ! 521: putchar('\n'); ! 522: parseform(0); ! 523: putchar (CTRL('Z')); ! 524: putchar('\n'); ! 525: ! 526: while (nlocal < NLOCAL) { ! 527: undefine(locals[nlocal]); ! 528: locals[nlocal] [strlen(locals[nlocal])-1] = 0; ! 529: undefine(locals[nlocal]); ! 530: nlocal++; ! 531: } ! 532: } ! 533: parseform(flags) ! 534: int flags; ! 535: { ! 536: int c; ! 537: ! 538: if (DEBUG) fprintf(stderr,"parseform\n"); ! 539: /* Now parse the form */ ! 540: while ((c = nonblank(1)) != ')') { ! 541: if (c == EOF) { ! 542: /* ARGH!! unterminated form */ ! 543: fprintf(stderr,"Unterminated form at line %d\n",line); ! 544: return; ! 545: } ! 546: if (parsememb(c,flags)&CCLOSE) fprintf(stderr,"Internal error in parsememb at line %d\n",line); ! 547: flags = 0; ! 548: } ! 549: } ! 550: parsememb(c,context) ! 551: int c; ! 552: int context; ! 553: { ! 554: char *oname; ! 555: char *name; ! 556: struct defblk *defp; ! 557: int retflags,retval; ! 558: ! 559: retflags = 0; ! 560: if (c == ')') { ! 561: ungetc(c,stdin); /* handle users typing '(foo)' */ ! 562: return(0); ! 563: } ! 564: if (c == '(') { ! 565: name = symbol(); ! 566: defp = getname(name); ! 567: if (DEBUG) fprintf(stderr,"parsememb complex %s type %s context %d\n",name,typetable[(defp->type&0377)],context); ! 568: if (defp->type & SVAL) retflags |= CSTRING; ! 569: if ((defp->type & DOUBLE) && (context & CSINGLE)) { ! 570: putchar(META('{')); ! 571: retflags |= CCLOSE; ! 572: context^= CSINGLE; ! 573: } ! 574: if (context & CARG) { ! 575: if ((defp->type & SVAL) == 0) retflags |= CCONT; ! 576: if (context&CSINGLE) { ! 577: putchar(META('{')); ! 578: retflags |= CCLOSE; ! 579: context ^= CSINGLE; ! 580: } ! 581: } ! 582: switch(defp->type&0377) { ! 583: ! 584: case GLOBAL: ! 585: name = symbol(); ! 586: define (name,SIMPLE+DOUBLE,glob(name,defp->body,META('1'))); ! 587: c = strlen(name); ! 588: oname = glob(name,defp->body,META('2')); ! 589: name[c]='='; ! 590: name[c+1] = 0; ! 591: define (name,UNARY+DOUBLE,oname); ! 592: closep(defp->name); ! 593: break; ! 594: case SGLOBAL: ! 595: { ! 596: char sbuf[128]; ! 597: ! 598: name = symbol(); ! 599: sprintf(sbuf,"%c<%s\n%s",CTRL('X'),name,defp->body); ! 600: define (name,SIMPLE+DOUBLE+SVAL,sbuf); ! 601: ! 602: sprintf(sbuf,"%s=",defp->name); ! 603: defp = getname(sbuf); /* Look up giberish for def */ ! 604: sprintf(sbuf,"%c<%s\n%s",CTRL('X'),name,defp->body); ! 605: c = strlen(name); ! 606: name[c]='='; ! 607: name[c+1] = 0; ! 608: define (name,XSTRING+DOUBLE,sbuf); ! 609: closep(defp->name); ! 610: } ! 611: break; ! 612: ! 613: case DCL: ! 614: name = symbol(); ! 615: if (c = gtype(name)) { ! 616: name = symbol(); ! 617: } else c = SIMPLE; ! 618: define(name,c,macbody(name)); ! 619: closep(name); ! 620: break; ! 621: case LOCAL: ! 622: name = symbol(); ! 623: if (--nlocal <= 1) { ! 624: fprintf (stderr,"Too many local declarations, symbol %s ignored at line %d\n",name,line); ! 625: ++nlocal; ! 626: } else { ! 627: char bod[4]; ! 628: int x; ! 629: ! 630: bod[0] = META('0')+nlocal; ! 631: bod[1] = CTRL(']'); ! 632: bod[2] = 0; ! 633: ! 634: define(name,NUMBER,bod); ! 635: x = strlen(name); ! 636: name[x]='='; ! 637: name[x+1] = 0; ! 638: bod[1] = META(CTRL(']')); ! 639: define(name,UNARY,bod); ! 640: defp = getname(name); ! 641: locals[nlocal] = defp->name; ! 642: } ! 643: closep(name); ! 644: break; ! 645: case SDCL: ! 646: name = symbol(); ! 647: if (--nlocal <= 1) { ! 648: fprintf (stderr,"Too many local declarations, symbol %s ignored at line %d\n",name,line); ! 649: ++nlocal; ! 650: } else { ! 651: char bod[10]; ! 652: int x; ! 653: ! 654: bod[0] = META('1'); ! 655: bod[1] = '2'; ! 656: bod[2] = CTRL('X'); ! 657: bod[3] = '&'; ! 658: bod[4] = META('0')+nlocal; ! 659: bod[5] = CTRL(']'); ! 660: bod[6] = CTRL('Z'); ! 661: bod[7] = 0; ! 662: define(name,SIMPLE+SVAL,bod); ! 663: x = strlen(name); ! 664: name[x]='='; ! 665: name[x+1] = 0; ! 666: bod[0] = META('0')+nlocal; ! 667: bod[1] = META(CTRL(']')); ! 668: bod[2] = META('1'); ! 669: bod[3] = '1'; ! 670: bod[4] = CTRL('X'); ! 671: bod[5] = '&'; ! 672: bod[6] = 0; ! 673: define(name,XSTRING,bod); ! 674: defp = getname(name); ! 675: locals[nlocal] = defp->name; ! 676: } ! 677: closep(name); ! 678: break; ! 679: case SIMPLE: ! 680: { ! 681: char nbuf[128]; ! 682: ! 683: strcpy(nbuf,name); ! 684: c = nonblank(1); ! 685: retflags |= parsememb(c,CARG|(context&CSINGLE)); ! 686: PUTS(defp->body); ! 687: closep(nbuf); ! 688: } ! 689: break; ! 690: case NUMBER: ! 691: PUTS (defp->body); ! 692: putchar(CTRL('Z')); ! 693: closep(name); ! 694: break; ! 695: case QUOTE: ! 696: PUTS(defp->body); ! 697: putchar(nonblank(1)); ! 698: closep(name); ! 699: break; ! 700: case BINARY: ! 701: PUTS(defp->body); ! 702: c = nonblank(1); ! 703: parsememb(c,CSINGLE); ! 704: c = nonblank(1); ! 705: parsememb(c,CSINGLE); ! 706: closep(name); ! 707: break; ! 708: case UNARY: ! 709: PUTS(defp->body); ! 710: c = nonblank(1); ! 711: parsememb(c,CSINGLE); ! 712: closep(name); ! 713: break; ! 714: case BEGIN: ! 715: putchar (META('{')); ! 716: parseform(0); ! 717: putchar (META('}')); ! 718: break; ! 719: case WHILE: ! 720: putchar (CTRLX); ! 721: putchar ('^'); ! 722: putchar (META('{')); ! 723: parseform(CSINGLE); ! 724: putchar (META('}')); ! 725: break; ! 726: case CASE: ! 727: putchar (CTRLX); ! 728: putchar ('!'); ! 729: putchar (META('{')); ! 730: c = nonblank(1); ! 731: parsememb(c,CSINGLE); ! 732: while (1) { ! 733: c = nonblank(1); ! 734: if (c == ')') break; ! 735: if (c != '(') { ! 736: fprintf(stderr,"Syntax error in case at line %d, character %c\n",line,c); ! 737: if (c == EOF) break; /* Best we can do */ ! 738: continue; ! 739: } ! 740: putchar (META('{')); ! 741: c = gochar(); ! 742: if (c == 'e') { ! 743: int c1; ! 744: c1 = gochar(); ! 745: if (c1 == 'l') { ! 746: c1 = gochar(); ! 747: c1 = gochar(); ! 748: c = 0377; /* Default case */ ! 749: } else ungetc(c1,stdin); ! 750: } ! 751: putchar(c); ! 752: parseform(0); ! 753: putchar (META('}')); ! 754: } ! 755: putchar (META('}')); ! 756: break; ! 757: case COND: ! 758: putchar(CTRLX); ! 759: putchar ('|'); ! 760: putchar (META('{')); ! 761: while (1) { ! 762: c = nonblank(1); ! 763: if (c == ')') { ! 764: putchar (META('}')); ! 765: break; ! 766: } ! 767: if (c != '(') { ! 768: fprintf(stderr,"Syntax error in conditional at line %d, character %c\n",line,c); ! 769: continue; ! 770: } ! 771: putchar(META('{')); ! 772: parseform(CSINGLE); ! 773: putchar(META('}')); ! 774: } ! 775: break; ! 776: case INSERT: ! 777: c = nonblank(1); ! 778: if (c == '"') { ! 779: while ((c=gochar()) != '"') { ! 780: if ((c <= 040) || ((c&0377) >= 0177)) { ! 781: if ((c&0377) >= 0200) putchar(META('q')); ! 782: else putchar(CTRL('Q')); ! 783: } ! 784: putchar(c&0177); ! 785: } ! 786: } else { ! 787: fprintf(stderr,"Argument to %s at line %d must be enclosed in quotes\n",name,line); ! 788: } ! 789: closep(name); ! 790: break; ! 791: case MAP: ! 792: { ! 793: char buf[256]; ! 794: char *cp; ! 795: c = nonblank(1); ! 796: if (c == '"') { ! 797: pstring(buf); ! 798: } else { ! 799: fprintf(stderr,"Argument to %s at line %d must be enclosed in quotes\n",name,line); ! 800: } ! 801: ! 802: while ((c = nonblank(1)) != ')') { ! 803: retval = parsememb(c,CARG|CSTRING|(context&CSINGLE)); ! 804: if (retval & CCLOSE) { ! 805: context &= ~CSINGLE; ! 806: retflags |= CCLOSE; ! 807: } ! 808: } ! 809: PUTS(defp->body); ! 810: cp = buf; ! 811: while (*cp) { ! 812: putchar(*cp); ! 813: cp++; ! 814: } ! 815: } ! 816: break; ! 817: case CHAR: ! 818: { ! 819: char buf[10]; ! 820: ! 821: buf[0] = nonblank(1); ! 822: if (buf[0] == CTRL('X')) { ! 823: buf[1] = nonblank(1); ! 824: buf[2]= 0; ! 825: } else buf[1] = 0; ! 826: c = nonblank(1); ! 827: if (c != ')') { ! 828: retflags |= parsememb(c,CARG|(context&CSINGLE)); ! 829: closep(defp->name); ! 830: } ! 831: PUTS(buf); ! 832: } ! 833: break; ! 834: case PSTRING: ! 835: { ! 836: char buf[256]; ! 837: char *cp; ! 838: c = nonblank(1); ! 839: if (c == '"') { ! 840: pstring(buf); ! 841: } else { ! 842: /* Argument is not a literal, must use the long form */ ! 843: ungetc(c,stdin); ! 844: sprintf(buf,"L%s",defp->name); ! 845: defp = getname(buf); ! 846: goto xstring; /* Process long form */ ! 847: } ! 848: ! 849: while ((c = nonblank(1)) != ')') { ! 850: retval = parsememb(c,CARG|CSTRING|(context&CSINGLE)); ! 851: if (retval & CCLOSE) { ! 852: context &= ~CSINGLE; ! 853: retflags |= CCLOSE; ! 854: } ! 855: } ! 856: PUTS(defp->body); ! 857: cp = buf; ! 858: while (*cp) { ! 859: if (*cp == '\n') putchar (CTRL('Q')); ! 860: if (*cp == CTRL('Z')) putchar (CTRL('Q')); ! 861: putchar(*cp); ! 862: cp++; ! 863: } ! 864: putchar('\n'); ! 865: } ! 866: break; ! 867: case XSTRING: ! 868: xstring: while ((c = nonblank(1)) != ')') { ! 869: retval = parsememb(c,CARG|CSTRING|(context&CSINGLE)); ! 870: if (retval & CCLOSE) { ! 871: context &= ~CSINGLE; ! 872: retflags |= CCLOSE; ! 873: } ! 874: } ! 875: PUTS(defp->body); ! 876: break; ! 877: default: ! 878: fprintf(stderr,"Error in parser at line %d, name %s\n",line,name); ! 879: } ! 880: } else { ! 881: if (c == '"') { /* String argument, if appropriate, push it */ ! 882: if ((context & CSTRING) == 0) { ! 883: fprintf(stderr,"Misplaced character string at line %d\n",line); ! 884: } ! 885: if (context & CSINGLE) { ! 886: retflags |= CCLOSE; ! 887: putchar(META('{')); ! 888: } ! 889: putchar (CTRL('X')); ! 890: putchar ('<'); ! 891: pstring (NULL); ! 892: retflags |= CSTRING; ! 893: } else { ! 894: ungetc(c,stdin); ! 895: name = symbol(); ! 896: defp = getname(name); ! 897: if (defp->type & SVAL) retflags |= CSTRING; ! 898: if ((defp->type & DOUBLE) && (context & CSINGLE)) { ! 899: putchar(META('{')); ! 900: retflags |= CCLOSE; ! 901: context^= CSINGLE; ! 902: } ! 903: if (DEBUG) fprintf(stderr,"parsememb simple %s type %s, context: %d\n",name,typetable[defp->type&0377],context); ! 904: switch(defp->type&0377) { ! 905: case SIMPLE: ! 906: case XSTRING: ! 907: if (context & CARG) { ! 908: if ((defp->type & SVAL) == 0) retflags |= CCONT; ! 909: if (context&CSINGLE) { ! 910: putchar(META('{')); ! 911: retflags |= CCLOSE; ! 912: } ! 913: } ! 914: PUTS(defp->body); ! 915: break; ! 916: case NUMBER: ! 917: PUTS (defp->body); ! 918: if ((context &CARG) == 0) putchar(CTRL('Z')); ! 919: break; ! 920: default: ! 921: fprintf(stderr,"function %s at line %d requires arguments\n",name,line); ! 922: } ! 923: } ! 924: } ! 925: if (DEBUG) { ! 926: c = getchar(); ! 927: fprintf(stderr,"exiting parsememb before %c\n",c); ! 928: ungetc(c,stdin); ! 929: } ! 930: ! 931: if (((context & CARG) == 0) && (retflags & CCLOSE)) { ! 932: putchar(CTRL('^')); ! 933: putchar(META('}')); ! 934: retflags &= ~(CCLOSE|CARG); ! 935: } ! 936: if (retflags & CCONT) putchar(CTRL('^')); ! 937: return(retflags & (CCLOSE^CSTRING)); ! 938: } ! 939: closep(name) ! 940: char *name; ! 941: { ! 942: int c; ! 943: ! 944: c = nonblank(1); ! 945: if (c != ')') { ! 946: fprintf(stderr,"Syntax error at line %d, extraneous characters in form after %s\n Ignoring characters:",line,name); ! 947: while ((c = getchar()) != ')') { ! 948: if (c == EOF) break; ! 949: fputc(c,stderr); ! 950: } ! 951: fputc('\n',stderr); ! 952: } ! 953: } ! 954: gochar() ! 955: { ! 956: int c; ! 957: ! 958: c = getchar(); ! 959: if (c == '\n') line++; ! 960: if (c != '\\') return(c); ! 961: else { ! 962: c = getchar(); ! 963: if (c == 'n') return('\n'+01000); ! 964: if ((c >= '0') && (c <= '7')) { ! 965: c -= '0'; ! 966: c = c*8 + getchar() - '0'; ! 967: c = c*8 + getchar() - '0'; ! 968: } ! 969: return(c+01000); /* Make sure it doesn't match anything */ ! 970: } ! 971: } ! 972: nonblank(cment) ! 973: int cment; ! 974: { ! 975: int c; ! 976: while (1) { ! 977: c = gochar(); ! 978: if (c == EOF) return(c); ! 979: if ((c == ' ') || (c == ' ')) continue; ! 980: if (c == '\n') { ! 981: continue; ! 982: } ! 983: if (c == '/') { ! 984: if (cment) putchar(CMENT); ! 985: while ((c = getchar()) != '/') { ! 986: if (c == EOF) { ! 987: fprintf(stderr,"unterminated comment"); ! 988: return(c); ! 989: } ! 990: if (cment) putchar(c); ! 991: if (c == '\n') { ! 992: if (cment) putchar(CMENT); ! 993: line++; ! 994: } ! 995: } ! 996: if (cment) putchar('\n'); ! 997: continue; ! 998: } ! 999: return(c); ! 1000: } ! 1001: } ! 1002: ! 1003: PUTS(string) ! 1004: char *string; ! 1005: { ! 1006: while (*string){ ! 1007: putchar(*string); ! 1008: string++; ! 1009: } ! 1010: } ! 1011: pstring(ptr) ! 1012: char *ptr; ! 1013: { ! 1014: int c; ! 1015: int oline; ! 1016: oline = line; ! 1017: while ((c = gochar()) != '"') { ! 1018: if (c == EOF) { ! 1019: fprintf(stderr,"Unterminated string starting at line %d\n",oline); ! 1020: break; ! 1021: } ! 1022: if (ptr) { ! 1023: *ptr++ = c; ! 1024: } else { ! 1025: if ((c&0377) == '\n') putchar(CTRL('Q')); ! 1026: if ((c&0377) == CTRL('Z')) putchar(CTRL('Q')); ! 1027: putchar(c); ! 1028: } ! 1029: } ! 1030: if (ptr) { ! 1031: *ptr++ = 0; ! 1032: } else { ! 1033: putchar('\n'); ! 1034: } ! 1035: } ! 1036: ! 1037: xgetc(fp) ! 1038: FILE *fp; ! 1039: { ! 1040: int c; ! 1041: ! 1042: c= fgetc(fp); ! 1043: fprintf(stderr,"got '%c' %o\n",c); ! 1044: return(c); ! 1045: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.