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