Return to symbol.h CVS log

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

Annotation of researchv9/jtools/src/pi/symbol.h, revision 1.1

1.1     ! root        1: #ifndef SYMBOL_H
        !             2: #define SYMBOL_H
        !             3: #ifndef UNIV_H
        !             4: #include "univ.h"
        !             5: #endif
        !             6: 
        !             7: #include "dtype.pub"
        !             8: 
        !             9: class Stmt; class SrcText;
        !            10: 
        !            11: struct Range {
        !            12:        long    lo;
        !            13:        long    hi;
        !            14: };
        !            15: 
        !            16: class Symbol : public PadRcv {                         // Symbol
        !            17:        friend  SymTab;
        !            18:        friend  Ed8SymTab;
        !            19:        friend  BsdSymTab;
        !            20:        Symbol  *hashlink;
        !            21: public:
        !            22:        int     disc();
        !            23:        int     ok();
        !            24:                Symbol(Symbol*,Symbol*,char*);
        !            25:        Symbol  *parent;
        !            26:        Symbol  *child;
        !            27:        Symbol  *rsib;
        !            28:        Symbol  *lsib;
        !            29:        char    *_text;
        !            30: virtual        char    *text(long=0);
        !            31:        Range   range;
        !            32:        char    *dump();
        !            33:        Source  *source();
        !            34: };
        !            35: 
        !            36: const LEAVE = 0, SHOW = 1, HIDE = 2;
        !            37: 
        !            38: class Var : public Symbol {                            // Var
        !            39:        friend  Expr;
        !            40:        friend  UType;
        !            41:        short   _disc;
        !            42:        short   showorhide;
        !            43:        Index   carte();
        !            44:        void    reformat(long);
        !            45:        char    *fmtlist();
        !            46:        void    showutype(UType*);
        !            47: public:
        !            48:                Var(class SymTab*,class Block*,Var*,UDisc,char*);
        !            49:                ~Var();
        !            50:        int     disc();
        !            51:        int     ok();
        !            52:        DType   type;
        !            53:        void    show(int=LEAVE, Attrib=0);
        !            54: };
        !            55: 
        !            56: class BlkVars : public PadRcv {                                        // BlkVars
        !            57: class  Block   *b;             // next block
        !            58:        Var     *v;             // prev variable
        !            59: PUBLIC(BlockVars,U_BLKVARS)
        !            60:        Var     *gen();
        !            61:                BlkVars(Block*i);
        !            62: };
        !            63: 
        !            64: class Block : public Symbol {                          // Block
        !            65:        friend  BlkVars;
        !            66:        friend  SymTab;
        !            67:        friend  Ed8SymTab;
        !            68:        friend  BsdSymTab;
        !            69:        Var     *var;
        !            70: PUBLIC(Block,U_BLOCK)
        !            71:                Block(SymTab*,Symbol*,Block*,char*);
        !            72:                ~Block();
        !            73: class  Stmt    *stmt;
        !            74: };     
        !            75: 
        !            76: class Source : public Symbol {                         // Source
        !            77:        friend  Ed8SymTab;
        !            78:        friend  BsdSymTab;
        !            79:        Func    *linefunc;
        !            80:        Stmt    *linestmt;
        !            81: PUBLIC(Source,U_SOURCE)
        !            82:                Source(SymTab*,Source*,char*,long);
        !            83:                ~Source();
        !            84:        SrcText *srctext;
        !            85:        SymTab  *symtab;
        !            86:        Block   *blk;
        !            87:        Stmt    *stmtafter(int);
        !            88:        char    *text(long=0);
        !            89: #ifndef V9
        !            90:        class   BsdType *bsdp;
        !            91: #endif
        !            92: };
        !            93:        
        !            94: class Func : public Symbol {                           // Func
        !            95:        friend  Ed8SymTab;
        !            96:        friend  BsdSymTab;
        !            97:        long    begin;
        !            98:        long    size;
        !            99:        long    lnnoptr;                                // coff
        !           100:        long    regsave;                                // mac32 - goes away
        !           101:        Block   *_blk;
        !           102:        void    gather();
        !           103: PUBLIC(Func,U_FUNC)
        !           104:                Func(SymTab*,Source*,Func*,long,char*);
        !           105:                ~Func();
        !           106:        Block   *blk();
        !           107:        Block   *blk(long);
        !           108:        DType   type;
        !           109:        Range   lines;
        !           110:        Stmt    *stmt(long);    
        !           111:        char    *text(long=0);
        !           112:        Var     *argument(int);
        !           113:        int     regused(int);
        !           114: };
        !           115: 
        !           116: #define Q_BPT   ((Expr*)1)     
        !           117: class Stmt : public Symbol {                           // Stmt
        !           118:        friend  Ed8SymTab;
        !           119:        friend  BsdSymTab;
        !           120:        friend  Instr;
        !           121: class  Process *process;
        !           122: class  Pad     *srcpad();
        !           123:        void    error(char*);
        !           124:        char    *contextsearch(char*,int);
        !           125: PUBLIC(Stmt,U_STMT)
        !           126:                Stmt(SymTab*,Block*,Stmt*);
        !           127:                ~Stmt();
        !           128:        void    asmblr();
        !           129:        void    select(long=0);
        !           130:        char    *text(long=0);
        !           131:        short   lineno;
        !           132:        short   hits;
        !           133: class  Expr    *condition;
        !           134:        Bls     *condtext;
        !           135:        void    dobpt(int);
        !           136:        void    settrace();
        !           137:        void    openframe();
        !           138:        char    *kbd(char*);
        !           139:        char    *help();
        !           140:        void    conditional(Expr*);
        !           141:        char    *srcline();
        !           142:        Func    *func();
        !           143:        char    *journal(Bls&);
        !           144: };
        !           145: 
        !           146: class UType : public Symbol {                          // UType
        !           147:        friend  Ed8SymTab;
        !           148:        friend  BsdSymTab; friend BsdType;
        !           149:        friend  TypMems;
        !           150:        friend  Var;            // for symtab
        !           151:        SymTab  *symtab;
        !           152:        long    begin;
        !           153:        short   size;
        !           154:        char    *canspecial;
        !           155:        Var     *mem;
        !           156: #ifndef V9
        !           157:        BsdType *bsdp;
        !           158:        char    *encode;
        !           159: #endif
        !           160:        void    gather();
        !           161:        void    display();
        !           162: PUBLIC(UType,U_UTYPE)
        !           163:                UType(SymTab*,long,long,char*);
        !           164: #ifndef V9
        !           165:                UType(SymTab*,char*,char*, BsdType*);
        !           166: #endif
        !           167:                ~UType();
        !           168:        DType   type;
        !           169:        Index   carte(enum Op);
        !           170:        void    show(int=LEAVE, Attrib=0);
        !           171: };
        !           172: 
        !           173: class TypMems : public PadRcv {                                // TypMems
        !           174:        char    pub_filler[8];
        !           175:        UType   *ut;
        !           176:        Var     *v;                     // prev
        !           177: PUBLIC(TypMems,U_TYPMEMS)
        !           178:                TypMems(UType *);
        !           179:        Var     *gen();
        !           180: };
        !           181: 
        !           182: #endif

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