![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to b.i CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests|
Return to b.i CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests |
1.1 root 1: typedef unsigned char u_char;
2: typedef unsigned short u_short;
3: typedef unsigned int u_int;
4: typedef unsigned long u_long;
5: typedef struct _physadr { int r[1]; } *physadr;
6: typedef int daddr_t;
7: typedef char * caddr_t;
8: typedef u_short ino_t;
9: typedef int swblk_t;
10: typedef int size_t;
11: typedef int time_t;
12: typedef int label_t[14];
13: typedef short dev_t;
14: typedef int off_t;
15: typedef long portid_t;
16: typedef struct fd_set { int fds_bits[1]; } fd_set;
17: extern struct _iobuf {
18: int _cnt;
19: unsigned char *_ptr;
20: unsigned char *_base;
21: short _flag;
22: char _file;
23: } _iob[20];
24: struct _iobuf *fopen();
25: struct _iobuf *fdopen();
26: struct _iobuf *freopen();
27: long ftell();
28: char *fgets();
29: extern char _ctype[];
30: typedef int (*SIG_TYP)();
31: SIG_TYP signal();
32: struct dir
33: {
34: ino_t d_ino;
35: char d_name[14];
36: };
37: struct vtimes {
38: int vm_utime;
39: int vm_stime;
40:
41: unsigned vm_idsrss;
42: unsigned vm_ixrss;
43: int vm_maxrss;
44: int vm_majflt;
45: int vm_minflt;
46: int vm_nswap;
47: int vm_inblk;
48: int vm_oublk;
49: };
50: struct timeb
51: {
52: time_t time;
53: unsigned short millitm;
54: short timezone;
55: short dstflag;
56: };
57: struct vtimes newv, oldv;
58: struct timeb newt, oldt;
59: char *cpp = "/lib/cpp";
60: char *ccom = "/usr/pjw/comp/vcc/comp.sv";
61: char *c2 = "/lib/c2";
62: char *as = "/bin/as";
63: char *ld = "/bin/ld";
64: char *crt0 = "/lib/crt0.o";
65: char tmp0[30];
66: char *tmp1, *tmp2, *tmp3, *tmp4, *tmp5;
67: char *outfile;
68: char *savestr(), *strspl(), *setsuf();
69: int idexit();
70: char **av, **clist, **llist, **plist;
71: int cflag, eflag, gflag, oflag, pflag, sflag, wflag, Rflag, exflag, proflag;
72: int vflag;
73: char *dflag;
74: int exfail;
75: char *chpass;
76: char *npassname;
77: extern int optind;
78: extern int opterr;
79: extern char *optarg;
80: extern int optopt;
81: int nc, nl, np, nxo, na;
82: main(argc, argv)
83: char **argv;
84: {
85: char *t;
86: char *assource;
87: int i, j, c;
88:
89: av = (char **)calloc(argc+10, sizeof (char **));
90: clist = (char **)calloc(argc, sizeof (char **));
91: llist = (char **)calloc(argc, sizeof (char **));
92: plist = (char **)calloc(argc, sizeof (char **));
93: opterr = 0;
94: while (optind<argc) switch (c = getopt(argc, argv, "vsSo:ROPgwEpPcD:I:U:C:t:B:l:d:")) {
95: case 'v':
96: vflag++;
97: continue;
98: case 'S':
99: sflag++;
100: cflag++;
101: continue;
102: case 'l':
103: llist[nl++] = strspl("-l", optarg);
104: continue;
105: case 'o':
106: outfile = optarg;
107: switch (getsuf(outfile)) {
108: case 'c':
109: case 'o':
110: error("-o would overwrite %s", outfile);
111: exit(8);
112: }
113: continue;
114: case 'R':
115: Rflag++;
116: continue;
117: case 'O':
118: oflag++;
119: continue;
120: case 'p':
121: proflag++;
122: continue;
123: case 'g':
124: gflag++;
125: continue;
126: case 'w':
127: wflag++;
128: continue;
129: case 'E':
130: exflag++;
131: case 'P':
132: pflag++;
133: t = strspl("-", "x");
134: t[1] = optopt;
135: plist[np++] = t;
136: case 'c':
137: cflag++;
138: continue;
139: case 'D':
140: case 'I':
141: case 'U':
142: case 'C':
143: plist[np] = strspl("-X", optarg);
144: plist[np++][1] = c;
145: continue;
146: case 't':
147: if (chpass)
148: error("-t overwrites earlier option", 0);
149: chpass = optarg;
150: if (chpass[0]==0)
151: chpass = "012p";
152: continue;
153: case 'B':
154: if (npassname)
155: error("-B overwrites earlier option", 0);
156: npassname = optarg;
157: if (npassname[0]==0)
158: npassname = "/usr/c/o";
159: continue;
160: case 'd':
161: dflag = strspl("-d", optarg);
162: continue;
163: case '?':
164: case 's':
165: t = strspl("-", "x");
166: t[1] = optopt;
167: llist[nl++] = t;
168: continue;
169: case (-1):
170: t = argv[optind];
171: optind++;
172: c = getsuf(t);
173: if (c=='c' || c=='s' || c=='i' || exflag) {
174: clist[nc++] = t;
175: t = setsuf(t, 'o');
176: }
177: if (nodup(llist, t)) {
178: llist[nl++] = t;
179: if (getsuf(t)=='o')
180: nxo++;
181: }
182: }
183: if (gflag) {
184: if (oflag)
185: fprintf((&_iob[2]), "cc: warning: -g disables -O\n");
186: oflag = 0;
187: }
188: if (npassname && chpass ==0)
189: chpass = "012p";
190: if (chpass && npassname==0)
191: npassname = "/usr/new";
192: if (chpass)
193: for (t=chpass; *t; t++) {
194: switch (*t) {
195: case '0':
196: ccom = strspl(npassname, "ccom");
197: continue;
198: case '2':
199: c2 = strspl(npassname, "c2");
200: continue;
201: case 'p':
202: cpp = strspl(npassname, "cpp");
203: continue;
204: }
205: }
206: if (proflag)
207: crt0 = "/lib/mcrt0.o";
208: if (nc==0)
209: goto nocom;
210: if (signal(2 , (int (*)())1) != (int (*)())1)
211: (void)signal(2 , idexit);
212: if (signal(15 , (int (*)())1) != (int (*)())1)
213: (void)signal(15 , idexit);
214: if (pflag==0)
215: sprintf(tmp0, "/tmp/ctm%05.5d", getpid());
216: tmp1 = strspl(tmp0, "1");
217: tmp2 = strspl(tmp0, "2");
218: tmp3 = strspl(tmp0, "3");
219: if (pflag==0)
220: tmp4 = strspl(tmp0, "4");
221: if (oflag)
222: tmp5 = strspl(tmp0, "5");
223: for (i=0; i<nc; i++) {
224: int suffix = getsuf(clist[i]);
225: if (nc > 1) {
226: printf("%s:\n", clist[i]);
227: fflush((&_iob[1]));
228: }
229: if (suffix == 's') {
230: assource = clist[i];
231: goto assemble;
232: } else
233: assource = tmp3;
234: if (suffix == 'i')
235: goto compile;
236: if (pflag)
237: tmp4 = setsuf(clist[i], 'i');
238: av[0] = "cpp";
239: av[1] = clist[i];
240: av[2] = exflag ? "-" : tmp4;
241: na = 3;
242: for (j = 0; j < np; j++)
243: av[na++] = plist[j];
244: av[na++] = 0;
245: switch (callsys(cpp, av)) {
246: case 0:
247: break;
248: default:
249: if (callsys("/lib/cpre",av)) {
250: exfail++;
251: exflag++;
252: }
253: }
254: if (pflag || exfail) {
255: cflag++;
256: continue;
257: }
258: if (sflag)
259: assource = tmp3 = setsuf(clist[i], 's');
260: compile:
261: av[0] = "ccom";
262: av[1] = suffix=='i'? clist[i]: tmp4;
263: av[2] = oflag? tmp5:tmp3;
264: na = 3;
265: if (proflag)
266: av[na++] = "-XP";
267: if (gflag)
268: av[na++] = "-Xg";
269: if (wflag)
270: av[na++] = "-w";
271: av[na] = 0;
272: if (callsys(ccom, av)) {
273: cflag++;
274: eflag++;
275: continue;
276: }
277: if (oflag) {
278: av[0] = "c2"; av[1] = tmp5; av[2] = tmp3; av[3] = 0;
279: if (callsys(c2, av)) {
280: unlink(tmp3);
281: tmp3 = assource = tmp5;
282: } else
283: unlink(tmp5);
284: }
285: if (sflag)
286: continue;
287: assemble:
288: if (tmp1) unlink(tmp1); if (tmp2) unlink(tmp2); if (tmp4) unlink(tmp4);
289: av[0] = "as"; av[1] = "-o"; av[2] = setsuf(clist[i], 'o');
290: na = 3;
291: if (Rflag)
292: av[na++] = "-R";
293: if (dflag)
294: av[na++] = dflag;
295: av[na++] = assource;
296: av[na] = 0;
297: if (callsys(as, av) > 1) {
298: cflag++;
299: eflag++;
300: continue;
301: }
302: }
303: nocom:
304: if (cflag==0 && nl!=0) {
305: i = 0;
306: av[0] = "ld"; av[1] = "-X"; av[2] = crt0; na = 3;
307: if (outfile) {
308: av[na++] = "-o";
309: av[na++] = outfile;
310: }
311: while (i < nl)
312: av[na++] = llist[i++];
313: if (gflag)
314: av[na++] = "-lg";
315: av[na++] = "-lc";
316: av[na++] = 0;
317: eflag |= callsys(ld, av);
318: if (nc==1 && nxo==1 && eflag==0)
319: unlink(setsuf(clist[0], 'o'));
320: }
321: dexit();
322: }
323: idexit()
324: {
325: eflag = 100;
326: dexit();
327: }
328: dexit()
329: {
330: if (!pflag) {
331: if (tmp1) unlink(tmp1);
332: if (tmp2) unlink(tmp2);
333: if (sflag==0)
334: if (tmp3) unlink(tmp3);
335: if (tmp4) unlink(tmp4);
336: if (tmp5) unlink(tmp5);
337: }
338: exit(eflag);
339: }
340: error(s, x)
341: char *s, *x;
342: {
343: struct _iobuf *diag = exflag ? (&_iob[2]) : (&_iob[1]);
344: fprintf(diag, "cc: ");
345: fprintf(diag, s, x);
346: (--( diag)->_cnt>=0? ((int)(*( diag)->_ptr++=(unsigned)('\n'))):_flsbuf((unsigned)('\n'), diag));
347: exfail++;
348: cflag++;
349: eflag++;
350: }
351: getsuf(as)
352: char as[];
353: {
354: register int c;
355: register char *s;
356: register int t;
357: s = as;
358: c = 0;
359: while (t = *s++)
360: if (t=='/')
361: c = 0;
362: else
363: c++;
364: s -= 3;
365: if (c <= 14 && c > 2 && *s++ == '.')
366: return (*s);
367: return (0);
368: }
369: char *
370: setsuf(as, ch)
371: char *as;
372: {
373: register char *s, *s1;
374: s = s1 = savestr(as);
375: while (*s)
376: if (*s++ == '/')
377: s1 = s;
378: s[-1] = ch;
379: return (s1);
380: }
381: callsys(f, v)
382: char *f, **v;
383: {
384: int t, status;
385: register char **vp;
386: if(vflag) {
387: vp = v;
388: fprintf((&_iob[2]),"+ ");
389: while (*vp)
390: fprintf((&_iob[2]),"%s ",*vp++);
391: fprintf((&_iob[2]), "\n");
392: }
393: ftime(&oldt);
394: vtimes(0, &oldv);
395: t = vfork();
396: if (t == -1) {
397: printf("No more processes\n");
398: return (100);
399: }
400: if (t == 0) {
401: execv(f, v);
402: printf("Can't find %s\n", f);
403: fflush((&_iob[1]));
404: _exit(100);
405: }
406: while (t != wait(&status))
407: ;
408: ftime(&newt);
409: vtimes(0, &newv);
410: printf("%s\n", f);
411: printf("real %g user %g sys %g ", newt.time - oldt.time
412: + newt.millitm / 1000. - oldt.millitm / 1000.,
413: (newv.vm_utime - oldv.vm_utime) / 60.,
414: (newv.vm_stime - oldv.vm_stime) / 60.);
415: printf("reads %d writes %d\n", newv.vm_inblk - oldv.vm_inblk,
416: newv.vm_oublk - oldv.vm_oublk);
417: if ((t=(status&0377)) != 0 && t!=14) {
418: if (t!=2) {
419: printf("Fatal error in %s\n", f);
420: eflag = 8;
421: }
422: dexit();
423: }
424: return ((status>>8) & 0377);
425: }
426: nodup(l, os)
427: char **l, *os;
428: {
429: register char *t, *s;
430: register int c;
431: s = os;
432: if (getsuf(s) != 'o')
433: return (1);
434: while (t = *l++) {
435: while (c = *s++)
436: if (c != *t++)
437: break;
438: if (*t==0 && c==0)
439: return (0);
440: s = os;
441: }
442: return (1);
443: }
444: char *savetab;
445: int saveleft;
446: char *
447: savestr(cp)
448: register char *cp;
449: {
450: register int len;
451: len = strlen(cp) + 1;
452: if (len > saveleft) {
453: saveleft = 1024;
454: if (len > saveleft)
455: saveleft = len;
456: savetab = (char *)malloc(saveleft);
457: if (savetab == 0) {
458: fprintf((&_iob[2]), "ran out of memory (savestr)\n");
459: exit(1);
460: }
461: }
462: strncpy(savetab, cp, len);
463: cp = savetab;
464: savetab += len;
465: saveleft -= len;
466: return (cp);
467: }
468: char *
469: strspl(left, right)
470: char *left, *right;
471: {
472: char buf[1024];
473: strcpy(buf, left);
474: strcat(buf, right);
475: return (savestr(buf));
476: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.