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 (file)
index 0000000..82c3b58
--- /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; i<num; i++) {
+                       fnext();
+                       if (fline == 1) goto bad;
+               }
+       if (num<fline)
+               for (i=num; i<ofline; i++) {
+                       fprev();
+               }
+               
+       if (maxfline & num>maxfline) 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<n; i++) {
+               if (fline == 1) return(i);
+               fprev();
+       }
+       return(i);
+}
+
+/* Go forwards n lines. */
+fforward(n) {
+       int i;
+       
+       if (nolines){
+               return(0);
+       }
+       for (i=0; i<n; i++) {
+               fnext();
+               if (fline == 1) {
+                       fprev();
+                       return(i);
+               }
+       }
+       return(i);
+}
+
+/* Print n lines. */
+fprintn(n) {
+       int i;
+       
+       if (nolines){
+               error("No lines in file");
+               return(0);
+       }
+       for (i=0; i<n; i++) {
+               fprint();
+               fnext();
+               if (fline == 1) break;
+       }
+       fprev();
+       return(i);
+}

diff --git a/usr/src/cmd/sdb/main.c b/usr/src/cmd/sdb/main.c
new file mode 100644 (file)
index 0000000..d5d2699
--- /dev/null
+++ b/usr/src/cmd/sdb/main.c
@@ -0,0 +1,153 @@
+#
+/*
+ *
+ *     UNIX debugger
+ *
+ */
+
+#include       "head.h"
+#include       <signal.h>
+#include       <stdio.h>
+#include       <sys/stat.h>
+
+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 (file)
index 0000000..1c407f4
--- /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 (file)
index 0000000..52533fc
--- /dev/null
+++ b/usr/src/cmd/sdb/prvar.c
@@ -0,0 +1,386 @@
+#include "head.h"
+#include <a.out.h>
+#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<WORDSIZE; i++) {
+                                       if (sflag && word.c[i] == 0) 
+                                               return;
+                                       if (size-- == 0)
+                                               return;
+                                       printchar(word.c[i]);
+                               }
+                               addr += WORDSIZE;
+                       }
+
+       }
+}
+
+printchar(c) {
+       if ((c & 0177) < ' ') 
+               printf("^%c", c + ('A' - 1));
+       else if ((c & 0177) == 0177)
+               printf("^?");
+       else
+               printf("%c", c);
+}
+