Return to symtab.h CVS log

Up to [Research Unix] / researchv9 / jtools / src / pi

Annotation of researchv9/jtools/src/pi/symtab.h, revision 1.1.1.1

1.1       root        1: #ifndef SYMTAB_H
                      2: #define SYMTAB_H
                      3: #ifndef UNIV_H
                      4: #include "univ.h"
                      5: #endif
                      6: 
                      7: #include "mip.h"
                      8: extern int FunctionGathered, UTypeGathered, FunctionStubs, UTypeStubs;
                      9: extern int IdToSymCalls, StrCmpCalls;
                     10: 
                     11: class SSet {
                     12:        friend  SymTab; friend LookupCache;
                     13:        char    v[8];
                     14: public:
                     15:                SSet(char=0);
                     16:                SSet(char,char,char=0,char=0,char=0,char=0,char=0);
                     17: };
                     18: 
                     19: class LookupCache {
                     20:        SSet    set;
                     21:        Symbol  *sym;
                     22:        long    loc;
                     23:        char    *id;
                     24: public:
                     25:                LookupCache() {}
                     26:        Symbol  *match(SSet, long);
                     27:        void    save(SSet, long, Symbol*);
                     28: };
                     29: 
                     30: class SymTab : public PadRcv {
                     31:        friend Ed8SymTab;
                     32:        friend BsdSymTab; friend BsdType;
                     33:        friend Core;
                     34: >pub
                     35:        char    pub_filler[3338];
                     36: >pri
                     37:        Pad     *_pad;
                     38:        int     fd;
                     39:        char    *strings;
                     40:        long    strsize;
                     41:        long    entries;
                     42:        long    _magic;
                     43:        long    relocation;
                     44: #define HASH           101 /* prime */
                     45:        Symbol  *hashtable[TOSYM+1][HASH];
                     46:        Core    *_core;
                     47:        char    *stabpath();
                     48:        Source  *_root;
                     49:        Block   *fakeblk();
                     50:        char    *dump();
                     51:        Block   *_blk;
                     52:        char    *_warn;
                     53:        Index   castix[UNDEF];  // only [STRTY] [ENUMTY] used
                     54:        UType   *utype;
                     55:        SymTab  *inherit;
                     56:        Var     *globregs(Block*, int);
                     57:        void    uncfront(Var *, char*);
                     58:        void    showutype(UType*);
                     59:        LookupCache
                     60:                loctosymcache;
                     61: >
                     62: virtual        char    *gethdr()               { return "SymTab.gethdr"; }
                     63: virtual        Source  *tree()                 { return 0; }
                     64: PUBLIC(SymTab,U_SYMTAB)
                     65:                SymTab(Core*,int,SymTab* =0,long=0);
                     66: virtual                ~SymTab();
                     67:        void    read();
                     68:        void    enter(Symbol*);
                     69:        Symbol  *idtosym(SSet,char*,int=1);
                     70:        Symbol  *loctosym(SSet,long,int=1);
                     71:        Pad     *pad();
                     72:        Core    *core();
                     73:        char    *symaddr(long);
                     74:        Source  *root();
                     75:        long    modtime();
                     76:        Block   *blk();
                     77:        char    *warn();
                     78:        Index   utypecarte(short);
                     79:        long    magic();
                     80:        UType   *utypelist();
                     81:        void    banner();
                     82: virtual        Block   *gatherfunc(Func*);
                     83: virtual        Var     *gatherutype(UType*);
                     84:        void    opentypes();
                     85: };
                     86: >pri
                     87: struct nlist; struct exec; struct mlist;
                     88: 
                     89: #ifdef V9
                     90: class Ed8SymTab : public SymTab {
                     91:        exec    *hdr;
                     92:        nlist   *base;
                     93:        nlist   *symoff;
                     94:        DType   gatherdtype(nlist *);
                     95:        DType   chain(int, nlist *);
                     96:        void    gathervar(nlist*, Var**, Block*, UDisc);
                     97:        int     isastring(char*);
                     98:        char    *gettbl();
                     99:        nlist   *nlistvector(long,long);
                    100:        Source  *tree();
                    101:        char    *gethdr();
                    102: public:
                    103:                Ed8SymTab(Core*,int,SymTab* =0);
                    104:                ~Ed8SymTab();
                    105:        Block   *gatherfunc(Func*);
                    106:        Var     *gatherutype(UType*);
                    107: };
                    108: #else
                    109: class BsdSymTab : public SymTab {
                    110:        exec    *hdr;
                    111:        nlist   *base;
                    112:        nlist   *symoff;
                    113:        DType   gatherdtype(nlist *);
                    114:        DType   chain(int, nlist *);
                    115:        void    gathervar(nlist*, Var**, Block*, UDisc);
                    116:        void    gathervar(nlist*, Var**, Block*, UDisc, class BsdType *);
                    117:        int     isastring(char*);
                    118:        char    *gettbl();
                    119:        nlist   *nlistvector(long,long);
                    120:        Source  *tree();
                    121:        char    *gethdr();
                    122:        BsdTShare *bsdshare;
                    123: public:
                    124:                BsdSymTab(Core*,int,SymTab* =0,long=0);
                    125:                ~BsdSymTab();
                    126:        Block   *gatherfunc(Func*);
                    127:        Var     *gatherutype(UType*);
                    128:        int     endtext();
                    129: };
                    130: #endif V9
                    131: >
                    132: char *DiscName(UDisc);
                    133: #endif

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