Return to symwrite.c CVS log

Up to [Research Unix] / researchv9 / cmd / strip

Annotation of researchv9/cmd/strip/symwrite.c, revision 1.1.1.1

1.1       root        1: #include "strip.h"
                      2: #include "hash.h"
                      3: 
                      4: symwrite(a)
                      5: register Adotout *a;
                      6: {
                      7:        int utmp;
                      8:        struct stx {
                      9:                char *lo, *hi;
                     10:                int base;
                     11:        } *stxtab, *stxend;
                     12:        char *rindex(), *mktemp(), *strcpy();
                     13: 
                     14:        register struct nlist *sym;
                     15:        register struct stx *stabx; register char *cp;
                     16: 
                     17:        struct st *stab; int strcount = 4;
                     18:        int tofd, error = 0;
                     19: 
                     20:        mktemp(strcpy(tmpnam, "/tmp/stripXXXXXX"));
                     21:        tofd = creat(tmpnam, 0666);
                     22:        if (tofd < 0)
                     23:                return failure("cannot creat ", tmpnam);
                     24: 
                     25:        lseek(a->fd, 0, 0);
                     26:        error = fcopy(tofd, a->fd, N_SYMOFF(a->hd));
                     27: 
                     28:        if (a->symtab) {
                     29:                stabx = stxtab = Malloc(struct stx, stcount);
                     30:                stxend = stxtab + stcount;
                     31:                for (stab = sroot; stab; stab = stab->next, stabx++) {
                     32:                        stabx->lo = stab->strtab;
                     33:                        stabx->hi = stabx->lo + stab->nused;
                     34:                        stabx->base = (long)(stabx->lo) - strcount;
                     35:                        strcount += stab->nused;
                     36:                }
                     37:                for (sym=a->symtab; sym<a->symend; sym++)
                     38:                        if (cp = sym->n_un.n_name) {
                     39:                                stabx = stxtab;
                     40:                                while (cp < stabx->lo || cp >= stabx->hi) ++stabx;
                     41:                                sym->n_un.n_name -= stabx->base;
                     42:                        }
                     43:                free(stxtab);
                     44:                a->hd.a_syms = (char *)a->symend - (char *)a->symtab;
                     45:        } else
                     46:                a->hd.a_syms = 0;
                     47: 
                     48:        lseek(tofd, 0, 0);
                     49:        error |= Write(tofd, (char *)&a->hd, sizeof(struct exec));
                     50: 
                     51:        if (a->symtab) {
                     52:                lseek(tofd, N_SYMOFF(a->hd), 0);
                     53:                error |= Write(tofd, a->symtab, a->hd.a_syms);
                     54:                error |= Write(tofd, &strcount, 4);
                     55:                for (stab = sroot; stab; stab = stab->next)
                     56:                        error |= Write(tofd, stab->strtab, stab->nused);
                     57:        }
                     58:        error |= close(tofd);
                     59:        close(a->fd);
                     60:        if (error)
                     61:                return failure("cannot write ", tmpnam);
                     62:        if ((a->fd = open(tmpnam, 0)) < 0)
                     63:                return failure("cannot reopen ", tmpnam);
                     64:        fstat(a->fd, &a->filstat);
                     65:        utmp = umask(0);
                     66:        tofd = creat(a->name, a->filstat.st_mode);
                     67:        (void)umask(utmp);
                     68:        if (tofd < 0)
                     69:                return failure("cannot creat ", a->name);
                     70:        ++copyrace;
                     71:        fcopy(tofd, a->fd, a->filstat.st_size);
                     72:        close(tofd);
                     73:        close(a->fd);
                     74:        --copyrace;
                     75:        if (unlink(tmpnam) < 0)
                     76:                return failure("cannot unlink ", tmpnam);
                     77:        return 0;
                     78: }
                     79: 
                     80: failure(m1, m2)
                     81: char *m1, *m2;
                     82: {
                     83:        if (m1)
                     84:                fprintf(stderr,"%s: %s%s\n", prognam, m1, m2);
                     85:        if (!copyrace && tmpnam[0])
                     86:                unlink(tmpnam);
                     87:        return 1;
                     88: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.