![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to m4.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin|
Return to m4.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin |
1.1 root 1: #include <stdio.h>
2: #include <ctype.h>
3:
4: #ifdef MSDOS
5: #define TMPFILE "m4%dXXX"
6: #define TMPMIN 2 /* minimum temp file length */
7: #else
8: #define TMPFILE "/tmp/m4%dxxxxxx"
9: #define TMPMIN 6
10: #endif
11:
12: #define isletter(c) (isalpha(c)||c=='_')
13: #define BQUOTE '`'
14: #define EQUOTE '\''
15: #define HASHSZ 199
16: #define STRBLK 16 /* block size for dynamic string storage */
17: #if STRBLK < 12
18: need room for decimal rep of long int
19: #endif
20:
21: enum {FUNC, MACD, DSKF, MSTR};
22: enum {EX, MY, DV, MD, AD, SB, EQ, NE, LE, GE, LT, GT, AN, OR, RP, NL};
23:
24: typedef struct { /* for storing variable-length strings */
25: int s_refc; /* references--when zero space is freed */
26: int s_hash; /* raw hash value (sum of chars in body) */
27: char *s_body; /* start of contents */
28: char *s_next; /* end of contents */
29: char *s_last; /* end of storage */
30: } STRING;
31:
32: typedef union ifr { /* input-source stack frame */
33: struct {
34: struct ifr *i_back;
35: char i_cbuf; /* unget buffer for lookahead */
36: int i_type; /* if type is MSTRing */
37: STRING *i_pstr;
38: char *i_pchr; /* next char */
39: } ifb;
40: struct {
41: struct ifr *i_back;
42: char i_cbuf;
43: int i_type; /* if type is DSKFile */
44: FILE *i_fp;
45: } ifdk;
46: } IFRAME;
47:
48: typedef struct fstk { /* file information stack frame */
49: struct fstk *f_back;
50: STRING *f_name; /* pointer to name (NULL if stdin) */
51: int f_flag; /* flag = 0 until EOF is reached */
52: int f_line; /* line counter */
53: } FFRAME;
54:
55: typedef struct ofr { /* argument collection stack frame */
56: struct ofr *o_back;
57: STRING *o_pstr;
58: } OFRAME;
59:
60: typedef struct ent { /* symbol table entry */
61: struct ent *e_next;
62: int e_type; /* FUNC or MACD */
63: union {
64: int (*e_pfun)();
65: STRING *e_pstr;
66: } e_at;
67: STRING *e_name;
68: } ENTRY;
69:
70: /*
71: * built in functions
72: */
73: extern int mchangequote(), mdecr(), mdefine(), mdivert(), mdivnum(), mdnl(),
74: mdumpdef(), merrprint(), meval(), mifdef(), mifelse(),
75: minclude(), mincr(), mindex(), mlen(), mmaketemp(), msinclude(),
76: msubstr(), msyscmd(), mtranslit(), mundefine(), mundivert();
77:
78: /*
79: * output file info
80: */
81: struct {
82: char *name;
83: FILE *fp;
84: } outfile[10] = {{ NULL, stdout }};
85:
86: /*
87: * op table for eval
88: */
89: struct opdata {
90: int optype;
91: char keychar;
92: char secchar;
93: int prec;
94: } optable[] = {
95: #define SI 8 /* precedence of unary + and - */
96: EX, '^', '\0', 7, EX, '*', '*', 7,
97: MY, '*', '\0', 6, DV, '/', '\0', 6, MD, '%', '\0', 6,
98: AD, '+', '\0', 5, SB, '-', '\0', 5,
99: EQ, '=', '=', 4, GE, '>', '=', 4, GT, '>', '\0', 4,
100: NE, '!', '=', 4, LE, '<', '=', 4, LT, '<', '\0', 4,
101: #define NT 3 /* precedence of unary ! */
102: AN, '&', '&', 2, AN, '&', '\0', 2,
103: OR, '|', '|', 1, OR, '|', '\0', 1,
104: RP, ')', '\0', 10, NL, '\0', '\0', 0
105: #define LP 0 /* precedence of open paren */
106: };
107:
108: ENTRY *e_root[HASHSZ]; /* pointers to symbol table hash buckets */
109: OFRAME *ostkptr; /* output stack pointer */
110: IFRAME *istkptr; /* input stack pointer */
111: FFRAME *fstkptr; /* file info stack pointer */
112: FILE *offp = stdout; /* current output file pointer */
113: int ofnum; /* current diversion number */
114: int lstdchr = '\n'; /* last char from stdin */
115: int single; /* single argument flag */
116: int dnlflag; /* delete to newline flag */
117:
118: char bqt = BQUOTE;
119: char eqt = EQUOTE;
120: extern char *alloc();
121: STRING *makestr();
122:
123: main(argc, argv)
124: int argc;
125: char *argv[];
126: {
127: #ifdef MSDOS
128: msdoscvt("m4", &argc, &argv);
129: #endif
130: buildin("changequote", mchangequote);
131: buildin("decr", mdecr);
132: buildin("define", mdefine);
133: buildin("divert", mdivert);
134: buildin("divnum", mdivnum);
135: buildin("dnl", mdnl);
136: buildin("dumpdef", mdumpdef);
137: buildin("errprint", merrprint);
138: buildin("eval", meval);
139: buildin("ifdef", mifdef);
140: buildin("ifelse", mifelse);
141: buildin("include", minclude);
142: buildin("incr", mincr);
143: buildin("index", mindex);
144: buildin("len", mlen);
145: buildin("maketemp", mmaketemp);
146: buildin("sinclude", msinclude);
147: buildin("substr", msubstr);
148: buildin("syscmd", msyscmd);
149: buildin("translit", mtranslit);
150: buildin("undefine", mundefine);
151: buildin("undivert", mundivert);
152:
153: single = (argc == 2);
154: if (argc > 1) {
155: while (--argc)
156: if (pushfile(*++argv))
157: process(0);
158: else
159: errorp(0, "cannot open %s", *argv);
160: } else {
161: pushfile("-");
162: process(0);
163: }
164: mdivert(NULL);
165: mundivert(NULL);
166: exit(0);
167: }
168:
169: process(pct)
170: int pct;
171: {
172: char lc = '\0';
173: register int c, qct = 0;
174: int i;
175: STRING *a[10];
176: register STRING *b;
177: ENTRY *e, *find();
178:
179: for (c=nxch(); pct && isspace(c); c=nxch())
180: ;
181: while (c != '\0') {
182: if (qct)
183: if (c == eqt) {
184: if (--qct)
185: outputc(c);
186: } else {
187: if (c == bqt)
188: ++qct;
189: outputc(c);
190: }
191: else if (c == bqt)
192: ++qct;
193: else if (c==')' && pct && !--pct || c==',' && pct==1)
194: return (c);
195: else if (isletter(c) && !isletter(lc) && !isdigit(lc)) {
196: b = makestr();
197: do {
198: appendstr(b, c);
199: lc = c;
200: c = nxch();
201: } while (isletter(c) || isdigit(c));
202: if ((e=find(b)) == NULL) {
203: outputs(b->s_body);
204: decstr(b);
205: continue;
206: }
207: for (i=9; i; a[i--]=NULL)
208: ;
209: a[0] = b;
210: if (c != '(') {
211: istkptr->i_cbuf = c;
212: if (c=='\n' && istkptr->i_type==DSKF)
213: if (fstkptr->f_flag)
214: --fstkptr->f_back->f_line;
215: else
216: --fstkptr->f_line;
217: } else do {
218: pushout(b=makestr());
219: c = process(1);
220: if (i++<9 && strlen(b->s_body))
221: a[i] = b;
222: else
223: decstr(b);
224: popout();
225: } while (c != ')');
226: if (e->e_type == MACD)
227: macro(e->e_at.e_pstr, a);
228: else
229: (*e->e_at.e_pfun)(a);
230: for (i = 0; i < 10; i++)
231: decstr(a[i]);
232: c = '\0';
233: } else {
234: if (c=='(' && pct)
235: ++pct;
236: outputc(c);
237: }
238: lc = c;
239: c = nxch();
240: }
241: if (pct)
242: errorp(1, "unexpected EOF");
243: return (c);
244: }
245:
246: macro(ps, pps)
247: STRING *ps, **pps;
248: {
249: STRING *x;
250: register char *b, *v;
251:
252: x = makestr();
253: b = ps->s_body;
254: while (*b) {
255: if (*b != '$')
256: appendstr(x, *b++);
257: else if (!isdigit(*++b))
258: appendstr(x, '$');
259: else if (ps = pps[*b++ - '0'])
260: for (v = ps->s_body; *v; v++)
261: appendstr(x, *v);
262: }
263: pushstr(x);
264: decstr(x);
265: }
266:
267: pushfile(s)
268: char *s;
269: {
270: FILE *fp, *fopen();
271: register STRING *a = NULL;
272: register FFRAME *ftemp = fstkptr;
273: char c;
274:
275: if (ftemp!=NULL && ftemp->f_flag) {
276: decstr(ftemp->f_name);
277: fstkptr = ftemp->f_back;
278: free(ftemp);
279: }
280: if ( strcmp(s, "-") == 0 )
281: fp = stdin;
282: else if ( (fp = fopen(s, "r")) == NULL )
283: return (0);
284: pushinp(DSKF);
285: istkptr->i_fp = fp;
286: ftemp = (FFRAME *)alloc(sizeof(FFRAME));
287: ftemp->f_back = fstkptr;
288: ftemp->f_line = 1;
289: ftemp->f_flag = 0;
290: if (fp!=stdin && !(fstkptr==NULL && single)) {
291: a = makestr();
292: while (c = *s++)
293: appendstr(a, c);
294: }
295: ftemp->f_name = a;
296: fstkptr = ftemp;
297: return (1);
298: }
299:
300: pushstr(a)
301: STRING *a;
302: {
303: if (a==NULL || *a->s_body=='\0')
304: return;
305: pushinp(MSTR);
306: istkptr->i_pstr = a;
307: istkptr->i_pchr = a->s_body;
308: ++a->s_refc;
309: }
310:
311: pushnum(x)
312: long x;
313: {
314: register STRING *a;
315:
316: a = makestr();
317: sprintf(a->s_body, "%ld", x);
318: pushstr(a);
319: decstr(a);
320: }
321:
322: pushinp(t)
323: char t;
324: {
325: IFRAME *itemp;
326:
327: itemp = istkptr;
328: istkptr = (IFRAME *)alloc(sizeof(IFRAME));
329: istkptr->i_back = itemp;
330: istkptr->i_type = t;
331: istkptr->i_cbuf = '\0';
332: }
333:
334: popinp()
335: {
336: IFRAME *itemp;
337:
338: itemp = istkptr;
339: switch (istkptr->i_type) {
340: case MSTR:
341: decstr(istkptr->i_pstr);
342: break;
343: case DSKF:
344: if (istkptr->i_fp != stdin)
345: fclose(istkptr->i_fp);
346: fstkptr->f_flag = 1;
347: break;
348: }
349: istkptr = istkptr->i_back;
350: free(itemp);
351: return (istkptr != NULL);
352: }
353:
354: pushout(b)
355: STRING *b;
356: {
357: OFRAME *otemp;
358:
359: otemp = (OFRAME *)alloc(sizeof(OFRAME));
360: otemp->o_back = ostkptr;
361: otemp->o_pstr = b;
362: ostkptr = otemp;
363: ++b->s_refc;
364: }
365:
366: popout()
367: {
368: OFRAME *otemp;
369:
370: otemp = ostkptr;
371: ostkptr = ostkptr->o_back;
372: decstr(otemp->o_pstr);
373: free(otemp);
374: }
375:
376: nxch()
377: {
378: register int c;
379: FFRAME *ftemp;
380:
381: if (istkptr == NULL)
382: return ('\0');
383: if ((ftemp = fstkptr)->f_flag) {
384: decstr(ftemp->f_name);
385: fstkptr = ftemp->f_back;
386: free(ftemp);
387: }
388: switch (istkptr->i_type) {
389: case DSKF:
390: if (c=istkptr->i_cbuf)
391: istkptr->i_cbuf = '\0';
392: else
393: c = getc(istkptr->i_fp);
394: if (istkptr->i_fp == stdin)
395: lstdchr = c;
396: if (c == EOF)
397: c = '\0';
398: else if (c == '\n')
399: if (fstkptr->f_flag)
400: ++fstkptr->f_back->f_line;
401: else
402: ++fstkptr->f_line;
403: break;
404: case MSTR:
405: if (c=istkptr->i_cbuf)
406: istkptr->i_cbuf = '\0';
407: else
408: c = *istkptr->i_pchr++;
409: break;
410: }
411: if (c == '\0')
412: return (popinp()? nxch() : c);
413: else if (!dnlflag)
414: return (c);
415: if (c == '\n')
416: dnlflag = 0;
417: return (nxch());
418: }
419:
420: outputc(c)
421: char c;
422: {
423: if (ostkptr != NULL)
424: appendstr(ostkptr->o_pstr, c);
425: else
426: outc(c);
427: }
428:
429: outc(c)
430: char c;
431: {
432: if (offp != NULL)
433: putc(c, offp);
434: }
435:
436:
437: STRING *
438: makestr()
439: {
440: register STRING *a;
441:
442: a = (STRING *)alloc(sizeof(STRING));
443: a->s_body = a->s_next = (STRING *)alloc(STRBLK);
444: a->s_last = a->s_body + STRBLK - 1;
445: a->s_refc = 1;
446: a->s_hash = 0;
447: *a->s_next = '\0';
448: return (a);
449: }
450:
451: appendstr(a, c)
452: STRING *a;
453: char c;
454: {
455: register char *r, *s, *t;
456: int size;
457:
458: if (a->s_next < a->s_last) {
459: *a->s_next++ = c;
460: *a->s_next = '\0';
461: } else {
462: r = s = alloc(size = a->s_last - (t = a->s_body) + 1 + STRBLK);
463: while (*s++ = *t++)
464: ;
465: *(a->s_next = s) = '\0';
466: *--s = c;
467: free(a->s_body);
468: a->s_last = (a->s_body = r) + size - 1;
469: }
470: a->s_hash += c;
471: }
472:
473: decstr(a)
474: STRING *a;
475: {
476: if (a == NULL)
477: return;
478: if (--a->s_refc)
479: return;
480: free(a->s_body);
481: free(a);
482: }
483:
484: cmpstr(a, b)
485: STRING *a, *b;
486: {
487: if (a==NULL && b==NULL)
488: return (1);
489: if (a==NULL && b!=NULL || a!=NULL && b==NULL)
490: return (0);
491: return (!strcmp(a->s_body, b->s_body));
492: }
493:
494: outputs(s)
495: char *s;
496: {
497: register char *t, c;
498:
499: for (t = s; c = *t++; outputc(c))
500: ;
501: }
502:
503: ENTRY *
504: find(a)
505: STRING *a;
506: {
507: register ENTRY *e;
508: register int hash;
509:
510: hash = a->s_hash;
511: for (e = e_root[hash % HASHSZ]; e != NULL; e = e->e_next)
512: if (e->e_name->s_hash == hash
513: && strcmp(e->e_name->s_body, a->s_body) == 0)
514: return (e);
515: return (NULL);
516: }
517:
518: buildin(s, f)
519: char *s;
520: int (*f)();
521: {
522: STRING *a;
523: register int hash;
524: register ENTRY *e;
525:
526: a = makestr();
527: while (*s)
528: appendstr(a, *s++);
529: hash = a->s_hash % HASHSZ;
530: e = (ENTRY *)alloc(sizeof(ENTRY));
531: e->e_next = e_root[hash];
532: e->e_type = FUNC;
533: e->e_at.e_pfun = f;
534: e->e_name = a;
535: e_root[hash] = e;
536: }
537:
538: char *
539: alloc(n)
540: int n;
541: {
542: char *x;
543:
544: if ((x=malloc(n)) != NULL)
545: return(x);
546: errorp(1, "out of space");
547: }
548:
549: /* VARARGS */
550: errorp(f, x)
551: int f;
552: {
553: fprintf(stderr, "m4: ");
554: if (fstkptr != NULL) {
555: if (fstkptr->f_name != NULL)
556: fprintf(stderr, "%s: ", fstkptr->f_name->s_body);
557: fprintf(stderr, "%d: ", fstkptr->f_line);
558: }
559: fprintf(stderr, "%r", &x);
560: putc('\n', stderr);
561: if (f) {
562: while (lstdchr!=EOF && lstdchr!='\n')
563: lstdchr = getchar();
564: exit(1);
565: }
566: }
567:
568: mchangequote(pps)
569: STRING **pps;
570: {
571: bqt = pps[1]? *pps[1]->s_body : BQUOTE;
572: eqt = pps[2]? *pps[2]->s_body : EQUOTE;
573: }
574:
575: mdefine(pps)
576: STRING **pps;
577: {
578: ENTRY *find();
579: register ENTRY *e;
580: register char *s;
581: register int hash;
582: int c;
583: static char illmac[] = "illegal macro name: %s";
584:
585: if (pps[1]==NULL || !isletter(*pps[1]->s_body)) {
586: errorp(0, illmac, pps[1]!=NULL? pps[1]->s_body : NULL);
587: return;
588: }
589: s = pps[1]->s_body + 1;
590: while (c = *s++)
591: if (!(isletter(c)||isdigit(c))) {
592: errorp(0, illmac, pps[1]->s_body);
593: return;
594: }
595: if (e = find(pps[1])) {
596: if (e->e_type == MACD)
597: decstr(e->e_at.e_pstr);
598: } else {
599: e = (ENTRY *)alloc(sizeof(ENTRY));
600: e->e_next = e_root[hash = pps[1]->s_hash % HASHSZ];
601: e->e_name = pps[1];
602: ++pps[1]->s_refc;
603: e_root[hash] = e;
604: }
605: e->e_type = MACD;
606: if (pps[2]) {
607: e->e_at.e_pstr = pps[2];
608: ++pps[2]->s_refc;
609: } else
610: e->e_at.e_pstr = makestr();
611: }
612:
613: mdivert(pps)
614: STRING **pps;
615: {
616: char *fn;
617:
618: if (pps == NULL)
619: ofnum = 0;
620: else
621: ofnum = (pps[1] != NULL)? atoi(pps[1]->s_body) : 0;
622: if (ofnum>0 && ofnum<=9) {
623: if (outfile[ofnum].fp == NULL) {
624: outfile[ofnum].name = fn = alloc(15);
625: sprintf(fn, TMPFILE, ofnum);
626: mktemp(fn);
627: if ((outfile[ofnum].fp=fopen(fn,"w"))==NULL)
628: errorp(1, "m4: /tmp open error\n");
629: }
630: }
631: if (ofnum>=0 && ofnum<=9)
632: offp = outfile[ofnum].fp;
633: else
634: offp = NULL;
635: }
636:
637: mdivnum()
638: {
639: pushnum((long)ofnum);
640: }
641:
642: mdnl()
643: {
644: dnlflag = 1;
645: }
646:
647: mdumpdef(pps)
648: STRING **pps;
649: {
650: ENTRY *find();
651: register ENTRY *e;
652: register int i, f = 0;
653: int hash;
654:
655: for (i = 1; i <= 9; ++i)
656: if (pps[i] != NULL) {
657: if (e=find(pps[i]))
658: outdef(e);
659: f = 1;
660: }
661: if (!f)
662: for (hash = 0; hash < HASHSZ; ++hash)
663: for (e = e_root[hash]; e; e = e->e_next) {
664: outputc(bqt);
665: outputs(e->e_name->s_body);
666: outputc(eqt);
667: outputc('\t');
668: outdef(e);
669: outputc('\n');
670: }
671: }
672:
673: outdef(e)
674: ENTRY *e;
675: {
676: if (e->e_type == MACD) {
677: outputc(bqt);
678: outputs(e->e_at.e_pstr->s_body);
679: outputc(eqt);
680: }
681: }
682:
683: merrprint(pps)
684: STRING **pps;
685: {
686: register int i;
687:
688: for (i=1; i<=9; i++)
689: if (pps[i])
690: fprintf(stderr, pps[i]->s_body);
691: }
692:
693: meval(pps)
694: STRING **pps;
695: {
696: long calc();
697: char *s;
698:
699: if (pps[1] == NULL)
700: pushnum((long)0);
701: else {
702: s = pps[1]->s_body;
703: pushnum(calc(0, &s));
704: }
705: }
706:
707: long
708: calc(pr, ps)
709: int pr;
710: char **ps;
711: {
712: register struct opdata *opptr;
713: register char c;
714: char *s;
715: long val1, val2, l;
716: int oplength;
717:
718: for (s = *ps; isspace(*s); ++s)
719: ;
720: if (isdigit(c=*s++))
721: for (val1 = c - '0'; isdigit(c = *s); ++s)
722: val1 = 10 * val1 + c - '0';
723: else switch (c) {
724: case '+':
725: val1 = calc(SI, &s);
726: break;
727: case '-':
728: val1 =-calc(SI, &s);
729: break;
730: case '!':
731: val1 =!calc(NT, &s);
732: break;
733: case '(':
734: val1 = calc(LP, &s);
735: break;
736: default:
737: if (c == '\0')
738: errorp(0, "eval: missing value");
739: else
740: errorp(0, "eval: invalid expression");
741: s = NULL;
742: }
743: if ((*ps = s) == NULL)
744: return (0);
745: for (;;) {
746: while (s!=NULL && isspace(c = *s))
747: ++s;
748: oplength = 1;
749: for (opptr = optable; s != NULL; ++opptr)
750: if (c != opptr->keychar) {
751: if (opptr->keychar == '\0')
752: s = NULL;
753: } else if (opptr->secchar=='\0') {
754: break;
755: } else if (opptr->secchar == *(s+1)) {
756: ++oplength;
757: break;
758: }
759: if ((*ps = s) == NULL) {
760: errorp(0, "eval: missing or unknown operator");
761: return (0);
762: }
763: if (opptr->prec <= pr)
764: return (val1);
765: *ps = s += oplength;
766: if (c == ')')
767: return (val1);
768: val2 = calc(opptr->prec, &s);
769: if ((*ps = s) == NULL)
770: return (0);
771: switch (opptr->optype) {
772: case EX:
773: if (val2 < 0)
774: val1 = 0;
775: else {
776: for (l = 1; val2; --val2)
777: l *= val1;
778: val1 = l;
779: }
780: break;
781: case MY:
782: val1 *= val2;
783: break;
784: case DV:
785: val1 /= val2;
786: break;
787: case MD:
788: val1 %= val2;
789: break;
790: case AD:
791: val1 += val2;
792: break;
793: case SB:
794: val1 -= val2;
795: break;
796: case EQ:
797: val1 = (val1 == val2);
798: break;
799: case NE:
800: val1 = (val1 != val2);
801: break;
802: case GE:
803: val1 = (val1 >= val2);
804: break;
805: case LE:
806: val1 = (val1 <= val2);
807: break;
808: case GT:
809: val1 = (val1 > val2);
810: break;
811: case LT:
812: val1 = (val1 < val2);
813: break;
814: case AN:
815: val1 = (val1 && val2);
816: break;
817: case OR:
818: val1 = (val1 || val2);
819: break;
820: }
821: }
822: }
823:
824: mifdef(pps)
825: STRING **pps;
826: {
827: ENTRY *find();
828:
829: if (pps[1] && find(pps[1])) {
830: pushstr(pps[2]);
831: } else
832: pushstr(pps[3]);
833: }
834:
835: mifelse(pps)
836: STRING **pps;
837: {
838: if (cmpstr(pps[1], pps[2]))
839: pushstr(pps[3]);
840: else if (moreargs(pps, 5))
841: if (cmpstr(pps[4], pps[5]))
842: pushstr(pps[6]);
843: else if (moreargs(pps, 8))
844: if (cmpstr(pps[7], pps[8]))
845: pushstr(pps[9]);
846: else
847: return;
848: else
849: pushstr(pps[7]);
850: else
851: pushstr(pps[4]);
852: }
853:
854: moreargs(pps, n)
855: STRING **pps;
856: register int n;
857: {
858: register int i;
859:
860: for (i=n; i<=9; i++)
861: if (pps[i] != NULL)
862: return (1);
863: return (0);
864: }
865:
866: minclude(pps)
867: STRING **pps;
868: {
869: if (msinclude(pps))
870: return;
871: errorp(1, "cannot open %s", pps[1]!=NULL? pps[1]->s_body : NULL);
872: }
873:
874: mincr(pps)
875: STRING **pps;
876: {
877: long atol();
878:
879: pushnum((long)((pps[1] != NULL)? atol(pps[1]->s_body)+1 : 1));
880: }
881:
882: mdecr(pps)
883: STRING **pps;
884: {
885: long atol();
886:
887: pushnum((long)((pps[1] != NULL)? atol(pps[1]->s_body)-1 : -1));
888: }
889:
890: mindex(pps)
891: STRING **pps;
892: {
893: register char *pc, *pf;
894: register int ln;
895: long v;
896: char *index();
897:
898: if (pps[2] == NULL)
899: v = 0;
900: else if (pps[1] == NULL)
901: v = -1;
902: else {
903: pc = pps[1]->s_body;
904: ln = strlen(pf = pps[2]->s_body);
905: while ((pc=index(pc, *pf))!=NULL && strncmp(pc, pf, ln))
906: ++pc;
907: v = (pc != NULL)? (long)(pc-pps[1]->s_body) : -1;
908: }
909: pushnum(v);
910: }
911:
912: mlen(pps)
913: STRING **pps;
914: {
915: pushnum((long)((pps[1] != NULL)? pps[1]->s_next-pps[1]->s_body : 0));
916: }
917:
918: mmaketemp(pps)
919: STRING **pps;
920: {
921: register char *pc;
922: if (pps[1]==NULL || strlen(pc = pps[1]->s_body)<TMPMIN)
923: return;
924: mktemp(pc);
925: pushstr(pps[1]);
926: }
927:
928: msinclude(pps)
929: STRING **pps;
930: {
931: return (pushfile((pps[1] != NULL)? pps[1]->s_body : NULL));
932: }
933:
934: msubstr(pps)
935: STRING **pps;
936: {
937: register char *pc, *pb, *pe;
938: int len, n, s;
939: STRING *a;
940:
941: if (pps[1] == NULL)
942: return;
943: len = strlen(pc = pps[1]->s_body);
944: if (pps[2] == NULL) {
945: n = (pps[3] != NULL)? atoi(pps[3]->s_body) : len;
946: s = (n>0)? 0 : -1;
947: } else {
948: s = atoi(pps[2]->s_body);
949: n = (pps[3] != NULL)? atoi(pps[3]->s_body) : (s>0)? len : -len;
950: }
951: if (n == 0)
952: return;
953: pe = pc + len;
954: if (s < 0)
955: s += len;
956: if (n < 0) {
957: s += n + 1;
958: n = -n;
959: }
960: a = makestr();
961: for (pb = pc + s; n--; ++pb)
962: if (pb>=pc && pb<=pe)
963: appendstr(a, *pb);
964: pushstr(a);
965: decstr(a);
966: }
967:
968: msyscmd(pps)
969: STRING **pps;
970: {
971: if (pps[1])
972: system(pps[1]->s_body);
973: }
974:
975: mtranslit(pps)
976: STRING **pps;
977: {
978: register char *pc, *pt, *pr;
979: char c = '\0';
980: STRING *a;
981:
982: if (pps[1]==NULL || pps[2]==NULL)
983: return;
984: a = makestr();
985: pc = pps[1]->s_body;
986: do {
987: pt = pps[2]->s_body;
988: pr = (pps[3] != NULL)? pps[3]->s_body : &c;
989: do {
990: if (*pc == *pt)
991: break;
992:
993: if (*pr)
994: ++pr;
995: } while (*++pt);
996: if (*pt) {
997: if (*pr)
998: appendstr(a, *pr);
999: } else
1000: appendstr(a, *pc);
1001: } while (*++pc);
1002: pushstr(a);
1003: decstr(a);
1004: }
1005:
1006: mundefine(pps)
1007: STRING **pps;
1008: {
1009: register ENTRY *e, *ep = NULL;
1010: register int hash;
1011:
1012: if (pps[1] == NULL)
1013: return;
1014: hash = pps[1]->s_hash;
1015: for (e = e_root[hash % HASHSZ]; e != NULL; e = e->e_next)
1016: if (e->e_name->s_hash == hash
1017: && strcmp(e->e_name->s_body, pps[1]->s_body) == 0)
1018: break;
1019: else
1020: ep = e;
1021: if (e == NULL)
1022: return;
1023: if (e->e_type == MACD)
1024: decstr(e->e_at.e_pstr);
1025: decstr(e->e_name);
1026: if (ep != NULL)
1027: ep->e_next = e->e_next;
1028: else
1029: e_root[hash % HASHSZ] = e->e_next;
1030: free(e);
1031: }
1032:
1033: mundivert(pps)
1034: STRING **pps;
1035: {
1036: register i, f = 0;
1037:
1038: if (pps)
1039: for (i = 1; i <= 9; i++)
1040: if (pps[i]) {
1041: undiv(atoi(pps[i]->s_body));
1042: f = 1;
1043: }
1044: if (pps==NULL || f==0)
1045: for (i = 1; i <= 9; i++)
1046: undiv(i);
1047: }
1048:
1049: undiv(n)
1050: register int n;
1051: {
1052: register int c;
1053: register FILE *fp;
1054:
1055: if (n>0 && n<=9 && (fp=outfile[n].fp) != NULL && ofnum!=n) {
1056: fclose(fp);
1057: if ((fp=fopen(outfile[n].name, "r")) == NULL)
1058: errorp(1, "cannot open %s", outfile[n].name);
1059: while ((c=getc(fp)) != EOF)
1060: outc(c);
1061: fclose(fp);
1062: unlink(outfile[n].name);
1063: free(outfile[n].name);
1064: outfile[n].name = outfile[n].fp = NULL;
1065: }
1066: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.