Return to kernproc.c CVS log

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

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

1.1     ! root        1: #include "univ.h"
        !             2: #include "process.pri"
        !             3: #include "hostcore.h"
        !             4: #include "master.pub"
        !             5: #include "frame.pri"
        !             6: #include "memory.pub"
        !             7: #include "symtab.pub"
        !             8: #include "symbol.h"
        !             9: #include "srcdir.h"
        !            10: #include "asm.pub"
        !            11: #include "parse.h"
        !            12: #include "expr.pub"
        !            13: SRCFILE("kernproc.c")
        !            14: 
        !            15: char *KernProcess::kbd(char *s)
        !            16: {
        !            17:        Parse y(G_EXPR,0);
        !            18:        Expr *e;
        !            19:        Bls error;
        !            20: 
        !            21:        trace( "%d.kbd(%s)", this, s ); OK(0);
        !            22:        if( !(e = (Expr*)y.parse(s)) )
        !            23:                return sf("%s: %s", y.error, s);
        !            24:        e->evaltext(globals, error);
        !            25:        if( e->evalerr )
        !            26:                return sf("%s: %s", s, error.text);
        !            27:        ((KernCore*)core)->cs_fp = e->val.lng;
        !            28:        habeascorpus(PENDING,0);
        !            29:        return 0;
        !            30: }
        !            31: 
        !            32: char *KernProcess::help()
        !            33: {
        !            34:        return "<expr> {start fp for callstack}";
        !            35: }
        !            36: 
        !            37: void KernProcess::open()
        !            38: {
        !            39:        Menu m;
        !            40:        char *error;
        !            41: 
        !            42:        trace("%d.open(%d)", this);     VOK;
        !            43:        Process::openpad();
        !            44:        if( core ) return;
        !            45:        insert(ERRORKEY, "Checking dump and symbol table...");
        !            46:        core = (Core*) new KernCore(this, master);
        !            47:        if( error = core->open() ){
        !            48:                delete core;
        !            49:                core = 0;
        !            50:                m.last("open system dump", (Action)&KernProcess::open, 0);
        !            51:                pad->menu( m );
        !            52:                insert(ERRORKEY, error);
        !            53:                return;
        !            54:        }
        !            55:        insert(ERRORKEY, core->symtab()->warn());
        !            56:        globals = new Globals(core);
        !            57:        _asm = core->newAsm();
        !            58:        m.last( "src text",  (Action)&KernProcess::srcfiles );  /* should check */
        !            59:        m.last( "Globals",   (Action)&KernProcess::openglobals );
        !            60:        m.last( "RawMemory", (Action)&KernProcess::openmemory  );
        !            61:        m.last( "Assembler", (Action)&KernProcess::openasm     );
        !            62:        m.last( "User Types",(Action)&KernProcess::opentypes   );
        !            63:        pad->menu(m);
        !            64:        pad->makecurrent();
        !            65:        docycle();
        !            66: }
        !            67: 
        !            68: Index KernProcess::carte()
        !            69: {
        !            70:        Menu m;
        !            71:        trace( "%d.carte(%d)", this ); OK(ZIndex);
        !            72:        m.last( "open system dump",  (Action)&KernProcess::open, 0 );
        !            73:        return m.index();
        !            74: }
        !            75: 
        !            76: void KernProcess::userclose()
        !            77: {
        !            78:        trace( "%d.userclose()", this );        VOK;
        !            79:        Process::userclose();
        !            80: }

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