![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pass0.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / sgs / as|
Return to pass0.c CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / as |
1.1 root 1: static char *ID_pass0 = "@(#) pass0.c: 1.16 12/10/83";
2:
3: #include <stdio.h>
4: #include <signal.h>
5: #include <ctype.h>
6: #include <paths.h>
7: #include "systems.h"
8: #include "pass0.h"
9: #include "sgs.h"
10:
11: /*
12: *
13: * "pass0.c" is a file containing the source for the setup program
14: * for the SGS Assemblers. Routines in this file parse the
15: * arguments, determining the source and object file names, invent
16: * names for temporary files, and execute the first pass of the
17: * assembler.
18: *
19: * This program can be invoked with the command:
20: *
21: * as [flags] ifile [-o ofile]
22: *
23: * where [flags] are optional user-specified flags,
24: * "ifile" is the name of the assembly languge source file
25: * and "ofile" is the name of a file where the object program is
26: * to be written. If "ofile" is not specified on the command line,
27: * it is created from "ifile" by the following algorithm:
28: *
29: * 1. If the name "ifile" ends with the two characters ".s",
30: * these are replaced with the two characters ".o".
31: *
32: * 2. If the name "ifile" does not end with the two
33: * characters ".s" and is no more than 12 characters in
34: * length, the name "ofile" is created by appending the
35: * characters ".o" to the name "ifile".
36: *
37: * 3. If the name "ifile" does not end with the two
38: * characters ".s" and is greater than 12 characters in
39: * length, the name "ofile" is created by appending the
40: * characters ".o" to the first 12 characters of "ifile".
41: *
42: * The global variables "name1" through "name6" are used to store
43: * the six temporary file names. The variable "pid" is used to
44: * store a character version of the process ID number. This is
45: * used to make temporary file names unique.
46: *
47: */
48:
49: #define NO 0
50: #define YES 1
51: #define MAXFLAGS 15 - 9 /* sizeof(xargp)-num of args required for pass1 */
52: #ifndef P_tmpdir
53: #define P_tmpdir "/usr/tmp"
54: #endif
55:
56: #if ONEPROC
57: short passnbr = 0;
58:
59: extern short opt;
60: extern short workaround;
61:
62: extern short
63: tstlookup,
64: Oflag,
65: dlflag;
66:
67: extern char file[];
68:
69: extern char *filenames[];
70:
71: #if M4ON
72: extern short rflag;
73: #endif
74:
75: #if M32RSTFIX
76: extern short rstflag; /* Don't generate workaround for RESTORE chip bug */
77: #endif
78:
79: #endif
80:
81: char *infile;
82:
83: char outfile[80];
84:
85: char *tempnam();
86:
87: char
88: *name0,
89: *name1,
90: *name2,
91: *name3,
92: *name4,
93: *name5,
94: *name6,
95: #if MULTSECT
96: *name7,
97: *name8,
98: *name9,
99: *name10,
100: *name11,
101: *name12,
102: *name13;
103: #else
104: *name7;
105: #endif
106:
107: short transvec = NO,
108: argindex = 1,
109: flagindex = 0;
110:
111: #if !ONEPROC
112: static char
113: nextpass[15];
114:
115: static char
116: teststr[4] = {'-','t','\0','\0'};
117:
118: static char
119: *xargp[16];
120: #endif
121:
122: static char
123: flagstr[8][3];
124:
125: #if M4ON
126: static short
127: macro = MACRO;
128: #endif
129:
130: #if !ONEPROC
131: static short
132: testas = -2;
133: #endif
134:
135: extern char
136: *strcpy(),
137: *strcat(),
138: *strncat();
139:
140: #define max(A,B) (((A)<(B))?(B):(A))
141:
142: extern char *malloc(), *getenv(), *mktemp();
143: extern int access();
144:
145: static char *pcopy(), *seed="AAA";
146:
147: /*
148: *
149: * "tempnam" is the routine that allocates the temporary files needed
150: * by the assembler. It searches directories for enough space for the
151: * files, then assigns a (guaranteed) unique filename using the prefix
152: * in the function call.
153: *
154: */
155:
156: char *
157: tempnam(dir, pfx)
158: char *dir; /* use this directory please (if non-NULL) */
159: char *pfx; /* use this (if non-NULL) as filename prefix */
160: {
161: register char *p, *q, *tdir;
162: int x=0, y=0, z;
163:
164: z=strlen(P_tmpdir);
165: if((tdir = getenv("TMPDIR")) != NULL) {
166: x = strlen(tdir);
167: }
168: if(dir != NULL) {
169: y=strlen(dir);
170: }
171: if((p=malloc((unsigned)(max(max(x,y),z)+16))) == NULL)
172: return(NULL);
173: if(x > 0 && access(pcopy(p, tdir), 3) == 0)
174: goto OK;
175: if(y > 0 && access(pcopy(p, dir), 3) == 0)
176: goto OK;
177: if(access(pcopy(p, P_tmpdir), 3) == 0)
178: goto OK;
179: if(access(pcopy(p, "/tmp"), 3) != 0)
180: return(NULL);
181: OK:
182: (void)strcat(p, "/");
183: if(pfx) {
184: *(p+strlen(p)+5) = '\0';
185: (void)strncat(p, pfx, 5);
186: }
187: (void)strcat(p, seed);
188: (void)strcat(p, "XXXXXX");
189: q = seed;
190: while(*q == 'Z')
191: *q++ = 'A';
192: ++*q;
193: (void)mktemp(p);
194: if (*p == '\0')
195: return(NULL);
196: return(p);
197: }
198:
199: static char*
200: pcopy(space, arg)
201: register char *space, *arg;
202: {
203: register char *p;
204:
205: if(arg) {
206: (void)strcpy(space, arg);
207: p = space-1+strlen(space);
208: if(*p == '/')
209: *p = '\0';
210: }
211: return(space);
212: }
213:
214: /*
215: *
216: * "getargs" is a general purpose argument parsing routine.
217: * It locates flags (identified by a preceding minus sign ('-'))
218: * and initializes any associated flags for the assembler.
219: * If there are any file names in the argument list, then a
220: * pointer to the name is stored in a global variable for
221: * later use.
222: *
223: */
224:
225: getargs(xargc,xargv)
226: register int xargc;
227: register char **xargv;
228: {
229: register char ch;
230:
231: while (xargc-- > 0) {
232: if (**xargv == '-') {
233: while ((ch = *++*xargv) != '\0')
234: switch (ch) {
235: #if M4ON
236: case 'm':
237: macro = ! macro;
238: break;
239: #endif
240: case 'o':
241: strcpy(outfile,*(++xargv));
242: --xargc;
243: while (*++*xargv != '\0') ;
244: --*xargv;
245: break;
246: case 'd':
247: if (*++*xargv == 'l')
248: #if !ONEPROC
249: xargp[argindex++] = "-dl";
250: #else
251: dlflag = YES;
252: #endif
253: break;
254: #if TRANVEC || !ONEPROC
255: case 't':
256: ++*xargv;
257: #endif
258: #if TRANVEC
259: if (**xargv == 'v'){
260: transvec = YES;
261: #if !ONEPROC
262: xargp[argindex++] = "-tv";
263: #endif
264: break;
265: }
266: #endif
267: #if !ONEPROC
268: if (isdigit(**xargv)) {
269: testas = **xargv - '0' - 1;
270: if (testas > -1) {
271: teststr[2] = (char)(testas + '0');
272: }
273: }
274: else {
275: --*xargv;
276: testas += 2;
277: }
278: xargp[argindex++] = teststr;
279: break;
280: #endif
281: case 'V':
282: /* version flag */
283: fprintf(stderr,"%s: assembler - %s\n",
284: SGSNAME,RELEASE);
285: break;
286: #if ONEPROC
287: case 'n':
288: if (*++*xargv == 'f') { /* -nf option */
289: /* no frills; disable work-arounds */
290: workaround = NO;
291: #if M32RSTFIX
292: rstflag = NO;
293: #endif /* M32RSTFIX */
294: } else { /* -n option */
295: opt = NO;
296: *--*xargv;
297: }
298: break;
299: #if DEBUG
300: case 'O':
301: Oflag = YES;
302: break;
303: case 'T': {
304: switch (*++*xargv) {
305: case 'L' : {
306: tstlookup = YES;
307: break;
308: }
309: }
310: break;
311: }
312: #endif
313: #if M4ON
314: case 'R':
315: rflag = YES;
316: break;
317: #endif
318: #if M32RSTFIX
319: case 'r': /* Don't generate the workaround
320: * for the RESTORE chip bug.
321: */
322: rstflag = NO;
323: break;
324: #endif /* M32RSTFIX */
325: #endif
326: #if VAX
327: case 'j': /* invoke ljas instead of as */
328: if (strcmp(xargv[0],"ljas")) {
329: execvp("ljas",xargv);
330: aerror("cannot exec ljas");
331: };
332: break;
333: #endif
334: default:
335: #if ONEPROC
336: flags(ch);
337: #else
338: flagstr[flagindex][0] = '-';
339: flagstr[flagindex][1] = ch;
340: xargp[argindex++] = &(flagstr[flagindex++][0]);
341: #endif
342: break;
343: }
344: xargv++;
345: }
346: else {
347: infile = *xargv++;
348: }
349: }
350: }
351:
352: /*
353: *
354: * "main" is the main driver for the assembler. It calls "getargs"
355: * to parse the argument list, set flags, and stores pointers
356: * to any file names in the argument list .
357: * If the output file was not specified in the argument list
358: * then the output file name is generated. Next the temporary
359: * file names are generated and the first pass of the assembler
360: * is invoked.
361: *
362: */
363:
364: main(argc,argv)
365: int argc;
366: char **argv;
367: {
368: register short index, count;
369: #if !ONEPROC
370: register char *temp;
371: #endif
372: FILE *fd;
373:
374: argc--;
375: if (argc <= 0) {
376: fprintf(stderr,"Usage: %sas [options] file\n",SGS);
377: exit(1);
378: }
379: #if !ONEPROC
380: temp = *argv;
381: index = -1;
382: while (temp[++index] != '\0') ;
383: while (--index >= 0 && temp[index] != '/') ;
384: strcpy(nextpass,&temp[++index]);
385: nextpass[strlen(nextpass)] = '1';
386: #endif
387: argv++;
388: getargs(argc, argv);
389: /* Check to see if input file exits */
390: if ((fd = fopen(infile,"r")) != NULL)
391: fclose(fd);
392: else {
393: fprintf(stderr,"Nonexistent file\n");
394: exit(1);
395: }
396: if (outfile[0] == '\0') {
397: for(index=0,count=0;infile[index]!='\0';index++,count++)
398: if(infile[index]=='/')
399: count = -1;
400: strcpy(outfile,infile+index-count);
401: if(outfile[count-2]=='.' &&
402: outfile[count-1]=='s')
403: outfile[count-1]='o';
404: else
405: {
406: if(count>12)
407: count = 12;
408: strcpy(outfile+count,".o");
409: }
410: }
411:
412: name1 = tempnam(TMPDIR,TMPFILE1);
413: name2 = tempnam(TMPDIR,TMPFILE2);
414: name3 = tempnam(TMPDIR,TMPFILE3);
415: name4 = tempnam(TMPDIR,TMPFILE4);
416: name5 = tempnam(TMPDIR,TMPFILE5);
417: name6 = tempnam(TMPDIR,TMPFILE6);
418: name7 = tempnam(TMPDIR,TMPFILE7);
419: #if MULTSECT
420: name8 = tempnam(TMPDIR,TMPFILE8);
421: name9 = tempnam(TMPDIR,TMPFILE9);
422: name10 = tempnam(TMPDIR,TMPFILEA);
423: name11 = tempnam(TMPDIR,TMPFILEB);
424: name12 = tempnam(TMPDIR,TMPFILEC);
425: name13 = tempnam(TMPDIR,TMPFILED);
426: #endif
427: #if !ONEPROC
428: xargp[0] = nextpass;
429: #endif
430: #if M4ON
431: if (macro) {
432: /* tell pass1 to unlink its input when through */
433: #if ONEPROC
434: rflag = YES;
435: #else
436: xargp[argindex++] = "-R";
437: #endif
438: callm4();
439: }
440: #endif
441:
442: #if ONEPROC
443: strcpy(file,infile);
444: filenames[0] = infile;
445: filenames[1] = outfile;
446: filenames[2] = name1;
447: filenames[3] = name2;
448: filenames[4] = name3;
449: filenames[5] = name4;
450: filenames[6] = name5;
451: filenames[7] = name6;
452: filenames[8] = name7;
453: #if MULTSECT
454: filenames[9] = name8;
455: filenames[10] = name9;
456: filenames[11] = name10;
457: filenames[12] = name11;
458: filenames[13] = name12;
459: filenames[14] = name13;
460: #endif
461: exit(aspass1());
462: #else
463: if (argindex > MAXFLAGS) {
464: fprintf(stderr,"Too many flags\n");
465: exit (1);
466: }
467:
468: xargp[argindex++] = infile;
469: xargp[argindex++] = outfile;
470: xargp[argindex++] = name1;
471: xargp[argindex++] = name2;
472: xargp[argindex++] = name3;
473: xargp[argindex++] = name4;
474: xargp[argindex++] = name5;
475: xargp[argindex++] = name6;
476: xargp[argindex++] = name7;
477: #if MULTSECT
478: xargp[argindex++] = name8;
479: xargp[argindex++] = name9;
480: xargp[argindex++] = name10;
481: xargp[argindex++] = name11;
482: xargp[argindex++] = name12;
483: xargp[argindex++] = name13;
484: #endif
485: xargp[argindex] = 0;
486: if (testas != -1) {
487: if (testas > -1) {
488: execv(NAS1,xargp);
489: }
490: else
491: execv(AS1,xargp);
492: fprintf(stderr,"Assembler Error - Cannot Exec Pass 1\n");
493: exit(1);
494: }
495: #endif
496: } /* main */
497:
498: #if M4ON
499: callm4()
500: {
501: static char
502: *av[] = { "m4", 0, 0, 0};
503:
504: /*
505: * The following code had to be added with a 'u370' ifdef due
506: * to a MAXI bug concerning static pointers. We think it's fixed
507: * that is why the code is commented out. It can be deleted
508: * when this fact is verified.
509: *
510: * char *regdef, *tvdef;
511: * regdef = CM4DEFS;
512: * tvdef = CM4TVDEFS;
513: */
514:
515: #if !NODEFS
516: static char
517: *regdef = CM4DEFS
518: #if TRANVEC
519: ,
520: *tvdef = CM4TVDEFS
521: #endif
522: ;
523:
524: #if TRANVEC
525: av[1] = (transvec) ? tvdef : regdef;
526: av[2] = infile;
527: #else
528: av[1] = regdef;
529: av[2] = infile;
530: #endif
531: #else
532: av[1] = infile;
533: #endif
534: name0 = tempnam(TMPDIR,TMPFILE0); /* m4 output file */
535: if (callsys(M4, av, name0) != 0) {
536: unlink(name0);
537: fprintf(stderr,"Assembly inhibited\n");
538: exit(100);
539: }
540: infile = name0;
541: return;
542: } /* callm4 */
543:
544: callsys(f,v,o)
545: char f[], *v[];
546: char *o; /* file name, if any, for redirecting stdout */
547: {
548: int t, status;
549:
550: if ((t=fork())==0) {
551: if (o != NULL) { /* redirect stdout */
552: if (freopen(o, "w", stdout) == NULL) {
553: fprintf(stderr,"Can't open %s\n", o);
554: exit(100);
555: }
556: }
557: execv(f, v);
558: fprintf(stderr,"Can't find %s\n", f);
559: exit(100);
560: } else
561: if (t == -1) {
562: fprintf(stderr,"Try again\n");
563: return(100);
564: }
565: while(t!=wait(&status));
566: if ((t=(status&0377)) != 0) {
567: if (t!=SIGINT) /* interrupt */
568: {
569: fprintf(stderr,"status %o\n",status);
570: fprintf(stderr,"Fatal error in %s\n", f);
571: }
572: exit(100);
573: }
574: return((status>>8) & 0377);
575: } /* callsys */
576: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.