![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / cdb|
Return to cmd.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / cdb |
1.1 root 1: static char sccsid[] = "@(#)cmd.c 2.8";
2:
3: #include <ctype.h>
4: #include <stdio.h>
5: #include "cdb.h"
6: #include <signal.h>
7:
8: static char vsbTarget[100]; /* used for string searches */
9: static char vchSearch = '/'; /* contains either ? or / */
10:
11: export CMDE vcmdDef;
12: export char *vsbCmd, *vsbCmdOld;
13: export long vdot;
14: export TYR vtyDot[cTyMax];
15: export int viln, vslop; /* line number & offset from true line number */
16: export char vsbFileTemp[80]; /* name of vifdTemp file */
17:
18:
19: /* C A L L S H E L L */
20:
21: local void CallShell(sbCmd)
22: char *sbCmd;
23: {
24: char stShell[20];
25:
26: if ((sbCmd == sbNil) OR (*sbCmd == chNull)) {
27: sprintf(stShell, "%s -i", getenv("SHELL"));
28: sbCmd = stShell;
29: } /* if */
30: system(sbCmd);
31: printf("\nback in cdb, debugging %s\n", vsbSymfile);
32: } /* CallShell */
33:
34:
35: /* E A T C M D L I S T */
36:
37: export char * EatCmdList()
38: {
39: char *sbCmd, *sbTemp;
40: TKE tk;
41:
42: sbCmd = vsbCmd;
43: tk = TkPeek();
44: if (tk == tkNil)
45: return(sbNil);
46:
47: if (tk != tkLCB) {
48: vsbCmd = sbNil; /* give caller the rest of line */
49: }
50: else {
51: tk = TkNext(); /* eat { */
52: sbCmd = vsbCmd;
53: sbTemp = SbFEob(vsbCmd) - 1;
54: if (*sbTemp == '}')
55: *sbTemp = chNull;
56: vsbCmd = sbTemp + 1;
57: } /* if */
58: while (*sbCmd == ' ')
59: sbCmd++;
60: return(sbCmd);
61: } /* EatCmdList */
62:
63:
64: /* E A T F I L E N A M E */
65:
66: local void EatFilename(sbName, psbIn)
67: char *sbName, **psbIn;
68: {
69: int cch;
70: char *sbIn;
71:
72: sbIn = *psbIn;
73: while (*sbIn == '\t' OR *sbIn == ' ')
74: sbIn++;
75: cch = strcspn(sbIn, "\t ;}");
76: strncpy(sbName, sbIn, cch);
77: sbName[cch] = chNull;
78: *psbIn = sbIn + cch;
79: } /* EatFilename */
80:
81:
82: /* S B F E O B */
83:
84: export char *SbFEob(sb)
85: char *sb;
86: {
87: int cNest;
88:
89: /* return pointer to AFTER '}', or to the chNull */
90: cNest = (*sb == '{') ? 0 : 1;
91: while (*sb) {
92: if (*sb == '{')
93: cNest++;
94: else if (*sb == '}')
95: if (--cNest == 0)
96: return(sb+1);
97: sb++;
98: } /* while */
99: return(sb);
100: } /* SbFEob */
101:
102:
103: /* F D O C O M M A N D */
104:
105: export FLAGT FDoCommand(sbCmdIn, fTop)
106: char *sbCmdIn;
107: FLAGT fTop;
108: {
109: int valShort, ln, cLn, cnt, ifd, ipd;
110: int sig, ibp, i, ilnSave;
111: FLAGT fHaveValue, fDidit, fDoit, fCommand;
112: char ch, chBp, chCmd, chNext;
113: char *sbBp, *sbTemp, *sbCmds, *sbTwoChars;
114: char sbName[80];
115: long valExp, adrLong;
116: ADRT adr;
117: TKE tk, tkRet;
118: ASE as;
119: pTYR ty;
120: TYR rgTy[cTyMax];
121:
122: /* the commands */
123: sbCmds = "\n<>-+?/^!~;{}AabBcCdDeEfFgiIklLMpqQrRsStTwWxzZ";
124: sbTwoChars = "<bi"; /* commands of two or more characters */
125: if (!fTop)
126: PushCmd(vsbCmd);
127: vsbCmd = vsbCmdOld = sbCmdIn;
128:
129: tk = TkNext();
130: do {
131: if ((tk == tkStr) AND (FSbCmp("help", vsbTok))) {
132: Help();
133: vcmdDef = cmdNil;
134: return(fTop);
135: }
136: else if (tk == tkStrConstant) {
137: printf("%s", vsbTok);
138: vcmdDef = cmdNil;
139: tk = TkNext();
140: continue;
141: } /* if */
142:
143: /* we guess whether to parse an expression */
144: /* this is a little weird because we try to do the `right' thing */
145: adrLong = 0;
146: chCmd = vsbTok[0];
147: fHaveValue = false;
148: fCommand = (tk == tkNil);
149: if (strchr(sbCmds, chCmd) != NULL) {
150: /* the first letter LOOKS like a command, keep going */
151: fCommand = (vcbTok == 1);
152: if ((vcbTok > 1) AND (tk == tkStr)) {
153: /* it is longer than 1 character, might be a variable name */
154: chNext = vsbTok[1];
155: if ( (vcbTok == 2)
156: AND (strchr(sbTwoChars, chCmd) != NULL) ) {
157: fCommand = (chCmd == 'b' AND strchr("abBtTuUxX", chNext))
158: OR (chCmd == 'i' AND chNext == 'f')
159: OR (chCmd == '<' AND chNext == '<');
160: } /* if */
161: } /* if */
162: /* a final chance to change our minds */
163: TkPeek(); /* load peek token information */
164: if ( (tk == tkStr)
165: AND (*vsbCmd != ' ')
166: AND (vsbTokPeek[0] != chNull)
167: AND !(strchr(";}", vsbTokPeek[0])) ) {
168: fCommand = false;
169: } /* if */
170: } /* if */
171:
172: if (!fCommand) {
173: /* assume it is a beginning expression */
174: vipd = IpdFAdr(AdrFIfdLn(vifd, viln)); /* force things right */
175: if ((tkRet = TkFExpr(&adrLong, rgTy)) != tkNil) {
176: valExp = ValFAdr(adrLong, rgTy); /* many cmds just want value */
177: valShort = valExp;
178: fHaveValue = true;
179: }
180: else {
181: if (PrecFTk(tkRet))
182: tk = TkNext();
183: UError("Unknown variable - %s", vsbTok);
184: } /* if */
185: } /* if */
186:
187: cnt = 1;
188: chCmd = vsbTok[0];
189: switch (chCmd) {
190: default:
191: vcmdDef = cmdNil;
192: UError("Unknown command `%c' (%#o)\n", chCmd, chCmd);
193: case '\n':
194: case '~':
195: case chNull: /* default command */
196: if (!fHaveValue) {
197: switch (vcmdDef) {
198: case cmdPrint:
199: viln++;
200: PrintLine(viln, 1, true);
201: break;
202: case cmdUpArrow:
203: case cmdDisplay:
204: i = IncFTyMode(vtyDot, vmode);
205: vdot += (vcmdDef == cmdUpArrow) ? -i : i;
206: DispVal(vdot, vtyDot, vmode, true, true, true);
207: printf("\n");
208: break;
209: case cmdLineSingle:
210: printf("s: ");
211: IbpFSingle(false, false);
212: break;
213: case cmdProcSingle:
214: printf("S: ");
215: IbpFSingle(true, false);
216: break;
217: } /* switch */
218: }
219: else if (tkRet == tkNumber) {
220: i = valShort;
221: if (i > 0)
222: viln = i;
223: else viln += i;
224: vslop = 0;
225: PrintLine(viln, 1, true);
226: vcmdDef = cmdPrint;
227: }
228: else if (tkRet == tkAdr) {
229: vdot = adrLong;
230: CopyTy(vtyDot, rgTy);
231: DispVal(vdot, vtyDot, modeNil, true, true, true);
232: printf("\n");
233: vcmdDef = cmdDisplay;
234: } /* if */
235: break;
236: case '+': /* go forward N (1) line and print it */
237: case '-': /* go backward N (1) line and print it */
238: i = GetExpr(&ty, tkNil);
239: if (ty == tyNil)
240: i = 1;
241: viln += (chCmd=='-') ? -abs(i) : abs(i);
242: PrintLine(viln, 1, true);
243: vcmdDef = cmdPrint;
244: continue;
245: case '!':
246: CallShell(vsbCmd); /* shell escape */
247: vsbCmd = sbNil;
248: break;
249: case '^': /* attempt to move backward, displaying memory */
250: GetMode(vmode);
251: vdot -= IncFTyMode(vtyDot, vmode);
252: DispVal(vdot, vtyDot, vmode, true, true, true);
253: printf("\n");
254: vcmdDef = cmdUpArrow;
255: break;
256: case '/': /* 2 commands: 'X/Y' == display *X in format Y
257: * '/hi mom' == search FORWARDS and print
258: */
259: case '?': /* 2 commands: 'X?Y' == display X in format Y
260: * '?hi mom' == search BACKWARDS and print
261: */
262: if (!fHaveValue) {
263: /* search for something */
264: if (*vsbCmd != chNull) {
265: strcpy(vsbTarget, vsbCmd);
266: *vsbCmd = chNull;
267: } /* if */
268: vchSearch = chCmd;
269: Find(vsbTarget, (chCmd=='?'));
270: vcmdDef = cmdPrint;
271: }
272: else {
273: vdot = adrLong;
274: CopyTy(vtyDot, rgTy);
275: GetMode(vmode);
276: if (chCmd == '/') {
277: /* this prints the CONTENTS of an address */
278: DispVal(vdot, vtyDot, vmode, true, true, true);
279: vcmdDef = cmdDisplay;
280: }
281: else {
282: /* this prints an ADDRESS */
283: vmode->cnt = 1;
284: DispVal(vdot, vtyDot, vmode, true, false, false);
285: vcmdDef = cmdNil;
286: } /* if */
287: printf("\n");
288: } /* if */
289: break;
290: case '<': /* playback commands */
291: EatFilename(sbName, &vsbCmd);
292: SetPlayback(sbName, (vsbTok[1] == '<'));
293: break;
294: case '>': /* record commands */
295: TkPeek();
296: if (vsbTokPeek[1] == chNull) {
297: if ( (vsbTokPeek[0] == 't')
298: OR (vsbTokPeek[0] == 'f')) {
299: TkNext(); /* actually eat next token */
300: StateRecord(vsbTok[0] == 't');
301: break;
302: }
303: else if (vsbTokPeek[0] == 'c') {
304: TkNext(); /* actually eat next token */
305: SetRecord(sbNil);
306: break;
307: } /* if */
308: /* we fall through on other, 1 character filenames */
309: } /* if */
310: EatFilename(sbName, &vsbCmd);
311: SetRecord(sbName);
312: break;
313: case ';': /* just a command delimiter */
314: vcmdDef = cmdNil;
315: break;
316: case 'A': /* toggle main assertion state */
317: if (viadMac > 0)
318: vas = (vas==asSuspended) ? asActive : asSuspended;
319: printf("Assertions are %s\n", (vas==asSuspended) ?
320: "SUSPENDED" : "ACTIVE");
321: vcmdDef = cmdNil;
322: break;
323: case 'a': /* maintain assertion list */
324: if (fHaveValue) {
325: TkNext();
326: switch (vsbTok[0]) {
327: case 'a':
328: as = asActive;
329: break;
330: case 'd':
331: as = asNil;
332: break;
333: case 's':
334: as = asSuspended;
335: break;
336: default:
337: UError("Invalid assertion maintenance command");
338: } /* switch */
339: ModAssert(valShort, as);
340: break;
341: } /* if */
342: if ((sbTemp=EatCmdList()) != sbNil)
343: AddAssert(sbTemp);
344: break;
345: case 'B': /* list all breakpoints */
346: ListBp();
347: break;
348: case 'b': /* set (set again) a break point */
349: vipd = IpdFAdr(AdrFIfdLn(vifd, viln));
350: chBp = vsbTok[1];
351: sbBp = EatCmdList();
352: ibp = ibpNil;
353: if (chBp == 'a') {
354: if (!fHaveValue)
355: UError("correct form is `address ba [<cmds>]'");
356: else
357: adr = valShort;
358: ibp = IbpFAdr(adr, 1, sbBp);
359: }
360: else if (chBp == chNull) {
361: /* vanilla breakpoint */
362: i = (fHaveValue) ? valShort : viln;
363: adr = AdrFIfdLn(vifd, i);
364: ibp = IbpFAdr(adr, 1, sbBp);
365: }
366: else {
367: ch = (isupper(chBp)) ? tolower(chBp) : chBp;
368: i = (fHaveValue) ? valShort : (ch=='u') ? 1 : -1;
369: ibp = IbpFSet(chBp, i, sbBp);
370: } /* if */
371: if (ibp != ibpNil) {
372: PrintPos(vrgBp[ibp].adr, fmtProc+fmtLn+fmtSave);
373: printf(":b \n");
374: } /* if */
375: vcmdDef = cmdNil;
376: break;
377: case 'C':
378: case 'c':
379: vipd = IpdFAdr(AdrFIfdLn(vifd, viln));
380: if (fHaveValue) {
381: /* we have a continuance count */
382: i = valShort;
383: if (vibp != ibpNil)
384: vrgBp[vibp].count = i;
385: } /* if */
386: i = GetExpr(&ty, tkNil);
387: if (ty != tyNil) {
388: adr = AdrFIfdLn(vifd, i);
389: ibp = IbpFAdr(adr, -1, "");
390: } /* if */
391: if (chCmd == 'c')
392: vsig = 0; /* do not pass signal back to child */
393: IbpFRun(ptResume);
394: vcmdDef = cmdNil;
395: continue;
396: case 'D':
397: ClearAll();
398: vcmdDef = cmdNil;
399: break;
400: case 'd':
401: adr = adrNil;
402: if (!fHaveValue)
403: adr = AdrFIfdLn(vifd, viln);
404: else if (valShort > 0
405: AND valShort < vibpMac) /* make sure it is range */
406: adr = vrgBp[valShort].adr;
407: if ((adr == adrNil)
408: OR (!FClearBp(adr)) ) {
409: printf("No such breakpoint\n");
410: ListBp();
411: break;
412: } /* if */
413: vcmdDef = cmdNil;
414: break;
415: case 'e':
416: adr = AdrFIfdLn(vifd, viln);
417: tk = TkPeek();
418: if (tk == tkNil) {
419: PrintPos(adr, fmtFile+fmtProc+fmtLn+fmtEol);
420: }
421: else {
422: fDidit = false;
423: EatFilename(sbName, &vsbCmd);
424: if (strchr(sbName, '.') == NULL) {
425: if ((ipd = IpdFName(sbName)) != ipdNil) {
426: OpenIpd(ipd, true);
427: PrintPos(adrNil,fmtFile+fmtProc+fmtLn+fmtPrint);
428: fDidit = true;
429: } /* if */
430: } /* if */
431: if (!fDidit) {
432: strcpy(vsbFileTemp, sbName);
433: if ((ifd = IfdFName(vsbFileTemp)) == vifdNil)
434: ifd = vifdTemp;
435: ifd = IfdFOpen(ifd);
436: if (ifd != vifdNil) {
437: PrintPos(adrNil, fmtFile+fmtLn+fmtPrint);
438: fDidit = true;
439: } /* if */
440: } /* if */
441: if (!fDidit)
442: UError("No such procedure or file name: %s",sbName);
443: } /* if */
444: vcmdDef = cmdPrint;
445: break;
446: case 'E':
447: cnt = (fHaveValue) ? valShort : 0;
448: OpenStack(cnt);
449: vcmdDef = cmdPrint;
450: break;
451: case 'F': /* find and fix bug */
452: FindAndFix();
453: break;
454: case 'f': /* set address display format */
455: tk = TkNext();
456: if (tk == tkStrConstant) {
457: strncpy(vsbFmt, vsbTok, 20); /* snarf */
458: vsbFmt[19] = chNull; /* just to be safe */
459: }
460: else if (tk == tkSemi) {
461: vsbFmt[0] = chNull;
462: }
463: else {
464: UError("Bad argument to the 'f' command");
465: } /* if */
466: vcmdDef = cmdNil;
467: break;
468: case 'g': /* 'goto' command (I'm SORRY!!!!!!!!) */
469: adr = GetExpr(&ty, tkNil);
470: if (ty == tyNil) {
471: UError("I need a linenumber");
472: } /* if */
473: GotoLn(adr);
474: break;
475: case 'i': /* conditional command */
476: fDoit = GetExpr(&ty, tkNil);
477: if (ty == tyNil)
478: fDoit = false;
479: tk = vtk; /* look ahead by expression parser */
480: if (tk != tkLCB)
481: UError("Missing {");
482: if (!fDoit) {
483: vsbCmd = SbFEob(vsbCmd); /* eat the first block */
484: tk = TkNext();
485: if (tk != tkLCB)
486: continue; /* we ate first part of next command */
487: } /* if */
488: break;
489: case '{': /* beginning of block, eat block */
490: vsbCmd = SbFEob(vsbCmd); /* returns ptr to matching }+1 */
491: break;
492: case '}': /* end of block */
493: break; /* we just throw it away */
494: case 'I': /* information about cdb's state */
495: ShowState();
496: vcmdDef = cmdNil;
497: break;
498: case 'k':
499: if (vpid == pidNil)
500: UError("No process to kill");
501: if (!YesNo("Really kill child? "))
502: break; /* their finger slipped or something */
503: KillChild();
504: printf("process killed\n");
505: vcmdDef = cmdNil;
506: break;
507: case 'l':
508: ListSomething();
509: break;
510: case 'L':
511: PrintPos(vpc, fmtFile+fmtProc+fmtLn+fmtPrint);
512: /* which puts us at the break */
513: vcmdDef = cmdPrint;
514: break;
515: case 'M': /* print|set map values */
516: DoMap();
517: vcmdDef = cmdNil;
518: break;
519: case 'p':
520: if (fHaveValue) {
521: i = valShort;
522: if (i < 0)
523: viln += i;
524: else viln = i;
525: vslop = 0;
526: } /* if */
527: cnt = GetExpr(&ty, tkNil);
528: if ((ty == tyNil) OR (cnt <= 0))
529: cnt = 1;
530: PrintLine(viln, cnt, true);
531: vcmdDef = cmdPrint;
532: continue;
533: case 'q':
534: if (!YesNo("Really quit? "))
535: break; /* their finger slipped or something */
536: exit(0);
537: /* NOTREACHED */
538: break;
539: case 'Q': /* quiet command, just eat it */
540: break;
541: case 'r':
542: case 'R':
543: ibp = IbpFNewChild((chCmd == 'R') ? sbNil : vsbCmd);
544: if (ibp == ibpNil)
545: /* just fire it up */
546: ibp = IbpFRun(ptResume);
547: vcmdDef = cmdNil;
548: break;
549: case 'S':
550: case 's':
551: i = (fHaveValue) ? valShort : 1;
552: vcmdDef = (chCmd=='s') ? cmdLineSingle : cmdProcSingle;
553: while (i--)
554: if (ibpNil != IbpFSingle(chCmd=='S', false))
555: break;
556: break;
557: case 'T':
558: case 't':
559: i = (fHaveValue) ? valShort : 20; /* default to 20 deep */
560: StackTrace(i, (chCmd=='T')); /* do locals, too, on T */
561: vcmdDef = cmdNil;
562: break;
563: case 'W':
564: cnt = 21;
565: case 'w':
566: viln = (fHaveValue) ? valShort : viln;
567: vslop = 0;
568: ilnSave = viln;
569: if (cnt == 1)
570: cnt = 11; /* i.e. - we didn't come through W */
571: i = GetExpr(&ty, tkNil);
572: if ((ty != tyNil) AND (i >= 1))
573: cnt = i;
574: ln = Max(viln-cnt/2, 0);
575: cLn = Min(cnt/2, viln-ln);
576: PrintLine(ln, cLn, true);
577: printf(">"); /* shows them which line they are on */
578: viln++;
579: cLn = Min(cnt-cLn, vrgFd[vifd].ilnMac-viln+1);
580: PrintLine(viln, cLn, true);
581: viln = ilnSave;
582: vcmdDef = cmdPrint;
583: continue;
584: case 'x': /* clear command line and exit current level */
585: if ((!fHaveValue) OR (valShort == 0))
586: vsbCmd = PopCmd();
587: return(true);
588: case 'z':
589: sig = (fHaveValue) ? valShort : vsig;
590: TkNext();
591: if (sig == SIGTRAP)
592: printf(
593: "WARNING: You are modifying the breakpoint signal!\n");
594: SaMaintain(sig, vsbTok);
595: break;
596: case 'Z':
597: vcaseMod = (vcaseMod) ? 0 : 040;
598: printf("Searches will %sbe case sensitive\n",
599: (vcaseMod!=0) ? "NOT " : "");
600: vcmdDef = cmdNil;
601: break;
602: } /* switch */
603: }
604: while ((tk = TkNext()) != tkNil);
605:
606: return(fTop);
607: } /* FDoCommand */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.