![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mk.bundle CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / mk|
Return to mk.bundle CVS log | Up to [Research Unix] / researchv10no / cmd / mk |
1.1 root 1: mkdir math fio libc
2: # To unbundle, sh this file
3: echo ./libc/README 1>&2
4: sed 's/.//' >./libc/README <<'//GO.SYSIN DD ./libc/README'
5: -here (as in ../fio) you have to add whatever commands
6: -you need to set up an archive in the shell file `gen'.
7: //GO.SYSIN DD ./libc/README
8: echo ./libc/doprint.c 1>&2
9: sed 's/.//' >./libc/doprint.c <<'//GO.SYSIN DD ./libc/doprint.c'
10: -#include <varargs.h>
11: -
12: -#define SIZE 1024
13: -#define FUNSIGN 4
14: -#define FSHORT 2
15: -#define FLONG 1
16: -#define PTR sizeof (char *)
17: -#define SHORT sizeof (int)
18: -#define INT sizeof (int)
19: -#define LONG sizeof (long)
20: -#define FLOAT sizeof (double)
21: -#define FDIGIT 30
22: -#define FDEFLT 8
23: -#define IDIGIT 40
24: -#define MAXCONV 30
25: -
26: -static char *out, *eout;
27: -static convcount = { 13 };
28: -
29: -static noconv();
30: -static cconv(), dconv(), hconv(), lconv();
31: -static oconv(), sconv(), uconv(), xconv();
32: -
33: -static econv(), fconv(), gconv(), percent();
34: -int printcol;
35: -static
36: -int (*fmtconv[MAXCONV])() =
37: -{
38: - noconv,
39: - cconv, dconv, hconv, lconv,
40: - oconv, sconv, uconv, xconv,
41: - econv, fconv, gconv, percent,
42: -};
43: -static
44: -char fmtindex[128] =
45: -{
46: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
47: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
48: - 0, 0, 0, 0, 0,12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
49: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
50: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
51: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
52: - 0, 0, 0, 1, 2, 9,10,11, 3, 0, 0, 0, 4, 0, 0, 5,
53: - 0, 0, 0, 6, 0, 7, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0,
54: -};
55: -
56: -fmtinstall(c, f)
57: -char c;
58: -int (*f)();
59: -{
60: -
61: - c &= 0177;
62: - if(fmtindex[c] == 0) {
63: - if(convcount >= MAXCONV)
64: - return 1;
65: - fmtindex[c] = convcount++;
66: - }
67: - fmtconv[fmtindex[c]] = f;
68: - return 0;
69: -}
70: -
71: -char*
72: -donprint(s, es, fmt, argpp)
73: -char *s, *es;
74: -register char *fmt;
75: -va_list *argpp;
76: -{
77: - register int f1, f2, f3, sf1, c;
78: - char *sout, *seout;
79: -
80: - sout = out;
81: - seout = eout;
82: - out = s;
83: - eout = es-1;
84: -loop:
85: - c = *fmt++;
86: - if(c != '%') {
87: - if(c == 0) {
88: - *out = 0;
89: - s = out;
90: - out = sout;
91: - eout = seout;
92: - return s;
93: - }
94: - if(out < eout)
95: - *out++ = c;
96: - printcol++;
97: - if(c == '\n')
98: - printcol = 0; else
99: - if(c == '\t')
100: - printcol = (printcol+7) & ~7;
101: - goto loop;
102: - }
103: - f1 = 0;
104: - f2 = -1;
105: - f3 = 0;
106: - c = *fmt++;
107: - sf1 = 0;
108: - if(c == '-') {
109: - sf1 = 1;
110: - c = *fmt++;
111: - }
112: - while(c >= '0' && c <= '9') {
113: - f1 = f1*10 + c-'0';
114: - c = *fmt++;
115: - }
116: - if(sf1)
117: - f1 = -f1;
118: - if(c != '.')
119: - goto l1;
120: - c = *fmt++;
121: - while(c >= '0' && c <= '9') {
122: - if(f2 < 0)
123: - f2 = 0;
124: - f2 = f2*10 + c-'0';
125: - c = *fmt++;
126: - }
127: -l1:
128: - if(c == 0)
129: - fmt--;
130: - /* NB: first arg is now a (va_list *) */
131: - c = (*fmtconv[fmtindex[c&0177]])(argpp, f1, f2, f3);
132: - if(c < 0) {
133: - f3 |= -c;
134: - c = *fmt++;
135: - goto l1;
136: - }
137: -#ifdef notdef
138: - argp += c; /* increment is now done in called routine by va_arg() */
139: -#endif
140: - goto loop;
141: -}
142: -
143: -numbconv(o, f1, f2, f3, b)
144: -va_list *o;
145: -{
146: - char s[IDIGIT];
147: - register long v;
148: - register int i, f, n, r;
149: -
150: - switch(f3 & (FLONG|FSHORT|FUNSIGN)) {
151: - case FLONG:
152: - v = va_arg(*o, long);
153: - r = LONG;
154: - break;
155: -
156: - case FUNSIGN|FLONG:
157: - v = va_arg(*o, unsigned long);
158: - r = LONG;
159: - break;
160: -
161: - /* NB: a (unsigned) short argument is promoted to an (unsigned) int arg. */
162: - case FSHORT:
163: - v = (short)va_arg(*o, int);
164: - r = SHORT;
165: - break;
166: -
167: - case FUNSIGN|FSHORT:
168: - v = (unsigned short)va_arg(*o, unsigned);
169: - r = SHORT;
170: - break;
171: -
172: - default:
173: - v = va_arg(*o, int);
174: - r = INT;
175: - break;
176: -
177: - case FUNSIGN:
178: - v = va_arg(*o, unsigned);
179: - r = INT;
180: - break;
181: - }
182: - f = 0;
183: - if(!(f3 & FUNSIGN) && v < 0) {
184: - v = -v;
185: - f = 1;
186: - }
187: - s[IDIGIT-1] = 0;
188: - for(i = IDIGIT-2; i >= 1; i--) {
189: - n = (unsigned long)v % b;
190: - n += '0';
191: - if(n > '9')
192: - n += 'a' - ('9'+1);
193: - s[i] = n;
194: - v = (unsigned long)v / b;
195: - if(f2 >= 0 && i >= IDIGIT-f2)
196: - continue;
197: - if(v <= 0)
198: - break;
199: - }
200: - if(f)
201: - s[--i] = '-';
202: - strconv(s+i, f1, -1);
203: - return r;
204: -}
205: -
206: -char*
207: -doprint(s, fmt, argp)
208: -char *s, *fmt;
209: -va_list *argp;
210: -{
211: -
212: - return donprint(s, s+SIZE, fmt, argp);
213: -}
214: -
215: -/*
216: - if you change this, change chconv
217: -*/
218: -
219: -strconv(o, f1, f2)
220: -char *o;
221: -{
222: - register int n, c;
223: - register char *s;
224: -
225: - n = 0;
226: - for(s = o; *s++;)
227: - n++;
228: - if(f1 >= 0)
229: - while(n < f1) {
230: - if(out < eout)
231: - *out++ = ' ';
232: - printcol++;
233: - n++;
234: - }
235: - for(s=o; c = *s++;)
236: - if(f2 != 0) {
237: - if(out < eout)
238: - *out++ = c;
239: - printcol++;
240: - if(c == '\n')
241: - printcol = 0; else
242: - if(c == '\t')
243: - printcol = (printcol+7) & ~7;
244: - f2--;
245: - }
246: - if(f1 < 0) {
247: - f1 = -f1;
248: - while(n < f1) {
249: - if(out < eout)
250: - *out++ = ' ';
251: - printcol++;
252: - n++;
253: - }
254: - }
255: -}
256: -
257: -chconv(o, f1)
258: -char o;
259: -{
260: - register int n;
261: -
262: - n = 1;
263: - if(f1 >= 0)
264: - while(n < f1) {
265: - if(out < eout)
266: - *out++ = ' ';
267: - printcol++;
268: - n++;
269: - }
270: - if(out < eout)
271: - *out++ = o;
272: - printcol++;
273: - if(o == '\n')
274: - printcol = 0; else
275: - if(o == '\t')
276: - printcol = (printcol+7) & ~7;
277: - if(f1 < 0) {
278: - f1 = -f1;
279: - while(n < f1) {
280: - if(out < eout)
281: - *out++ = ' ';
282: - printcol++;
283: - n++;
284: - }
285: - }
286: -}
287: -
288: -/* ARGSUSED */
289: -static
290: -noconv(o, f1, f2, f3)
291: -char *o;
292: -{
293: -
294: - strconv("***", 0, -1);
295: - return 0;
296: -}
297: -
298: -/* ARGSUSED */
299: -static
300: -cconv(o, f1, f2, f3)
301: -va_list *o;
302: -{
303: - chconv((char)va_arg(*o, int), f1);
304: - return INT;
305: -}
306: -
307: -static
308: -dconv(o, f1, f2, f3)
309: -va_list *o;
310: -{
311: - int r;
312: -
313: - r = numbconv(o, f1, f2, f3, 10);
314: - return r;
315: -}
316: -
317: -/* ARGSUSED */
318: -static
319: -hconv(o, f1, f2, f3)
320: -{
321: - return -FSHORT;
322: -}
323: -
324: -/* ARGSUSED */
325: -static
326: -lconv(o, f1, f2, f3)
327: -{
328: -
329: - return -FLONG;
330: -}
331: -
332: -static
333: -oconv(o, f1, f2, f3)
334: -va_list *o;
335: -{
336: - int r;
337: -
338: - r = numbconv(o, f1, f2, f3, 8);
339: - return r;
340: -}
341: -
342: -/* ARGSUSED */
343: -static
344: -sconv(o, f1, f2, f3)
345: -va_list *o;
346: -{
347: -
348: - strconv(va_arg(*o, char *), f1, f2);
349: - return PTR;
350: -}
351: -
352: -/* ARGSUSED */
353: -static
354: -uconv(o, f1, f2, f3)
355: -{
356: - return -FUNSIGN;
357: -}
358: -
359: -static
360: -xconv(o, f1, f2, f3)
361: -va_list *o;
362: -{
363: - int r;
364: -
365: - r = numbconv(o, f1, f2, f3, 16);
366: - return r;
367: -}
368: -
369: -double pow10(), frexp();
370: -/* ARGSUSED */
371: -fltconv(f, f1, f2, f3, c)
372: -register double f;
373: -{
374: - char s1[FDIGIT+10], s2[FDIGIT+10];
375: - register double g;
376: - register int d, i, n, s;
377: - double h;
378: - int e;
379: - int c1, c2, c3;
380: -
381: - s = 0;
382: - if(f < 0) {
383: - f = -f;
384: - s++;
385: - }
386: -
387: -loop:
388: - e = 0;
389: - g = 0;
390: - if(f != 0) {
391: - g = frexp(f, &e);
392: - e = e * .30103;
393: - d = e/2;
394: - h = f * pow10(-d); /* 10**-e in 2 parts */
395: - g = h * pow10(d-e);
396: - while(g < 1) {
397: - e--;
398: - g = h * pow10(d-e);
399: - }
400: - while(g >= 10) {
401: - e++;
402: - g = h * pow10(d-e);
403: - }
404: - }
405: - if(f2 < 0)
406: - f2 = FDEFLT;
407: - if(c == 'g' && f2 > 0)
408: - f2--;
409: - if(f2 > FDIGIT)
410: - f2 = FDIGIT;
411: - /*
412: - * n is number of digits to convert
413: - * 1 before, f2 after, 1 extra for rounding
414: - */
415: - n = f2 + 2;
416: - if(c == 'f') {
417: - /*
418: - * e+1 before, f2 after, 1 extra
419: - */
420: - n += e;
421: - if(n <= 0) {
422: - n = 1;
423: - g = 0;
424: - }
425: - }
426: - if(n >= FDIGIT+2) {
427: - if(c == 'e')
428: - f2 = -1;
429: - c = 'e';
430: - goto loop;
431: - }
432: - /*
433: - * convert n digits
434: - */
435: - for(i=0; i<n; i++) {
436: - d = g;
437: - if(d > g)
438: - d--;
439: - g -= d;
440: - s1[i+1] = d + '0';
441: - g *= 10;
442: - }
443: - /*
444: - * round by adding .5 into extra digit
445: - */
446: - d = 5;
447: - for(i=n-1; i>=0; i--) {
448: - s1[i+1] += d;
449: - d = 0;
450: - if(s1[i+1] > '9') {
451: - s1[i+1] -= 10;
452: - d++;
453: - }
454: - }
455: - i = 1;
456: - if(d) {
457: - s1[0] = '1';
458: - e++;
459: - i = 0;
460: - }
461: - /*
462: - * copy into final place
463: - * c1 digits of leading '0'
464: - * c2 digits from conversion
465: - * c3 digits after '.'
466: - */
467: - d = 0;
468: - if(s)
469: - s2[d++] = '-';
470: - c1 = 0;
471: - c2 = f2 + 1;
472: - c3 = f2;
473: - if(c == 'g')
474: - if(e >= -5 && e <= f2) {
475: - c1 = -e - 1;
476: - c3 = c1;
477: - if(c1 < 0)
478: - c1 = 0;
479: - c3 = f2 - e;
480: - c = 'h';
481: - }
482: - if(c == 'f') {
483: - c1 = -e;
484: - if(c1 < 0)
485: - c1 = 0;
486: - if(c1 > f2)
487: - c1 = c2;
488: - c2 += e;
489: - if(c2 < 0)
490: - c2 = 0;
491: - }
492: - while(c1 > 0) {
493: - if(c1+c2 == c3)
494: - s2[d++] = '.';
495: - s2[d++] = '0';
496: - c1--;
497: - }
498: - while(c2 > 0) {
499: - if(c1+c2 == c3)
500: - s2[d++] = '.';
501: - s2[d++] = s1[i++];
502: - c2--;
503: - }
504: - /*
505: - * strip trailing '0' on g conv
506: - */
507: - if(c == 'g' || c == 'h') {
508: - for(n=d-1; n>=0; n--)
509: - if(s2[n] != '0')
510: - break;
511: - for(i=n; i>=0; i--)
512: - if(s2[i] == '.') {
513: - d = n;
514: - if(i != n)
515: - d++;
516: - break;
517: - }
518: - }
519: - if(c == 'e' || c == 'g') {
520: - s2[d++] = 'e';
521: - s2[d++] = '+';
522: - c1 = e;
523: - if(c1 < 0) {
524: - s2[d-1] = '-';
525: - c1 = -c1;
526: - }
527: - if(c1 >= 100) {
528: - s2[d++] = c1/100 + '0';
529: - c1 %= 100;
530: - }
531: - s2[d++] = c1/10 + '0';
532: - s2[d++] = c1%10 + '0';
533: - }
534: - s2[d] = 0;
535: - strconv(s2, f1, -1);
536: - return FLOAT;
537: -}
538: -
539: -static
540: -econv(o, f1, f2, f3)
541: -va_list *o;
542: -{
543: -
544: - return fltconv(va_arg(*o, double), f1, f2, f3, 'e');
545: -}
546: -
547: -static
548: -fconv(o, f1, f2, f3)
549: -va_list *o;
550: -{
551: -
552: - return fltconv(va_arg(*o, double), f1, f2, f3, 'f');
553: -}
554: -
555: -static
556: -gconv(o, f1, f2, f3)
557: -va_list *o;
558: -{
559: -
560: - return fltconv(va_arg(*o, double), f1, f2, f3, 'g');
561: -}
562: -
563: -static
564: -percent()
565: -{
566: -
567: - if(out < eout)
568: - *out++ = '%';
569: - return 0;
570: -}
571: //GO.SYSIN DD ./libc/doprint.c
572: echo ./libc/exit.c 1>&2
573: sed 's/.//' >./libc/exit.c <<'//GO.SYSIN DD ./libc/exit.c'
574: -#include <libc.h>
575: -
576: -extern int (*_onexitfns[])();
577: -
578: -void
579: -exit(status)
580: -{
581: - int i, (*f)();
582: -
583: - for(i = NONEXIT-1; i >= 0; i--)
584: - if(_onexitfns[i]){
585: - f = _onexitfns[i];
586: - _onexitfns[i] = 0; /* self defense against bozos */
587: - (*f)();
588: - }
589: - _exit(status);
590: -}
591: //GO.SYSIN DD ./libc/exit.c
592: echo ./libc/regcomp.c 1>&2
593: sed 's/.//' >./libc/regcomp.c <<'//GO.SYSIN DD ./libc/regcomp.c'
594: -#include <libc.h>
595: -#include "regprog.h"
596: -
597: -/*
598: - * Parser Information
599: - */
600: -typedef struct Node{
601: - Inst *first;
602: - Inst *last;
603: -}Node;
604: -#define NSTACK 20
605: -static Node andstack[NSTACK];
606: -static Node *andp;
607: -static int atorstack[NSTACK];
608: -static int *atorp;
609: -static int cursubid; /* id of current subexpression */
610: -static int subidstack[NSTACK]; /* parallel to atorstack */
611: -static int *subidp;
612: -static int lastwasand; /* Last token was operand */
613: -static int nbra;
614: -static char *exprp; /* pointer to next character in source expression */
615: -static int nclass;
616: -static Class *classp;
617: -static Inst *freep;
618: -static int errors;
619: -
620: -/* predeclared crap */
621: -static void operator();
622: -static void pushand();
623: -static void pushator();
624: -static void evaluntil();
625: -static void bldcclass();
626: -
627: -static void
628: -rcerror(s)
629: - char *s;
630: -{
631: - errors++;
632: - regerror(s);
633: -}
634: -
635: -static Inst *
636: -newinst(t)
637: - int t;
638: -{
639: - freep->type=t;
640: - freep->left=0;
641: - freep->right=0;
642: - return freep++;
643: -}
644: -
645: -static void
646: -operand(t)
647: - int t;
648: -{
649: - register Inst *i;
650: - if(lastwasand)
651: - operator(CAT); /* catenate is implicit */
652: - i=newinst(t);
653: - if(t==CCLASS) /* ugh */
654: - i->right=(Inst *)&(classp[nclass-1]); /* UGH! */
655: - pushand(i, i);
656: - lastwasand=TRUE;
657: -}
658: -
659: -static void
660: -operator(t)
661: - int t;
662: -{
663: - if(t==RBRA && --nbra<0)
664: - rcerror("unmatched right paren");
665: - if(t==LBRA) {
666: - if (++cursubid >= NSUBEXP)
667: - rcerror ("too many subexpressions");
668: - nbra++;
669: - if (lastwasand)
670: - operator(CAT);
671: - } else
672: - evaluntil(t);
673: - if(t!=RBRA)
674: - pushator(t);
675: - lastwasand=FALSE;
676: - if(t==STAR || t==QUEST || t==PLUS || t==RBRA)
677: - lastwasand=TRUE; /* these look like operands */
678: -}
679: -
680: -static void
681: -regerr2(s, c)
682: - char *s;
683: -{
684: - char buf[100];
685: - char *cp = buf;
686: - while(*s)
687: - *cp++ = *s++;
688: - *cp++ = c;
689: - *cp = '\0';
690: - rcerror(buf);
691: -}
692: -
693: -static void
694: -cant(s)
695: - char *s;
696: -{
697: - char buf[100];
698: - strcpy(buf, "can't happen: ");
699: - strcat(buf, s);
700: - rcerror(buf);
701: -}
702: -
703: -static void
704: -pushand(f, l)
705: - Inst *f, *l;
706: -{
707: - if(andp >= &andstack[NSTACK])
708: - cant("operand stack overflow");
709: - andp->first=f;
710: - andp->last=l;
711: - andp++;
712: -}
713: -
714: -static void
715: -pushator(t)
716: - int t;
717: -{
718: - if(atorp >= &atorstack[NSTACK])
719: - cant("operator stack overflow");
720: - *atorp++=t;
721: - *subidp++=cursubid;
722: -}
723: -
724: -static Node *
725: -popand(op)
726: -{
727: - register Inst *inst;
728: -
729: - if(andp <= &andstack[0]) {
730: - regerr2("missing operand for ", op);
731: - inst=newinst(NOP);
732: - pushand(inst,inst);
733: - }
734: - return --andp;
735: -}
736: -
737: -static int
738: -popator()
739: -{
740: - if(atorp <= &atorstack[0])
741: - cant("operator stack underflow");
742: - --subidp;
743: - return *--atorp;
744: -}
745: -
746: -static void
747: -evaluntil(pri)
748: - register pri;
749: -{
750: - register Node *op1, *op2;
751: - register Inst *inst1, *inst2;
752: -
753: - while(pri==RBRA || atorp[-1]>=pri){
754: - switch(popator()){
755: - default:
756: - rcerror("unknown operator in evaluntil");
757: - break;
758: - case LBRA: /* must have been RBRA */
759: - op1=popand('(');
760: - inst2=newinst(RBRA);
761: - inst2->subid = *subidp;
762: - op1->last->next = inst2;
763: - inst1=newinst(LBRA);
764: - inst1->subid = *subidp;
765: - inst1->next=op1->first;
766: - pushand(inst1, inst2);
767: - return;
768: - case OR:
769: - op2=popand('|');
770: - op1=popand('|');
771: - inst2=newinst(NOP);
772: - op2->last->next=inst2;
773: - op1->last->next=inst2;
774: - inst1=newinst(OR);
775: - inst1->right=op1->first;
776: - inst1->left=op2->first;
777: - pushand(inst1, inst2);
778: - break;
779: - case CAT:
780: - op2=popand(0);
781: - op1=popand(0);
782: - op1->last->next=op2->first;
783: - pushand(op1->first, op2->last);
784: - break;
785: - case STAR:
786: - op2=popand('*');
787: - inst1=newinst(OR);
788: - op2->last->next=inst1;
789: - inst1->right=op2->first;
790: - pushand(inst1, inst1);
791: - break;
792: - case PLUS:
793: - op2=popand('+');
794: - inst1=newinst(OR);
795: - op2->last->next=inst1;
796: - inst1->right=op2->first;
797: - pushand(op2->first, inst1);
798: - break;
799: - case QUEST:
800: - op2=popand('?');
801: - inst1=newinst(OR);
802: - inst2=newinst(NOP);
803: - inst1->left=inst2;
804: - inst1->right=op2->first;
805: - op2->last->next=inst2;
806: - pushand(inst1, inst2);
807: - break;
808: - }
809: - }
810: -}
811: -
812: -static Prog *
813: -optimize(pp)
814: - Prog *pp;
815: -{
816: - register Inst *inst, *target;
817: - int size;
818: - Prog *npp;
819: - int diff;
820: -
821: - /*
822: - * get rid of NOOP chains
823: - */
824: - for(inst=pp->firstinst; inst->type!=END; inst++){
825: - target=inst->next;
826: - while(target->type == NOP)
827: - target=target->next;
828: - inst->next=target;
829: - }
830: -
831: - /*
832: - * The original allocation is for an area larger than
833: - * necessary. Reallocate to the actual space used
834: - * and then relocate the code.
835: - */
836: - size = sizeof(Prog) + (freep - pp->firstinst)*sizeof(Inst);
837: - npp = (Prog *)realloc((char *)pp, size);
838: - if(npp==NULL || npp==pp)
839: - return(pp);
840: - diff = (char *)npp - (char *)pp;
841: - freep = (Inst *)((char *)freep + diff);
842: - for(inst=npp->firstinst; inst<freep; inst++){
843: - switch(inst->type){
844: - case OR:
845: - case STAR:
846: - case PLUS:
847: - case QUEST:
848: - case CCLASS:
849: - *(char **)&inst->right += diff;
850: - break;
851: - }
852: - *(char **)&inst->left += diff;
853: - }
854: - *(char **)&npp->startinst += diff;
855: - return(npp);
856: -}
857: -
858: -#ifdef DEBUG
859: -static void
860: -dumpstack(){
861: - Node *stk;
862: - int *ip;
863: -
864: - printf("operators\n");
865: - for(ip=atorstack; ip<atorp; ip++)
866: - printf("0%o\n", *ip);
867: - printf("operands\n");
868: - for(stk=andstack; stk<andp; stk++)
869: - printf("0%o\t0%o\n", stk->first->type, stk->last->type);
870: -}
871: -
872: -static void
873: -dump(pp)
874: - Prog *pp;
875: -{
876: - Inst *l;
877: -
878: - l=pp->firstinst;
879: - do{
880: - printf("%d:\t0%o\t%d\t%d\n", l-pp->firstinst, l->type,
881: - l->left-pp->firstinst, l->right-pp->firstinst);
882: - }while(l++->type);
883: -}
884: -#endif
885: -
886: -static void
887: -startlex(s)
888: - char *s;
889: -{
890: - exprp=s;
891: - nclass=0;
892: - nbra=0;
893: -}
894: -
895: -static Class *
896: -newclass(){
897: - register Class *p;
898: - register n;
899: -
900: - if(nclass >= NCLASS)
901: - regerr2("too many character classes; limit", NCLASS+'0');
902: - p = &(classp[nclass++]);
903: - for(n=0; n<16; n++)
904: - p->map[n]=0;
905: - return p;
906: -}
907: -
908: -static int
909: -lex(){
910: - register c= *exprp++;
911: -
912: - switch(c){
913: - case '\\':
914: - if(*exprp)
915: - c= *exprp++;
916: - break;
917: - case 0:
918: - c=END;
919: - --exprp; /* In case we come here again */
920: - break;
921: - case '*':
922: - c=STAR;
923: - break;
924: - case '?':
925: - c=QUEST;
926: - break;
927: - case '+':
928: - c=PLUS;
929: - break;
930: - case '|':
931: - c=OR;
932: - break;
933: - case '.':
934: - c=ANY;
935: - break;
936: - case '(':
937: - c=LBRA;
938: - break;
939: - case ')':
940: - c=RBRA;
941: - break;
942: - case '^':
943: - c=BOL;
944: - break;
945: - case '$':
946: - c=EOL;
947: - break;
948: - case '[':
949: - c=CCLASS;
950: - bldcclass();
951: - break;
952: - }
953: - return c;
954: -}
955: -
956: -static int
957: -nextc(){
958: - if(exprp[0]==0 || (exprp[0]=='\\' && exprp[1]==0))
959: - rcerror("malformed '[]'");
960: - if(exprp[0]=='\\'){
961: - exprp++;
962: - return *exprp++|0200;
963: - }
964: - return *exprp++;
965: -}
966: -
967: -static void
968: -bldcclass(){
969: - register c1, c2;
970: - register Class *classp;
971: - register negate=FALSE;
972: -
973: - classp=newclass();
974: - /* we have already seen the '[' */
975: - if(*exprp=='^'){
976: - negate=TRUE;
977: - exprp++;
978: - }
979: - while((c1=c2=nextc()) != ']'){
980: - if(*exprp=='-'){
981: - exprp++; /* eat '-' */
982: - if((c2=nextc()) == ']')
983: - rcerror("malformed '[]'");
984: - }
985: - for((c1&=0177), (c2&=0177); c1<=c2; c1++)
986: - classp->map[c1/8] |= 1<<(c1&07);
987: - }
988: - if(negate)
989: - for(c1=0; c1<16; c1++)
990: - classp->map[c1]^=0377;
991: - classp->map[0] &= 0376; /* exclude NUL */
992: -}
993: -
994: -extern regexp *
995: -regcomp(s)
996: - char *s;
997: -{
998: - register token;
999: - Prog *pp;
1000: -
1001: - /* get memory for the program */
1002: - pp = (Prog *)malloc(sizeof(Prog) + 3*sizeof(Inst)*strlen(s));
1003: - if (pp == NULL) {
1004: - rcerror("out of memory");
1005: - return NULL;
1006: - }
1007: - freep = pp->firstinst;
1008: - classp = pp->class;
1009: - errors = 0;
1010: -
1011: - /* go compile the sucker */
1012: - startlex(s);
1013: - atorp=atorstack;
1014: - andp=andstack;
1015: - subidp=subidstack;
1016: - lastwasand=FALSE;
1017: - cursubid=0;
1018: -
1019: - /* Start with a low priority operator to prime parser */
1020: - pushator(START-1);
1021: - while((token=lex()) != END){
1022: - if((token&0300) == OPERATOR)
1023: - operator(token);
1024: - else
1025: - operand(token);
1026: - }
1027: -
1028: - /* Close with a low priority operator */
1029: - evaluntil(START);
1030: -
1031: - /* Force END */
1032: - operand(END);
1033: - evaluntil(START);
1034: -#ifdef DEBUG
1035: - dumpstack();
1036: -#endif
1037: - if(nbra)
1038: - rcerror("unmatched left paren");
1039: - --andp; /* points to first and only operand */
1040: - pp->startinst=andp->first;
1041: -#ifdef DEBUG
1042: - dump(pp);
1043: -#endif
1044: - pp = optimize(pp);
1045: -#ifdef DEBUG
1046: - printf("start: %d\n", andp->first-pp->firstinst);
1047: - dump(pp);
1048: -#endif
1049: - if (errors) {
1050: - free((char *)pp);
1051: - pp = NULL;
1052: - }
1053: - return (regexp *)pp;
1054: -}
1055: //GO.SYSIN DD ./libc/regcomp.c
1056: echo ./libc/getfields.c 1>&2
1057: sed 's/.//' >./libc/getfields.c <<'//GO.SYSIN DD ./libc/getfields.c'
1058: -#include <libc.h>
1059: -
1060: -static char is_sep[256] = {
1061: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1062: - 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1063: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1064: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1065: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1066: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1067: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1068: - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1069: -};
1070: -static char is_field[256] = {
1071: - 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1072: - 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1073: - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1074: - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1075: - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1076: - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1077: - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1078: - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1079: -};
1080: -static char last_sep[256];
1081: -
1082: -char *
1083: -setfields(arg)
1084: - char *arg;
1085: -{
1086: - register unsigned char *s;
1087: - register i;
1088: -
1089: - for(i = 1, s = (unsigned char *)last_sep; i < 256; i++)
1090: - if(is_sep[i])
1091: - *s++ = i;
1092: - *s = 0;
1093: - memset(is_sep, 0, sizeof is_sep);
1094: - memset(is_field, 1, sizeof is_field);
1095: - for(s = (unsigned char *)arg; *s;){
1096: - is_sep[*s] = 1;
1097: - is_field[*s++] = 0;
1098: - }
1099: - is_field[0] = 0;
1100: - return(last_sep);
1101: -}
1102: -
1103: -getfields(ss, sp, nptrs)
1104: - char *ss;
1105: - char **sp;
1106: -{
1107: - register unsigned char *s = (unsigned char *)ss;
1108: - register unsigned char **p = (unsigned char **)sp;
1109: - register unsigned c;
1110: -
1111: - for(;;){
1112: - if(--nptrs < 0) break;
1113: - *p++ = s;
1114: - while(is_field[c = *s++])
1115: - ;
1116: - if(c == 0) break;
1117: - s[-1] = 0;
1118: - }
1119: - if(nptrs > 0)
1120: - *p = 0;
1121: - else if(--s >= (unsigned char *)ss)
1122: - *s = c;
1123: - return(p - (unsigned char **)sp);
1124: -}
1125: -
1126: -getmfields(ss, sp, nptrs)
1127: - char *ss;
1128: - char **sp;
1129: -{
1130: - register unsigned char *s = (unsigned char *)ss;
1131: - register unsigned char **p = (unsigned char **)sp;
1132: - register unsigned c;
1133: - register unsigned d;
1134: -
1135: - if(nptrs <= 0)
1136: - return(0);
1137: - goto flushdelim;
1138: - for(;;){
1139: - *p++ = s;
1140: - if(--nptrs == 0) break;
1141: - while(is_field[c = *s++])
1142: - ;
1143: - /*
1144: - * s is now pointing 1 past the delimiter of the last field
1145: - * c is the delimiter
1146: - */
1147: - if(c == 0) break;
1148: - s[-1] = 0;
1149: - flushdelim:
1150: - while(is_sep[c = *s++])
1151: - ;
1152: - /*
1153: - * s is now pointing 1 past the beginning of the next field
1154: - * c is the first letter of the field
1155: - */
1156: - if(c == 0) break;
1157: - s--;
1158: - /*
1159: - * s is now pointing to the beginning of the next field
1160: - * c is the first letter of the field
1161: - */
1162: - }
1163: - if(nptrs > 0)
1164: - *p = 0;
1165: - return(p - (unsigned char **)sp);
1166: -}
1167: -
1168: -#ifdef MAIN
1169: -#include <fio.h>
1170: -
1171: -main()
1172: -{
1173: - char *fields[256];
1174: - char *s;
1175: - int n, i;
1176: - char buf[1024];
1177: -
1178: - print("go:\n");
1179: - while(s = Frdline(0)){
1180: - strcpy(buf, s);
1181: - Fprint(1, "getf:");
1182: - n = getfields(s, fields, 4);
1183: - for(i = 0; i < n; i++)
1184: - Fprint(1, " >%s<", fields[i]);
1185: - Fputc(1, '\n');
1186: - Fprint(1, "getmf:");
1187: - n = getmfields(buf, fields, 4);
1188: - for(i = 0; i < n; i++)
1189: - Fprint(1, " >%s<", fields[i]);
1190: - Fputc(1, '\n');
1191: - Fflush(1);
1192: - }
1193: - exit(0);
1194: -}
1195: -#endif
1196: //GO.SYSIN DD ./libc/getfields.c
1197: echo ./libc/libc.h 1>&2
1198: sed 's/.//' >./libc/libc.h <<'//GO.SYSIN DD ./libc/libc.h'
1199: -/* system calls */
1200: -extern unsigned alarm();
1201: -extern void nap(), pause();
1202: -extern char *sbrk();
1203: -extern void exit(), _exit();
1204: -extern long lseek();
1205: -extern void nice();
1206: -extern void profil();
1207: -extern unsigned long settod();
1208: -extern void sync();
1209: -extern long time();
1210: -
1211: -/* libc et al */
1212: -extern long lcm();
1213: -extern double atof(), strtod();
1214: -extern long atol();
1215: -extern char *crypt();
1216: -extern char *ctime();
1217: -extern char *ecvt(), *fcvt(), *gcvt();
1218: -extern char *galloc();
1219: -extern char *getenv();
1220: -extern char *getlogin();
1221: -extern char *getpass();
1222: -extern char *getwd(), *getcwd();
1223: -extern char *malloc(), *realloc(), *calloc();
1224: -extern char *memcpy(), *memchr(), *memccpy(), *memset();
1225: -extern char *mktemp();
1226: -extern double frand();
1227: -extern char *setfields();
1228: -extern char *strcpy(), *strncpy(), *strcat(), *strncat(), *strchr(), *strrchr();
1229: -extern char *strpbrk(), *strtok(), *strdup();
1230: -extern int atoi();
1231: -extern char *tgetstr(), tgoto();
1232: -extern char *ttyname(), *cttyname();
1233: -
1234: -#define NONEXIT 33
1235: //GO.SYSIN DD ./libc/libc.h
1236: echo ./libc/onexit.c 1>&2
1237: sed 's/.//' >./libc/onexit.c <<'//GO.SYSIN DD ./libc/onexit.c'
1238: -#include <libc.h>
1239: -
1240: -int (*_onexitfns[NONEXIT])();
1241: -
1242: -atexit(f)
1243: -int (*f)();
1244: -{
1245: - onexit(f);
1246: -}
1247: -
1248: -onexit(f)
1249: -int (*f)();
1250: -{
1251: - int i;
1252: -
1253: - for(i=0; i<NONEXIT; i++)
1254: - if(!_onexitfns[i]){
1255: - _onexitfns[i] = f;
1256: - return(1);
1257: - }
1258: - return(0);
1259: -}
1260: //GO.SYSIN DD ./libc/onexit.c
1261: echo ./libc/regexp.h 1>&2
1262: sed 's/.//' >./libc/regexp.h <<'//GO.SYSIN DD ./libc/regexp.h'
1263: -/* the structure describing a sub-expression match */
1264: -typedef struct {
1265: - char *sp;
1266: - char *ep;
1267: -} regsubexp;
1268: -
1269: -/* a compiled regular expression */
1270: -typedef char *regexp;
1271: -
1272: -/* the routines */
1273: -extern regexp *regcomp();
1274: -extern int regexec();
1275: -extern void regsub();
1276: //GO.SYSIN DD ./libc/regexp.h
1277: echo ./libc/print.c 1>&2
1278: sed 's/.//' >./libc/print.c <<'//GO.SYSIN DD ./libc/print.c'
1279: -#include <varargs.h>
1280: -
1281: -#define SIZE 1024
1282: -extern int printcol;
1283: -
1284: -char *doprint();
1285: -
1286: -/* VARARGS 1 */
1287: -print(fmt, va_alist)
1288: -char *fmt;
1289: -va_dcl
1290: -{
1291: - char buf[SIZE], *out;
1292: - va_list ap;
1293: -
1294: - va_start(ap);
1295: - out = doprint(buf, fmt, &ap);
1296: - va_end(ap);
1297: - return write(1, buf, (int)(out-buf));
1298: -}
1299: -
1300: -/* VARARGS 2 */
1301: -fprint(fd, fmt, va_alist)
1302: -char *fmt;
1303: -va_dcl
1304: -{
1305: - char buf[SIZE], *out;
1306: - va_list ap;
1307: -
1308: - va_start(ap);
1309: - out = doprint(buf, fmt, &ap);
1310: - va_end(ap);
1311: - return write(fd, buf, (int)(out-buf));
1312: -}
1313: -
1314: -/* VARARGS 2 */
1315: -sprint(buf, fmt, va_alist)
1316: -char *buf;
1317: -char *fmt;
1318: -va_dcl
1319: -{
1320: - char *out;
1321: - int scol;
1322: - va_list ap;
1323: -
1324: - scol = printcol;
1325: - va_start(ap);
1326: - out = doprint(buf, fmt, &ap);
1327: - va_end(ap);
1328: - printcol = scol;
1329: - return out-buf;
1330: -}
1331: //GO.SYSIN DD ./libc/print.c
1332: echo ./libc/strdup.c 1>&2
1333: sed 's/.//' >./libc/strdup.c <<'//GO.SYSIN DD ./libc/strdup.c'
1334: -/* @(#)strdup.c 1.2 */
1335: -/*LINTLIBRARY*/
1336: -/* string duplication
1337: - returns pointer to a new string which is the duplicate of string
1338: - pointed to by s1
1339: - NULL is returned if new string can't be created
1340: -*/
1341: -
1342: -#include <string.h>
1343: -#ifndef NULL
1344: -#define NULL 0
1345: -#endif
1346: -
1347: -extern int strlen();
1348: -extern char *malloc();
1349: -
1350: -char *
1351: -strdup(s1)
1352: -
1353: - char * s1;
1354: -
1355: -{
1356: - char * s2;
1357: -
1358: - s2 = malloc((unsigned) strlen(s1)+1) ;
1359: - return(s2==NULL ? NULL : strcpy(s2,s1) );
1360: -}
1361: //GO.SYSIN DD ./libc/strdup.c
1362: echo ./libc/Makefile 1>&2
1363: sed 's/.//' >./libc/Makefile <<'//GO.SYSIN DD ./libc/Makefile'
1364: -OBJ=doprint.o exit.o getfields.o onexit.o print.o strdup.o regcomp.o regexec.o regsub.o dup2.o
1365: -
1366: -libc.a: $(OBJ)
1367: - ar r libc.a $(OBJ)
1368: - $(RANLIB) libc.a
1369: -
1370: -cray: libc.o
1371: -
1372: -libc.o: $(OBJ)
1373: - cat $(OBJ) > libc.o
1374: //GO.SYSIN DD ./libc/Makefile
1375: echo ./libc/regexec.c 1>&2
1376: sed 's/.//' >./libc/regexec.c <<'//GO.SYSIN DD ./libc/regexec.c'
1377: -#include "regprog.h"
1378: -
1379: -/*
1380: - * Machine state
1381: - */
1382: -#define LISTINCREMENT 8
1383: -typedef struct List{
1384: - Inst *inst; /* Instruction of the thread */
1385: - Subexp se; /* matched subexpressions in this thread */
1386: -}List;
1387: -static List *tl, *nl; /* This list, next list */
1388: -static List *tle, *nle; /* ends of this and next list */
1389: -static List *list[2];
1390: -static List *liste[2];
1391: -static int listsize = LISTINCREMENT;
1392: -
1393: -static Subexp sempty; /* empty set of matches */
1394: -static int match; /* true if match is found */
1395: -
1396: -/*
1397: - * Note optimization in addinst:
1398: - * *lp must be pending when addinst called; if *l has been looked
1399: - * at already, the optimization is a bug.
1400: - */
1401: -static List *
1402: -newthread(lp, ip, sep)
1403: - List *lp; /* list to add to */
1404: - Inst *ip; /* instruction to add */
1405: - register Subexp *sep; /* pointers to subexpressions */
1406: -{
1407: - register List *p;
1408: -
1409: - for(p=lp; p->inst != NULL; p++){
1410: - if(p->inst==ip){
1411: - if((sep)->m[0].sp < p->se.m[0].sp)
1412: - p->se = *sep;
1413: - return NULL;
1414: - }
1415: - }
1416: - p->inst = ip;
1417: - p->se = *sep;
1418: - (++p)->inst = NULL;
1419: - return p;
1420: -}
1421: -
1422: -static void
1423: -newmatch(mp, ms, sp)
1424: - regsubexp *mp;
1425: - int ms;
1426: - register Subexp *sp;
1427: -{
1428: - register int i;
1429: -
1430: - if (mp==NULL || ms <=0)
1431: - return;
1432: - if(mp[0].sp==0 || sp->m[0].sp<mp[0].sp ||
1433: - (sp->m[0].sp==mp[0].sp && sp->m[0].ep>mp[0].ep)) {
1434: - for (i=0; i<ms && i<NSUBEXP; i++)
1435: - mp[i] = sp->m[i];
1436: - for (; i<ms; i++)
1437: - mp[i].sp = mp[i].ep = NULL;
1438: - }
1439: -}
1440: -
1441: -extern int
1442: -regexec(progp, starts, mp, ms)
1443: - Prog *progp; /* program to run */
1444: - char *starts; /* string to run machine on */
1445: - regsubexp *mp; /* subexpression elements */
1446: - int ms; /* number of elements pointed to by mp */
1447: -{
1448: - register flag=0;
1449: - register Inst *inst;
1450: - register List *tlp;
1451: - register char *s;
1452: - int startchar=progp->startinst->type<OPERATOR? progp->startinst->type : 0;
1453: - int i, checkstart;
1454: -
1455: -restart:
1456: - match = 0;
1457: - checkstart = startchar;
1458: - sempty.m[0].sp = NULL;
1459: - if (mp!=NULL && ms >0)
1460: - mp[0].sp = mp[0].ep = NULL;
1461: - if (list[0] == NULL) {
1462: - list[0] = (List *)malloc(2*listsize*sizeof(List));
1463: - list[1] = list[0] + listsize;
1464: - liste[0] = list[0] + listsize - 1;
1465: - liste[1] = list[1] + listsize - 1;
1466: - if (list[0] == NULL)
1467: - regerror("list overflow");
1468: - }
1469: - list[0][0].inst = list[1][0].inst = NULL;
1470: -
1471: - /* Execute machine once for each character, including terminal NUL */
1472: - s=starts;
1473: - do{
1474: - /* fast check for first char */
1475: - if(checkstart && *s!=startchar)
1476: - continue;
1477: - tl=list[flag];
1478: - tle=liste[flag];
1479: - nl=list[flag^=1];
1480: - nle=liste[flag];
1481: - nl->inst=0;
1482: - /* Add first instruction to this list */
1483: - sempty.m[0].sp = s;
1484: - (void)newthread(tl, progp->startinst, &sempty);
1485: - /* Execute machine until this list is empty */
1486: - for(tlp=tl; inst=tlp->inst; tlp++){ /* assignment = */
1487: - Switchstmt:
1488: - switch(inst->type){
1489: - default: /* regular character */
1490: - if(inst->type == *s){
1491: - Addinst:
1492: - if(newthread(nl, inst->next, &tlp->se)==nle)
1493: - goto realloc;
1494: - }
1495: - break;
1496: - case LBRA:
1497: - tlp->se.m[inst->subid].sp = s;
1498: - inst=inst->next;
1499: - goto Switchstmt;
1500: - case RBRA:
1501: - tlp->se.m[inst->subid].ep = s;
1502: - inst=inst->next;
1503: - goto Switchstmt;
1504: - case ANY:
1505: - goto Addinst;
1506: - case BOL:
1507: - if(s == starts){
1508: - inst=inst->next;
1509: - goto Switchstmt;
1510: - }
1511: - break;
1512: - case EOL:
1513: - if(*s=='\0'){
1514: - inst=inst->next;
1515: - goto Switchstmt;
1516: - }
1517: - break;
1518: - case CCLASS:
1519: - if(((char *)inst->right)[*s/8]&(1<<(*s&07)))
1520: - goto Addinst;
1521: - break;
1522: - case OR:
1523: - /* evaluate right choice later */
1524: - if (newthread(tlp, inst->right, &tlp->se) == tle)
1525: - goto realloc;
1526: - /* efficiency: advance and re-evaluate */
1527: - inst=inst->left;
1528: - goto Switchstmt;
1529: - case END: /* Match! */
1530: - match = 1;
1531: - tlp->se.m[0].ep = s;
1532: - if (mp != NULL && ms > 0) newmatch(mp, ms, &tlp->se);
1533: - break;
1534: - }
1535: - }
1536: - checkstart = startchar && nl->inst==NULL;
1537: - }while(*s++);
1538: - return match;
1539: -realloc:
1540: - free(list[0]);
1541: - list[0] = NULL;
1542: - listsize += LISTINCREMENT;
1543: - goto restart;
1544: -}
1545: -
1546: //GO.SYSIN DD ./libc/regexec.c
1547: echo ./libc/regprog.h 1>&2
1548: sed 's/.//' >./libc/regprog.h <<'//GO.SYSIN DD ./libc/regprog.h'
1549: -#include <regexp.h>
1550: -
1551: -/* useful constants */
1552: -#define NULL 0
1553: -#define TRUE 1
1554: -#define FALSE 0
1555: -#define HAT '\177' /* character to mark real beg. of line */
1556: -
1557: -/*
1558: - * Sub expression matches
1559: - */
1560: -#define NSUBEXP 10
1561: -typedef struct {
1562: - regsubexp m[NSUBEXP];
1563: -}Subexp;
1564: -
1565: -/*
1566: - * character class
1567: - */
1568: -typedef struct {
1569: - char map[16]; /* 16 bytes == 128 bits, one bit per char */
1570: -}Class;
1571: -
1572: -/*
1573: - * Machine instructions
1574: - */
1575: -typedef struct Inst{
1576: - int type; /* < 0200 ==> literal, otherwise action */
1577: - union {
1578: - int sid; /* sub-expression id for RBRA and LBRA */
1579: - struct Inst *other; /* instructions pointer */
1580: - } u;
1581: - struct Inst *left;
1582: -}Inst;
1583: -#define next left /* Left branch is usually just next ptr */
1584: -#define subid u.sid
1585: -#define right u.other
1586: -
1587: -/*
1588: - * Program definition
1589: - */
1590: -#define NCLASS 16
1591: -typedef struct Program{
1592: - Inst *startinst; /* start pc */
1593: - Class class[NCLASS]; /* .data */
1594: - Inst firstinst[5]; /* .text */
1595: -}Prog;
1596: -
1597: -/*
1598: - * Actions and Tokens
1599: - *
1600: - * 02xx are operators, value == precedence
1601: - * 03xx are tokens, i.e. operands for operators
1602: - */
1603: -#define OPERATOR 0200 /* Bitmask of all operators */
1604: -#define START 0200 /* Start, used for marker on stack */
1605: -#define RBRA 0201 /* Right bracket, ) */
1606: -#define LBRA 0202 /* Left bracket, ( */
1607: -#define OR 0203 /* Alternation, | */
1608: -#define CAT 0204 /* Concatentation, implicit operator */
1609: -#define STAR 0205 /* Closure, * */
1610: -#define PLUS 0206 /* a+ == aa* */
1611: -#define QUEST 0207 /* a? == a|nothing, i.e. 0 or 1 a's */
1612: -#define ANY 0300 /* Any character, . */
1613: -#define NOP 0301 /* No operation, internal use only */
1614: -#define BOL 0302 /* Beginning of line, ^ */
1615: -#define EOL 0303 /* End of line, $ */
1616: -#define CCLASS 0304 /* Character class, [] */
1617: -#define END 0377 /* Terminate: match found */
1618: //GO.SYSIN DD ./libc/regprog.h
1619: echo ./libc/regsub.c 1>&2
1620: sed 's/.//' >./libc/regsub.c <<'//GO.SYSIN DD ./libc/regsub.c'
1621: -#include "regprog.h"
1622: -
1623: -/* substitute into one string using the matches from the last regexec() */
1624: -extern void
1625: -regsub (sp, dp, mp, ms)
1626: - char *sp; /* source string */
1627: - char *dp; /* destination string */
1628: - regsubexp *mp; /* subexpression elements */
1629: - int ms; /* number of elements pointed to by mp */
1630: -{
1631: - char *ssp;
1632: - register int i;
1633: -
1634: - while (*sp != '\0') {
1635: - if (*sp == '\\') {
1636: - switch (*++sp) {
1637: - case '0':
1638: - case '1':
1639: - case '2':
1640: - case '3':
1641: - case '4':
1642: - case '5':
1643: - case '6':
1644: - case '7':
1645: - case '8':
1646: - case '9':
1647: - i = *sp-'0';
1648: - if (mp[i].sp != NULL && mp!=NULL && ms>i)
1649: - for (ssp = mp[i].sp;
1650: - ssp < mp[i].ep;
1651: - ssp++)
1652: - *dp++ = *ssp;
1653: - break;
1654: - case '\\':
1655: - *dp++ = '\\';
1656: - break;
1657: - case '\0':
1658: - sp--;
1659: - break;
1660: - default:
1661: - *dp++ = *sp;
1662: - break;
1663: - }
1664: - } else if (*sp == '&') {
1665: - if (mp[0].sp != NULL && mp!=NULL && ms>0)
1666: - if (mp[0].sp != NULL)
1667: - for (ssp = mp[0].sp;
1668: - ssp < mp[0].ep; ssp++)
1669: - *dp++ = *ssp;
1670: - } else
1671: - *dp++ = *sp;
1672: - sp++;
1673: - }
1674: - *dp = '\0';
1675: -}
1676: //GO.SYSIN DD ./libc/regsub.c
1677: echo ./libc/dup2.c 1>&2
1678: sed 's/.//' >./libc/dup2.c <<'//GO.SYSIN DD ./libc/dup2.c'
1679: -#ifdef SYSV
1680: -/*
1681: - dup2(a, b)
1682: -
1683: - dup a as value b
1684: -*/
1685: -
1686: -dup2(a, b)
1687: -{
1688: - int poot[256]; /* greater than NFILES i hope! */
1689: - register i, ret;
1690: -
1691: - close(b);
1692: - for(i = 0; (poot[i] = dup(a)) >= 0; i++)
1693: - if(poot[i] == b) break;
1694: - ret = i;
1695: - while(--i >= 0)
1696: - close(poot[i]); /* don't need 'em anymore */
1697: - return(poot[ret]);
1698: -}
1699: -#endif
1700: //GO.SYSIN DD ./libc/dup2.c
1701: echo ./libc/new.mk 1>&2
1702: sed 's/.//' >./libc/new.mk <<'//GO.SYSIN DD ./libc/new.mk'
1703: -#ifdef DEBUG
1704: -#include <stdio.h>
1705: -#endif
1706: -#include <libc.h>
1707: -#include "regprog.h"
1708: -
1709: -/*
1710: - * Parser Information
1711: - */
1712: -typedef struct Node{
1713: - Inst *first;
1714: - Inst *last;
1715: -}Node;
1716: -#define NSTACK 20
1717: -static Node andstack[NSTACK];
1718: -static Node *andp;
1719: -static int atorstack[NSTACK];
1720: -static int *atorp;
1721: -static int cursubid; /* id of current subexpression */
1722: -static int subidstack[NSTACK]; /* parallel to atorstack */
1723: -static int *subidp;
1724: -static int lastwasand; /* Last token was operand */
1725: -static int nbra;
1726: -static char *exprp; /* pointer to next character in source expression */
1727: -static int nclass;
1728: -static Class *classp;
1729: -static Inst *freep;
1730: -static int errors;
1731: -
1732: -/* predeclared crap */
1733: -static void operator();
1734: -static void pushand();
1735: -static void pushator();
1736: -static void evaluntil();
1737: -static void bldcclass();
1738: -
1739: -static void
1740: -rcerror(s)
1741: - char *s;
1742: -{
1743: - errors++;
1744: - regerror(s);
1745: -}
1746: -
1747: -static Inst *
1748: -newinst(t)
1749: - int t;
1750: -{
1751: - freep->type=t;
1752: - freep->left=0;
1753: - freep->right=0;
1754: - return freep++;
1755: -}
1756: -
1757: -static void
1758: -operand(t)
1759: - int t;
1760: -{
1761: - register Inst *i;
1762: - if(lastwasand)
1763: - operator(CAT); /* catenate is implicit */
1764: - i=newinst(t);
1765: - if(t==CCLASS) /* ugh */
1766: - i->right=(Inst *)&(classp[nclass-1]); /* UGH! */
1767: - pushand(i, i);
1768: - lastwasand=TRUE;
1769: -}
1770: -
1771: -static void
1772: -operator(t)
1773: - int t;
1774: -{
1775: - if(t==RBRA && --nbra<0)
1776: - rcerror("unmatched right paren");
1777: - if(t==LBRA) {
1778: - if (++cursubid >= NSUBEXP)
1779: - rcerror ("too many subexpressions");
1780: - nbra++;
1781: - if (lastwasand)
1782: - operator(CAT);
1783: - } else
1784: - evaluntil(t);
1785: - if(t!=RBRA)
1786: - pushator(t);
1787: - lastwasand=FALSE;
1788: - if(t==STAR || t==QUEST || t==PLUS || t==RBRA)
1789: - lastwasand=TRUE; /* these look like operands */
1790: -}
1791: -
1792: -static void
1793: -regerr2(s, c)
1794: - char *s;
1795: -{
1796: - char buf[100];
1797: - char *cp = buf;
1798: - while(*s)
1799: - *cp++ = *s++;
1800: - *cp++ = c;
1801: - *cp = '\0';
1802: - rcerror(buf);
1803: -}
1804: -
1805: -static void
1806: -cant(s)
1807: - char *s;
1808: -{
1809: - char buf[100];
1810: - strcpy(buf, "can't happen: ");
1811: - strcat(buf, s);
1812: - rcerror(buf);
1813: -}
1814: -
1815: -static void
1816: -pushand(f, l)
1817: - Inst *f, *l;
1818: -{
1819: - if(andp >= &andstack[NSTACK])
1820: - cant("operand stack overflow");
1821: - andp->first=f;
1822: - andp->last=l;
1823: - andp++;
1824: -}
1825: -
1826: -static void
1827: -pushator(t)
1828: - int t;
1829: -{
1830: - if(atorp >= &atorstack[NSTACK])
1831: - cant("operator stack overflow");
1832: - *atorp++=t;
1833: - *subidp++=cursubid;
1834: -}
1835: -
1836: -static Node *
1837: -popand(op)
1838: -{
1839: - register Inst *inst;
1840: -
1841: - if(andp <= &andstack[0]) {
1842: - regerr2("missing operand for ", op);
1843: - inst=newinst(NOP);
1844: - pushand(inst,inst);
1845: - }
1846: - return --andp;
1847: -}
1848: -
1849: -static int
1850: -popator()
1851: -{
1852: - if(atorp <= &atorstack[0])
1853: - cant("operator stack underflow");
1854: - --subidp;
1855: - return *--atorp;
1856: -}
1857: -
1858: -static void
1859: -evaluntil(pri)
1860: - register pri;
1861: -{
1862: - register Node *op1, *op2;
1863: - register Inst *inst1, *inst2;
1864: -
1865: - while(pri==RBRA || atorp[-1]>=pri){
1866: - switch(popator()){
1867: - default:
1868: - rcerror("unknown operator in evaluntil");
1869: - break;
1870: - case LBRA: /* must have been RBRA */
1871: - op1=popand('(');
1872: - inst2=newinst(RBRA);
1873: - inst2->subid = *subidp;
1874: - op1->last->next = inst2;
1875: - inst1=newinst(LBRA);
1876: - inst1->subid = *subidp;
1877: - inst1->next=op1->first;
1878: - pushand(inst1, inst2);
1879: - return;
1880: - case OR:
1881: - op2=popand('|');
1882: - op1=popand('|');
1883: - inst2=newinst(NOP);
1884: - op2->last->next=inst2;
1885: - op1->last->next=inst2;
1886: - inst1=newinst(OR);
1887: - inst1->right=op1->first;
1888: - inst1->left=op2->first;
1889: - pushand(inst1, inst2);
1890: - break;
1891: - case CAT:
1892: - op2=popand(0);
1893: - op1=popand(0);
1894: - op1->last->next=op2->first;
1895: - pushand(op1->first, op2->last);
1896: - break;
1897: - case STAR:
1898: - op2=popand('*');
1899: - inst1=newinst(OR);
1900: - op2->last->next=inst1;
1901: - inst1->right=op2->first;
1902: - pushand(inst1, inst1);
1903: - break;
1904: - case PLUS:
1905: - op2=popand('+');
1906: - inst1=newinst(OR);
1907: - op2->last->next=inst1;
1908: - inst1->right=op2->first;
1909: - pushand(op2->first, inst1);
1910: - break;
1911: - case QUEST:
1912: - op2=popand('?');
1913: - inst1=newinst(OR);
1914: - inst2=newinst(NOP);
1915: - inst1->left=inst2;
1916: - inst1->right=op2->first;
1917: - op2->last->next=inst2;
1918: - pushand(inst1, inst2);
1919: - break;
1920: - }
1921: - }
1922: -}
1923: -
1924: -static Prog *
1925: -optimize(pp)
1926: - Prog *pp;
1927: -{
1928: - register Inst *inst, *target;
1929: - int size;
1930: - Prog *npp;
1931: -
1932: - /*
1933: - * get rid of NOOP chains
1934: - */
1935: - for(inst=pp->firstinst; inst->type!=END; inst++){
1936: - target=inst->next;
1937: - while(target->type == NOP)
1938: - target=target->next;
1939: - inst->next=target;
1940: - }
1941: -
1942: - /*
1943: - * The original allocation is for an area larger than
1944: - * necessary. Reallocate to the actual space used
1945: - * and then relocate the code.
1946: - */
1947: - size = sizeof(Prog) + (freep - pp->firstinst)*sizeof(Inst);
1948: - npp = (Prog *)realloc((char *)pp, size);
1949: - if(npp==NULL || npp==pp)
1950: - return(pp);
1951: - freep = &npp->firstinst[freep - pp->firstinst];
1952: - npp->startinst = &npp->firstinst[pp->startinst - pp->firstinst];
1953: - for(inst=npp->firstinst; inst<freep; inst++){
1954: - switch(inst->type){
1955: - case OR:
1956: - case STAR:
1957: - case PLUS:
1958: - case QUEST:
1959: - inst->right = &npp->firstinst[inst->right - pp->firstinst];
1960: - break;
1961: - case CCLASS:
1962: - inst->right = (Inst *) &npp->class[(Class*)inst->right - pp->class];
1963: - break;
1964: - }
1965: - inst->left = &npp->firstinst[inst->left - pp->firstinst];
1966: - }
1967: - return(npp);
1968: -}
1969: -
1970: -#ifdef DEBUG
1971: -static char *
1972: -dumptype(t){
1973: - static char ordinary[4] = "'.'";
1974: -
1975: - switch(t){
1976: - case START: return "START";
1977: - case RBRA: return "RBRA";
1978: - case LBRA: return "LBRA";
1979: - case OR: return "OR";
1980: - case CAT: return "CAT";
1981: - case STAR: return "STAR";
1982: - case PLUS: return "PLUS";
1983: - case QUEST: return "QUEST";
1984: - case ANY: return "ANY";
1985: - case NOP: return "NOP";
1986: - case BOL: return "BOL";
1987: - case EOL: return "EOL";
1988: - case CCLASS: return "CCLASS";
1989: - case END: return "END";
1990: - default:
1991: - ordinary[1] = t;
1992: - return ordinary;
1993: - }
1994: -}
1995: -
1996: -static void
1997: -dumpstack(){
1998: - Node *stk;
1999: - int *ip;
2000: -
2001: - printf("operators\n");
2002: - for(ip=atorstack; ip<atorp; ip++)
2003: - printf("0%o\n", *ip);
2004: - printf("operands\n");
2005: - for(stk=andstack; stk<andp; stk++){
2006: - printf("%s\t", dumptype(stk->first->type));
2007: - printf("%s\n", dumptype(stk->last->type));
2008: - }
2009: -}
2010: -
2011: -static void
2012: -putC(c)
2013: -{
2014: - if(c < ' ' || '~' < c){
2015: - switch(c){
2016: - default:
2017: - putchar('^');
2018: - putchar((c + '@') & 0x7f);
2019: - return;
2020: - case '\b':
2021: - c = 'b';
2022: - break;
2023: - case '\t':
2024: - c = 't';
2025: - break;
2026: - case '\n':
2027: - c = 'n';
2028: - break;
2029: - case '\v':
2030: - c = 'v';
2031: - break;
2032: - case '\f':
2033: - c = 'f';
2034: - break;
2035: - case '\r':
2036: - c = 'r';
2037: - break;
2038: - }
2039: - putchar('\\');
2040: - }
2041: - putchar(c);
2042: -}
2043: -
2044: -static void
2045: -putCHAR(from, to)
2046: -{
2047: - if(from != 0)
2048: - if(from == to)
2049: - putC(from);
2050: - else{
2051: - putC(from);
2052: - putchar('-');
2053: - putC(to);
2054: - }
2055: -}
2056: -
2057: -static void
2058: -dump(pp)
2059: - Prog *pp;
2060: -{
2061: - int c, from;
2062: - Inst *l;
2063: - Class *classp;
2064: -
2065: - l=pp->firstinst;
2066: - do{
2067: - printf("%d:\t%s\t%d\t", l-pp->firstinst, dumptype(l->type),
2068: - l->left-pp->firstinst);
2069: - if(l->type == CCLASS){
2070: - classp = (Class*) l->right;
2071: - putchar('[');
2072: - if(classp->map[0] & 02){ /* ^A? */
2073: - putchar('^'); /* assume negation */
2074: - for(from=0, c=1; c < 128; ++c){
2075: - if(classp->map[c/8] & (1<<(c&07))){
2076: - putCHAR(from, c-1);
2077: - from = 0;
2078: - } else {
2079: - if(from == 0)
2080: - from = c;
2081: - }
2082: - }
2083: - putCHAR(from, c-1);
2084: - } else {
2085: - for(from=0, c=1; c < 128; ++c){
2086: - if(classp->map[c/8] & (1<<(c&07))){
2087: - if(from == 0)
2088: - from = c;
2089: - } else {
2090: - putCHAR(from, c-1);
2091: - from = 0;
2092: - }
2093: - }
2094: - putCHAR(from, c-1);
2095: - }
2096: - putchar(']');
2097: - } else
2098: - printf("%d", l->right-pp->firstinst);
2099: - putchar('\n');
2100: - }while(l++->type);
2101: -}
2102: -#endif
2103: -
2104: -static void
2105: -startlex(s)
2106: - char *s;
2107: -{
2108: - exprp=s;
2109: - nclass=0;
2110: - nbra=0;
2111: -}
2112: -
2113: -static Class *
2114: -newclass(){
2115: - register Class *p;
2116: - register n;
2117: -
2118: - if(nclass >= NCLASS)
2119: - regerr2("too many character classes; limit", NCLASS+'0');
2120: - p = &(classp[nclass++]);
2121: - for(n=0; n<16; n++)
2122: - p->map[n]=0;
2123: - return p;
2124: -}
2125: -
2126: -static int
2127: -lex(){
2128: - register c= *exprp++;
2129: -
2130: - switch(c){
2131: - case '\\':
2132: - if(*exprp)
2133: - c= *exprp++;
2134: - break;
2135: - case 0:
2136: - c=END;
2137: - --exprp; /* In case we come here again */
2138: - break;
2139: - case '*':
2140: - c=STAR;
2141: - break;
2142: - case '?':
2143: - c=QUEST;
2144: - break;
2145: - case '+':
2146: - c=PLUS;
2147: - break;
2148: - case '|':
2149: - c=OR;
2150: - break;
2151: - case '.':
2152: - c=ANY;
2153: - break;
2154: - case '(':
2155: - c=LBRA;
2156: - break;
2157: - case ')':
2158: - c=RBRA;
2159: - break;
2160: - case '^':
2161: - c=BOL;
2162: - break;
2163: - case '$':
2164: - c=EOL;
2165: - break;
2166: - case '[':
2167: - c=CCLASS;
2168: - bldcclass();
2169: - break;
2170: - }
2171: - return c;
2172: -}
2173: -
2174: -static int
2175: -nextc(){
2176: - if(exprp[0]==0 || (exprp[0]=='\\' && exprp[1]==0))
2177: - rcerror("malformed '[]'");
2178: - if(exprp[0]=='\\'){
2179: - exprp++;
2180: - return *exprp++|0200;
2181: - }
2182: - return *exprp++;
2183: -}
2184: -
2185: -static void
2186: -bldcclass(){
2187: - register c1, c2;
2188: - register Class *classp;
2189: - register negate=FALSE;
2190: -
2191: - classp=newclass();
2192: - /* we have already seen the '[' */
2193: - if(*exprp=='^'){
2194: - negate=TRUE;
2195: - exprp++;
2196: - }
2197: - while((c1=c2=nextc()) != ']'){
2198: - if(*exprp=='-'){
2199: - exprp++; /* eat '-' */
2200: - if((c2=nextc()) == ']')
2201: - rcerror("malformed '[]'");
2202: - }
2203: - for((c1&=0177), (c2&=0177); c1<=c2; c1++)
2204: - classp->map[c1/8] |= 1<<(c1&07);
2205: - }
2206: - if(negate)
2207: - for(c1=0; c1<16; c1++)
2208: - classp->map[c1]^=0377;
2209: - classp->map[0] &= 0376; /* exclude NUL */
2210: -}
2211: -
2212: -extern regexp *
2213: -regcomp(s)
2214: - char *s;
2215: -{
2216: - register token;
2217: - Prog *pp;
2218: -
2219: - /* get memory for the program */
2220: - pp = (Prog *)malloc(sizeof(Prog) + 3*sizeof(Inst)*strlen(s));
2221: - if (pp == NULL) {
2222: - rcerror("out of memory");
2223: - return NULL;
2224: - }
2225: - freep = pp->firstinst;
2226: - classp = pp->class;
2227: - errors = 0;
2228: -
2229: - /* go compile the sucker */
2230: - startlex(s);
2231: - atorp=atorstack;
2232: - andp=andstack;
2233: - subidp=subidstack;
2234: - lastwasand=FALSE;
2235: - cursubid=0;
2236: -
2237: - /* Start with a low priority operator to prime parser */
2238: - pushator(START-1);
2239: - while((token=lex()) != END){
2240: - if((token&0300) == OPERATOR)
2241: - operator(token);
2242: - else
2243: - operand(token);
2244: - }
2245: -
2246: - /* Close with a low priority operator */
2247: - evaluntil(START);
2248: -
2249: - /* Force END */
2250: - operand(END);
2251: - evaluntil(START);
2252: -#ifdef DEBUG
2253: - dumpstack();
2254: -#endif
2255: - if(nbra)
2256: - rcerror("unmatched left paren");
2257: - --andp; /* points to first and only operand */
2258: - pp->startinst=andp->first;
2259: -#ifdef DEBUG
2260: - dump(pp);
2261: -#endif
2262: - pp = optimize(pp);
2263: -#ifdef DEBUG
2264: - printf("start: %d\n", pp->startinst-pp->firstinst);
2265: - dump(pp);
2266: - fflush(stdout);
2267: -#endif
2268: - if (errors) {
2269: - free((char *)pp);
2270: - pp = NULL;
2271: - }
2272: - return (regexp *)pp;
2273: -}
2274: -
2275: -#ifdef DEBUG
2276: -#include <setjmp.h>
2277: -
2278: -jmp_buf jmpbuf;
2279: -
2280: -main( argc, argv )
2281: - char **argv;
2282: -{
2283: - regexp *prog = NULL;
2284: - regsubexp match[NSUBEXP];
2285: - char line[256];
2286: - int i;
2287: -
2288: - while( TRUE ) {
2289: - setjmp( jmpbuf );
2290: -
2291: - if(prog)
2292: - free( prog );
2293: -
2294: - do {
2295: - fputs( "Enter re: ", stdout );
2296: - if ( gets(line) == NULL )
2297: - exit(0);
2298: - } while( (prog = regcomp(line)) == NULL );
2299: -
2300: - fputs( "Enter string: ", stdout );
2301: - while( gets(line) != NULL ) {
2302: - if ( !regexec(prog,line,match,NSUBEXP) )
2303: - puts( "*** NO MATCH ***" );
2304: - else
2305: - for( i = 0; i < NSUBEXP; ++i )
2306: - if ( match[i].sp )
2307: - printf( "match[%d] = \"%.*s\"\n", i, match[i].ep - match[i].sp, match[i].sp );
2308: - }
2309: - }
2310: -}
2311: -
2312: -regerror( s )
2313: - char *s;
2314: -{
2315: - puts( s );
2316: - longjmp( jmpbuf );
2317: -}
2318: -
2319: -#endif
2320: //GO.SYSIN DD ./libc/new.mk
2321: echo ./fio/README 1>&2
2322: sed 's/.//' >./fio/README <<'//GO.SYSIN DD ./fio/README'
2323: -here (as in ../libc) you have to add whatever commands
2324: -you need to set up an archive in the shell file `gen'.
2325: //GO.SYSIN DD ./fio/README
2326: echo ./fio/fio.h 1>&2
2327: sed 's/.//' >./fio/fio.h <<'//GO.SYSIN DD ./fio/fio.h'
2328: -#define FIOBSIZE 4096
2329: -
2330: -typedef struct Fbuffer
2331: -{
2332: - unsigned char *next; /* next char to be used */
2333: - unsigned char *end; /* first invalid char */
2334: - unsigned char *lnext; /* previous value of next */
2335: - unsigned short flags; /* see FIO_.* below */
2336: - short oflush; /* if >= 0 fd to flush on read */
2337: - long offset; /* seek of end */
2338: - unsigned char buf[FIOBSIZE];
2339: -} Fbuffer;
2340: -extern Fbuffer *Ffb[];
2341: -
2342: -#define FIORESET(f) ((f)->next=(f)->lnext=(f)->end=(f)->buf, (f)->flags&= ~FIO_MALLOCED, (f)->oflush= -1)
2343: -#define FIOSET(f, fd) if((f=Ffb[fd&=0x7f]) == 0){Finit(fd,(char *)0);f=Ffb[fd];}
2344: -/* FIOLINELEN is length of last input */
2345: -#define FIOLINELEN(fd) (((int)(Ffb[fd]->next - Ffb[fd]->lnext))-1)
2346: -/* FIOSEEK is lseek of next char to be processed */
2347: -#define FIOSEEK(fd) (Ffb[fd]->offset - (Ffb[fd]->end - Ffb[fd]->next))
2348: -#define FIOFLUSH(fd) if((fd >= 0) && Ffb[fd]) Fflush(fd)
2349: -
2350: -#define FIO_RDLAST 0x0001 /* true if last input was rdline */
2351: -#define FIO_WRITING 0x0002 /* true if last action was write */
2352: -#define FIO_MALLOCED 0x0004 /* set if Finit did the malloc */
2353: -
2354: -extern void Finit();
2355: -extern char *Frdline();
2356: -extern void Fundo();
2357: -extern int Fgetc();
2358: -extern long Fread();
2359: -extern long Fwrite();
2360: -extern long Fseek();
2361: -extern int Fflush();
2362: -
2363: -#ifdef FIO_IMP
2364: -/* COUNT is the type of counts to things like read, write, memcpy etc */
2365: -#ifdef GNOT
2366: -#define COUNT long
2367: -#define FIOMALLOC(n) malloc(n)
2368: -#define SEEK(a,b,c) seek(a,b,c)
2369: -#else
2370: -#define COUNT int
2371: -#define FIOMALLOC(n) malloc(n)
2372: -#define SEEK(a,b,c) lseek(a,b,c)
2373: -#endif
2374: -extern COUNT read(), write();
2375: -#endif
2376: //GO.SYSIN DD ./fio/fio.h
2377: echo ./fio/fiofillbuf.c 1>&2
2378: sed 's/.//' >./fio/fiofillbuf.c <<'//GO.SYSIN DD ./fio/fiofillbuf.c'
2379: -#define FIO_IMP
2380: -#include "fio.h"
2381: -#include <libc.h>
2382: -
2383: -Ffillbuf(fd)
2384: -{
2385: - register COUNT n;
2386: - register Fbuffer *f = Ffb[fd];
2387: -
2388: - if(n = &f->buf[FIOBSIZE]-f->end){
2389: - FIOFLUSH(f->oflush);
2390: - n = read(fd, f->end, n);
2391: - if(n <= 0)
2392: - return(-1);
2393: - f->end += n;
2394: - f->offset += n;
2395: - }
2396: - return(1);
2397: -}
2398: //GO.SYSIN DD ./fio/fiofillbuf.c
2399: echo ./fio/fioflush.c 1>&2
2400: sed 's/.//' >./fio/fioflush.c <<'//GO.SYSIN DD ./fio/fioflush.c'
2401: -#define FIO_IMP
2402: -#include "fio.h"
2403: -#include <libc.h>
2404: -
2405: -Fflush(fd)
2406: -{
2407: - register Fbuffer *f;
2408: -
2409: - FIOSET(f, fd);
2410: - if(f->flags&FIO_WRITING)
2411: - return(F_flush(f, fd));
2412: - else
2413: - return(0);
2414: -}
2415: -
2416: -F_flush(f, fd)
2417: - register Fbuffer *f;
2418: -{
2419: - register COUNT n;
2420: -
2421: - f->flags &= ~FIO_WRITING;
2422: - if(n = f->next - f->buf){
2423: - if(write(fd, f->buf, n) != n)
2424: - return(-1);
2425: - f->next = f->buf;
2426: - }
2427: - return(0);
2428: -}
2429: //GO.SYSIN DD ./fio/fioflush.c
2430: echo ./fio/fiogetc.c 1>&2
2431: sed 's/.//' >./fio/fiogetc.c <<'//GO.SYSIN DD ./fio/fiogetc.c'
2432: -#define FIO_IMP
2433: -#include "fio.h"
2434: -#include <libc.h>
2435: -
2436: -Fgetc(fd)
2437: -{
2438: - register Fbuffer *f;
2439: -
2440: - FIOSET(f, fd);
2441: - if(f->next >= f->end){
2442: - if(f->end >= &f->buf[FIOBSIZE])
2443: - f->end = f->next = f->buf;
2444: - else
2445: - f->next = f->end;
2446: - if(Ffillbuf(fd) <= 0)
2447: - return(-1);
2448: - }
2449: - f->lnext = f->next;
2450: - f->flags &= ~(FIO_RDLAST|FIO_WRITING);
2451: - return(*f->next++);
2452: -}
2453: //GO.SYSIN DD ./fio/fiogetc.c
2454: echo ./fio/fioinit.c 1>&2
2455: sed 's/.//' >./fio/fioinit.c <<'//GO.SYSIN DD ./fio/fioinit.c'
2456: -#define FIO_IMP
2457: -#include "fio.h"
2458: -#include <libc.h>
2459: -
2460: -static Fdie()
2461: -{
2462: - Fexit(0);
2463: -}
2464: -
2465: -void
2466: -Finit(fd, buf)
2467: - char *buf;
2468: -{
2469: - register Fbuffer *f;
2470: - static setfioexit = 1;
2471: -
2472: - if(setfioexit){
2473: - setfioexit = 0;
2474: - atexit(Fdie);
2475: - }
2476: - fd &= 0x7f;
2477: - if(buf){
2478: - Ffb[fd] = (Fbuffer *)buf;
2479: - Ffb[fd]->flags = 0;
2480: - } else if(!Ffb[fd]){
2481: - Ffb[fd] = (Fbuffer *)FIOMALLOC((COUNT)sizeof(Fbuffer));
2482: - Ffb[fd]->flags = FIO_MALLOCED;
2483: - }
2484: - f = Ffb[fd];
2485: - FIORESET(f);
2486: - f->offset = SEEK(fd, 0L, 1);
2487: - if(f->offset < 0)
2488: - f->offset = 0; /* file not been written yet */
2489: -}
2490: -
2491: -#ifdef GNOT
2492: -#define NOFILE 128
2493: -#endif
2494: -#ifndef GNOT
2495: -#include <sys/param.h>
2496: -#endif
2497: -
2498: -Fbuffer *Ffb[NOFILE];
2499: -
2500: -Fexit(type)
2501: -{
2502: - register n;
2503: -
2504: - for(n = 0; n < NOFILE; n++)
2505: - if(Ffb[n])
2506: - if(type == 0)
2507: - Fflush(n);
2508: - else
2509: - Fclose(n);
2510: -}
2511: //GO.SYSIN DD ./fio/fioinit.c
2512: echo ./fio/fioprint.c 1>&2
2513: sed 's/.//' >./fio/fioprint.c <<'//GO.SYSIN DD ./fio/fioprint.c'
2514: -#define FIO_IMP
2515: -#include <varargs.h>
2516: -#include <fio.h>
2517: -
2518: -/* VARARGS 2 */
2519: -Fprint(f, fmt, va_alist)
2520: -int f;
2521: -char *fmt;
2522: -va_dcl
2523: -{
2524: - char buf[FIOBSIZE], *out;
2525: - register long n;
2526: - va_list ap;
2527: - extern char *doprint();
2528: -
2529: - va_start(ap);
2530: - out = doprint(buf, fmt, &ap);
2531: - va_end(ap);
2532: - n = out-buf;
2533: - if(Fwrite(f, buf, n) != n)
2534: - return(-1);
2535: - else
2536: - return((int)n);
2537: -}
2538: //GO.SYSIN DD ./fio/fioprint.c
2539: echo ./fio/fioputc.c 1>&2
2540: sed 's/.//' >./fio/fioputc.c <<'//GO.SYSIN DD ./fio/fioputc.c'
2541: -#define FIO_IMP
2542: -#include "fio.h"
2543: -#include <libc.h>
2544: -
2545: -Fputc(fd, c)
2546: -{
2547: - register Fbuffer *f;
2548: -
2549: - FIOSET(f, fd);
2550: - if(f->next >= &f->buf[FIOBSIZE]){
2551: - if(F_flush(f, fd))
2552: - return(-1);
2553: - }
2554: - *f->next++ = c;
2555: - f->end = f->next;
2556: - f->offset++;
2557: - f->flags |= FIO_WRITING;
2558: - return(0);
2559: -}
2560: //GO.SYSIN DD ./fio/fioputc.c
2561: echo ./fio/fiordline.c 1>&2
2562: sed 's/.//' >./fio/fiordline.c <<'//GO.SYSIN DD ./fio/fiordline.c'
2563: -#define FIO_IMP
2564: -#include "fio.h"
2565: -#include <libc.h>
2566: -
2567: -char *
2568: -Frdline(fd)
2569: -{
2570: - register unsigned char *p;
2571: - register Fbuffer *f;
2572: - register n;
2573: - register char *nextnl;
2574: -
2575: - FIOSET(f, fd);
2576: - while((nextnl = memchr(f->next, '\n', (COUNT)(f->end-f->next))) == 0){
2577: - if(f->next == f->buf){
2578: - if(f->end >= &f->buf[FIOBSIZE])
2579: - f->end = &f->buf[FIOBSIZE-64]; /* full buffer, no newline */
2580: - } else {
2581: - n = f->next-f->buf;
2582: - memcpy(f->buf, f->next, (COUNT)(FIOBSIZE-n));
2583: - f->next -= n;
2584: - f->end -= n;
2585: - }
2586: - if(Ffillbuf(fd) <= 0)
2587: - return((char *)0);
2588: - }
2589: - f->lnext = f->next;
2590: - f->next = (unsigned char *)(nextnl+1);
2591: - *nextnl = 0;
2592: - f->flags = (f->flags|FIO_RDLAST)&~FIO_WRITING;
2593: - return((char *)f->lnext);
2594: -}
2595: //GO.SYSIN DD ./fio/fiordline.c
2596: echo ./fio/fioread.c 1>&2
2597: sed 's/.//' >./fio/fioread.c <<'//GO.SYSIN DD ./fio/fioread.c'
2598: -#define FIO_IMP
2599: -#include "fio.h"
2600: -#include <libc.h>
2601: -
2602: -#define MAXREAD 0xff00 /* 64K - 4K */
2603: -#define FIOSHORT 100
2604: -
2605: -long
2606: -Fread(fd, addr, n)
2607: - char *addr;
2608: - long n;
2609: -{
2610: - register unsigned char *p;
2611: - register Fbuffer *f;
2612: - COUNT k;
2613: - char *oaddr = addr;
2614: - char *goal = addr+n;
2615: -
2616: - FIOSET(f, fd);
2617: -again:
2618: - k = f->end - f->next;
2619: - if(n < k) k = n;
2620: - memcpy(addr, (char *)f->next, k);
2621: - f->next += k;
2622: - f->lnext = f->next; /* effectively disable undo */
2623: - n -= k;
2624: - addr += k;
2625: - if((n > 0) && (n < FIOSHORT)){ /* buffer reads of less than FIOSHORT */
2626: - if(f->next == f->end)
2627: - f->next = f->end = f->buf;
2628: - if(Ffillbuf(fd) < 0)
2629: - return((long)(addr - oaddr));
2630: - goto again;
2631: - }
2632: - if(n > 0)
2633: - FIOFLUSH(f->oflush);
2634: - while(n > 0){ /* buffer is empty so do real reads */
2635: - k = n;
2636: - if(k > MAXREAD) k = MAXREAD;
2637: - if((k = read(fd, addr, k)) < 0)
2638: - return(-1L);
2639: - if(k == 0) break;
2640: - addr += k;
2641: - n -= k;
2642: - f->offset += k;
2643: - }
2644: - return((long)(addr - oaddr));
2645: -}
2646: //GO.SYSIN DD ./fio/fioread.c
2647: echo ./fio/fioseek.c 1>&2
2648: sed 's/.//' >./fio/fioseek.c <<'//GO.SYSIN DD ./fio/fioseek.c'
2649: -#define FIO_IMP
2650: -#include "fio.h"
2651: -#include <libc.h>
2652: -
2653: -long
2654: -Fseek(fd, n, cmd)
2655: - long n;
2656: -{
2657: - register Fbuffer *f;
2658: - register long dest, k;
2659: -
2660: - FIOSET(f, fd);
2661: - switch(cmd)
2662: - {
2663: - case 0:
2664: - dest = n;
2665: - break;
2666: - case 1:
2667: - /* allow for the fact we are beyond where we think we are */
2668: - dest = f->offset + n + f->next-f->end;
2669: - break;
2670: - case 2:
2671: - if(f->flags&FIO_WRITING)
2672: - F_flush(f, fd);
2673: - dest = SEEK(fd, n, cmd);
2674: - FIORESET(f);
2675: - f->offset = dest;
2676: - break;
2677: - }
2678: - if(dest < 0)
2679: - return(dest);
2680: - k = f->end - ((f->flags&FIO_WRITING)? f->buf : f->lnext);
2681: - if((dest >= f->offset) || (dest < f->offset-k)){
2682: - if(f->flags&FIO_WRITING)
2683: - F_flush(f, fd);
2684: - FIORESET(f);
2685: - f->offset = dest;
2686: - SEEK(fd, f->offset, 0);
2687: - } else {
2688: - f->next = f->lnext + (dest-(f->offset-k));
2689: - if(f->flags&FIO_WRITING){
2690: - f->offset -= f->end - f->next;
2691: - f->end = f->next;
2692: - }
2693: - SEEK(fd, f->offset, 0);
2694: - }
2695: - return(dest);
2696: -}
2697: //GO.SYSIN DD ./fio/fioseek.c
2698: echo ./fio/fioundo.c 1>&2
2699: sed 's/.//' >./fio/fioundo.c <<'//GO.SYSIN DD ./fio/fioundo.c'
2700: -#define FIO_IMP
2701: -#include "fio.h"
2702: -#include <libc.h>
2703: -
2704: -void
2705: -Fundo(fd)
2706: -{
2707: - register Fbuffer *f;
2708: -
2709: - FIOSET(f, fd);
2710: - if(f->flags&FIO_WRITING)
2711: - return;
2712: - if(f->flags&FIO_RDLAST)
2713: - f->next[-1] = '\n';
2714: - f->next = f->lnext;
2715: -}
2716: //GO.SYSIN DD ./fio/fioundo.c
2717: echo ./fio/fiowrite.c 1>&2
2718: sed 's/.//' >./fio/fiowrite.c <<'//GO.SYSIN DD ./fio/fiowrite.c'
2719: -#define FIO_IMP
2720: -#include "fio.h"
2721: -#include <libc.h>
2722: -
2723: -long
2724: -Fwrite(fd, addr, nbytes)
2725: - register char *addr;
2726: - register long nbytes;
2727: -{
2728: - register Fbuffer *f;
2729: - register COUNT n;
2730: - long nnbytes = nbytes;
2731: -
2732: - FIOSET(f, fd);
2733: - f->flags |= FIO_WRITING;
2734: - n = &f->buf[FIOBSIZE] - f->next;
2735: - if(nbytes < n) n = nbytes;
2736: - memcpy(f->next, addr, n);
2737: - f->end = (f->next += n);
2738: - f->offset += n;
2739: - nbytes -= n;
2740: - addr += n;
2741: - if(nbytes){
2742: - if(F_flush(f, fd))
2743: - return(-1L);
2744: - while(nbytes >= FIOBSIZE){
2745: - if(write(fd, addr, (COUNT)FIOBSIZE) != FIOBSIZE)
2746: - return(-1L);
2747: - addr += FIOBSIZE;
2748: - nbytes -= FIOBSIZE;
2749: - f->offset += FIOBSIZE;
2750: - }
2751: - memcpy(f->buf, addr, (COUNT)(n = nbytes));
2752: - f->end = f->next = f->buf+n;
2753: - f->offset += n;
2754: - f->flags |= FIO_WRITING;
2755: - }
2756: - return(nnbytes);
2757: -}
2758: //GO.SYSIN DD ./fio/fiowrite.c
2759: echo ./fio/libc.h 1>&2
2760: sed 's/.//' >./fio/libc.h <<'//GO.SYSIN DD ./fio/libc.h'
2761: -/* system calls */
2762: -extern unsigned alarm();
2763: -extern void nap(), pause();
2764: -extern char *sbrk();
2765: -extern void exit(), _exit();
2766: -extern long lseek();
2767: -extern void nice();
2768: -extern void profil();
2769: -extern unsigned long settod();
2770: -extern void sync();
2771: -extern long time();
2772: -
2773: -/* libc et al */
2774: -extern long lcm();
2775: -extern double atof(), strtod();
2776: -extern long atol();
2777: -extern char *crypt();
2778: -extern char *ctime();
2779: -extern char *ecvt(), *fcvt(), *gcvt();
2780: -extern char *galloc();
2781: -extern char *getenv();
2782: -extern char *getlogin();
2783: -extern char *getpass();
2784: -extern char *getwd(), *getcwd();
2785: -extern char *malloc(), *realloc(), *calloc();
2786: -extern char *memcpy(), *memchr(), *memccpy(), *memset();
2787: -extern char *mktemp();
2788: -extern double frand();
2789: -extern char *strcpy(), *strncpy(), *strcat(), *strncat(), *strchr(), *strrchr();
2790: -extern char *strpbrk(), *strtok(), *strdup();
2791: -extern int atoi();
2792: -extern char *tgetstr(), tgoto();
2793: -extern char *ttyname(), *cttyname();
2794: -
2795: -#define NONEXIT 33
2796: //GO.SYSIN DD ./fio/libc.h
2797: echo ./fio/tstrd.c 1>&2
2798: sed 's/.//' >./fio/tstrd.c <<'//GO.SYSIN DD ./fio/tstrd.c'
2799: -#include <fio.h>
2800: -#include <libc.h>
2801: -
2802: -main(argc, argv)
2803: - char **argv;
2804: -{
2805: - register n, c, k;
2806: - int len, fd, cd;
2807: - char *b1, *b2, *p;
2808: -
2809: - if(argc < 2){
2810: - Fprint(2, "Usage: tstrd file\n");
2811: - exit(1);
2812: - }
2813: - len = flen(argv[1]);
2814: - if((fd = open(argv[1], 0)) < 0){
2815: - perror(argv[1]);
2816: - exit(1);
2817: - }
2818: - if((b1 = malloc(len)) == 0){
2819: - Fprint(2, "malloc(%d) failed\n", len);
2820: - exit(1);
2821: - }
2822: - if(read(fd, b1, len) != len){
2823: - perror("read");
2824: - exit(1);
2825: - }
2826: - lseek(fd, 0L, 0);
2827: - if((b2 = malloc(len)) == 0){
2828: - Fprint(2, "malloc(%d) failed\n", len);
2829: - exit(1);
2830: - }
2831: - for(p = b2, cd = 0; cd < len;){
2832: - n = 1000*nrand(6) + nrand(199);
2833: - if(n > len-cd) n = len-cd;
2834: - Fprint(1, "%d getchars\n", n);
2835: - cd += n;
2836: - while(n--)
2837: - *p++ = Fgetc(fd);
2838: - if(cd == len)
2839: - continue;
2840: - n = 1000*nrand(12) + nrand(199);
2841: - if(n > len-cd) n = len-cd;
2842: - cd += n;
2843: - Fprint(1, "%d read\n", n);
2844: - if(Fread(fd, p, (long)n) != (long)n) break;
2845: - p += n;
2846: - }
2847: -done:
2848: - if(memcmp(b1, b2, len)){
2849: - Fprint(2, "memcmp failed!\n");
2850: - exit(1);
2851: - }
2852: - Fprint(2, "tstrd: %d bytes, succeeded\n", len);
2853: - exit(0);
2854: -}
2855: -
2856: -#include <sys/types.h>
2857: -#include <sys/stat.h>
2858: -
2859: -flen(s)
2860: - char *s;
2861: -{
2862: - struct stat sb;
2863: - int n;
2864: -
2865: - if(stat(s, &sb) < 0){
2866: - perror(s);
2867: - exit(1);
2868: - }
2869: - n = sb.st_size;
2870: - if(sizeof(int) == 2)
2871: - n &= 0x7FFF;
2872: - return(n);
2873: -}
2874: //GO.SYSIN DD ./fio/tstrd.c
2875: echo ./fio/tstsk.c 1>&2
2876: sed 's/.//' >./fio/tstsk.c <<'//GO.SYSIN DD ./fio/tstsk.c'
2877: -#include <fio.h>
2878: -#include <libc.h>
2879: -
2880: -#define TMP "/tmp/tstsk"
2881: -#define FN(x) (unsigned char)((x&0xFF)^(x/251))
2882: -
2883: -main(argc, argv)
2884: - char **argv;
2885: -{
2886: - register n, c, k;
2887: - int len, fd, cd;
2888: - char *b1, *b2, *p;
2889: -
2890: - if(argc != 1){
2891: - Fprint(2, "Usage: tstsk\n");
2892: - exit(1);
2893: - }
2894: - len = 1000000;
2895: - if(sizeof(int) == 2)
2896: - len &= 0x7FFF;
2897: - if((fd = creat(TMP, 0666)) < 0){
2898: - perror(TMP);
2899: - exit(1);
2900: - }
2901: - close(fd);
2902: - if((fd = open(TMP, 2)) < 0){
2903: - perror(TMP);
2904: - exit(1);
2905: - }
2906: - unlink(TMP);
2907: - if((b2 = malloc(len)) == 0){
2908: - Fprint(2, "malloc(%d) failed\n", len);
2909: - exit(1);
2910: - }
2911: - for(n = 0, p = b2; n < len; n++)
2912: - *p++ = FN(n);
2913: - if(write(fd, b2, len) != len){
2914: - perror("write");
2915: - exit(1);
2916: - }
2917: - lseek(fd, 0L, 0);
2918: - Finit(fd, (char *)0);
2919: - for(n = 0; n < 500; n++){
2920: - k = nrand(len);
2921: - c = nrand(sizeof(Fbuffer))+100;
2922: - if(k+c > len) c = len-k;
2923: - test(fd, k, c, n);
2924: - }
2925: -done:
2926: - Fprint(2, "tstsk: %d bytes, %d seeks, succeeded\n", len, n);
2927: - exit(0);
2928: -}
2929: -
2930: -test(fd, off, n, count)
2931: -{
2932: - long offset;
2933: - int c;
2934: -
2935: - offset = off;
2936: - if(Fseek(fd, offset, 0) != offset){
2937: - fprint(2, "fseek(%ld) != %ld!!\n", offset, offset);
2938: - exit(1);
2939: - }
2940: - while(n-- > 0){
2941: - if((c = Fgetc(fd)) != FN(offset)){
2942: - fprint(2, "tst %d: char mismatch; %ld: %x, expected %x\n",
2943: - count, offset, c, FN(offset));
2944: - dumpfb(fd);
2945: - exit(1);
2946: - }
2947: - offset++;
2948: - }
2949: -}
2950: -
2951: -dumpfb(fd)
2952: -{
2953: - register Fbuffer *f = Ffb[fd];
2954: - register unsigned char *c;
2955: - register long off;
2956: - int i;
2957: -
2958: - fprint(2, "buf@%ld: next=%ld end=%ld lnext=%ld buf=%ld offset=%ld\n",
2959: - f, f->next, f->end, f->lnext, f->buf, f->offset);
2960: - off = f->offset - (f->end - f->buf);
2961: - for(c = f->buf; c < &f->buf[64]; ){
2962: - fprint(2, "%7ld:", off);
2963: - for(i = 0; i < 16; i++, off++)
2964: - fprint(2, " %2x", *c++);
2965: - fprint(2, "\n");
2966: - }
2967: -}
2968: //GO.SYSIN DD ./fio/tstsk.c
2969: echo ./fio/tstwr.c 1>&2
2970: sed 's/.//' >./fio/tstwr.c <<'//GO.SYSIN DD ./fio/tstwr.c'
2971: -#include <fio.h>
2972: -#include <libc.h>
2973: -
2974: -#define TMP "/tmp/tstwr"
2975: -
2976: -main(argc, argv)
2977: - char **argv;
2978: -{
2979: - register n, c, k;
2980: - int len, fd, cd;
2981: - char *b1, *b2, *p;
2982: -
2983: - if(argc < 2){
2984: - Fprint(2, "Usage: tstwr file\n");
2985: - exit(1);
2986: - }
2987: - len = flen(argv[1]);
2988: - if((fd = open(argv[1], 0)) < 0){
2989: - perror(argv[1]);
2990: - exit(1);
2991: - }
2992: - if((b1 = malloc(len)) == 0){
2993: - Fprint(2, "malloc(%d) failed\n", len);
2994: - exit(1);
2995: - }
2996: - if(read(fd, b1, len) != len){
2997: - perror("read");
2998: - exit(1);
2999: - }
3000: - close(fd);
3001: - if((fd = creat(TMP, 0666)) < 0){
3002: - perror(TMP);
3003: - exit(1);
3004: - }
3005: - close(fd);
3006: - if((fd = open(TMP, 2)) < 0){
3007: - perror(TMP);
3008: - exit(1);
3009: - }
3010: -/* unlink(TMP); /**/
3011: - if((b2 = malloc(len)) == 0){
3012: - Fprint(2, "malloc(%d) failed\n", len);
3013: - exit(1);
3014: - }
3015: - for(p = b1, cd = 0; cd < len;){
3016: - n = 1000*nrand(6) + nrand(199);
3017: - if(n > len-cd) n = len-cd;
3018: - Fprint(1, "%d putc's\n", n);
3019: - cd += n;
3020: - while(n--)
3021: - Fputc(fd, *p++);
3022: - if(len == cd)
3023: - continue;
3024: - n = 1000*nrand(12) + nrand(199);
3025: - if(n > len-cd) n = len-cd;
3026: - cd += n;
3027: - Fprint(1, "%d write\n", n);
3028: - if(Fwrite(fd, p, (long)n) != (long)n) break;
3029: - p += n;
3030: - }
3031: -done:
3032: - Fflush(fd);
3033: - lseek(fd, 0L, 0);
3034: - if((n = read(fd, b2, len)) != len){
3035: - fprint(2, "read %d, len=%d: ", n, len);
3036: - perror("read2");
3037: - exit(1);
3038: - }
3039: - if(memcmp(b1, b2, len)){
3040: - Fprint(2, "memcmp failed!\n");
3041: - exit(1);
3042: - }
3043: - Fprint(2, "tstwr: %d bytes, succeeded\n", len);
3044: - exit(0);
3045: -}
3046: -
3047: -#include <sys/types.h>
3048: -#include <sys/stat.h>
3049: -
3050: -flen(s)
3051: - char *s;
3052: -{
3053: - struct stat sb;
3054: - int n;
3055: -
3056: - if(stat(s, &sb) < 0){
3057: - perror(s);
3058: - exit(1);
3059: - }
3060: - n = sb.st_size;
3061: - if(sizeof(int) == 2)
3062: - n &= 0x7FFF;
3063: - return(n);
3064: -}
3065: //GO.SYSIN DD ./fio/tstwr.c
3066: echo ./fio/Makefile 1>&2
3067: sed 's/.//' >./fio/Makefile <<'//GO.SYSIN DD ./fio/Makefile'
3068: -OBJ=fiofillbuf.o fioflush.o fiogetc.o fioinit.o fioprint.o fioputc.o\
3069: - fiordline.o fioread.o fioseek.o fioundo.o fiowrite.o fiotie.o fioclose.o
3070: -
3071: -fio.a: $(OBJ)
3072: - ar r fio.a $(OBJ)
3073: - $(RANLIB) fio.a
3074: -
3075: -cray: fio.o
3076: -
3077: -fio.o: $(OBJ)
3078: - cat $(OBJ) > fio.o
3079: //GO.SYSIN DD ./fio/Makefile
3080: echo ./fio/fiotie.c 1>&2
3081: sed 's/.//' >./fio/fiotie.c <<'//GO.SYSIN DD ./fio/fiotie.c'
3082: -#define FIO_IMP
3083: -#include "fio.h"
3084: -
3085: -void
3086: -Ftie(ifd, ofd)
3087: -{
3088: - register Fbuffer *f;
3089: -
3090: - FIOSET(f, ifd);
3091: - f->oflush = ofd;
3092: -}
3093: //GO.SYSIN DD ./fio/fiotie.c
3094: echo ./fio/tstagh.c 1>&2
3095: sed 's/.//' >./fio/tstagh.c <<'//GO.SYSIN DD ./fio/tstagh.c'
3096: -#include <fio.h>
3097: -#include <libc.h>
3098: -
3099: -#define TMP "/tmp/tstsk"
3100: -#define FN(x) (unsigned char)((x&0xFF)^(x/251))
3101: -
3102: -main(argc, argv)
3103: - char **argv;
3104: -{
3105: - register n, c, k;
3106: - int len, fd, cd;
3107: - char *b1, *b2, *p;
3108: -
3109: - Fprint(1, "the letter 'c' is 'c'\n");
3110: - dumpfb(1);
3111: - Fseek(1, -3, 1);
3112: - dumpfb(1);
3113: - Fputc(1, '\n');
3114: - dumpfb(1);
3115: - exit(0);
3116: -}
3117: -
3118: -dumpfb(fd)
3119: -{
3120: - register Fbuffer *f = Ffb[fd];
3121: - register unsigned char *c;
3122: - register long off;
3123: - int i;
3124: -
3125: - fprint(2, "buf@%ld: next=%ld end=%ld lnext=%ld buf=%ld offset=%ld\n",
3126: - f, f->next, f->end, f->lnext, f->buf, f->offset);
3127: - off = f->offset - (f->end - f->buf);
3128: - for(c = f->buf; c < &f->buf[64]; ){
3129: - fprint(2, "%7ld:", off);
3130: - for(i = 0; i < 16; i++, off++)
3131: - fprint(2, " %2x", *c++);
3132: - fprint(2, "\n");
3133: - }
3134: -}
3135: //GO.SYSIN DD ./fio/tstagh.c
3136: echo ./fio/fioclose.c 1>&2
3137: sed 's/.//' >./fio/fioclose.c <<'//GO.SYSIN DD ./fio/fioclose.c'
3138: -#define FIO_IMP
3139: -#include "fio.h"
3140: -#include <libc.h>
3141: -
3142: -void
3143: -Fclose(fd)
3144: -{
3145: - register Fbuffer *f;
3146: -
3147: - FIOSET(f, fd);
3148: - Fflush(fd);
3149: - if(f->flags&FIO_MALLOCED)
3150: - free((char *)f);
3151: - Ffb[fd] = 0;
3152: - close(fd);
3153: -}
3154: //GO.SYSIN DD ./fio/fioclose.c
3155: echo ./README 1>&2
3156: sed 's/.//' >./README <<'//GO.SYSIN DD ./README'
3157: -mk runs on Unix V9. To run on other systems requires some help.
3158: -the help takes the form of the fast i/o library (fio) and some
3159: -libc routines. dir.o provides support for the directory routines
3160: -on V7-style filesystems; on most modern systems you should probably
3161: -not use dir.o.
3162: -
3163: - - edit Makefile by setting the initial variables as
3164: -per the instructions.
3165: -
3166: - - type make (unless on the cray, in which case, type make cray).
3167: -
3168: - - everything should now be compiled and you should have a mk.
3169: -
3170: - - edit mkfile to set the system type as in the Makefile
3171: -
3172: -as a first order test that all is well, try
3173: - mk
3174: -which generates a `correctly compiled' mk in the file nmk.
3175: -
3176: -If things go badly, (core dump hell), try not using alloc.c. it may be
3177: -that your hardware needs special alloc treatment. otherwise, mail
3178: -research!andrew (or [email protected]).
3179: -
3180: -the manual page and a tutorial style document are included.
3181: //GO.SYSIN DD ./README
3182: echo ./fio.h 1>&2
3183: sed 's/.//' >./fio.h <<'//GO.SYSIN DD ./fio.h'
3184: -#define FIOBSIZE 4096
3185: -
3186: -typedef struct Fbuffer
3187: -{
3188: - unsigned char *next; /* next char to be used */
3189: - unsigned char *end; /* first invalid char */
3190: - unsigned char *lnext; /* previous value of next */
3191: - unsigned short flags; /* see FIO_.* below */
3192: - short oflush; /* if >= 0 fd to flush on read */
3193: - long offset; /* seek of end */
3194: - unsigned char buf[FIOBSIZE];
3195: -} Fbuffer;
3196: -extern Fbuffer *Ffb[];
3197: -
3198: -#define FIORESET(f) ((f)->next=(f)->lnext=(f)->end=(f)->buf, (f)->flags&= ~FIO_MALLOCED, (f)->oflush= -1)
3199: -#define FIOSET(f, fd) if((f=Ffb[fd&=0x7f]) == 0){Finit(fd,(char *)0);f=Ffb[fd];}
3200: -/* FIOLINELEN is length of last input */
3201: -#define FIOLINELEN(fd) (((int)(Ffb[fd]->next - Ffb[fd]->lnext))-1)
3202: -/* FIOSEEK is lseek of next char to be processed */
3203: -#define FIOSEEK(fd) (Ffb[fd]->offset - (Ffb[fd]->end - Ffb[fd]->next))
3204: -#define FIOFLUSH(fd) if((fd >= 0) && Ffb[fd]) Fflush(fd)
3205: -
3206: -#define FIO_RDLAST 0x0001 /* true if last input was rdline */
3207: -#define FIO_WRITING 0x0002 /* true if last action was write */
3208: -#define FIO_MALLOCED 0x0004 /* set if Finit did the malloc */
3209: -
3210: -extern void Finit();
3211: -extern char *Frdline();
3212: -extern void Fundo();
3213: -extern int Fgetc();
3214: -extern long Fread();
3215: -extern long Fwrite();
3216: -extern long Fseek();
3217: -extern int Fflush();
3218: -
3219: -#ifdef FIO_IMP
3220: -/* COUNT is the type of counts to things like read, write, memcpy etc */
3221: -#ifdef GNOT
3222: -#define COUNT long
3223: -#define FIOMALLOC(n) malloc(n)
3224: -#define SEEK(a,b,c) seek(a,b,c)
3225: -#else
3226: -#define COUNT int
3227: -#define FIOMALLOC(n) malloc(n)
3228: -#define SEEK(a,b,c) lseek(a,b,c)
3229: -#endif
3230: -extern COUNT read(), write();
3231: -#endif
3232: //GO.SYSIN DD ./fio.h
3233: echo ./regexp.h 1>&2
3234: sed 's/.//' >./regexp.h <<'//GO.SYSIN DD ./regexp.h'
3235: -/* the structure describing a sub-expression match */
3236: -typedef struct {
3237: - char *sp;
3238: - char *ep;
3239: -} regsubexp;
3240: -
3241: -/* a compiled regular expression */
3242: -typedef char *regexp;
3243: -
3244: -/* the routines */
3245: -extern regexp *regcomp();
3246: -extern int regexec();
3247: -extern void regsub();
3248: //GO.SYSIN DD ./regexp.h
3249: echo ./libc.h 1>&2
3250: sed 's/.//' >./libc.h <<'//GO.SYSIN DD ./libc.h'
3251: -/* system calls */
3252: -extern unsigned alarm();
3253: -extern void nap(), pause();
3254: -extern char *sbrk();
3255: -extern void exit(), _exit();
3256: -extern long lseek();
3257: -extern void nice();
3258: -extern void profil();
3259: -extern unsigned long settod();
3260: -extern void sync();
3261: -extern long time();
3262: -
3263: -/* libc et al */
3264: -extern long lcm();
3265: -extern double atof(), strtod();
3266: -extern long atol();
3267: -extern char *crypt();
3268: -extern char *ctime();
3269: -extern char *ecvt(), *fcvt(), *gcvt();
3270: -extern char *galloc();
3271: -extern char *getenv();
3272: -extern char *getlogin();
3273: -extern char *getpass();
3274: -extern char *getwd(), *getcwd();
3275: -extern char *malloc(), *realloc(), *calloc();
3276: -extern char *memcpy(), *memchr(), *memccpy(), *memset();
3277: -extern char *mktemp();
3278: -extern double frand();
3279: -extern char *setfields();
3280: -extern char *strcpy(), *strncpy(), *strcat(), *strncat(), *strchr(), *strrchr();
3281: -extern char *strpbrk(), *strtok(), *strdup();
3282: -extern int atoi();
3283: -extern char *tgetstr(), tgoto();
3284: -extern char *ttyname(), *cttyname();
3285: -
3286: -#define NONEXIT 33
3287: //GO.SYSIN DD ./libc.h
3288: echo ./math/pow10.c 1>&2
3289: sed 's/.//' >./math/pow10.c <<'//GO.SYSIN DD ./math/pow10.c'
3290: -static double p[10] =
3291: -{
3292: - 1.0e0,
3293: - 1.0e1,
3294: - 1.0e2,
3295: - 1.0e3,
3296: - 1.0e4,
3297: - 1.0e5,
3298: - 1.0e6,
3299: - 1.0e7,
3300: - 1.0e8,
3301: - 1.0e9,
3302: -};
3303: -
3304: -double
3305: -pow10(e)
3306: -{
3307: - int i;
3308: -
3309: - if(e < 0)
3310: - return 1 / pow10(-e);
3311: - if(e >= 10) {
3312: - i = e/2;
3313: - return pow10(i) * pow10(e-i);
3314: - }
3315: - return p[e];
3316: -}
3317: //GO.SYSIN DD ./math/pow10.c
3318: echo ./math/Makefile 1>&2
3319: sed 's/.//' >./math/Makefile <<'//GO.SYSIN DD ./math/Makefile'
3320: -OBJ=pow10.o
3321: -
3322: -math.a: $(OBJ)
3323: - ar r math.a $(OBJ)
3324: - $(RANLIB) math.a
3325: -
3326: -cray: math.o
3327: -
3328: -math.o: $(OBJ)
3329: - cat $(OBJ) > math.o
3330: //GO.SYSIN DD ./math/Makefile
3331: echo ./Makefile 1>&2
3332: sed 's/.//' >./Makefile <<'//GO.SYSIN DD ./Makefile'
3333: -OBJ=alloc.o arc.o bquote.o builtins.o dir.o expand.o gen.o glob.o graph.o job.o lex.o main.o makefile.o match.o mk.o parse.o quote.o recipe.o regexp.o rule.o run.o shprint.o sig.o symtab.o t_ar.o t_driver.o t_file.o var.o word.o
3334: -# first define the system type from V9, BSD42, SEQUENT, SYSV
3335: -SYSTEM=SYSV
3336: -# second add any special C flags (and -DCRAY and -g if on the cray)
3337: -CFLAGS=-I. -D$(SYSTEM)
3338: -# third, if you don't have a ranlib, set RANLIB=:
3339: -RANLIB=: # ranlib on other systems
3340: -# now, to make everything just type make
3341: -
3342: -mk: nlib $(OBJ)
3343: - $(CC) $(CFLAGS) -o mk $(OBJ) fio/fio.a libc/libc.a math/math.a
3344: -nlib:
3345: - cd math; make CFLAGS="$(CFLAGS)" CC=$(CC) RANLIB=$(RANLIB)
3346: - cd libc; make CFLAGS="$(CFLAGS)" CC=$(CC) RANLIB=$(RANLIB)
3347: - cd fio; make CFLAGS="$(CFLAGS)" CC=$(CC) RANLIB=$(RANLIB)
3348: -
3349: -clean:
3350: - rm -f *.o mk nmk */*.[oa]
3351: -alloc.o arc.o bquote.o builtins.o dir.o expand.o gen.o glob.o graph.o job.o lex.o main.o makefile.o match.o mk.o parse.o quote.o recipe.o regexp.o rule.o run.o shprint.o sig.o symtab.o t_ar.o t_driver.o t_file.o var.o word.o: fio.h libc.h mk.h ndir.h regexp.h
3352: //GO.SYSIN DD ./Makefile
3353: echo ./mkconv 1>&2
3354: sed 's/.//' >./mkconv <<'//GO.SYSIN DD ./mkconv'
3355: -x=/tmp/mk$$
3356: -trap 'rm -f $x' 0 1 2
3357: -tee $x < $1 | sed -e 's/$(\([^)]*\))\([ :\/]\)/$\1\2/g
3358: - s/$(\([^)]*\))$/$\1/g
3359: - s/$(\([^)]*\))/${\1}/g
3360: - s/^ @/ /
3361: - /^ -/,/[^\\]$/{
3362: - /[^\\]$/s/$/; set -e/
3363: - }
3364: - /^ -/s/ -/ set +e; /
3365: - s/:&/:/
3366: - s/$% /$stem /g
3367: - s/$%\./$stem\./g
3368: - s/$%/${stem}/g
3369: - s/$@/${target}/g
3370: - s/$^/${prereq}/g
3371: - s/$?/$newprereq/g'
3372: -if egrep -s 'cd[ ]|make' < $x
3373: -then
3374: - echo "Warning: recipes containing \`cd' or \`make' need attention."
3375: - egrep 'cd[ ]|make' < $x
3376: -fi 1>&2
3377: //GO.SYSIN DD ./mkconv
3378: echo ./membername 1>&2
3379: sed 's/.//' >./membername <<'//GO.SYSIN DD ./membername'
3380: -echo "$@" | tr " " "\012" | sed -e "s/[^(]*(\([^)]*\)).*/\1/" | tr "\012" " "
3381: //GO.SYSIN DD ./membername
3382: echo ./mk.1 1>&2
3383: sed 's/.//' >./mk.1 <<'//GO.SYSIN DD ./mk.1'
3384: -.TH MK 1
3385: -.CT 1 prog_c writing_troff prog_other
3386: -.SH NAME
3387: -mk, mkconv, membername \- maintain (make) related files
3388: -.SH SYNOPSIS
3389: -.B mk
3390: -[
3391: -.B -f
3392: -.I mkfile
3393: -] ...
3394: -[
3395: -.I option ...
3396: -]
3397: -[
3398: -.I name ...
3399: -]
3400: -.PP
3401: -.B mkconv
3402: -.I makefile
3403: -.PP
3404: -.B membername
3405: -.I aggregate ...
3406: -.SH DESCRIPTION
3407: -.I Mk
3408: -is most often used to keep object files current with the
3409: -source they depend on.
3410: -.PP
3411: -.I Mk
3412: -reads
3413: -.I mkfile
3414: -and builds and executes dependency dags (directed acyclic graphs) for the target
3415: -.IR names .
3416: -If no target is specified, the targets of the first non-metarule in
3417: -the first
3418: -.I mkfile
3419: -are used.
3420: -If no
3421: -.B -f
3422: -option is present,
3423: -.L mkfile
3424: -is tried.
3425: -Other options are:
3426: -.TP \w'\fL-d[egp]\ 'u
3427: -.B -a
3428: -Assume all targets to be out of date.
3429: -Thus, everything gets made.
3430: -.PD 0
3431: -.TP
3432: -.BR -d [ egp ]
3433: -Produce debugging output
3434: -.RB ( p
3435: -is for parsing,
3436: -.B g
3437: -for graph building,
3438: -.B e
3439: -for execution).
3440: -.TP
3441: -.B -e
3442: -Explain why each target is made.
3443: -.TP
3444: -.B -i
3445: -Force any missing intermediate targets to be made.
3446: -.TP
3447: -.B -k
3448: -Do as much work as possible in the face of errors.
3449: -.TP
3450: -.B -m
3451: -Generate an equivalent makefile on standard output.
3452: -Recipes are not handled well.
3453: -.TP
3454: -.B -n
3455: -Print, but do not execute, the commands
3456: -needed to update the targets.
3457: -.TP
3458: -.B -t
3459: -Touch (update the modified date of) non-virtual targets, without
3460: -executing any recipes.
3461: -.TP
3462: -.B -u
3463: -Produce a table of clock seconds spent with
3464: -.I n
3465: -recipes running.
3466: -.TP
3467: -.BI -w name1,name2,...
3468: -Set the initial date stamp for each name
3469: -to the current time.
3470: -The names may also be separated by blanks or newlines.
3471: -(Use with
3472: -.B -n
3473: -to find what else would need to change if the named files
3474: -were modified.)
3475: -.PD
3476: -.PP
3477: -.I Mkconv
3478: -attempts to convert a
3479: -.IR make (1)
3480: -.I makefile
3481: -to a
3482: -.IR mkfile
3483: -on standard output.
3484: -The conversion is not likely to be faithful.
3485: -.PP
3486: -The shell script
3487: -.I membername
3488: -extracts member names
3489: -(see `Aggregates' below)
3490: -from its arguments.
3491: -.SS Definitions
3492: -A
3493: -.I mkfile
3494: -consists of
3495: -.I assignments
3496: -(described under `Environment') and
3497: -.IR rules .
3498: -A rule contains
3499: -.I targets
3500: -and a
3501: -.I tail.
3502: -A target is a literal string, or
3503: -.I label,
3504: -and is normally a file name.
3505: -The tail contains zero or more
3506: -.I prerequisites
3507: -and an optional
3508: -.I recipe,
3509: -which is a shell script.
3510: -.PP
3511: -A
3512: -.I metarule
3513: -has a target of the form
3514: -.IB A % B
3515: -where
3516: -.I A
3517: -and
3518: -.I B
3519: -are (possibly empty) strings.
3520: -A metarule applies to any label that matches the target with
3521: -.B %
3522: -replaced by an arbitrary string, called the
3523: -.IR stem .
3524: -In interpreting a metarule,
3525: -the stem is substituted for all occurrences of
3526: -.B %
3527: -in the prerequisite names.
3528: -A metarule may be marked as using regular expressions (described under `Syntax').
3529: -In this case,
3530: -.B %
3531: -has no special meaning;
3532: -the target is interpreted according to
3533: -.IR regexp (3).
3534: -The dependencies may refer to subexpressions in the normal way, using
3535: -.BI \e n.
3536: -The
3537: -.I dependency dag
3538: -for a target consists of
3539: -.I nodes
3540: -connected by directed
3541: -.IR arcs .
3542: -A node consists of a label
3543: -and a set of arcs leading to prerequisite nodes.
3544: -The root
3545: -node is labeled with an original target
3546: -.I name.
3547: -.SS Building the Dependency Dag
3548: -.PP
3549: -Read the
3550: -.I mkfiles
3551: -in command line order and distribute rule tails over targets
3552: -to get single-target rules.
3553: -.PP
3554: -For a node
3555: -.IR n ,
3556: -for every rule
3557: -.I r
3558: -that matches
3559: -.IR n 's
3560: -label generate an arc to a prerequisite node.
3561: -The node
3562: -.I n
3563: -is then marked as done.
3564: -The process is then repeated for each of the prerequisite nodes.
3565: -The process stops if
3566: -.I n
3567: -is already done,
3568: -or if
3569: -.I n
3570: -has no prerequisites,
3571: -or if any rule would be used more than
3572: -.B $NREP
3573: -times on the current path in the dag.
3574: -A probable node is one where the label exists as a file
3575: -or is a target of a non-metarule.
3576: -.PP
3577: -After the graph is built, it is checked for cycles,
3578: -and subdags containing no probable nodes are deleted.
3579: -Also, for any node with arcs generated by a non-metarule with a recipe,
3580: -arcs generated by a metarule with a recipe
3581: -are deleted.
3582: -Disconnected subdags are deleted.
3583: -.SS Execution
3584: -Labels have an associated date stamp.
3585: -A label is
3586: -.I ready
3587: -if it has no prerequisites, or
3588: -all its prerequisites are made.
3589: -A ready label is
3590: -.I trivially uptodate
3591: -if it is not a target and has a nonzero date stamp, or
3592: -it has a nonzero date stamp,
3593: -and all its prerequisites are made and predate the ready label.
3594: -A ready label is marked
3595: -.I made
3596: -(and given a date stamp)
3597: -if it is trivially uptodate or by executing the recipe
3598: -associated with the arcs leading from the node associated with the ready label.
3599: -The
3600: -.B P
3601: -attribute can be used to generalize
3602: -.IR mk 's
3603: -notion of determining if prerequisites predate a label.
3604: -Rather than comparing date stamps, it executes a specified program
3605: -and uses the exit status.
3606: -.PP
3607: -Date stamps are calculated differently for virtual labels,
3608: -for labels that correspond to extant files,
3609: -and for other labels.
3610: -If a label is
3611: -.I virtual
3612: -(target of a rule with the
3613: -.B V
3614: -attribute),
3615: -its date stamp is initially zero and upon being made is set to
3616: -the most recent date stamp of its prerequisites.
3617: -Otherwise, if a label is nonexistent
3618: -(does not exist as a file),
3619: -its date stamp is set to the most recent date stamp of its prerequisites,
3620: -or zero if it has no prerequisites.
3621: -Otherwise, the label is the name of a file and
3622: -the label's date stamp is always that file's modification date.
3623: -.PP
3624: -Nonexistent labels which have prerequisites
3625: -and are prerequisite to other label(s) are treated specially unless the
3626: -.B -i
3627: -flag is used.
3628: -Such a label
3629: -.I l
3630: -is given the date stamp of its most recent prerequisite
3631: -and if this causes all the labels which have
3632: -.I l
3633: -as a prerequisite to be trivially uptodate,
3634: -.I l
3635: -is considered to be trivially uptodate.
3636: -Otherwise,
3637: -.I l
3638: -is made in the normal fashion.
3639: -.PP
3640: -Two recipes are called identical if they arose by distribution
3641: -from a single rule as described above.
3642: -Identical recipes may be executed only when all
3643: -their prerequisite nodes are ready, and then just one instance of
3644: -the identical recipes is executed to make all their target nodes.
3645: -.PP
3646: -Files may be made in any order that respects
3647: -the preceding restrictions.
3648: -.PP
3649: -A recipe is executed by supplying the recipe as standard input to
3650: -the command
3651: -.B
3652: - /bin/sh -e
3653: -.br
3654: -The environment is augmented by the following variables:
3655: -.TP 14
3656: -.B $alltarget
3657: -all the targets of this rule.
3658: -.TP
3659: -.B $newprereq
3660: -the prerequisites that caused this rule to execute.
3661: -.TP
3662: -.B $nproc
3663: -the process slot for this recipe.
3664: -It satisfies
3665: -.RB 0\(<= $nproc < $NPROC ,
3666: -where
3667: -.B $NPROC
3668: -is the maximum number of recipes that may be executing
3669: -simultaneously.
3670: -.TP
3671: -.B $pid
3672: -the process id for the
3673: -.I mk
3674: -forking the recipe.
3675: -.TP
3676: -.B $prereq
3677: -all the prerequisites for this rule.
3678: -.TP
3679: -.B $stem
3680: -if this is a metarule,
3681: -.B $stem
3682: -is the string that matched
3683: -.BR % .
3684: -Otherwise, it is empty.
3685: -For regular expression metarules, the variables
3686: -.LR stem0 ", ...,"
3687: -.L stem9
3688: -are set to the corresponding subexpressions.
3689: -.TP
3690: -.B $target
3691: -the targets for this rule that need to be remade.
3692: -.PP
3693: -Unless the rule has the
3694: -.B Q
3695: -attribute,
3696: -the recipe is printed prior to execution
3697: -with recognizable shell variables expanded.
3698: -To see the commands print as they execute,
3699: -include a
3700: -.L set -x
3701: -in your rule.
3702: -Commands returning nonzero status (see
3703: -.IR intro (1))
3704: -cause
3705: -.I mk
3706: -to terminate.
3707: -.SS Aggregates
3708: -Names of the form
3709: -.IR a ( b )
3710: -refer to member
3711: -.I b
3712: -of the aggregate
3713: -.IR a .
3714: -Currently, the only aggregates supported are
3715: -.IR ar (1)
3716: -archives.
3717: -.SS Environment
3718: -Rules may make use of shell (or environment) variables.
3719: -A legal shell variable reference of the form
3720: -.B $OBJ
3721: -or
3722: -.B ${name}
3723: -is expanded as in
3724: -.IR sh (1).
3725: -A reference of the form
3726: -.BI ${name: A % B = C\fB%\fID\fB}\fR,
3727: -where
3728: -.I A, B, C, D
3729: -are (possibly empty) strings,
3730: -has the value formed by expanding
3731: -.B $name
3732: -and substituting
3733: -.I C
3734: -for
3735: -.I A
3736: -and
3737: -.I D
3738: -for
3739: -.I B
3740: -in each word in
3741: -.B $name
3742: -that matches pattern
3743: -.IB A % B .
3744: -.PP
3745: -Variables can be set by
3746: -assignments of the form
3747: -.I
3748: - var\fB=\fR[\fIattr\fB=\fR]\fItokens\fR
3749: -.br
3750: -where
3751: -.I tokens
3752: -and the optional attributes
3753: -are defined under `Syntax' below.
3754: -The environment is exported to recipe executions.
3755: -Variable values are taken from (in increasing order of precedence)
3756: -the default values below, the environment, the mkfiles,
3757: -and any command line assignment.
3758: -A variable assignment argument overrides the first (but not any subsequent)
3759: -assignment to that variable.
3760: -.br
3761: -.ne 1i
3762: -.EX
3763: -.ta \n(.lu/3u +\n(.lu/3u
3764: -.nf
3765: -AS=as FFLAGS= NPROC=1
3766: -CC=cc LEX=lex NREP=1
3767: -CFLAGS= LFLAGS= YACC=yacc
3768: -FC=f77 LDFLAGS= YFLAGS=
3769: -BUILTINS='
3770: -.ta 8n
3771: -%.o: %.c
3772: - $CC $CFLAGS -c $stem.c
3773: -%.o: %.s
3774: - $AS -o $stem.o $stem.s
3775: -%.o: %.f
3776: - $FC $FFLAGS -c $stem.f
3777: -%.o: %.y
3778: - $YACC $YFLAGS $stem.y &&
3779: - $CC $CFLAGS -c y.tab.c && mv y.tab.o $stem.o; rm y.tab.c
3780: -%.o: %.l
3781: - $LEX $LFLAGS -t $stem.l > $stem.c &&
3782: - $CC $CFLAGS -c $stem.c && rm $stem.c'
3783: -ENVIRON=
3784: -.EE
3785: -.PP
3786: -The builtin rules are obtained from the variable
3787: -.B BUILTINS
3788: -after all input has been processed.
3789: -The
3790: -.B ENVIRON
3791: -variable is split into parts at control-A characters,
3792: -the control-A characters are deleted, and the parts are
3793: -placed in the environment.
3794: -The variable
3795: -.B MKFLAGS
3796: -contains all the option arguments (arguments starting with
3797: -.L -
3798: -or containing
3799: -.LR = )
3800: -and
3801: -.B MKARGS
3802: -contains all the targets in the call to
3803: -.IR mk .
3804: -.SS Syntax
3805: -Leading white space (blank or tab) is ignored.
3806: -Input after an unquoted
3807: -.B #
3808: -(a comment) is ignored as are blank lines.
3809: -Lines can be spread over several physical lines by
3810: -placing a
3811: -.B \e
3812: -before newlines to be elided.
3813: -Non-recipe lines are processed by substituting for
3814: -.BI ` cmd `
3815: -and then substituting for variable references.
3816: -Finally, the filename metacharacters
3817: -.B []*?
3818: -are expanded.
3819: -.tr #"
3820: -Quoting by
3821: -.BR \&'' ,
3822: -.BR ## ,
3823: -and
3824: -.B \e
3825: -is supported.
3826: -The semantics for substitution and quoting are given in
3827: -.IR sh (1).
3828: -.PP
3829: -The contents of files may be included by lines beginning with
3830: -.B <
3831: -followed by a filename.
3832: -.PP
3833: -.tr ##
3834: -Assignments and rule header lines are distinguished by
3835: -the first unquoted occurrence of
3836: -.B :
3837: -(rule header)
3838: -or
3839: -.B =
3840: -(assignment).
3841: -.PP
3842: -A rule definition consists of a header line followed by a recipe.
3843: -The recipe consists of all lines following the header line
3844: -that start with white space.
3845: -The recipe may be empty.
3846: -The first character on every line of the recipe is elided.
3847: -The header line consists of at least one target followed by the rule separator
3848: -and a possibly empty list of prerequisites.
3849: -The rule separator is either a single
3850: -.LR :
3851: -or is a
3852: -.L :
3853: -immediately followed by attributes and another
3854: -.LR : .
3855: -If any prerequisite is more recent than any of the targets,
3856: -the recipe is executed.
3857: -This meaning is modified by the following attributes
3858: -.TP
3859: -.B <
3860: -The standard output of the recipe is read by
3861: -.I mk
3862: -as an additional mkfile.
3863: -Assignments take effect immediately.
3864: -Rule definitions are used when a new dependency dag is constructed.
3865: -.PD 0
3866: -.TP
3867: -.B D
3868: -If the recipe exits with an error status, the target is deleted.
3869: -.TP
3870: -.B N
3871: -If there is no recipe, the target has its time updated.
3872: -.TP
3873: -.B P
3874: -The characters after the
3875: -.B P
3876: -until the terminating
3877: -.B :
3878: -are taken as a program name.
3879: -It will be invoked as
3880: -.B "sh -c prog 'arg1' 'arg2'"
3881: -and should return 0 exit status
3882: -if and only if arg1 is not out of date with respect to arg2.
3883: -Date stamps are still propagated in the normal way.
3884: -.TP
3885: -.B Q
3886: -The recipe is not printed prior to execution.
3887: -.TP
3888: -.B R
3889: -The rule is a metarule using regular expressions.
3890: -.TP
3891: -.B U
3892: -The targets are considered to have been updated
3893: -even if the recipe did not do so.
3894: -.TP
3895: -.B V
3896: -The targets of this rule are marked as virtual.
3897: -They are distinct from files of the same name.
3898: -.PD
3899: -.PP
3900: -Similarly, assignments may have attributes terminated by
3901: -.BR = .
3902: -The only assignment attribute is
3903: -.TP 3
3904: -.B U
3905: -Do not export this variable to recipe executions.
3906: -.SH EXAMPLES
3907: -A simple mkfile to compile a program.
3908: -.IP
3909: -.EX
3910: -prog: a.o b.o c.o
3911: - $CC $CFLAGS -o $target $prereq
3912: -.EE
3913: -.PP
3914: -Override flag settings in the mkfile.
3915: -.IP
3916: -.EX
3917: -$ mk target CFLAGS='-O -s'
3918: -.EE
3919: -.PP
3920: -To get the prerequisites for an aggregate.
3921: -.IP
3922: -.EX
3923: -$ membername 'libc.a(read.o)' 'libc.a(write.o)'
3924: -read.o write.o
3925: -.EE
3926: -.PP
3927: -Maintain a library.
3928: -.IP
3929: -.EX
3930: -libc.a(%.o):N: %.o
3931: -libc.a: libc.a(abs.o) libc.a(access.o) libc.a(alarm.o) ...
3932: - names=`membername $newprereq`
3933: - ar r libc.a $names && rm $names
3934: -.EE
3935: -.PP
3936: -Backquotes used to derive a list from a master list.
3937: -.IP
3938: -.EX
3939: -NAMES=alloc arc bquote builtins expand main match mk var word
3940: -OBJ=`echo $NAMES|sed -e 's/[^ ][^ ]*/&.o/g'`
3941: -.EE
3942: -.PP
3943: -Regular expression metarules.
3944: -The single quotes are needed to protect the
3945: -.BR \e s.
3946: -.IP
3947: -.EX
3948: -\&'([^/]*)/(.*)\e.o':R: '\e1/\e2.c'
3949: - cd $stem1; $CC $CFLAGS -c $stem2.c
3950: -.EE
3951: -.PP
3952: -A correct way to deal with
3953: -.IR yacc (1)
3954: -grammars.
3955: -The file
3956: -.B lex.c
3957: -includes the file
3958: -.B x.tab.h
3959: -rather than
3960: -.B y.tab.h
3961: -in order to reflect changes in content, not just modification time.
3962: -.IP
3963: -.EX
3964: -YFLAGS=-d
3965: -lex.o: x.tab.h
3966: -x.tab.h: y.tab.h
3967: - cmp -s x.tab.h y.tab.h || cp y.tab.h x.tab.h
3968: -y.tab.c y.tab.h: gram.y
3969: - $YACC $YFLAGS gram.y
3970: -.EE
3971: -.PP
3972: -The above example could also use the
3973: -.B P
3974: -attribute for the
3975: -.B x.tab.h
3976: -rule:
3977: -.IP
3978: -.EX
3979: -x.tab.h:Pcmp -s: y.tab.h
3980: - cp y.tab.h x.tab.h
3981: -.EE
3982: -.SH SEE ALSO
3983: -.IR make (1),
3984: -.IR chdate (1),
3985: -.IR sh (1),
3986: -.IR regexp (3)
3987: -.br
3988: -A. Hume,
3989: -.RI ` Mk :
3990: -a Successor to
3991: -.IR Make ',
3992: -this manual, Volume 2
3993: -.SH BUGS
3994: -Identical recipes for regular expression metarules only have one target.
3995: -.br
3996: -Seemingly appropriate input like
3997: -.B CFLAGS=-DHZ=60
3998: -is parsed as an erroneous attribute; correct it by inserting
3999: -a space after the first
4000: -.LR = .
4001: //GO.SYSIN DD ./mk.1
4002: echo ./alloc.c 1>&2
4003: sed 's/.//' >./alloc.c <<'//GO.SYSIN DD ./alloc.c'
4004: -#include "libc.h"
4005: -
4006: -static int goo; /* so no empty object on cray */
4007: -
4008: -#ifndef CRAY
4009: -
4010: -#define A(x) ((((long)x)+sizeof(long)-1)&~(sizeof(long)-1))
4011: -
4012: -char *next;
4013: -int nleft;
4014: -
4015: -char *
4016: -malloc(n)
4017: -{
4018: - extern char *sbrk();
4019: - char *s;
4020: -
4021: - n = A(n);
4022: - if(n > nleft){
4023: - next = sbrk(nleft = A(32000));
4024: - if(next == (char *)-1){
4025: - perror("mk: sbrk");
4026: - Exit();
4027: - }
4028: - }
4029: - s = next;
4030: - next += n;
4031: - nleft -= n;
4032: - return(s);
4033: -}
4034: -
4035: -free(s)
4036: - char *s;
4037: -{
4038: -}
4039: -
4040: -char *
4041: -realloc(s, n)
4042: - char *s;
4043: - unsigned n;
4044: -{
4045: - char *r;
4046: -
4047: - r = malloc(n);
4048: - memcpy(r, s, n);
4049: - return(r);
4050: -}
4051: -
4052: -#endif
4053: //GO.SYSIN DD ./alloc.c
4054: echo ./arc.c 1>&2
4055: sed 's/.//' >./arc.c <<'//GO.SYSIN DD ./arc.c'
4056: -#include "mk.h"
4057: -
4058: -Arc *
4059: -newarc(n, r, stem, match)
4060: - Node *n;
4061: - Rule *r;
4062: - char *stem;
4063: - regsubexp *match;
4064: -{
4065: - register Arc *a;
4066: -
4067: - a = (Arc *)Malloc(sizeof(Arc));
4068: - a->n = n;
4069: - a->r = r;
4070: - a->stem = strdup(stem);
4071: - memcpy((char *)a->match, (char *)match, sizeof a->match);
4072: - a->next = 0;
4073: - a->flag = 0;
4074: - a->prog = r->prog;
4075: - return(a);
4076: -}
4077: -
4078: -dumpa(s, a)
4079: - char *s;
4080: - register Arc *a;
4081: -{
4082: - char buf[1024];
4083: -
4084: - sprint(buf, "%s ", (*s == ' ')? s:"");
4085: - Fprint(1, "%sArc@%ld: n=%ld r=%ld flag=0x%x stem='%s'",
4086: - s, a, a->n, a->r, a->flag, a->stem);
4087: - if(a->prog)
4088: - Fprint(1, " prog='%s'", a->prog);
4089: - Fprint(1, "\n");
4090: - if(a->n)
4091: - dumpn(buf, a->n);
4092: -}
4093: -
4094: -nrep()
4095: -{
4096: - register Symtab *sym;
4097: -
4098: - if(sym = symlook("NREP", S_VAR, (char *)0))
4099: - nreps = atoi(sym->value);
4100: - if(nreps < 1)
4101: - nreps = 1;
4102: - if(DEBUG(D_GRAPH))
4103: - Fprint(1, "nreps = %d\n", nreps);
4104: -}
4105: //GO.SYSIN DD ./arc.c
4106: echo ./bquote.c 1>&2
4107: sed 's/.//' >./bquote.c <<'//GO.SYSIN DD ./bquote.c'
4108: -#include "mk.h"
4109: -
4110: -bquote(fd, src, dest)
4111: - register char *src, *dest;
4112: -{
4113: - int childin[2], childout[2], pid, i;
4114: - int quotedone = 1;
4115: - char *ldest, *t;
4116: - char *newline = "\n";
4117: - int wearedone = 0;
4118: - int initdone = 0;
4119: - extern char **environ;
4120: -
4121: - while(wearedone == 0)
4122: - switch(*src)
4123: - {
4124: - default:
4125: - *dest++ = *src++;
4126: - break;
4127: - case 0:
4128: - if(quotedone)
4129: - wearedone = 1;
4130: - else {
4131: - if(t = Frdline(fd)){
4132: - inline++;
4133: - *dest++ = '\n'|EBIT;
4134: - strcpy(src, t);
4135: - continue;
4136: - } else {
4137: - SYNERR(-1); Fprint(2, "missing closing `\n");
4138: - break;
4139: - }
4140: - }
4141: - break;
4142: - case '\\':
4143: - if(*src)
4144: - *dest++ = *src++;
4145: - else
4146: - if(t = Frdline(fd)){
4147: - inline++;
4148: - strcpy(src, t);
4149: - }
4150: - break;
4151: - case '`':
4152: - if(quotedone = 1-quotedone){
4153: - if(initdone == 0){
4154: - execinit();
4155: - initdone = 1;
4156: - }
4157: - Fflush(1);
4158: - Fflush(2);
4159: - if(pipe(childin) < 0){
4160: - SYNERR(-1); perror("pipe1");
4161: - Exit();
4162: - }
4163: - if(pipe(childout) < 0){
4164: - SYNERR(-1); perror("pipe2");
4165: - Exit();
4166: - }
4167: - if((pid = fork()) < 0){
4168: - SYNERR(-1); perror("fork");
4169: - Exit();
4170: - }
4171: - if(pid){ /* parent */
4172: - close(childin[0]);
4173: - close(childout[1]);
4174: - if(ldest < dest){
4175: - writeout(childin[1], ldest, dest);
4176: - writeout(childin[1], newline, newline+1);
4177: - }
4178: - close(childin[1]);
4179: - dest = ldest;
4180: - while((i = read(childout[0], dest, 512)) > 0)
4181: - dest += i;
4182: - if((dest > ldest) && (dest[-1] == '\n'))
4183: - dest--;
4184: - close(childout[0]);
4185: - } else {
4186: - dup2(childin[0], 0);
4187: - dup2(childout[1], 1);
4188: - close(childin[0]);
4189: - close(childin[1]);
4190: - close(childout[0]);
4191: - close(childout[1]);
4192: - if(execle(SHELL, "sh", (char *)0, environ) < 0)
4193: - perror("exec");
4194: - _exit(1);
4195: - }
4196: - } else
4197: - ldest = dest;
4198: - src++;
4199: - break;
4200: - }
4201: - *dest = 0;
4202: -}
4203: -
4204: -writeout(fd, b, e)
4205: - register char *b, *e;
4206: -{
4207: - char buf[BIGBLOCK];
4208: - register char *s;
4209: -
4210: - for(s = buf; b < e;){
4211: - if(s >= &buf[BIGBLOCK-1]){
4212: - SYNERR(-1); Fprint(2, "too much text (%d chars) for `expr`\n", s-buf);
4213: - Exit();
4214: - }
4215: - if(*b&EBIT){
4216: - *s++ = '\\';
4217: - *s++ = (~EBIT) & *b++;
4218: - } else
4219: - *s++ = *b++;
4220: - }
4221: - write(fd, buf, s-buf);
4222: -}
4223: //GO.SYSIN DD ./bquote.c
4224: echo ./builtins.c 1>&2
4225: sed 's/.//' >./builtins.c <<'//GO.SYSIN DD ./builtins.c'
4226: -#include "mk.h"
4227: -
4228: -char *bltin[] =
4229: -{
4230: - "AS", "as",
4231: - "CC", "cc",
4232: - "CFLAGS", "",
4233: - "FC", "f77",
4234: - "FFLAGS", "",
4235: - "LDFLAGS", "",
4236: - "LEX", "lex",
4237: - "LFLAGS", "",
4238: - "NPROC", "1",
4239: - "NREP", "1",
4240: - "YACC", "yacc",
4241: - "YFLAGS", "",
4242: - "BUILTINS", "%.o: %.c\n\
4243: - $CC $CFLAGS -c $stem.c\n\
4244: -%.o: %.s\n\
4245: - $AS -o $stem.o $stem.s\n\
4246: -%.o: %.f\n\
4247: - $FC $FFLAGS -c $stem.f\n\
4248: -%.o: %.y\n\
4249: - $YACC $YFLAGS $stem.y && $CC $CFLAGS -c y.tab.c && mv y.tab.o $stem.o; rm y.tab.c\n\
4250: -%.o: %.l\n\
4251: - $LEX $LFLAGS -t $stem.l > /tmp/$$.c && $CC $CFLAGS -c /tmp/$$.c && mv /tmp/$$.o $stem.o; rm /tmp/$$.c\n",
4252: - "ENVIRON", "",
4253: - 0
4254: -};
4255: -
4256: -builtins()
4257: -{
4258: - register char **b;
4259: -
4260: - for(b = bltin; *b; b += 2)
4261: - setvar(b[0], strdup(b[1]));
4262: -}
4263: -
4264: -parsebuiltins()
4265: -{
4266: - char *s, *file;
4267: - int fd;
4268: - int n;
4269: -
4270: - s = symlook("BUILTINS", S_VAR, (char *)0)->value;
4271: - if(*s == 0)
4272: - return;
4273: - file = mktemp("/tmp/mkXXXXXX");
4274: - if((fd = creat(file, 0600)) < 0){
4275: - fprint(2, "mk: builtins in ");
4276: - perror(file);
4277: - Exit();
4278: - }
4279: - if(n = strlen(s)){
4280: - write(fd, s, n);
4281: - if(s[n-1] != '\n')
4282: - write(fd, "\n", 1);
4283: - }
4284: - close(fd);
4285: - parse("BUILTINS", open(file, 0), 0, 0);
4286: - unlink(file);
4287: -}
4288: //GO.SYSIN DD ./builtins.c
4289: echo ./dir.c 1>&2
4290: sed 's/.//' >./dir.c <<'//GO.SYSIN DD ./dir.c'
4291: -#include <sys/types.h>
4292: -#include <sys/stat.h>
4293: -#ifndef SEQUENT
4294: -#include <ndir.h>
4295: -#else
4296: -#include <dir.h>
4297: -#endif
4298: -
4299: -#ifdef SEQUENT
4300: -#define DIRSIZE MAXNAMELEN
4301: -#else
4302: -#define DIRSIZE 14
4303: -#endif
4304: -#ifndef MAXNAMELEN
4305: -#define MAXNAMELEN 255
4306: -#endif
4307: -#ifndef DIRSIZ
4308: -#define DIRSIZ(dp) \
4309: - ((sizeof(struct direct) - MAXNAMLEN + (dp)->d_namlen + sizeof(ino_t) - 1) &\
4310: - ~(sizeof(ino_t) - 1))
4311: -#endif
4312: -
4313: -extern char *strncpy(), *malloc();
4314: -
4315: -DIR *
4316: -opendir(name)
4317: -register char *name;
4318: -{
4319: - DIR dirbuf, *dirp;
4320: - struct stat statb;
4321: - char buf[MAXNAMELEN+1];
4322: - register char *s;
4323: -
4324: - strncpy(buf, name, MAXNAMELEN);
4325: - buf[MAXNAMELEN-1] = 0;
4326: - if ((dirbuf.dd_fd = open(buf, 0)) < 0)
4327: - return((DIR *)0);
4328: - if (fstat(dirbuf.dd_fd, &statb)!=0 || (statb.st_mode & S_IFMT)!=S_IFDIR){
4329: - close(dirbuf.dd_fd);
4330: - return((DIR *)0);
4331: - }
4332: - dirbuf.dd_loc = 0;
4333: - dirp = (DIR *)malloc(sizeof(DIR));
4334: - *dirp = dirbuf;
4335: - return(dirp);
4336: -}
4337: -
4338: -void
4339: -closedir(dirp)
4340: -DIR *dirp;
4341: -{
4342: - close(dirp->dd_fd);
4343: - free((char *)dirp);
4344: -}
4345: -
4346: -/*
4347: - * read an old stlye directory entry and present it as a new one
4348: - */
4349: -#define ODIRSIZ 14
4350: -
4351: -struct olddirect {
4352: - ino_t d_ino;
4353: - char d_name[ODIRSIZ];
4354: -#ifdef CRAY
4355: - char d_pad[10];
4356: -#endif
4357: -};
4358: -
4359: -/*
4360: - * get next entry in a directory.
4361: - */
4362: -struct direct *
4363: -readdir(dirp)
4364: - register DIR *dirp;
4365: -{
4366: - register struct olddirect *dp;
4367: - static struct direct dir;
4368: -
4369: - for (;;) {
4370: - if (dirp->dd_loc == 0) {
4371: - dirp->dd_size = read(dirp->dd_fd, dirp->dd_buf,
4372: - DIRBLKSIZ);
4373: - if (dirp->dd_size <= 0)
4374: - return((struct direct *)0);
4375: - }
4376: - if (dirp->dd_loc >= dirp->dd_size) {
4377: - dirp->dd_loc = 0;
4378: - continue;
4379: - }
4380: - dp = (struct olddirect *)(dirp->dd_buf + dirp->dd_loc);
4381: - dirp->dd_loc += sizeof(struct olddirect);
4382: - if (dp->d_ino == 0)
4383: - continue;
4384: - dir.d_ino = dp->d_ino;
4385: - strncpy(dir.d_name, dp->d_name, ODIRSIZ);
4386: - dir.d_name[ODIRSIZ] = '\0'; /* insure null termination */
4387: - dir.d_namlen = strlen(dir.d_name);
4388: - dir.d_reclen = DIRSIZ(&dir);
4389: - return (&dir);
4390: - }
4391: -}
4392: //GO.SYSIN DD ./dir.c
4393: echo ./expand.c 1>&2
4394: sed 's/.//' >./expand.c <<'//GO.SYSIN DD ./expand.c'
4395: -#include "mk.h"
4396: -#include <ctype.h>
4397: -
4398: -static Word *bollard;
4399: -
4400: -static void
4401: -append(s)
4402: - char *s;
4403: -{
4404: - register Word *w;
4405: - register char *p;
4406: -
4407: - if(bollard){
4408: - for(w = bollard; w->next; w = w->next)
4409: - ;
4410: - w = w->next = stow(s);
4411: - } else
4412: - w = bollard = stow(s);
4413: - if(w) /* if we got a word */
4414: - for(p = w->s; *p;)
4415: - *p++ &= ~EBIT;
4416: -}
4417: -
4418: -Word *
4419: -expand(s)
4420: - register char *s;
4421: -{
4422: - char save;
4423: - register char *t;
4424: - Word *head, *w;
4425: -
4426: - w = head = newword("");
4427: - while(*s){
4428: - while(SEP(*s))
4429: - s++;
4430: - if(*s == 0) break;
4431: - for(t = s+1; *t && !SEP(*t); t++)
4432: - ;
4433: - save = *t;
4434: - *t = 0;
4435: - bollard = 0;
4436: - glob(s, append);
4437: - w->next = bollard;
4438: - while(w->next)
4439: - w = w->next;
4440: - *t = save;
4441: - s = t;
4442: - }
4443: - w = head->next;
4444: - delword(head);
4445: - return(w);
4446: -}
4447: //GO.SYSIN DD ./expand.c
4448: echo ./gen.c 1>&2
4449: sed 's/.//' >./gen.c <<'//GO.SYSIN DD ./gen.c'
4450: -#include "mk.h"
4451: -
4452: -#define NMATCH 10
4453: -
4454: -gen(buf)
4455: - char *buf;
4456: -{
4457: - char buf1[BIGBLOCK];
4458: - register char *src, *dest;
4459: - register char *s1, *s2, *s3, *s4;
4460: - regexp *prog;
4461: - regsubexp match[NMATCH];
4462: - char c;
4463: -
4464: - if((s1 = strchr(buf, '@')) == 0)
4465: - return;
4466: - patrule = 0;
4467: - src = buf;
4468: - dest = buf1;
4469: - do {
4470: - while(src != s1)
4471: - *dest++ = *src++;
4472: - if((s2 = strchr(s1+1, '@')) && (s3 = strchr(s2+1, '@'))
4473: - && (s4 = strchr(s3+1, '@')))
4474: - ;
4475: - else {
4476: - SYNERR(-1); Fprint(2, "expected four @\n");
4477: - break;
4478: - }
4479: - src = s4+1;
4480: - *s2++ = *s3++ = *s4 = 0;
4481: - prog = regcomp(s2);
4482: - for(s2 = ++s1; ; s2 = s1){
4483: - while((*s2 == ' ')||(*s2 == '\t'))
4484: - s2++;
4485: - if(s1 != s2) *dest++ = ' ';
4486: - if(*s2 == 0) break;
4487: - for(s1 = s2+1; *s1 && (*s1 != ' ') && (*s1 != '\t');)
4488: - s1++;
4489: - c = *s1;
4490: - *s1 = 0;
4491: - if(regexec(prog, s2, match, NMATCH)){
4492: - regsub(s3, dest, match, NMATCH);
4493: - while(*dest) dest++;
4494: - } else
4495: - while(*dest = *s2++)
4496: - dest++;
4497: - *s1 = c;
4498: - }
4499: - } while(s1 = strchr(src, '@'));
4500: - while(*dest++ = *src++)
4501: - ;
4502: - memcpy(buf, buf1, (int)(dest-buf1));
4503: -}
4504: //GO.SYSIN DD ./gen.c
4505: echo ./glob.c 1>&2
4506: sed 's/.//' >./glob.c <<'//GO.SYSIN DD ./glob.c'
4507: -#include <sys/types.h>
4508: -#include <sys/stat.h>
4509: -#ifndef SEQUENT
4510: -#include <ndir.h>
4511: -#else
4512: -#include <dir.h>
4513: -#endif
4514: -#include <string.h>
4515: -#include "mk.h"
4516: -
4517: -#define MAXPATH BIGBLOCK
4518: -
4519: -static char result[MAXPATH];
4520: -static doit();
4521: -
4522: -/*
4523: - * globals (file name generation)
4524: - *
4525: - * "*" in params matches r.e ".*"
4526: - * "?" in params matches r.e. "."
4527: - * "[...]" in params matches character class
4528: - * "[...a-z...]" in params matches a through z.
4529: - *
4530: - */
4531: -
4532: -static
4533: -gglob(arg, dest, fn)
4534: - char *arg, *dest;
4535: - void (*fn)();
4536: -{
4537: - int meta;
4538: - char *slash, *s;
4539: - DIR *dirf;
4540: -
4541: - /*
4542: - check for meta chars
4543: - */
4544: - for(s = arg, slash = 0, meta = 0; *s && !meta; s++)
4545: - switch(*s)
4546: - {
4547: - case '/':
4548: - slash = s+1;
4549: - break;
4550: - case '\\':
4551: - if(s[1])
4552: - s++;
4553: - break;
4554: - case '[':
4555: - case '*':
4556: - case '?':
4557: - meta = 1;
4558: - break;
4559: - }
4560: - if(meta == 0){
4561: - strcpy(dest, arg);
4562: - (*fn)(result);
4563: - return;
4564: - }
4565: - if(slash){
4566: - memcpy(dest, arg, slash-arg);
4567: - dest += slash-arg;
4568: - *dest = 0;
4569: - } else
4570: - slash = arg;
4571: - s = strchr(slash, '/');
4572: - if(dirf = opendir(result[0] ? result : ".")){
4573: - struct direct *e;
4574: - int found;
4575: -
4576: - found = 0;
4577: - if(s) *s = 0;
4578: - /* slash is null terminated (s) pattern */
4579: - while(e = readdir(dirf)){
4580: - if(e->d_name[0] == '.' && *slash != '.'){
4581: - if (e->d_name[1] == 0)
4582: - continue;
4583: - if (e->d_name[1] == '.' && e->d_name[2] == 0)
4584: - continue;
4585: - }
4586: - if(gmatch(e->d_name, slash)){
4587: - found = 1;
4588: - strcpy(dest, e->d_name);
4589: - doit(s, dest, fn);
4590: - }
4591: - }
4592: - if(!found){
4593: - strcpy(dest, slash);
4594: - doit(s, dest, fn);
4595: - }
4596: - closedir(dirf);
4597: - } else {
4598: - if(s)
4599: - *s = 0;
4600: - strcpy(dest, slash);
4601: - dest = strchr(dest, 0);
4602: - if(s){
4603: - *dest++ = '/';
4604: - *dest = 0;
4605: - gglob(s+1, dest, fn);
4606: - } else
4607: - (*fn)(result);
4608: - }
4609: - if(s) *s = '/';
4610: -}
4611: -
4612: -static
4613: -doit(s, dest, fn)
4614: - char *s, *dest;
4615: - void (*fn)();
4616: -{
4617: - if(s){
4618: - register char *ss;
4619: -
4620: - ss = strchr(dest, 0);
4621: - *ss++ = '/';
4622: - *ss = 0;
4623: - gglob(s+1, ss, fn);
4624: - } else
4625: - (*fn)(result);
4626: -}
4627: -
4628: -gmatch(s, p)
4629: -register char *s, *p;
4630: -{
4631: - register int scc;
4632: - unsigned char c;
4633: -
4634: - scc = *s++&(0xFF&~EBIT);
4635: - switch (c = *p++)
4636: - {
4637: - case '[':
4638: - {
4639: - int ok;
4640: - int lc;
4641: - int notflag = 0;
4642: -
4643: - ok = 0;
4644: - lc = 077777;
4645: - if (*p == '^'){
4646: - notflag = 1;
4647: - p++;
4648: - }
4649: - while (c = *p++){
4650: - if (c == ']')
4651: - return(ok ? gmatch(s, p) : 0);
4652: - else if (c == '-'){
4653: - if (notflag){
4654: - if (scc < lc || scc > *(p++))
4655: - ok++;
4656: - else
4657: - return(0);
4658: - } else {
4659: - if (lc <= scc && scc <= (*p++))
4660: - ok++;
4661: - }
4662: - } else {
4663: - lc = c&~EBIT;
4664: - if (notflag){
4665: - if (scc && scc != lc)
4666: - ok++;
4667: - else
4668: - return(0);
4669: - } else {
4670: - if (scc == lc)
4671: - ok++;
4672: - }
4673: - }
4674: - }
4675: - return(0);
4676: - }
4677: -
4678: - default:
4679: - if ((c&~EBIT) != scc)
4680: - return(0);
4681: -
4682: - case '?':
4683: - return(scc ? gmatch(s, p) : 0);
4684: -
4685: - case '*':
4686: - while (*p == '*')
4687: - p++;
4688: -
4689: - if (*p == 0)
4690: - return(1);
4691: - --s;
4692: - while (*s){
4693: - if (gmatch(s++, p))
4694: - return(1);
4695: - }
4696: - return(0);
4697: -
4698: - case 0:
4699: - return(scc == 0);
4700: - }
4701: -}
4702: -
4703: -glob(s, fn)
4704: - char *s;
4705: - void (*fn)();
4706: -{
4707: - result[0] = 0;
4708: - if(strlen(s) >= MAXPATH){
4709: - SYNERR(inline-1);
4710: - Fprint(2, "too much input for glob expansion; max=%d, given %d\n", MAXPATH, strlen(s));
4711: - Exit();
4712: - }
4713: - gglob(s, result, fn);
4714: -}
4715: -
4716: -#ifdef MAIN
4717: -
4718: -void
4719: -pr(s)
4720: - char *s;
4721: -{
4722: - Fwrite(1, s, strlen(s));
4723: - Fputc(1, '\n');
4724: -}
4725: -
4726: -main(argc, argv)
4727: - char **argv;
4728: -{
4729: - for(argv++; *argv; argv++){
4730: - Fprint(1, "<%s>:\n", *argv);
4731: - glob(*argv, pr);
4732: - Fprint(1, "*******\n");
4733: - }
4734: - exit(0);
4735: -}
4736: -#endif
4737: //GO.SYSIN DD ./glob.c
4738: echo ./graph.c 1>&2
4739: sed 's/.//' >./graph.c <<'//GO.SYSIN DD ./graph.c'
4740: -#include "mk.h"
4741: -
4742: -static Node *newnode(), *applyrules();
4743: -static cyclechk(), vacuous(), ambiguous(), attribute();
4744: -
4745: -Node *
4746: -graph(target)
4747: - char *target;
4748: -{
4749: - Node *node;
4750: - char *cnt;
4751: -
4752: - node = applyrules(target, cnt = rulecnt());
4753: - free(cnt);
4754: - cyclechk(node);
4755: - node->flags |= PROBABLE; /* make sure it doesn't get deleted */
4756: - (void)vacuous(node);
4757: - (void)ambiguous(node);
4758: - (void)attribute(node);
4759: - return(node);
4760: -}
4761: -
4762: -static Node *
4763: -applyrules(target, cnt)
4764: - char *target, *cnt;
4765: -{
4766: - Symtab *sym;
4767: - Node *node;
4768: - Rule *r;
4769: - Arc head, *a = &head;
4770: - Word *w;
4771: - char stem[NAMEBLOCK], buf[NAMEBLOCK];
4772: - regsubexp rmatch[NREGEXP];
4773: -
4774: -/* print("appplyrules(%ld='%s')\n", target, target);/**/
4775: - if(sym = symlook(target, S_NODE, (char *)0)){
4776: - node = (Node *)(sym->value);
4777: - return(node);
4778: - }
4779: - target = strdup(target);
4780: - node = newnode(target);
4781: - head.n = 0;
4782: - head.next = 0;
4783: - sym = symlook(target, S_TARGET, (char *)0);
4784: - for(r = sym? (Rule *)(sym->value):0; r; r = r->chain){
4785: - if(r->attr&META) continue;
4786: - if(strcmp(target, r->target)) continue;
4787: - if(cnt[r->rule] >= nreps) continue;
4788: - cnt[r->rule]++;
4789: - node->flags |= PROBABLE;
4790: - if(r->attr&VIR)
4791: - node->flags |= VIRTUAL;
4792: - if(r->attr&NOREC)
4793: - node->flags |= NORECIPE;
4794: - if(r->attr&DEL)
4795: - node->flags |= DELETE;
4796: - if(r->tail == 0)
4797: - a = a->next = newarc((Node *)0, r, "", rmatch);
4798: - else
4799: - for(w = r->tail; w; w = w->next){
4800: - a = a->next = newarc(applyrules(w->s, cnt), r, "", rmatch);
4801: - }
4802: - cnt[r->rule]--;
4803: - head.n = node;
4804: - }
4805: - for(r = metarules; r; r = r->next){
4806: - if(r->attr®EXP){
4807: - stem[0] = 0;
4808: - patrule = r;
4809: - if(regexec(r->pat, node->name, rmatch, NREGEXP) == 0)
4810: - continue;
4811: - } else {
4812: - if(!match(node->name, r->target, stem)) continue;
4813: - }
4814: - if(cnt[r->rule] >= nreps) continue;
4815: - cnt[r->rule]++;
4816: - if(r->attr&VIR)
4817: - node->flags |= VIRTUAL;
4818: - if(r->attr&NOREC)
4819: - node->flags |= NORECIPE;
4820: - if(r->attr&DEL)
4821: - node->flags |= DELETE;
4822: - if(r->tail == 0)
4823: - a = a->next = newarc((Node *)0, r, strdup(stem), rmatch);
4824: - else
4825: - for(w = r->tail; w; w = w->next){
4826: - if(r->attr®EXP)
4827: - regsub(w->s, buf, rmatch, NREGEXP);
4828: - else
4829: - subst(stem, w->s, buf);
4830: - a = a->next = newarc(applyrules(buf, cnt), r, strdup(stem), rmatch);
4831: - }
4832: - cnt[r->rule]--;
4833: - }
4834: - a->next = node->prereqs;
4835: - node->prereqs = head.next;
4836: - return(node);
4837: -}
4838: -
4839: -static
4840: -togo(node)
4841: - register Node *node;
4842: -{
4843: - register Arc *la, *a;
4844: -
4845: - /* delete them now */
4846: - for(a = node->prereqs; a; la = a, a = a->next)
4847: - if(a->flag&TOGO){
4848: - if(a == node->prereqs)
4849: - node->prereqs = a->next;
4850: - else
4851: - la->next = a->next, a = la;
4852: - }
4853: -}
4854: -
4855: -static
4856: -vacuous(node)
4857: - register Node *node;
4858: -{
4859: - register Arc *la, *a;
4860: - int vac = !(node->flags&PROBABLE);
4861: -
4862: - if(node->flags&READY)
4863: - return(node->flags&VACUOUS);
4864: - node->flags |= READY;
4865: - for(a = node->prereqs; a; a = a->next)
4866: - if(a->n && vacuous(a->n) && (a->r->attr&META))
4867: - a->flag |= TOGO;
4868: - else
4869: - vac = 0;
4870: - /* if a rule generated arcs that DON'T go; no others from that rule go */
4871: - for(a = node->prereqs; a; a = a->next)
4872: - if((a->flag&TOGO) == 0)
4873: - for(la = node->prereqs; la; la = la->next)
4874: - if((la->flag&TOGO) && (la->r == a->r)){
4875: - la->flag &= ~TOGO;
4876: - }
4877: - togo(node);
4878: - if(vac)
4879: - node->flags |= VACUOUS;
4880: - return(vac);
4881: -}
4882: -
4883: -static Node *
4884: -newnode(name)
4885: - char *name;
4886: -{
4887: - register Node *node;
4888: -
4889: - node = (Node *)Malloc(sizeof(Node));
4890: - symlook(name, S_NODE, (char *)node);
4891: - node->name = name;
4892: - node->time = timeof(name, 0);
4893: - node->prereqs = 0;
4894: - node->flags = node->time? PROBABLE : 0;
4895: - node->next = 0;
4896: - return(node);
4897: -}
4898: -
4899: -dumpn(s, n)
4900: - char *s;
4901: - register Node *n;
4902: -{
4903: - char buf[1024];
4904: - register Arc *a;
4905: -
4906: - sprint(buf, "%s ", (*s == ' ')? s:"");
4907: - Fprint(1, "%s%s@%ld: time=%ld flags=0x%x next=%ld\n",
4908: - s, n->name, n, n->time, n->flags, n->next);
4909: - for(a = n->prereqs; a; a = a->next)
4910: - dumpa(buf, a);
4911: -}
4912: -
4913: -static
4914: -trace(s, a)
4915: - char *s;
4916: - register Arc *a;
4917: -{
4918: - Fprint(2, "\t%s", s);
4919: - while(a){
4920: - Fprint(2, " <-(%s:%d)- %s", a->r->file, a->r->line,
4921: - a->n? a->n->name:"");
4922: - if(a->n){
4923: - for(a = a->n->prereqs; a; a = a->next)
4924: - if(*a->r->recipe) break;
4925: - } else
4926: - a = 0;
4927: - }
4928: - Fputc(2, '\n');
4929: -}
4930: -
4931: -static
4932: -cyclechk(n)
4933: - register Node *n;
4934: -{
4935: - register Arc *a;
4936: -
4937: - if((n->flags&CYCLE) && n->prereqs){
4938: - Fprint(2, "mk: cycle in graph detected at target %s\n", n->name);
4939: - Exit();
4940: - }
4941: - n->flags |= CYCLE;
4942: - for(a = n->prereqs; a; a = a->next)
4943: - if(a->n)
4944: - cyclechk(a->n);
4945: - n->flags &= ~CYCLE;
4946: -}
4947: -
4948: -static
4949: -ambiguous(n)
4950: - register Node *n;
4951: -{
4952: - register Arc *a;
4953: - register Rule *r = 0;
4954: - Arc *la;
4955: - int bad = 0;
4956: -
4957: - for(a = n->prereqs; a; a = a->next){
4958: - if(a->n)
4959: - ambiguous(a->n);
4960: - if(*a->r->recipe == 0) continue;
4961: - if(r == 0)
4962: - r = a->r, la = a;
4963: - else{
4964: - if(r->recipe != a->r->recipe){
4965: - if((r->attr&META) && !(a->r->attr&META)){
4966: - la->flag |= TOGO;
4967: - r = a->r, la = a;
4968: - } else if(!(r->attr&META) && (a->r->attr&META)){
4969: - a->flag |= TOGO;
4970: - continue;
4971: - }
4972: - }
4973: - if(r->recipe != a->r->recipe){
4974: - if(bad == 0){
4975: - Fprint(2, "mk: ambiguous recipes for %s:\n", n->name);
4976: - bad = 1;
4977: - trace(n->name, la);
4978: - }
4979: - trace(n->name, a);
4980: - }
4981: - }
4982: - }
4983: - if(bad)
4984: - Exit();
4985: - togo(n);
4986: -}
4987: -
4988: -static
4989: -attribute(n)
4990: - register Node *n;
4991: -{
4992: - register Arc *a;
4993: -
4994: - for(a = n->prereqs; a; a = a->next){
4995: - if(a->r->attr&VIR)
4996: - n->flags |= VIRTUAL;
4997: - if(a->r->attr&NOREC)
4998: - n->flags |= NORECIPE;
4999: - if(a->r->attr&DEL)
5000: - n->flags |= DELETE;
5001: - if(a->n)
5002: - attribute(a->n);
5003: - }
5004: - if(n->flags&VIRTUAL)
5005: - n->time = 0;
5006: -}
5007: //GO.SYSIN DD ./graph.c
5008: echo ./job.c 1>&2
5009: sed 's/.//' >./job.c <<'//GO.SYSIN DD ./job.c'
5010: -#include "mk.h"
5011: -
5012: -Job *
5013: -newjob(r, nlist, stem, match, pre, npre, tar, atar)
5014: - Rule *r;
5015: - Node *nlist;
5016: - char *stem;
5017: - regsubexp *match;
5018: - Word *pre, *npre, *tar, *atar;
5019: -{
5020: - register Job *j;
5021: -
5022: - j = (Job *)Malloc(sizeof(Job));
5023: - j->r = r;
5024: - j->n = nlist;
5025: - j->stem = stem;
5026: - j->match = match;
5027: - j->p = pre;
5028: - j->np = npre;
5029: - j->t = tar;
5030: - j->at = atar;
5031: - j->nproc = -1;
5032: - j->fd = -1;
5033: - j->next = 0;
5034: - return(j);
5035: -}
5036: -
5037: -dumpj(s, j, all)
5038: - char *s;
5039: - Job *j;
5040: -{
5041: - Fprint(1, "%s\n", s);
5042: - while(j){
5043: - Fprint(1, "job@%ld: r=%ld n=%ld stem='%s' nproc=%d\n",
5044: - j, j->r, j->n, j->stem, j->nproc);
5045: - Fprint(1, "\ttarget='%s' alltarget='%s' prereq='%s' nprereq='%s'\n",
5046: - wtos(j->t), wtos(j->at), wtos(j->p), wtos(j->np));
5047: - j = all? j->next : 0;
5048: - }
5049: -}
5050: //GO.SYSIN DD ./job.c
5051: echo ./lex.c 1>&2
5052: sed 's/.//' >./lex.c <<'//GO.SYSIN DD ./lex.c'
5053: -#include "mk.h"
5054: -
5055: -lex(fd, buf)
5056: - char *buf;
5057: -{
5058: - char buf1[BIGBLOCK];
5059: -
5060: - quote1(fd, buf, buf1); /* '..' */
5061: - bquote(fd, buf1, buf); /* `cmd` */
5062: - quote2(fd, buf, buf1); /* ".." and variable expansion */
5063: - strcpy(buf, buf1);
5064: -}
5065: //GO.SYSIN DD ./lex.c
5066: echo ./main.c 1>&2
5067: sed 's/.//' >./main.c <<'//GO.SYSIN DD ./main.c'
5068: -#include "mk.h"
5069: -
5070: -#define MKFILE "mkfile"
5071: -
5072: -static char *version = "@(#)mk general release 3";
5073: -int debug;
5074: -Rule *rules, *metarules;
5075: -int nproclimit;
5076: -int nflag = 0;
5077: -int tflag = 0;
5078: -int iflag = 0;
5079: -int kflag = 0;
5080: -int mflag = 0;
5081: -int aflag = 0;
5082: -int uflag = 0;
5083: -char *explain = 0;
5084: -Word *target1;
5085: -int nreps = 1;
5086: -Job *jobs;
5087: -char *whatif = 0;
5088: -#ifdef PROF
5089: -short buf[10000];
5090: -#endif
5091: -
5092: -main(argc, argv)
5093: - char **argv;
5094: -{
5095: - register Word *w;
5096: - register char *s;
5097: - char *files[256], **f = files, **ff;
5098: - char mkargs[256], *ma = mkargs;
5099: - int i;
5100: - int tfd = -1;
5101: - char *temp = "/tmp/mkargXXXXXX";
5102: -
5103: - *ma = 0;
5104: - for(argv++; *argv && (**argv == '-'); argv++)
5105: - {
5106: - for(s = argv[0]; *s; *ma++ = *s++);
5107: - *ma++ = ' ';
5108: - switch(argv[0][1])
5109: - {
5110: - case 'a':
5111: - aflag = 1;
5112: - break;
5113: - case 'd':
5114: - if(*(s = &argv[0][2]))
5115: - while(*s) switch(*s++)
5116: - {
5117: - case 'p': debug |= D_PARSE; break;
5118: - case 'g': debug |= D_GRAPH; break;
5119: - case 'e': debug |= D_EXEC; break;
5120: - }
5121: - else
5122: - debug = 0xFFFF;
5123: - break;
5124: - case 'e':
5125: - explain = &argv[0][2];
5126: - break;
5127: - case 'f':
5128: - if(*++argv == 0)
5129: - usage();
5130: - *f++ = *argv;
5131: - for(s = argv[0]; *s; *ma++ = *s++);
5132: - *ma++ = ' ';
5133: - break;
5134: - case 'i':
5135: - iflag = 1;
5136: - break;
5137: - case 'k':
5138: - kflag = 1;
5139: - break;
5140: - case 'm':
5141: - mflag = 1;
5142: - aflag = nflag = 1;
5143: - break;
5144: - case 'n':
5145: - nflag = 1;
5146: - break;
5147: - case 't':
5148: - tflag = 1;
5149: - break;
5150: - case 'u':
5151: - uflag = 1;
5152: - break;
5153: - case 'w':
5154: - if(argv[0][2])
5155: - whatif = &argv[0][2];
5156: - else {
5157: - if(*++argv == 0)
5158: - usage();
5159: - whatif = &argv[0][0];
5160: - }
5161: - break;
5162: - default:
5163: - usage();
5164: - }
5165: - }
5166: -#ifdef PROF
5167: - {
5168: - extern etext();
5169: - monitor(main, etext, buf, sizeof buf, 300);
5170: - }
5171: -#endif
5172: -
5173: - if(aflag)
5174: - iflag = 1;
5175: -
5176: - account();
5177: - syminit();
5178: - builtins();
5179: - initenv();
5180: -
5181: - /*
5182: - assignment args become null strings
5183: - */
5184: - for(i = 0; argv[i]; i++) if(strchr(argv[i], '=')){
5185: - for(s = argv[i]; *s; *ma++ = *s++);
5186: - *ma++ = ' ';
5187: - if(tfd < 0){
5188: - mktemp(temp);
5189: - close(creat(temp, 0600));
5190: - if((tfd = open(temp, 2)) < 0){
5191: - perror(temp);
5192: - Exit();
5193: - }
5194: - }
5195: - Fprint(tfd, "%s\n", argv[i]);
5196: - *argv[i] = 0;
5197: - }
5198: - if(tfd >= 0){
5199: - Fflush(tfd);
5200: - lseek(tfd, 0L, 0);
5201: - parse("command line args", tfd, 1, 1);
5202: - unlink(temp);
5203: - }
5204: -
5205: - if(ma != mkargs) ma--;
5206: - *ma = 0;
5207: - symlook("MKFLAGS", S_VAR, strdup(mkargs));
5208: - for(ma = mkargs, i = 0; argv[i]; i++){
5209: - if(*argv[i] == 0) continue;
5210: - if(i) *ma++ = ' ';
5211: - for(s = argv[i]; *s; *ma++ = *s++);
5212: - }
5213: - *ma = 0;
5214: - symlook("MKARGS", S_VAR, strdup(mkargs));
5215: -
5216: - if(f == files){
5217: - if(access(MKFILE, 4) == 0)
5218: - parse(MKFILE, open(MKFILE, 0), 0, 1);
5219: - } else
5220: - for(ff = files; ff < f; ff++)
5221: - parse(*ff, open(*ff, 0), 0, 1);
5222: - parsebuiltins();
5223: - if(DEBUG(D_PARSE)){
5224: - dumpw("default targets", target1);
5225: - dumpr("rules", rules);
5226: - dumpr("metarules", metarules);
5227: - dumpv("variables");
5228: - }
5229: - if(whatif)
5230: - timeinit(whatif);
5231: - execinit();
5232: - /* skip assignment args */
5233: - while(*argv && (**argv == 0))
5234: - argv++;
5235: - sigcatch();
5236: - if(*argv == 0){
5237: - if(target1)
5238: - for(w = target1; w; w = w->next)
5239: - mk(w->s);
5240: - else {
5241: - Fprint(2, "mk: nothing to mk\n");
5242: - Exit();
5243: - }
5244: - } else
5245: - for(; *argv; argv++)
5246: - if(**argv)
5247: - mk(*argv);
5248: - if(uflag)
5249: - praccount();
5250: - if(mflag)
5251: - makefile();
5252: - exit(0);
5253: -}
5254: -
5255: -usage()
5256: -{
5257: -
5258: - Fprint(2, "Usage: mk [-f file] [-n] [-a] [-e] [-t] [-k] [-i] [-d[egp]] [targets ...]\n");
5259: - Exit();
5260: -}
5261: -
5262: -char *
5263: -Malloc(n)
5264: -{
5265: - register char *s;
5266: -
5267: - if(s = malloc(n))
5268: - return(s);
5269: - Fprint(2, "mk: cannot alloc %d bytes\n", n);
5270: - Exit();
5271: - return((char *)0); /* shut cyntax up */
5272: -}
5273: -
5274: -Exit()
5275: -{
5276: - while(wait((int *)0) >= 0)
5277: - ;
5278: - exit(1);
5279: -}
5280: -
5281: -char *
5282: -strndup(s, n)
5283: - char *s;
5284: -{
5285: - register char *goo;
5286: -
5287: - goo = Malloc(n);
5288: - memcpy(goo, s, n);
5289: - return(goo);
5290: -}
5291: -
5292: -initenv()
5293: -{
5294: - extern char **environ;
5295: - register char **p, *s, *ss;
5296: -
5297: - for(p = environ; *p; p++){
5298: - s = shname(*p);
5299: - switch(*s)
5300: - {
5301: - case '=':
5302: - *s = 0;
5303: - ss = strdup(s+1);
5304: - symlook(strdup(*p), S_VAR, ss)->value = ss;
5305: - *s = '=';
5306: - break;
5307: - case 0:
5308: - ss = strdup("");
5309: - symlook(strdup(*p), S_VAR, ss)->value = ss;
5310: - break;
5311: - }
5312: - }
5313: -}
5314: -
5315: -assert(s, n)
5316: - char *s;
5317: -{
5318: - if(!n){
5319: - Fprint(2, "mk: Assertion ``%s'' failed.\n", s);
5320: - Exit();
5321: - }
5322: -}
5323: //GO.SYSIN DD ./main.c
5324: echo ./makefile.c 1>&2
5325: sed 's/.//' >./makefile.c <<'//GO.SYSIN DD ./makefile.c'
5326: -#include "mk.h"
5327: -
5328: -#define FOLD 65
5329: -
5330: -static char *first = 0;
5331: -static didit;
5332: -
5333: -maketarget(s)
5334: - char *s;
5335: -{
5336: - if(first == 0)
5337: - first = s;
5338: -}
5339: -
5340: -addmake(n)
5341: - Node *n;
5342: -{
5343: - symlook(n->name, S_MAKEFILE, (char *)n);
5344: -}
5345: -
5346: -static
5347: -fold(s, sep)
5348: - char *s;
5349: -{
5350: - int i = 0;
5351: -
5352: - while(*s){
5353: - i++;
5354: - if((*s == ' ') && (i > FOLD)){
5355: - Fprint(1, "\\\n%c", sep);
5356: - i = 0;
5357: - } else
5358: - Fputc(1, *s++);
5359: - }
5360: -}
5361: -
5362: -static void
5363: -vd(s)
5364: - register Symtab *s;
5365: -{
5366: - Fprint(1, "%s=", s->name);
5367: - fold(symlook(s->name, S_VAR, (char *)0)->value, ' ');
5368: - Fputc(1, '\n');
5369: -}
5370: -
5371: -#define SUB(s) { register char *ss = s; while(*dest++ = *ss++); dest--; copy = 0; }
5372: -
5373: -static char *
5374: -vexpand(ww, dest, j)
5375: - char **ww, *dest;
5376: - Job *j;
5377: -{
5378: - register char *s, *w = *ww;
5379: - char carry, *q;
5380: - int copy;
5381: -
5382: - assert("vexpand no $", *w == '$');
5383: - if(*++w == '{'){
5384: - for(s = ++w; *s != '}'; s++)
5385: - if(*s == 0) break;
5386: - } else
5387: - s = shname(w);
5388: - carry = *s;
5389: - *s = 0;
5390: - copy = 1;
5391: - if(!symlook(w, S_MAKEVAR, (char *)0)){
5392: - if(strcmp(w, "target") == 0){
5393: - SUB("$?")
5394: - } else if(strcmp(w, "stem") == 0){
5395: - SUB(j->stem)
5396: - } else if(strcmp(w, "prereq") == 0){
5397: - SUB("$@")
5398: - } else if(strcmp(w, "pid") == 0){
5399: - SUB("$$$$")
5400: - } else if(strcmp(w, "newprereq") == 0){
5401: - SUB(wtos(j->np))
5402: - } else if(strcmp(w, "alltarget") == 0){
5403: - SUB(wtos(j->at))
5404: - Fprint(2, "Warning; $alltarget expanded to '%s'\n", wtos(j->at));
5405: - } else if((strncmp(w, "stem", 4) == 0) && (w[4] >= '0') && (w[4] <= '9')){
5406: - int i = w[4] - '0';
5407: - int nb = j->match[i].ep - j->match[i].sp;
5408: -
5409: - memcpy(dest, j->match[i].sp, nb);
5410: - dest += nb;
5411: - } else {
5412: - SUB("1");
5413: - Fprint(2, "Warning; $%s expanded to 1\n", w);
5414: - }
5415: - }
5416: - if(copy){
5417: - *dest++ = '$';
5418: - *dest++ = '{';
5419: - for(q = w; q != s;)
5420: - *dest++ = *q++;
5421: - *dest++ = '}';
5422: - }
5423: - *s = carry;
5424: - if(carry == '}')
5425: - s++;
5426: - *ww = s;
5427: - return(dest);
5428: -}
5429: -
5430: -static
5431: -recipepr(s, j)
5432: - char *s;
5433: - Job *j;
5434: -{
5435: - char buf[BIGBLOCK];
5436: - register char *q = buf;
5437: -
5438: - while(*s)
5439: - switch(*s)
5440: - {
5441: - case '\\':
5442: - *q++ = *s++;
5443: - *q++ = *s++;
5444: - break;
5445: - case '$':
5446: - q = vexpand(&s, q, j);
5447: - break;
5448: - case '\n':
5449: - *q = 0;
5450: - Fprint(1, "\t%s\n", buf);
5451: - q = buf;
5452: - s++;
5453: - break;
5454: - default:
5455: - *q++ = *s++;
5456: - break;
5457: - }
5458: - *q = 0;
5459: - if(q != buf)
5460: - Fprint(1, "\t%s\n", buf);
5461: -}
5462: -
5463: -static void
5464: -nd(s)
5465: - Symtab *s;
5466: -{
5467: - Job *j = (Job *)s->value;
5468: - register Node *n = j->n;
5469: - Arc *a;
5470: - int i;
5471: - char *ss, *s, c;
5472: -
5473: - if(strcmp(n->name, first) == 0){
5474: - if(didit)
5475: - return;
5476: - didit = 1;
5477: - }
5478: - Fprint(1, "\n%s:", n->name);
5479: - fold(wtos(j->p), ' ');
5480: - Fputc(1, '\n');
5481: - recipepr(j->r->recipe, j);
5482: -}
5483: -
5484: -makefile()
5485: -{
5486: - symtraverse(S_MAKEVAR, vd);
5487: - didit = 0;
5488: - nd(symlook(first, S_MAKEFILE, (char *)0));
5489: - symtraverse(S_MAKEFILE, nd);
5490: -}
5491: //GO.SYSIN DD ./makefile.c
5492: echo ./match.c 1>&2
5493: sed 's/.//' >./match.c <<'//GO.SYSIN DD ./match.c'
5494: -#include "mk.h"
5495: -
5496: -mninlist(name, list, stem)
5497: - register char *name, *stem;
5498: - Word *list;
5499: -{
5500: - for(; list; list = list->next){
5501: - if(match(name, list->s, stem))
5502: - return(1);
5503: - }
5504: - return(0);
5505: -}
5506: -
5507: -static
5508: -isatomic(p)
5509: - char *p;
5510: -{
5511: - while(*p){
5512: - if((*p == '.') || (*p == '/'))
5513: - return(0);
5514: - p++;
5515: - }
5516: - return(1);
5517: -}
5518: -
5519: -match(name, template, stem)
5520: - char *name, *template, *stem;
5521: -{
5522: - register char *p, *q;
5523: - char *b;
5524: - char *ostem = stem;
5525: -
5526: - for(p = name, q = template; *p && *q && !PERCENT(*q);)
5527: - if(*p++ != *q++) return(0);
5528: - if(!PERCENT(*q))
5529: - return(0);
5530: - b = p;
5531: - while(*p) p++;
5532: - while(*q) q++;
5533: - for(q--; !PERCENT(*q); q--)
5534: - if(*--p != *q) return(0);
5535: - while(b < p)
5536: - *stem++ = *b++;
5537: - *stem = 0;
5538: - if(*q == '&')
5539: - return(isatomic(ostem));
5540: - return(1);
5541: -}
5542: -
5543: -subst(stem, template, dest)
5544: - register char *stem, *template, *dest;
5545: -{
5546: - while(*template){
5547: - if(PERCENT(*template)){
5548: - template++;
5549: - while(*stem)
5550: - *dest++ = *stem++;
5551: - } else
5552: - *dest++ = *template++;
5553: - }
5554: - *dest = 0;
5555: -}
5556: //GO.SYSIN DD ./match.c
5557: echo ./mk.c 1>&2
5558: sed 's/.//' >./mk.c <<'//GO.SYSIN DD ./mk.c'
5559: -#include "mk.h"
5560: -
5561: -int runerrs;
5562: -
5563: -mk(target)
5564: - char *target;
5565: -{
5566: - Node *node;
5567: - int did = 0;
5568: -
5569: - nproc(); /* it can be updated dynamically */
5570: - nrep(); /* it can be updated dynamically */
5571: - runerrs = 0;
5572: - if(mflag)
5573: - maketarget(target);
5574: - node = graph(target);
5575: - if(DEBUG(D_GRAPH)){
5576: - dumpn("new target\n", node);
5577: - Fflush(1);
5578: - }
5579: - clrmade(node);
5580: - while(node->flags&NOTMADE){
5581: - if(work(node, (Node *)0, (Arc *)0))
5582: - did = 1; /* found something to do */
5583: - else {
5584: - if(waitup(1, (int *)0) > 0){
5585: - if(node->flags&(NOTMADE|BEINGMADE)){
5586: - assert("must be run errors", runerrs);
5587: - break; /* nothing more waiting */
5588: - }
5589: - }
5590: - }
5591: - }
5592: - if(node->flags&BEINGMADE)
5593: - waitup(-1, (int *)0);
5594: - while(jobs)
5595: - waitup(-2, (int *)0);
5596: - assert("target didn't get done", runerrs || (node->flags&MADE));
5597: - if(did == 0)
5598: - Fprint(1, "mk: '%s' is up to date\n", node->name);
5599: -}
5600: -
5601: -clrmade(n)
5602: - register Node *n;
5603: -{
5604: - register Arc *a;
5605: -
5606: - n->flags &= ~(CANPRETEND|PRETENDING);
5607: - n->flags |= CANPRETEND;
5608: - MADESET(n, NOTMADE);
5609: - for(a = n->prereqs; a; a = a->next)
5610: - if(a->n)
5611: - clrmade(a->n);
5612: -}
5613: -
5614: -static void
5615: -unpretend(n)
5616: - register Node *n;
5617: -{
5618: - MADESET(n, NOTMADE);
5619: - n->flags &= ~(CANPRETEND|PRETENDING);
5620: - n->time = 0;
5621: -}
5622: -
5623: -work(node, p, parc)
5624: - Node *node, *p;
5625: - Arc *parc;
5626: -{
5627: - register Arc *a, *ra;
5628: - int weoutofdate;
5629: - int ready;
5630: - int did = 0;
5631: -
5632: -/* print("work(%s) flags=0x%x time=%ld\n", node->name, node->flags, node->time);/**/
5633: - if(node->flags&BEINGMADE)
5634: - return(did);
5635: - if((node->flags&MADE) && (node->flags&PRETENDING) && p && outofdate(p, parc, 0)){
5636: - if(explain)
5637: - fprint(1, "unpretending %s(%ld) because %s is out of date(%ld)\n",
5638: - node->name, node->time, p->name, p->time);
5639: - unpretend(node);
5640: - }
5641: - /*
5642: - have a look if we are pretending in case
5643: - someone has been unpretended out from underneath us
5644: - */
5645: - if(node->flags&MADE){
5646: - if(node->flags&PRETENDING){
5647: - node->time = 0;
5648: - }else
5649: - return(did);
5650: - }
5651: - /* consider no prerequsite case */
5652: - if(node->prereqs == 0){
5653: - if(node->time == 0){
5654: - Fprint(2, "mk: don't know how to make '%s'\n", node->name);
5655: - if(kflag){
5656: - node->flags |= BEINGMADE;
5657: - runerrs++;
5658: - } else
5659: - Exit();
5660: - } else
5661: - MADESET(node, MADE);
5662: - return(did);
5663: - }
5664: - /*
5665: - now see if we are out of date or what
5666: - */
5667: - ready = 1;
5668: - weoutofdate = aflag;
5669: - ra = 0;
5670: - for(a = node->prereqs; a; a = a->next)
5671: - if(a->n){
5672: - did = work(a->n, node, a) || did;
5673: - if(a->n->flags&(NOTMADE|BEINGMADE))
5674: - ready = 0;
5675: - if(outofdate(node, a, 0)){
5676: - weoutofdate = 1;
5677: - if((ra == 0) || (ra->n == 0)
5678: - || (ra->n->time < a->n->time))
5679: - ra = a;
5680: - }
5681: - } else {
5682: - if(node->time == 0){
5683: - if(ra == 0)
5684: - ra = a;
5685: - weoutofdate = 1;
5686: - }
5687: - }
5688: - if(ready == 0) /* can't do anything now */
5689: - return(did);
5690: - if(weoutofdate == 0){
5691: - MADESET(node, MADE);
5692: - return(did);
5693: - }
5694: - /*
5695: - can we pretend to be made?
5696: - */
5697: - if((iflag == 0) && (node->time == 0) && (node->flags&(PRETENDING|CANPRETEND)) && p && ra->n && !outofdate(p, ra, 0)){
5698: - node->flags &= ~CANPRETEND;
5699: - MADESET(node, MADE);
5700: - node->time = ra->n->time;
5701: - if(explain && ((node->flags&PRETENDING) == 0))
5702: - fprint(1, "pretending %s has time %ld\n", node->name, node->time);
5703: - node->flags |= PRETENDING;
5704: - return(did);
5705: - }
5706: - /*
5707: - node is out of date and we REALLY do have to do something.
5708: - quickly rescan for pretenders
5709: - */
5710: - for(a = node->prereqs; a; a = a->next)
5711: - if(a->n && (a->n->flags&PRETENDING)){
5712: - if(explain)
5713: - Fprint(1, "unpretending %s because of %s because of %s\n",
5714: - a->n->name, node->name, ra->n? ra->n->name : "rule with no prerequisites");
5715: -
5716: - unpretend(a->n);
5717: - did = work(a->n, node, a) || did;
5718: - ready = 0;
5719: - }
5720: - if(ready == 0) /* try later unless nothing has happened for -k's sake */
5721: - return(did || work(node, p, parc));
5722: - did = dorecipe(node) || did;
5723: - return(did);
5724: -}
5725: -
5726: -update(fake, node)
5727: - register Node *node;
5728: -{
5729: - register Arc *a;
5730: -
5731: - MADESET(node, fake? BEINGMADE : MADE);
5732: - if(((node->flags&VIRTUAL) == 0) && (access(node->name, 0) == 0)){
5733: - node->time = timeof(node->name, 1);
5734: - node->flags &= ~(CANPRETEND|PRETENDING);
5735: - for(a = node->prereqs; a; a = a->next)
5736: - if(a->prog)
5737: - (void)outofdate(node, a, 1);
5738: - } else {
5739: - node->time = 1;
5740: - for(a = node->prereqs; a; a = a->next)
5741: - if(a->n && outofdate(node, a, 1))
5742: - node->time = a->n->time;
5743: - }
5744: -/* print("----node %s time=%ld flags=0x%x\n", node->name, node->time, node->flags);/**/
5745: -}
5746: -
5747: -static
5748: -pcmp(prog, n1, n2)
5749: - char *prog, *n1, *n2;
5750: -{
5751: - char buf[3*NAMEBLOCK];
5752: - int ret, pid;
5753: -
5754: - pid = fork();
5755: - if(pid < 0){
5756: - fprint(2, "mk: ");
5757: - perror("pcmp fork");
5758: - Exit();
5759: - }
5760: - Fexit(0);
5761: - if(pid == 0){
5762: - sprint(buf, "%s '%s' '%s'", prog, n1, n2);
5763: - execl(SHELL, "sh", "-c", buf, (char *)0);
5764: - sprint(buf, "exec %s", SHELL);
5765: - perror(buf);
5766: - _exit(1);
5767: - } else {
5768: - while(waitup(-3, &pid) >= 0)
5769: - ;
5770: - return(pid? 2:1);
5771: - }
5772: -}
5773: -
5774: -
5775: -outofdate(node, arc, eval)
5776: - register Node *node;
5777: - register Arc *arc;
5778: -{
5779: - char buf[3*NAMEBLOCK], *str;
5780: - Symtab *sym;
5781: - int ret;
5782: -
5783: - if(arc->prog){
5784: - sprint(buf, "%s%c%s", node->name, 0377, arc->n->name);
5785: - if(!(sym = symlook(buf, S_OUTOFDATE, (char *)0)) || eval){
5786: - if(!sym)
5787: - str = strdup(buf);
5788: - ret = pcmp(arc->prog, node->name, arc->n->name);
5789: - if(sym)
5790: - sym->value = (char *)ret;
5791: - else
5792: - symlook(str, S_OUTOFDATE, (char *)ret);
5793: - } else
5794: - ret = (int)sym->value;
5795: - return(ret-1);
5796: - } else
5797: - return(node->time < arc->n->time);
5798: -}
5799: -
5800: //GO.SYSIN DD ./mk.c
5801: echo ./mk.h 1>&2
5802: sed 's/.//' >./mk.h <<'//GO.SYSIN DD ./mk.h'
5803: -#include "libc.h"
5804: -#include "fio.h"
5805: -#include "regexp.h"
5806: -
5807: -typedef struct Word
5808: -{
5809: - char *s;
5810: - struct Word *next;
5811: -} Word;
5812: -extern Word *newword(), *expand(), *wsubst(), *stow();
5813: -
5814: -typedef struct Rule
5815: -{
5816: - char *target; /* one target */
5817: - Word *tail; /* constituents of targets */
5818: - char *recipe; /* do it ! */
5819: - short attr; /* attributes */
5820: - short line; /* source line */
5821: - char *file; /* source file */
5822: - Word *alltargets; /* all the targets */
5823: - int rule; /* rule number */
5824: - regexp *pat; /* reg exp goo */
5825: - char *prog; /* to use in out of date */
5826: - struct Rule *chain; /* hashed per target */
5827: - struct Rule *next;
5828: -} Rule;
5829: -extern Rule *rules, *metarules, *patrule;
5830: -
5831: -#define META 0x0001
5832: -#define SEQ 0x0002
5833: -#define UPD 0x0004
5834: -#define RED 0x0008
5835: -#define QUIET 0x0010
5836: -#define VIR 0x0020
5837: -#define REGEXP 0x0040
5838: -#define NOREC 0x0080
5839: -#define DEL 0x0100
5840: -
5841: -#define NREGEXP 10
5842: -
5843: -typedef struct Arc
5844: -{
5845: - short flag;
5846: - struct Node *n;
5847: - Rule *r;
5848: - char *stem;
5849: - char *prog;
5850: - regsubexp match[NREGEXP];
5851: - struct Arc *next;
5852: -} Arc;
5853: -extern Arc *newarc();
5854: -#define TOGO 1
5855: -
5856: -typedef struct Node
5857: -{
5858: - char *name;
5859: - long time;
5860: - unsigned short flags;
5861: - Arc *prereqs;
5862: - struct Node *next; /* list for a rule */
5863: -} Node;
5864: -extern Node *graph();
5865: -#define VIRTUAL 0x0001
5866: -#define CYCLE 0x0002
5867: -#define READY 0x0004
5868: -#define CANPRETEND 0x0008
5869: -#define PRETENDING 0x0010
5870: -#define NOTMADE 0x0020
5871: -#define BEINGMADE 0x0040
5872: -#define MADE 0x0080
5873: -#define MADESET(n,m) n->flags = (n->flags&~(NOTMADE|BEINGMADE|MADE))|(m)
5874: -#define PROBABLE 0x0100
5875: -#define VACUOUS 0x0200
5876: -#define NORECIPE 0x0400
5877: -#define DELETE 0x0800
5878: -
5879: -typedef struct Job
5880: -{
5881: - Rule *r; /* master rule for job */
5882: - Node *n; /* list of node targets */
5883: - char *stem;
5884: - regsubexp *match;
5885: - Word *p; /* prerequisites */
5886: - Word *np; /* new prerequisites */
5887: - Word *t; /* targets */
5888: - Word *at; /* all targets */
5889: - int nproc; /* slot number */
5890: - int fd; /* if redirecting */
5891: - struct Job *next;
5892: -} Job;
5893: -extern Job *newjob(), *jobs;
5894: -
5895: -typedef struct Symtab
5896: -{
5897: - short space;
5898: - char *name;
5899: - char *value;
5900: - struct Symtab *next;
5901: -} Symtab;
5902: -extern Symtab *symlook();
5903: -enum {
5904: - S_VAR, /* variable -> value */
5905: - S_TARGET, /* target -> rule */
5906: - S_TIME, /* file -> time */
5907: - S_PID, /* pid -> products */
5908: - S_NODE, /* target name -> node */
5909: - S_AGG, /* aggregate -> time */
5910: - S_BITCH, /* bitched about aggregate not there */
5911: - S_NOEXPORT, /* var -> noexport */
5912: - S_OVERRIDE, /* can't override */
5913: - S_OUTOFDATE, /* n1\377n2 -> 2(outofdate) or 1(not outofdate) */
5914: - S_MAKEFILE, /* target -> node */
5915: - S_MAKEVAR, /* dumpable mk variable */
5916: -};
5917: -
5918: -extern int debug;
5919: -extern int nflag, tflag, iflag, kflag, aflag, mflag;
5920: -extern int inline;
5921: -extern char *infile;
5922: -extern char *Malloc(), *strndup();
5923: -extern long timeof();
5924: -extern void touch(), delete();
5925: -extern char *shname(), *vexpand();
5926: -extern int nproclimit;
5927: -extern int nreps;
5928: -extern char *explain;
5929: -extern char *envpr(), *wtos();
5930: -extern char *rulecnt();
5931: -
5932: -#define SYNERR(l) (Fprint(2, "mk: %s:%d: syntax error; ", infile, (((l)>=0)?(l):inline)))
5933: -#define RERR(r) (Fprint(2, "mk: %s:%d: rule error; ", (r)->file, (r)->line))
5934: -#define NAMEBLOCK 1000
5935: -#define BIGBLOCK 20000
5936: -
5937: -#ifndef SHELL
5938: -#define SHELL "/bin/sh" /* should be bourne-like */
5939: -#endif
5940: -
5941: -#define SEP(c) (((c)==' ')||((c)=='\t')||((c)=='\n'))
5942: -
5943: -#define DEBUG(x) (debug&(x))
5944: -#define D_PARSE 0x01
5945: -#define D_GRAPH 0x02
5946: -#define D_EXEC 0x04
5947: -
5948: -#define EBIT 0x80 /* sorry japan */
5949: -
5950: -#define PERCENT(ch) (((ch) == '%') || ((ch) == '&'))
5951: //GO.SYSIN DD ./mk.h
5952: echo ./parse.c 1>&2
5953: sed 's/.//' >./parse.c <<'//GO.SYSIN DD ./parse.c'
5954: -#include "mk.h"
5955: -
5956: -char *infile;
5957: -int inline;
5958: -static longline();
5959: -extern Word *target1;
5960: -
5961: -parse(f, fd, varoverride, ruleoverride)
5962: - char *f;
5963: -{
5964: - int hline;
5965: - char *s, *body;
5966: - Word *head, *tail;
5967: - int attr, set;
5968: - char *prog, *inc;
5969: -
5970: - if(fd < 0){
5971: - perror(f);
5972: - Exit();
5973: - }
5974: - ipush();
5975: - infile = strdup(f);
5976: - inline = 1;
5977: - Finit(fd, (char *)0);
5978: - while(s = Frdline(fd)){
5979: - if((*s == '#') || (*s == 0)){
5980: - inline++;
5981: - continue;
5982: - }
5983: - hline = inline;
5984: - switch(rhead(s, fd, &head, &tail, &attr, &prog))
5985: - {
5986: - case '<':
5987: - if((tail == 0) || ((inc = wtos(tail)) == 0)){
5988: - SYNERR(-1);
5989: - Fprint(2, "missing include file name\n");
5990: - Exit();
5991: - }
5992: - parse(inc, open(inc, 0), 0, 1);
5993: - break;
5994: - case ':':
5995: - rbody(fd, &body);
5996: - addrules(head, tail, body, attr, hline, ruleoverride, prog);
5997: - break;
5998: - case '=':
5999: - if(head->next){
6000: - SYNERR(-1);
6001: - Fprint(2, "multiple vars on left side of assignment\n");
6002: - Exit();
6003: - }
6004: - if(symlook(head->s, S_OVERRIDE, (char *)0)){
6005: - set = varoverride;
6006: - symdel(head->s, S_OVERRIDE);
6007: - } else {
6008: - set = 1;
6009: - if(varoverride)
6010: - symlook(head->s, S_OVERRIDE, "");
6011: - }
6012: - if(set)
6013: - setvar(head->s, wtos(tail));
6014: - if(attr)
6015: - (void)symlook(head->s, S_NOEXPORT, "");
6016: - break;
6017: - default:
6018: - SYNERR(hline);
6019: - Fprint(2, "expected : or =\n");
6020: - Exit();
6021: - break;
6022: - }
6023: - }
6024: - close(fd);
6025: - ipop();
6026: -}
6027: -
6028: -addrules(head, tail, body, attr, hline, override, prog)
6029: - Word *head, *tail;
6030: - char *body, *prog;
6031: -{
6032: - register Word *w;
6033: -
6034: - assert("addrules args", head && body);
6035: - if((target1 == 0) && !(attr®EXP))
6036: - frule(head);
6037: - for(w = head; w; w = w->next)
6038: - addrule(w->s, tail, body, head, attr, hline, override, prog);
6039: -}
6040: -
6041: -rhead(s, fd, h, t, attr, prog)
6042: - char *s;
6043: - Word **h, **t;
6044: - int *attr;
6045: - char **prog;
6046: -{
6047: - char buf[BIGBLOCK];
6048: - register char *p;
6049: - char *pp;
6050: - int sep;
6051: -
6052: - longline(fd, s, buf); /* cover \\n guys */
6053: - lex(fd, buf);
6054: - if(p = strchr(buf, '#')) /* comment ? */
6055: - *p = 0;
6056: - for(p = buf; *p; p++)
6057: - if((*p == ':') || (*p == '=') || (*p == '<')) break;
6058: - if(*p == 0){
6059: - return('?');
6060: - }
6061: - sep = *p;
6062: - *p++ = 0;
6063: - *attr = 0;
6064: - *prog = 0;
6065: - if(sep == '='){
6066: - char *le, *e;
6067: -
6068: - le = strchr(p, ' ');
6069: - if(e = strchr(p, '\t'))
6070: - if((le == 0) || (e < le))
6071: - le = e;
6072: - if((e = strchr(p, '=')) && ((le == 0) || (e < le))){
6073: - while(*p != '='){
6074: - switch(*p++)
6075: - {
6076: - case 0:
6077: - SYNERR(-1);
6078: - Fprint(2, "missing trailing =\n");
6079: - Exit();
6080: - default:
6081: - SYNERR(-1);
6082: - Fprint(2, "unknown attribute '%c'\n", p[-1]);
6083: - Exit();
6084: - case 'U':
6085: - *attr = 1;
6086: - break;
6087: - }
6088: - }
6089: - p++;
6090: - }
6091: - }
6092: - if((sep == ':') && *p && (*p != ' ') && (*p != '\t')){
6093: - while(*p != ':')
6094: - switch(*p++)
6095: - {
6096: - case 0:
6097: - eos:
6098: - SYNERR(-1);
6099: - Fprint(2, "missing trailing :\n");
6100: - Exit();
6101: - default:
6102: - SYNERR(-1);
6103: - Fprint(2, "unknown attribute '%c'\n", p[-1]);
6104: - Exit();
6105: - case '<':
6106: - *attr |= RED;
6107: - break;
6108: - case 'D':
6109: - *attr |= DEL;
6110: - break;
6111: - case 'N':
6112: - *attr |= NOREC;
6113: - break;
6114: - case 'P':
6115: - pp = p;
6116: - while(*p && (*p != ':'))
6117: - p++;
6118: - if(*p == 0)
6119: - goto eos;
6120: - *p = 0;
6121: - *prog = strdup(pp);
6122: - *p = ':';
6123: - break;
6124: - case 'Q':
6125: - *attr |= QUIET;
6126: - break;
6127: - case 'R':
6128: - *attr |= REGEXP;
6129: - break;
6130: - case 'U':
6131: - *attr |= UPD;
6132: - break;
6133: - case 'V':
6134: - *attr |= VIR;
6135: - break;
6136: - }
6137: - p++;
6138: - }
6139: - *h = expand(buf);
6140: - if((*h == 0) && (sep != '<')){
6141: - SYNERR(inline-1);
6142: - Fprint(2, "no var on left side of assignment/rule\n");
6143: - Exit();
6144: - }
6145: - while((*p == ' ') || (*p == '\t'))
6146: - p++;
6147: - *t = expand(p);
6148: - return(sep);
6149: -}
6150: -
6151: -rbody(fd, b)
6152: - char **b;
6153: -{
6154: - char buf[BIGBLOCK];
6155: - char *cp, *s;
6156: - register n;
6157: -
6158: - cp = buf;
6159: - while(s = Frdline(fd)){
6160: - inline++;
6161: - if((*s != '\t') && (*s != ' ')){
6162: - inline--;
6163: - Fundo(fd);
6164: - break;
6165: - }
6166: - memcpy(cp, s+1, n = FIOLINELEN(fd)-1);
6167: - cp += n;
6168: - *cp++ = '\n';
6169: - }
6170: - *cp++ = 0;
6171: - assert("rbody overflow", cp <= &buf[BIGBLOCK]);
6172: - *b = (buf[0])? strndup(buf, (int)(cp-buf)) : strdup("");
6173: -}
6174: -
6175: -static
6176: -longline(fd, line, dest)
6177: - register char *line, *dest;
6178: -{
6179: - for(;;){
6180: - inline++;
6181: - while(*dest++ = *line++);
6182: - dest -= 2;
6183: - if(*dest == '\\'){
6184: - *dest = 0;
6185: - if((line = Frdline(fd)) == 0){
6186: - Fundo(fd);
6187: - break;
6188: - }
6189: - } else
6190: - break;
6191: - }
6192: -}
6193: -
6194: -struct input
6195: -{
6196: - char *file;
6197: - int line;
6198: - struct input *next;
6199: -};
6200: -static struct input *inputs = 0;
6201: -
6202: -ipush()
6203: -{
6204: - register struct input *in, *me;
6205: -
6206: - me = (struct input *)Malloc(sizeof(*me));
6207: - me->file = infile;
6208: - me->line = inline;
6209: - me->next = 0;
6210: - if(inputs == 0)
6211: - inputs = me;
6212: - else {
6213: - for(in = inputs; in->next; )
6214: - in = in->next;
6215: - in->next = me;
6216: - }
6217: -}
6218: -
6219: -ipop()
6220: -{
6221: - register struct input *in, *me;
6222: -
6223: - assert("pop input list", inputs != 0);
6224: - if(inputs->next == 0){
6225: - me = inputs;
6226: - inputs = 0;
6227: - } else {
6228: - for(in = inputs; in->next->next; )
6229: - in = in->next;
6230: - me = in->next;
6231: - in->next = 0;
6232: - }
6233: - infile = me->file;
6234: - inline = me->line;
6235: - free((char *)me);
6236: -}
6237: //GO.SYSIN DD ./parse.c
6238: echo ./quote.c 1>&2
6239: sed 's/.//' >./quote.c <<'//GO.SYSIN DD ./quote.c'
6240: -#include "mk.h"
6241: -
6242: -/*
6243: - quoted stuff gets EBIT
6244: -*/
6245: -
6246: -static
6247: -squote(fd, srcp, destp)
6248: - char **srcp, **destp;
6249: -{
6250: - register char *src = *srcp, *dest = *destp;
6251: -
6252: - while(*src != '\''){
6253: - if(*src == 0){
6254: - char *s;
6255: -
6256: - if(s = Frdline(fd)){
6257: - inline++;
6258: - *dest++ = '\n'|EBIT;
6259: - strcpy(src, s);
6260: - continue;
6261: - } else {
6262: - SYNERR(-1); Fprint(2, "missing closing '\n");
6263: - break;
6264: - }
6265: - }
6266: - *dest++ = *src++|EBIT;
6267: - }
6268: - *dest = 0;
6269: - if(*src)
6270: - src++;
6271: - *srcp = src;
6272: - *destp = dest;
6273: -}
6274: -
6275: -static
6276: -dquote(fd, src, dest)
6277: - char **src, **dest;
6278: -{
6279: - char *p = *src, *s = *dest;
6280: - char *t, carry;
6281: - Symtab *sym;
6282: -
6283: - while(*p != '"'){
6284: - switch(*p)
6285: - {
6286: - case 0:
6287: - if(t = Frdline(fd)){
6288: - inline++;
6289: - *s++ = '\n'|EBIT;
6290: - strcpy(p, t);
6291: - continue;
6292: - } else {
6293: - SYNERR(-1); Fprint(2, "missing closing \"\n");
6294: - break;
6295: - }
6296: - break;
6297: - case '\\':
6298: - switch(*++p)
6299: - {
6300: - default:
6301: - *s++ = '\\'|EBIT;
6302: - case '\\': case '"':
6303: - case '\'': case '$':
6304: - *s++ = *p|EBIT;
6305: - }
6306: - p++;
6307: - break;
6308: - case '$':
6309: - varsub(&p, &s, EBIT);
6310: - break;
6311: - default:
6312: - *s++ = *p++|EBIT;
6313: - }
6314: - }
6315: - *s = 0;
6316: - if(*p)
6317: - p++;
6318: - *src = p;
6319: - *dest = s;
6320: -}
6321: -
6322: -quote1(fd, src, dest)
6323: - char *src, *dest;
6324: -{
6325: - char *t;
6326: -
6327: - while(*src){
6328: - switch(*src)
6329: - {
6330: - case '\'':
6331: - src++;
6332: - squote(fd, &src, &dest);
6333: - break;
6334: - case '\\':
6335: - if(src[1]){
6336: - *dest++ = *++src | EBIT;
6337: - src++;
6338: - } else if(t = Frdline(fd)){
6339: - inline++;
6340: - strcpy(src, t);
6341: - }
6342: - break;
6343: - default:
6344: - *dest++ = *src++;
6345: - }
6346: - }
6347: - *dest = 0;
6348: -}
6349: -
6350: -quote2(fd, src, dest)
6351: - char *src, *dest;
6352: -{
6353: - char *t;
6354: -
6355: - while(*src){
6356: - switch(*src)
6357: - {
6358: - case '"':
6359: - src++;
6360: - dquote(fd, &src, &dest);
6361: - break;
6362: - case '\\':
6363: - if(src[1]){
6364: - *dest++ = *++src;
6365: - src++;
6366: - } else if(t = Frdline(fd)){
6367: - inline++;
6368: - strcpy(src, t);
6369: - }
6370: - break;
6371: - case '$':
6372: - varsub(&src, &dest, 0);
6373: - break;
6374: - default:
6375: - *dest++ = *src++;
6376: - }
6377: - }
6378: - *dest = 0;
6379: -}
6380: -
6381: -static char *
6382: -subsub(val, ext, dest, bit)
6383: - char *val, *ext, *dest;
6384: -{
6385: - register char *s;
6386: - char *a, *b, *c, *d;
6387: - int na, nb, nc, nd, n;
6388: - int destsub = 0;
6389: -
6390: - /* prepare literals */
6391: - a = s = ext;
6392: - for(; *s && (*s != '=') && !PERCENT(*s); s++)
6393: - ;
6394: - na = s-a;
6395: - if(PERCENT(*s)) s++;
6396: - b = s;
6397: - for(; *s && (*s != '='); s++)
6398: - ;
6399: - nb = s-b;
6400: - if(*s == '=') s++;
6401: - c = s;
6402: - for(; *s && !PERCENT(*s); s++)
6403: - ;
6404: - nc = s-c;
6405: - if(PERCENT(*s)) s++, destsub = 1;
6406: - d = s;
6407: - for(; *s; s++)
6408: - ;
6409: - nd = s-d;
6410: - /* break into words, do sub */
6411: - while(*val){
6412: - for(s = val; *s && !SEP(*s); s++)
6413: - ;
6414: - /* substitute in val..s */
6415: - if((memcmp(val, a, na) == 0) && (memcmp(s-nb, b, nb) == 0)){
6416: -#define DEST(s,n) if(n) memcpy(dest,s,n), dest += n
6417: - DEST(c, nc);
6418: - n = (s-nb) - (val+na);
6419: - if(destsub)
6420: - DEST(val+na, n);
6421: - DEST(d, nd);
6422: - } else
6423: - while(val < s)
6424: - *dest++ = (*val++&~EBIT)|bit;
6425: - /* clean up */
6426: - while(*s && SEP(*s))
6427: - *dest++ = (*s++&~EBIT)|bit;
6428: - val = s;
6429: - }
6430: - return(dest);
6431: -}
6432: -
6433: -varsub(psrc, pdest, bit)
6434: - char **psrc, **pdest;
6435: -{
6436: - char *t, carry;
6437: - Symtab *sym;
6438: - char *src = *psrc, *dest = *pdest;
6439: - char *v = 0, vc;
6440: -
6441: - if(*++src == '{'){
6442: - for(t = ++src; *src != '}'; src++)
6443: - if(*src == 0){
6444: - SYNERR(-1);
6445: - Fprint(2, "missing '}'\n");
6446: - Exit();
6447: - }
6448: - v = shname(t);
6449: - if(src == v)
6450: - v = 0;
6451: - else {
6452: - if(*v != ':'){
6453: - SYNERR(-1);
6454: - Fprint(2, "bad variable name\n");
6455: - Exit();
6456: - }
6457: - vc = *v;
6458: - *v = 0;
6459: - }
6460: - *src++ = carry = 0;
6461: - } else {
6462: - src = shname(t = src);
6463: - carry = *src;
6464: - *src = 0;
6465: - }
6466: - if(sym = symlook(t, S_VAR, (char *)0)){
6467: - if(v){
6468: -char buf[BIGBLOCK]; strcpy(buf, v+1); lex(-1, buf);
6469: - dest = subsub(sym->value, buf, dest, bit);
6470: - *v = vc;
6471: - } else
6472: - for(t = sym->value; *t; )
6473: - *dest++ = *t++|bit;
6474: - }
6475: - if(carry)
6476: - *src = carry;
6477: - *psrc = src;
6478: - *pdest = dest;
6479: -}
6480: //GO.SYSIN DD ./quote.c
6481: echo ./recipe.c 1>&2
6482: sed 's/.//' >./recipe.c <<'//GO.SYSIN DD ./recipe.c'
6483: -#include "mk.h"
6484: -
6485: -dorecipe(node)
6486: - Node *node;
6487: -{
6488: - char buf[BIGBLOCK];
6489: - register Node *n;
6490: - Rule *r = 0;
6491: - Arc *a, *aa;
6492: - Word head, ahead, lp, ln, *w, *ww, *aw;
6493: - Symtab *s;
6494: - int did = 0;
6495: - regexp rmatch[NREGEXP];
6496: -
6497: - /*
6498: - pick up the rule
6499: - */
6500: - for(a = node->prereqs; a; a = a->next)
6501: - if(*a->r->recipe)
6502: - r = (aa = a)->r;
6503: - /*
6504: - no recipe? go to buggery!
6505: - */
6506: - if(r == 0){
6507: - if(!(node->flags&VIRTUAL) && !(node->flags&NORECIPE)){
6508: - Fprint(2, "mk: no recipe to make '%s'\n", node->name);
6509: - Exit();
6510: - }
6511: - update(0, node);
6512: - if(tflag){
6513: - if(!(node->flags&VIRTUAL))
6514: - touch(node->name);
6515: - else if(explain)
6516: - Fprint(1, "no touch of virtual '%s'\n", node->name);
6517: - }
6518: - return(did);
6519: - }
6520: - /*
6521: - build the node list
6522: - */
6523: - node->next = 0;
6524: - head.next = 0;
6525: - ww = &head;
6526: - ahead.next = 0;
6527: - aw = &ahead;
6528: - if(r->attr®EXP){
6529: - ww->next = newword(node->name);
6530: - aw->next = newword(node->name);
6531: - } else {
6532: - for(w = r->alltargets; w; w = w->next){
6533: - if(r->attr&META)
6534: - subst(aa->stem, w->s, buf);
6535: - else
6536: - strcpy(buf, w->s);
6537: - aw->next = newword(buf);
6538: - aw = aw->next;
6539: - if((s = symlook(buf, S_NODE, (char *)0)) == 0)
6540: - continue; /* not a node we are interested in */
6541: - n = (Node *)s->value;
6542: - ww->next = newword(buf);
6543: - ww = ww->next;
6544: - if(n == node) continue;
6545: - n->next = node->next;
6546: - node->next = n;
6547: - }
6548: - }
6549: - for(n = node; n; n = n->next)
6550: - if((n->flags&READY) == 0)
6551: - return(did);
6552: - /*
6553: - gather the params for the job
6554: - */
6555: - lp.next = ln.next = 0;
6556: - for(n = node; n; n = n->next){
6557: - for(a = n->prereqs; a; a = a->next){
6558: - if(a->n){
6559: - addw(&lp, a->n->name);
6560: - if(outofdate(n, a, 0)){
6561: - addw(&ln, a->n->name);
6562: - if(explain)
6563: - fprint(1, "%s(%ld) < %s(%ld)\n",
6564: - n->name, n->time, a->n->name, a->n->time);
6565: - }
6566: - } else {
6567: - if(explain)
6568: - fprint(1, "%s has no prerequisites\n",
6569: - n->name);
6570: - }
6571: - }
6572: - MADESET(n, BEINGMADE);
6573: - }
6574: -/* print("lt=%s ln=%s lp=%s\n",wtos(head.next),wtos(ln.next),wtos(lp.next));/**/
6575: - run(newjob(r, node, aa->stem, aa->match, lp.next, ln.next, head.next, ahead.next));
6576: - return(1);
6577: -}
6578: -
6579: -addw(w, s)
6580: - register Word *w;
6581: - char *s;
6582: -{
6583: - register Word *lw;
6584: -
6585: - for(lw = w; w = w->next; lw = w){
6586: - if(strcmp(s, w->s) == 0)
6587: - return;
6588: - }
6589: - lw->next = newword(s);
6590: -}
6591: //GO.SYSIN DD ./recipe.c
6592: echo ./regexp.c 1>&2
6593: sed 's/.//' >./regexp.c <<'//GO.SYSIN DD ./regexp.c'
6594: -#include "mk.h"
6595: -
6596: -Rule *patrule;
6597: -
6598: -regerror(s)
6599: - char *s;
6600: -{
6601: - if(patrule)
6602: - Fprint(2, "mk: %s:%d: regular expression error; %s\n",
6603: - patrule->file, patrule->line, s);
6604: - else
6605: - Fprint(2, "mk: %s:%d: regular expression error; %s\n",
6606: - infile, inline, s);
6607: - Exit();
6608: -}
6609: -
6610: -rsub(src, r, a, proto, dest)
6611: - char *src, *dest, *proto;
6612: - Rule *r;
6613: - Arc *a;
6614: -{
6615: - rdump("rsub", a->match);
6616: - print("rsub(src=%d '%s' proto=%d '%s')\n", src, src, proto, proto);
6617: - *dest = 0;
6618: -}
6619: -
6620: -rdump(s, m)
6621: - char *s;
6622: - register regsubexp *m;
6623: -{
6624: - register i;
6625: -
6626: - print("rdump: %s\n", s);
6627: - for(i = 0; i < NREGEXP; i++, m++)
6628: - print("\t%d: %d - %d '%s'\n", i, m->sp, m->ep, m->sp);
6629: -}
6630: //GO.SYSIN DD ./regexp.c
6631: echo ./rule.c 1>&2
6632: sed 's/.//' >./rule.c <<'//GO.SYSIN DD ./rule.c'
6633: -#include "mk.h"
6634: -
6635: -static Rule *lr, *lmr;
6636: -static rcmp();
6637: -static int nrules = 0;
6638: -
6639: -addrule(head, tail, body, ahead, attr, hline, override, prog)
6640: - Word *tail, *ahead;
6641: - char *head, *body, *prog;
6642: -{
6643: - register Rule *r;
6644: - Rule *rr;
6645: - Symtab *sym;
6646: - int reuse;
6647: -
6648: - if(sym = symlook(head, S_TARGET, (char *)0)){
6649: - for(r = (Rule *)sym->value; r; r = r->chain)
6650: - if(rcmp(r, head, tail) == 0) break;
6651: - if(r && !override)
6652: - return;
6653: - } else
6654: - r = 0;
6655: - reuse = r != 0;
6656: - if(r == 0)
6657: - r = (Rule *)Malloc(sizeof(Rule));
6658: - r->target = head;
6659: - r->tail = tail;
6660: - r->recipe = body;
6661: - r->line = hline;
6662: - r->file = infile;
6663: - r->attr = attr;
6664: - r->alltargets = ahead;
6665: - r->prog = prog;
6666: - r->rule = nrules++;
6667: - if(!reuse){
6668: - rr = (Rule *)symlook(head, S_TARGET, (char *)r)->value;
6669: - if(rr != r){
6670: - r->chain = rr->chain;
6671: - rr->chain = r;
6672: - } else
6673: - r->chain = 0;
6674: - }
6675: - if(strchr(head, '%') || strchr(head, '&') || (attr®EXP))
6676: - goto meta;
6677: - if(reuse)
6678: - return;
6679: - r->next = 0;
6680: - r->pat = 0;
6681: - if(rules == 0)
6682: - rules = lr = r;
6683: - else {
6684: - lr->next = r;
6685: - lr = r;
6686: - }
6687: - return;
6688: -meta:
6689: - r->attr |= META;
6690: - if(reuse)
6691: - return;
6692: - r->next = 0;
6693: - if(r->attr®EXP){
6694: - patrule = r;
6695: - r->pat = regcomp(head);
6696: - }
6697: - if(metarules == 0)
6698: - metarules = lmr = r;
6699: - else {
6700: - lmr->next = r;
6701: - lmr = r;
6702: - }
6703: -}
6704: -
6705: -dumpr(s, r)
6706: - char *s;
6707: - register Rule *r;
6708: -{
6709: - Fprint(1, "%s: start=%ld\n", s, r);
6710: - for(; r; r = r->next){
6711: - Fprint(1, "\tRule %ld: %s[%d] attr=%x next=%ld chain=%ld alltarget='%s'",
6712: - r, r->file, r->line, r->attr, r->next, r->chain, wtos(r->alltargets));
6713: - if(r->prog)
6714: - Fprint(1, " prog='%s'", r->prog);
6715: - Fprint(1, "\n\ttarget=%s: %s\n", r->target, wtos(r->tail));
6716: - Fprint(1, "\trecipe@%ld='%s'\n", r->recipe, r->recipe);
6717: - }
6718: -}
6719: -
6720: -frule(w)
6721: - Word *w;
6722: -{
6723: - extern Word *target1;
6724: - register Word *ww;
6725: - register char *s;
6726: -
6727: -#define ADD(s) {if(target1==0)target1=ww=newword(s);else ww=ww->next=newword(s);}
6728: -
6729: - for(ww = w; ww; ww = ww->next)
6730: - if(strchr(w->s, '%') || strchr(w->s, '&'))
6731: - return; /* no metarule targets */
6732: - while(w){
6733: - if(s = strchr(w->s, '+')){
6734: - *s++ = 0;
6735: - if(*w->s)
6736: - ADD(w->s);
6737: - if(*s)
6738: - ADD(s);
6739: - s[-1] = '+';
6740: - } else
6741: - ADD(w->s);
6742: - w = w->next;
6743: - }
6744: -}
6745: -
6746: -static
6747: -rcmp(r, target, tail)
6748: - register Rule *r;
6749: - char *target;
6750: - register Word *tail;
6751: -{
6752: - register Word *w;
6753: -
6754: - if(strcmp(r->target, target))
6755: - return(1);
6756: - for(w = r->tail; w && tail; w = w->next, tail = tail->next)
6757: - if(strcmp(w->s, tail->s))
6758: - return(1);
6759: - return(w || tail);
6760: -}
6761: -
6762: -char *
6763: -rulecnt()
6764: -{
6765: - register char *s;
6766: -
6767: - s = Malloc(nrules);
6768: - memset(s, 0, nrules);
6769: - return(s);
6770: -}
6771: -
6772: -ismeta(s)
6773: - register char *s;
6774: -{
6775: - for(; *s; s++)
6776: - switch(*s)
6777: - {
6778: - case '\\':
6779: - if(s[1])
6780: - s++;
6781: - break;
6782: - case '[':
6783: - case '*':
6784: - case '?':
6785: - return(1);
6786: - break;
6787: - }
6788: - return(0);
6789: -}
6790: //GO.SYSIN DD ./rule.c
6791: echo ./run.c 1>&2
6792: sed 's/.//' >./run.c <<'//GO.SYSIN DD ./run.c'
6793: -#include "mk.h"
6794: -
6795: -typedef struct Event
6796: -{
6797: - int pid;
6798: - Job *job;
6799: -} Event;
6800: -static Event *events;
6801: -static int nevents, nrunning;
6802: -typedef struct Process
6803: -{
6804: - int pid;
6805: - int status;
6806: - struct Process *b, *f;
6807: -} Process;
6808: -static Process *phead, *pfree;
6809: -static void pnew(), pdelete();
6810: -static char *envy[1024];
6811: -static char **special;
6812: -static pidslot();
6813: -
6814: -run(j)
6815: - Job *j;
6816: -{
6817: - register Job *jj;
6818: -
6819: - if(jobs){
6820: - for(jj = jobs; jj->next; jj = jj->next)
6821: - ;
6822: - jj->next = j;
6823: - } else
6824: - jobs = j;
6825: - j->next = 0;
6826: - /* this code also in waitup after parse redirect */
6827: - if(nrunning < nproclimit)
6828: - sched();
6829: -}
6830: -
6831: -sched()
6832: -{
6833: - register Job *j;
6834: - char buf[BIGBLOCK];
6835: - int slot, pip[2], pid;
6836: - Node *n;
6837: -
6838: - if(jobs == 0){
6839: - account();
6840: - return;
6841: - }
6842: - j = jobs;
6843: - jobs = j->next;
6844: - if(DEBUG(D_EXEC))
6845: - fprint(1, "firing up job for target %s\n", wtos(j->t));
6846: - slot = nextslot();
6847: - events[slot].job = j;
6848: - dovars(j, slot);
6849: - shprint(j->r->recipe, envy, buf);
6850: - if(!tflag && !mflag && (nflag || !(j->r->attr&QUIET)))
6851: - Fwrite(1, buf, (long)strlen(buf));
6852: - if(mflag){
6853: - for(n = j->n; n; n = n->next)
6854: - symlook(n->name, S_MAKEFILE, (char *)j);
6855: - }
6856: - if(nflag||tflag){
6857: - for(n = j->n; n; n = n->next){
6858: - if(tflag){
6859: - if(!(n->flags&VIRTUAL))
6860: - touch(n->name);
6861: - else if(explain)
6862: - Fprint(1, "no touch of virtual '%s'\n", n->name);
6863: - }
6864: - n->time = time((long *)0);
6865: - MADESET(n, MADE);
6866: - }
6867: - } else {
6868: - Fexit(0);
6869: - if(j->r->attr&RED){
6870: - if(pipe(pip) < 0){
6871: - perror("pipe");
6872: - Exit();
6873: - }
6874: - }
6875: - if((pid = fork()) < 0){
6876: - perror("mk fork");
6877: - Exit();
6878: - }
6879: - if(pid == 0){
6880: - if(j->r->attr&RED){
6881: - close(pip[0]);
6882: - dup2(pip[1], 1);
6883: - close(pip[1]);
6884: - }
6885: - if(pipe(pip) < 0){
6886: - perror("pipe-i");
6887: - Exit();
6888: - }
6889: - if((pid = fork()) < 0){
6890: - perror("mk fork");
6891: - Exit();
6892: - }
6893: - if(pid != 0){
6894: - close(pip[1]);
6895: - dup2(pip[0], 0);
6896: - close(pip[0]);
6897: - execle(SHELL, "sh", "-e", (char *)0, envy);
6898: - perror(SHELL);
6899: - _exit(1);
6900: - } else {
6901: - int k;
6902: - char *s, *send;
6903: -
6904: - close(pip[0]);
6905: - s = j->r->recipe;
6906: - send = s+strlen(s);
6907: - while(s < send){
6908: - if((k = write(pip[1], s, send-s)) < 0)
6909: - break;
6910: - s += k;
6911: - }
6912: - _exit(0);
6913: - }
6914: - }
6915: - account();
6916: - nrunning++;
6917: - if(j->r->attr&RED)
6918: - close(pip[1]), j->fd = pip[0];
6919: - else
6920: - j->fd = -1;
6921: - if(DEBUG(D_EXEC))
6922: - fprint(1, "pid for target %s = %d\n", wtos(j->t), pid);
6923: - events[slot].pid = pid;
6924: - }
6925: -}
6926: -
6927: -waitup(echildok, retstatus)
6928: - int *retstatus;
6929: -{
6930: - int status, pid;
6931: - int slot;
6932: - Symtab *s;
6933: - Word *w;
6934: - Job *j;
6935: - char buf[64];
6936: - char buf1[BIGBLOCK];
6937: - int uarg = 0;
6938: - int done;
6939: - Node *n;
6940: - Process *p;
6941: - extern int errno, runerrs;
6942: -
6943: - /* first check against the proces slist */
6944: - if(retstatus)
6945: - for(p = phead; p; p = p->f)
6946: - if(p->pid == *retstatus){
6947: - *retstatus = p->status;
6948: - pdelete(p);
6949: - return(-1);
6950: - }
6951: -again: /* rogue processes */
6952: - if((pid = wait(&status)) < 0){
6953: - if(echildok > 0){
6954: - return(1);
6955: - } else {
6956: - fprint(2, "mk: (waitup %d) ", echildok);
6957: - perror("mk wait");
6958: - Exit();
6959: - }
6960: - }
6961: - if(DEBUG(D_EXEC))
6962: - fprint(1, "waitup got pid=%d, status=0x%ux\n", pid, status);
6963: - if(retstatus && (pid == *retstatus)){
6964: - *retstatus = status;
6965: - return(-1);
6966: - }
6967: - slot = pidslot(pid);
6968: - if(slot < 0){
6969: - if(DEBUG(D_EXEC))
6970: - fprint(2, "mk: wait returned unexpected process %d\n", pid);
6971: - pnew(pid, status);
6972: - goto again;
6973: - }
6974: - j = events[slot].job;
6975: - account();
6976: - nrunning--;
6977: - events[slot].pid = -1;
6978: - if(status){
6979: - dovars(j, slot);
6980: - shprint(j->r->recipe, envy, buf1);
6981: - front(buf1);
6982: - Fprint(2, "mk: %s: exit status=%d", buf1, 0xFF&(status>>8));
6983: - status &= 0xFF;
6984: - if(status&0x7F)
6985: - Fprint(2, " signal=%d", status&0x7F);
6986: - if(status&0x80)
6987: - Fprint(2, ", core dumped");
6988: - for(n = j->n, done = 0; n; n = n->next)
6989: - if(n->flags&DELETE){
6990: - if(done++ == 0)
6991: - Fprint(2, ", deleting");
6992: - Fprint(2, " '%s'", n->name);
6993: - }
6994: - Fputc(2, '\n');
6995: - for(n = j->n, done = 0; n; n = n->next)
6996: - if(n->flags&DELETE){
6997: - if(done++ == 0)
6998: - Fflush(2);
6999: - delete(n->name);
7000: - }
7001: - if(kflag){
7002: - runerrs++;
7003: - uarg = 1;
7004: - Fflush(2);
7005: - } else {
7006: - jobs = 0;
7007: - Exit();
7008: - }
7009: - }
7010: - if(j->fd >= 0){
7011: - sprint(buf, "process %d", pid);
7012: - parse(buf, j->fd, 0, 0);
7013: - execinit(); /* reread environ */
7014: - nproc();
7015: - while(jobs && (nrunning < nproclimit))
7016: - sched();
7017: - }
7018: - for(w = j->t; w; w = w->next){
7019: - if((s = symlook(w->s, S_NODE, (char *)0)) == 0)
7020: - continue; /* not interested in this node */
7021: - update(uarg, (Node *)s->value);
7022: - }
7023: - if(nrunning < nproclimit)
7024: - sched();
7025: - return(0);
7026: -}
7027: -
7028: -execinit()
7029: -{
7030: - extern char **environ;
7031: - extern char **vardump();
7032: - register char *s, *ss, c;
7033: - Symtab *st;
7034: -
7035: - environ = envy;
7036: - special = vardump(envy);
7037: - if(st = symlook("ENVIRON", S_VAR, (char *)0))
7038: - for(s = st->value; *s;){
7039: - for(ss = s; *ss && (*ss != 1); ss++);
7040: - c = *ss;
7041: - *ss = 0;
7042: - *special++ = strdup(s);
7043: - s = ss;
7044: - if(*ss = c)
7045: - s++;
7046: - }
7047: - *special = 0;
7048: -}
7049: -
7050: -char *myenv[] =
7051: -{
7052: - "target", "stem", "prereq", "pid", "nproc", "newprereq",
7053: - "alltarget",
7054: - "stem1", "stem2", "stem3", "stem4", "stem5", "stem6",
7055: - "stem7", "stem8", "stem9", "stem0", 0
7056: -};
7057: -
7058: -dovars(j, slot)
7059: - register Job *j;
7060: -{
7061: - char buf[BIGBLOCK];
7062: - char *s, *t;
7063: - int i, n = 0;
7064: -
7065: -#define SPECIAL ((sizeof myenv)/(sizeof myenv[0])-1)
7066: -#define VSET(name, exp) {strcpy(buf, "name="); strcpy(strchr(buf, 0), exp);}
7067: -
7068: - for(i = 0; i < SPECIAL; i++)
7069: - if(special[i])
7070: - free(special[i]);
7071: - VSET(target, s = wtos(j->t));
7072: - special[n++] = strdup(buf);
7073: - free(s);
7074: - /* WATCH OUT; stem set below if reg exp!! */
7075: - VSET(stem, j->stem);
7076: - special[n++] = strdup(buf);
7077: - VSET(prereq, s = wtos(j->p));
7078: - special[n++] = strdup(buf);
7079: - free(s);
7080: - sprint(buf, "pid=%d", getpid());
7081: - special[n++] = strdup(buf);
7082: - sprint(buf, "nproc=%d", slot);
7083: - special[n++] = strdup(buf);
7084: - VSET(newprereq, s = wtos(j->np));
7085: - special[n++] = strdup(buf);
7086: - free(s);
7087: - VSET(alltarget, s = wtos(j->at));
7088: - special[n++] = strdup(buf);
7089: - free(s);
7090: - for(i = 0; i <= 9; i++){
7091: - sprint(buf, "stem%d=", i);
7092: - if(j->r->attr®EXP){
7093: - for(s = buf; *s; s++);
7094: - for(t = j->match[i].sp; t < j->match[i].ep; *s++ = *t++);
7095: - *s = 0;
7096: - }
7097: - special[n+i] = strdup(buf);
7098: - if((i == 1) && (j->r->attr®EXP)){
7099: - buf[1] = 's'; buf[2] = 't'; buf[3] = 'e'; buf[4] = 'm';
7100: - special[1] = strdup(buf+1);
7101: - }
7102: - }
7103: - special[SPECIAL] = 0;
7104: -}
7105: -
7106: -nproc()
7107: -{
7108: - register Symtab *sym;
7109: -
7110: - if(sym = symlook("NPROC", S_VAR, (char *)0))
7111: - nproclimit = atoi(sym->value);
7112: - if(nproclimit < 1)
7113: - nproclimit = 1;
7114: - if(DEBUG(D_EXEC))
7115: - fprint(1, "nprocs = %d\n", nproclimit);
7116: - if(nproclimit > nevents){
7117: - if(nevents)
7118: - events = (Event *)realloc((char *)events, nproclimit*sizeof(Event));
7119: - else
7120: - events = (Event *)malloc(nproclimit*sizeof(Event));
7121: - while(nevents < nproclimit)
7122: - events[nevents++].pid = 0;
7123: - }
7124: -}
7125: -
7126: -nextslot()
7127: -{
7128: - register i;
7129: -
7130: - for(i = 0; i < nproclimit; i++)
7131: - if(events[i].pid <= 0) return(i);
7132: - assert("out of slots!!", 0);
7133: - return(0); /* cyntax */
7134: -}
7135: -
7136: -static
7137: -pidslot(pid)
7138: -{
7139: - register i;
7140: -
7141: - for(i = 0; i < nevents; i++)
7142: - if(events[i].pid == pid) return(i);
7143: - return(-1);
7144: -}
7145: -
7146: -static void
7147: -pnew(pid, status)
7148: -{
7149: - register Process *p;
7150: -
7151: - if(pfree){
7152: - p = pfree;
7153: - pfree = p->f;
7154: - } else
7155: - p = (Process *)Malloc(sizeof(Process));
7156: - p->pid = pid;
7157: - p->status = status;
7158: - p->f = phead;
7159: - phead = p;
7160: - if(p->f)
7161: - p->f->b = p;
7162: - p->b = 0;
7163: -}
7164: -
7165: -static void
7166: -pdelete(p)
7167: - Process *p;
7168: -{
7169: - if(p->f)
7170: - p->f->b = p->b;
7171: - if(p->b)
7172: - p->b->f = p->f;
7173: - else
7174: - phead = p->f;
7175: - p->f = pfree;
7176: - pfree = p;
7177: -}
7178: -
7179: -static long tslot[1000];
7180: -static long tick;
7181: -
7182: -account()
7183: -{
7184: - long t;
7185: -
7186: - time(&t);
7187: - if(tick)
7188: - tslot[nrunning] += (t-tick);
7189: - tick = t;
7190: -}
7191: -
7192: -praccount()
7193: -{
7194: - int i;
7195: -
7196: - account();
7197: - for(i = 0; i <= nevents; i++)
7198: - Fprint(1, "%d: %ld\n", i, tslot[i]);
7199: -}
7200: //GO.SYSIN DD ./run.c
7201: echo ./shprint.c 1>&2
7202: sed 's/.//' >./shprint.c <<'//GO.SYSIN DD ./shprint.c'
7203: -#include "mk.h"
7204: -
7205: -shprint(s, env, dest)
7206: - char *s, **env, *dest;
7207: -{
7208: - register char *q = dest;
7209: -
7210: - while(*s)
7211: - switch(*s)
7212: - {
7213: - case '\\':
7214: - *q++ = *s++;
7215: - *q++ = *s++;
7216: - break;
7217: - case '$':
7218: - q = vexpand(&s, q, env);
7219: - break;
7220: - default:
7221: - *q++ = *s++;
7222: - break;
7223: - }
7224: - *q = 0;
7225: -}
7226: -
7227: -char *
7228: -mygetenv(name, env)
7229: - char *name, **env;
7230: -{
7231: - register char *p, *q;
7232: -
7233: - for(; *env; env++){
7234: - for(p = name, q = *env; *p == *q; p++, q++)
7235: - if(*p == 0) break;
7236: - if((*p == 0) && (*q == '='))
7237: - return(q+1);
7238: - }
7239: - return((char *)0);
7240: -}
7241: -
7242: -char *
7243: -vexpand(ww, dest, env)
7244: - char **ww, *dest, **env;
7245: -{
7246: - register char *s, *w = *ww;
7247: - char carry, *q;
7248: -
7249: - assert("vexpand no $", *w == '$');
7250: - if(*++w == '{'){
7251: - for(s = ++w; *s != '}'; s++)
7252: - if(*s == 0) break;
7253: - } else
7254: - s = shname(w);
7255: - carry = *s;
7256: - *s = 0;
7257: - if(q = mygetenv(w, env)){
7258: - while(*q)
7259: - *dest++ = *q++;
7260: - } else { /* copy name */
7261: - for(q = *ww; q != s;)
7262: - *dest++ = *q++;
7263: - if(carry == '}')
7264: - *dest++ = carry;
7265: - }
7266: - *s = carry;
7267: - if(carry == '}')
7268: - s++;
7269: - *ww = s;
7270: - return(dest);
7271: -}
7272: -
7273: -front(s)
7274: - char *s;
7275: -{
7276: - register char *t;
7277: - register i, j;
7278: - char *flds[512];
7279: - char buf[BIGBLOCK];
7280: -
7281: - setfields(" \t\n");
7282: - strcpy(buf, s);
7283: - i = getfields(buf, flds, 512);
7284: - if(i > 5){
7285: - flds[4] = flds[i-1];
7286: - flds[3] = "...";
7287: - i = 5;
7288: - }
7289: - t = s;
7290: - for(j = 0; j < i; j++){
7291: - for(s = flds[j]; *s; *t++ = *s++);
7292: - *t++ = ' ';
7293: - }
7294: - *t = 0;
7295: -}
7296: //GO.SYSIN DD ./shprint.c
7297: echo ./sig.c 1>&2
7298: sed 's/.//' >./sig.c <<'//GO.SYSIN DD ./sig.c'
7299: -#include "mk.h"
7300: -#include <signal.h>
7301: -
7302: -static
7303: -sigint()
7304: -{
7305: - extern errno;
7306: -
7307: - signal(SIGINT, SIG_IGN);
7308: - kflag = 1; /* to make sure waitup doesn't exit */
7309: - jobs = 0; /* make sure no more get scheduled */
7310: - while(waitup(1, (int *)0) == 0)
7311: - ;
7312: - Fprint(1, "mk: interrupted!\n");
7313: - Exit();
7314: -}
7315: -
7316: -sigcatch()
7317: -{
7318: - if(signal(SIGINT, SIG_IGN) != SIG_IGN)
7319: - signal(SIGINT, sigint);
7320: -}
7321: //GO.SYSIN DD ./sig.c
7322: echo ./symtab.c 1>&2
7323: sed 's/.//' >./symtab.c <<'//GO.SYSIN DD ./symtab.c'
7324: -#include "mk.h"
7325: -
7326: -#define NHASH 4099
7327: -#define HASHMUL 79L /* this is a good value */
7328: -static Symtab *hash[NHASH];
7329: -
7330: -syminit()
7331: -{
7332: - register Symtab **s, *ss;
7333: -
7334: - for(s = hash; s < &hash[NHASH]; s++){
7335: - for(ss = *s; ss; ss = ss->next)
7336: - free((char *)ss);
7337: - *s = 0;
7338: - }
7339: -}
7340: -
7341: -Symtab *
7342: -symlook(sym, space, install)
7343: - char *sym;
7344: - char *install;
7345: -{
7346: - register long h;
7347: - register char *p;
7348: - register Symtab *s;
7349: -
7350: - for(p = sym, h = space; *p; h += *p++)
7351: - h *= HASHMUL;
7352: - if(h < 0)
7353: - h = ~h;
7354: - h %= NHASH;
7355: - for(s = hash[h]; s; s = s->next)
7356: - if((s->space == space) && (strcmp(s->name, sym) == 0))
7357: - return(s);
7358: - if(install == 0)
7359: - return((Symtab *)0);
7360: - s = (Symtab *)Malloc(sizeof(Symtab));
7361: - s->space = space;
7362: - s->name = sym;
7363: - s->value = install;
7364: - s->next = hash[h];
7365: - hash[h] = s;
7366: - return(s);
7367: -}
7368: -
7369: -symdel(sym, space)
7370: - char *sym;
7371: -{
7372: - register long h;
7373: - register char *p;
7374: - register Symtab *s, *ls;
7375: -
7376: - for(p = sym, h = space; *p; h += *p++)
7377: - h *= HASHMUL;
7378: - if(h < 0)
7379: - h = ~h;
7380: - h %= NHASH;
7381: - for(s = hash[h], ls = 0; s; ls = s, s = s->next)
7382: - if((s->space == space) && (strcmp(s->name, sym) == 0)){
7383: - if(ls)
7384: - ls->next = s->next;
7385: - else
7386: - hash[h] = s->next;
7387: - free((char *)s);
7388: - }
7389: -}
7390: -
7391: -symtraverse(space, fn)
7392: - void (*fn)();
7393: -{
7394: - register Symtab **s, *ss;
7395: -
7396: - for(s = hash; s < &hash[NHASH]; s++)
7397: - for(ss = *s; ss; ss = ss->next)
7398: - if(ss->space == space)
7399: - (*fn)(ss);
7400: -}
7401: -
7402: -symstat()
7403: -{
7404: - register Symtab **s, *ss;
7405: - register n;
7406: - int l[1000];
7407: -
7408: - memset((char *)l, 0, sizeof(l));
7409: - for(s = hash; s < &hash[NHASH]; s++){
7410: - for(ss = *s, n = 0; ss; ss = ss->next)
7411: - n++;
7412: - l[n]++;
7413: - }
7414: - for(n = 0; n < 1000; n++)
7415: - if(l[n]) Fprint(1, "%ld of length %d\n", l[n], n);
7416: -}
7417: //GO.SYSIN DD ./symtab.c
7418: echo ./t_ar.c 1>&2
7419: sed 's/.//' >./t_ar.c <<'//GO.SYSIN DD ./t_ar.c'
7420: -#include "mk.h"
7421: -#include <sys/types.h>
7422: -#include <sys/stat.h>
7423: -#include <ar.h>
7424: -
7425: -static atimes();
7426: -
7427: -long
7428: -atimeof(force, name, ar, mem)
7429: - char *name, *ar, *mem;
7430: -{
7431: - struct stat sbuf;
7432: - Symtab *sym;
7433: -
7434: - if(stat(ar, &sbuf) < 0)
7435: - sbuf.st_mtime = 0;
7436: - if(sym = symlook(ar, S_AGG, (char *)0)){
7437: - if(force || (sbuf.st_mtime > (long)sym->value)){
7438: - atimes(ar);
7439: - symlook(ar, S_AGG, ar)->value = (char *)sbuf.st_mtime;
7440: - }
7441: - } else {
7442: - atimes(ar);
7443: - symlook(strdup(ar), S_AGG, ar)->value = (char *)sbuf.st_mtime;
7444: - }
7445: - if(sym = symlook(name, S_TIME, (char *)0))
7446: - sbuf.st_mtime = (long)sym->value;
7447: - else
7448: - sbuf.st_mtime = 0;
7449: - return((long)sbuf.st_mtime);
7450: -}
7451: -
7452: -void
7453: -atouch(name, ar, mem)
7454: - char *name, *ar, *mem;
7455: -{
7456: - int fd;
7457: - struct ar_hdr hdr;
7458: - char *s;
7459: - long t;
7460: - char buf[NAMEBLOCK];
7461: -
7462: - strcpy(buf, mem);
7463: -#ifdef SYSV
7464: - strcat(buf, "/");
7465: -#endif
7466: - if((fd = open(ar, 2)) < 0){
7467: - if((fd = creat(ar, 0666)) < 0){
7468: - perror(ar);
7469: - Exit();
7470: - }
7471: - write(fd, ARMAG, SARMAG);
7472: - }
7473: - if(symlook(name, S_TIME, (char *)0)){
7474: - /* hoon off and change it in situ */
7475: - lseek(fd, (long)SARMAG, 0);
7476: - while(read(fd, (char *)&hdr, sizeof(hdr)) == sizeof(hdr)){
7477: - for(s = &hdr.ar_name[sizeof(hdr.ar_name)]; *--s == ' ';);
7478: - s[1] = 0;
7479: - if(strcmp(buf, hdr.ar_name) == 0){
7480: - t = sizeof(hdr.ar_name)-sizeof(hdr);
7481: - lseek(fd, t, 1);
7482: - fprint(fd, "%-12ld", time((long *)0));
7483: - break;
7484: - }
7485: - t = atol(hdr.ar_size);
7486: -#ifdef CRAY
7487: - t = (t+7)&~7;
7488: - t -= sizeof(hdr)-60;
7489: -#else
7490: - if(t&01) t++;
7491: -#endif
7492: - lseek(fd, t, 1);
7493: - }
7494: - } else {
7495: - lseek(fd, 0L, 2);
7496: - fprint(fd, "%-16s%-12ld%-6d%-6d%-8lo%-10ld%2s", buf, time((long *)0),
7497: - getuid(), getgid(), 0100666L, 0L, ARFMAG);
7498: - }
7499: - close(fd);
7500: -}
7501: -
7502: -
7503: -void
7504: -adelete(name, ar, mem)
7505: - char *name, *ar, *mem;
7506: -{
7507: - Fprint(2, "sorry; mk doesn't know how to delete archive members yet\n");
7508: -}
7509: -
7510: -static
7511: -atimes(ar)
7512: - char *ar;
7513: -{
7514: - struct ar_hdr hdr;
7515: - long t;
7516: - int fd;
7517: - char buf[BIGBLOCK];
7518: - register char *s;
7519: -
7520: - if((fd = open(ar, 0)) < 0)
7521: - return;
7522: - if(read(fd, buf, SARMAG) != SARMAG){
7523: - close(fd);
7524: - return;
7525: - }
7526: - while(read(fd, (char *)&hdr, sizeof(hdr)) == sizeof(hdr)){
7527: - for(s = &hdr.ar_name[sizeof(hdr.ar_name)]; *--s == ' ';);
7528: -#ifdef SYSV
7529: - if(*s == '/') /* Damn you Sytem V */
7530: - s--;
7531: -#endif
7532: - s[1] = 0;
7533: - t = atol(hdr.ar_date);
7534: - sprint(buf, "%s(%s)", ar, hdr.ar_name);
7535: - symlook(strdup(buf), S_TIME, (char *)t)->value = (char *)t;
7536: - t = atol(hdr.ar_size);
7537: - if(t&01) t++;
7538: - lseek(fd, t, 1);
7539: - }
7540: - close(fd);
7541: -}
7542: //GO.SYSIN DD ./t_ar.c
7543: echo ./t_driver.c 1>&2
7544: sed 's/.//' >./t_driver.c <<'//GO.SYSIN DD ./t_driver.c'
7545: -#include "mk.h"
7546: -#include <ar.h>
7547: -
7548: -#define AR 123456L
7549: -
7550: -extern long ftimeof(), atimeof();
7551: -extern void ftouch(), atouch();
7552: -extern void fdelete(), adelete();
7553: -static long split();
7554: -
7555: -struct ftype
7556: -{
7557: - long magic;
7558: - long (*time)();
7559: - void (*touch)();
7560: - void (*delete)();
7561: -} ftab[] =
7562: -{
7563: - { 0L, ftimeof, ftouch, fdelete },
7564: - { AR, atimeof, atouch, adelete },
7565: - { 0L, (long (*)())0 }
7566: -};
7567: -
7568: -long
7569: -timeof(name, force)
7570: - char *name;
7571: -{
7572: - char buf[BIGBLOCK], *part2;
7573: - register struct ftype *f;
7574: - long magic;
7575: -
7576: - magic = split(name, buf, &part2);
7577: - for(f = ftab; f->time; f++)
7578: - if(f->magic == magic)
7579: - return((*f->time)(force, name, buf, part2));
7580: - Fprint(2, "mk: '%s' appears to have an unknown magic number (%ld)\n", name, magic);
7581: - Exit();
7582: - return(0L); /* shut cyntax up */
7583: -}
7584: -
7585: -void
7586: -touch(name)
7587: - char *name;
7588: -{
7589: - char buf[BIGBLOCK], *part2;
7590: - register struct ftype *f;
7591: - long magic;
7592: -
7593: - magic = split(name, buf, &part2);
7594: - Fprint(1, "touch(%s)\n", name);
7595: - if(nflag)
7596: - return;
7597: - for(f = ftab; f->time; f++)
7598: - if(f->magic == magic){
7599: - (*f->touch)(name, buf, part2);
7600: - return;
7601: - }
7602: - Fprint(2, "mk: give me a break! I never heard of magic=%ld\n", magic);
7603: - Exit();
7604: -}
7605: -
7606: -void
7607: -delete(name)
7608: - char *name;
7609: -{
7610: - char buf[BIGBLOCK], *part2;
7611: - register struct ftype *f;
7612: - long magic;
7613: -
7614: - magic = split(name, buf, &part2);
7615: - for(f = ftab; f->time; f++)
7616: - if(f->magic == magic){
7617: - (*f->delete)(name, buf, part2);
7618: - return;
7619: - }
7620: - Fprint(2, "mk: give me a break! I never heard of magic=%ld\n", magic);
7621: - Exit();
7622: -}
7623: -
7624: -static long
7625: -type(file)
7626: - char *file;
7627: -{
7628: - int fd;
7629: - char buf[SARMAG];
7630: - short m;
7631: - long goo;
7632: -
7633: - if(access(file, 0) < 0){
7634: - if(symlook(file, S_BITCH, (char *)0) == 0){
7635: - Fprint(1, "%s doesn't exist: assuming it will be an archive\n", file);
7636: - (void)symlook(file, S_BITCH, file);
7637: - }
7638: - return(AR);
7639: - }
7640: - if((fd = open(file, 0)) < 0){
7641: - perror(file);
7642: - Exit();
7643: - }
7644: - if(read(fd, buf, SARMAG) != SARMAG){
7645: - close(fd);
7646: - return(-1L);
7647: - }
7648: - if(strncmp(ARMAG, buf, SARMAG) == 0)
7649: - goo = AR;
7650: - else {
7651: - lseek(fd, 0L, 0);
7652: - if(read(fd, (char *)&m, sizeof m) == sizeof m)
7653: - goo = m;
7654: - else
7655: - goo = -1;
7656: - }
7657: - close(fd);
7658: - return(goo);
7659: -}
7660: -
7661: -static long
7662: -split(name, buf, p2)
7663: - char *name, *buf, **p2;
7664: -{
7665: - register char *s;
7666: -
7667: - strcpy(buf, name);
7668: - if(s = strchr(buf, '(')){
7669: - *s++ = 0;
7670: - *p2 = s;
7671: - while(*s && (*s != ')'))
7672: - s++;
7673: - *s = 0;
7674: - return(type(buf));
7675: - } else
7676: - return(0L);
7677: -}
7678: //GO.SYSIN DD ./t_driver.c
7679: echo ./t_file.c 1>&2
7680: sed 's/.//' >./t_file.c <<'//GO.SYSIN DD ./t_file.c'
7681: -#include "mk.h"
7682: -#include <sys/types.h>
7683: -#include <sys/stat.h>
7684: -#include <errno.h>
7685: -
7686: -#define MYSEP(s) ((*s == ' ') || (*s == ',') || (*s == '\n'))
7687: -
7688: -timeinit(s)
7689: - register char *s;
7690: -{
7691: - register long t;
7692: - register char *os;
7693: -
7694: - for(t = time((long *)0); *s; s = os){
7695: - for(os = s; !MYSEP(os); os++)
7696: - if(*os == 0){
7697: - symlook(strdup(s), S_TIME, (char *)t)->value = (char *)t;
7698: - return;
7699: - }
7700: - *os++ = 0;
7701: - symlook(strdup(s), S_TIME, (char *)t)->value = (char *)t;
7702: - while(MYSEP(os))
7703: - os++;
7704: - }
7705: -}
7706: -
7707: -long
7708: -ftimeof(force, name)
7709: - char *name;
7710: -{
7711: - struct stat sbuf;
7712: - Symtab *sym;
7713: -
7714: - if(!force && (sym = symlook(name, S_TIME, (char *)0))){
7715: - return((long)sym->value);
7716: - }
7717: - if(stat(name, &sbuf) < 0)
7718: - sbuf.st_mtime = 0;
7719: - symlook(name, S_TIME, (char *)sbuf.st_mtime);
7720: - return((long)sbuf.st_mtime);
7721: -}
7722: -
7723: -void
7724: -ftouch(name)
7725: - char *name;
7726: -{
7727: - int fd;
7728: - char buf[1];
7729: - struct stat sbuf;
7730: -
7731: - if(stat(name, &sbuf) < 0) /* not there and zero length are same case */
7732: - sbuf.st_size = 0;
7733: - if(sbuf.st_size == 0){
7734: - if((fd = creat(name, 0666)) < 0){
7735: - bad:
7736: - perror(name);
7737: - Exit();
7738: - }
7739: - close(fd);
7740: - return;
7741: - }
7742: - if((fd = open(name, 2)) < 0)
7743: - goto bad;
7744: - if(read(fd, buf, 1) != 1)
7745: - goto bad;
7746: - if(lseek(fd, 0L, 0) < 0)
7747: - goto bad;
7748: - if(write(fd, buf, 1) != 1)
7749: - goto bad;
7750: - close(fd);
7751: -}
7752: -
7753: -void
7754: -fdelete(s)
7755: - char *s;
7756: -{
7757: - if(unlink(s) < 0)
7758: - perror(s);
7759: -}
7760: //GO.SYSIN DD ./t_file.c
7761: echo ./var.c 1>&2
7762: sed 's/.//' >./var.c <<'//GO.SYSIN DD ./var.c'
7763: -#include "mk.h"
7764: -
7765: -setvar(name, value)
7766: - char *name;
7767: - char *value;
7768: -{
7769: - symlook(name, S_VAR, value)->value = value;
7770: - symlook(name, S_MAKEVAR, "");
7771: -}
7772: -
7773: -static char **nextv;
7774: -
7775: -static void
7776: -vcopy(s)
7777: - register Symtab *s;
7778: -{
7779: - register char **p;
7780: - extern char *myenv[];
7781: -
7782: - if(symlook(s->name, S_NOEXPORT, (char *)0))
7783: - return;
7784: - for(p = myenv; *p; p++)
7785: - if(strcmp(*p, s->name) == 0) return;
7786: - if(*nextv)
7787: - free(*nextv);
7788: - *nextv++ = envpr(s->name, s->value);
7789: -}
7790: -
7791: -char **
7792: -vardump(p)
7793: - char **p;
7794: -{
7795: - nextv = p;
7796: - symtraverse(S_VAR, vcopy);
7797: - *nextv = 0;
7798: - return(nextv);
7799: -}
7800: -
7801: -static void
7802: -print1(s)
7803: - register Symtab *s;
7804: -{
7805: - Fprint(1, "\t%s='%s'\n", s->name, s->value);
7806: -}
7807: -
7808: -dumpv(s)
7809: - char *s;
7810: -{
7811: - Fprint(1, "%s:\n", s);
7812: - symtraverse(S_VAR, print1);
7813: -}
7814: -
7815: -char *
7816: -envpr(name, value)
7817: - register char *name;
7818: - register char *value;
7819: -{
7820: - char buf[BIGBLOCK];
7821: -
7822: - sprint(buf, "%s=", name);
7823: - strcpy(strchr(buf, 0), value);
7824: - return(strdup(buf));
7825: -}
7826: -
7827: -#include <ctype.h>
7828: -
7829: -char *
7830: -shname(s)
7831: - char *s;
7832: -{
7833: - register unsigned char *a = (unsigned char *)s;
7834: -
7835: - /* always go one !! */
7836: - a++;
7837: - while(isalnum(*a) || (*a == '_')) a++;
7838: - return((char *)a);
7839: -}
7840: //GO.SYSIN DD ./var.c
7841: echo ./word.c 1>&2
7842: sed 's/.//' >./word.c <<'//GO.SYSIN DD ./word.c'
7843: -#include "mk.h"
7844: -
7845: -Word *
7846: -newword(s)
7847: - char *s;
7848: -{
7849: - register Word *w = (Word *)Malloc(sizeof(Word));
7850: -
7851: - w->s = strdup(s);
7852: - w->next = 0;
7853: - return(w);
7854: -}
7855: -
7856: -Word *
7857: -stow(s)
7858: - char *s;
7859: -{
7860: - char save;
7861: - register char *t;
7862: - Word *head, *w;
7863: -
7864: - w = head = newword("");
7865: - while(*s){
7866: - while(SEP(*s))
7867: - s++;
7868: - if(*s == 0) break;
7869: - for(t = s; *t && !SEP(*t); t++)
7870: - ;
7871: - save = *t;
7872: - *t = 0;
7873: - w->next = newword(s);
7874: - w = w->next;
7875: - *t = save;
7876: - s = t;
7877: - }
7878: - w = head->next;
7879: - delword(head);
7880: - return(w);
7881: -}
7882: -
7883: -char *
7884: -wtos(w)
7885: - register Word *w;
7886: -{
7887: - static char buf[BIGBLOCK];
7888: - register char *s = buf;
7889: - register char *t;
7890: -
7891: - for(; w; w = w->next){
7892: - for(t = w->s; *t;)
7893: - *s++ = *t++;
7894: - if(w->next)
7895: - *s++ = ' ';
7896: - }
7897: - *s = 0;
7898: - return(strdup(buf));
7899: -}
7900: -
7901: -delword(w)
7902: - Word *w;
7903: -{
7904: - free(w->s);
7905: - free((char *)w);
7906: -}
7907: -
7908: -dumpw(s, w)
7909: - char *s;
7910: - Word *w;
7911: -{
7912: - Fprint(1, "%s", s);
7913: - for(; w; w = w->next)
7914: - Fprint(1, " '%s'", w->s);
7915: - Fputc(1, '\n');
7916: -}
7917: //GO.SYSIN DD ./word.c
7918: echo ./ndir.h 1>&2
7919: sed 's/.//' >./ndir.h <<'//GO.SYSIN DD ./ndir.h'
7920: -/* Copyright (c) 1982 Regents of the University of California */
7921: -/* and modified by pjw in 1986 */
7922: -
7923: -/*
7924: - * this must be a power of 2 and a multiple of all the ones in the system
7925: - */
7926: -#define DIRBLKSIZ 512
7927: -
7928: -/*
7929: - * This limits the directory name length. Its main constraint
7930: - * is that it appears twice in the user structure. (u. area) in bsd systems
7931: - */
7932: -#define MAXNAMLEN 255
7933: -
7934: -struct direct {
7935: - unsigned long d_ino;
7936: - short d_reclen;
7937: - short d_namlen;
7938: - char d_name[MAXNAMLEN + 1];
7939: - /* typically shorter */
7940: -};
7941: -
7942: -struct _dirdesc {
7943: - int dd_fd;
7944: - long dd_loc; /* where we left off in dd_buf */
7945: - long dd_size; /* bytes back from system */
7946: - long dd_offset; /* lseek at beginning of dd_buf */
7947: - char dd_buf[DIRBLKSIZ];
7948: -};
7949: -
7950: -/*
7951: - * useful macros.
7952: - */
7953: -#define NDIRSIZ(dp) \
7954: - ((sizeof(struct direct) - MAXNAMLEN + (dp)->d_namlen + sizeof(ino_t) - 1) &\
7955: - ~(sizeof(ino_t) - 1))
7956: -typedef struct _dirdesc DIR;
7957: -#ifndef NULL
7958: -#define NULL 0
7959: -#endif
7960: -
7961: -/*
7962: - * functions defined on directories
7963: - */
7964: -extern DIR *opendir();
7965: -extern struct direct *readdir();
7966: -extern long telldir();
7967: -extern void seekdir();
7968: -#define rewinddir(dirp) seekdir((dirp), 0)
7969: -extern void closedir();
7970: //GO.SYSIN DD ./ndir.h
7971: echo ./tmac.an 1>&2
7972: sed 's/.//' >./tmac.an <<'//GO.SYSIN DD ./tmac.an'
7973: -'''\" PWB Manual Entry Macros - 1.36 of 11/11/80
7974: -'''\" Nroff/Troff Version @(#)1.36
7975: -'''\" Option -rs1 short (9") pages
7976: -'''\" Option -rp# set no. of first page, put no. of pgs. on stderr
7977: -'''\" Option -rd1 give modified date instead of printed date
7978: -.deth
7979: -.tmwrong version of man entry macros - use -man6
7980: -.ab
7981: -..
7982: -.ifn .ds Tm \uTM\d
7983: -.ift .ds Tm \v'-0.5m'\s-4TM\s+4\v'0.5m'
7984: -.de}E
7985: -.}f
7986: -.in\\n()Ru+\\n(INu
7987: -.ll\\n(LLu
7988: -.lt\\n(LLu
7989: -.pl\\n()Lu
7990: -..
7991: -.deDT
7992: -.ift .ta 3.6m 7.2m 10.8m 14.4m 18m 21.6m 25.2m 28.8m 32.4m 36m 39.6m 43.2m 46.8m
7993: -.ifn .ta 5n 10n 15n 20n 25n 30n 35n 40n 45n 50n 55n 60n 65n
7994: -..
7995: -.de HY
7996: -.hy14
7997: -..
7998: -.de}f
7999: -.ift .vs \\n()Vp
8000: -.ps\\n()S
8001: -.ft1
8002: -..
8003: -.de}H
8004: -.ev1
8005: -.}C
8006: -.}E
8007: -.ie\\n()s 'sp |2v
8008: -.el'sp |3v
8009: -.".ps\\n()S-1
8010: -.".iet .bd1 3
8011: -.".el.bd1 0
8012: -.tl \\*(]H\\*(]L\\*(]H
8013: -.bd1
8014: -.ps\\n()S
8015: -.ie\\n()s 'sp 1.5v
8016: -.el'sp 3v
8017: -.ev
8018: -.ns
8019: -.if \\n(CL .2C
8020: -..
8021: -.de}F
8022: -.ev1
8023: -.}E
8024: -.if\\n()s 'sp |\\n(.pu-1v-1p
8025: -.if\\n()t 'sp |\\n(.pu-3v
8026: -.ifn 'sp |\\n(.pu-4v
8027: -.ifn .tl Page %\\*(]D\\*(]W
8028: -.if\\n()s .tl - % -
8029: -.if\\n()t \{.if o .tl Page %\\*(]D\\*(]W
8030: -.ife .tl \\*(]W\\*(]DPage % \}
8031: -.ev
8032: -'bp
8033: -..
8034: -.ifn .ig
8035: -.de}C
8036: -.if "\\*(.T"aps"\{\
8037: -. po0i
8038: -. lt7.5i
8039: -. if\\n()s .tl \l0.25i\l0.25i\h1i\l0.25i
8040: -. if\\n()t .tl \l0.25i\l0.25i
8041: -. lt
8042: -. po\}
8043: -..
8044: -.de}M
8045: -.}N
8046: -.wh-.5p }C
8047: -.ll\\n(LLu
8048: -.}P
8049: -..
8050: -.de}K
8051: -.}N
8052: -.pl1
8053: -.ll\\n(LLu
8054: -..
8055: -.de}P
8056: -.nr )P \\n%+1-\\np
8057: -.if \\nq .tm \\n(.F \\n()P \\np
8058: -.bp
8059: -.if \\nq .nr p \\n%
8060: -..
8061: -.deTH
8062: -.PD
8063: -.nrIN \\n()Mu
8064: -.ift .ds ]H \\$1\^(\^\\$2\^)
8065: -.ifn .ds ]H \\$1(\\$2)
8066: -.if\\n()s .ds ]D
8067: -.if\\n()t .ds ]D Tenth Edition
8068: -.ifn .ds ]D Tenth Edition
8069: -.ds]L
8070: -.if!\\$3 .ds ]L (\^\\$3\^)
8071: -.if!\\$4 .ds ]D \\$4
8072: -.wh0 }H
8073: -.wh-\\n(:mu }F
8074: -.em}M
8075: -.if\\n(nl .}P
8076: -.nr)I \\n()Mu
8077: -.nr)R 0
8078: -.}E
8079: -.DT
8080: -.ifn \{.na
8081: -.nh\}
8082: -.ift \{.bd S 3 3
8083: -.HY \}
8084: -..
8085: -.deSH
8086: -.PD
8087: -.}X 0 "\\$1" smaller
8088: -.nr)E 2
8089: -\&\\$1 \|\\$2 \|\\$3 \|\\$4 \|\\$5 \|\\$6
8090: -..
8091: -.deSS
8092: -.}X 3n "" ""
8093: -.nr)E 2
8094: -\&\\$1 \|\\$2 \|\\$3 \|\\$4 \|\\$5 \|\\$6
8095: -..
8096: -.de}X
8097: -.}E
8098: -.ti\\$1
8099: -.sp\\n(PDu
8100: -.ne1.1v
8101: -.nr)R 0
8102: -.fi
8103: -'''ss12
8104: -'''if\\$2SYNOPSIS .ss 18
8105: -.it1 }N
8106: -.if!\\$3 .SM
8107: -.iet .bd1 3
8108: -.el.bd1 0
8109: -..
8110: -.de}2
8111: -.nr)E 0
8112: -.}E
8113: -.nr)I \\n()Mu
8114: -.ns
8115: -.bd1
8116: -..
8117: -.deSM
8118: -.nh
8119: -.ps\\n()S-1
8120: -.if!\\$1 \&\\$1
8121: -.if!\\$2 \&\\$2
8122: -.if!\\$3 \&\\$3
8123: -.if!\\$4 \&\\$4
8124: -.if!\\$5 \&\\$5
8125: -.if!\\$6 \&\\$6
8126: -.if!\\$1 .ps \\n()S
8127: -.if\\$1 .it 1 }N
8128: -.HY
8129: -..
8130: -.deI
8131: -.nh
8132: -.ft2
8133: -.it1 }N
8134: -.if!\\$1 \&\\$1 \\$2 \\$3 \\$4 \\$5 \\$6
8135: -.HY
8136: -..
8137: -.deB
8138: -.nh
8139: -.it1 }N
8140: -.ie!\\$1 \%\&\f5\\$1 \\$2 \\$3 \\$4 \\$5 \\$6
8141: -.el .ft5
8142: -.HY
8143: -..
8144: -.deL
8145: -.nh
8146: -.it1 }N
8147: -.ift \{.ie!\\$1 \%\&\f5\\$1 \\$2 \\$3 \\$4 \\$5 \\$6
8148: -.el .ft5 \}
8149: -.ifn \{.ft5
8150: -.if!\\$1 \{.ie\\$2 `\\$1'
8151: -.el .ie\\$3 `\\$1 \\$2'
8152: -.el .ie\\$4 `\\$1 \\$2 \\$3'
8153: -.el .ie\\$5 `\\$1 \\$2 \\$3 \\$4'
8154: -.el .ie\\$6 `\\$1 \\$2 \\$3 \\$4 \\$5'
8155: -.el `\\$1 \\$2 \\$3 \\$4 \\$5 \\$6'\}\}
8156: -.HY
8157: -..
8158: -.deF
8159: -.nh
8160: -.it1 }N
8161: -.ie!\\$1 \%\&\f5\\$1 \\$2 \\$3 \\$4 \\$5 \\$6
8162: -.el .ft5
8163: -.HY
8164: -..
8165: -.deRI
8166: -.nh
8167: -.}S 1 2 \& "\\$1" "\\$2" "\\$3" "\\$4" "\\$5" "\\$6"
8168: -.HY
8169: -.}f
8170: -..
8171: -.deIR
8172: -.nh
8173: -.}S 2 1 \& "\\$1" "\\$2" "\\$3" "\\$4" "\\$5" "\\$6"
8174: -.HY
8175: -.}f
8176: -..
8177: -.deIB
8178: -.nh
8179: -.ift .}S 2 5 \%\& "\\$1" "\\$2" "\\$3" "\\$4" "\\$5" "\\$6"
8180: -.ifn .}S 2 1 \%\& "\\$1" "\\$2" "\\$3" "\\$4" "\\$5" "\\$6"
8181: -.HY
8182: -.}f
8183: -..
8184: -.deRB
8185: -.nh
8186: -.ift .}S 1 5 \%\& "\\$1" "\\$2" "\\$3" "\\$4" "\\$5" "\\$6"
8187: -.ifn .}S 1 1 \%\& "\\$1" "\\$2" "\\$3" "\\$4" "\\$5" "\\$6"
8188: -.HY
8189: -.}f
8190: -..
8191: -.deBR
8192: -.nh
8193: -.ift .}S 5 1 \%\& "\\$1" "\\$2" "\\$3" "\\$4" "\\$5" "\\$6"
8194: -.ifn .}S 1 1 \%\& "\\$1" "\\$2" "\\$3" "\\$4" "\\$5" "\\$6"
8195: -.HY
8196: -.}f
8197: -..
8198: -.deBI
8199: -.nh
8200: -.ift .}S 5 2 \%\& "\\$1" "\\$2" "\\$3" "\\$4" "\\$5" "\\$6"
8201: -.ifn .}S 1 2 \%\& "\\$1" "\\$2" "\\$3" "\\$4" "\\$5" "\\$6"
8202: -.HY
8203: -.}f
8204: -..
8205: -.de LR
8206: -.nh
8207: -.ift \%\&\f5\\$1\f1\\$2
8208: -.ifn \%`\\$1'\\$2
8209: -.HY
8210: -..
8211: -.de RL
8212: -.nh
8213: -.ift \%\&\f1\\$1\\f5\\$2\\f1\\$3
8214: -.ifn \%\\$1`\\$2'\\$3
8215: -.HY
8216: -..
8217: -.de}S
8218: -.ds]F
8219: -.if\\$12 .if !\\$5 .ds ]F \^
8220: -.if\\$22 .if !\\$5 .ds ]F \^
8221: -.ie!\\$4 .}S \\$2 \\$1 "\\$3\f\\$1\\$4\\*(]F" "\\$5" "\\$6" "\\$7" "\\$8" "\\$9"
8222: -.el\\$3
8223: -.}f
8224: -..
8225: -.deFR
8226: -\%\&\f5\\$1\f1\\$2 \\$3 \\$4 \\$5 \\$6
8227: -..
8228: -.deRF
8229: -\%\&\f1\\$1\f5\\$2\f1\\$3
8230: -..
8231: -.deEX
8232: -.ift .ft5
8233: -.nf
8234: -..
8235: -.deEE
8236: -.ft1
8237: -.fi
8238: -..
8239: -.dePP
8240: -.sp\\n(PDu
8241: -.ne1.1v
8242: -.}E
8243: -.nr)I \\n()Mu
8244: -.ns
8245: -..
8246: -.deP
8247: -.PP
8248: -..
8249: -.deLP
8250: -.PP
8251: -..
8252: -.dePD
8253: -.ift .nr PD .4v
8254: -.ifn .nr PD 1v
8255: -.if!\\$1 .nr PD \\$1v
8256: -..
8257: -.deHP
8258: -.sp\\n(PDu
8259: -.ne1.1v
8260: -.if!\\$1 .nr )I \\$1n
8261: -.ll\\n(LLu
8262: -.in\\n()Ru+\\n(INu+\\n()Iu
8263: -.ti\\n()Ru+\\n(INu
8264: -.}f
8265: -..
8266: -.deIP
8267: -.ie!\\$1 \{.TP "\\$2"
8268: -\&\\$1\}
8269: -.el\{.sp\\n(PDu
8270: -.ne1.1v
8271: -.if!\\$2 .nr )I \\$2n
8272: -.}f
8273: -.ll\\n(LLu
8274: -.in\\n()Ru+\\n(INu+\\n()Iu
8275: -.lg\}
8276: -..
8277: -.deTP
8278: -.if!\\$1 \{.nr )I \\$1n
8279: -.if\\$10 .nr )I \\n()M\}
8280: -.sp\\n(PDu
8281: -.ne1.1v
8282: -.in\\n()Ru
8283: -.lg0
8284: -.ns
8285: -.it1 }N
8286: -.nr)E 1
8287: -.di]B
8288: -..
8289: -.deTF
8290: -.IP "" \w'\f5\\$1\ \ \fP'u
8291: -.PD0
8292: -..
8293: -.de}1
8294: -.ds]X \&\\*(]B\\
8295: -.rm]B
8296: -.nr)E 0
8297: -.if!\\$1 .nr )I \\$1n
8298: -.}f
8299: -.ll\\n(LLu
8300: -.in\\n()Ru+\\n(INu+\\n()Iu
8301: -.ti\\n(INu
8302: -.ie!\\n()Iu+\\n()Ru-\w\\*(]Xu-3p \{\\*(]X
8303: -.br\}
8304: -.el\\*(]X\h|\\n()Iu+\\n()Ru\c
8305: -.}f
8306: -.lg
8307: -..
8308: -.de}N
8309: -.if\\n()E .br
8310: -.if\\n()E1 .di
8311: -.if\\n()E0 .}f
8312: -.if\\n()E1 .}1
8313: -.if\\n()E2 .}2
8314: -..
8315: -.deRS
8316: -.nr]\\n+()p \\n()I
8317: -.nr)\\n()p \\n()R
8318: -.ie!\\$1 .nr )R +\\$1n
8319: -.el.nr )R +\\n()I
8320: -.nr)I \\n()Mu
8321: -.}E
8322: -..
8323: -.deRE
8324: -.if!\\$1 \{.ie \\$10 .nr )p 1 1
8325: -.el.nr )p \\$1 1 \}
8326: -.ds]i \\*(]I\\n()p
8327: -.ds]r \\*(]R\\n()p
8328: -.nr)I \\*(]i
8329: -.nr)R \\*(]r
8330: -.if\\n()p .nr )p -1
8331: -.}E
8332: -..
8333: -'''\" .2C begin 2-column display, by diversion
8334: -'''\" CC=amount of text that will fit on page
8335: -'''\" CL=1 multicolumn in effect, else 0
8336: -'''\" CI saved indent
8337: -'''\" CB contains diverted text
8338: -.de 2C
8339: -.ne 2
8340: -.nf
8341: -.nr CC \\n(.t/1v*2v
8342: -.nr CI \\n(IN
8343: -.nr IN 0
8344: -.di CB
8345: -.nr CL 1
8346: -.}E
8347: -.dt \\n(CCu C1
8348: -..
8349: -'''\" .1C return to 1-column
8350: -.de 1C
8351: -.nr CL 0
8352: -.C1
8353: -.fi
8354: -..
8355: -'''\" end of diversion, at end of page or return to 1-column
8356: -'''\" CC=pos of nominal column end
8357: -.de C1
8358: -.dt
8359: -\!.C3
8360: -.di
8361: -.if \\n(dn \{.nr CC \\n(dnu/2u+\\n(nlu
8362: -.wh \\n(CCu C2
8363: -.mk
8364: -.nf
8365: -.nr IN \\n(CIu
8366: -.}E
8367: -.CB \}
8368: -..
8369: -'''\" end of first column retrieved from diversion
8370: -'''\" CC=pos of actual column end
8371: -.de C2
8372: -.wh \\n(CCu
8373: -.mk CC
8374: -.po +(\\n(LLu/2u)u
8375: -.rt
8376: -.if \\n(dn>1v .ns
8377: -..
8378: -'''\" end of second column
8379: -.de C3
8380: -.br
8381: -.po -(\\n(LLu/2u)u
8382: -.if \\n(CC>\\n(nl .sp |\\n(CCu
8383: -.ne 2
8384: -..
8385: -.dePM
8386: -.if\\$1 .nr !K 0
8387: -.if\w\\$1 \{\
8388: -.ie\\$1P .nr !K 1
8389: -.el.ie \\$1BP .nr !K 3
8390: -.el.ie \\$1BR .nr !K 4
8391: -.el.nr !K 2 \}
8392: -.if\\n(!K .wh -(\\n(:mu+5v) )G
8393: -..
8394: -.de)G
8395: -.if\\n(!K 'sp 2v
8396: -.ie\\n(!K=1 \{\
8397: -.iet .bd1 3
8398: -.el.bd1 0
8399: -.tlPRIVATE
8400: -.bd1
8401: -.tlThis information should not be disclosed to unauthorized persons.
8402: -.tlIt is meant solely for use by authorized Bell System employees. \}
8403: -.el.ie \\n(!K=3 \{\
8404: -.iet .bd1 3
8405: -.el.bd1 0
8406: -.tlBELL LABORATORIES PROPRIETARY
8407: -.bd1
8408: -.tlNot for use or disclosure outside Bell Laboratories except by
8409: -.tlwritten approval of the director of the distributing organization. \}
8410: -.el.ie \\n(!K=4 \{\
8411: -.iet .bd1 3
8412: -.el.bd1 0
8413: -.tlBELL LABORATORIES RESTRICTED
8414: -.bd1
8415: -.tlThe information herein is meant solely for use by authorized
8416: -.tlBell Laboratories employees and is not to be disclosed to others. \}
8417: -.el.if \\n(!K=2 \{\
8418: -.iet .bd1 3
8419: -.el.bd1 0
8420: -.tlNOTICE
8421: -.bd1
8422: -.tlNot for use or disclosure outside the
8423: -.tlBell System except under written agreement. \}
8424: -..
8425: -.nr)s 0
8426: -.ift .if \ns .nr )s 1
8427: -.nr)t 0
8428: -.ift .if !\ns .nr )t 1
8429: -.if\n()s \{.nr )L 9i
8430: -.nrLL 4.75i
8431: -.nr)O .75i
8432: -.nr)S 9
8433: -.nr)V 10 \}
8434: -.if\n()t \{.nr )L 11i
8435: -.nrLL 6.5i
8436: -.nr)O 1i
8437: -.nr)S 10
8438: -.nr)V 12 \}
8439: -.ift \{.ds R \(rg
8440: -.dsS \s\n()S
8441: -..\}
8442: -.ifn \{.nr )L 11i
8443: -.nrLL 6.5i
8444: -.nr)O .463i
8445: -.if '\*(.T'think' \{.nrLL 80n
8446: -.nr)O 0\}
8447: -.if '\*(.T'thinksmall' \{.nrLL 142n
8448: -.vs 9p
8449: -.nr)O 0\}
8450: -.dsR (Reg.)
8451: -.dsS
8452: -..\}
8453: -.if\nT .nr LL 80n
8454: -.if\nV>1 \{
8455: -.nrLL 82n
8456: -.nr)L 84v
8457: -.rmul \}
8458: -.nr)p 0 1
8459: -.ds]I \\\\n(]
8460: -.ds]R \\\\n()
8461: -.if\nd0 .nr m \n(mo-1
8462: -.if\nm0 .ds ]m January
8463: -.if\nm1 .ds ]m February
8464: -.if\nm2 .ds ]m March
8465: -.if\nm3 .ds ]m April
8466: -.if\nm4 .ds ]m May
8467: -.if\nm5 .ds ]m June
8468: -.if\nm6 .ds ]m July
8469: -.if\nm7 .ds ]m August
8470: -.if\nm8 .ds ]m September
8471: -.if\nm9 .ds ]m October
8472: -.if\nm10 .ds ]m November
8473: -.if\nm11 .ds ]m December
8474: -.ifn \{.nr m \nm+1
8475: -.ie\nd .ds ]W (last mod. \nm/\nd/\ny)
8476: -.el.ds ]W (printed \n(mo/\n(dy/\n(yr)
8477: -..\}
8478: -.if\n()s .ds ]W
8479: -.if\n()t \{.ie \nd .ds ]W \*(]m \nd, 19\ny
8480: -.el.ds ]W \*(]m \n(dy, 19\n(yr
8481: -..\}
8482: -.pl\n()Lu
8483: -.ll\n(LLu
8484: -.lt\n(LLu
8485: -.po\n()Ou
8486: -.fp 5 L CW
8487: -.ift .tr \``\''
8488: -.}f
8489: -.if\n()s .nr :m 3.5v
8490: -.if\n()t .nr :m 6v
8491: -.ifn .nr :m 7v
8492: -.ift .nr )M 3.6m
8493: -.ifn .nr )M 5n
8494: -.em}K
8495: -.nr q \np
8496: -.if!\np .nr p 1
8497: -.pn \np
8498: //GO.SYSIN DD ./tmac.an
8499: echo ./mkfile 1>&2
8500: sed 's/.//' >./mkfile <<'//GO.SYSIN DD ./mkfile'
8501: -NAMES=alloc arc bquote builtins dir expand gen glob graph job\
8502: - lex main makefile match mk parse quote\
8503: - recipe regexp rule run shprint sig symtab t_ar t_driver t_file var word
8504: -OBJ=${NAMES:%=%.o}
8505: -NPROC=2
8506: -BUILTINS=
8507: -# for profiling, use -p -DPROF
8508: -CFLAGS=-I.. -DSYSV
8509: -
8510: -nmk: $OBJ
8511: - $CC $CFLAGS -o nmk $OBJ fio/fio.a libc/libc.a math/math.a
8512: -
8513: -goo:V: nmk
8514: - nmk
8515: -
8516: -clean:V:
8517: - rm -f cyntax nmk *.o O/*
8518: -
8519: -install:V: nmk
8520: - cp nmk /usr/bin/mk
8521: - strip /usr/bin/mk
8522: -
8523: -pp:V:
8524: - pr *.h *.c | lp -dpsu -n2
8525: -
8526: -%.o: mk.h
8527: -
8528: -%.o: %.c
8529: - $CC $CFLAGS -c $stem.c
8530: -
8531: -tut.out: tut.ms
8532: - pic tut.ms | tbl | troff -Tpost -ms > tut.out
8533: -
8534: -sane:V: nmk
8535: - cp nmk goo
8536: - rm arc.o; goo -e
8537: - goo -e -wjob.o
8538: -
8539: -poot:V: nmk
8540: - echo 'pooter Any Dk,g nj/fart/whistle.uucp' >> /n/research/usr/lib/uucp/Systems.dk
8541: - ./nmk -k -i -f /usr/lib/upas/mkfile NPROC=1 systems
8542: //GO.SYSIN DD ./mkfile
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.