4.3BSD - /usr/ingres/source/monitor/mac.c

   1: # include   <useful.h>
   2: # include   <sccs.h>
   3: 
   4: SCCSID(@(#)mac.c	8.1	12/31/84)
   5: 
   6: 
   7: # define TRACE if (FALSE) printf
   8: 
   9: /*
  10: **  MACRO PROCESSOR
  11: */
  12: 
  13: 
  14: # define    ANYDELIM    '\020'      /* \| -- zero or more delims */
  15: # define    ONEDELIM    '\021'      /* \^ -- exactly one delim */
  16: # define    CHANGE      '\022'      /* \& -- token change */
  17: 
  18: # define    PARAMN      '\023'      /* $ -- non-preprocessed param */
  19: # define    PARAMP      '\024'      /* $$ -- preprocessed param */
  20: 
  21: # define    PRESCANENABLE   '@'     /* character to enable prescan */
  22: # define    LBRACE      '{'     /* left brace */
  23: # define    RBRACE      '}'     /* right brace */
  24: # define    BACKSLASH   '\\'        /* backslash */
  25: # define    LQUOTE      '`'     /* left quote */
  26: # define    RQUOTE      '\''        /* right quote */
  27: # define    SPACE       ' '
  28: # define    TAB     '\t'
  29: # define    NEWLINE     '\n'
  30: 
  31: # define    QUOTED      0200        /* pass right through bit */
  32: # define    CHARMASK    0177        /* character part */
  33: # define    BYTEMASK    0377        /* one byte */
  34: 
  35: # define    ITERTHRESH  100     /* iteration limit */
  36: # define    NPRIMS      (sizeof Macprims / sizeof Macprims[0])
  37: 
  38: /* token modes, used to compute token changes */
  39: # define    NONE        0       /* guarantees a token change */
  40: # define    ID      1       /* identifier */
  41: # define    NUMBER      2       /* number (int or float) */
  42: # define    DELIM       3       /* delimiter, guarantees a token change */
  43: # define    QUOTEMODE   4       /* quoted construct */
  44: # define    OP      5       /* operator */
  45: # define    NOCHANGE    6       /* guarantees no token change */
  46: 
  47: 
  48: 
  49: # include   "buf.h"         /* headers for buffer manip */
  50: 
  51: 
  52: /* macro definitions */
  53: struct macro
  54: {
  55:     struct macro    *nextm;     /* pointer to next macro header */
  56:     char        *template;  /* pointer to macro template */
  57:     char        *substitute;    /* pointer to substitution text */
  58: };
  59: 
  60: /* primitive declarations */
  61: struct macro    Macprims[] =
  62: {
  63:     &Macprims[1],   "{define;\020\024t;\020\024s}",             (char *) 1,
  64:     &Macprims[2],   "{rawdefine;\020\024t;\020\024s}",          (char *) 2,
  65:     &Macprims[3],   "{remove;\020\024t}",                   (char *) 3,
  66:     &Macprims[4],   "{dump}",                       (char *) 4,
  67:     &Macprims[5],   "{type\020\024m}",                  (char *) 5,
  68:     &Macprims[6],   "{read\020\024m}",                  (char *) 6,
  69:     &Macprims[7],   "{readdefine;\020\024n;\020\024m}",         (char *) 7,
  70:     &Macprims[8],   "{ifsame;\020\024a;\020\024b;\020\023t;\020\023f}", (char *) 8,
  71:     &Macprims[9],   "{ifeq;\020\024a;\020\024b;\020\023t;\020\023f}",   (char *) 9,
  72:     &Macprims[10],  "{ifgt;\020\024a;\020\024b;\020\023t;\020\023f}",   (char *) 10,
  73:     &Macprims[11],  "{eval\020\024e}",                  (char *) 11,
  74:     &Macprims[12],  "{substr;\020\024f;\020\024t;\024s}",           (char *) 12,
  75:     &Macprims[13],  "{dnl}",                        (char *) 13,
  76:     &Macprims[14],  "{remove}",                     (char *) 3,
  77:     0,      "{dump;\020\024n}",                 (char *) 4,
  78: };
  79: 
  80: struct macro    *Machead    = &Macprims[0]; /* head of macro list */
  81: 
  82: 
  83: /* parameters */
  84: struct param
  85: {
  86:     struct param    *nextp;
  87:     char        mode;
  88:     char        name;
  89:     char        *paramt;
  90: };
  91: 
  92: 
  93: 
  94: /* the environment */
  95: struct env
  96: {
  97:     struct env  *nexte;     /* next environment */
  98:     int     (*rawget)();    /* raw character get routine */
  99:     char        **rawpar;   /* a parameter to that routine */
 100:     char        prevchar;   /* previous character read */
 101:     char        tokenmode;  /* current token mode */
 102:     char        change;     /* token change flag */
 103:     char        eof;        /* eof flag */
 104:     char        newline;    /* set if bol */
 105:     char        rawnewline; /* same for raw input */
 106:     struct buf  *pbuf;      /* peek buffer */
 107:     struct buf  *mbuf;      /* macro buffer */
 108:     char        endtrap;    /* endtrap flag */
 109:     char        pass;       /* pass flag */
 110:     char        pdelim;     /* current parameter delimiter */
 111:     struct param    *params;    /* parameter list */
 112:     int     itercount;  /* iteration count */
 113:     int     quotelevel; /* quote nesting level */
 114: };
 115: 
 116: /* current environment pointer */
 117: struct env  *Macenv;
 118: /*
 119: **  MACINIT -- initialize for macro processing
 120: **
 121: **	*** EXTERNAL INTERFACE ***
 122: **
 123: **	The macro processor is initialized.  Any crap left over from
 124: **	previous processing (which will never occur normally, but may
 125: **	happen on an interrupt, for instance) will be cleaned up.  The
 126: **	raw input is defined, and the 'endtrap' parameter tells whether
 127: **	this is "primary" processing or not; in other words, it tells
 128: **	whether to spring {begintrap} and {endtrap}.
 129: **
 130: **	This routine must always be called prior to any processing.
 131: */
 132: 
 133: macinit(rawget, rawpar, endtrap)
 134: int (*rawget)();
 135: char    **rawpar;
 136: int endtrap;
 137: {
 138:     static struct env   env;
 139:     register struct env *e;
 140:     register struct env *f;
 141: 
 142:     /* clear out old crap */
 143:     for (e = Macenv; e != 0; e = f)
 144:     {
 145:         bufpurge(&e->mbuf);
 146:         bufpurge(&e->pbuf);
 147:         macpflush(e);
 148:         f = e->nexte;
 149:         if (f != 0)
 150:             buffree(e);
 151:     }
 152: 
 153:     /* set up the primary environment */
 154:     Macenv = e = &env;
 155:     clrmem(e, sizeof *e);
 156: 
 157:     e->rawget = rawget;
 158:     e->rawpar = rawpar;
 159:     e->endtrap = endtrap;
 160:     e->newline = 1;
 161: 
 162:     if (endtrap)
 163:         macspring("{begintrap}");
 164: }
 165: /*
 166: **  MACGETCH -- get character after macro processing
 167: **
 168: **	*** EXTERNAL INTERFACE ROUTINE ***
 169: **
 170: **	The macro processor must have been previously initialized by a
 171: **	call to macinit().
 172: */
 173: 
 174: macgetch()
 175: {
 176:     register struct env *e;
 177:     register int        c;
 178: 
 179:     e = Macenv;
 180:     for (;;)
 181:     {
 182:         /* get an input character */
 183:         c = macgch();
 184: 
 185:         /* check for end-of-file processing */
 186:         if (c == 0)
 187:         {
 188:             /* check to see if we should spring {endtrap} */
 189:             if (e->endtrap)
 190:             {
 191:                 e->endtrap = 0;
 192:                 macspring("{endtrap}");
 193:                 continue;
 194:             }
 195: 
 196:             /* don't spring endtrap -- real end of file */
 197:             return (0);
 198:         }
 199: 
 200:         /* not an end of file -- check for pass character through */
 201:         if (e->pass)
 202:         {
 203:             e->pass = 0;
 204:             e->change = 0;
 205:         }
 206:         if ((c & QUOTED) != 0 || !e->change || e->tokenmode == DELIM)
 207:         {
 208:             /* the character is to be passed through */
 209:             /* reset iteration count and purge macro buffer */
 210:             e->itercount = 0;
 211:             bufflush(&e->mbuf);
 212:             e->newline = (c == NEWLINE);
 213:             return (c & CHARMASK);
 214:         }
 215: 
 216:         /* this character is a candidate for macro processing */
 217:         macunget(0);
 218:         bufflush(&e->mbuf);
 219: 
 220:         /* check for infinite loop */
 221:         if (e->itercount > ITERTHRESH)
 222:         {
 223:             printf("Infinite loop in macro\n");
 224:             e->pass++;
 225:             continue;
 226:         }
 227: 
 228:         /* see if we have a macro match */
 229:         if (macallscan())
 230:         {
 231:             /* yep -- count iterations and rescan it */
 232:             e->itercount++;
 233:         }
 234:         else
 235:         {
 236:             /* nope -- pass the next token through raw */
 237:             e->pass++;
 238:         }
 239:     }
 240: }
 241: /*
 242: **  MACGCH -- get input character, knowing about tokens
 243: **
 244: **	The next input character is returned.  In addition, the quote
 245: **	level info is maintained and the QUOTED bit is set if the
 246: **	returned character is (a) quoted or (b) backslash escaped.
 247: **	As a side effect the change flag is maintained.  Also, the
 248: **	character is saved in mbuf.
 249: */
 250: 
 251: macgch()
 252: {
 253:     register int        c;
 254:     register struct env *e;
 255:     register int        i;
 256: 
 257:     e = Macenv;
 258: 
 259:     for (;;)
 260:     {
 261:         /* get virtual raw character, save in mbuf, and set change */
 262:         c = macfetch(e->quotelevel > 0);
 263: 
 264:         /* test for magic frotz */
 265:         switch (c)
 266:         {
 267:           case 0:   /* end of file */
 268:             return (0);
 269: 
 270:           case LQUOTE:
 271:             if (e->quotelevel++ == 0)
 272:                 continue;
 273:             break;
 274: 
 275:           case RQUOTE:
 276:             if (e->quotelevel == 0)
 277:                 return (c);
 278:             if (--e->quotelevel == 0)
 279:             {
 280:                 continue;
 281:             }
 282:             break;
 283: 
 284:           case BACKSLASH:
 285:             if (e->quotelevel > 0)
 286:                 break;
 287:             c = macfetch(1);
 288: 
 289:             /* handle special cases */
 290:             if (c == e->pdelim)
 291:                 break;
 292: 
 293:             /* do translations */
 294:             switch (c)
 295:             {
 296:               case SPACE:   /* space */
 297:               case TAB: /* tab */
 298:               case NEWLINE: /* newline */
 299:               case RQUOTE:
 300:               case LQUOTE:
 301:               case '$':
 302:               case LBRACE:
 303:               case RBRACE:
 304:               case BACKSLASH:
 305:                 break;
 306: 
 307:               default:
 308:                 /* take character as is (unquoted) */
 309:                 c = 0;
 310:                 break;
 311:             }
 312: 
 313:             if (c != 0)
 314:                 break;
 315: 
 316:             /* not an escapable character -- treat it normally */
 317:             macunget(1);
 318:             c = BACKSLASH;
 319:             /* do default character processing on backslash */
 320: 
 321:           default:
 322:             if (e->quotelevel > 0)
 323:                 break;
 324:             return (c);
 325:         }
 326: 
 327:         /* the character is quoted */
 328:         return (c | QUOTED);
 329:     }
 330: }
 331: /*
 332: **  MACFETCH -- fetch virtual raw character
 333: **
 334: **	A character is fetched from the peek buffer.  If that buffer is
 335: **	empty, it is fetched from the raw input.  The character is then
 336: **	saved away, and the change flag is set accordingly.
 337: **	The QUOTED bit on the character is set if the 'quote' flag
 338: **	parameter is set; used for backslash escapes.
 339: **	Note that the QUOTED bit appears only on the character which
 340: **	goes into the macro buffer; the character returned is normal.
 341: */
 342: 
 343: macfetch(quote)
 344: int quote;
 345: {
 346:     register struct env *e;
 347:     register int        c;
 348:     register int        escapech;
 349: 
 350:     e = Macenv;
 351:     escapech = 0;
 352: 
 353:     for (;;)
 354:     {
 355:         /* get character from peek buffer */
 356:         c = bufget(&e->pbuf);
 357: 
 358:         if (c == 0)
 359:         {
 360:             /* peek buffer is empty */
 361:             /* check for already raw eof */
 362:             if (!e->eof)
 363:             {
 364:                 /* note that c must be int so that the QUOTED bit is not negative */
 365:                 c = (*e->rawget)(e->rawpar);
 366:                 if (c <= 0)
 367:                 {
 368:                     c = 0;
 369:                     e->eof++;
 370:                 }
 371:                 else
 372:                 {
 373:                     if (e->rawnewline)
 374:                         e->prevchar = NEWLINE;
 375:                     e->rawnewline = (c == NEWLINE);
 376:                 }
 377:             }
 378:         }
 379: 
 380:         /* test for escapable character */
 381:         if (escapech)
 382:         {
 383:             switch (c)
 384:             {
 385:               case 't': /* become quoted tab */
 386:                 c = TAB | QUOTED;
 387:                 break;
 388: 
 389:               case 'n': /* become quoted newline */
 390:                 c = NEWLINE | QUOTED;
 391:                 break;
 392: 
 393:               default:
 394:                 bufput(c, &e->pbuf);
 395:                 c = BACKSLASH;
 396:             }
 397:             escapech = 0;
 398:         }
 399:         else
 400:         {
 401:             if (c == BACKSLASH)
 402:             {
 403:                 escapech++;
 404:                 continue;
 405:             }
 406:         }
 407:         break;
 408:     }
 409: 
 410:     /* quote the character if appropriate to mask change flag */
 411:     /* ('escapech' now becomes the maybe quoted character) */
 412:     escapech = c;
 413:     if (quote && c != 0)
 414:         escapech |= QUOTED;
 415: 
 416:     /* set change flag */
 417:     macschng(escapech);
 418: 
 419:     if (c != 0)
 420:     {
 421:         /* save the character in the macro buffer */
 422:         bufput(escapech, &e->mbuf);
 423:     }
 424: 
 425:     return (c);
 426: }
 427: /*
 428: **  MACSCHNG -- set change flag and compute token type
 429: **
 430: **	The change flag and token type is set.  This does some tricky
 431: **	stuff to determine just when a new token begins.  Most notably,
 432: **	notice that quoted stuff IS scanned, but the change flag is
 433: **	reset in a higher level routine so that quoted stuff looks
 434: **	like a single token, but any begin/end quote causes a token
 435: **	change.
 436: */
 437: 
 438: macschng(ch)
 439: char    ch;
 440: {
 441:     register struct env *e;
 442:     register char       c;
 443:     register int        thismode;
 444:     int         changeflag;
 445: 
 446:     e = Macenv;
 447:     c = ch;
 448:     changeflag = 0;
 449:     thismode = macmode(c);
 450: 
 451:     switch (e->tokenmode)
 452:     {
 453:       case NONE:
 454:         /* always cause token change */
 455:         break;
 456: 
 457:       case QUOTEMODE:
 458:         /* change only on initial entry to quotes */
 459:         break;
 460: 
 461:       case DELIM:
 462:         changeflag++;
 463:         break;
 464: 
 465:       case ID:
 466:         /* take any sequence of letters and numerals */
 467:         if (thismode == NUMBER)
 468:             thismode = ID;
 469:         break;
 470: 
 471:       case NUMBER:
 472:         /* take string of digits and decimal points */
 473:         if (c == '.')
 474:             thismode = NUMBER;
 475:         break;
 476: 
 477:       case OP:
 478:         switch (e->prevchar)
 479:         {
 480:           case '<':
 481:           case '>':
 482:           case '!':
 483:             if (c != '=')
 484:                 changeflag++;
 485:             break;
 486: 
 487:           case '*':
 488:             if (c != '*' && c != '/')
 489:                 changeflag++;
 490:             break;
 491: 
 492:           case '/':
 493:             if (c != '*')
 494:                 changeflag++;
 495:             break;
 496: 
 497:           case '.':
 498:             if (thismode == NUMBER)
 499:                 e->tokenmode = thismode;
 500:             break;
 501: 
 502:           default:
 503:             changeflag++;
 504:             break;
 505:         }
 506:         break;
 507: 
 508:       case NOCHANGE:    /* never cause token change */
 509:         e->tokenmode = thismode;
 510:         break;
 511:     }
 512: 
 513:     e->prevchar = c;
 514:     if (thismode != e->tokenmode)
 515:         changeflag++;
 516:     e->tokenmode = thismode;
 517:     e->change = changeflag;
 518: }
 519: /*
 520: **  MACMODE -- return mode of a character
 521: */
 522: 
 523: macmode(ch)
 524: char    ch;
 525: {
 526:     register char   c;
 527: 
 528:     c = ch;
 529: 
 530:     if ((c & QUOTED) != 0)
 531:         return (QUOTEMODE);
 532:     if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c == '_'))
 533:         return (ID);
 534:     if (c >= '0' && c <= '9')
 535:         return (NUMBER);
 536:     if (c == SPACE || c == TAB || c == NEWLINE)
 537:         return (DELIM);
 538:     return (OP);
 539: }
 540: /*
 541: **  MACALLSCAN -- scan to see if input matches a macro
 542: **
 543: **	Returns true if there was a match, false if not.  In any case,
 544: **	the virtual raw input (i.e., the peek buffer) will contain
 545: **	either the old raw input, or the substituted macro.
 546: */
 547: 
 548: macallscan()
 549: {
 550:     register struct macro   *m;
 551: 
 552:     for (m = Machead; m != 0; m = m->nextm)
 553:     {
 554:         /* check to see if it matches this macro */
 555:         if (macscan(m))
 556:         {
 557:             /* it does -- substituted value is in mbuf */
 558:             macrescan();
 559:             return (1);
 560:         }
 561: 
 562:         /* it doesn't match this macro -- try the next one */
 563:         macrescan();
 564:     }
 565: 
 566:     /* it doesn't match any of them -- tough luck */
 567:     return (0);
 568: }
 569: /*
 570: **  MACSCAN -- scan a single macro for a match
 571: **
 572: **	As is scans it also collects parameters for possible future
 573: **	substitution.  If it finds a match, it takes responsibility
 574: **	for doing the substitution.
 575: */
 576: 
 577: macscan(mac)
 578: struct macro    *mac;
 579: {
 580:     register struct macro   *m;
 581:     register char       c;
 582:     register char       *temp;
 583:     char            pname, pdelim;
 584: 
 585:     m = mac;
 586: 
 587:     /* check for anchored mode */
 588:     temp = m->template;
 589:     if (*temp == ONEDELIM)
 590:     {
 591:         if (!Macenv->newline)
 592:             return (0);
 593:         temp++;
 594:     }
 595: 
 596:     /* scan the template */
 597:     for ( ; c = *temp; temp++)
 598:     {
 599:         if (c == PARAMN || c == PARAMP)
 600:         {
 601:             /* we have a parameter */
 602:             pname = *++temp;
 603:             pdelim = *++temp;
 604:             if (macparam(c, pname, pdelim))
 605:             {
 606:                 /* parameter ok */
 607:                 continue;
 608:             }
 609: 
 610:             /* failure on parameter scan */
 611:             return (0);
 612:         }
 613: 
 614:         if (!macmatch(c))
 615:         {
 616:             /* failure on literal match */
 617:             return (0);
 618:         }
 619:     }
 620: 
 621:     /* it matches!!  substitute the macro */
 622:     macsubs(m);
 623:     return (1);
 624: }
 625: /*
 626: **  MACPARAM -- collect a parameter
 627: **
 628: **	The parameter is collected and stored away "somewhere" with
 629: **	name 'name'.  The delimiter is taken to be 'delim'.  'Mode'
 630: **	tells whether to prescan the parameter (done immediately before
 631: **	substitute time to avoid side effects if the macro actually
 632: **	turns out to not match).
 633: */
 634: 
 635: macparam(mode, name, delim)
 636: char    mode;
 637: char    name;
 638: char    delim;
 639: {
 640:     register char       c;
 641:     register struct env *e;
 642:     struct buf      *b;
 643:     register struct param   *p;
 644:     int         bracecount;
 645:     extern char     *bufalloc(),*bufcrunch();
 646:     e = Macenv;
 647:     b = 0;
 648: 
 649:     e->pdelim = delim;
 650:     TRACE("\nmacparam(%d, %c, %c):\n", mode, name, delim);
 651:     if (mode == PARAMP)
 652:     {
 653:         /* check for REALLY prescan */
 654:         c = macgch();
 655:         if (c != PRESCANENABLE)
 656:         {
 657:             mode = PARAMN;
 658:             macunget(0);
 659:         }
 660:     }
 661: 
 662:     bracecount = 0;
 663:     e->tokenmode = NOCHANGE;
 664:     while (!macmatch(delim))
 665:     {
 666:         do
 667:         {
 668:             c = macgch();
 669:             if (c == 0 || c == NEWLINE)
 670:             {
 671:                 e->pdelim = 0;
 672:                 bufpurge(&b);
 673:                 TRACE("macparam fails\n");
 674:                 return (0);
 675:             }
 676:             bufput(c, &b);
 677:             if (c == LBRACE)
 678:                 bracecount++;
 679:             else if (c == RBRACE && bracecount > 0)
 680:                 bracecount--;
 681:         } while (bracecount > 0);
 682:     }
 683: 
 684:     e->pdelim = 0;
 685: 
 686:     /* allocate and store the parameter */
 687:     p = (struct param *) bufalloc(sizeof *p);
 688:     p->mode = mode;
 689:     p->name = name;
 690:     p->nextp = e->params;
 691:     e->params = p;
 692:     p->paramt = bufcrunch(&b);
 693:     bufpurge(&b);
 694:     TRACE("macparam: |%s|\n", p->paramt);
 695: 
 696:     return (1);
 697: }
 698: /*
 699: **  MACMATCH -- test for a match between template character and input.
 700: **
 701: **	The parameter is the character from the template to match on.
 702: **	The input is read.  The template character may be a meta-
 703: **	character.  In all cases if the match occurs the input is
 704: **	thrown away; if no match occurs the input is left unchanged.
 705: **
 706: **	Return value is true for a match, false for no match.
 707: */
 708: 
 709: macmatch(template)
 710: char    template;
 711: {
 712:     register char   t;
 713:     register char   c;
 714:     register int    res;
 715: 
 716:     t = template;
 717:     TRACE("\tmacmatch(%c)", t);
 718: 
 719:     switch (t)
 720:     {
 721:       case ANYDELIM:    /* match zero or more delimiters */
 722:         /* chew and chuck delimiters */
 723:         while (macdelim())
 724:             ;
 725: 
 726:         /* as a side effect, must match a token change */
 727:         if (!macckch())
 728:         {
 729:             TRACE(" fail\n");
 730:             return (0);
 731:         }
 732:         TRACE(" succeed\n");
 733:         return (1);
 734: 
 735:       case ONEDELIM:    /* match exactly one delimiter */
 736:         TRACE(":\n");
 737:         res = macdelim();
 738:         return (res);
 739: 
 740:       case CHANGE:      /* match a token change */
 741:       case 0:       /* end of template */
 742:         TRACE(":\n");
 743:         res = macckch();
 744:         return (res);
 745: 
 746:       default:      /* must have exact character match */
 747:         c = macgch();
 748:         TRACE(" against %c ", c);
 749:         if (c == t)
 750:         {
 751:             TRACE("succeed\n");
 752:             return (1);
 753:         }
 754: 
 755:         /* failure */
 756:         macunget(0);
 757:         TRACE("fail\n");
 758:         return (0);
 759:     }
 760: }
 761: /*
 762: **  MACDELIM -- test for next input character a delimiter
 763: **
 764: **	Returns true if the next input character is a delimiter, false
 765: **	otherwise.  Delimiters are chewed.
 766: */
 767: 
 768: macdelim()
 769: {
 770:     register char   c;
 771: 
 772:     c = macgch();
 773:     TRACE("\t\tmacdelim against %c: ", c);
 774:     if (macmode(c) == DELIM)
 775:     {
 776:         TRACE("succeed\n");
 777:         return (1);
 778:     }
 779:     macunget(0);
 780:     TRACE("fail\n");
 781:     return (0);
 782: }
 783: /*
 784: **  MACCKCH -- check for token change
 785: **
 786: **	Returns true if a token change occurs between this and the next
 787: **	character.  No characters are ever chewed, however, the token
 788: **	change (if it exists) is always chewed.
 789: */
 790: 
 791: macckch()
 792: {
 793:     register int        change;
 794:     register char       c;
 795:     register struct env *e;
 796: 
 797:     e = Macenv;
 798: 
 799:     if (e->tokenmode == NONE)
 800:     {
 801:         /* then last character has been ungotten: take old change */
 802:         change = e->change;
 803:     }
 804:     else
 805:     {
 806:         c = macgch();
 807:         change = Macenv->change;
 808:         macunget(0);
 809:     }
 810:     TRACE("macckch got %c ret %d\n", c, change);
 811: 
 812:     /* chew the change and return */
 813:     e->tokenmode = NOCHANGE;
 814:     return (change);
 815: }
 816: /*
 817: **  MACSUBS -- substitute in macro substitution
 818: **
 819: **	This routine prescans appropriate parameters and then either
 820: **	loads the substitution into the macro buffer or calls the
 821: **	correct primitive routine.
 822: */
 823: 
 824: macsubs(mac)
 825: struct macro    *mac;
 826: {
 827:     register struct param   *p;
 828:     register struct env *e;
 829:     register char       *s;
 830:     char            *macprim();
 831: 
 832:     e = Macenv;
 833: 
 834:     for (p = e->params; p != 0; p = p->nextp)
 835:     {
 836:         /* check to see if we should prescan */
 837:         if (p->mode != PARAMP)
 838:         {
 839:             continue;
 840:         }
 841: 
 842:         /* prescan parameter */
 843:         macprescan(&p->paramt);
 844:         p->mode = PARAMN;
 845:     }
 846: 
 847:     s = mac->substitute;
 848: 
 849:     /* clear out the macro call */
 850:     bufflush(&e->mbuf);
 851: 
 852:     if (s <= (char *) NPRIMS)
 853:     {
 854:         /* it is a primitive */
 855:         macload(macprim(s), 0);
 856:     }
 857:     else
 858:     {
 859:         /* it is a user-defined macro */
 860:         macload(s, 1);
 861:     }
 862: }
 863: /*
 864: **  MACPRESCAN -- prescan a parameter
 865: **
 866: **	The parameter pointed to by 'pp' is fed once through the macro
 867: **	processor and replaced with the new version.
 868: */
 869: 
 870: macprescan(pp)
 871: char    **pp;
 872: {
 873:     struct buf      *b;
 874:     char            *p;
 875:     register struct env *e;
 876:     register char       c;
 877:     extern int      macsget();
 878: 
 879:     b = 0;
 880:     p = *pp;
 881: 
 882:     /* set up a new environment */
 883:     macnewev(macsget, &p);
 884:     e = Macenv;
 885: 
 886:     /* scan the parameter */
 887:     while ((c = macgetch()) != 0)
 888:         bufput(c, &b);
 889: 
 890:     /* free the old parameter */
 891:     buffree(*pp);
 892: 
 893:     /* move in the new one */
 894:     *pp = bufcrunch(&b);
 895:     bufpurge(&b);
 896: 
 897:     /* restore the old environment */
 898:     macpopev();
 899: }
 900: /*
 901: **  MACNEWEV -- set up new environment
 902: **
 903: **	Parameters are raw get routine and parameter
 904: */
 905: 
 906: macnewev(rawget, rawpar)
 907: int (*rawget)();
 908: char    **rawpar;
 909: {
 910:     register struct env *e;
 911:     extern char     *bufalloc();
 912: 
 913:     e = (struct env *) bufalloc(sizeof *e);
 914:     e->rawget = rawget;
 915:     e->rawpar = rawpar;
 916:     e->nexte = Macenv;
 917:     e->newline = 1;
 918:     Macenv = e;
 919: }
 920: /*
 921: **  MACPOPEV -- pop an environment
 922: **
 923: **	Makes sure all buffers and stuff are purged
 924: */
 925: 
 926: macpopev()
 927: {
 928:     register struct env *e;
 929: 
 930:     e = Macenv;
 931:     bufpurge(&e->mbuf);
 932:     bufpurge(&e->pbuf);
 933:     macpflush(e);
 934:     Macenv = e->nexte;
 935:     buffree(e);
 936: }
 937: /*
 938: **  MACPFLUSH -- flush all parameters
 939: **
 940: **	Used to deallocate all parameters in a given environment.
 941: */
 942: 
 943: macpflush(env)
 944: struct env  *env;
 945: {
 946:     register struct env *e;
 947:     register struct param   *p;
 948:     register struct param   *q;
 949: 
 950:     e = env;
 951: 
 952:     for (p = e->params; p != 0; p = q)
 953:     {
 954:         buffree(p->paramt);
 955:         q = p->nextp;
 956:         buffree(p);
 957:     }
 958: 
 959:     e->params = 0;
 960: }
 961: /*
 962: **  MACSGET -- get from string
 963: **
 964: **	Works like a getchar from a string.  Used by macprescan().
 965: **	The parameter is a pointer to the string.
 966: */
 967: 
 968: macsget(pp)
 969: char    **pp;
 970: {
 971:     register char   **p;
 972:     register int    c;
 973: 
 974:     p = pp;
 975: 
 976:     c = **p & BYTEMASK;
 977:     if (c != 0)
 978:         (*p)++;
 979:     return (c);
 980: }
 981: /*
 982: **  MACLOAD -- load a string into the macro buffer
 983: **
 984: **	The parameters are a pointer to a string to be appended to
 985: **	the macro buffer and a flag telling whether parameter substi-
 986: **	tution can occur.
 987: */
 988: 
 989: macload(str, flag)
 990: char    *str;
 991: int flag;
 992: {
 993:     register struct env *e;
 994:     register char       *s;
 995:     register char       c;
 996:     extern char     *macplkup();
 997: 
 998:     e = Macenv;
 999:     s = str;
1000: 
1001:     if (s == 0)
1002:         return;
1003: 
1004:     while ((c = *s++) != 0)
1005:     {
1006:         if (c == PARAMN)
1007:             macload(macplkup(*s++), 0);
1008:         else
1009:             bufput(c & CHARMASK, &e->mbuf);
1010:     }
1011: }
1012: /*
1013: **  MACRESCAN -- rescan the macro buffer
1014: **
1015: **	Copies the macro buffer into the peek buffer so that it will be
1016: **	reread.  Also deallocates any parameters which may happen to be
1017: **	stored away.
1018: */
1019: 
1020: macrescan()
1021: {
1022:     register struct env *e;
1023:     register char       c;
1024: 
1025:     e = Macenv;
1026: 
1027:     while ((c = bufget(&e->mbuf) & CHARMASK) != 0)
1028:         bufput(c, &e->pbuf);
1029: 
1030:     e->quotelevel = 0;
1031:     e->tokenmode = NONE;
1032:     macpflush(e);
1033: }
1034: /*
1035: **  MACUNGET -- unget a character
1036: **
1037: **	Moves one character from the macro buffer to the peek buffer.
1038: **	If 'mask' is set, the character has the quote bit stripped off.
1039: */
1040: 
1041: macunget(mask)
1042: int mask;
1043: {
1044:     register struct env *e;
1045:     register char       c;
1046: 
1047:     e = Macenv;
1048: 
1049:     if (e->prevchar != 0)
1050:     {
1051:         c = bufget(&e->mbuf);
1052:         if (mask)
1053:              c &= CHARMASK;
1054:         bufput(c, &e->pbuf);
1055:         e->tokenmode = NONE;
1056:     }
1057: }
1058: /*
1059: **  MACPLKUP -- look up parameter
1060: **
1061: **	Returns a pointer to the named parameter.  Returns null
1062: **	if the parameter is not found ("cannot happen").
1063: */
1064: 
1065: char *
1066: macplkup(name)
1067: char    name;
1068: {
1069:     register struct param   *p;
1070: 
1071:     for (p = Macenv->params; p != 0; p = p->nextp)
1072:     {
1073:         if (p->name == name)
1074:             return (p->paramt);
1075:     }
1076: 
1077:     return (0);
1078: }
1079: /*
1080: **  MACSPRING -- spring a trap
1081: **
1082: **	The named trap is sprung, in other words, if the named macro is
1083: **	defined it is called, otherwise there is no replacement text.
1084: */
1085: 
1086: macspring(trap)
1087: char    *trap;
1088: {
1089:     register struct env *e;
1090:     register char       *p;
1091:     char            *macro();
1092: 
1093:     e = Macenv;
1094: 
1095:     bufflush(&e->mbuf);
1096: 
1097:     /* fetch the macro */
1098:     p = macro(trap);
1099: 
1100:     /* if not defined, don't bother */
1101:     if (p == 0)
1102:         return;
1103: 
1104:     /* load the trap */
1105:     macload(p);
1106: 
1107:     /* insert a newline after the trap */
1108:     bufput('\n', &e->mbuf);
1109: 
1110:     macrescan();
1111: }
1112: /*
1113: **  MACPRIM -- do primitives
1114: **
1115: **	The parameter is the primitive to execute.
1116: */
1117: 
1118: char *
1119: macprim(n)
1120: int n;
1121: {
1122:     register struct env *e;
1123:     extern char     *macplkup();
1124:     extern char     *macsstr();
1125: 
1126:     e = Macenv;
1127: 
1128:     switch (n)
1129:     {
1130:       case 1:   /* {define; $t; $s} */
1131:         macdnl();
1132:         macdefine(macplkup('t'), macplkup('s'), 0);
1133:         break;
1134: 
1135:       case 2:   /* {rawdefine; $t; $s} */
1136:         macdnl();
1137:         macdefine(macplkup('t'), macplkup('s'), 1);
1138:         break;
1139: 
1140:       case 3:   /* {remove $t} */
1141:         macdnl();
1142:         macremove(macplkup('t'));
1143:         break;
1144: 
1145:       case 4:   /* {dump} */
1146:             /* {dump; $n} */
1147:         macdnl();
1148:         macdump(macplkup('n'));
1149:         break;
1150: 
1151:       case 5:   /* {type $m} */
1152:         macdnl();
1153:         printf("%s\n", macplkup('m'));
1154:         break;
1155: 
1156:       case 6:   /* {read $m} */
1157:         printf("%s ", macplkup('m'));
1158:         macread();
1159:         break;
1160: 
1161:       case 7:   /* {read; $n; $m} */
1162:         printf("%s ", macplkup('m'));
1163:         macread();
1164:         macdefine(macplkup('n'), bufcrunch(&e->mbuf), 1);
1165:         return("{readcount}");
1166: 
1167:       case 8:   /* {ifsame; $a; $b; $t; $f} */
1168:         if (sequal(macplkup('a'), macplkup('b')))
1169:             return (macplkup('t'));
1170:         else
1171:             return (macplkup('f'));
1172: 
1173:       case 9:   /* {ifeq; $a; $b; $t; $f} */
1174:         if (macnumber(macplkup('a')) == macnumber(macplkup('b')))
1175:             return (macplkup('t'));
1176:         else
1177:             return (macplkup('f'));
1178: 
1179:       case 10:  /* {ifgt; $a; $b; $t; $f} */
1180:         if (macnumber(macplkup('a')) > macnumber(macplkup('b')))
1181:             return (macplkup('t'));
1182:         else
1183:             return (macplkup('f'));
1184: 
1185:       case 12:  /* {substr; $f; $t; $s} */
1186:         return (macsstr(macnumber(macplkup('f')), macnumber(macplkup('t')), macplkup('s')));
1187: 
1188:       case 13:  /* {dnl} */
1189:         macdnl();
1190:         break;
1191: 
1192:       default:
1193:         syserr("macro: bad primitive %d", n);
1194:     }
1195: 
1196:     return ("");
1197: }
1198: /*
1199: **  MACDNL -- delete to newline
1200: **
1201: **	Used in general after macro definitions to avoid embarrassing
1202: **	newlines.  Just reads input until a newline character, and
1203: **	then throws it away.
1204: */
1205: 
1206: macdnl()
1207: {
1208:     register char       c;
1209:     register struct env *e;
1210: 
1211:     e = Macenv;
1212: 
1213:     while ((c = macgch()) != 0 && c != NEWLINE)
1214:         ;
1215: 
1216:     bufflush(&e->mbuf);
1217: }
1218: /*
1219: **  MACDEFINE -- define primitive
1220: **
1221: **	This function defines a macro.  The parameters are the
1222: **	template, the substitution string, and a flag telling whether
1223: **	this is a raw define or not.  Syntax checking is done.
1224: */
1225: 
1226: macdefine(template, subs, raw)
1227: char    *template;
1228: char    *subs;
1229: int raw;
1230: {
1231:     register struct env *e;
1232:     char            paramdefined[128];
1233:     char            *p;
1234:     register char       c;
1235:     char            d;
1236:     struct buf      *b;
1237:     register struct macro   *m;
1238:     extern int      macsget();
1239:     extern char     *bufalloc(),*bufcrunch();
1240:     char            *mactcvt();
1241:     int         escapech;
1242: 
1243:     /* remove any old macro definition */
1244:     macremove(template);
1245: 
1246:     /* get a new environment */
1247:     macnewev(macsget, &p);
1248:     b = 0;
1249:     e = Macenv;
1250: 
1251:     /* undefine all parameters */
1252:     clrmem(paramdefined, 128);
1253: 
1254:     /* avoid an initial token change */
1255:     e->tokenmode = NOCHANGE;
1256:     escapech = 1;
1257: 
1258:     /* allocate macro header and template */
1259:     m = (struct macro *) bufalloc(sizeof *m);
1260: 
1261:     /* scan and convert template, collect available parameters */
1262:     p = template;
1263:     m->template = mactcvt(raw, paramdefined);
1264:     if (m->template == 0)
1265:     {
1266:         /* some sort of syntax error */
1267:         buffree(m);
1268:         macpopev();
1269:         return;
1270:     }
1271: 
1272:     bufflush(&e->mbuf);
1273:     bufflush(&e->pbuf);
1274:     e->eof = 0;
1275: 
1276:     /* scan substitute string */
1277:     for (p = subs; c = macfetch(0); )
1278:     {
1279:         if (c != '$')
1280:         {
1281:             /* substitute non-parameters literally */
1282:             bufput(c & CHARMASK, &b);
1283:             continue;
1284:         }
1285: 
1286:         /* it's a parameter */
1287:         bufput(PARAMN, &b);
1288:         c = macfetch(0);
1289: 
1290:         /* check to see if name is supplied */
1291:         if (paramdefined[c] == 0)
1292:         {
1293:             /* nope, it's not */
1294:             printf("define: parameter %c referenced but not defined\n", c);
1295:             buffree(m->template);
1296:             buffree(m);
1297:             macpopev();
1298:             bufpurge(&b);
1299:             return;
1300:         }
1301:         bufput(c & CHARMASK, &b);
1302:     }
1303: 
1304:     /* allocate substitution string */
1305:     m->substitute = bufcrunch(&b);
1306: 
1307:     /* allocate it as a macro */
1308:     m->nextm = Machead;
1309:     Machead = m;
1310: 
1311:     /* finished... */
1312:     macpopev();
1313:     bufpurge(&b);
1314: }
1315: /*
1316: **  MACTCVT -- convert template to internal form
1317: **
1318: **	Converts the template from external form to internal form.
1319: **
1320: **	Parameters:
1321: **	raw -- set if only raw type conversion should take place.
1322: **	paramdefined -- a map of flags to determine declaration of
1323: **		parameters, etc.  If zero, no parameters are allowed.
1324: **
1325: **	Return value:
1326: **	A character pointer off into mystic space.
1327: **
1328: **	The characters of the template are read using macfetch, so
1329: **	a new environment should be created which will arrange to
1330: **	get this.
1331: */
1332: 
1333: char *
1334: mactcvt(raw, paramdefined)
1335: int raw;
1336: char    paramdefined[128];
1337: {
1338:     register int        c;
1339:     struct buf      *b;
1340:     register char       d;
1341:     register int        escapech;
1342:     char            *p;
1343: 
1344:     b = 0;
1345:     escapech = 1;
1346: 
1347:     while (c = macfetch(0))
1348:     {
1349:         switch (c)
1350:         {
1351:           case '$':     /* parameter */
1352:             if (escapech < 0)
1353:             {
1354:                 printf("define: every parameter needs a delimiter\n");
1355:                 bufpurge(&b);
1356:                 return (0);
1357:             }
1358: 
1359:             /* skip delimiters before parameter in non-raw */
1360:             if (Macenv->change && !escapech && !raw)
1361:                 bufput(ANYDELIM, &b);
1362: 
1363:             escapech = 0;
1364:             c = macfetch(0);
1365:             d = PARAMN;
1366:             if (c == '$')
1367:             {
1368:                 /* prescanned parameter */
1369:                 d = PARAMP;
1370:                 c = macfetch(0);
1371:             }
1372: 
1373:             /* process parameter name */
1374:             if (c == 0)
1375:             {
1376:                 /* no parameter name */
1377:                 printf("define: null parameter name\n");
1378:                 bufpurge(&b);
1379:                 return (0);
1380:             }
1381: 
1382:             bufput(d, &b);
1383:             escapech = -1;
1384: 
1385:             /* check for legal parameter */
1386:             if (paramdefined == 0)
1387:                 break;
1388: 
1389:             if (paramdefined[c])
1390:             {
1391:                 printf("define: parameter %c redeclared\n", c);
1392:                 bufpurge(&b);
1393:                 return (0);
1394:             }
1395:             paramdefined[c]++;
1396: 
1397:             /* get parameter delimiter */
1398:             break;
1399: 
1400:           case BACKSLASH:       /* a backslash escape */
1401:             escapech = 1;
1402:             c = macfetch(0);
1403:             switch (c)
1404:             {
1405:               case '|':
1406:                 c = ANYDELIM;
1407:                 break;
1408: 
1409:               case '^':
1410:                 c = ONEDELIM;
1411:                 break;
1412: 
1413:               case '&':
1414:                 c = CHANGE;
1415:                 break;
1416: 
1417:               default:
1418:                 escapech = 0;
1419:                 c = BACKSLASH;
1420:                 macunget(0);
1421:                 break;
1422:             }
1423:             break;
1424: 
1425:           case NEWLINE | QUOTED:
1426:           case TAB | QUOTED:
1427:           case SPACE | QUOTED:
1428:             if (escapech < 0)
1429:                 c &= CHARMASK;
1430:             escapech = 1;
1431:             break;
1432: 
1433:           default:
1434:             /* change delimiters to ANYDELIM */
1435:             if (macmode(c) == DELIM && !raw)
1436:             {
1437:                 while (macmode(c = macfetch(0)) == DELIM)
1438:                     ;
1439:                 macunget(0);
1440:                 if (c == 0)
1441:                     c = ONEDELIM;
1442:                 else
1443:                     c = ANYDELIM;
1444:                 escapech = 1;
1445:             }
1446:             else
1447:             {
1448:                 if (Macenv->change && !escapech)
1449:                 {
1450:                     bufput(ANYDELIM, &b);
1451:                 }
1452: 
1453:                 if (escapech < 0)
1454:                 {
1455:                     /* parameter: don't allow quoted delimiters */
1456:                     c &= CHARMASK;
1457:                 }
1458:                 escapech = 0;
1459:             }
1460:             break;
1461:         }
1462:         bufput(c, &b);
1463:     }
1464:     if (escapech <= 0)
1465:         bufput(CHANGE, &b);
1466: 
1467:     p = bufcrunch(&b);
1468:     bufpurge(&b);
1469:     TRACE("mactcvt: '%s'\n", p);
1470:     return (p);
1471: }
1472: /*
1473: **  MACREMOVE -- remove macro
1474: **
1475: **	The named macro is looked up.  If it is found it is removed
1476: **	from the macro list.
1477: */
1478: 
1479: macremove(name)
1480: char    *name;
1481: {
1482:     register struct macro   *m;
1483:     register struct macro   **mp;
1484:     extern int      macsget();
1485:     char            *p;
1486:     register char       *cname;
1487:     struct macro        *macmlkup();
1488: 
1489:     if (name != 0)
1490:     {
1491:         /* convert name to internal format */
1492:         macnewev(macsget, &p);
1493:         p = name;
1494:         cname = mactcvt(0, 0);
1495:         macpopev();
1496:         if (cname == 0)
1497:         {
1498:             /* some sort of syntax error */
1499:             return;
1500:         }
1501:     }
1502: 
1503:     /* find macro */
1504:     while (name == 0 ? ((m = Machead)->substitute > (char *) NPRIMS) : ((m = macmlkup(cname)) != 0))
1505:     {
1506:         /* remove macro from list */
1507:         mp = &Machead;
1508: 
1509:         /* find it's parent */
1510:         while (*mp != m)
1511:             mp = &(*mp)->nextm;
1512: 
1513:         /* remove macro from list */
1514:         *mp = m->nextm;
1515:         buffree(m->template);
1516:         buffree(m->substitute);
1517:         buffree(m);
1518:     }
1519:     buffree(cname);
1520: }
1521: /*
1522: **  MACMLKUP -- look up macro
1523: **
1524: **	The named macro is looked up and a pointer to the macro header
1525: **	is returned.  Zero is returned if the macro is not found.
1526: **	The name must be in internal form.
1527: */
1528: 
1529: struct macro *
1530: macmlkup(name)
1531: char    *name;
1532: {
1533:     register struct macro   *m;
1534:     register char       *n;
1535: 
1536:     n = name;
1537: 
1538:     /* scan the macro list for it */
1539:     for (m = Machead; m != 0; m = m->nextm)
1540:     {
1541:         if (macmmatch(n, m->template, 0))
1542:             return (m);
1543:     }
1544:     return (0);
1545: }
1546: /*
1547: **  MACMMATCH -- check for macro name match
1548: **
1549: **	The given 'name' and 'temp' are compared for equality.  If they
1550: **	match true is returned, else false.
1551: **	Both must be converted to internal format before the call is
1552: **	given.
1553: **
1554: **	"Match" is defined as two macros which might scan as equal.
1555: **
1556: **	'Flag' is set to indicate that the macros must match exactly,
1557: **	that is, neither may have any parameters and must end with both
1558: **	at end-of-template.  This mode is used for getting traps and
1559: **	such.
1560: */
1561: 
1562: macmmatch(name, temp, flag)
1563: char    *name;
1564: char    *temp;
1565: int flag;
1566: {
1567:     register char   ac;
1568:     register char   bc;
1569:     char        *ap, *bp;
1570: 
1571:     ap = name;
1572:     bp = temp;
1573: 
1574:     /* scan character by character */
1575:     for (;; ap++, bp++)
1576:     {
1577:         ac = *ap;
1578:         bc = *bp;
1579:         TRACE("macmmatch: ac=%c/%u, bc=%c/%u\n", ac, ap, bc, bp);
1580: 
1581:         if (bc == ANYDELIM)
1582:         {
1583:             if (macmmchew(&ap))
1584:                 continue;
1585:         }
1586:         else
1587:         {
1588:             switch (ac)
1589:             {
1590:               case SPACE:
1591:               case NEWLINE:
1592:               case TAB:
1593:                 if (ac == bc || bc == ONEDELIM)
1594:                     continue;
1595:                 break;
1596: 
1597:               case ONEDELIM:
1598:                 if (ac == bc || macmode(bc) == DELIM)
1599:                     continue;
1600:                 break;
1601: 
1602:               case ANYDELIM:
1603:                 if (macmmchew(&bp))
1604:                     continue;
1605:                 break;
1606: 
1607:               case PARAMP:
1608:               case PARAMN:
1609:               case 0:
1610:                 if (bc == PARAMN || bc == PARAMP || bc == 0 ||
1611:                     bc == ANYDELIM || bc == ONEDELIM ||
1612:                     bc == CHANGE || macmode(bc) == DELIM)
1613:                 {
1614:                     /* success */
1615:                     if (!flag)
1616:                         return (1);
1617:                     if (ac == 0 && bc == 0)
1618:                         return (1);
1619:                 }
1620:                 break;
1621: 
1622:               default:
1623:                 if (ac == bc)
1624:                     continue;
1625:                 break;
1626:             }
1627:         }
1628: 
1629:         /* failure */
1630:         return (0);
1631:     }
1632: }
1633: /*
1634: **  MACMMCHEW -- chew nonspecific match characters
1635: **
1636: **	The pointer passed as parameter is scanned so as to skip over
1637: **	delimiters and pseudocharacters.
1638: **	At least one character must match.
1639: */
1640: 
1641: macmmchew(pp)
1642: char    **pp;
1643: {
1644:     register char   *p;
1645:     register char   c;
1646:     register int    matchflag;
1647: 
1648:     p = *pp;
1649: 
1650:     for (matchflag = 0; ; matchflag++)
1651:     {
1652:         c = *p;
1653:         if (c != ANYDELIM && c != ONEDELIM && c != CHANGE &&
1654:             macmode(c) != DELIM)
1655:             break;
1656:         p++;
1657:     }
1658: 
1659:     p--;
1660:     if (matchflag == 0)
1661:         return (0);
1662:     *pp = p;
1663:     return (1);
1664: }
1665: /*
1666: **  MACREAD -- read a terminal input line
1667: **
1668: **	Reads one line from the user.  Returns the line into mbuf,
1669: **	and a count of the number of characters read into the macro
1670: **	"{readcount}" (-1 for end of file).
1671: */
1672: 
1673: macread()
1674: {
1675:     register struct env *e;
1676:     register int        count;
1677:     register char       c;
1678: 
1679:     e = Macenv;
1680:     count = -1;
1681: 
1682:     while ((c = getchar()) > 0)
1683:     {
1684:         count++;
1685:         if (c == NEWLINE)
1686:             break;
1687:         bufput(c, &e->mbuf);
1688:     }
1689: 
1690:     macdefine("{readcount}", iocv(count), 1);
1691: }
1692: /*
1693: **  MACNUMBER -- return converted number
1694: **
1695: **	This procedure is essentially identical to the system atoi
1696: **	routine, in that it does no syntax checking whatsoever.
1697: */
1698: 
1699: macnumber(s)
1700: char    *s;
1701: {
1702:     register char       *p;
1703:     register char       c;
1704:     register int        result;
1705:     int         minus;
1706: 
1707:     result = 0;
1708:     p = s;
1709:     minus = 0;
1710: 
1711:     while ((c = *p++) == SPACE)
1712:         ;
1713: 
1714:     if (c == '-')
1715:     {
1716:         minus++;
1717:         while ((c = *p++) == SPACE)
1718:             ;
1719:     }
1720: 
1721:     while (c >= '0' && c <= '9')
1722:     {
1723:         result = result * 10 + (c - '0');
1724:         c = *p++;
1725:     }
1726: 
1727:     if (minus)
1728:         result = -result;
1729: 
1730:     return (result);
1731: }
1732: /*
1733: **  MACSUBSTR -- substring primitive
1734: **
1735: **	The substring of 'string' from 'from' to 'to' is extracted.
1736: **	A pointer to the result is returned.  Note that macsstr
1737: **	in the general case modifies 'string' in place.
1738: */
1739: 
1740: char *
1741: macsstr(from, to, string)
1742: int from;
1743: int to;
1744: char    *string;
1745: {
1746:     register int    f;
1747:     int     l;
1748:     register char   *s;
1749:     register int    t;
1750: 
1751:     s = string;
1752:     t = to;
1753:     f = from;
1754: 
1755:     if (f < 1)
1756:         f = 1;
1757: 
1758:     if (f >= t)
1759:         return ("");
1760:     l = length(s);
1761:     if (t < l)
1762:         s[t] = 0;
1763:     return (&s[f - 1]);
1764: }
1765: /*
1766: **  MACDUMP -- dump a macro definition to the terminal
1767: **
1768: **	All macros matching 'name' are output to the buffer.  If
1769: **	'name' is the null pointer, all macros are printed.
1770: */
1771: 
1772: macdump(name)
1773: char    *name;
1774: {
1775:     register struct macro   *m;
1776:     register char       *p;
1777:     register char       *n;
1778:     extern int      macsget();
1779:     extern char     *macmocv();
1780:     char            *ptr;
1781: 
1782:     n = name;
1783:     if (n != 0)
1784:     {
1785:         macnewev(macsget, &ptr);
1786:         ptr = n;
1787:         n = mactcvt(0, 0);
1788:         macpopev();
1789:         if (n == 0)
1790:             return;
1791:     }
1792: 
1793:     for (m = Machead; m != 0; m = m->nextm)
1794:     {
1795:         if (n == 0 || macmmatch(n, m->template, 0))
1796:         {
1797:             if (m->substitute <= (char *) NPRIMS)
1798:                 continue;
1799:             p = macmocv(m->template);
1800:             macload("`{rawdefine; ", 0);
1801:             macload(p, 0);
1802:             macload("; ", 0);
1803:             p = macmocv(m->substitute);
1804:             macload(p, 0);
1805:             macload("}'\n", 0);
1806:         }
1807:     }
1808:     if (n != 0)
1809:         buffree(n);
1810: }
1811: /*
1812: **  MACMOCV -- macro output conversion
1813: **
1814: **	This routine converts the internal format of the named macro
1815: **	to an unambigous external representation.
1816: **
1817: **	Note that much work can be done to this routine to make it
1818: **	produce cleaner output, for example, translate "\|" to " "
1819: **	in most cases.
1820: */
1821: 
1822: char *
1823: macmocv(m)
1824: char    *m;
1825: {
1826:     register char   *p;
1827:     struct buf  *b;
1828:     register int    c;
1829:     register int    pc;
1830:     static char *lastbuf;
1831:     extern char *bufcrunch();
1832: 
1833:     p = m;
1834: 
1835:     /* release last used buffer (as appropriate) */
1836:     if (lastbuf != 0)
1837:     {
1838:         buffree(lastbuf);
1839:         lastbuf = 0;
1840:     }
1841: 
1842:     if (p <= (char *) NPRIMS)
1843:     {
1844:         /* we have a primitive */
1845:         p = "Primitive xxx";
1846:         itoa(m, &p[10]);
1847:         return (p);
1848:     }
1849: 
1850:     b = 0;
1851: 
1852:     for (; (c = *p++) != 0; pc = c)
1853:     {
1854:         switch (c)
1855:         {
1856:           case BACKSLASH:
1857:           case '|':
1858:           case '&':
1859:           case '^':
1860:             break;
1861: 
1862:           case ANYDELIM:
1863:             c = '\\|';
1864:             break;
1865: 
1866:           case ONEDELIM:
1867:             c = '\\^';
1868:             break;
1869: 
1870:           case CHANGE:
1871:             c = '\\&';
1872:             break;
1873: 
1874:           case PARAMN:
1875:             c = '$';
1876:             break;
1877: 
1878:           case PARAMP:
1879:             c = '$$';
1880:             break;
1881: 
1882:           case '$':
1883:             c = '\\$';
1884:             break;
1885: 
1886:           case NEWLINE:
1887:             c = ('\\' | QUOTED) | ('\n' << 8);
1888:             break;
1889: 
1890:           default:
1891:             bufput(c, &b);
1892:             continue;
1893:         }
1894: 
1895:         if (pc == BACKSLASH)
1896:             bufput(pc, &b);
1897:         pc = c & CHARMASK;
1898:         bufput(pc, &b);
1899:         pc = (c >> 8) & CHARMASK;
1900:         if (pc != 0)
1901:         {
1902:             c = pc;
1903:             bufput(c, &b);
1904:         }
1905:     }
1906: 
1907:     p = bufcrunch(&b);
1908:     bufpurge(&b);
1909:     lastbuf = p;
1910:     return (p);
1911: }
1912: /*
1913: **  MACRO -- get macro substitution value
1914: **
1915: **	***  EXTERNAL INTERFACE  ***
1916: **
1917: **	This routine handles the rather specialized case of looking
1918: **	up a macro and returning the substitution value.  The name
1919: **	must match EXACTLY, character for character.
1920: **
1921: **	The null pointer is returned if the macro is not defined.
1922: */
1923: 
1924: char *
1925: macro(name)
1926: char    *name;
1927: {
1928:     register struct macro   *m;
1929:     register char       *n;
1930:     extern int      macsget();
1931:     char            *p;
1932: 
1933:     /* convert macro name to internal format */
1934:     macnewev(macsget, &p);
1935:     p = name;
1936:     n = mactcvt(0, 0);
1937:     macpopev();
1938:     if (n == 0)
1939:     {
1940:         /* some sort of syntax error */
1941:         return (0);
1942:     }
1943: 
1944:     for (m = Machead; m != 0; m = m->nextm)
1945:     {
1946:         if (macmmatch(n, m->template, 1))
1947:         {
1948:             buffree(n);
1949:             return (m->substitute);
1950:         }
1951:     }
1952: 
1953:     buffree(n);
1954:     return (0);
1955: }

Defined functions

Defined variables

Defined struct's

Defined macros