Return to hksyminit.c CVS log

Up to [Research Unix] / researchv10no / cmd / adb / cray

Annotation of researchv10no/cmd/adb/cray/hksyminit.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * set up the symbol table
        !             3:  * very cheap hack version for cray:
        !             4:  * read the loader map
        !             5:  */
        !             6: 
        !             7: #include "defs.h"
        !             8: #include "sym.h"
        !             9: #include <stdio.h>
        !            10: #include "machine.h"
        !            11: 
        !            12: #define        NMFMT   "%s %lo%c"      /* name value (junk) */
        !            13: 
        !            14: #define        NSYMS   20
        !            15: 
        !            16: static lcopy();
        !            17: 
        !            18: /*
        !            19:  * `fn' is the name of the a.out file.
        !            20:  * if it was a valid a.out, look for a map in `fn'.map
        !            21:  * else see if fn itself is a map
        !            22:  */
        !            23: 
        !            24: hksyminit(fn, isexec)
        !            25: char *fn;
        !            26: int isexec;
        !            27: {
        !            28:        FILE *fp;
        !            29:        register struct sym *p;
        !            30:        struct sym *syms;
        !            31:        char buf[ARB];
        !            32:        long val;
        !            33:        char flag;
        !            34:        char name[ARB];
        !            35:        int inmap = 0;
        !            36:        char *malloc();
        !            37: 
        !            38:        symtab = NULL;
        !            39:        strcpy(name, fn);
        !            40:        if (isexec)
        !            41:                strcat(name, ".map");
        !            42:        if ((fp = fopen(name, "r")) == NULL)
        !            43:                return;
        !            44:        if (fgets(buf, ARB, fp) == NULL
        !            45:        ||  (buf[0] != '1' || buf[2] != ' ')) {
        !            46:                fclose(fp);
        !            47:                return;         /* probably not a loader map */
        !            48:        }
        !            49:        syms = NULL;
        !            50:        while (fgets(buf, ARB, fp)) {
        !            51:                if (inmap == 0) {
        !            52:                        if (maphdr(buf) == 0)
        !            53:                                continue;
        !            54:                        inmap++;
        !            55:                }
        !            56:                if (sscanf(buf, NMFMT, name, &val, &flag) != 3)
        !            57:                        continue;
        !            58:                if (!isalpha(name[0]))
        !            59:                        continue;
        !            60:                if (syms == NULL || p >= syms + NSYMS) {
        !            61:                        if ((syms = (struct sym *)malloc(NSYMS * sizeof(struct sym))) == NULL) {
        !            62:                                printf("out of mem for syms");
        !            63:                                break;
        !            64:                        }
        !            65:                        p = syms;
        !            66:                }
        !            67:                if ((p->y_name = malloc(strlen(name) + 1)) == NULL) {
        !            68:                        printf("out of mem for syms");
        !            69:                        break;
        !            70:                }
        !            71:                lcopy(p->y_name, name);
        !            72:                p->y_value = watoba(val);
        !            73:                if (flag == ' ')
        !            74:                        p->y_type = S_DATA;
        !            75:                else
        !            76:                        p->y_type = S_TEXT;     /* parcel addr */
        !            77:                p->y_next = symtab;
        !            78:                symtab = p;
        !            79:                p++;
        !            80:        }
        !            81:        fclose(fp);
        !            82: }
        !            83: 
        !            84: /*
        !            85:  * look for the beginning of the interesting part
        !            86:  * this is just to cut down on specious syms
        !            87:  */
        !            88: 
        !            89: maphdr(s)
        !            90: register char *s;
        !            91: {
        !            92: 
        !            93:        while (*s == ' ')
        !            94:                s++;
        !            95:        return (strncmp(s, "ENTRY POINT CROSS-", 18) == 0);
        !            96: }
        !            97: 
        !            98: static
        !            99: lcopy(s, t)
        !           100: register char *s, *t;
        !           101: {
        !           102: 
        !           103:        while (*t) {
        !           104:                if (*t == '$') {
        !           105:                        *s++ = '_';
        !           106:                        t++;
        !           107:                }
        !           108:                else
        !           109:                        *s++ = *t++;
        !           110:        }
        !           111:        *s = 0;
        !           112: }
        !           113: 
        !           114: /*
        !           115:  * compare sym entry name with one the user typed
        !           116:  */
        !           117: eqsym(sp, n)
        !           118: struct sym *sp;
        !           119: char *n;
        !           120: {
        !           121: 
        !           122:        return (strncmp(sp->y_name, n, 8) == 0);
        !           123: }

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