Return to mac.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ingres / source / monitor

Annotation of 42BSD/ingres/source/monitor/mac.c, revision 1.1

1.1     ! root        1: # include      <useful.h>
        !             2: # include      <sccs.h>
        !             3: 
        !             4: SCCSID(@(#)mac.c       7.1     2/5/81)
        !             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: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.