![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to f77.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / f77 / f77.tahoe|
Return to f77.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / f77 / f77.tahoe |
1.1 root 1: /*
2: * f77.c
3: *
4: * Driver program for the 4.2 BSD f77 compiler.
5: *
6: * University of Utah CS Dept modification history:
7: *
8: * $Log: f77.c,v $
9: * Revision 1.14 85/03/01 00:07:57 donn
10: * Portability fix from Ralph Campbell.
11: *
12: * Revision 1.13 85/02/12 19:31:47 donn
13: * Use CATNAME to get the name of a concatenation command instead of
14: * explicitly running 'cat' -- you can get the wrong 'cat' the old way!
15: *
16: * Revision 1.12 85/01/14 06:42:30 donn
17: * Changed to call the peephole optimizer with the '-f' flag, so that
18: * floating point moves are translated to integer moves.
19: *
20: * Revision 1.11 85/01/14 04:38:59 donn
21: * Jerry's change to pass -O to f1 so it knows whether the peephole optimizer
22: * will be run. This is necessary in order to handle movf/movl translation.
23: *
24: * Revision 1.10 85/01/14 03:59:12 donn
25: * Added Jerry Berkman's fix for the '-q' flag.
26: *
27: * Revision 1.9 84/11/09 01:51:26 donn
28: * Cosmetic change to stupid() suggested by John McCarthy at Memorial
29: * University, St. Johns.
30: *
31: * Revision 1.8 84/09/14 16:02:34 donn
32: * Added changes to notice when people do 'f77 -c foo.f -o bar.o' and tell
33: * them why it doesn't do what they think it does.
34: *
35: * Revision 1.7 84/08/24 21:08:31 donn
36: * Added call to setrlimit() to prevent core dumps when not debugging.
37: * Reorganized the include file arrangment somewhat.
38: *
39: * Revision 1.6 84/08/24 20:20:24 donn
40: * Changed stupidity check on Jerry Berkman's suggestion -- now it balks if
41: * the load file exists and has a sensitive suffix.
42: *
43: * Revision 1.5 84/08/15 18:56:44 donn
44: * Added test for -O combined with -g, suggested by Raleigh Romine. To keep
45: * things simple, if both are specified then the second in the list is thrown
46: * out and the user is warned.
47: *
48: * Revision 1.4 84/08/05 21:33:15 donn
49: * Added stupidity check -- f77 won't load on a file that it's asked to
50: * compile as well.
51: *
52: * Revision 1.3 84/08/04 22:58:24 donn
53: * Improved error reporting -- we now explain why we died and what we did.
54: * Only works on 4.2. Added at the instigation of Jerry Berkman.
55: *
56: * Revision 1.2 84/07/28 13:11:24 donn
57: * Added Ralph Campbell's changes to reduce offsets to data.
58: *
59: */
60:
61: char *xxxvers[] = "\n@(#) F77 DRIVER, VERSION 4.2, 1984 JULY 28\n";
62: #include <stdio.h>
63: #include <sys/types.h>
64: #include <sys/stat.h>
65: #include <ctype.h>
66: #include <signal.h>
67:
68: #ifdef SIGPROF
69: /*
70: * Some 4.2 BSD capabilities.
71: */
72: #include <sys/time.h>
73: #include <sys/resource.h>
74: #define NOCORE 1
75: #include <sys/wait.h>
76: #define PSIGNAL 1
77: #define INLINE 1
78: #endif
79:
80: #include "defines.h"
81: #include "machdefs.h"
82: #include "pathnames.h"
83: #include "version.h"
84:
85: static FILEP diagfile = {stderr} ;
86: static int pid;
87: static int sigivalue = 0;
88: static int sigqvalue = 0;
89: static int sighvalue = 0;
90: static int sigtvalue = 0;
91:
92: static char *pass1name = PASS1NAME ;
93: static char *pass2name = PASS2NAME ;
94: static char *pass2opt = PASS2OPT ;
95: static char *asmname = ASMNAME ;
96: static char *ldname = LDNAME ;
97: static char *footname = FOOTNAME;
98: static char *proffoot = PROFFOOT;
99: static char *macroname = "m4";
100: static char *shellname = _PATH_BSHELL;
101: static char *cppname = _PATH_CPP;
102: static char *aoutname = "a.out" ;
103: static char *temppref = TEMPPREF;
104:
105: static char *infname;
106: static char textfname[44];
107: static char asmfname[44];
108: static char asmpass2[44];
109: static char initfname[44];
110: static char sortfname[44];
111: static char prepfname[44];
112: static char objfdefault[44];
113: static char optzfname[44];
114: static char setfname[44];
115:
116: static char fflags[50] = "-";
117: static char f2flags[50];
118: static char cflags[50] = "-c";
119: #if TARGET == GCOS
120: static char eflags[30] = "system=gcos ";
121: #else
122: static char eflags[30] = "system=unix ";
123: #endif
124: static char rflags[30] = "";
125: static char lflag[3] = "-x";
126: static char *fflagp = fflags+1;
127: static char *f2flagp = f2flags;
128: static char *cflagp = cflags+2;
129: static char *eflagp = eflags+12;
130: static char *rflagp = rflags;
131: static char *cppflags = "";
132: static char **cppargs;
133: static char **loadargs;
134: static char **loadp;
135:
136: static flag erred = NO;
137: static flag loadflag = YES;
138: static flag saveasmflag = NO;
139: static flag profileflag = NO;
140: static flag optimflag = NO;
141: static flag debugflag = NO;
142: static flag verbose = NO;
143: static flag nofloating = NO;
144: static flag fortonly = NO;
145: static flag macroflag = NO;
146: static flag sdbflag = NO;
147: static flag namesflag = YES;
148:
149: static int ncpp;
150:
151:
152: main(argc, argv)
153: int argc;
154: char **argv;
155: {
156: int i, c, status;
157: char *setdoto(), *lastchar(), *lastfield(), *copys(), *argvtos();
158: ptr ckalloc();
159: register char *s;
160: char fortfile[20], *t;
161: char buff[100];
162: int intrupt();
163: int new_aoutname = NO;
164:
165: sigivalue = signal(SIGINT, SIG_IGN) == SIG_IGN;
166: sigqvalue = signal(SIGQUIT,SIG_IGN) == SIG_IGN;
167: sighvalue = signal(SIGHUP, SIG_IGN) == SIG_IGN;
168: sigtvalue = signal(SIGTERM,SIG_IGN) == SIG_IGN;
169: enbint(intrupt);
170:
171: pid = getpid();
172: crfnames();
173:
174: cppargs = (char **) ckalloc( argc * sizeof(*cppargs) );
175: loadargs = (char **) ckalloc( (argc+20) * sizeof(*loadargs) );
176: loadargs[1] = "-X";
177: loadargs[2] = "-u";
178: #if HERE==PDP11 || HERE==VAX || HERE==TAHOE
179: loadargs[3] = "_MAIN_";
180: #endif
181: #if HERE == INTERDATA
182: loadargs[3] = "main";
183: #endif
184: loadp = loadargs + 4;
185:
186: --argc;
187: ++argv;
188:
189: while(argc>0 && argv[0][0]=='-' && argv[0][1]!='\0')
190: {
191: for(s = argv[0]+1 ; *s ; ++s) switch(*s)
192: {
193: case 'T': /* use special passes */
194: switch(*++s)
195: {
196: case '1':
197: pass1name = s+1; goto endfor;
198: case '2':
199: pass2name = s+1; goto endfor;
200: case 'p':
201: pass2opt = s+1; goto endfor;
202: case 'a':
203: asmname = s+1; goto endfor;
204: case 'l':
205: ldname = s+1; goto endfor;
206: case 'F':
207: footname = s+1; goto endfor;
208: case 'm':
209: macroname = s+1; goto endfor;
210: case 't':
211: temppref = s+1; goto endfor;
212: default:
213: fatali("bad option -T%c", *s);
214: }
215: break;
216:
217: case '6':
218: if(s[1]=='6')
219: {
220: *fflagp++ = *s++;
221: goto copyfflag;
222: }
223: else {
224: fprintf(diagfile, "invalid flag 6%c\n", s[1]);
225: done(1);
226: }
227:
228: case 'w':
229: if(s[1]=='6' && s[2]=='6')
230: {
231: *fflagp++ = *s++;
232: *fflagp++ = *s++;
233: }
234:
235: copyfflag:
236: case 'u':
237: case 'U':
238: case '1':
239: case 'C':
240: *fflagp++ = *s;
241: break;
242:
243: case 'O':
244: if(sdbflag)
245: {
246: fprintf(diagfile, "-O and -g are incompatible; -O ignored\n");
247: break;
248: }
249: optimflag = YES;
250: #if TARGET == INTERDATA
251: *loadp++ = "-r";
252: *loadp++ = "-d";
253: #endif
254: *fflagp++ = 'O';
255: break;
256:
257: case 'N':
258: *fflagp++ = 'N';
259: if( oneof(*++s, "qxscn") )
260: *fflagp++ = *s++;
261: else {
262: fprintf(diagfile, "invalid flag -N%c\n", *s);
263: done(1);
264: }
265: while( isdigit(*s) )
266: *fflagp++ = *s++;
267: *fflagp++ = 'X';
268: goto endfor;
269:
270: case 'm':
271: if(s[1] == '4')
272: ++s;
273: macroflag = YES;
274: break;
275:
276: case 'S':
277: strcat(cflags, " -S");
278: saveasmflag = YES;
279:
280: case 'c':
281: if( new_aoutname == YES ){
282: fprintf(diagfile, "-c prevents loading, -o %s ignored\n", aoutname);
283: new_aoutname = NO;
284: }
285: loadflag = NO;
286: break;
287:
288: case 'v':
289: verbose = YES;
290: fprintf(diagfile,"\nBerkeley F77, version %s\n",
291: VERSIONNUMBER);
292: break;
293:
294: case 'd':
295: debugflag = YES;
296: *fflagp++ = 'd';
297: s++;
298: while( isdigit(*s) || *s == ',' )
299: *fflagp++ = *s++;
300: *fflagp++ = 'X';
301: goto endfor;
302:
303: case 'M':
304: *loadp++ = "-M";
305: break;
306:
307: case 'g':
308: if(optimflag)
309: {
310: fprintf(diagfile, "-g and -O are incompatible; -g ignored\n");
311: break;
312: }
313: strcat(cflags," -g");
314: sdbflag = YES;
315: goto copyfflag;
316:
317: case 'p':
318: profileflag = YES;
319: strcat(cflags," -p");
320: *fflagp++ = 'p';
321: if(s[1] == 'g')
322: {
323: proffoot = GPRFFOOT;
324: s++;
325: }
326: break;
327:
328: case 'q':
329: namesflag = NO;
330: *fflagp++ = *s;
331: break;
332:
333: case 'o':
334: if( ! strcmp(s, "onetrip") )
335: {
336: *fflagp++ = '1';
337: goto endfor;
338: }
339: new_aoutname = YES;
340: aoutname = *++argv;
341: --argc;
342: if( loadflag == NO ){
343: fprintf(diagfile, "-c prevents loading, -o %s ignored\n", aoutname);
344: new_aoutname = NO;
345: }
346: break;
347:
348: #if TARGET == PDP11
349: case 'f':
350: nofloating = YES;
351: pass2name = NOFLPASS2;
352: break;
353: #endif
354:
355: case 'F':
356: fortonly = YES;
357: loadflag = NO;
358: break;
359: case 'D':
360: case 'I':
361: cppargs[ncpp++] = *argv;
362: goto endfor;
363:
364: case 'i':
365: if((s[1]=='2' || s[1]=='4') && s[2] == '\0')
366: {
367: *fflagp++ = *s++;
368: goto copyfflag;
369: }
370: #ifdef INLINE
371: *f2flagp++ = '-';
372: while(*f2flagp++ = *s++)
373: ;
374: *f2flagp = ' ';
375: if(strcmp(pass2name, PASS2NAME) == 0)
376: pass2name = PASS2INAME;
377: goto endfor;
378: #else
379: fprintf(diagfile, "invalid flag -i%c\n", s[1]);
380: done(1);
381: #endif
382:
383: case 'l': /* letter ell--library */
384: s[-1] = '-';
385: *loadp++ = s-1;
386: goto endfor;
387:
388: case 'E': /* EFL flag argument */
389: while( *eflagp++ = *++s)
390: ;
391: *eflagp++ = ' ';
392: goto endfor;
393: case 'R':
394: while( *rflagp++ = *++s )
395: ;
396: *rflagp++ = ' ';
397: goto endfor;
398: default:
399: lflag[1] = *s;
400: *loadp++ = copys(lflag);
401: break;
402: }
403: endfor:
404: --argc;
405: ++argv;
406: }
407:
408: #ifdef NOCORE
409: if(!debugflag)
410: {
411: struct rlimit r;
412:
413: r.rlim_cur = r.rlim_max = 0;
414: setrlimit(RLIMIT_CORE, &r);
415: }
416: #endif NOCORE
417:
418: *fflagp = '\0';
419:
420: if (ncpp > 0)
421: cppflags = argvtos (ncpp,cppargs);
422:
423: loadargs[0] = ldname;
424: #if TARGET == PDP11
425: if(nofloating)
426: *loadp++ = (profileflag ? NOFLPROF : NOFLFOOT);
427: else
428: #endif
429: *loadp++ = (profileflag ? proffoot : footname);
430:
431: for(i = 0 ; i<argc ; ++i)
432: switch(c = dotchar(infname = argv[i]) )
433: {
434: case 'r': /* Ratfor file */
435: case 'e': /* EFL file */
436: if( unreadable(argv[i]) )
437: {
438: erred = YES;
439: break;
440: }
441: s = fortfile;
442: t = lastfield(argv[i]);
443: while( *s++ = *t++)
444: ;
445: s[-2] = 'f';
446:
447: if(macroflag)
448: {
449: sprintf(buff, "%s %s >%s", macroname, infname, prepfname);
450: if( sys(buff) )
451: {
452: rmf(prepfname);
453: erred = YES;
454: break;
455: }
456: infname = prepfname;
457: }
458:
459: if(c == 'e')
460: sprintf(buff, "efl %s %s >%s", eflags, infname, fortfile);
461: else
462: sprintf(buff, "ratfor %s %s >%s", rflags, infname, fortfile);
463: status = sys(buff);
464: if(macroflag)
465: rmf(infname);
466: if(status)
467: {
468: erred = YES;
469: rmf(fortfile);
470: break;
471: }
472:
473: if( ! fortonly )
474: {
475: infname = argv[i] = lastfield(argv[i]);
476: *lastchar(infname) = 'f';
477:
478: if( dofort(argv[i]) )
479: erred = YES;
480: else {
481: if( nodup(t = setdoto(argv[i])) )
482: *loadp++ = t;
483: rmf(fortfile);
484: }
485: }
486: break;
487:
488: case 'F': /* C preprocessor -> Fortran file */
489: if( unreadable(argv[i]) )
490: {
491: erred = YES;
492: break;
493: }
494: s = fortfile;
495: t = lastfield(argv[i]);
496: while( *s++ = *t++)
497: ;
498: s[-2] = 'f';
499: sprintf(buff,"%s %s %s >%s", cppname, cppflags, infname, fortfile);
500: status = sys(buff);
501: if(status)
502: {
503: erred = YES;
504: rmf(fortfile);
505: break;
506: }
507:
508: if( ! fortonly )
509: {
510: infname = argv[i] = lastfield(argv[i]);
511: *lastchar(infname) = 'f';
512:
513: if ( dofort(argv[i]) )
514: erred = YES;
515: else {
516: if (nodup(t = setdoto(argv[i])) )
517: *loadp++ = t;
518: rmf(fortfile);
519: }
520: }
521: break;
522:
523: case 'f': /* Fortran file */
524: if( unreadable(argv[i]) )
525: erred = YES;
526: else if( dofort(argv[i]) )
527: erred = YES;
528: else if( nodup(t=setdoto(argv[i])) )
529: *loadp++ = t;
530: break;
531:
532: case 'c': /* C file */
533: case 's': /* Assembler file */
534: if( unreadable(argv[i]) )
535: {
536: erred = YES;
537: break;
538: }
539: #if HERE==PDP11 || HERE==VAX || HERE==TAHOE
540: if( namesflag == YES )
541: fprintf(diagfile, "%s:\n", argv[i]);
542: #endif
543: sprintf(buff, "cc %s %s", cflags, argv[i] );
544: if( sys(buff) )
545: erred = YES;
546: else
547: if( nodup(t = setdoto(argv[i])) )
548: *loadp++ = t;
549: break;
550:
551: case 'o':
552: if( nodup(argv[i]) )
553: *loadp++ = argv[i];
554: break;
555:
556: default:
557: if( ! strcmp(argv[i], "-o") ) {
558: aoutname = argv[++i];
559: new_aoutname = YES;
560: if( loadflag == NO ){
561: fprintf(diagfile, "-c prevents loading, -o %s ignored\n", aoutname);
562: new_aoutname = NO;
563: }
564: } else
565: *loadp++ = argv[i];
566: break;
567: }
568:
569: if( loadflag && stupid(aoutname) )
570: erred = YES;
571: if(loadflag && !erred)
572: doload(loadargs, loadp);
573: done(erred);
574: }
575:
576:
577:
578: /*
579: * argvtos() copies a list of arguments contained in an array of character
580: * strings to a single dynamically allocated string. Each argument is
581: * separated by one blank space. Returns a pointer to the string or null
582: * if out of memory.
583: */
584: #define SBUFINCR 1024
585: #define SBUFMAX 10240
586:
587: char *
588: argvtos(argc, argv)
589: char **argv;
590: int argc;
591: {
592: register char *s; /* string pointer */
593: register int i; /* string buffer pointer */
594: char *malloc(); /* memory allocator */
595: char *realloc(); /* increase size of storage */
596: char *sbuf; /* string buffer */
597: int nbytes; /* bytes of memory required */
598: int nu; /* no. of SBUFINCR units required */
599: int sbufsize; /* current size of sbuf */
600: int strlen(); /* string length */
601:
602: sbufsize = SBUFINCR;
603: if ((sbuf = malloc((unsigned)sbufsize)) == NULL)
604: {
605: fatal("out of memory (argvtos)");
606: /* NOTREACHED */
607: }
608:
609: for (i = 0; argc-- > 0; ++argv)
610: {
611: if ((nbytes = (i+strlen(*argv)+1-sbufsize)) > 0)
612: {
613: nu = (nbytes+SBUFINCR-1)/SBUFINCR;
614: sbufsize += nu * SBUFINCR;
615: if (sbufsize > SBUFMAX)
616: {
617: fatal("argument length exceeded (argvtos)");
618: /* NOTREACHED */
619: }
620: if ((sbuf = realloc(sbuf, (unsigned)sbufsize)) == NULL)
621: {
622: fatal("out of memory (argvtos)");
623: /* NOTREACHED */
624: }
625: }
626: for (s = *argv; *s != '\0'; i++, s++)
627: sbuf[i] = *s;
628: sbuf[i++] = ' ';
629: }
630: sbuf[--i] = '\0';
631: return(sbuf);
632: }
633:
634: dofort(s)
635: char *s;
636: {
637: int retcode;
638: char buff[200];
639:
640: infname = s;
641: sprintf(buff, "%s %s %s %s %s %s",
642: pass1name, fflags, s, asmfname, initfname, textfname);
643: switch( sys(buff) )
644: {
645: case 1:
646: goto error;
647: case 0:
648: break;
649: default:
650: goto comperror;
651: }
652:
653: if( dopass2() )
654: goto comperror;
655: doasm(s);
656: retcode = 0;
657:
658: ret:
659: rmf(asmfname);
660: rmf(initfname);
661: rmf(textfname);
662: return(retcode);
663:
664: error:
665: fprintf(diagfile, "\nError. No assembly.\n");
666: retcode = 1;
667: goto ret;
668:
669: comperror:
670: fprintf(diagfile, "\ncompiler error.\n");
671: retcode = 2;
672: goto ret;
673: }
674:
675:
676:
677:
678: dopass2()
679: {
680: char buff[100];
681:
682: if(verbose)
683: fprintf(diagfile, "PASS2.");
684:
685: #if FAMILY==DMR
686: sprintf(buff, "%s %s - %s", pass2name, textfname, asmpass2);
687: return( sys(buff) );
688: #endif
689:
690:
691: #if FAMILY == PCC
692: # if TARGET==INTERDATA
693: sprintf(buff, "%s -A%s <%s >%s", pass2name, setfname, textfname, asmpass2);
694: # else
695: sprintf(buff, "%s %s %s >%s",
696: pass2name, f2flags, textfname, asmpass2);
697: # endif
698: return( sys(buff) );
699: #endif
700: }
701:
702:
703:
704:
705: doasm(s)
706: char *s;
707: {
708: register char *lastc;
709: char *obj;
710: char buff[200];
711: char *lastchar(), *setdoto();
712:
713: if(*s == '\0')
714: s = objfdefault;
715: lastc = lastchar(s);
716: obj = setdoto(s);
717:
718: #if TARGET==PDP11 || TARGET==VAX || TARGET==TAHOE
719: # ifdef PASS2OPT
720: if(optimflag)
721: {
722: #if TARGET==TAHOE
723: sprintf(buff, "%s -f %s %s",
724: #else
725: sprintf(buff, "%s %s %s",
726: #endif
727: pass2opt, asmpass2, optzfname);
728: if( sys(buff) )
729: rmf(optzfname);
730: else
731: (void)rename(optzfname, asmpass2);
732: }
733: # endif
734: #endif
735:
736: if(saveasmflag)
737: {
738: *lastc = 's';
739: #if TARGET == INTERDATA
740: sprintf(buff, "%s %s %s %s %s >%s", CATNAME, asmfname, initfname,
741: setfname, asmpass2, obj);
742: #else
743: #if TARGET == VAX || TARGET == TAHOE
744: sprintf(buff, "%s %s %s %s >%s",
745: CATNAME, asmfname, asmpass2, initfname, obj);
746: #else
747: sprintf(buff, "%s %s %s %s >%s",
748: CATNAME, asmfname, initfname, asmpass2, obj);
749: #endif
750: #endif
751: sys(buff);
752: *lastc = 'o';
753: }
754: else
755: {
756: if(verbose)
757: fprintf(diagfile, " ASM.");
758: #if TARGET == INTERDATA
759: sprintf(buff, "%s -o %s %s %s %s %s", asmname, obj, asmfname,
760: initfname, setfname, asmpass2);
761: #endif
762:
763: #if TARGET == VAX || TARGET == TAHOE
764: /* vax assembler currently accepts only one input file */
765:
766: sprintf(buff, "%s %s %s >>%s",
767: CATNAME, asmpass2, initfname, asmfname);
768: sys(buff);
769: #ifdef UCBVAXASM
770: sprintf(buff, "%s -J -o %s %s", asmname, obj, asmfname);
771: #else
772: sprintf(buff, "%s -o %s %s", asmname, obj, asmfname);
773: #endif
774: #endif
775:
776: #if TARGET == PDP11
777: sprintf(buff, "%s -u -o %s %s %s", asmname, obj, asmfname, asmpass2);
778: #endif
779:
780: #if TARGET!=INTERDATA && TARGET!=PDP11 && TARGET!=VAX && TARGET!=TAHOE
781: sprintf(buff, "%s -o %s %s %s", asmname, obj, asmfname, asmpass2);
782: #endif
783:
784: if( sys(buff) )
785: fatal("assembler error");
786: if(verbose)
787: fprintf(diagfile, "\n");
788: #if HERE==PDP11 && TARGET!=PDP11
789: rmf(obj);
790: #endif
791: }
792:
793: rmf(asmpass2);
794: }
795:
796:
797:
798: doload(v0, v)
799: register char *v0[], *v[];
800: {
801: char **p;
802: int waitpid;
803:
804: if (profileflag)
805: {
806: for(p = p_liblist ; *p ; *v++ = *p++)
807: ;
808: }
809: else {
810: for(p = liblist ; *p ; *v++ = *p++)
811: ;
812: }
813:
814: *v++ = "-o";
815: *v++ = aoutname;
816: *v = NULL;
817:
818: if(verbose)
819: fprintf(diagfile, "LOAD.");
820: if(debugflag)
821: {
822: for(p = v0 ; p<v ; ++p)
823: fprintf(diagfile, "%s ", *p);
824: fprintf(diagfile, "\n");
825: }
826:
827: #if HERE==PDP11 || HERE==INTERDATA || HERE==VAX || HERE==TAHOE
828: if( (waitpid = fork()) == 0)
829: {
830: enbint(SIG_DFL);
831: execv(ldname, v0);
832: fatalstr("couldn't load %s", ldname);
833: }
834: await(waitpid);
835: #endif
836:
837: #if HERE==INTERDATA
838: if(optimflag)
839: {
840: char buff1[100], buff2[100];
841: sprintf(buff1, "nopt %s -o junk.%d", aoutname, pid);
842: sprintf(buff2, "mv junk.%d %s", pid, aoutname);
843: if( sys(buff1) || sys(buff2) )
844: err("bad optimization");
845: }
846: #endif
847:
848: if(verbose)
849: fprintf(diagfile, "\n");
850: }
851:
852: /* Process control and Shell-simulating routines */
853:
854: sys(str)
855: char *str;
856: {
857: register char *s, *t;
858: char *argv[100];
859: char *inname, *outname;
860: int append;
861: int waitpid;
862: int argc;
863:
864:
865: if(debugflag)
866: fprintf(diagfile, "%s\n", str);
867: inname = NULL;
868: outname = NULL;
869: argv[0] = shellname;
870: argc = 1;
871:
872: t = str;
873: while( isspace(*t) )
874: ++t;
875: while(*t)
876: {
877: if(*t == '<')
878: inname = t+1;
879: else if(*t == '>')
880: {
881: if(t[1] == '>')
882: {
883: append = YES;
884: outname = t+2;
885: }
886: else {
887: append = NO;
888: outname = t+1;
889: }
890: }
891: else
892: argv[argc++] = t;
893: while( !isspace(*t) && *t!='\0' )
894: ++t;
895: if(*t)
896: {
897: *t++ = '\0';
898: while( isspace(*t) )
899: ++t;
900: }
901: }
902:
903: if(argc == 1) /* no command */
904: return(-1);
905: argv[argc] = 0;
906:
907: if((waitpid = fork()) == 0)
908: {
909: if(inname)
910: freopen(inname, "r", stdin);
911: if(outname)
912: freopen(outname, (append ? "a" : "w"), stdout);
913: enbint(SIG_DFL);
914:
915: texec(argv[1] , argv);
916:
917: fatalstr("Cannot load %s", argv[1]);
918: }
919:
920: return( await(waitpid) );
921: }
922:
923:
924:
925:
926:
927: #include "errno.h"
928:
929: /* modified version from the Shell */
930: texec(f, av)
931: char *f;
932: char **av;
933: {
934: extern int errno;
935:
936: execv(f, av+1);
937:
938: if (errno==ENOEXEC)
939: {
940: av[1] = f;
941: execv(shellname, av);
942: fatal("No shell!");
943: }
944: if (errno==ENOMEM)
945: fatalstr("%s: too large", f);
946: }
947:
948:
949:
950:
951:
952:
953: done(k)
954: int k;
955: {
956: static int recurs = NO;
957:
958: if(recurs == NO)
959: {
960: recurs = YES;
961: rmfiles();
962: }
963: exit(k);
964: }
965:
966:
967:
968:
969:
970:
971: enbint(k)
972: int (*k)();
973: {
974: if(sigivalue == 0)
975: signal(SIGINT,k);
976: if(sigqvalue == 0)
977: signal(SIGQUIT,k);
978: if(sighvalue == 0)
979: signal(SIGHUP,k);
980: if(sigtvalue == 0)
981: signal(SIGTERM,k);
982: }
983:
984:
985:
986:
987: intrupt()
988: {
989: done(2);
990: }
991:
992:
993: #ifdef PSIGNAL
994: /*
995: * Fancy 4.2 BSD signal printing stuff.
996: */
997: char harmless[NSIG] = { 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1 };
998: #endif
999:
1000:
1001: await(waitpid)
1002: int waitpid;
1003: {
1004:
1005: #ifdef PSIGNAL
1006: extern char *sys_siglist[];
1007: union wait status;
1008: #else PSIGNAL
1009: int status;
1010: #endif PSIGNAL
1011:
1012: int w;
1013:
1014: enbint(SIG_IGN);
1015: while ( (w = wait(&status)) != waitpid)
1016: if(w == -1)
1017: fatal("bad wait code");
1018: enbint(intrupt);
1019:
1020: #ifdef PSIGNAL
1021: if(status.w_termsig)
1022: {
1023: debugflag = 0; /* Prevent us from dumping core ourselves */
1024: if(status.w_termsig != SIGINT && status.w_termsig < NSIG)
1025: fprintf(diagfile, "%s%s\n", sys_siglist[status.w_termsig],
1026: status.w_coredump ? " -- core dumped" : "");
1027: if(status.w_termsig < NSIG && ! harmless[status.w_termsig])
1028: fatal("see a system manager");
1029: else
1030: done(3);
1031: }
1032: return(status.w_retcode);
1033: #else PSIGNAL
1034: if(status & 0377)
1035: {
1036: if(status != SIGINT)
1037: fprintf(diagfile, "Termination code %d\n", status);
1038: done(3);
1039: }
1040: return(status>>8);
1041: #endif PSIGNAL
1042: }
1043:
1044: /* File Name and File Manipulation Routines */
1045:
1046: unreadable(s)
1047: register char *s;
1048: {
1049: register FILE *fp;
1050:
1051: if(fp = fopen(s, "r"))
1052: {
1053: fclose(fp);
1054: return(NO);
1055: }
1056:
1057: else
1058: {
1059: fprintf(diagfile, "Error: Cannot read file %s\n", s);
1060: return(YES);
1061: }
1062: }
1063:
1064:
1065:
1066: stupid(s)
1067: char *s;
1068: {
1069: char c;
1070:
1071: if( (c = dotchar(s))
1072: && index("focsreF", c)
1073: && access(s, 0) == 0 )
1074: {
1075: fprintf(diagfile, "Loading on %s would destroy it\n", s);
1076: return(YES);
1077: }
1078: return(NO);
1079: }
1080:
1081:
1082:
1083: clf(p)
1084: FILEP *p;
1085: {
1086: if(p!=NULL && *p!=NULL && *p!=stdout)
1087: {
1088: if(ferror(*p))
1089: fatal("writing error");
1090: fclose(*p);
1091: }
1092: *p = NULL;
1093: }
1094:
1095: rmfiles()
1096: {
1097: rmf(textfname);
1098: rmf(asmfname);
1099: rmf(initfname);
1100: rmf(asmpass2);
1101: #if TARGET == INTERDATA
1102: rmf(setfname);
1103: #endif
1104: }
1105:
1106:
1107:
1108:
1109:
1110:
1111:
1112:
1113: /* return -1 if file does not exist, 0 if it is of zero length
1114: and 1 if of positive length
1115: */
1116: content(filename)
1117: char *filename;
1118: {
1119: #ifdef VERSION6
1120: struct stat
1121: {
1122: char cjunk[9];
1123: char size0;
1124: int size1;
1125: int ijunk[12];
1126: } buf;
1127: #else
1128: struct stat buf;
1129: #endif
1130:
1131: if(stat(filename,&buf) < 0)
1132: return(-1);
1133: #ifdef VERSION6
1134: return(buf.size0 || buf.size1);
1135: #else
1136: return( buf.st_size > 0 );
1137: #endif
1138: }
1139:
1140:
1141:
1142:
1143: crfnames()
1144: {
1145: fname(textfname, "x");
1146: fname(asmfname, "s");
1147: fname(asmpass2, "a");
1148: fname(initfname, "d");
1149: fname(sortfname, "S");
1150: fname(objfdefault, "o");
1151: fname(prepfname, "p");
1152: fname(optzfname, "z");
1153: fname(setfname, "A");
1154: }
1155:
1156:
1157:
1158:
1159: rmf(fn)
1160: register char *fn;
1161: {
1162: /* if(!debugflag && fn!=NULL && *fn!='\0') */
1163:
1164: if(fn!=NULL && *fn!='\0')
1165: unlink(fn);
1166: }
1167:
1168:
1169:
1170:
1171:
1172: LOCAL fname(name, suff)
1173: char *name, *suff;
1174: {
1175: sprintf(name, "%s/%s%d.%s", _PATH_TMP, temppref, pid, suff);
1176: }
1177:
1178:
1179:
1180:
1181: dotchar(s)
1182: register char *s;
1183: {
1184: for( ; *s ; ++s)
1185: if(s[0]=='.' && s[1]!='\0' && s[2]=='\0')
1186: return( s[1] );
1187: return(NO);
1188: }
1189:
1190:
1191:
1192: char *lastfield(s)
1193: register char *s;
1194: {
1195: register char *t;
1196: for(t = s; *s ; ++s)
1197: if(*s == '/')
1198: t = s+1;
1199: return(t);
1200: }
1201:
1202:
1203:
1204: char *lastchar(s)
1205: register char *s;
1206: {
1207: while(*s)
1208: ++s;
1209: return(s-1);
1210: }
1211:
1212: char *setdoto(s)
1213: register char *s;
1214: {
1215: *lastchar(s) = 'o';
1216: return( lastfield(s) );
1217: }
1218:
1219:
1220:
1221: badfile(s)
1222: char *s;
1223: {
1224: fatalstr("cannot open intermediate file %s", s);
1225: }
1226:
1227:
1228:
1229: ptr ckalloc(n)
1230: int n;
1231: {
1232: ptr p, calloc();
1233:
1234: if( p = calloc(1, (unsigned) n) )
1235: return(p);
1236:
1237: fatal("out of memory");
1238: /* NOTREACHED */
1239: }
1240:
1241:
1242:
1243:
1244:
1245: char *copyn(n, s)
1246: register int n;
1247: register char *s;
1248: {
1249: register char *p, *q;
1250:
1251: p = q = (char *) ckalloc(n);
1252: while(n-- > 0)
1253: *q++ = *s++;
1254: return(p);
1255: }
1256:
1257:
1258:
1259: char *copys(s)
1260: char *s;
1261: {
1262: return( copyn( strlen(s)+1 , s) );
1263: }
1264:
1265:
1266:
1267:
1268:
1269: oneof(c,s)
1270: register c;
1271: register char *s;
1272: {
1273: while( *s )
1274: if(*s++ == c)
1275: return(YES);
1276: return(NO);
1277: }
1278:
1279:
1280:
1281: nodup(s)
1282: char *s;
1283: {
1284: register char **p;
1285:
1286: for(p = loadargs ; p < loadp ; ++p)
1287: if( !strcmp(*p, s) )
1288: return(NO);
1289:
1290: return(YES);
1291: }
1292:
1293:
1294:
1295: static fatal(t)
1296: char *t;
1297: {
1298: fprintf(diagfile, "Compiler error in file %s: %s\n", infname, t);
1299: if(debugflag)
1300: abort();
1301: done(1);
1302: exit(1);
1303: }
1304:
1305:
1306:
1307:
1308: static fatali(t,d)
1309: char *t;
1310: int d;
1311: {
1312: char buff[100];
1313: sprintf(buff, t, d);
1314: fatal(buff);
1315: }
1316:
1317:
1318:
1319:
1320: static fatalstr(t, s)
1321: char *t, *s;
1322: {
1323: char buff[100];
1324: sprintf(buff, t, s);
1325: fatal(buff);
1326: }
1327: err(s)
1328: char *s;
1329: {
1330: fprintf(diagfile, "Error in file %s: %s\n", infname, s);
1331: }
1332:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.