Return to process.h CVS log

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

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

1.1       root        1: #ifndef PROCESS_H
                      2: #define PROCESS_H
                      3: #ifndef UNIV_H
                      4: #include "univ.h"
                      5: #endif
                      6: #include "format.h"
                      7: 
                      8: class Process : public PadRcv {
                      9:        friend HostMaster; friend Master;       
                     10:        friend HostProcess; friend SigMask; friend SrcDir;
                     11:        friend KernProcess; friend KernMaster;
                     12:        friend KernCore; friend BatchProcess;
                     13:        friend RtRawProcess; friend RtRawMaster;
                     14:        friend RtNrtxProcess; friend RtNrtxMaster; friend RtNrtxSigMask;
                     15: 
                     16:        int     isdead;
                     17:        Asm     *_asm;
                     18:        Bpts    *_bpts;
                     19:        Core    *core;
                     20:        CallStk *callstk;
                     21:        Memory  *memory;
                     22:        Journal *_journal;
                     23:        Pad     *pad;
                     24:        Process *sibling;
                     25:        Master  *master;
                     26:        Process *parent;
                     27:        SrcDir  *srcdir;
                     28:        char    *_prefix;
                     29:        Behavs  prev_behavs;
                     30:        char    stoprequest;
                     31:        char    cycles;
                     32:        Process *_slave;
                     33: >pub
                     34:        char    pub_filler[256*3+4];
                     35: >pri
                     36: #define BEHAVSKEY 1
                     37: #define ERRORKEY 2
                     38:        int     padlines;
                     39:        Bls     bls[3];                 /* error [1] behavs [2] */
                     40:        void    openbpts();
                     41:        void    opentypes();
                     42:        void    mergeback(long);
                     43:        void    srcfiles();
                     44:        void    habeascorpus(Behavs,long);
                     45:        void    banner();
                     46:        int     changes();
                     47:        void    docycle();
                     48:        void    insert(long,PRINTF_TYPES);
                     49:        void    closeframes();
                     50:        void    merge();
                     51:        char    *bptreq(BptReq*);
                     52:        void    slavedriver(Process*);
                     53: >
                     54:        void    cycle();
                     55: virtual        Index   carte();
                     56:        void    linereq(long,Attrib=0);
                     57: PUBLIC(Process,U_PROCESS)
                     58:        Globals *globals;
                     59:                Process(Process* =0, char* =0, char* =0, char* =0);
                     60:        char    *procpath;
                     61:        char    *stabpath;
                     62:        char    *comment;
                     63:        char    *prefix(char*);
                     64:        void    openglobals(Menu* =0);
                     65:        void    openmemory(long=0);
                     66:        void    openasm(long=0);
                     67:        void    openjournal();
                     68:        Journal *journal();
                     69:        Frame   *frame(long);
                     70:        SymTab  *symtab();
                     71:        Bpts    *bpts();
                     72:        Process *slave();
                     73:        void    go();
                     74:        void    pop();
                     75:        void    stmtstep(long);
                     76:        void    stepinto();
                     77:        void    instrstep(long);
                     78:        void    stepover(long,long);
                     79:        void    openframe(long,char* =0);
                     80:        void    openpad();
                     81:        void    currentstmt();
                     82: 
                     83:        char    *help();
                     84:        char    *kbd(char*);
                     85: virtual        void    userclose();
                     86: virtual        void    stop();
                     87: };
                     88: >pri
                     89: class HostProcess : public Process { friend HostCore;
                     90:        Index   carte();
                     91:        SigMask *sigmsk;
                     92:        void    opensigmask();
                     93:        void    hang();
                     94:        void    hangopen();
                     95:        void    hangtakeover();
                     96:        void    userclose();
                     97:        void    reopendump();
                     98:        void    substitute(HostProcess*);
                     99:        void    takeover();
                    100:        int     accept(Action);
                    101:        void    imprint();
                    102:        void    destroy();
                    103: #ifndef V9
                    104:        void    takeoverstopped();
                    105:        int     openstopped(long ischild=0);
                    106: #endif
                    107:        HostCore
                    108:                *hostcore()             { return (HostCore*) core; }
                    109: public:
                    110:                HostProcess(Process*sib=0, char*p=0, char*s =0, char*c=0)
                    111:                        :(sib,p,s,c) {}
                    112:        void    open(long ischild=0);
                    113:        void    stop();
                    114: };
                    115: 
                    116: class BatchProcess : public HostProcess {
                    117: public:
                    118:                BatchProcess(char*p, char*s):(0,p,s,0) {}
                    119:        void    open();
                    120: };
                    121: 
                    122: class KernProcess : public Process { friend KernCore;
                    123:        Index   carte();
                    124:        void    userclose();
                    125:        KernCore
                    126:                *kerncore()             { return (KernCore*) core; }
                    127:        char    *kbd(char*);
                    128:        char    *help();
                    129: public:
                    130:                KernProcess(Process*sib=0, char*p=0, char*s =0, char*c=0)
                    131:                        :(sib,p,s,c) {}
                    132:        void    open();
                    133: };
                    134: >
                    135: #endif

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