![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ar.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin|
Return to ar.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin |
1.1 root 1: /*
2: * Archive manager.
3: * Also manages libraries for the
4: * link editor,
5: * including ranlib header updates.
6: */
7: #define PORTAR 1 /* COFF frmat */
8:
9: #ifdef COHERENT
10: #define SLASH '/'
11: #else
12: #define SLASH '\\'
13: #endif
14:
15: #include <stdlib.h>
16: #include <stdio.h>
17: #include <string.h>
18: #include <arcoff.h>
19: #include <ar.h>
20: #if !PORTAR
21: #include <canon.h>
22: #else
23: #include <coff.h>
24: #endif
25: #include <sys/types.h>
26: #include <sys/stat.h>
27:
28: #define RO 0
29: #define RW 1
30:
31: #define NONE 0
32: #define BEFORE 1
33: #define AFTER 2
34:
35: #define ALLOK 0
36: #define NOTALL 1
37: #define ERROR 2
38:
39: #define aechk() { if(ferror(afp)) ioerr(anp); }
40: #define techk() { if(ferror(tfp)) ioerr(tnp); }
41:
42: char nwork[] = "No work";
43: char found[] = "found";
44: char copen[] = "%s: cannot open";
45: char ccrea[] = "%s: cannot create";
46: char creop[] = "%s: cannot reopen";
47:
48: FILE *afp;
49: FILE *tfp;
50: FILE *rfp;
51: #define DIRSIZ 14
52: #if PORTAR
53: struct old_ar_hdr ahb;
54: char rnp[] = "";
55: char rnpx[] = "SYMDEF.__";
56: #else
57: #define SARMAG sizeof(short)
58: char rnp[] = HDRNAME;
59: char *rnpx = rnp;
60: struct ar_hdr ahb;
61: #endif
62:
63: int usage();
64: long fsize();
65:
66: long ranCt; /* count of ranlib entrys for coff */
67:
68: int nname;
69: char **namep;
70: int cflag;
71: int kflag;
72: int lflag;
73: int sflag;
74: int uflag;
75: int vflag;
76: int xflag;
77: char *pnp;
78: char *anp;
79: char *tnp;
80: int xstat = ALLOK;
81: int pos = NONE;
82: int (*ffp)() = usage;
83: FILE *makeh();
84:
85: char state[] = "'%s' file not found";
86:
87: /*
88: * ar called as ranlib.
89: */
90: ranlib(argv)
91: char *argv[];
92: {
93: int rfunc();
94:
95: ffp = rfunc;
96: ++sflag;
97: anp = argv[1];
98: (*ffp)();
99: delexit(xstat);
100: }
101:
102: main(argc, argv)
103: char *argv[];
104: {
105: register i;
106: char *p;
107: int usage(), rfunc();
108:
109: if (NULL == (p = strrchr(argv[0], SLASH)))
110: p = argv[0];
111: else
112: p++;
113:
114: if (!strcmp(p, "ranlib"))
115: ranlib(argv);
116:
117: if (strcmp(p, "ar"))
118: diag(1, "called as %s, expecting ar, or ranlib", p);
119:
120: _addargs("AR", &argc, &argv);
121: if (argc < 2)
122: usage();
123: key(argv[1]);
124: nname = argc - 2;
125: namep = &argv[2];
126: for (i = 2; i < argc; ++i) {
127: if (pos != NONE && pnp == NULL) {
128: pnp = argv[i];
129: ++namep;
130: --nname;
131: } else {
132: anp = argv[i];
133: ++namep;
134: --nname;
135: break;
136: }
137: }
138: if (anp == NULL)
139: usage();
140: if (pos != NONE) {
141: if (pnp == NULL)
142: usage();
143: if (ffp == usage)
144: ffp = rfunc;
145: }
146: (*ffp)();
147: delexit(xstat);
148: }
149:
150: /*
151: * Decode key.
152: * Save function name in 'ffp'.
153: * Set 'c', 'l', 'k' and 'v' flags.
154: */
155: key(p)
156: register char *p;
157: {
158: register c;
159: int dfunc(), rfunc(), qfunc(), tfunc();
160: int mfunc(), xfunc(), pfunc();
161:
162: while (c = *p++) {
163: switch (c) {
164:
165: case 'd': /* Delete */
166: ffp = dfunc;
167: break;
168:
169: case 'r': /* Replace */
170: ffp = rfunc;
171: break;
172:
173: case 'q': /* Quick append */
174: ffp = qfunc;
175: break;
176:
177: case 't': /* Tabulate */
178: ffp = tfunc;
179: break;
180:
181: case 'p': /* Print */
182: ffp = pfunc;
183: break;
184:
185: case 'm': /* Move */
186: ffp = mfunc;
187: break;
188:
189: case 'x': /* Extract */
190: ffp = xfunc;
191: ++xflag;
192: break;
193:
194: case 'c': /* no create message */
195: ++cflag;
196: break;
197:
198: case 'k': /* keep dates */
199: ++kflag;
200: break;
201:
202: case 'l': /* local temp file */
203: ++lflag;
204: break;
205:
206: case 's': /* ranlib symbol table */
207: ++sflag;
208: break;
209:
210: case 'u': /* update replace */
211: ++uflag;
212: break;
213:
214: case 'v': /* verbose */
215: ++vflag;
216: break;
217:
218: case 'a': /* after position or append */
219: pos = AFTER;
220: break;
221:
222: case 'b': /* before position */
223: case 'i': /* insert */
224: pos = BEFORE;
225: break;
226:
227: default:
228: usage();
229: }
230: }
231: }
232:
233: /*
234: * Seek forward for ahb.ar_size rounded up.
235: */
236: static
237: seekPast()
238: {
239: long len;
240:
241: len = (ahb.ar_size + 1) & ~1;
242: fseek(afp, len, 1);
243: }
244:
245: /*
246: * Replace.
247: * Eliminate dead stuff if 'u'.
248: * Copy up to insert point.
249: * Copy in new files.
250: * Copy the rest of the file.
251: * Copy back.
252: */
253: rfunc()
254: {
255: register char *qfn;
256: register i, nef;
257: FILE *qfp;
258:
259: if (nname == 0 && sflag == 0)
260: diag(1, nwork);
261: aopen(RW); /* open archive */
262: ropen(); /* maybe open ranlib */
263: if (uflag) {
264: update();
265: fseek(afp, (long)SARMAG, 0); /* bypass magic */
266: if (rfp != NULL) {
267: geth();
268: if (eqh(rnp)) /* if SYMBOL header bypass */
269: seekPast();
270: else
271: fseek(afp, (long)SARMAG, 0);
272: }
273: }
274: topen(); /* open tmpfile */
275: while (nef = geth()) {
276: if (pos==BEFORE && eqh(pnp)) {
277: fseek(afp, (long)-sizeof(struct ar_hdr), 1);
278: break;
279: }
280: if (pos == NONE) {
281: for (i=0; i<nname; ++i) {
282: if ((qfn=namep[i])!=NULL && eqh(qfn))
283: break;
284: }
285: if (i != nname) {
286: seekPast();
287: namep[i] = NULL;
288: remove(i, qfn);
289: qfp = makeh(qfn);
290: if (vflag)
291: printf("%s: in place replace.\n", qfn);
292: puth(tfp, tnp);
293: ffcopy(tfp, tnp, qfp, qfn, (long)ahb.ar_size);
294: fclose(qfp);
295: continue;
296: }
297: }
298: mmove(0);
299: if (pos==AFTER && eqh(pnp))
300: break;
301: }
302: if (nef==0 && pos!=NONE)
303: diag(1, "%s: not in archive", pnp);
304: for (i=0; i<nname; ++i) {
305: if ((qfn=namep[i]) == NULL)
306: continue;
307: remove(i, qfn);
308: qfp = makeh(qfn);
309: if (vflag)
310: printf("%s: replaced.\n", qfn);
311: puth(tfp, tnp);
312: ffcopy(tfp, tnp, qfp, qfn, (long)ahb.ar_size);
313: fclose(qfp);
314: }
315: while (geth())
316: mmove(0);
317: tacopy();
318: }
319:
320: /*
321: * Handle the 'u' option.
322: * Read through the archive, comparing
323: * the dates in the headers to the last
324: * modification dates of the files in
325: * the command line. Make some files
326: * go away.
327: */
328: update()
329: {
330: register char *p;
331: register i;
332: struct stat sb;
333:
334: while (geth()) {
335: for (i=0; i<nname; ++i) {
336: p = namep[i];
337: if (p!=NULL && eqh(p)) {
338: if (stat(p, &sb) < 0)
339: diag(1, state, p);
340: if (ahb.ar_date >= sb.st_mtime) {
341: if (vflag)
342: printf("%s: no update.\n", p);
343: namep[i] = NULL;
344: remove(i, p);
345: }
346: }
347: }
348: seekPast();
349: }
350: for (i=0; i<nname && namep[i]==NULL; ++i)
351: ;
352: if (i >= nname) {
353: if (vflag)
354: fprintf(stderr, "%s.\n", nwork);
355: delexit(ALLOK);
356: }
357: }
358:
359: /*
360: * Move.
361: * Copy stuff before insert.
362: * Copy moved stuff.
363: * Copy remainder.
364: * Copy back to archive.
365: */
366: mfunc()
367: {
368: register nef;
369: long s;
370:
371: aopen(RW);
372: ropen();
373: topen();
374: while (nef = geth()) {
375: if (pos==BEFORE && eqh(pnp))
376: break;
377: mmove(0);
378: if (pos==AFTER && eqh(pnp))
379: break;
380: }
381: if (nef==0 && pos!=NONE)
382: diag(1, "%s: not in archive", pnp);
383: s = ftell(afp);
384: if (pos == BEFORE)
385: s -= sizeof(struct ar_hdr);
386: fseek(afp, (long)SARMAG, 0);
387: while (geth())
388: mmove(1);
389: if (nef) {
390: fseek(afp, s, 0);
391: while (geth())
392: mmove(0);
393: }
394: tacopy();
395: }
396:
397: /*
398: * Conditional move to the
399: * temp file from the archive
400: * file. Used by move and replace
401: */
402: mmove(f1)
403: register f1;
404: {
405: register f2, i;
406: register long size;
407:
408: f2 = 0;
409: for (i=0; i<nname; ++i) {
410: if (eqh(namep[i])) {
411: ++f2;
412: break;
413: }
414: }
415: if (f1 == f2) {
416: if (vflag)
417: amsg("copied");
418: size = ahb.ar_size;
419: puth(tfp, tnp);
420: ffcopy(tfp, tnp, afp, anp, size);
421: } else {
422: if (vflag)
423: amsg("skipped");
424: seekPast();
425: }
426: }
427:
428: /*
429: * Print.
430: */
431: pfunc()
432: {
433: aopen(RO);
434: while (geth()) {
435: if (nname==0 || match())
436: pfile();
437: else
438: seekPast();
439: }
440: if (nname != 0)
441: notdone(found);
442: }
443:
444: pfile()
445: {
446: if (vflag)
447: amsg(NULL);
448: ffcopy(stdout, "Stdout", afp, anp, ahb.ar_size);
449: }
450:
451: /*
452: * Delete.
453: * Copy archive to temp, deleting
454: * members along the way. If all of
455: * the files have been deleted then
456: * copy back.
457: */
458: dfunc()
459: {
460: register long size;
461:
462: if (nname == 0)
463: diag(1, nwork);
464: aopen(RW);
465: ropen();
466: topen();
467: while (geth()) {
468: if (match()) {
469: if (vflag)
470: amsg("deleted");
471: seekPast();
472: continue;
473: }
474: if (vflag)
475: amsg("copied");
476: size = ahb.ar_size;
477: puth(tfp, tnp);
478: ffcopy(tfp, tnp, afp, anp, size);
479: }
480: if (notdone("deleted"))
481: delexit(ERROR);
482: tacopy();
483: }
484:
485: /*
486: * Quick insert.
487: * Copy archive to temp file.
488: * Tack new files onto the end.
489: * If no errors, copy back.
490: */
491: qfunc()
492: {
493: register char *qfn;
494: register FILE *qfp;
495: register i;
496:
497: if (nname == 0)
498: diag(1, nwork);
499: aopen(RW);
500: if (geth() != 0 && eqh(rnp)) {
501: fseek(afp, (long)-sizeof(ahb), 1);
502: ahb.ar_date = 0;
503: puth(afp, anp);
504: }
505: fseek(afp, (long)0, 2);
506: for (i=0; i<nname; ++i) {
507: if ((qfn=namep[i]) == NULL)
508: continue;
509: remove(i, qfn);
510: qfp = makeh(qfn);
511: if (vflag)
512: printf("%s: quick insert.\n", qfn);
513: puth(afp, anp);
514: ffcopy(afp, anp, qfp, qfn, (long)ahb.ar_size);
515: fclose(qfp);
516: }
517: }
518:
519: /*
520: * Table.
521: * Read through archive.
522: * If good member print its name.
523: * If verbose, print extra stuff.
524: */
525: tfunc()
526: {
527: register char *p;
528: register c, n;
529:
530: aopen(RO);
531: while (geth()) {
532: if (nname==0 || match()) {
533: if (!*(p = ahb.ar_name)) {
534: seekPast();
535: continue;
536: }
537: n = 0;
538: while (n<DIRSIZ && (c=*p++)) {
539: putchar(c);
540: ++n;
541: }
542: if (vflag) {
543: while (n++ < DIRSIZ+1)
544: putchar(' ');
545: #if COHERENT
546: printf("%5d %5d ", ahb.ar_gid, ahb.ar_uid);
547: printf("%03o ", ahb.ar_mode & 0777);
548: #endif
549: printf("%10ld ", ahb.ar_size);
550: printf("%s", ctime(&ahb.ar_date));
551: } else
552: putchar('\n');
553: }
554: seekPast();
555: }
556: if (nname != 0)
557: notdone(found);
558: }
559:
560: /*
561: * Extract.
562: * Read through archive.
563: * Extract any files you find.
564: * At end, mutter about files
565: * that were not there.
566: */
567: xfunc()
568: {
569: register char *p1, *p2;
570: register c;
571: char fnb[DIRSIZ+1];
572: FILE *xfp;
573:
574: aopen(RO);
575: while (geth()) {
576: if (nname==0 || match()) {
577: if (!*(p1 = ahb.ar_name)) {
578: seekPast();
579: continue;
580: }
581: p2 = fnb;
582: while (p1<&ahb.ar_name[DIRSIZ] && (c=*p1++))
583: *p2++ = c;
584: *p2 = 0;
585: if ((xfp=fopen(fnb, "wb")) == NULL) {
586: diag(0, ccrea, fnb);
587: seekPast();
588: continue;
589: }
590: if (vflag)
591: amsg("extracting");
592: ffcopy(xfp, fnb, afp, anp, ahb.ar_size);
593: chmod(fnb, ahb.ar_mode);
594:
595: fclose(xfp);
596: if (kflag) {
597: time_t times[2];
598: time_t time();
599:
600: time(times+0);
601: times[1] = ahb.ar_date;
602: if (utime(fnb, times) < 0)
603: diag(0, "Unable to set time for %s",
604: fnb);
605: }
606: } else
607: seekPast();
608: }
609: if (nname != 0)
610: notdone(found);
611: }
612:
613: /*
614: * Make an archive header.
615: * Put it in the external archive
616: * header buffer 'ahb'. The arg.
617: * 'fn' is the file name. The file
618: * is open on 'fp'.
619: */
620: FILE *
621: makeh(fn)
622: char *fn;
623: {
624: FILE *fp;
625: char *p1;
626:
627: struct stat sb;
628:
629: #if GEMDOS
630: if (stat(fn, &sb) < 0)
631: diag(1, state, fn);
632:
633: if (NULL == (fp = fopen(fn, "rb")))
634: diag(1, copen, fn);
635: #else
636: if (NULL == (fp = fopen(fn, "rb")))
637: diag(1, copen, fn);
638:
639: if (fstat(fileno(fp), &sb) < 0)
640: diag(1, state, fn);
641: #endif
642: if (fn == rnpx)
643: fn = "";
644:
645: if (NULL == (p1 = strrchr(fn, SLASH)))
646: p1 = fn - 1;
647:
648: strncpy(ahb.ar_name, p1 + 1, DIRSIZ);
649:
650: if (kflag)
651: ahb.ar_date = sb.st_mtime;
652: else
653: time(&ahb.ar_date);
654: ahb.ar_uid = sb.st_uid;
655: ahb.ar_gid = sb.st_gid;
656: ahb.ar_mode = sb.st_mode & 07777;
657: ahb.ar_size = sb.st_size;
658:
659: return (fp);
660: }
661:
662: /*
663: * Test if the member whose
664: * header is held in the archive
665: * header buffer is mentioned in
666: * the user's list of members.
667: * Return the number of matches.
668: * All matches are NULLed.
669: */
670: match()
671: {
672: register char *p;
673: register i, n;
674:
675: n = 0;
676: for (i=0; i<nname; ++i) {
677: if ((p=namep[i]) == NULL)
678: continue;
679: if (eqh(p)) {
680: ++n;
681: namep[i] = NULL;
682: }
683: }
684: return (n);
685: }
686:
687: /*
688: * Remove all instances of name
689: * 'fn' from the list of names that
690: * is described by 'namep' and
691: * 'nname'.
692: * Start at index 'i+1'.
693: */
694: remove(i, fn)
695: register i;
696: register char *fn;
697: {
698: register char *p;
699:
700: for (++i; i<nname; ++i) {
701: if ((p=namep[i]) == NULL)
702: continue;
703: if (strcmp(fn, p) == 0)
704: namep[i] = NULL;
705: }
706: }
707:
708: /*
709: * This routine digs through the
710: * list of names described by 'namep'
711: * and 'nname' looking for names that
712: * have not been NULLed out. If any
713: * are found it prints a title and
714: * the names. The number of names that
715: * were found is returned.
716: */
717: notdone(s)
718: char *s;
719: {
720: register char *p;
721: register i, n;
722:
723: n = 0;
724: for (i=0; i<nname; ++i) {
725: p = namep[i];
726: if (p != NULL) {
727: if (n++ == 0)
728: fprintf(stderr, "Not %s:\n", s);
729: fprintf(stderr, "%s\n", p);
730: }
731: }
732: return (n);
733: }
734:
735: /*
736: * File to file copy.
737: * With ranlib construction.
738: */
739: ffcopy(tfp, tfn, ffp, ffn, s)
740: FILE *tfp, *ffp;
741: char *tfn, *ffn;
742: long s;
743: {
744: register n;
745: int pad;
746: static char fb[BUFSIZ];
747:
748: if (rfp != NULL)
749: raddmod(tfp, ffp, s);
750:
751: pad = s & 1;
752: for (n = ftell(ffp) % BUFSIZ; s; (s -= n), (n = 0)) {
753: if ((n = BUFSIZ - n) > s)
754: n = s;
755: if (fread (fb, sizeof(char), n, ffp) != n)
756: ioerr(ffn);
757: if (fwrite(fb, sizeof(char), n, tfp) != n)
758: ioerr(tfn);
759: }
760: if (pad) {
761: fgetc(ffp);
762: if (!xflag)
763: fputc(0, tfp);
764: }
765: }
766:
767: /*
768: * Get the next archive header
769: * into 'ahb'. Check for any I/O
770: * errors. Return true if a header
771: * was read and false on EOF.
772: */
773: geth()
774: {
775: #if PORTAR
776: struct ar_hdr hdr;
777: int uid, gid, mode;
778: register char *p;
779:
780: if (fread(&hdr, sizeof(hdr), 1, afp) != 1) {
781: aechk();
782: return (0);
783: }
784:
785: memset(&ahb, '\0', sizeof(ahb));
786: memcpy(ahb.ar_name, hdr.ar_name, DIRSIZ);
787: if (NULL != (p = strchr(ahb.ar_name, '/')))
788: *p = '\0';
789:
790: sscanf(hdr.ar_date, "%d %d %d %o %d",
791: &ahb.ar_date, &uid, &gid, &mode, &ahb.ar_size);
792: ahb.ar_uid = uid; /* use intermediate fields for shorts */
793: ahb.ar_gid = gid;
794: ahb.ar_mode = mode & 07777;
795:
796: #else
797: if (fread(&ahb, sizeof(ahb), 1, afp) != 1) {
798: aechk();
799: return (0);
800: }
801: cantime(ahb.ar_date);
802: canshort(ahb.ar_gid);
803: canshort(ahb.ar_uid);
804: canshort(ahb.ar_mode);
805: cansize(ahb.ar_size);
806: #endif
807: return (1);
808: }
809:
810: /*
811: * Write the header in 'ahb' to
812: * the temp file.
813: */
814: puth(fp, np)
815: FILE *fp;
816: char *np;
817: {
818: #if PORTAR
819: struct ar_hdr hdr;
820: register i;
821:
822: sprintf(hdr.ar_date, "%-12ld%-6d%-6d%-8o%-10ld",
823: ahb.ar_date, ahb.ar_uid,
824: ahb.ar_gid, ahb.ar_mode & 07777, ahb.ar_size);
825:
826: memcpy(hdr.ar_fmag, ARFMAG, sizeof(hdr.ar_fmag));
827:
828: for (i = 0; (i < DIRSIZ) && ahb.ar_name[i]; i++)
829: hdr.ar_name[i] = ahb.ar_name[i];
830: hdr.ar_name[i++] = '/';
831: for (; i < sizeof(hdr.ar_name); i++)
832: hdr.ar_name[i] = ' ';
833:
834: fwrite(&hdr, sizeof(hdr), 1, fp);
835: #else
836: cantime(ahb.ar_date);
837: canshort(ahb.ar_gid);
838: canshort(ahb.ar_uid);
839: canshort(ahb.ar_mode);
840: cansize(ahb.ar_size);
841: fwrite(&ahb, sizeof(ahb), 1, fp);
842: #endif
843: if(ferror(fp))
844: ioerr(np);
845: }
846:
847: /*
848: * Compare a string to the name
849: * of the member in the archive header
850: * buffer. True return if same.
851: */
852: eqh(p)
853: char *p;
854: {
855: register char *p1;
856:
857: if (NULL == (p1 = strrchr(p, SLASH)))
858: p1 = p;
859: else
860: p1++;
861:
862: return (!strncmp(p1, ahb.ar_name, DIRSIZ));
863: }
864:
865: /*
866: * Open archive.
867: * The argument 'aam' is the
868: * access mode (RO or RW).
869: */
870: aopen(aam)
871: {
872: #ifdef PORTAR
873: char buf[SARMAG];
874: #else
875: int i;
876: #endif
877:
878: if ((afp=fopen(anp, "rb")) == NULL) {
879: if (aam == RO)
880: diag(1, copen, anp);
881: if ((afp=fopen(anp, "wb"))==NULL
882: || (afp=freopen(anp, "wrb", afp))==NULL)
883: diag(1, ccrea, anp);
884: if (cflag == 0)
885: printf("%s: new archive.\n", anp);
886: #if PORTAR
887: fputs(ARMAG, afp);
888: #else
889: i = ARMAG;
890: canint(i);
891: fwrite(&i, sizeof(i), 1, afp);
892: #endif
893: aechk();
894: return;
895: }
896: if (aam != RO) {
897: fclose(afp);
898: if ((afp=fopen(anp, "rwb"))==NULL)
899: diag(1, copen, anp);
900: }
901: #if PORTAR
902: fread(buf, SARMAG, 1, afp);
903: aechk();
904: if(memcmp(buf, ARMAG, SARMAG))
905: #else
906: fread(&i, sizeof(i), 1, afp);
907: aechk();
908: canint(i);
909: if (i != ARMAG)
910: #endif
911: diag(1, "%s: not an archive", anp);
912: }
913:
914: /*
915: * Open tempfile.
916: * Stash the name in 'tnp' for
917: * the benefit of 'delexit'.
918: * Honour the 'l' option w.r.t.
919: * file placement.
920: */
921: topen()
922: {
923: int i;
924:
925: extern char *tempnam();
926: tnp = tempnam((lflag ? "." : NULL), "v");
927:
928: if ((tfp=fopen(tnp, "wb")) == NULL)
929: diag(1, ccrea, tnp);
930: #if PORTAR
931: fputs(ARMAG, tfp);
932: #else
933: i = ARMAG;
934: canint(i);
935: fwrite(&i, sizeof(i), 1, tfp);
936: #endif
937: techk();
938: }
939:
940: /*
941: * Copy tempfile back to the
942: * archive.
943: */
944: tacopy()
945: {
946: register FILE *xtp;
947: #if PORTAR
948: char buf[SARMAG];
949: #else
950: int i;
951: #endif
952:
953: fclose(tfp);
954: tfp = NULL; /* Scare off delexit */
955: fclose(afp);
956: if ((xtp=fopen(tnp, "rb")) == NULL)
957: diag(1, creop, tnp);
958: if ((afp=fopen(anp, "wb")) == NULL)
959: diag(1, creop, anp);
960: if (vflag)
961: printf("%s: copy back.\n", anp);
962: #if PORTAR
963: if (fread(buf, SARMAG, 1, xtp) != 1)
964: ioerr(tnp);
965: if (fwrite(buf, SARMAG, 1, afp) != 1)
966: ioerr(anp);
967: if (rfp != NULL)
968: rcopy();
969: ffcopy(afp, anp, xtp, tnp, fsize(xtp, tnp) - SARMAG);
970: #else
971: if (fread(&i, sizeof(i), 1, xtp) != 1)
972: ioerr(tnp);
973: if (fwrite(&i, sizeof(i), 1, afp) != 1)
974: ioerr(anp);
975: if (rfp != NULL)
976: rcopy();
977: ffcopy(afp, anp, xtp, tnp, fsize(xtp, tnp) - sizeof(int));
978: #endif
979: tfp = xtp; /* Delete */
980: }
981:
982: /*
983: * Write diagnostic.
984: * The flag 'f' marks fatal errors.
985: */
986: diag(f, a)
987: {
988: fprintf(stderr, "%r.\n", &a);
989: if (f)
990: delexit(ERROR);
991: xstat = NOTALL;
992: }
993:
994: /*
995: * Print a message for a
996: * given archive member. The header
997: * is in the header buffer.
998: */
999: amsg(s)
1000: char *s;
1001: {
1002: register char *p;
1003: register c;
1004:
1005: p = ahb.ar_name;
1006: while (p<&ahb.ar_name[DIRSIZ] && (c=*p++)!=0)
1007: putchar(c);
1008: putchar(':');
1009: if (s != NULL)
1010: printf(" %s.", s);
1011: putchar('\n');
1012: }
1013:
1014: /*
1015: * Exit.
1016: * Delete the tempfile if
1017: * present.
1018: */
1019: delexit(s)
1020: {
1021: if (tfp != NULL)
1022: unlink(tnp);
1023: #ifdef DEBUG
1024: if (s)
1025: abort();
1026: #endif
1027: unlink(rnpx);
1028: exit(s);
1029: }
1030:
1031: /*
1032: * Mutter about an I/O error
1033: * on file 's'.
1034: */
1035: ioerr(s)
1036: char *s;
1037: {
1038: diag(1, "%s: I/O error", s);
1039: }
1040:
1041: /*
1042: * Print usage message.
1043: */
1044: usage()
1045: {
1046: fprintf(stderr, "Usage: ar options [posname] afile [name ...].\n");
1047: delexit(ERROR);
1048: }
1049:
1050: /*
1051: * Compute the size of a file.
1052: * In bytes.
1053: * The file must not be seeked.
1054: */
1055: long
1056: fsize(fp, fn)
1057: FILE *fp;
1058: char *fn;
1059: {
1060: struct stat sb;
1061:
1062: #if GEMDOS
1063: if (stat(fn, &sb) < 0)
1064: diag(1, state, fn);
1065: #else
1066: fstat(fileno(fp), &sb);
1067: #endif
1068: return (sb.st_size);
1069: }
1070:
1071: /*
1072: * Ranlib stuff.
1073: * If the current archive has HDRNAME as first module,
1074: * then skip it and open rfp for creation of new ranlib header,
1075: * otherwise backup and make a vanilla archive.
1076: * Unless sflag was set as an option,
1077: * in which case make rfp anyway.
1078: * Unless HDRNAME matches the name list and ffp == dfunc,
1079: * in which case make rfp only if sflag was set.
1080: */
1081: ropen()
1082: {
1083: extern int dfunc();
1084: long loc;
1085:
1086: ranCt = 0;
1087: loc = ftell(afp);
1088: if (geth() != 0) { /* Must not be end of file */
1089: if (eqh(rnp)) { /* Symbol header */
1090: seekPast();
1091: if (ffp == dfunc && match()) {
1092: if (vflag)
1093: amsg("deleted");
1094: } else
1095: ++sflag;
1096: } else {
1097: fseek(afp, loc, 0);
1098: if (sflag && ffp == dfunc) {
1099: strcpy(ahb.ar_name, rnp);
1100: match();
1101: }
1102: }
1103: }
1104: if (sflag && (rfp = fopen(rnpx, "wb")) == NULL)
1105: diag(1, ccrea, rnpx);
1106: }
1107:
1108: /*
1109: * Add the symbols in mfp to the ranlib header,
1110: * and seek mfp back to where it began.
1111: * The postion of this module in the archive
1112: * is -sizeof(arhdr) from current position of afp.
1113: */
1114: #if PORTAR
1115: raddmod(afp, mfp, s)
1116: FILE *afp, *mfp;
1117: long s;
1118: {
1119: FILEHDR fdh;
1120: SYMENT sym;
1121: long off;
1122: long str_length, aroff, i;
1123: int len, j, c, aux;
1124: char *str_tab;
1125:
1126: aroff = ftell(afp) - sizeof(struct ar_hdr);
1127: off = ftell(mfp);
1128: str_length = fdh.f_magic = 0;
1129: if (1 != fread(&fdh, sizeof(fdh), 1, mfp) ||
1130: (C_386_MAGIC != fdh.f_magic) ||
1131: !fdh.f_nsyms)
1132: goto done;
1133:
1134: i = fdh.f_symptr + (SYMESZ * fdh.f_nsyms);
1135: str_length = 0;
1136: if (!fdh.f_symptr)
1137: goto done;
1138: if (i < s) { /* make our own eof inside archive */
1139: fseek(mfp, i + off, 0);
1140: if (1 != fread(&str_length, sizeof(str_length), 1, mfp))
1141: str_length = 0;
1142: }
1143: if (str_length) {
1144: len = str_length -= 4;
1145: if (len != str_length)
1146: diag(1, "Cannot process %.*s small model",
1147: DIRSIZ, ahb.ar_name);
1148: if(NULL == (str_tab = malloc(len)))
1149: diag(1, "out of space %.*s", DIRSIZ, ahb.ar_name);
1150: if (1 != fread(str_tab, len, 1, mfp))
1151: diag(1, "truncated module %.*s", DIRSIZ, ahb.ar_name);
1152: }
1153:
1154: fseek(mfp, fdh.f_symptr + off, 0);
1155:
1156: for (aux = i = 0; i < fdh.f_nsyms; i++) {
1157: if (1 != fread(&sym, sizeof(sym), 1, mfp))
1158: diag(1, "truncated module %.*s", DIRSIZ, ahb.ar_name);
1159:
1160: /* bypass aux symbols */
1161: if (aux) {
1162: aux--;
1163: continue;
1164: }
1165: aux = sym.n_numaux;
1166:
1167: if (C_EXT != sym.n_sclass ||
1168: (!sym.n_scnum && !sym.n_value))
1169: continue;
1170:
1171: fwrite(&aroff, sizeof(aroff), 1, rfp);
1172: ranCt++;
1173:
1174: if (!sym._n._n_n._n_zeroes) {
1175: fputs(str_tab + sym._n._n_n._n_offset - 4, rfp);
1176: fputc(0, rfp);
1177: continue;
1178: }
1179: for (j = 0; (j < SYMNMLEN) && (c = sym._n._n_name[j]); j++)
1180: fputc(c, rfp);
1181: fputc(0, rfp);
1182: }
1183: if (str_length)
1184: free(str_tab);
1185: done:
1186: fseek(mfp, off, 0);
1187: }
1188:
1189: /*
1190: * Reverse byte order on 386s
1191: */
1192: flipwrite(x)
1193: unsigned long x;
1194: {
1195: #ifdef GEMDOS
1196: if (1 != fwrite(&x, sizeof(x), 1, afp))
1197: ioerr(anp);
1198: #else
1199: union full {
1200: unsigned char uc[4];
1201: unsigned long ul;
1202: } l;
1203: unsigned char c;
1204:
1205: l.ul = x;
1206: c = l.uc[0]; l.uc[0] = l.uc[3]; l.uc[3] = c;
1207: c = l.uc[1]; l.uc[1] = l.uc[2]; l.uc[2] = c;
1208:
1209: if (1 != fwrite(&l, sizeof(x), 1, afp))
1210: ioerr(anp);
1211: #endif
1212: }
1213:
1214: /*
1215: * Copy the ranlib header to the output archive.
1216: * Close and null the ranlib file pointer
1217: */
1218: rcopy()
1219: {
1220: register FILE *fp;
1221: int c, pad;
1222: long i, x, ranLen;
1223:
1224: ranLen = ftell(rfp); /* we are at the end */
1225: fclose(rfp);
1226: rfp = NULL;
1227:
1228: fp = makeh(rnpx);
1229: pad = ranLen & 1;
1230: ahb.ar_size = ranLen += pad + sizeof(ranCt);
1231:
1232: time(&ahb.ar_date);
1233: ahb.ar_date += (long)(10*365+3)*24*60*60;
1234:
1235: puth(afp, anp);
1236: tfp = NULL;
1237: flipwrite(ranCt);
1238: ranLen += sizeof(struct ar_hdr);
1239:
1240: for (i = 0; i < ranCt; i++) {
1241: if (1 != fread(&x, sizeof(x), 1, fp))
1242: ioerr(rnpx);
1243: flipwrite(x + ranLen);
1244: while(fgetc(fp))
1245: ;
1246: }
1247:
1248: fseek (fp, 0L, 0);
1249: for (i = 0; i < ranCt; i++) {
1250: if (1 != fread(&x, sizeof(x), 1, fp))
1251: ioerr(rnpx);
1252: while (c = fgetc(fp))
1253: fputc(c, afp);
1254: fputc(0, afp);
1255: }
1256: if (pad)
1257: fputc(0, afp);
1258:
1259: fclose(fp);
1260: unlink(rnpx);
1261: }
1262: #else
1263: struct ldheader ldh;
1264: struct ldsym lds;
1265: struct ar_sym ars;
1266:
1267: xwrite()
1268: {
1269: if (fwrite(lds.ls_id, sizeof(lds.ls_id), 1, rfp) != 1
1270: || fwrite(&ars.ar_off, sizeof(ars.ar_off), 1, rfp) != 1)
1271: ioerr(rnpx);
1272: }
1273:
1274: xread(fp) register FILE *fp;
1275: {
1276: register int r;
1277: union { long l; unsigned u[2]; } u;
1278:
1279: if ((ldh.l_flag & LF_32) == 0) {
1280: r = fread(&lds, sizeof(lds)-sizeof(short), 1, fp);
1281: u.l = lds.ls_addr;
1282: canshort(u.u[0]);
1283: lds.ls_addr = u.u[0];
1284: } else {
1285: r = fread(&lds, sizeof(lds), 1, fp);
1286: canlong(lds.ls_addr);
1287: }
1288: canshort(lds.ls_type);
1289: return (r);
1290: }
1291:
1292: raddmod(afp, mfp) FILE *afp, *mfp;
1293: {
1294: fsize_t off, offset;
1295: int seg, nsym;
1296:
1297: ars.ar_off = ftell(afp) - sizeof(ahb) - SARMAG;
1298: cansize(ars.ar_off);
1299: off = ftell(mfp);
1300: ldh.l_magic = 0; /* in case fread fails */
1301: if (fread(&ldh, sizeof ldh, 1, mfp) != 1)
1302: goto done;
1303: canshort(ldh.l_magic);
1304: if (ldh.l_magic != L_MAGIC)
1305: goto done;
1306: canshort(ldh.l_flag);
1307: if ((ldh.l_flag & LF_32) == 0)
1308: ldh.l_tbase = sizeof(ldh) - 2*sizeof(short);
1309: else
1310: canshort(ldh.l_tbase);
1311: offset = ldh.l_tbase - (fsize_t)sizeof(ldh);
1312: for (seg=0; seg<L_SYM; seg++) {
1313: if (seg==L_BSSI || seg==L_BSSD)
1314: continue;
1315: cansize(ldh.l_ssize[seg]);
1316: offset += ldh.l_ssize[seg];
1317: }
1318: fseek(mfp, offset, 1);
1319: cansize(ldh.l_ssize[L_SYM]);
1320: if ((ldh.l_flag & LF_32) == 0)
1321: nsym = ldh.l_ssize[L_SYM]
1322: / (sizeof(struct ldsym) - sizeof(short));
1323: else
1324: nsym = ldh.l_ssize[L_SYM]/sizeof(struct ldsym);
1325: while (nsym--) {
1326: if (xread(mfp) == 0)
1327: diag(1, "truncated module %.*s", DIRSIZ, ahb.ar_name);
1328: if ((lds.ls_type&L_GLOBAL) == 0)
1329: continue;
1330: if ((lds.ls_type&LR_SEG) != L_REF)
1331: xwrite();
1332: }
1333: done:
1334: fseek(mfp, off, 0); /* back to beginning of module */
1335: }
1336:
1337: /*
1338: * Copy the ranlib header to the output archive
1339: * close and null the ranlib file pointer.
1340: */
1341: rcopy()
1342: {
1343: register FILE *fp;
1344: fclose(rfp);
1345: rfp = NULL;
1346: fp = makeh(rnpx);
1347: time(&ahb.ar_date);
1348: ahb.ar_date += (long)(10*365+3)*24*60*60;
1349: puth(afp, anp);
1350: tfp = NULL;
1351: ffcopy(afp, anp, fp, rnpx, fsize(fp, rnpx));
1352: fclose(fp);
1353: unlink(rnpx);
1354: }
1355: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.