![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to process.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jtools / src / pi|
Return to process.c CVS log | Up to [Research Unix] / researchv9 / jtools / src / pi |
1.1 root 1: #include "frame.pri"
2: #include "hostcore.h"
3: #include "process.pri"
4: #include "srcdir.h"
5: #include "expr.pub"
6: #include "master.pub"
7: #include "bpts.pri"
8: #include "memory.pub"
9: #include "asm.pub"
10: #include "symtab.pub"
11: #include "symbol.h"
12: #include "srctext.pub"
13: #include "format.pub"
14: #include "journal.pub"
15: SRCFILE("process.c")
16:
17: void Process::pop()
18: {
19: trace("%d.pop()", this); VOK;
20: journal()->insert("pop");
21: char *error = 0;
22: if( core->behavs() == ACTIVE ){
23: stop();
24: sleep(1);
25: }
26: if( !error ) error = core->popcallstack();
27: if( error ) insert(ERRORKEY, error);
28: habeascorpus(STMT_STEPPED, changes());
29: }
30:
31: char *Process::kbd(char *s)
32: {
33: trace("%d.kbd(%s)", this, s); OK("Process::kbd");
34: journal()->insert("kbd: %s", s);
35: char p[256], c[256], e[256];
36: long l;
37: if( 3 == sscanf(s, "bpt %[^:]:%d %s", p, &l, e) ){
38: BptReq r(p, l, e);
39: return r.set(this);
40: }
41: if( 2 == sscanf(s, " bpt %[^:]:%d", p, &l, e) ){
42: BptReq r(p, l);
43: return r.set(this);
44: }
45: if( 3 == sscanf(s, "bpt %[^{}]%[{}] %s", p, c, e) ){
46: BptReq r(p, c, e);
47: return r.set(this);
48: }
49: if( 2 == sscanf(s, "bpt %[^{}]%[{}]", p, c) ){
50: BptReq r(p, c);
51: return r.set(this);
52: }
53: return help();
54: }
55:
56: char *Process::help()
57: {
58: return "<ugly-keyboard-language> { cat /usr/jerq/lib/pi.help }";
59: }
60:
61: Process::Process(Process *sib, char *p, char *s, char *c)
62: {
63: trace( "%d.Process(%d,%s,%s,%s)",this,sib,p,s,c); VOK;
64: sibling = sib;
65: procpath = p ? sf("%s",p) : 0;
66: stabpath = s ? sf("%s",s) : 0;
67: comment = c ? sf("%s",c) : 0;
68: stoprequest = 0;
69: cycles = 0;
70: _prefix = 0;
71: srcdir = 0;
72: parent = 0;
73: isdead = 0;
74: padlines = 0;
75: }
76:
77: void Process::currentstmt()
78: {
79: trace( "%d.currentstmt()", this ); VOK;
80:
81: if( !callstk ){
82: insert(ERRORKEY, "cannot show source (there is no callstack yet)");
83: return;
84: }
85: for( long l = 0; l < callstk->size; ++l ){
86: Frame *f = frame(l);
87: if( !f->func ) continue;
88: Stmt *stmt = f->func->stmt(f->pc);
89: /* Stmt *stmt = (Stmt*) core->symtab()->loctosym(U_STMT, f->pc); */
90: if( stmt ){
91: stmt->select();
92: return;
93: }
94: }
95: insert(ERRORKEY, "cannot show source for any frame on callstack");
96: pad->makecurrent();
97: }
98:
99: Index Process::carte() { return ZIndex; }
100:
101: void Process::closeframes()
102: {
103: trace( "%d.closeframes()", this ); VOK;
104: if( callstk ) {
105: for( long l = callstk->size-1; l>=0; --l ){
106: if( callstk->fpf[l].frame ){
107: callstk->fpf[l].frame->hostclose();
108: delete callstk->fpf[l].frame;
109: callstk->fpf[l].frame = 0;
110: }
111: }
112: delete callstk;
113: callstk = 0;
114: }
115: }
116:
117: void Process::userclose()
118: {
119: trace( "%d.userclose()", this ); VOK;
120: if( _journal ){
121: _journal->hostclose();
122: delete _journal;
123: _journal = 0;
124: }
125: if( _bpts ){
126: _bpts->hostclose();
127: delete _bpts;
128: _bpts = 0;
129: }
130: if( srcdir ){
131: srcdir->hostclose();
132: delete srcdir;
133: srcdir = 0;
134: }
135: if( memory ){
136: memory->userclose();
137: delete memory;
138: memory = 0;
139: }
140: if( _asm ){
141: _asm->userclose();
142: delete _asm;
143: _asm = 0;
144: }
145: closeframes();
146: if( core ){
147: core->close();
148: delete core;
149: core = 0;
150: }
151: if( globals ){
152: globals->hostclose();
153: delete globals;
154: globals = 0;
155: }
156: if( pad ){
157: delete pad;
158: pad = 0;
159: }
160: isdead = 1;
161: master->insert(this);
162: master->makeproc(procpath, stabpath, comment);
163: }
164:
165: Bpts *Process::bpts() { return _bpts; }
166:
167: SymTab *Process::symtab() { return core->symtab(); }
168:
169: void Process::banner()
170: {
171: trace( "%d.banner()", this ); VOK;
172: if( pad ){
173: pad->name(procpath); /* basename ? */
174: pad->banner("Process: %s", procpath);
175: }
176: }
177:
178: void Process::openpad()
179: {
180: trace("%d.openpad(%d)", this); VOK;
181: if( !pad ){
182: pad = new Pad( (PadRcv*) this );
183: pad->options(TRUNCATE|NO_TILDE);
184: banner();
185: pad->lines(padlines = ERRORKEY);
186: pad->clear(); /* from a previous attempt! */
187: pad->makecurrent();
188: }
189: pad->makecurrent();
190: }
191:
192: void Process::openglobals(Menu *m)
193: {
194: trace("%d.openglobals()", this); VOK;
195: if( !globals ) globals = new Globals(core);
196: globals->open();
197: if( m) globals->addvars(m);
198: }
199:
200: void Process::opentypes()
201: {
202: trace("%d.opentypes()", this); VOK;
203: core->symtab()->opentypes();
204: }
205:
206: void Process::srcfiles()
207: {
208: trace( "%d.srcfiles()", this ); VOK;
209: if( !srcdir ) srcdir = new SrcDir( this );
210: srcdir->open();
211: }
212:
213: void Process::merge()
214: {
215: trace( "%d.merge()",this,); VOK;
216: CallStk *old = callstk;
217: callstk = core->callstack();
218: if( !callstk ){
219: if (old) {
220: callstk = old;
221: closeframes();
222: }
223: insert(ERRORKEY, "cannot obtain callstack");
224: return;
225: }
226: if( !old ) return;
227: long c = callstk->size-1, i;
228: for( long o = old->size-1; o>=0; --o ){
229: Frame *of;
230: if( of = old->fpf[o].frame ){
231: for( i = c; i>=0; --i )
232: if( callstk->fpf[i].func == old->fpf[o].func )
233: break;
234: if( i >= 0 ){
235: Frame nf = callstk->frame(i);
236: of->ap = nf.ap;
237: of->fp = nf.fp;
238: of->pc = nf.pc;
239: of->regbase = nf.regbase;
240: of->regsave = nf.regsave;
241: if( of->pad ){
242: of->banner();
243: of->changes();
244: }
245: callstk->fpf[i].frame = of;
246: of->level = i;
247: c = i-1;
248: } else {
249: of->hostclose();
250: delete of;
251: }
252: }
253: }
254: delete old;
255: }
256:
257: void Process::mergeback(long) /* arg never used - should go away */
258: {
259: trace( "%d.mergeback()", this ); VOK;
260:
261: if( core->behavs() == ACTIVE ){
262: stop();
263: if( core->behavs() == ACTIVE ){
264: insert(ERRORKEY, "process not stopped");
265: return;
266: }
267: }
268: merge();
269: pad->lines(padlines = ERRORKEY);
270: if( callstk ) pad->lines(padlines = callstk->size+ERRORKEY);
271: linereq(BEHAVSKEY); // it gets linereq'd?
272: }
273:
274: Frame *Process::frame(long l)
275: {
276: trace("%d.frame(%d)", this, l); OK(0);
277: if( !callstk || l < 0 || l >= callstk->size ) return 0;
278: Frame *f = callstk->fpf[l].frame;
279: if( f ) return f;
280: f = callstk->fpf[l].frame = new Frame(core); // gets its own oid
281: PadRcv save = *(PadRcv*)f; // save PadRcv part
282: *f = callstk->frame(l);
283: *(PadRcv*)f = save; // restore PadRcv part
284: f->func = callstk->fpf[l].func;
285: f->level = l;
286: return f;
287: }
288:
289: void Process::linereq(long l, Attrib a)
290: {
291: trace("%d.linereq(%d,%x)", this, l, a); VOK;
292: if( l <= ERRORKEY ){
293: pad->insert(l, a, "%s", bls[l].text);
294: journal()->insert("%s", bls[l].text);
295: return;
296: }
297: if( padlines && l>padlines ) return; // too late
298: Frame *f = frame(l-ERRORKEY-1);
299: Bls t;
300: pad->insert(l, a|DONT_CUT, (PadRcv*)f, f->carte(), "%s", f->text(t));
301: if( l == ERRORKEY+1 )
302: journal()->insert("%s", t.text);
303: }
304:
305: void Process::insert(long l, PRINTF_ARGS)
306: {
307: trace("%d.insert(%d)", this, l); VOK;
308: if( l == ERRORKEY ){ // ERROR doesn't change much
309: Bls cmp;
310: cmp.af(PRINTF_COPY);
311: if( !strcmp(cmp.text, bls[ERRORKEY].text) )
312: return;
313: }
314: if( l > ERRORKEY ) return;
315: bls[l].clear();
316: bls[l].af(PRINTF_COPY);
317: pad->insert(l, DONT_CUT, "%s", bls[l].text);
318: }
319:
320: void Process::openframe(long pc, char *k)
321: {
322: trace( "%d.openframe(%d)", this, pc ); VOK;
323:
324: Func *func = (Func*) symtab()->loctosym(U_FUNC, pc);
325: if( !func ){
326: pad->insert(ERRORKEY, "cannot find function");
327: return;
328: }
329: if( !callstk ){
330: pad->insert(ERRORKEY, "there is no callstack yet");
331: return;
332: }
333: long l;
334: Frame *f = 0;
335: for( l = 0; l < callstk->size; ++l )
336: if( callstk->fpf[l].func == func ){
337: f = frame(l);
338: f->open();
339: break;
340: }
341: if( !f ){
342: mergeback(2);
343: insert(ERRORKEY, "%s is not on callstack", func->text());
344: pad->makecurrent();
345: return;
346: }
347: for( ++l; l < callstk->size; ++l )
348: if( callstk->fpf[l].func == func ){
349: f->pad->insert(1, "called recursively - deepest instance");
350: break;
351: }
352: if( f && k ) f->kbd(k);
353: }
354:
355: void Process::openmemory(long a)
356: {
357: trace( "%d.openmemory(%d)", this, a ); VOK;
358: if( !memory ) memory = new Memory(core);
359: memory->open(a);
360: }
361:
362: void Process::openasm(long a)
363: {
364: trace("%d.openasm()", this); VOK;
365: if( !_asm ) _asm = core->newAsm();
366: if( a!= -1 ) _asm->open(a);
367: }
368:
369: void Process::openjournal()
370: {
371: trace("%d.openjournal()", this); VOK;
372: if( !_journal)
373: _journal = new Journal(basename(core->procpath()));
374: journal()->open();
375: }
376:
377: Journal *Process::journal()
378: {
379: trace("%d.journal()", this); OK(0);
380: return _journal;
381: }
382:
383: void Process::openbpts()
384: {
385: trace( "%d.openbpts()", this ); VOK;
386: bpts()->pad->makecurrent();
387: }
388:
389: void Process::stop()
390: {
391: trace( "%d.stop()", this ); VOK;
392:
393: IF_LIVE( !core->online() ) return;
394: journal()->insert("stop");
395: insert(ERRORKEY, 0);
396: switch( core->behavs() ){
397: case ACTIVE:
398: insert(ERRORKEY, core->stop());
399: sleep(1);
400: cycle(); /* will ignore next cycle from term */
401: return;
402: default:
403: stoprequest = 1;
404: habeascorpus(core->behavs(),changes());
405: }
406: }
407:
408: void Process::stmtstep(long i)
409: {
410: char *error = 0;
411: class Stmt *stmt;
412: long changed = 0;
413:
414: trace("%d.stmtstep(%d)", this, i); VOK;
415: journal()->insert("step %d stmts", i);
416: insert(ERRORKEY, 0);
417: stoprequest = 0;
418: for( ; i>0 && !error && changed==0; --i ){
419: if( i>1 ) insert(BEHAVSKEY, "step %d statements", i);
420: if( !(stmt = (Stmt*) symtab()->loctosym(U_STMT, core->pc())) )
421: error = "cannot locate start stmt for step";
422: else
423: error = core->step(stmt->range.lo, stmt->range.hi);
424: if( !error ) changed = changes();
425: }
426: insert(ERRORKEY, error);
427: if( error ){
428: docycle();
429: return;
430: }
431: habeascorpus(STMT_STEPPED, changed);
432: }
433:
434: void Process::stepinto()
435: {
436: char *error = 0;
437: class Stmt *stmt;
438: long time(long*), t0 = time(0), timeout = 10, changed = 0;
439:
440: trace( "%d.stepinto()", this ); VOK;
441: journal()->insert("step into function");
442: insert(ERRORKEY, 0);
443: stoprequest = 0;
444: if( !(stmt = (Stmt*) symtab()->loctosym(U_STMT, core->pc())) )
445: error = "cannot locate start stmt for step into";
446: while( !error && changed==0 ){
447: if( core->pc() < stmt->range.lo ) break;
448: if( core->pc() >= stmt->range.hi ) break;
449: error = core->step();
450: if( !error && time(0) > t0+timeout )
451: error = sf( "step into timeout (%d secs)", timeout );
452: if( !error )
453: changed = changes();
454: }
455: if( !error )
456: error = core->stepprolog();
457: insert(ERRORKEY, error);
458: if( error ){
459: docycle();
460: return;
461: }
462: habeascorpus(STMT_STEPPED, changed);
463: }
464:
465: void Process::instrstep(long i)
466: {
467: char *error = 0;
468: long changed = 0;
469:
470: trace("%d.instrstep(%d)", this, i); VOK;
471: journal()->insert("step %d instructions", i);
472: stoprequest = 0;
473: insert(ERRORKEY, 0);
474: while( i>0 && !error && changed==0 ){
475: insert(BEHAVSKEY, "step %d instructions", i--);
476: error = core->step();
477: if( !error ) changed = changes();
478: }
479: insert(ERRORKEY, error);
480: if( error ){
481: docycle();
482: return;
483: }
484: habeascorpus(INST_STEPPED,changed);
485: openasm( core->pc() );
486: }
487:
488: void Process::stepover(long lo, long hi)
489: {
490: trace( "%d.stepover()", this ); VOK;
491: journal()->insert("step over call");
492: stoprequest = 0;
493: char *error = core->step(lo, hi);
494: insert(ERRORKEY, error);
495: if( error ){
496: docycle();
497: return;
498: }
499: habeascorpus(INST_STEPPED, changes());
500: openasm(core->pc());
501: }
502:
503: void Process::go()
504: {
505: Behavs b = core->behavs();
506: char *error = 0;
507:
508: trace( "%d.go() %s", this, BehavsName(b) ); VOK;
509: journal()->insert("run");
510: stoprequest = 0;
511: switch( b ){
512: case ACTIVE:
513: case ERRORED:
514: habeascorpus(b,0);
515: break;
516: case BREAKED:
517: if( !error ) error = core->step();
518: case INST_STEPPED:
519: case STMT_STEPPED:
520: case PENDING:
521: case HALTED:
522: if( !error ) _bpts->lay();
523: if( !error ) error = core->run();
524: }
525: insert(ERRORKEY, error);
526: docycle();
527: }
528:
529: void Process::cycle()
530: {
531: trace( "%d.cycle() %d", this ); VOK;
532: if( cycles <= 0 ) return;
533: --cycles;
534: docycle();
535: }
536:
537: void Process::docycle()
538: {
539: Behavs b;
540:
541: trace( "%d.docycle() %d", this ); VOK;
542: b = core->behavs();
543: switch( b ){
544: case ACTIVE:
545: pad->alarm(1);
546: ++cycles;
547: break;
548: case HALTED:
549: case PENDING:
550: case BREAKED:
551: if (core->online()) _bpts->lift();
552: break;
553: default:
554: break;
555: }
556: habeascorpus(b, b!=ERRORED ? changes() : 0);
557: }
558:
559: void Process::habeascorpus(Behavs b, long c)
560: {
561: char *error;
562: Bls *t = &bls[BEHAVSKEY];
563: Frame *f;
564:
565: trace( "%d.habeascorpus(%d, c)", this, b, c ); VOK;
566: t->clear();
567: if( c > 0 ) t->af( "%d %s changed ", c, c==1 ? "spy" : "spies" );
568: t->af( "%s ", BehavsName(b) );
569: switch( b ){
570: case HALTED: break; // shut up cfront
571: case BREAKED: {
572: class Stmt *stmt = bpts()->bptstmt(core->pc());
573: if( !stmt || stoprequest ) break;
574: Expr *e = stmt->condition;
575: if( !e || e==Q_BPT ) break;
576: delete core->callstack(); // term needs refreshed
577: Frame cf = core->frameabove(0);
578: cf.addsymbols();
579: stmt->condtext->clear();
580: stmt->condtext->af("[%d] ", ++stmt->hits);
581: e->evaltext(&cf, *stmt->condtext);
582: Bls j;
583: journal()->insert("%s", stmt->journal(j));
584: if( e->val.lng || c>0 )
585: break;
586: if( !e->evalerr ){
587: pad->alarm();
588: ++cycles;
589: }
590: stmt->select();
591: if( e->evalerr ){
592: insert(ERRORKEY, "%s", stmt->condtext->text);
593: break;
594: }
595: error = core->step();
596: if( !error ) _bpts->lay();
597: if( !error ) error = core->run();
598: insert(ERRORKEY, error);
599: return;
600: }
601: case ERRORED:
602: t->af( core->problem() );
603: break;
604: case PENDING:
605: t->af(core->eventname());
606: break;
607: case ACTIVE:
608: t->af( "%s ", core->resources() ); // fall thru
609: case INST_STEPPED:
610: case STMT_STEPPED:
611: long pc = core->pc();
612: if( pc ){
613: if( *symtab()->symaddr(pc) )
614: t->af( "pc=%s", symtab()->symaddr(pc) );
615: else
616: t->af( "pc=%d", pc );
617: }
618: break;
619: }
620: switch( b ){
621: case ACTIVE:
622: pad->lines(padlines = ERRORKEY);
623: case ERRORED:
624: linereq(BEHAVSKEY);
625: break;
626: case HALTED:
627: case BREAKED:
628: case INST_STEPPED:
629: case STMT_STEPPED:
630: case PENDING:
631: mergeback(2);
632: if( globals ) globals->changes();
633: if( b!=INST_STEPPED && (f = frame(0)) )
634: f->select(b != STMT_STEPPED ? SVP : 0);
635: }
636: }
637:
638: int Process::changes()
639: {
640: int changed = 0;
641: Frame *f;
642:
643: trace( "%d.changes()", this ); OK(0);
644: if( callstk )
645: for( long l = 0; l < callstk->size; ++l )
646: if( f = callstk->fpf[l].frame )
647: changed += f->changes();
648: if( globals ) changed += globals->changes();
649: if( memory ) changed += memory->changes();
650: return changed;
651: }
652:
653: char *Process::prefix(char *p)
654: {
655: trace( "%d.prefix(%s) %s", this, p, _prefix ); OK("Process::prefix");
656: if( *p=='/' && _prefix && strncmp(_prefix, "/n/", 3) )
657: return p;
658: if( p && _prefix )
659: return sf( "%s/%s", _prefix, *p=='/' ? p+1 : p );
660: return p;
661: }
662:
663: void Process::slavedriver(Process *sd)
664: {
665: trace("%d.slavedriver(%d)", this, sd); VOK;
666: if( sd == this ){
667: pad->insert(ERRORKEY, "slave must be different process");
668: return;
669: }
670: pad->insert(ERRORKEY, "slave of %s", sd->procpath);
671: sd->pad->insert(ERRORKEY, "master of %s", procpath);
672: sd->_slave = this;
673: core->slavedriver(sd->core);
674: }
675:
676: Process *Process::slave()
677: {
678: trace("%d.slave()", this); OK(0);
679: return _slave;
680: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.