361 lines
7.9 KiB
C
361 lines
7.9 KiB
C
/*
|
|
* Copyright (c) 1980 Regents of the University of California.
|
|
* All rights reserved. The Berkeley software License Agreement
|
|
* specifies the terms and conditions for redistribution.
|
|
*/
|
|
|
|
#ifndef lint
|
|
char copyright[] =
|
|
"@(#) Copyright (c) 1980 Regents of the University of California.\n\
|
|
All rights reserved.\n";
|
|
#endif not lint
|
|
|
|
#ifndef lint
|
|
static char sccsid[] = "@(#)ranlib.c 1.1 94/10/31 SMI"; /* from UCB 5.2 9.5.85 */
|
|
#endif not lint
|
|
/*
|
|
* ranlib - create table of contents for archive; string table version
|
|
*/
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <ar.h>
|
|
#include <ranlib.h>
|
|
#include <a.out.h>
|
|
#include <stdio.h>
|
|
|
|
#ifdef BROWSER
|
|
|
|
#ifndef cb_library_tags_h_INCLUDED
|
|
#include "cb_library_tags.h"
|
|
#endif
|
|
|
|
char *cb_program_name = "ranlib";
|
|
|
|
cb_callback_write_stab()
|
|
{
|
|
}
|
|
#else
|
|
+++ -DBROWSER is to be left ON! +++
|
|
#endif
|
|
|
|
struct ar_hdr archdr;
|
|
#define OARMAG 0177545
|
|
long arsize;
|
|
struct exec exp;
|
|
FILE *fi, *fo;
|
|
long off, oldoff;
|
|
long atol(), ftell();
|
|
#define TABSZ 6000
|
|
int tabsz = TABSZ;
|
|
struct ranlib *tab;
|
|
int tnum;
|
|
#define STRTABSZ 75000
|
|
int strtabsz = STRTABSZ;
|
|
char *tstrtab;
|
|
int tssiz;
|
|
char *strtab;
|
|
int ssiz;
|
|
int new;
|
|
char tempnm[] = "__.SYMDEF";
|
|
char firstname[17];
|
|
|
|
main(argc, argv)
|
|
char **argv;
|
|
{
|
|
char cmdbuf[BUFSIZ];
|
|
/* magbuf must be an int array so it is aligned on an int-ish
|
|
boundary, so that we may access its first word as an int! */
|
|
int magbuf[(SARMAG+sizeof(int))/sizeof(int)];
|
|
register int just_touch = 0;
|
|
register int doupdate;
|
|
|
|
/* check for the "-t" flag" */
|
|
if (argc > 1 && strcmp(argv[1], "-t") == 0) {
|
|
just_touch++;
|
|
argc--;
|
|
argv++;
|
|
}
|
|
|
|
--argc;
|
|
/* allocate initial buffers */
|
|
if ((tab = (struct ranlib *)malloc(TABSZ * sizeof (*tab))) == 0 ||
|
|
(tstrtab = (char *)malloc(STRTABSZ * sizeof (*tstrtab))) == 0) {
|
|
fprintf(stderr, "ranlib: cannot allocate buffers\n");
|
|
exit(1);
|
|
}
|
|
while(argc--) {
|
|
fi = fopen(*++argv,"r");
|
|
#ifdef BROWSER
|
|
cb_ranlib_start_library(*argv,
|
|
CB_CURRENT_LANGUAGE,
|
|
CB_CURRENT_MAJOR_VERSION,
|
|
CB_CURRENT_MINOR_VERSION,
|
|
CB_EX_FOCUS_UNIT_LIBRARY_FORMAT);
|
|
#endif
|
|
if (fi == NULL) {
|
|
fprintf(stderr, "ranlib: cannot open %s\n", *argv);
|
|
continue;
|
|
}
|
|
off = SARMAG;
|
|
fread((char *)magbuf, 1, SARMAG, fi);
|
|
if (strncmp((char *)magbuf, ARMAG, SARMAG)) {
|
|
if (magbuf[0] == OARMAG)
|
|
fprintf(stderr, "old format ");
|
|
else
|
|
fprintf(stderr, "not an ");
|
|
fprintf(stderr, "archive: %s\n", *argv);
|
|
continue;
|
|
}
|
|
if (just_touch) {
|
|
register int len;
|
|
|
|
fseek(fi, (long) SARMAG, 0);
|
|
if (fread(cmdbuf, sizeof archdr.ar_name, 1, fi) != 1) {
|
|
fprintf(stderr, "malformed archive: %s\n",
|
|
*argv);
|
|
continue;
|
|
}
|
|
len = strlen(tempnm);
|
|
if (bcmp(cmdbuf, tempnm, len) != 0 ||
|
|
cmdbuf[len] != ' ') {
|
|
fprintf(stderr, "no symbol table: %s\n", *argv);
|
|
continue;
|
|
}
|
|
fclose(fi);
|
|
fixdate(*argv);
|
|
continue;
|
|
}
|
|
fseek(fi, 0L, 0);
|
|
new = tnum = 0;
|
|
tssiz = 0;
|
|
if (nextel(fi) == 0) {
|
|
fclose(fi);
|
|
continue;
|
|
}
|
|
do {
|
|
long o;
|
|
register n;
|
|
struct nlist sym;
|
|
|
|
if(strncmp(archdr.ar_name, tempnm, sizeof (archdr.ar_name)) == 0)
|
|
continue;
|
|
fread((char *)&exp, 1, sizeof(struct exec), fi);
|
|
if (N_BADMAG(exp))
|
|
continue;
|
|
if (!strncmp(tempnm, archdr.ar_name, sizeof(archdr.ar_name)))
|
|
continue;
|
|
if (exp.a_syms == 0) {
|
|
fprintf(stderr,
|
|
"ranlib: warning: %s(%s): no symbol table\n",
|
|
*argv, archdr.ar_name);
|
|
continue;
|
|
}
|
|
o = N_STROFF(exp) - sizeof (struct exec);
|
|
if (ftell(fi)+o+sizeof(ssiz) >= off) {
|
|
fprintf(stderr,
|
|
"ranlib: warning: %s(%s): old format .o file\n",
|
|
*argv, archdr.ar_name);
|
|
continue;
|
|
}
|
|
fseek(fi, o, 1);
|
|
fread((char *)&ssiz, 1, sizeof (ssiz), fi);
|
|
if (ssiz < sizeof ssiz){
|
|
/* sanity check */
|
|
fprintf(stderr,
|
|
"ranlib: warning: %s(%s): mangled string table\n",
|
|
*argv, archdr.ar_name);
|
|
continue;
|
|
}
|
|
strtab = (char *)calloc(1, ssiz);
|
|
if (strtab == 0) {
|
|
fprintf(stderr, "ranlib: ran out of memory\n");
|
|
exit(1);
|
|
}
|
|
fread(strtab+sizeof(ssiz), ssiz - sizeof(ssiz), 1, fi);
|
|
fseek(fi, -(exp.a_syms+ssiz), 1);
|
|
n = exp.a_syms / sizeof(struct nlist);
|
|
while (--n >= 0) {
|
|
fread((char *)&sym, 1, sizeof(sym), fi);
|
|
if (sym.n_un.n_strx == 0)
|
|
continue;
|
|
sym.n_un.n_name = strtab + sym.n_un.n_strx;
|
|
#ifdef BROWSER
|
|
if (sym.n_type == 0x48) {
|
|
cb_ranlib_symbol(sym.n_un.n_name,
|
|
cb_focus_library_unit);
|
|
continue;
|
|
}
|
|
#endif
|
|
if ((sym.n_type&N_EXT)==0)
|
|
continue;
|
|
switch (sym.n_type&N_TYPE) {
|
|
|
|
case N_UNDF:
|
|
if (sym.n_value!=0)
|
|
stash(&sym);
|
|
continue;
|
|
|
|
default:
|
|
stash(&sym);
|
|
continue;
|
|
}
|
|
}
|
|
} while(nextel(fi));
|
|
new = fixsize();
|
|
fclose(fi);
|
|
doupdate = 0;
|
|
if (tnum == 0) {
|
|
/*
|
|
* No symbols in the archive. Delete the table of
|
|
* contents from the archive, if it's there,
|
|
* otherwise, leave the archive alone.
|
|
*/
|
|
if(!new) {
|
|
sprintf(cmdbuf, "ar dl %s %s\n", *argv,
|
|
tempnm);
|
|
updatearchive(cmdbuf, *argv);
|
|
}
|
|
} else {
|
|
/*
|
|
* There are symbols in the archive. Build a
|
|
* table-of-contents file; replace the current one
|
|
* in the archive, if there's one there, otherwise
|
|
* add it.
|
|
*/
|
|
fo = fopen(tempnm, "w");
|
|
if(fo == NULL) {
|
|
fprintf(stderr, "ranlib: can't create ");
|
|
perror(tempnm);
|
|
exit(1);
|
|
}
|
|
tnum *= sizeof (struct ranlib);
|
|
fwrite(&tnum, 1, sizeof (tnum), fo);
|
|
tnum /= sizeof (struct ranlib);
|
|
fwrite((char *)tab, tnum, sizeof(struct ranlib), fo);
|
|
fwrite(&tssiz, 1, sizeof (tssiz), fo);
|
|
fwrite(tstrtab, tssiz, 1, fo);
|
|
fclose(fo);
|
|
if(new)
|
|
sprintf(cmdbuf, "ar rlb %s %s %s\n",
|
|
firstname, *argv, tempnm);
|
|
else
|
|
sprintf(cmdbuf, "ar rl %s %s\n", *argv,
|
|
tempnm);
|
|
updatearchive(cmdbuf, *argv);
|
|
unlink(tempnm);
|
|
}
|
|
}
|
|
#ifdef BROWSER
|
|
cb_ranlib_exit();
|
|
#endif
|
|
exit(0);
|
|
}
|
|
|
|
nextel(af)
|
|
FILE *af;
|
|
{
|
|
register r;
|
|
register char *cp;
|
|
|
|
oldoff = off;
|
|
fseek(af, off, 0);
|
|
r = fread((char *)&archdr, 1, sizeof(struct ar_hdr), af);
|
|
if (r != sizeof(struct ar_hdr))
|
|
return(0);
|
|
for (cp=archdr.ar_name; cp < & archdr.ar_name[sizeof(archdr.ar_name)]; cp++)
|
|
if (*cp == ' ')
|
|
*cp = '\0';
|
|
arsize = atol(archdr.ar_size);
|
|
if (arsize & 1)
|
|
arsize++;
|
|
off = ftell(af) + arsize;
|
|
return(1);
|
|
}
|
|
|
|
stash(s)
|
|
struct nlist *s;
|
|
{
|
|
int i;
|
|
register char *cp;
|
|
|
|
if (tnum >= tabsz) {
|
|
tabsz *= 2;
|
|
tab = (struct ranlib *)realloc( tab, tabsz*sizeof *tab );
|
|
if (tab == 0){
|
|
fprintf(stderr, "ranlib: symbol table overflow\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
tab[tnum].ran_un.ran_strx = tssiz;
|
|
tab[tnum].ran_off = oldoff;
|
|
for (cp = s->n_un.n_name; tstrtab[tssiz++] = *cp++;)
|
|
if (tssiz >= strtabsz) {
|
|
strtabsz *= 2;
|
|
tstrtab = (char *)realloc( tstrtab, strtabsz*sizeof *tstrtab);
|
|
if (tstrtab == 0) {
|
|
fprintf(stderr, "ranlib: string table overflow\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
tnum++;
|
|
}
|
|
|
|
fixsize()
|
|
{
|
|
int i;
|
|
off_t offdelta;
|
|
|
|
if (tssiz&1)
|
|
tssiz++;
|
|
offdelta = sizeof(archdr) + sizeof (tnum) + tnum * sizeof(struct ranlib) +
|
|
sizeof (tssiz) + tssiz;
|
|
off = SARMAG;
|
|
nextel(fi);
|
|
if(strncmp(archdr.ar_name, tempnm, sizeof (archdr.ar_name)) == 0) {
|
|
new = 0;
|
|
offdelta -= sizeof(archdr) + arsize;
|
|
} else {
|
|
new = 1;
|
|
strncpy(firstname, archdr.ar_name, sizeof(archdr.ar_name));
|
|
}
|
|
for(i=0; i<tnum; i++)
|
|
tab[i].ran_off += offdelta;
|
|
return(new);
|
|
}
|
|
|
|
updatearchive(cmd, archname)
|
|
char *cmd;
|
|
char *archname;
|
|
{
|
|
if(system(cmd))
|
|
fprintf(stderr, "ranlib: ``%s'' failed\n", cmd);
|
|
else
|
|
fixdate(archname);
|
|
}
|
|
|
|
/* patch time */
|
|
fixdate(s)
|
|
char *s;
|
|
{
|
|
long time();
|
|
char buf[24];
|
|
int fd, tm;
|
|
struct stat stat;
|
|
|
|
fd = open(s, 1);
|
|
if(fd < 0) {
|
|
fprintf(stderr, "ranlib: can't reopen %s\n", s);
|
|
return;
|
|
}
|
|
if (fstat(fd, &stat) < 0) {
|
|
fprintf(stderr, "ranlib: can't stat %s\n", s);
|
|
return;
|
|
}
|
|
tm = time((long *)NULL);
|
|
tm = (tm > stat.st_mtime) ? tm : stat.st_mtime;
|
|
sprintf(buf, "%-*ld", sizeof(archdr.ar_date), tm + 5);
|
|
lseek(fd, (long)SARMAG + ((char *)archdr.ar_date-(char *)&archdr), 0);
|
|
write(fd, buf, sizeof(archdr.ar_date));
|
|
close(fd);
|
|
}
|