1*7bbd84d4Sbostic /*-
2*7bbd84d4Sbostic * %sccs.include.proprietary.c%
3*7bbd84d4Sbostic */
4*7bbd84d4Sbostic
5*7bbd84d4Sbostic #ifndef lint
6*7bbd84d4Sbostic static char sccsid[] = "@(#)sed1.c 4.4 (Berkeley) 04/18/91";
7*7bbd84d4Sbostic #endif /* not lint */
88d9f6cdbSralph
98d9f6cdbSralph #include <stdio.h>
108d9f6cdbSralph #include "sed.h"
118d9f6cdbSralph
128d9f6cdbSralph char *trans[040] = {
138d9f6cdbSralph "\\01",
148d9f6cdbSralph "\\02",
158d9f6cdbSralph "\\03",
168d9f6cdbSralph "\\04",
178d9f6cdbSralph "\\05",
188d9f6cdbSralph "\\06",
198d9f6cdbSralph "\\07",
208d9f6cdbSralph "<-",
218d9f6cdbSralph ">-",
228d9f6cdbSralph "\n",
238d9f6cdbSralph "\\13",
248d9f6cdbSralph "\\14",
258d9f6cdbSralph "\\15",
268d9f6cdbSralph "\\16",
278d9f6cdbSralph "\\17",
288d9f6cdbSralph "\\20",
298d9f6cdbSralph "\\21",
308d9f6cdbSralph "\\22",
318d9f6cdbSralph "\\23",
328d9f6cdbSralph "\\24",
338d9f6cdbSralph "\\25",
348d9f6cdbSralph "\\26",
358d9f6cdbSralph "\\27",
368d9f6cdbSralph "\\30",
378d9f6cdbSralph "\\31",
388d9f6cdbSralph "\\32",
398d9f6cdbSralph "\\33",
408d9f6cdbSralph "\\34",
418d9f6cdbSralph "\\35",
428d9f6cdbSralph "\\36",
438d9f6cdbSralph "\\37"
448d9f6cdbSralph };
458d9f6cdbSralph char rub[] = {"\177"};
468d9f6cdbSralph
execute(file)478d9f6cdbSralph execute(file)
488d9f6cdbSralph char *file;
498d9f6cdbSralph {
508d9f6cdbSralph register char *p1, *p2;
5123489cd2Sbostic register struct reptr *ipc;
528d9f6cdbSralph int c;
538d9f6cdbSralph char *execp;
548d9f6cdbSralph
558d9f6cdbSralph if (file) {
568d9f6cdbSralph if ((f = open(file, 0)) < 0) {
578d9f6cdbSralph fprintf(stderr, "Can't open %s\n", file);
588d9f6cdbSralph }
598d9f6cdbSralph } else
608d9f6cdbSralph f = 0;
618d9f6cdbSralph
628d9f6cdbSralph ebp = ibuf;
638d9f6cdbSralph cbp = ibuf;
648d9f6cdbSralph
658d9f6cdbSralph if(pending) {
668d9f6cdbSralph ipc = pending;
678d9f6cdbSralph pending = 0;
688d9f6cdbSralph goto yes;
698d9f6cdbSralph }
708d9f6cdbSralph
718d9f6cdbSralph for(;;) {
728d9f6cdbSralph if((execp = gline(linebuf)) == badp) {
738d9f6cdbSralph close(f);
748d9f6cdbSralph return;
758d9f6cdbSralph }
768d9f6cdbSralph spend = execp;
778d9f6cdbSralph
788d9f6cdbSralph for(ipc = ptrspace; ipc->command; ) {
798d9f6cdbSralph
808d9f6cdbSralph p1 = ipc->ad1;
818d9f6cdbSralph p2 = ipc->ad2;
828d9f6cdbSralph
838d9f6cdbSralph if(p1) {
848d9f6cdbSralph
858d9f6cdbSralph if(ipc->inar) {
868d9f6cdbSralph if(*p2 == CEND) {
878d9f6cdbSralph p1 = 0;
888d9f6cdbSralph } else if(*p2 == CLNUM) {
898d9f6cdbSralph c = p2[1];
908d9f6cdbSralph if(lnum > tlno[c]) {
918d9f6cdbSralph ipc->inar = 0;
928d9f6cdbSralph if(ipc->negfl)
938d9f6cdbSralph goto yes;
948d9f6cdbSralph ipc++;
958d9f6cdbSralph continue;
968d9f6cdbSralph }
978d9f6cdbSralph if(lnum == tlno[c]) {
988d9f6cdbSralph ipc->inar = 0;
998d9f6cdbSralph }
1008d9f6cdbSralph } else if(match(p2, 0)) {
1018d9f6cdbSralph ipc->inar = 0;
1028d9f6cdbSralph }
1038d9f6cdbSralph } else if(*p1 == CEND) {
1048d9f6cdbSralph if(!dolflag) {
1058d9f6cdbSralph if(ipc->negfl)
1068d9f6cdbSralph goto yes;
1078d9f6cdbSralph ipc++;
1088d9f6cdbSralph continue;
1098d9f6cdbSralph }
1108d9f6cdbSralph
1118d9f6cdbSralph } else if(*p1 == CLNUM) {
1128d9f6cdbSralph c = p1[1];
1138d9f6cdbSralph if(lnum != tlno[c]) {
1148d9f6cdbSralph if(ipc->negfl)
1158d9f6cdbSralph goto yes;
1168d9f6cdbSralph ipc++;
1178d9f6cdbSralph continue;
1188d9f6cdbSralph }
1198d9f6cdbSralph if(p2)
1208d9f6cdbSralph ipc->inar = 1;
1218d9f6cdbSralph } else if(match(p1, 0)) {
1228d9f6cdbSralph if(p2)
1238d9f6cdbSralph ipc->inar = 1;
1248d9f6cdbSralph } else {
1258d9f6cdbSralph if(ipc->negfl)
1268d9f6cdbSralph goto yes;
1278d9f6cdbSralph ipc++;
1288d9f6cdbSralph continue;
1298d9f6cdbSralph }
1308d9f6cdbSralph }
1318d9f6cdbSralph
1328d9f6cdbSralph if(ipc->negfl) {
1338d9f6cdbSralph ipc++;
1348d9f6cdbSralph continue;
1358d9f6cdbSralph }
1368d9f6cdbSralph yes:
1378d9f6cdbSralph command(ipc);
1388d9f6cdbSralph
1398d9f6cdbSralph if(delflag)
1408d9f6cdbSralph break;
1418d9f6cdbSralph
1428d9f6cdbSralph if(jflag) {
1438d9f6cdbSralph jflag = 0;
1448d9f6cdbSralph if((ipc = ipc->lb1) == 0) {
1458d9f6cdbSralph ipc = ptrspace;
1468d9f6cdbSralph break;
1478d9f6cdbSralph }
1488d9f6cdbSralph } else
1498d9f6cdbSralph ipc++;
1508d9f6cdbSralph
1518d9f6cdbSralph }
1528d9f6cdbSralph if(!nflag && !delflag) {
1538d9f6cdbSralph for(p1 = linebuf; p1 < spend; p1++)
1548d9f6cdbSralph putc(*p1, stdout);
1558d9f6cdbSralph putc('\n', stdout);
1568d9f6cdbSralph }
1578d9f6cdbSralph
1588d9f6cdbSralph if(aptr > abuf) {
1598d9f6cdbSralph arout();
1608d9f6cdbSralph }
1618d9f6cdbSralph
1628d9f6cdbSralph delflag = 0;
1638d9f6cdbSralph
1648d9f6cdbSralph }
1658d9f6cdbSralph }
match(expbuf,gf)1668d9f6cdbSralph match(expbuf, gf)
1678d9f6cdbSralph char *expbuf;
1688d9f6cdbSralph {
1698d9f6cdbSralph register char *p1, *p2, c;
1708d9f6cdbSralph
1718d9f6cdbSralph if(gf) {
1728d9f6cdbSralph if(*expbuf) return(0);
1738d9f6cdbSralph p1 = linebuf;
1748d9f6cdbSralph p2 = genbuf;
1758d9f6cdbSralph while(*p1++ = *p2++);
1768d9f6cdbSralph locs = p1 = loc2;
1778d9f6cdbSralph } else {
1788d9f6cdbSralph p1 = linebuf;
1798d9f6cdbSralph locs = 0;
1808d9f6cdbSralph }
1818d9f6cdbSralph
1828d9f6cdbSralph p2 = expbuf;
1838d9f6cdbSralph if(*p2++) {
1848d9f6cdbSralph loc1 = p1;
1858d9f6cdbSralph if(*p2 == CCHR && p2[1] != *p1)
1868d9f6cdbSralph return(0);
1878d9f6cdbSralph return(advance(p1, p2));
1888d9f6cdbSralph }
1898d9f6cdbSralph
1908d9f6cdbSralph /* fast check for first character */
1918d9f6cdbSralph
1928d9f6cdbSralph if(*p2 == CCHR) {
1938d9f6cdbSralph c = p2[1];
1948d9f6cdbSralph do {
1958d9f6cdbSralph if(*p1 != c)
1968d9f6cdbSralph continue;
1978d9f6cdbSralph if(advance(p1, p2)) {
1988d9f6cdbSralph loc1 = p1;
1998d9f6cdbSralph return(1);
2008d9f6cdbSralph }
2018d9f6cdbSralph } while(*p1++);
2028d9f6cdbSralph return(0);
2038d9f6cdbSralph }
2048d9f6cdbSralph
2058d9f6cdbSralph do {
2068d9f6cdbSralph if(advance(p1, p2)) {
2078d9f6cdbSralph loc1 = p1;
2088d9f6cdbSralph return(1);
2098d9f6cdbSralph }
2108d9f6cdbSralph } while(*p1++);
2118d9f6cdbSralph return(0);
2128d9f6cdbSralph }
advance(alp,aep)2138d9f6cdbSralph advance(alp, aep)
2148d9f6cdbSralph char *alp, *aep;
2158d9f6cdbSralph {
2168d9f6cdbSralph register char *lp, *ep, *curlp;
2178d9f6cdbSralph char c;
2188d9f6cdbSralph char *bbeg;
2198d9f6cdbSralph int ct;
2208d9f6cdbSralph
2218d9f6cdbSralph /*fprintf(stderr, "*lp = %c, %o\n*ep = %c, %o\n", *lp, *lp, *ep, *ep); /*DEBUG*/
2228d9f6cdbSralph
2238d9f6cdbSralph lp = alp;
2248d9f6cdbSralph ep = aep;
2258d9f6cdbSralph for (;;) switch (*ep++) {
2268d9f6cdbSralph
2278d9f6cdbSralph case CCHR:
2288d9f6cdbSralph if (*ep++ == *lp++)
2298d9f6cdbSralph continue;
2308d9f6cdbSralph return(0);
2318d9f6cdbSralph
2328d9f6cdbSralph case CDOT:
2338d9f6cdbSralph if (*lp++)
2348d9f6cdbSralph continue;
2358d9f6cdbSralph return(0);
2368d9f6cdbSralph
2378d9f6cdbSralph case CNL:
2388d9f6cdbSralph case CDOL:
2398d9f6cdbSralph if (*lp == 0)
2408d9f6cdbSralph continue;
2418d9f6cdbSralph return(0);
2428d9f6cdbSralph
2438d9f6cdbSralph case CEOF:
2448d9f6cdbSralph loc2 = lp;
2458d9f6cdbSralph return(1);
2468d9f6cdbSralph
2478d9f6cdbSralph case CCL:
2488d9f6cdbSralph c = *lp++ & 0177;
2498d9f6cdbSralph if(ep[c>>3] & bittab[c & 07]) {
2508d9f6cdbSralph ep += 16;
2518d9f6cdbSralph continue;
2528d9f6cdbSralph }
2538d9f6cdbSralph return(0);
2548d9f6cdbSralph
2558d9f6cdbSralph case CBRA:
2568d9f6cdbSralph braslist[*ep++] = lp;
2578d9f6cdbSralph continue;
2588d9f6cdbSralph
2598d9f6cdbSralph case CKET:
2608d9f6cdbSralph braelist[*ep++] = lp;
2618d9f6cdbSralph continue;
2628d9f6cdbSralph
2638d9f6cdbSralph case CBACK:
2648d9f6cdbSralph bbeg = braslist[*ep];
2658d9f6cdbSralph ct = braelist[*ep++] - bbeg;
2668d9f6cdbSralph
2678d9f6cdbSralph if(ecmp(bbeg, lp, ct)) {
2688d9f6cdbSralph lp += ct;
2698d9f6cdbSralph continue;
2708d9f6cdbSralph }
2718d9f6cdbSralph return(0);
2728d9f6cdbSralph
2738d9f6cdbSralph case CBACK|STAR:
2748d9f6cdbSralph bbeg = braslist[*ep];
2758d9f6cdbSralph ct = braelist[*ep++] - bbeg;
2768d9f6cdbSralph curlp = lp;
2778d9f6cdbSralph while(ecmp(bbeg, lp, ct))
2788d9f6cdbSralph lp += ct;
2798d9f6cdbSralph
2808d9f6cdbSralph while(lp >= curlp) {
2818d9f6cdbSralph if(advance(lp, ep)) return(1);
2828d9f6cdbSralph lp -= ct;
2838d9f6cdbSralph }
2848d9f6cdbSralph return(0);
2858d9f6cdbSralph
2868d9f6cdbSralph
2878d9f6cdbSralph case CDOT|STAR:
2888d9f6cdbSralph curlp = lp;
2898d9f6cdbSralph while (*lp++);
2908d9f6cdbSralph goto star;
2918d9f6cdbSralph
2928d9f6cdbSralph case CCHR|STAR:
2938d9f6cdbSralph curlp = lp;
2948d9f6cdbSralph while (*lp++ == *ep);
2958d9f6cdbSralph ep++;
2968d9f6cdbSralph goto star;
2978d9f6cdbSralph
2988d9f6cdbSralph case CCL|STAR:
2998d9f6cdbSralph curlp = lp;
3008d9f6cdbSralph do {
3018d9f6cdbSralph c = *lp++ & 0177;
3028d9f6cdbSralph } while(ep[c>>3] & bittab[c & 07]);
3038d9f6cdbSralph ep += 16;
3048d9f6cdbSralph goto star;
3058d9f6cdbSralph
3068d9f6cdbSralph star:
3078d9f6cdbSralph if(--lp == curlp) {
3088d9f6cdbSralph continue;
3098d9f6cdbSralph }
3108d9f6cdbSralph
3118d9f6cdbSralph if(*ep == CCHR) {
3128d9f6cdbSralph c = ep[1];
3138d9f6cdbSralph do {
3148d9f6cdbSralph if(*lp != c)
3158d9f6cdbSralph continue;
3168d9f6cdbSralph if(advance(lp, ep))
3178d9f6cdbSralph return(1);
3188d9f6cdbSralph } while(lp-- > curlp);
3198d9f6cdbSralph return(0);
3208d9f6cdbSralph }
3218d9f6cdbSralph
3228d9f6cdbSralph if(*ep == CBACK) {
3238d9f6cdbSralph c = *(braslist[ep[1]]);
3248d9f6cdbSralph do {
3258d9f6cdbSralph if(*lp != c)
3268d9f6cdbSralph continue;
3278d9f6cdbSralph if(advance(lp, ep))
3288d9f6cdbSralph return(1);
3298d9f6cdbSralph } while(lp-- > curlp);
3308d9f6cdbSralph return(0);
3318d9f6cdbSralph }
3328d9f6cdbSralph
3338d9f6cdbSralph do {
3348d9f6cdbSralph if(lp == locs) break;
3358d9f6cdbSralph if (advance(lp, ep))
3368d9f6cdbSralph return(1);
3378d9f6cdbSralph } while (lp-- > curlp);
3388d9f6cdbSralph return(0);
3398d9f6cdbSralph
3408d9f6cdbSralph default:
3418d9f6cdbSralph fprintf(stderr, "RE botch, %o\n", *--ep);
3428d9f6cdbSralph }
3438d9f6cdbSralph }
3448d9f6cdbSralph substitute(ipc)
34523489cd2Sbostic struct reptr *ipc;
3468d9f6cdbSralph {
3478d9f6cdbSralph if(match(ipc->re1, 0) == 0) return(0);
3488d9f6cdbSralph
3498d9f6cdbSralph sflag = 1;
3508d9f6cdbSralph dosub(ipc->rhs);
3518d9f6cdbSralph
3528d9f6cdbSralph if(ipc->gfl) {
3538d9f6cdbSralph while(*loc2) {
3548d9f6cdbSralph if(match(ipc->re1, 1) == 0) break;
3558d9f6cdbSralph dosub(ipc->rhs);
3568d9f6cdbSralph }
3578d9f6cdbSralph }
3588d9f6cdbSralph return(1);
3598d9f6cdbSralph }
3608d9f6cdbSralph
dosub(rhsbuf)3618d9f6cdbSralph dosub(rhsbuf)
3628d9f6cdbSralph char *rhsbuf;
3638d9f6cdbSralph {
3648d9f6cdbSralph register char *lp, *sp, *rp;
3658d9f6cdbSralph int c;
3668d9f6cdbSralph
3678d9f6cdbSralph lp = linebuf;
3688d9f6cdbSralph sp = genbuf;
3698d9f6cdbSralph rp = rhsbuf;
3708d9f6cdbSralph while (lp < loc1)
3718d9f6cdbSralph *sp++ = *lp++;
3728d9f6cdbSralph while(c = *rp++) {
3738d9f6cdbSralph if (c == '&') {
3748d9f6cdbSralph sp = place(sp, loc1, loc2);
3758d9f6cdbSralph continue;
3768d9f6cdbSralph } else if (c&0200 && (c &= 0177) >= '1' && c < NBRA+'1') {
3778d9f6cdbSralph sp = place(sp, braslist[c-'1'], braelist[c-'1']);
3788d9f6cdbSralph continue;
3798d9f6cdbSralph }
3808d9f6cdbSralph *sp++ = c&0177;
3818d9f6cdbSralph if (sp >= &genbuf[LBSIZE])
3828d9f6cdbSralph fprintf(stderr, "output line too long.\n");
3838d9f6cdbSralph }
3848d9f6cdbSralph lp = loc2;
3858d9f6cdbSralph loc2 = sp - genbuf + linebuf;
3868d9f6cdbSralph while (*sp++ = *lp++)
3878d9f6cdbSralph if (sp >= &genbuf[LBSIZE]) {
3888d9f6cdbSralph fprintf(stderr, "Output line too long.\n");
3898d9f6cdbSralph }
3908d9f6cdbSralph lp = linebuf;
3918d9f6cdbSralph sp = genbuf;
3928d9f6cdbSralph while (*lp++ = *sp++);
3938d9f6cdbSralph spend = lp-1;
3948d9f6cdbSralph }
place(asp,al1,al2)3958d9f6cdbSralph char *place(asp, al1, al2)
3968d9f6cdbSralph char *asp, *al1, *al2;
3978d9f6cdbSralph {
3988d9f6cdbSralph register char *sp, *l1, *l2;
3998d9f6cdbSralph
4008d9f6cdbSralph sp = asp;
4018d9f6cdbSralph l1 = al1;
4028d9f6cdbSralph l2 = al2;
4038d9f6cdbSralph while (l1 < l2) {
4048d9f6cdbSralph *sp++ = *l1++;
4058d9f6cdbSralph if (sp >= &genbuf[LBSIZE])
4068d9f6cdbSralph fprintf(stderr, "Output line too long.\n");
4078d9f6cdbSralph }
4088d9f6cdbSralph return(sp);
4098d9f6cdbSralph }
4108d9f6cdbSralph
4118d9f6cdbSralph command(ipc)
41223489cd2Sbostic struct reptr *ipc;
4138d9f6cdbSralph {
4148d9f6cdbSralph register int i;
4158d9f6cdbSralph register char *p1, *p2, *p3;
4168d9f6cdbSralph char *execp;
4178d9f6cdbSralph
4188d9f6cdbSralph
4198d9f6cdbSralph switch(ipc->command) {
4208d9f6cdbSralph
4218d9f6cdbSralph case ACOM:
4228d9f6cdbSralph *aptr++ = ipc;
4238d9f6cdbSralph if(aptr >= &abuf[ABUFSIZE]) {
4248d9f6cdbSralph fprintf(stderr, "Too many appends after line %ld\n",
4258d9f6cdbSralph lnum);
4268d9f6cdbSralph }
4278d9f6cdbSralph *aptr = 0;
4288d9f6cdbSralph break;
4298d9f6cdbSralph
4308d9f6cdbSralph case CCOM:
4318d9f6cdbSralph delflag = 1;
4328d9f6cdbSralph if(!ipc->inar || dolflag) {
4338d9f6cdbSralph for(p1 = ipc->re1; *p1; )
4348d9f6cdbSralph putc(*p1++, stdout);
4358d9f6cdbSralph putc('\n', stdout);
4368d9f6cdbSralph }
4378d9f6cdbSralph break;
4388d9f6cdbSralph case DCOM:
4398d9f6cdbSralph delflag++;
4408d9f6cdbSralph break;
4418d9f6cdbSralph case CDCOM:
4428d9f6cdbSralph p1 = p2 = linebuf;
4438d9f6cdbSralph
4448d9f6cdbSralph while(*p1 != '\n') {
4458d9f6cdbSralph if(*p1++ == 0) {
4468d9f6cdbSralph delflag++;
4478d9f6cdbSralph return;
4488d9f6cdbSralph }
4498d9f6cdbSralph }
4508d9f6cdbSralph
4518d9f6cdbSralph p1++;
4528d9f6cdbSralph while(*p2++ = *p1++);
4538d9f6cdbSralph spend = p2-1;
4548d9f6cdbSralph jflag++;
4558d9f6cdbSralph break;
4568d9f6cdbSralph
4578d9f6cdbSralph case EQCOM:
4588d9f6cdbSralph fprintf(stdout, "%ld\n", lnum);
4598d9f6cdbSralph break;
4608d9f6cdbSralph
4618d9f6cdbSralph case GCOM:
4628d9f6cdbSralph p1 = linebuf;
4638d9f6cdbSralph p2 = holdsp;
4648d9f6cdbSralph while(*p1++ = *p2++);
4658d9f6cdbSralph spend = p1-1;
4668d9f6cdbSralph break;
4678d9f6cdbSralph
4688d9f6cdbSralph case CGCOM:
4698d9f6cdbSralph *spend++ = '\n';
4708d9f6cdbSralph p1 = spend;
4718d9f6cdbSralph p2 = holdsp;
4728d9f6cdbSralph while(*p1++ = *p2++)
4738d9f6cdbSralph if(p1 >= lbend)
4748d9f6cdbSralph break;
4758d9f6cdbSralph spend = p1-1;
4768d9f6cdbSralph break;
4778d9f6cdbSralph
4788d9f6cdbSralph case HCOM:
4798d9f6cdbSralph p1 = holdsp;
4808d9f6cdbSralph p2 = linebuf;
4818d9f6cdbSralph while(*p1++ = *p2++);
4828d9f6cdbSralph hspend = p1-1;
4838d9f6cdbSralph break;
4848d9f6cdbSralph
4858d9f6cdbSralph case CHCOM:
4868d9f6cdbSralph *hspend++ = '\n';
4878d9f6cdbSralph p1 = hspend;
4888d9f6cdbSralph p2 = linebuf;
4898d9f6cdbSralph while(*p1++ = *p2++)
4908d9f6cdbSralph if(p1 >= hend)
4918d9f6cdbSralph break;
4928d9f6cdbSralph hspend = p1-1;
4938d9f6cdbSralph break;
4948d9f6cdbSralph
4958d9f6cdbSralph case ICOM:
4968d9f6cdbSralph for(p1 = ipc->re1; *p1; )
4978d9f6cdbSralph putc(*p1++, stdout);
4988d9f6cdbSralph putc('\n', stdout);
4998d9f6cdbSralph break;
5008d9f6cdbSralph
5018d9f6cdbSralph case BCOM:
5028d9f6cdbSralph jflag = 1;
5038d9f6cdbSralph break;
5048d9f6cdbSralph
5058d9f6cdbSralph case LCOM:
5068d9f6cdbSralph p1 = linebuf;
5078d9f6cdbSralph p2 = genbuf;
5088d9f6cdbSralph genbuf[72] = 0;
5098d9f6cdbSralph while(*p1)
5108d9f6cdbSralph if(*p1 >= 040) {
5118d9f6cdbSralph if(*p1 == 0177) {
5128d9f6cdbSralph p3 = rub;
5138d9f6cdbSralph while(*p2++ = *p3++)
5148d9f6cdbSralph if(p2 >= lcomend) {
5158d9f6cdbSralph *p2 = '\\';
5168d9f6cdbSralph fprintf(stdout, "%s\n", genbuf);
5178d9f6cdbSralph p2 = genbuf;
5188d9f6cdbSralph }
5198d9f6cdbSralph p2--;
5208d9f6cdbSralph p1++;
5218d9f6cdbSralph continue;
5228d9f6cdbSralph }
5238d9f6cdbSralph *p2++ = *p1++;
5248d9f6cdbSralph if(p2 >= lcomend) {
5258d9f6cdbSralph *p2 = '\\';
5268d9f6cdbSralph fprintf(stdout, "%s\n", genbuf);
5278d9f6cdbSralph p2 = genbuf;
5288d9f6cdbSralph }
5298d9f6cdbSralph } else {
5308d9f6cdbSralph p3 = trans[*p1-1];
5318d9f6cdbSralph while(*p2++ = *p3++)
5328d9f6cdbSralph if(p2 >= lcomend) {
5338d9f6cdbSralph *p2 = '\\';
5348d9f6cdbSralph fprintf(stdout, "%s\n", genbuf);
5358d9f6cdbSralph p2 = genbuf;
5368d9f6cdbSralph }
5378d9f6cdbSralph p2--;
5388d9f6cdbSralph p1++;
5398d9f6cdbSralph }
5408d9f6cdbSralph *p2 = 0;
5418d9f6cdbSralph fprintf(stdout, "%s\n", genbuf);
5428d9f6cdbSralph break;
5438d9f6cdbSralph
5448d9f6cdbSralph case NCOM:
5458d9f6cdbSralph if(!nflag) {
5468d9f6cdbSralph for(p1 = linebuf; p1 < spend; p1++)
5478d9f6cdbSralph putc(*p1, stdout);
5488d9f6cdbSralph putc('\n', stdout);
5498d9f6cdbSralph }
5508d9f6cdbSralph
5518d9f6cdbSralph if(aptr > abuf)
5528d9f6cdbSralph arout();
5538d9f6cdbSralph if((execp = gline(linebuf)) == badp) {
5548d9f6cdbSralph pending = ipc;
5558d9f6cdbSralph delflag = 1;
5568d9f6cdbSralph break;
5578d9f6cdbSralph }
5588d9f6cdbSralph spend = execp;
5598d9f6cdbSralph
5608d9f6cdbSralph break;
5618d9f6cdbSralph case CNCOM:
5628d9f6cdbSralph if(aptr > abuf)
5638d9f6cdbSralph arout();
5648d9f6cdbSralph *spend++ = '\n';
5658d9f6cdbSralph if((execp = gline(spend)) == badp) {
5668d9f6cdbSralph pending = ipc;
5678d9f6cdbSralph delflag = 1;
5688d9f6cdbSralph break;
5698d9f6cdbSralph }
5708d9f6cdbSralph spend = execp;
5718d9f6cdbSralph break;
5728d9f6cdbSralph
5738d9f6cdbSralph case PCOM:
5748d9f6cdbSralph for(p1 = linebuf; p1 < spend; p1++)
5758d9f6cdbSralph putc(*p1, stdout);
5768d9f6cdbSralph putc('\n', stdout);
5778d9f6cdbSralph break;
5788d9f6cdbSralph case CPCOM:
5798d9f6cdbSralph cpcom:
5808d9f6cdbSralph for(p1 = linebuf; *p1 != '\n' && *p1 != '\0'; )
5818d9f6cdbSralph putc(*p1++, stdout);
5828d9f6cdbSralph putc('\n', stdout);
5838d9f6cdbSralph break;
5848d9f6cdbSralph
5858d9f6cdbSralph case QCOM:
5868d9f6cdbSralph if(!nflag) {
5878d9f6cdbSralph for(p1 = linebuf; p1 < spend; p1++)
5888d9f6cdbSralph putc(*p1, stdout);
5898d9f6cdbSralph putc('\n', stdout);
5908d9f6cdbSralph }
5918d9f6cdbSralph if(aptr > abuf) arout();
5928d9f6cdbSralph fclose(stdout);
5938d9f6cdbSralph exit(0);
5948d9f6cdbSralph case RCOM:
5958d9f6cdbSralph
5968d9f6cdbSralph *aptr++ = ipc;
5978d9f6cdbSralph if(aptr >= &abuf[ABUFSIZE])
5988d9f6cdbSralph fprintf(stderr, "Too many reads after line%ld\n",
5998d9f6cdbSralph lnum);
6008d9f6cdbSralph
6018d9f6cdbSralph *aptr = 0;
6028d9f6cdbSralph
6038d9f6cdbSralph break;
6048d9f6cdbSralph
6058d9f6cdbSralph case SCOM:
6068d9f6cdbSralph i = substitute(ipc);
6078d9f6cdbSralph if(ipc->pfl && i)
6088d9f6cdbSralph if(ipc->pfl == 1) {
6098d9f6cdbSralph for(p1 = linebuf; p1 < spend; p1++)
6108d9f6cdbSralph putc(*p1, stdout);
6118d9f6cdbSralph putc('\n', stdout);
6128d9f6cdbSralph }
6138d9f6cdbSralph else
6148d9f6cdbSralph goto cpcom;
6158d9f6cdbSralph if(i && ipc->fcode)
6168d9f6cdbSralph goto wcom;
6178d9f6cdbSralph break;
6188d9f6cdbSralph
6198d9f6cdbSralph case TCOM:
6208d9f6cdbSralph if(sflag == 0) break;
6218d9f6cdbSralph sflag = 0;
6228d9f6cdbSralph jflag = 1;
6238d9f6cdbSralph break;
6248d9f6cdbSralph
6258d9f6cdbSralph wcom:
6268d9f6cdbSralph case WCOM:
6278d9f6cdbSralph fprintf(ipc->fcode, "%s\n", linebuf);
6286e34b221Sralph fflush(ipc->fcode);
6298d9f6cdbSralph break;
6308d9f6cdbSralph case XCOM:
6318d9f6cdbSralph p1 = linebuf;
6328d9f6cdbSralph p2 = genbuf;
6338d9f6cdbSralph while(*p2++ = *p1++);
6348d9f6cdbSralph p1 = holdsp;
6358d9f6cdbSralph p2 = linebuf;
6368d9f6cdbSralph while(*p2++ = *p1++);
6378d9f6cdbSralph spend = p2 - 1;
6388d9f6cdbSralph p1 = genbuf;
6398d9f6cdbSralph p2 = holdsp;
6408d9f6cdbSralph while(*p2++ = *p1++);
6418d9f6cdbSralph hspend = p2 - 1;
6428d9f6cdbSralph break;
6438d9f6cdbSralph
6448d9f6cdbSralph case YCOM:
6458d9f6cdbSralph p1 = linebuf;
6468d9f6cdbSralph p2 = ipc->re1;
6478d9f6cdbSralph while(*p1 = p2[*p1]) p1++;
6488d9f6cdbSralph break;
6498d9f6cdbSralph }
6508d9f6cdbSralph
6518d9f6cdbSralph }
6528d9f6cdbSralph
6538d9f6cdbSralph char *
gline(addr)6548d9f6cdbSralph gline(addr)
6558d9f6cdbSralph char *addr;
6568d9f6cdbSralph {
6578d9f6cdbSralph register char *p1, *p2;
6588d9f6cdbSralph register c;
6598d9f6cdbSralph p1 = addr;
6608d9f6cdbSralph p2 = cbp;
6618d9f6cdbSralph for (;;) {
6628d9f6cdbSralph if (p2 >= ebp) {
6638d9f6cdbSralph if ((c = read(f, ibuf, BUFSIZ)) <= 0) {
6648d9f6cdbSralph return(badp);
6658d9f6cdbSralph }
6668d9f6cdbSralph p2 = ibuf;
6678d9f6cdbSralph ebp = ibuf+c;
6688d9f6cdbSralph }
6698d9f6cdbSralph if ((c = *p2++) == '\n') {
6708d9f6cdbSralph if(p2 >= ebp) {
6718d9f6cdbSralph if((c = read(f, ibuf, BUFSIZ)) <= 0) {
6728d9f6cdbSralph close(f);
6738d9f6cdbSralph if(eargc == 0)
6748d9f6cdbSralph dolflag = 1;
6758d9f6cdbSralph }
6768d9f6cdbSralph
6778d9f6cdbSralph p2 = ibuf;
6788d9f6cdbSralph ebp = ibuf + c;
6798d9f6cdbSralph }
6808d9f6cdbSralph break;
6818d9f6cdbSralph }
6828d9f6cdbSralph if(c)
6838d9f6cdbSralph if(p1 < lbend)
6848d9f6cdbSralph *p1++ = c;
6858d9f6cdbSralph }
6868d9f6cdbSralph lnum++;
6878d9f6cdbSralph *p1 = 0;
6888d9f6cdbSralph cbp = p2;
6898d9f6cdbSralph
6908d9f6cdbSralph return(p1);
6918d9f6cdbSralph }
ecmp(a,b,count)6928d9f6cdbSralph ecmp(a, b, count)
6938d9f6cdbSralph char *a, *b;
6948d9f6cdbSralph {
6958d9f6cdbSralph while(count--)
6968d9f6cdbSralph if(*a++ != *b++) return(0);
6978d9f6cdbSralph return(1);
6988d9f6cdbSralph }
6998d9f6cdbSralph
arout()7008d9f6cdbSralph arout()
7018d9f6cdbSralph {
7028d9f6cdbSralph register char *p1;
7038d9f6cdbSralph FILE *fi;
7048d9f6cdbSralph char c;
7058d9f6cdbSralph int t;
7068d9f6cdbSralph
7078d9f6cdbSralph aptr = abuf - 1;
7088d9f6cdbSralph while(*++aptr) {
7098d9f6cdbSralph if((*aptr)->command == ACOM) {
7108d9f6cdbSralph for(p1 = (*aptr)->re1; *p1; )
7118d9f6cdbSralph putc(*p1++, stdout);
7128d9f6cdbSralph putc('\n', stdout);
7138d9f6cdbSralph } else {
7148d9f6cdbSralph if((fi = fopen((*aptr)->re1, "r")) == NULL)
7158d9f6cdbSralph continue;
7168d9f6cdbSralph while((t = getc(fi)) != EOF) {
7178d9f6cdbSralph c = t;
7188d9f6cdbSralph putc(c, stdout);
7198d9f6cdbSralph }
7208d9f6cdbSralph fclose(fi);
7218d9f6cdbSralph }
7228d9f6cdbSralph }
7238d9f6cdbSralph aptr = abuf;
7248d9f6cdbSralph *aptr = 0;
7258d9f6cdbSralph }
7268d9f6cdbSralph
727