From: Howard Katseff Date: Mon, 10 Dec 1979 16:01:27 +0000 (-0800) Subject: BSD 3 development X-Git-Tag: BSD-3~385 X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/commitdiff_plain/780dc7a77e310e4d939f10b9399d0e6fc74341c9 BSD 3 development Work on file usr/src/cmd/sdb/fio.c Work on file usr/src/cmd/sdb/main.c Work on file usr/src/cmd/sdb/mktemp.c Work on file usr/src/cmd/sdb/prvar.c Synthesized-from: 3bsd --- diff --git a/usr/src/cmd/sdb/fio.c b/usr/src/cmd/sdb/fio.c new file mode 100644 index 0000000000..82c3b58252 --- /dev/null +++ b/usr/src/cmd/sdb/fio.c @@ -0,0 +1,176 @@ +#include "head.h" + +/* + * These procedures manage the source files examined by sdb. + */ + +/* Change the current source file to `name'. */ +finit(name) +char *name; { + register char *p, *q; + + if (fiobuf.fd) close(fiobuf.fd); + q = name; + for (p=fp; *q; *p++ = *q++) ; + *p = 0; + if ((fiobuf.fd = open(filework,0)) == -1) { + nolines = 1; + perror(filework); + return; + } + binit(&fiobuf); + cpstr(curfile, name); + for (p=fbuf;;p++) { + if (bread(&fiobuf,p,1) <= 0) { + nolines = 1; + printf("%s: No lines in file\n", name); + return; + } + if (*p == '\n') break; + } + fline = 1; + maxfline = 0; + nolines = 0; +} + +/* Make the next line current. */ +fnext() { + register char *p; + + if (nolines){ + return; + } + for(p=fbuf;;p++) { + if (bread(&fiobuf,p,1) <= 0) { + p--; + blseek(&fiobuf,0L,0); + fline = 0; + continue; + } + if (*p == '\n') break; + } + fline++; +} + + +/* Make the previous line current. */ +fprev() { + char c; + register int i; + + if (nolines){ + return; + } + for(i=0; i<3; i++) { + for (;;) { + if (bread(&fiobuf, &c+1, -1) <= 0) { + if (maxfline) blseek(&fiobuf,0L,2); + else { + blseek(&fiobuf,0L,0); + for(;;) { + if (bread(&fiobuf,&c,1)<=0) + break; + if (c == '\n') maxfline++; + } + } + } + if (c == '\n') break; + } + } + bread(&fiobuf, &c, 1); /* eat the '\n' */ + + fline -= 2; + if (fline < 0) fline = maxfline - 1; + + fnext(); +} + + +/* Print the current line. */ +fprint() { + register char *p; + + if (nolines){ + error("No lines in file"); + return; + } + printf("%d: ", fline); + p = fbuf; + while(putchar(*p++) != '\n') + ; +} + +/* Make line `num' current. */ +ffind(num) +register int num; { + register int i, ofline; + + if (nolines){ + return; + } + ofline = fline; + if (num>fline) + for (i=fline; imaxfline) goto bad; + + return; + +bad: error("Not that many lines in file"); + ffind(ofline); +} + +/* Go back n lines. */ +fback(n) { + int i; + + if (nolines){ + return(0); + } + for (i=0; i +#include +#include + +INT mkfault; +INT executing; +CHAR *lp; +L_INT maxoff; +L_INT maxpos; +ADDR sigint; +ADDR sigqit; +INT wtflag; +L_INT maxfile; +L_INT maxstor; +L_INT txtsiz; +L_INT datsiz; +L_INT datbas; +L_INT stksiz; +STRING errflg; +INT magic; +L_INT entrypt; + +CHAR lastc; + +STRING symfil; +STRING corfil; +INT argcount; +int fpe(); + + + +#ifndef STD +char *mktemp(), *tfn; +int tfd; +#endif + +main(argc, argv) +REG STRING *argv; +REG INT argc; +{ + register char *p; + struct stat stbuf; + + maxfile=1L<<24; maxstor=1L<<31; + + setbuf(stdout, NULL); + setbuf(stderr, NULL); + + WHILE argc>1 + DO IF eqstr("-w",argv[1]) + THEN wtflag=2; argc--; argv++; + ELSE break; + FI + OD + + IF argc>1 THEN symfil = argv[1]; FI + IF argc>2 THEN corfil = argv[2]; FI + fp = filework; + if (argc > 3) { + for (p = argv[3]; *p; *fp++ = *p++) ; + *fp++ = '/'; + } + argcount=argc; + + if (stat(symfil, &stbuf) == -1) { + printf("`%s' does not exist\n", symfil); + exit(4); + } + symtime = stbuf.st_mtime; + if (stat(corfil, &stbuf) != -1) { + if (symtime > stbuf.st_mtime) + printf("Warning: `%s' newer than `%s'\n", + symfil, corfil); + } + + setsym(); setcor(); + initfp(); + + /* set up variables for user */ + maxoff=MAXOFF; maxpos=MAXPOS; + gtty(2, &sdbttym); + IF (sigint= (ADDR) signal(SIGINT,01))!=01 + THEN sigint= (ADDR) fault; signal(SIGINT,fault); + FI + sigqit= (ADDR) signal(SIGQUIT,1); + signal(SIGILL, fpe); +#ifdef VAX135 + tfn = "/usr/hpk/sdblog/XXXXXX"; +#endif +#ifdef UCBVAX + tfn = "/usr/staff/hpk/sdblog/XXXXXX"; +#endif +#ifndef STD + tfn = mktemp(tfn); + tfd = open(tfn); + if (tfd < 0) + tfd = creat(tfn, 0666); + lseek(tfd, 0l, 2); +#endif + + setjmp(env); + if (debug) printf("Sdb restarted\n"); + gtty(2, &userttym); + if (sdbttym.sg_flags != userttym.sg_flags) + stty(2, &sdbttym); + IF executing THEN delbp(); FI + executing=FALSE; + + for (;;) { + mkfault = 0; + printf("*"); + if (decode(readline(stdin)) == 1) { + printf("Error; try again\n"); + continue; + } + + if (debug) { + printf("cmd %c:\n", cmd); + printf("%s:%s\n", proc, var); + printf("args-%s;re-%s;integ-%d\n", args, re, integ); + printf("scallf-%d;reflg-%d\n\n", scallf, reflag); + } + +#ifndef STD + write(tfd, &cmd, 1); +#endif + + docommand(); + } +} + + +fault(a) +{ + signal(a,fault); + mkfault++; + printf("\n"); + longjmp(env, 0); +} + +fpe() { + signal(SIGILL, fpe); + error("Illegal floating constant"); + longjmp(env, 0); +} diff --git a/usr/src/cmd/sdb/mktemp.c b/usr/src/cmd/sdb/mktemp.c new file mode 100644 index 0000000000..1c407f4510 --- /dev/null +++ b/usr/src/cmd/sdb/mktemp.c @@ -0,0 +1,21 @@ +/* make temporary file with given prefix. */ +char * +mktemp(as) +char *as; +{ + register char *s; + register unsigned pid; + + pid = getpid(); + s = as; + while (*s++) + ; + s--; + while (*--s == 'X') { + *s = (pid%10) + '0'; + pid /= 10; + } + s++; + *s = 'a'; + return(as); +} diff --git a/usr/src/cmd/sdb/prvar.c b/usr/src/cmd/sdb/prvar.c new file mode 100644 index 0000000000..52533fc9cc --- /dev/null +++ b/usr/src/cmd/sdb/prvar.c @@ -0,0 +1,386 @@ +#include "head.h" +#include +#include "cdefs.h" +struct user u; +BKPTR bkpthead; +STRING errflg; + +/* + * outvar(): + * Prints named variable, recursing once for each structure member or + * subscript. + * proc:var: variable name + * fmt: print format + * metaflag: set iff var contains metacharacters * or ? + * addr: partial address of variable, initally 0 + * class: type class of variable + * subflag: number of levels of subscript indirection + * prnamep: pointer to end of partially formed print name of variable + * comblk: name of common block containing variable, if any + * prflag: as in findvar + * + * Here and elsewhere we assume that -1 is an invalid address, and + * its is used to indicate error. + */ +outvar(proc, var, fmt, metaflag, addr, class, subflag, prnamep, comblk, prflag) +ADDR addr; char *proc, *var, *fmt, class, *prnamep, *comblk; { + char *p, *q, *r, *oldpr; + register int match; + long soffset, goffset; + register ADDR newaddr = -1, arrowaddr; + register enum {INIT, ARROW, DOT} typeflag; + + switch (var[0]) { + case '\0': + if (prflag == 0) return(addr); + if (metaflag) { + if (comblk[0] && !(eqstr(comblk, "*"))) + printf("%.8s:%.8s", comblk, prname); + else if (proc[0]) + printf("%.8s:%.8s", proc, prname); + else + printf("%s", prname); + if (prflag == 1) + printf("/ "); + else + printf("= "); + } + if (prflag == 1) + dispf(addr, fmt, class, sl_type, sl_size, subflag); + else + dispf(addr, fmt, 0, -1, 0, 0); + return(addr); + + case '[': + *prnamep++ = *var++; + p = var; + for (;;) { + *prnamep++ = *var; + if (*var == '\0' || *var == ']') break; + var++; + } + newaddr = getindir(class, addr, sl_type); + newaddr += typetosize(sl_type, sl_size) * readint(&p); + return(outvar(proc, var+1, fmt, metaflag, newaddr, N_GSYM, + subflag+1, prnamep, comblk, prflag)); + + case '-': + case '>': + typeflag = ARROW; + while (eqany(*var, "->")) + *prnamep++ = *var++; + subflag++; + arrowaddr = getindir(class, addr, sl_type); + if (errflg) { + printf("%s\n", errflg); + errflg = 0; + return(0); + } + class = N_GSYM; + if (var[0] == '\0') { + p = var; + goto recurse; + } + break; + + case '.': + typeflag = DOT; + if (class == N_RSYM) { + error("Not with a register variable"); + return(0); + } + *prnamep++ = *var++; + subflag = 0; + break; + + default: + typeflag = INIT; + break; + } + + if (typeflag == INIT) { + soffset = proc[0] ? adrtostoffset(callpc-1) : -1; + goffset = proc[0] ? -1 : findfile(curfile)->stf_offset; + } else { + soffset = proc[0] ? adrtostoffset(callpc-1) : -1; + goffset = findfile(curfile)->stf_offset; + } + + p = var; + oldpr = prnamep; + while (!eqany(*p, "->.[") && *p != '\0') + *prnamep++ = *p++; + *prnamep = '\0'; + + match = 0; + slookinit(); + + for (;;) { + if (soffset != -1) + if ((soffset = slooknext(var, soffset, typeflag!=INIT, + comblk)) != -1) + goto found; + if (goffset != -1) + if ((goffset = globallookup(var, goffset, + typeflag!=INIT)) != -1) + goto found; + return(newaddr); + + found: + r = sl_name; + q = oldpr; + while (*r) *q++ = *r++; + *q ='\0'; + + switch(typeflag) { + case INIT: + class = sl_class & STABMASK; + if (!varclass(class) || class == N_SSYM) + goto l; + newaddr = (class == N_LSYM) ? -sl_addr : sl_addr; + newaddr = formaddr(class, newaddr); + break; + + case ARROW: + class = sl_class & STABMASK; + if (!varclass(class) || class != N_SSYM) + goto l; + newaddr = arrowaddr + sl_addr; + break; + + case DOT: + class = sl_class & STABMASK; + if (!varclass(class) || class != N_SSYM) + goto l; + newaddr = addr + sl_addr; + break; + } + + recurse: + newaddr = outvar(proc, p, fmt, metaflag, newaddr, + class, subflag, prnamep, comblk, prflag); + + if (!metaflag) + return(newaddr); +l:; } +} + +prdebug() { + register struct proct *procp; + register struct filet *filep; + + printf("dot=%d\n", dot); + printf("extstart = %d\n", extstart); + for(filep=files;filep->sfilename[0];filep++) + printf("%s offs %d @ %d flag %d addr 0x%x\n", filep->sfilename, filep->stf_offset, filep, filep->lineflag, filep->faddr); + for(procp=procs;procp->pname[0];procp++) { + printf("%8.8s addr 0x%x; offs %d; sfptr %d; line %d", + procp->pname, procp->paddr, procp->st_offset, + procp->sfptr, procp->lineno); + if (procp->entrypt) printf(" entrypoint"); + printf("\n"); + } +} + +/* display addr using format desc or class s */ +dispf(addr, desc, class, type, size, subflag) +char *desc; short type; ADDR addr; { + dispx(addr, desc, class, type, size, subflag); + printf("\n"); +} + +char pd[] = "%x"; +dispx(addr, desc, class, type, size, subflag) +char *desc; short type; ADDR addr; { + int i, sflag; + char *p; + char dlen, dfmt; + long value; + union { + struct { + char c[WORDSIZE]; + }; + struct { + int w; + }; + struct { + float f; + } + } word; + union { + struct{ + int w1, w2; + }; + struct { + double d; + }; + } dbl; + + class &= STABMASK; + if (desc[0] == '\0') desc = typetodesc(type, subflag); + cpstr(odesc, desc); + otype = type; + oclass = class; + oaddr = addr; + oincr = 0; + if (debug) printf("dispf(%d,%s,0%o,0%o)\n", addr,desc,class,type); + pd[1] = dfmt = 'd'; + dlen = '\0'; + for (p = desc; *p; p++) { + if (*p>= '0' && *p<'9') { + size = readint(&p); + p--; + } else switch (*p) { + case 'l': + case 'h': + case 'b': + dlen = *p; + break; + + case 'a': + case 'c': + case 'd': + case 'f': + case 'g': + case 'o': + case 'p': + case 's': + case 'u': + case 'x': + pd[1] = dfmt = *p; + break; + + default: + printf("Illegal descriptor: %c\n", *p); + return; + } + } + + if (type == -1) + value = addr; + else if (class == N_RSYM && addr < 16) { + /* MACHINE DEPENDENT */ + if ((addr > 0 && addr < 6) || addr > 11) { + printf("Bad register var %d\n", addr); + return; + } + value = *(ADDR *)(((ADDR) &u) + R0 + (WORDSIZE)*addr); + } + else { + value = getval(addr, dfmt == 'g' ? 'd' : dfmt); + } + + if (errflg) { + printf("%s", errflg); + errflg = 0; + return; + } + + switch (dfmt) { + default: + switch (dfmt) { + case 'u': + case 'x': + case 'o': + switch (dlen) { + case 'h': + value = (unsigned short) value; + oincr = 2; + break; + case 'b': + value = (unsigned char) value; + oincr = 1; + break; + case 'l': + value = (unsigned long) value; + oincr = 4; + break; + } + break; + + default: + switch (dlen) { + case 'h': + value = (short) value; + oincr = 2; + break; + case 'b': + value = (char) value; + oincr = 1; + break; + case 'l': + value = (long) value; + oincr = 4; + break; + } + } + if (value > 0) { + if (value > 9 && dfmt == 'x') + printf("0x"); + else if (value > 7 && dfmt == 'o') + printf("0"); + } + printf(pd, value); + return; + + case 'f': + pd[1] = 'g'; + word.w = value; + printf(pd, word.f); + return; + + case 'g': + dbl.w1 = value; + dbl.w2 = (class == (char) N_RSYM) ? + *(ADDR *)(((ADDR) &u)+R0+(WORDSIZE)*(addr+1)) : + getval(addr+WORDSIZE, 'd'); + printf("%.13g", dbl.d); + return; + + case 'p': + printf("%s:%d", adrtoprocp(value)->pname, + adrtolineno(value)); + return; + + case 's': + addr = getindir(class, addr, type); + goto aa; + + case 'c': + if (size <= 1) { + oincr = 1; + printchar(value); + return; + } else + goto aa; + + case 'a': + aa: sflag = size == 0; + if (sflag) + size = 128; /* maximum length for s and a */ + else + oincr = size; + for (;;) { + word.w = getval(addr, 'd'); + for (i=0; i