Return to core.c CVS log

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

Annotation of researchv9/jtools/src/pi/core.c, revision 1.1

1.1     ! root        1: #include "process.pub"
        !             2: #include "frame.pri"
        !             3: #include "symtab.pri"
        !             4: #include "symbol.h"
        !             5: #include "core.pri"
        !             6: #include "master.pub"
        !             7: SRCFILE("core.c")
        !             8: 
        !             9: void Cslfd::init(long l, double d) { flterr=0; flt=dbl=d; chr=sht=lng=l; }
        !            10: Cslfd::Cslfd(long l)             { init(l, 0.0); }     
        !            11: Cslfd::Cslfd(double d)           { init(0,   d); }
        !            12: Cslfd::Cslfd(int i)              { init(i, 0.0); }
        !            13: Cslfd::Cslfd()                   { init(0, 0.0); }
        !            14: char *Cslfd::floaterror()        { return flterr; }
        !            15: 
        !            16: Core::Core(Process *p, Master *m)
        !            17: {
        !            18:        _process = p;
        !            19:        _symtab = (m && m->core) ? m->core->_symtab : 0;
        !            20:        corefd = stabfd = -1;
        !            21:        _online = 0;
        !            22:        behavs_problem = "?";
        !            23: }
        !            24: 
        !            25: char *Core::docall(long,int)           { return "docall";              }
        !            26: long Core::apforcall(int)              { return 0;                     }
        !            27: long Core::returnregloc()              { return 0;                     }
        !            28: int Core::corefstat()                  { return fstat(corefd,&corestat); }
        !            29: int Core::stabfstat()                  { return fstat(stabfd,&stabstat); }
        !            30: Asm *Core::newAsm()                    { return 0;                     }
        !            31: Behavs Core::behavs()                  { return 0;                     }
        !            32: Cslfd *Core::peekcode(long l)          { return peek(l);               }
        !            33: CallStk *Core::callstack()             { return 0;                     }
        !            34: Frame Core::frameabove(long)           { Frame f; return f;            }
        !            35: Process *Core::process()               { return _process;              }
        !            36: SymTab *Core::symtab()                 { return _symtab;               }
        !            37: char *Core::special(char*,long)                { return "special";             }
        !            38: char *Core::destroy()                  { return "destroy";             }
        !            39: char *Core::eventname()                        { return "eventname";           }
        !            40: char *Core::laybpt(Trap*)              { return "laybpt";              }
        !            41: char *Core::liftbpt(Trap*)             { return "liftbpt";             }
        !            42: char *Core::open()                     { return "open";                }
        !            43: char *Core::peekstring(long,char*)     { return "peekstring";          }
        !            44: char *Core::poke(long,long,int)                { return "poke long";           }
        !            45: char *Core::pokedbl(long,double,int)   { return "poke double";         }
        !            46: char *Core::procpath()                 { return _process->procpath;    }
        !            47: char *Core::read(long,char*,int)       { return "read";                }
        !            48: char *Core::readcontrol()              { return "readcontrol";         }
        !            49: char *Core::regname(int)               { return "regname";             }
        !            50: char *Core::regpoke(int r,long l)      { return poke(regloc(r), l, 4); }
        !            51: char *Core::reopen(char*,char*)                { return "reopen";              }
        !            52: char *Core::resources()                        { return "resources";           }
        !            53: char *Core::run()                      { return "run";                 }
        !            54: char *Core::stabpath()                 { return _process->stabpath;    }
        !            55: char *Core::popcallstack()             { return "popcallstack";        }
        !            56: char *Core::step(long,long)            { return "step";                }
        !            57: char *Core::stepprolog()               { return 0;                     }
        !            58: char *Core::stop()                     { return "stop";                }
        !            59: char *Core::write(long,char*,int)      { return "write";               }
        !            60: int Core::REG_AP()                     { return 0;                     }
        !            61: int Core::REG_FP()                     { return 0;                     }
        !            62: int Core::REG_PC()                     { return 0;                     }
        !            63: int Core::REG_SP()                     { return 0;                     }
        !            64: char *Core::specialop(char*)           { return 0;                     }
        !            65: int Core::event()                      { return 0;                     }
        !            66: int Core::online()                     { return _online;               }
        !            67: long Core::ap()                                { return regpeek(REG_AP());     }
        !            68: long Core::fp()                                { return regpeek(REG_FP());     }
        !            69: long Core::pc()                                { return regpeek(REG_PC());     }
        !            70: long Core::regloc(int,int)             { return 0;                     }
        !            71: long Core::regpeek(int r)              { return peek(regloc(r))->lng;  }
        !            72: long Core::saved(Frame*,int,int)       { return 0;                     }
        !            73: long Core::sp()                                { return regpeek(REG_SP());     }
        !            74: int Core::nregs()                      { return 0;                     }
        !            75: 
        !            76: char *Core::problem()
        !            77: {
        !            78:        return sf("unanticipated problem: %s; mail tac", behavs_problem);
        !            79: }
        !            80: 
        !            81: Cslfd *Core::peek(long loc, Cslfd *fail)
        !            82: {
        !            83:        static Cslfd *c;
        !            84:        trace( "%d.peek(%d,%d)", this, loc, fail );
        !            85:        if( fail != PEEKFAIL ) return fail;
        !            86:        return c ? c : (c = new Cslfd);
        !            87: }
        !            88: 
        !            89: char *BehavsName(Behavs b)
        !            90: {
        !            91:        switch(b){
        !            92:        case BREAKED:           return "BREAKPOINT:";
        !            93:        case ERRORED:           return "ERROR STATE:";
        !            94:        case HALTED:            return "STOPPED:";
        !            95:        case ACTIVE:            return "RUNNING:";
        !            96:        case PENDING:           return "EVENT PENDING:";
        !            97:        case INST_STEPPED:      return "INSTR STEPPED:";
        !            98:        case STMT_STEPPED:      return "STMT STEPPED:";
        !            99:        }
        !           100:        return Name( "Behavs=%d", b);
        !           101: }
        !           102: 
        !           103: void Core::close()
        !           104: {
        !           105:        trace( "%d.close()", this );    VOK;
        !           106:        if( corefd>=0 ) ::close(corefd);
        !           107:        if( stabfd>=0 ) ::close(stabfd);
        !           108:        if( _symtab ) delete _symtab;
        !           109: }
        !           110: 
        !           111: char *Core::blockmove(long s, long d, long ct)
        !           112: {
        !           113:        trace( "%d.blockmove(0x%X,0x%X,%d)", this, s, d, ct); OK("Core::blockmove");
        !           114:        char *buf = new char[ct];
        !           115:        char *error = read(s, buf, ct);
        !           116:        if( !error ) error = write(d, buf, ct);
        !           117:        delete buf;
        !           118:        return error;
        !           119: }
        !           120: 
        !           121: void Context::restore()
        !           122: {
        !           123:        trace( "%d.restore()", this );  VOK;
        !           124:        error = "context restore error";
        !           125: }
        !           126: 
        !           127: Context *Core::newContext()
        !           128: {
        !           129:        return new Context;
        !           130: }
        !           131: 
        !           132: void Core::slavedriver(Core *sd)
        !           133: {
        !           134:        trace("%d.slavedriver()"); VOK;
        !           135:        sd->_symtab->inherit = _symtab;
        !           136: }

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