![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to runcont.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / pdx / process|
Return to runcont.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / pdx / process |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)runcont.c 5.1 (Berkeley) 6/6/85";
9: #endif not lint
10:
11: /*
12: * Execution management.
13: */
14:
15: #include "defs.h"
16: #include <signal.h>
17: #include "process.h"
18: #include "machine.h"
19: #include "object.h"
20: #include "main.h"
21: #include "breakpoint.h"
22: #include "command.h"
23: #include "process.rep"
24:
25: #define MAXNARGS 100 /* maximum number of arguments to RUN */
26:
27: typedef char *String;
28:
29: LOCAL BOOLEAN just_started;
30: LOCAL int argc;
31: LOCAL String argv[MAXNARGS];
32: LOCAL String infile;
33: LOCAL String outfile;
34: LOCAL PROCESS pbuf;
35: PROCESS *process = &pbuf;
36:
37: /*
38: * This is a px-related kludge to deal with the possibility
39: * of object code magically coming from a tmp file.
40: */
41:
42: LOCAL String mode;
43: LOCAL String realname;
44:
45: setargs(m, r)
46: char *m, *r;
47: {
48: mode = m;
49: realname = r;
50: }
51:
52: /*
53: * Initialize the argument list.
54: */
55:
56: arginit()
57: {
58: infile = NIL;
59: outfile = NIL;
60: # if (isvaxpx)
61: argv[0] = mode;
62: argv[1] = objname;
63: if (option('t') && realname == NIL) {
64: argc = 2;
65: } else {
66: argv[2] = realname;
67: argc = 3;
68: }
69: # else
70: argv[0] = objname;
71: argc = 1;
72: # endif
73: }
74:
75: /*
76: * Add an argument to the list for the debuggee.
77: */
78:
79: newarg(arg)
80: String arg;
81: {
82: if (argc >= MAXNARGS) {
83: error("too many arguments to run");
84: }
85: argv[argc++] = arg;
86: }
87:
88: /*
89: * Set the standard input for the debuggee.
90: */
91:
92: inarg(filename)
93: String filename;
94: {
95: if (infile != NIL) {
96: error("multiple input redirects");
97: }
98: infile = filename;
99: }
100:
101: /*
102: * Set the standard output for the debuggee.
103: * Probably should check to avoid overwriting an existing file.
104: */
105:
106: outarg(filename)
107: String filename;
108: {
109: if (outfile != NIL) {
110: error("multiple output redirect");
111: }
112: outfile = filename;
113: }
114:
115: /*
116: * Initial start of the process. The idea is to get it to the point
117: * where the object code has been loaded but execution has not begun.
118: */
119:
120: initstart()
121: {
122: arginit();
123: argv[argc] = NIL;
124: initcache(process);
125: start(argv, infile, outfile);
126: if (process->status != STOPPED) {
127: panic("could not start program");
128: }
129: }
130:
131: /*
132: * Run starts debuggee executing.
133: */
134:
135: run()
136: {
137: fixbps();
138: curline = 0;
139: argv[argc] = NIL;
140: start(argv, infile, outfile);
141: if (process->status == STOPPED) {
142: just_started = TRUE;
143: isstopped = FALSE;
144: cont();
145: } else if (option('r')) {
146: panic("could not start program");
147: }
148: }
149:
150: /*
151: * Continue execution wherever we left off.
152: *
153: * Note that this routine never returns. Eventually bpact() will fail
154: * and we'll call printstatus or step will call it.
155: */
156:
157: typedef int INTFUNC();
158:
159: LOCAL INTFUNC *dbintr;
160: LOCAL intr();
161:
162: #define succeeds == TRUE
163: #define fails == FALSE
164:
165: cont()
166: {
167: dbintr = signal(SIGINT, intr);
168: if (just_started) {
169: just_started = FALSE;
170: } else {
171: if (!isstopped) {
172: error("can't continue execution");
173: }
174: isstopped = FALSE;
175: step();
176: }
177: for (;;) {
178: if (single_stepping) {
179: printnews();
180: } else {
181: setallbps();
182: resume();
183: unsetallbps();
184: if (bpact() fails) {
185: printstatus();
186: }
187: }
188: step();
189: }
190: /* NOTREACHED */
191: }
192:
193: /*
194: * This routine is called if we get an interrupt while "running" px
195: * but actually in the debugger. Could happen, for example, while
196: * processing breakpoints.
197: *
198: * We basically just want to keep going; the assumption is
199: * that when the process resumes it will get the interrupt
200: * which will then be handled.
201: */
202:
203: LOCAL intr()
204: {
205: signal(SIGINT, intr);
206: }
207:
208: fixintr()
209: {
210: signal(SIGINT, dbintr);
211: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.