![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to driver.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / usr.bin / sf77|
Return to driver.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / usr.bin / sf77 |
1.1 root 1: #include <stdio.h>
2: #include <ctype.h>
3: #include "defines"
4: #include "machdefs"
5: #include "drivedefs"
6: #include "ftypes"
7: #include <signal.h>
8:
9: static FILEP diagfile = {stderr} ;
10: static int pid;
11: static int sigivalue = 0;
12: static int sigqvalue = 0;
13: static int sighvalue = 0;
14: static int sigtvalue = 0;
15:
16: static char *pass1name = PASS1NAME ;
17: static char *pass2name = PASS2NAME ;
18: static char *asmname = ASMNAME ;
19: static char *ldname = LDNAME ;
20: static char *footname = FOOTNAME;
21: static char *proffoot = PROFFOOT;
22: static char *macroname = "m4";
23: static char *shellname = "/bin/sh";
24: static char *aoutname = "a.out" ;
25: static char *temppref = TEMPPREF;
26:
27: static char *infname;
28: static char textfname[44];
29: static char asmfname[44];
30: static char asmpass2[44];
31: static char initfname[44];
32: static char sortfname[44];
33: static char prepfname[44];
34: static char objfdefault[44];
35: static char optzfname[44];
36: static char setfname[44];
37:
38: static char fflags[50] = "-";
39: static char cflags[50] = "-c";
40: #if TARGET == GCOS
41: static char eflags[30] = "system=gcos ";
42: #else
43: static char eflags[30] = "system=unix ";
44: #endif
45: static char rflags[30] = "";
46: static char lflag[3] = "-x";
47: static char *fflagp = fflags+1;
48: static char *cflagp = cflags+2;
49: static char *eflagp = eflags+12;
50: static char *rflagp = rflags;
51: static char **loadargs;
52: static char **loadp;
53:
54: static flag erred = NO;
55: static flag loadflag = YES;
56: static flag saveasmflag = NO;
57: static flag profileflag = NO;
58: static flag optimflag = NO;
59: static flag debugflag = NO;
60: static flag verbose = NO;
61: static flag nofloating = NO;
62: static flag fortonly = NO;
63: static flag macroflag = NO;
64: static flag sdbflag = NO;
65:
66:
67:
68: main(argc, argv)
69: int argc;
70: char **argv;
71: {
72: int i, c, status;
73: char *setdoto(), *lastchar(), *lastfield(), *copys();
74: ptr ckalloc();
75: register char *s;
76: char fortfile[20], *t;
77: char buff[100];
78: int intrupt();
79:
80: sigivalue = (int) signal(SIGINT, SIG_IGN) & 01;
81: sigqvalue = (int) signal(SIGQUIT,SIG_IGN) & 01;
82: sighvalue = (int) signal(SIGHUP, SIG_IGN) & 01;
83: sigtvalue = (int) signal(SIGTERM,SIG_IGN) & 01;
84: enbint(intrupt);
85:
86: pid = getpid();
87: crfnames();
88:
89: loadargs = (char **) ckalloc( (argc+20) * sizeof(*loadargs) );
90: loadargs[1] = "-X";
91: loadargs[2] = "-u";
92: #if TARGET==PDP11 || TARGET==VAX || TARGET==TAHOE
93: loadargs[3] = "_MAIN__";
94: #endif
95: #if TARGET == INTERDATA
96: loadargs[3] = "main";
97: #endif
98: loadp = loadargs + 4;
99:
100: --argc;
101: ++argv;
102:
103: while(argc>0 && argv[0][0]=='-' && argv[0][1]!='\0')
104: {
105: for(s = argv[0]+1 ; *s ; ++s) switch(*s)
106: {
107: case 'T': /* use special passes */
108: switch(*++s)
109: {
110: case '1':
111: pass1name = s+1; goto endfor;
112: case '2':
113: pass2name = s+1; goto endfor;
114: case 'a':
115: asmname = s+1; goto endfor;
116: case 'l':
117: ldname = s+1; goto endfor;
118: case 'F':
119: footname = s+1; goto endfor;
120: case 'm':
121: macroname = s+1; goto endfor;
122: case 't':
123: temppref = s+1; goto endfor;
124: default:
125: fatali("bad option -T%c", *s);
126: }
127: break;
128:
129: case '6':
130: if(s[1]=='6')
131: {
132: *fflagp++ = *s++;
133: goto copyfflag;
134: }
135: else {
136: fprintf(diagfile, "invalid flag 6%c\n", s[1]);
137: done(1);
138: }
139:
140: case 'w':
141: if(s[1]=='6' && s[2]=='6')
142: {
143: *fflagp++ = *s++;
144: *fflagp++ = *s++;
145: }
146:
147: copyfflag:
148: case 'u':
149: case 'U':
150: case '1':
151: case 'C':
152: *fflagp++ = *s;
153: break;
154:
155: case 'O':
156: optimflag = YES;
157: #if TARGET == INTERDATA
158: *loadp++ = "-r";
159: *loadp++ = "-d";
160: #endif
161: *fflagp++ = 'O';
162: if( isdigit(s[1]) )
163: *fflagp++ = *++s;
164: break;
165:
166: case 'N':
167: *fflagp++ = 'N';
168: if( oneof(*++s, "qxscn") )
169: *fflagp++ = *s++;
170: else {
171: fprintf(diagfile, "invalid flag -N%c\n", *s);
172: done(1);
173: }
174: while( isdigit(*s) )
175: *fflagp++ = *s++;
176: *fflagp++ = 'X';
177: goto endfor;
178:
179: case 'm':
180: if(s[1] == '4')
181: ++s;
182: macroflag = YES;
183: break;
184:
185: case 'S':
186: strcat(cflags, " -S");
187: saveasmflag = YES;
188:
189: case 'c':
190: loadflag = NO;
191: break;
192:
193: case 'v':
194: verbose = YES;
195: break;
196:
197: case 'd':
198: debugflag = YES;
199: goto copyfflag;
200:
201: case 'M':
202: *loadp++ = "-M";
203: break;
204:
205: case 'g':
206: strcat(cflags," -g");
207: sdbflag = YES;
208: goto copyfflag;
209:
210: case 'p':
211: profileflag = YES;
212: strcat(cflags," -p");
213: goto copyfflag;
214:
215: case 'o':
216: if( ! strcmp(s, "onetrip") )
217: {
218: *fflagp++ = '1';
219: goto endfor;
220: }
221: aoutname = *++argv;
222: --argc;
223: break;
224:
225: #if TARGET == PDP11
226: case 'f':
227: nofloating = YES;
228: pass2name = NOFLPASS2;
229: break;
230: #endif
231:
232: case 'F':
233: fortonly = YES;
234: loadflag = NO;
235: break;
236:
237: case 'I':
238: if(s[1]=='2' || s[1]=='4' || s[1]=='s')
239: {
240: *fflagp++ = *s++;
241: goto copyfflag;
242: }
243: fprintf(diagfile, "invalid flag -I%c\n", s[1]);
244: done(1);
245:
246: case 'l': /* letter ell--library */
247: s[-1] = '-';
248: *loadp++ = s-1;
249: goto endfor;
250:
251: case 'E': /* EFL flag argument */
252: while( *eflagp++ = *++s)
253: ;
254: *eflagp++ = ' ';
255: goto endfor;
256: case 'R':
257: while( *rflagp++ = *++s )
258: ;
259: *rflagp++ = ' ';
260: goto endfor;
261: default:
262: lflag[1] = *s;
263: *loadp++ = copys(lflag);
264: break;
265: }
266: endfor:
267: --argc;
268: ++argv;
269: }
270:
271: *fflagp = '\0';
272:
273: loadargs[0] = ldname;
274: #if TARGET == PDP11
275: if(nofloating)
276: *loadp++ = (profileflag ? NOFLPROF : NOFLFOOT);
277: else
278: #endif
279: *loadp++ = (profileflag ? proffoot : footname);
280:
281: for(i = 0 ; i<argc ; ++i)
282: switch(c = dotchar(infname = argv[i]) )
283: {
284: case 'r': /* Ratfor file */
285: case 'e': /* EFL file */
286: if( unreadable(argv[i]) )
287: {
288: erred = YES;
289: break;
290: }
291: s = fortfile;
292: t = lastfield(argv[i]);
293: while( *s++ = *t++)
294: ;
295: s[-2] = 'f';
296:
297: if(macroflag)
298: {
299: sprintf(buff, "%s %s >%s", macroname, infname, prepfname);
300: if( sys(buff) )
301: {
302: rmf(prepfname);
303: erred = YES;
304: break;
305: }
306: infname = prepfname;
307: }
308:
309: if(c == 'e')
310: sprintf(buff, "efl %s %s >%s", eflags, infname, fortfile);
311: else
312: sprintf(buff, "ratfor %s %s >%s", rflags, infname, fortfile);
313: status = sys(buff);
314: if(macroflag)
315: rmf(infname);
316: if(status)
317: {
318: erred = YES;
319: rmf(fortfile);
320: break;
321: }
322:
323: if( ! fortonly )
324: {
325: infname = argv[i] = lastfield(argv[i]);
326: *lastchar(infname) = 'f';
327:
328: if( dofort(argv[i]) )
329: erred = YES;
330: else {
331: if( nodup(t = setdoto(argv[i])) )
332: *loadp++ = t;
333: rmf(fortfile);
334: }
335: }
336: break;
337:
338: case 'f': /* Fortran file */
339: case 'F':
340: if( unreadable(argv[i]) )
341: erred = YES;
342: else if( dofort(argv[i]) )
343: erred = YES;
344: else if( nodup(t=setdoto(argv[i])) )
345: *loadp++ = t;
346: break;
347:
348: case 'c': /* C file */
349: case 's': /* Assembler file */
350: if( unreadable(argv[i]) )
351: {
352: erred = YES;
353: break;
354: }
355: #if HERE==PDP11 || HERE==VAX || HERE==TAHOE
356: fprintf(diagfile, "%s:\n", argv[i]);
357: #endif
358: sprintf(buff, "cc %s %s", cflags, argv[i] );
359: if( sys(buff) )
360: erred = YES;
361: else
362: if( nodup(t = setdoto(argv[i])) )
363: *loadp++ = t;
364: break;
365:
366: case 'o':
367: if( nodup(argv[i]) )
368: *loadp++ = argv[i];
369: break;
370:
371: default:
372: if( ! strcmp(argv[i], "-o") )
373: aoutname = argv[++i];
374: else
375: *loadp++ = argv[i];
376: break;
377: }
378:
379: if(loadflag && !erred)
380: doload(loadargs, loadp);
381: done(erred);
382: }
383:
384: dofort(s)
385: char *s;
386: {
387: int retcode;
388: char buff[200];
389:
390: infname = s;
391: sprintf(buff, "%s %s %s %s %s %s",
392: pass1name, fflags, s, asmfname, initfname, textfname);
393: switch( sys(buff) )
394: {
395: case 1:
396: goto error;
397: case 0:
398: break;
399: default:
400: goto comperror;
401: }
402:
403: if(content(initfname) > 0)
404: if( dodata() )
405: goto error;
406: if( dopass2() )
407: goto comperror;
408: doasm(s);
409: retcode = 0;
410:
411: ret:
412: rmf(asmfname);
413: rmf(initfname);
414: rmf(textfname);
415: return(retcode);
416:
417: error:
418: fprintf(diagfile, "\nError. No assembly.\n");
419: retcode = 1;
420: goto ret;
421:
422: comperror:
423: fprintf(diagfile, "\ncompiler error.\n");
424: retcode = 2;
425: goto ret;
426: }
427:
428:
429:
430:
431: dopass2()
432: {
433: char buff[100];
434:
435: if(verbose)
436: fprintf(diagfile, "PASS2.");
437:
438: #if FAMILY==DMR
439: sprintf(buff, "%s %s - %s", pass2name, textfname, asmpass2);
440: return( sys(buff) );
441: #endif
442:
443: #if FAMILY == PCC
444: # if TARGET==INTERDATA
445: sprintf(buff, "%s -A%s <%s >%s", pass2name, setfname, textfname, asmpass2);
446: # else
447: sprintf(buff, "%s %s >%s", pass2name, textfname, asmpass2);
448: # endif
449: return( sys(buff) );
450: #endif
451: }
452:
453:
454:
455:
456: doasm(s)
457: char *s;
458: {
459: register char *lastc;
460: char *obj;
461: char buff[200];
462: char *lastchar(), *setdoto();
463:
464: if(*s == '\0')
465: s = objfdefault;
466: lastc = lastchar(s);
467: obj = setdoto(s);
468:
469: #if TARGET==PDP11 || TARGET==VAX || TARGET==TAHOE
470: # ifdef PASS2OPT
471: if(optimflag)
472: {
473: sprintf(buff, "%s %s %s", PASS2OPT, asmpass2, optzfname);
474: if( sys(buff) )
475: rmf(optzfname);
476: else
477: {
478: sprintf(buff,"mv %s %s", optzfname, asmpass2);
479: sys(buff);
480: }
481: }
482: # endif
483: #endif
484:
485: if(saveasmflag)
486: {
487: *lastc = 's';
488: #if TARGET == INTERDATA
489: sprintf(buff, "cat %s %s %s >%s",asmfname, setfname, asmpass2, obj);
490: #else
491: sprintf(buff, "cat %s %s >%s", asmfname, asmpass2, obj);
492: #endif
493: sys(buff);
494: *lastc = 'o';
495: }
496: else
497: {
498: if(verbose)
499: fprintf(diagfile, " ASM.");
500: #if TARGET == INTERDATA
501: sprintf(buff, "%s -o %s %s %s %s", asmname, obj, asmfname, setfname, asmpass2);
502: #endif
503:
504: #if TARGET == VAX || TARGET == TAHOE
505: /* vax assembler currently accepts only one input file */
506: sprintf(buff, "cat %s >>%s", asmpass2, asmfname);
507: sys(buff);
508: sprintf(buff, "%s -o %s %s", asmname, obj, asmfname);
509: #else
510:
511: #if TARGET == PDP11
512: sprintf(buff, "%s -u -o %s %s %s", asmname, obj, asmfname, asmpass2);
513: #else
514: sprintf(buff, "%s -o %s %s %s", asmname, obj, asmfname, asmpass2);
515: #endif
516: #endif
517:
518: if( sys(buff) )
519: fatal("assembler error");
520: if(verbose)
521: fprintf(diagfile, "\n");
522: #if HERE==PDP11 && TARGET!=PDP11
523: rmf(obj);
524: #endif
525: }
526:
527: rmf(asmpass2);
528: }
529:
530:
531:
532: doload(v0, v)
533: register char *v0[], *v[];
534: {
535: char **p;
536: int waitpid;
537:
538: if(sdbflag)
539: *v++ = "-lg";
540: for(p = liblist ; *p ; *v++ = *p++)
541: ;
542:
543: *v++ = "-o";
544: *v++ = aoutname;
545: *v = NULL;
546:
547: if(verbose)
548: fprintf(diagfile, "LOAD.");
549: if(debugflag)
550: {
551: for(p = v0 ; p<v ; ++p)
552: fprintf(diagfile, "%s ", *p);
553: fprintf(diagfile, "\n");
554: }
555:
556: #if HERE==PDP11 || HERE==INTERDATA || HERE==VAX || HERE==TAHOE
557: if( (waitpid = fork()) == 0)
558: {
559: enbint(SIG_DFL);
560: execv(ldname, v0);
561: fatalstr("couldn't load %s", ldname);
562: }
563: await(waitpid);
564: #endif
565:
566: #if HERE==INTERDATA
567: if(optimflag)
568: {
569: char buff1[100], buff2[100];
570: sprintf(buff1, "nopt %s -o junk.%d", aoutname, pid);
571: sprintf(buff2, "mv junk.%d %s", pid, aoutname);
572: if( sys(buff1) || sys(buff2) )
573: err("bad optimization");
574: }
575: #endif
576:
577: if(verbose)
578: fprintf(diagfile, "\n");
579: }
580:
581: /* Process control and Shell-simulating routines */
582:
583: sys(str)
584: char *str;
585: {
586: register char *s, *t;
587: char *argv[100], path[100];
588: char *inname, *outname;
589: int append;
590: int waitpid;
591: int argc;
592:
593:
594: if(debugflag)
595: fprintf(diagfile, "%s\n", str);
596: inname = NULL;
597: outname = NULL;
598: argv[0] = shellname;
599: argc = 1;
600:
601: t = str;
602: while( isspace(*t) )
603: ++t;
604: while(*t)
605: {
606: if(*t == '<')
607: inname = t+1;
608: else if(*t == '>')
609: {
610: if(t[1] == '>')
611: {
612: append = YES;
613: outname = t+2;
614: }
615: else {
616: append = NO;
617: outname = t+1;
618: }
619: }
620: else
621: argv[argc++] = t;
622: while( !isspace(*t) && *t!='\0' )
623: ++t;
624: if(*t)
625: {
626: *t++ = '\0';
627: while( isspace(*t) )
628: ++t;
629: }
630: }
631:
632: if(argc == 1) /* no command */
633: return(-1);
634: argv[argc] = 0;
635:
636: s = path;
637: t = "/usr/bin/";
638: while(*t)
639: *s++ = *t++;
640: for(t = argv[1] ; *s++ = *t++ ; )
641: ;
642: if((waitpid = fork()) == 0)
643: {
644: if(inname)
645: freopen(inname, "r", stdin);
646: if(outname)
647: freopen(outname, (append ? "a" : "w"), stdout);
648: enbint(SIG_DFL);
649:
650: texec(path+9, argv); /* command */
651: texec(path+4, argv); /* /bin/command */
652: texec(path , argv); /* /usr/bin/command */
653:
654: fatalstr("Cannot load %s",path+9);
655: }
656:
657: return( await(waitpid) );
658: }
659:
660:
661:
662:
663:
664: #include "errno.h"
665:
666: /* modified version from the Shell */
667: texec(f, av)
668: char *f;
669: char **av;
670: {
671: extern int errno;
672:
673: execv(f, av+1);
674:
675: if (errno==ENOEXEC)
676: {
677: av[1] = f;
678: execv(shellname, av);
679: fatal("No shell!");
680: }
681: if (errno==ENOMEM)
682: fatalstr("%s: too large", f);
683: }
684:
685:
686:
687:
688:
689:
690: done(k)
691: int k;
692: {
693: static int recurs = NO;
694:
695: if(recurs == NO)
696: {
697: recurs = YES;
698: rmfiles();
699: }
700: exit(k);
701: }
702:
703:
704:
705:
706:
707:
708: enbint(k)
709: int (*k)();
710: {
711: if(sigivalue == 0)
712: signal(SIGINT,k);
713: if(sigqvalue == 0)
714: signal(SIGQUIT,k);
715: if(sighvalue == 0)
716: signal(SIGHUP,k);
717: if(sigtvalue == 0)
718: signal(SIGTERM,k);
719: }
720:
721:
722:
723:
724: intrupt()
725: {
726: done(2);
727: }
728:
729:
730:
731: await(waitpid)
732: int waitpid;
733: {
734: int w, status;
735:
736: enbint(SIG_IGN);
737: while ( (w = wait(&status)) != waitpid)
738: if(w == -1)
739: fatal("bad wait code");
740: enbint(intrupt);
741: if(status & 0377)
742: {
743: if(status != SIGINT)
744: fprintf(diagfile, "Termination code %d", status);
745: done(3);
746: }
747: return(status>>8);
748: }
749:
750: /* File Name and File Manipulation Routines */
751:
752: unreadable(s)
753: register char *s;
754: {
755: register FILE *fp;
756:
757: if(fp = fopen(s, "r"))
758: {
759: fclose(fp);
760: return(NO);
761: }
762:
763: else
764: {
765: fprintf(diagfile, "Error: Cannot read file %s\n", s);
766: return(YES);
767: }
768: }
769:
770:
771:
772: clf(p)
773: FILEP *p;
774: {
775: if(p!=NULL && *p!=NULL && *p!=stdout)
776: {
777: if(ferror(*p))
778: fatal("writing error");
779: fclose(*p);
780: }
781: *p = NULL;
782: }
783:
784: rmfiles()
785: {
786: rmf(textfname);
787: rmf(asmfname);
788: rmf(initfname);
789: rmf(asmpass2);
790: #if TARGET == INTERDATA
791: rmf(setfname);
792: #endif
793: }
794:
795:
796:
797:
798:
799:
800:
801:
802: /* return -1 if file does not exist, 0 if it is of zero length
803: and 1 if of positive length
804: */
805: content(filename)
806: char *filename;
807: {
808: #ifdef VERSION6
809: struct stat
810: {
811: char cjunk[9];
812: char size0;
813: int size1;
814: int ijunk[12];
815: } buf;
816: #else
817: # include <sys/types.h>
818: # include <sys/stat.h>
819: struct stat buf;
820: #endif
821:
822: if(stat(filename,&buf) < 0)
823: return(-1);
824: #ifdef VERSION6
825: return(buf.size0 || buf.size1);
826: #else
827: return( buf.st_size > 0 );
828: #endif
829: }
830:
831:
832:
833:
834: crfnames()
835: {
836: fname(textfname, "x");
837: fname(asmfname, "s");
838: fname(asmpass2, "a");
839: fname(initfname, "d");
840: fname(sortfname, "S");
841: fname(objfdefault, "o");
842: fname(prepfname, "p");
843: fname(optzfname, "z");
844: fname(setfname, "A");
845: }
846:
847:
848:
849:
850: rmf(fn)
851: register char *fn;
852: {
853: if(!debugflag && fn!=NULL && *fn!='\0')
854: unlink(fn);
855: }
856:
857:
858:
859:
860:
861: LOCAL fname(name, suff)
862: char *name, *suff;
863: {
864: sprintf(name, "/tmp/%s%d.%s", temppref, pid, suff);
865: }
866:
867:
868:
869:
870: dotchar(s)
871: register char *s;
872: {
873: for( ; *s ; ++s)
874: if(s[0]=='.' && s[1]!='\0' && s[2]=='\0')
875: return( s[1] );
876: return(NO);
877: }
878:
879:
880:
881: char *lastfield(s)
882: register char *s;
883: {
884: register char *t;
885: for(t = s; *s ; ++s)
886: if(*s == '/')
887: t = s+1;
888: return(t);
889: }
890:
891:
892:
893: char *lastchar(s)
894: register char *s;
895: {
896: while(*s)
897: ++s;
898: return(s-1);
899: }
900:
901: char *setdoto(s)
902: register char *s;
903: {
904: *lastchar(s) = 'o';
905: return( lastfield(s) );
906: }
907:
908:
909:
910: badfile(s)
911: char *s;
912: {
913: fatalstr("cannot open intermediate file %s", s);
914: }
915:
916:
917:
918: ptr ckalloc(n)
919: int n;
920: {
921: ptr p, calloc();
922:
923: if( p = calloc(1, (unsigned) n) )
924: return(p);
925:
926: fatal("out of memory");
927: /* NOTREACHED */
928: }
929:
930:
931:
932:
933:
934: char *copyn(n, s)
935: register int n;
936: register char *s;
937: {
938: register char *p, *q;
939:
940: p = q = (char *) ckalloc(n);
941: while(n-- > 0)
942: *q++ = *s++;
943: return(p);
944: }
945:
946:
947:
948: char *copys(s)
949: char *s;
950: {
951: return( copyn( strlen(s)+1 , s) );
952: }
953:
954:
955:
956:
957:
958: oneof(c,s)
959: register c;
960: register char *s;
961: {
962: while( *s )
963: if(*s++ == c)
964: return(YES);
965: return(NO);
966: }
967:
968:
969:
970: nodup(s)
971: char *s;
972: {
973: register char **p;
974:
975: for(p = loadargs ; p < loadp ; ++p)
976: if( !strcmp(*p, s) )
977: return(NO);
978:
979: return(YES);
980: }
981:
982:
983:
984: static fatal(t)
985: char *t;
986: {
987: fprintf(diagfile, "Compiler error in file %s: %s\n", infname, t);
988: if(debugflag)
989: abort();
990: done(1);
991: exit(1);
992: }
993:
994:
995:
996:
997: static fatali(t,d)
998: char *t;
999: int d;
1000: {
1001: char buff[100];
1002: sprintf(buff, t, d);
1003: fatal(buff);
1004: }
1005:
1006:
1007:
1008:
1009: static fatalstr(t, s)
1010: char *t, *s;
1011: {
1012: char buff[100];
1013: sprintf(buff, t, s);
1014: fatal(buff);
1015: }
1016: err(s)
1017: char *s;
1018: {
1019: fprintf(diagfile, "Error in file %s: %s\n", infname, s);
1020: }
1021:
1022: /* Code to generate initializations for DATA statements */
1023:
1024: LOCAL int nch = 0;
1025: LOCAL FILEP asmfile;
1026: LOCAL FILEP sortfile;
1027:
1028: #include "ftypes"
1029:
1030: static ftnint typesize[NTYPES]
1031: = { 1, SZADDR, SZSHORT, SZLONG, SZLONG, 2*SZLONG,
1032: 2*SZLONG, 4*SZLONG, SZLONG, 1, 1, 1};
1033: static int typealign[NTYPES]
1034: = { 1, ALIADDR, ALISHORT, ALILONG, ALILONG, ALIDOUBLE,
1035: ALILONG, ALIDOUBLE, ALILONG, 1, 1, 1};
1036:
1037: dodata()
1038: {
1039: char buff[50];
1040: char varname[XL+1], ovarname[XL+1];
1041: int status;
1042: flag erred;
1043: ftnint offset, vlen, type;
1044: register ftnint ooffset, ovlen;
1045: ftnint nblank, vchar;
1046: int size, align;
1047: int vargroup;
1048: ftnint totlen, doeven();
1049:
1050: erred = NO;
1051: ovarname[0] = '\0';
1052: ooffset = 0;
1053: ovlen = 0;
1054: totlen = 0;
1055: nch = 0;
1056:
1057: sprintf(buff, "sort %s >%s", initfname, sortfname);
1058: if(status = sys(buff))
1059: fatali("call sort status = %d", status);
1060: if( (sortfile = fopen(sortfname, "r")) == NULL)
1061: badfile(sortfname);
1062: if( (asmfile = fopen(asmfname, "a")) == NULL)
1063: badfile(asmfname);
1064: pruse(asmfile, USEINIT);
1065:
1066: while( rdname(&vargroup, varname) && rdlong(&offset) && rdlong(&vlen) && rdlong(&type) )
1067: {
1068: size = typesize[type];
1069: if( strcmp(varname, ovarname) )
1070: {
1071: prspace(ovlen-ooffset);
1072: strcpy(ovarname, varname);
1073: ooffset = 0;
1074: totlen += ovlen;
1075: ovlen = vlen;
1076: if(vargroup == 0)
1077: align = (type==TYCHAR || type==TYBLANK ?
1078: SZLONG : typealign[type]);
1079: else align = ALIDOUBLE;
1080: totlen = doeven(totlen, align);
1081: if(vargroup == 2)
1082: prcomblock(asmfile, varname);
1083: else
1084: fprintf(asmfile, LABELFMT, varname);
1085: }
1086: if(offset < ooffset)
1087: {
1088: erred = YES;
1089: err("overlapping initializations");
1090: ooffset = offset;
1091: }
1092: if(offset > ooffset)
1093: {
1094: prspace(offset-ooffset);
1095: ooffset = offset;
1096: }
1097: if(type == TYCHAR)
1098: {
1099: if( rdlong(&vchar) )
1100: prch( (int) vchar );
1101: else
1102: fatal("bad intermediate file format");
1103: }
1104: else if(type == TYBLANK)
1105: {
1106: if( rdlong(&nblank) )
1107: {
1108: size = nblank;
1109: while( --nblank >= 0)
1110: prch( ' ' );
1111: }
1112: else
1113: fatal("bad intermediate file format");
1114: }
1115: else
1116: {
1117: putc('\t', asmfile);
1118: while ( putc( getc(sortfile), asmfile) != '\n')
1119: ;
1120: }
1121: if( (ooffset += size) > ovlen)
1122: {
1123: erred = YES;
1124: err("initialization out of bounds");
1125: }
1126: }
1127:
1128: prspace(ovlen-ooffset);
1129: #if ALIDOUBLE>SZLONG
1130: totlen = doeven(totlen+ovlen, ALIDOUBLE );
1131: #else
1132: totlen = doeven(totlen+ovlen, SZLONG );
1133: #endif
1134: clf(&sortfile);
1135: clf(&asmfile);
1136: clf(&sortfile);
1137: rmf(sortfname);
1138: return(erred);
1139: }
1140:
1141:
1142:
1143:
1144: prspace(n)
1145: register ftnint n;
1146: {
1147: register ftnint m;
1148:
1149: while(nch>0 && n>0)
1150: {
1151: --n;
1152: prch(0);
1153: }
1154: m = SZSHORT * (n/SZSHORT);
1155: if(m > 0)
1156: prskip(asmfile, m);
1157: for(n -= m ; n>0 ; --n)
1158: prch(0);
1159: }
1160:
1161:
1162:
1163:
1164: ftnint doeven(tot, align)
1165: register ftnint tot;
1166: int align;
1167: {
1168: ftnint new;
1169: new = roundup(tot, align);
1170: prspace(new - tot);
1171: return(new);
1172: }
1173:
1174:
1175:
1176: rdname(vargroupp, name)
1177: int *vargroupp;
1178: register char *name;
1179: {
1180: register int i, c;
1181:
1182: if( (c = getc(sortfile)) == EOF)
1183: return(NO);
1184: *vargroupp = c - '0';
1185:
1186: for(i = 0 ; i<XL ; ++i)
1187: {
1188: if( (c = getc(sortfile)) == EOF)
1189: return(NO);
1190: if(c != ' ')
1191: *name++ = c;
1192: }
1193: *name = '\0';
1194: return(YES);
1195: }
1196:
1197:
1198:
1199: rdlong(n)
1200: register ftnint *n;
1201: {
1202: register int c;
1203:
1204: for(c = getc(sortfile) ; c!=EOF && isspace(c) ; c = getc(sortfile) );
1205: ;
1206: if(c == EOF)
1207: return(NO);
1208:
1209: for(*n = 0 ; isdigit(c) ; c = getc(sortfile) )
1210: *n = 10* (*n) + c - '0';
1211: return(YES);
1212: }
1213:
1214:
1215:
1216:
1217: prch(c)
1218: register int c;
1219: {
1220: static int buff[SZSHORT];
1221:
1222: buff[nch++] = c;
1223: if(nch == SZSHORT)
1224: {
1225: prchars(asmfile, buff);
1226: nch = 0;
1227: }
1228: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.