#ifndef lint
-static char sccsid[] = "@(#)access.c 4.8 10/13/84";
+static char sccsid[] = "@(#)_access.c 4.8 10/13/84";
#endif
/*
- * Adb: access data in file/process address space.
+ * Adb: _access data in file/process address space.
*
- * The routines in this file access referenced data using
- * the maps to access files, ptrace to access subprocesses,
+ * The routines in this file _access referenced data using
+ * the maps to _access files, ptrace to _access subprocesses,
* or the system page tables when debugging the kernel,
* to translate virtual to physical addresses.
*/
#include "defs.h"
-MAP txtmap;
-MAP datmap;
-INT wtflag;
-STRING errflg;
-INT errno;
+struct map txtmap;
+struct map datmap;
+short wtflag;
+char *errflg;
+short errno;
-INT pid;
+short pid;
/*
* Primitives: put a value in a space, get a value from a space
* and get a word or byte not returning if an error occurred.
*/
put(addr, space, value)
- off_t addr; { (void) access(WT, addr, space, value); }
+ off_t addr; { (void) _access(WT, addr, space, value); }
u_int
get(addr, space)
- off_t addr; { return (access(RD, addr, space, 0)); };
+ off_t addr; { return (_access(RD, addr, space, 0)); };
u_int
chkget(addr, space)
u_int
bchkget(addr, space)
- off_t addr; { return(chkget(addr, space) & LOBYTE); }
+ off_t addr; { return(chkget(addr, space) & 0377); }
/*
* Read/write according to mode at address addr in i/d space.
* relative to the ``current'' process (as specified by its p_addr in
* <p) and mapping system space addresses through the system page tables.
*/
-access(mode, addr, space, value)
+_access(mode, addr, space, value)
int mode, space, value;
off_t addr;
{
errflg = "page table botch";
return (-1);
}
- /* SHOULD CHECK NOT I/O ADDRESS; NEED CPU TYPE! */
+ /* SHOULD CHECK NOT I/O ADDRESS; NEED CPU typedef! */
if (pte.pg_v == 0 && (pte.pg_fod || pte.pg_pfnum == 0)) {
errflg = "page not valid/reclaimable";
return (-1);
}
chkmap(addr,space)
- REG L_INT *addr;
- REG INT space;
+ register long *addr;
+ register short space;
{
- REG MAPPTR amap;
+ register struct map *amap;
amap=((space&DSP?&datmap:&txtmap));
- IF space&STAR ORF !within(*addr,amap->b1,amap->e1)
- THEN IF within(*addr,amap->b2,amap->e2)
- THEN *addr += (amap->f2)-(amap->b2);
- ELSE rwerr(space); return(0);
- FI
- ELSE *addr += (amap->f1)-(amap->b1);
- FI
+ if (space&STAR || !within(*addr,amap->b1,amap->e1)) {
+ if (within(*addr,amap->b2,amap->e2)) {
+ *addr += (amap->f2)-(amap->b2);
+ }
+ else {
+ rwerr(space); return(0);
+ }
+ }
+ else {
+ *addr += (amap->f1)-(amap->b1);
+ }
return(1);
}
#include "defs.h"
-MSG BADEQ;
-MSG NOMATCH;
-MSG BADVAR;
-MSG BADCOM;
-
-MAP txtmap;
-MAP datmap;
-INT executing;
-CHAR *lp;
-INT fcor;
-INT fsym;
-INT mkfault;
-STRING errflg;
-
-CHAR lastc;
-CHAR eqformat[512] = "z";
-CHAR stformat[512] = "X\"= \"^i";
-
-L_INT dot;
-L_INT ditto;
-INT dotinc;
-INT lastcom = '=';
-L_INT var[];
-L_INT locval;
-L_INT locmsk;
-INT pid;
-L_INT expv;
-L_INT adrval;
-INT adrflg;
-L_INT cntval;
-INT cntflg;
+char BADEQ[];
+char NOMATCH[];
+char BADVAR[];
+char BADCOM[];
+
+struct map txtmap;
+struct map datmap;
+short executing;
+char *lp;
+short fcor;
+short fsym;
+short mkfault;
+char *errflg;
+
+char lastc;
+char eqformat[512] = "z";
+char stformat[512] = "X\"= \"^i";
+
+long dot;
+long ditto;
+short dotinc;
+short lastcom = '=';
+long var[];
+long locval;
+long locmsk;
+short pid;
+long expv;
+long adrval;
+short adrflg;
+long cntval;
+short cntflg;
/* command decoding */
command(buf,defcom)
-STRING buf;
-CHAR defcom;
+char *buf;
+char defcom;
{
- INT itype, ptype, modifier, regptr;
- BOOL longpr, eqcom;
- CHAR wformat[1];
- CHAR savc;
- L_INT w, savdot;
- STRING savlp=lp;
- IF buf
- THEN IF *buf==EOR
- THEN return(FALSE);
- ELSE lp=buf;
- FI
- FI
-
- REP
- IF adrflg=expr(0)
- THEN dot=expv; ditto=dot;
- FI
+ short itype, ptype, modifier, regptr;
+ bool longpr, eqcom;
+ char wformat[1];
+ char savc;
+ long w, savdot;
+ char*CHECKME savlp=lp;
+ if (buf) {
+ if (*buf=='\n') {
+ return(0);
+ }
+ else {
+ lp=buf;
+ }
+ }
+
+ do {
+
+ if (adrflg=expr(0)) {
+ dot=expv; ditto=dot;
+ }
adrval=dot;
- IF rdc()==',' ANDF expr(0)
- THEN cntflg=TRUE; cntval=expv;
- ELSE cntflg=FALSE; cntval=1; lp--;
- FI
-
- IF !eol(rdc())
- THEN lastcom=lastc;
- ELSE IF adrflg==0 THEN dot=inkdot(dotinc); FI
+ if (rdc()==',' && expr(0)) {
+ cntflg=-1; cntval=expv;
+ }
+ else {
+ cntflg=0; cntval=1; lp--;
+ }
+
+ if (!eol(rdc())) {
+ lastcom=lastc;
+ }
+ else {
+ if (adrflg==0) { dot=inkdot(dotinc); }
lp--; lastcom=defcom;
- FI
+ }
- switch(lastcom&STRIP) {
+ switch(lastcom&0177) {
case '/':
itype=DSP; ptype=DSYM;
goto trypr;
case '?':
- itype=ISP; ptype=ISYM;
+ itype=_ISP; ptype=ISYM;
goto trystar;
trystar:
- IF rdc()=='*' THEN lastcom |= QUOTE; ELSE lp--; FI
- IF lastcom"E
- THEN itype |= STAR; ptype = (DSYM+ISYM)-ptype;
- FI
+ if (rdc()=='*') { lastcom |= 0200; }NEWLINEelse { lp--; }
+ if (lastcom&0200) {
+ itype |= STAR; ptype = (DSYM+ISYM)-ptype;
+ }
trypr:
- longpr=FALSE; eqcom=lastcom=='=';
+ longpr=0; eqcom=lastcom=='=';
switch (rdc()) {
case 'm':
{/*reset map data*/
- INT fcount;
- MAP *smap;
- UNION{MAP *m; L_INT *mp;}amap;
+ short fcount;
+ struct map *smap;
+ union{struct map *m; long *mp;}amap;
- IF eqcom THEN error(BADEQ); FI
+ if (eqcom) { error(BADEQ); }
smap=(itype&DSP?&datmap:&txtmap);
amap.m=smap; fcount=3;
- IF itype&STAR
- THEN amap.mp += 3;
- FI
- WHILE fcount-- ANDF expr(0)
- DO *(amap.mp)++ = expv; OD
- IF rdc()=='?' THEN smap->ufd=fsym;
- ELIF lastc == '/' THEN smap->ufd=fcor;
- ELSE lp--;
- FI
+ if (itype&STAR) {
+ amap.mp += 3;
+ }
+ while (fcount-- && expr(0)) { *(amap.mp)++ = expv; }
+ if (rdc()=='?') {
+ smap->ufd=fsym;
+ }
+ else if (lastc == '/') {
+ smap->ufd=fcor;
+ }
+ else {
+ lp--;
+ }
}
break;
case 'L':
- longpr=TRUE;
+ longpr=-1;
case 'l':
/*search for exp*/
- IF eqcom THEN error(BADEQ); FI
+ if (eqcom) { error(BADEQ); }
dotinc=(longpr?4:2); savdot=dot;
expr(1); locval=expv;
- IF expr(0) THEN locmsk=expv; ELSE locmsk = -1L; FI
- IF !longpr THEN locmsk &= 0xFFFF; locval &= 0xFFFF; FI
- LOOP w=get(dot,itype);
- IF errflg ORF mkfault ORF (w&locmsk)==locval THEN break; FI
+ if (expr(0)) { locmsk=expv; }NEWLINEelse { locmsk = -1L; }
+ if (!longpr) { locmsk &= 0xFFFF; locval &= 0xFFFF; }
+ for(;;) {
+ w=get(dot,itype);
+ if (errflg || mkfault || (w&locmsk)==locval) { break; }
dot=inkdot(dotinc);
- POOL
- IF errflg
- THEN dot=savdot; errflg=NOMATCH;
- FI
+ }
+ if (errflg) {
+ dot=savdot; errflg=NOMATCH;
+ }
psymoff(dot,ptype,"");
break;
case 'W':
- longpr=TRUE;
+ longpr=-1;
case 'w':
- IF eqcom THEN error(BADEQ); FI
+ if (eqcom) { error(BADEQ); }
wformat[0]=lastc; expr(1);
- REP savdot=dot; psymoff(dot,ptype,":%16t"); exform(1,wformat,itype,ptype);
+ do {
+ savdot=dot; psymoff(dot,ptype,":%16t"); exform(1,wformat,itype,ptype);
errflg=0; dot=savdot;
- IF longpr
- THEN put(dot,itype,expv);
- ELSE put(dot,itype,itol(get(dot+2,itype),expv));
- FI
+ if (longpr) {
+ put(dot,itype,expv);
+ }
+ else {
+ put(dot,itype,itol(get(dot+2,itype),expv));
+ }
savdot=dot;
- printf("=%8t"); exform(1,wformat,itype,ptype);
+ _printf("=%8t"); exform(1,wformat,itype,ptype);
newline();
- PER expr(0) ANDF errflg==0 DONE
+ } while (expr(0) && errflg==0);
dot=savdot;
chkerr();
break;
default:
lp--;
getformat(eqcom ? eqformat : stformat);
- IF !eqcom
- THEN psymoff(dot,ptype,":%16t");
- FI
+ if (!eqcom) {
+ psymoff(dot,ptype,":%16t");
+ }
scanform(cntval,(eqcom?eqformat:stformat),itype,ptype);
}
break;
case '>':
lastcom=0; savc=rdc();
- IF regptr=getreg(savc)
- THEN IF kcore THEN
+ if (regptr=getreg(savc)) {
+ if (kcore) {
+
*(int *)regptr = dot;
- ELSE
- *(ADDR *)(((ADDR)&u)+regptr) = dot;
- ptrace(PT_WRITE_U, pid, regptr,
- *(ADDR *)(((ADDR)&u)+regptr));
- FI
- ELIF (modifier=varchk(savc)) != -1
- THEN var[modifier]=dot;
- ELSE error(BADVAR);
- FI
+ }
+ else {
+
+ *(intptr_t *)(((intptr_t)&u)+regptr) = dot;
+ ptrace(PT_WRITE_U, pid, regptr,
+ *(intptr_t *)(((intptr_t)&u)+regptr));
+ }
+ }
+ else if ((modifier=varchk(savc)) != -1) {
+ var[modifier]=dot;
+ }
+ else {
+ error(BADVAR);
+ }
break;
case '!':
printtrace(nextchar()); break;
case ':':
- IF !executing
- THEN executing=TRUE;
+ if (!executing) {
+ executing=-1;
subpcs(nextchar());
- executing=FALSE;
+ executing=0;
lastcom=0;
- FI
+ }
break;
case 0:
}
flushbuf();
- PER rdc()==';' DONE
- IF buf THEN lp=savlp; ELSE lp--; FI
- return(adrflg ANDF dot!=0);
+ } while (rdc()==';');
+ if (buf) { lp=savlp; }NEWLINEelse { lp--; }
+ return(adrflg && dot!=0);
}
#include "mode.h"
#include "head.h"
-/* access modes */
+/* _access modes */
#define RD 0
#define WT 1
#define NSP 0
-#define ISP 1
+#define _ISP 1
#define DSP 2
#define STAR 4
#define STARCOM 0200
#define BKPTSET 1
#define BKPTEXEC 2
-#define USERPS PSL
-#define USERPC PC
+#define USERPS _PSL
+#define USERPC _PC
#define BPT 03
#define TBIT 020
#define FD 0200
/* the quantities involving ctob() are located in the kernel stack. */
/* the others are in the pcb. */
-#define KSP 0
-#define ESP 4
-#define SSP 8
-#define USP (ctob(UPAGES)-5*sizeof(int))
-#define R0 (ctob(UPAGES)-18*sizeof(int))
-#define R1 (ctob(UPAGES)-17*sizeof(int))
-#define R2 (ctob(UPAGES)-16*sizeof(int))
-#define R3 (ctob(UPAGES)-15*sizeof(int))
-#define R4 (ctob(UPAGES)-14*sizeof(int))
-#define R5 (ctob(UPAGES)-13*sizeof(int))
-#define R6 (ctob(UPAGES)-12*sizeof(int))
-#define R7 (ctob(UPAGES)-11*sizeof(int))
-#define R8 (ctob(UPAGES)-10*sizeof(int))
-#define R9 (ctob(UPAGES)-9*sizeof(int))
-#define R10 (ctob(UPAGES)-8*sizeof(int))
-#define R11 (ctob(UPAGES)-7*sizeof(int))
-#define AP (ctob(UPAGES)-21*sizeof(int))
-#define FP (ctob(UPAGES)-20*sizeof(int))
-#define PC (ctob(UPAGES)-2*sizeof(int))
-#define PSL (ctob(UPAGES)-1*sizeof(int))
-#define P0BR 80
-#define P0LR 84
-#define P1BR 88
-#define P1LR 92
+#define _KSP 0
+#define _ESP 4
+#define _SSP 8
+#define _USP (ctob(UPAGES)-5*sizeof(int))
+#define _R0 (ctob(UPAGES)-18*sizeof(int))
+#define _R1 (ctob(UPAGES)-17*sizeof(int))
+#define _R2 (ctob(UPAGES)-16*sizeof(int))
+#define _R3 (ctob(UPAGES)-15*sizeof(int))
+#define _R4 (ctob(UPAGES)-14*sizeof(int))
+#define _R5 (ctob(UPAGES)-13*sizeof(int))
+#define _R6 (ctob(UPAGES)-12*sizeof(int))
+#define _R7 (ctob(UPAGES)-11*sizeof(int))
+#define _R8 (ctob(UPAGES)-10*sizeof(int))
+#define _R9 (ctob(UPAGES)-9*sizeof(int))
+#define _R10 (ctob(UPAGES)-8*sizeof(int))
+#define _R11 (ctob(UPAGES)-7*sizeof(int))
+#define _AP (ctob(UPAGES)-21*sizeof(int))
+#define _FP (ctob(UPAGES)-20*sizeof(int))
+#define _PC (ctob(UPAGES)-2*sizeof(int))
+#define _PSL (ctob(UPAGES)-1*sizeof(int))
+#define _P0BR 80
+#define _P0LR 84
+#define _P1BR 88
+#define _P1LR 92
#define MAXOFF 255
#define MAXPOS 80
/* long to ints and back (puns) */
union {
- INT I[2];
- L_INT L;
+ short I[2];
+ long L;
} itolws;
#ifndef vax
#endif
/* result type declarations */
-L_INT inkdot();
-POS get();
-POS chkget();
-STRING exform();
-L_INT round();
-BKPTR scanbkpt();
-VOID fault();
+long inkdot();
+unsigned get();
+unsigned chkget();
+char*CHECKME exform();
+long round();
+struct bkpt*CHECKME scanbkpt();
+void fault();
struct pcb pcb;
int kernel;
#include "defs.h"
-MSG BADSYM;
-MSG BADVAR;
-MSG BADKET;
-MSG BADSYN;
-MSG NOCFN;
-MSG NOADR;
-MSG BADLOC;
+char BADSYM[];
+char BADVAR[];
+char BADKET[];
+char BADSYN[];
+char NOCFN[];
+char NOADR[];
+char BADLOC[];
-ADDR lastframe;
-ADDR savlastf;
-ADDR savframe;
-ADDR savpc;
-ADDR callpc;
+intptr_t lastframe;
+intptr_t savlastf;
+intptr_t savframe;
+intptr_t savpc;
+intptr_t callpc;
-CHAR *lp;
-INT radix;
-STRING errflg;
-L_INT localval;
-CHAR isymbol[1024];
+char *lp;
+short radix;
+char *errflg;
+long localval;
+char isymbol[1024];
-CHAR lastc,peekc;
+char lastc,peekc;
-L_INT dot;
-L_INT ditto;
-INT dotinc;
-L_INT var[];
-L_INT expv;
+long dot;
+long ditto;
+short dotinc;
+long var[];
+long expv;
expr(a)
{ /* term | term dyadic expr | */
- INT rc;
- L_INT lhs;
+ short rc;
+ long lhs;
rdc(); lp--; rc=term(a);
- WHILE rc
- DO lhs = expv;
+ while (rc) {
+ lhs = expv;
switch ((int)readchar()) {
term(a|1); expv |= lhs; break;
case ')':
- IF (a&2)==0 THEN error(BADKET); FI
+ if ((a&2)==0) { error(BADKET); }
default:
lp--;
return(rc);
}
- OD
+ }
return(rc);
}
term(a|1); expv=chkget(expv,DSP); return(1);
case '@':
- term(a|1); expv=chkget(expv,ISP); return(1);
+ term(a|1); expv=chkget(expv,_ISP); return(1);
case '-':
term(a|1); expv = -expv; return(1);
case '(':
expr(2);
- IF *lp!=')'
- THEN error(BADSYN);
- ELSE lp++; return(1);
- FI
+ if (*lp!=')') {
+ error(BADSYN);
+ }
+ else {
+ lp++; return(1);
+ }
default:
lp--;
item(a)
{ /* name [ . local ] | number | . | ^ | <var | <register | 'x | | */
- INT base, d;
- CHAR savc;
- BOOL hex;
- L_INT frame;
+ short base, d;
+ char savc;
+ bool hex;
+ long frame;
register struct nlist *symp;
int regptr;
- hex=FALSE;
+ hex=0;
readchar();
- IF symchar(0)
- THEN readsym();
- IF lastc=='.'
- THEN frame= *(ADDR *)(((ADDR)&u)+FP); lastframe=0;
- callpc= *(ADDR *)(((ADDR)&u)+PC);
- WHILE errflg==0
- DO savpc=callpc;
+ if (symchar(0)) {
+ readsym();
+ if (lastc=='.') {
+ frame= *(intptr_t *)(((intptr_t)&u)+_FP); lastframe=0;
+ callpc= *(intptr_t *)(((intptr_t)&u)+_PC);
+ while (errflg==0) {
+ savpc=callpc;
findsym(callpc,ISYM);
- IF eqsym(cursym->n_un.n_name,isymbol,'~')
- THEN break;
- FI
+ if (eqsym(cursym->n_un.n_name,isymbol,'~')) {
+ break;
+ }
callpc=get(frame+16, DSP);
lastframe=frame;
- frame=get(frame+12,DSP)&EVEN;
- IF frame==0
- THEN error(NOCFN);
- FI
- OD
+ frame=get(frame+12,DSP)&-2;
+ if (frame==0) {
+ error(NOCFN);
+ }
+ }
savlastf=lastframe; savframe=frame;
readchar();
- IF symchar(0)
- THEN chkloc(expv=frame);
- FI
- ELIF (symp=lookup(isymbol))==0 THEN error(BADSYM);
- ELSE expv = symp->n_value;
- FI
+ if (symchar(0)) {
+ chkloc(expv=frame);
+ }
+ }
+ else if ((symp=lookup(isymbol))==0) {
+ error(BADSYM);
+ }
+ else {
+ expv = symp->n_value;
+ }
lp--;
- ELIF getnum(readchar)
- THEN ;
- ELIF lastc=='.'
- THEN readchar();
- IF symchar(0)
- THEN lastframe=savlastf; callpc=savpc;
+ }
+ else if (getnum(readchar)) {
+ ;
+ }
+ else if (lastc=='.') {
+ readchar();
+ if (symchar(0)) {
+ lastframe=savlastf; callpc=savpc;
chkloc(savframe);
- ELSE expv=dot;
- FI
+ }
+ else {
+ expv=dot;
+ }
lp--;
- ELIF lastc=='"'
- THEN expv=ditto;
-
- ELIF lastc=='+'
- THEN expv=inkdot(dotinc);
-
- ELIF lastc=='^'
- THEN expv=inkdot(-dotinc);
-
- ELIF lastc=='<'
- THEN savc=rdc();
- IF regptr=getreg(savc)
- THEN IF kcore THEN expv = *(int *)regptr;
- ELSE expv= * (ADDR *)(((ADDR)&u)+regptr); FI
- ELIF (base=varchk(savc)) != -1
- THEN expv=var[base];
- ELSE error(BADVAR);
- FI
-
- ELIF lastc=='\''
- THEN d=4; expv=0;
- WHILE quotchar()
- DO IF d--
- THEN expv = (expv << 8) | lastc;
- ELSE error(BADSYN);
- FI
- OD
-
- ELIF a
- THEN error(NOADR);
- ELSE lp--; return(0);
- FI
+ }
+ else if (lastc=='"') {
+ expv=ditto;
+
+ }
+ else if (lastc=='+') {
+ expv=inkdot(dotinc);
+
+ }
+ else if (lastc=='^') {
+ expv=inkdot(-dotinc);
+
+ }
+ else if (lastc=='<') {
+ savc=rdc();
+ if (regptr=getreg(savc)) {
+ if (kcore) {
+ expv = *(int *)regptr;
+ }
+ else { expv= * (intptr_t *)(((intptr_t)&u)+regptr); }
+ }
+ else if ((base=varchk(savc)) != -1) {
+ expv=var[base];
+ }
+ else {
+ error(BADVAR);
+ }
+
+ }
+ else if (lastc=='\'') {
+ d=4; expv=0;
+ while (quotchar()) {
+ if (d--) {
+ expv = (expv << 8) | lastc;
+ }
+ else {
+ error(BADSYN);
+ }
+ }
+
+ }
+ else if (a) {
+ error(NOADR);
+ }
+ else {
+ lp--; return(0);
+ }
return(1);
}
/* service routines for expression reading */
getnum(rdf) int (*rdf)();
{
- INT base,d,frpt;
- BOOL hex;
- UNION{REAL r; L_INT i;} real;
- IF isdigit(lastc) ORF (hex=TRUE, lastc=='#' ANDF isxdigit((*rdf)()))
- THEN expv = 0;
+ short base,d,frpt;
+ bool hex;
+ union{float r; long i;} real;
+ if (isdigit(lastc) || (hex=-1, lastc=='#' && isxdigit((*rdf)()))) {
+ expv = 0;
base = (hex ? 16 : radix);
- WHILE (base>10 ? isxdigit(lastc) : isdigit(lastc))
- DO expv = (base==16 ? expv<<4 : expv*base);
- IF (d=convdig(lastc))>=base THEN error(BADSYN); FI
+ while ((base>10 ? isxdigit(lastc) : isdigit(lastc))) {
+ expv = (base==16 ? expv<<4 : expv*base);
+ if ((d=convdig(lastc))>=base) { error(BADSYN); }
expv += d; (*rdf)();
- IF expv==0
- THEN IF (lastc=='x' ORF lastc=='X')
- THEN hex=TRUE; base=16; (*rdf)();
- ELIF (lastc=='t' ORF lastc=='T')
- THEN hex=FALSE; base=10; (*rdf)();
- ELIF (lastc=='o' ORF lastc=='O')
- THEN hex=FALSE; base=8; (*rdf)();
- FI
- FI
- OD
- IF lastc=='.' ANDF (base==10 ORF expv==0) ANDF !hex
- THEN real.r=expv; frpt=0; base=10;
- WHILE isdigit((*rdf)())
- DO real.r *= base; frpt++;
+ if (expv==0) {
+ if ((lastc=='x' || lastc=='X')) {
+ hex=-1; base=16; (*rdf)();
+ }
+ else if ((lastc=='t' || lastc=='T')) {
+ hex=0; base=10; (*rdf)();
+ }
+ else if ((lastc=='o' || lastc=='O')) {
+ hex=0; base=8; (*rdf)();
+ }
+ }
+ }
+ if (lastc=='.' && (base==10 || expv==0) && !hex) {
+ real.r=expv; frpt=0; base=10;
+ while (isdigit((*rdf)())) {
+ real.r *= base; frpt++;
real.r += lastc-'0';
- OD
- WHILE frpt--
- DO real.r /= base; OD
+ }
+ while (frpt--) { real.r /= base; }
expv = real.i;
- FI
+ }
peekc=lastc;
/* lp--; */
return(1);
- ELSE return(0);
- FI
+ }
+ else {
+ return(0);
+ }
}
readsym()
{
- REG char *p;
+ register char *p;
p = isymbol;
- REP IF p < &isymbol[sizeof(isymbol)-1]
- THEN *p++ = lastc;
- FI
+ do {
+ if (p < &isymbol[sizeof(isymbol)-1]) {
+ *p++ = lastc;
+ }
readchar();
- PER symchar(1) DONE
+ } while (symchar(1));
*p++ = 0;
}
convdig(c)
-CHAR c;
+char c;
{
- IF isdigit(c)
- THEN return(c-'0');
- ELIF isxdigit(c)
- THEN return(c-'a'+10);
- ELSE return(17);
- FI
+ if (isdigit(c)) {
+ return(c-'0');
+ }
+ else if (isxdigit(c)) {
+ return(c-'a'+10);
+ }
+ else {
+ return(17);
+ }
}
symchar(dig)
{
- IF lastc=='\\' THEN readchar(); return(TRUE); FI
- return( isalpha(lastc) ORF lastc=='_' ORF dig ANDF isdigit(lastc) );
+ if (lastc=='\\') { readchar(); return(-1); }
+ return( isalpha(lastc) || lastc=='_' || dig && isdigit(lastc) );
}
varchk(name)
{
- IF isdigit(name) THEN return(name-'0'); FI
- IF isalpha(name) THEN return((name&037)-1+10); FI
+ if (isdigit(name)) { return(name-'0'); }
+ if (isalpha(name)) { return((name&037)-1+10); }
return(-1);
}
chkloc(frame)
-L_INT frame;
+long frame;
{
readsym();
- REP IF localsym(frame)==0 THEN error(BADLOC); FI
+ do {
+ if (localsym(frame)==0) { error(BADLOC); }
expv=localval;
- PER !eqsym(cursym->n_un.n_name,isymbol,'~') DONE
+ } while (!eqsym(cursym->n_un.n_name,isymbol,'~'));
}
eqsym(s1, s2, c)
#include "defs.h"
-MSG BADMOD;
-MSG NOFORK;
-MSG ADWRAP;
-
-INT mkfault;
-CHAR *lp;
-L_INT maxoff;
-ADDR sigint;
-ADDR sigqit;
-STRING errflg;
-CHAR lastc,peekc;
-L_INT dot;
-INT dotinc;
-L_INT expv;
-L_INT var[];
-
-
-STRING fphack;
+char BADMOD[];
+char NOFORK[];
+char ADWRAP[];
+
+short mkfault;
+char *lp;
+long maxoff;
+intptr_t sigint;
+intptr_t sigqit;
+char *errflg;
+char lastc,peekc;
+long dot;
+short dotinc;
+long expv;
+long var[];
+
+
+char *fphack;
rdfp()
{
return(lastc= *fphack++);
}
scanform(icount,ifp,itype,ptype)
-L_INT icount;
-STRING ifp;
+long icount;
+char *ifp;
{
- STRING fp;
- CHAR modifier;
- INT fcount, init=1;
- L_INT savdot;
- BOOL exact;
- BOOL doit = 1;
-
- WHILE icount
- DO fp=ifp;
+ char *fp;
+ char modifier;
+ short fcount, init=1;
+ long savdot;
+ bool exact;
+ bool doit = 1;
+
+ while (icount) {
+ fp=ifp;
savdot=dot; init=0;
- IF init==0 ANDF (exact=(findsym(dot,ptype)==0)) ANDF maxoff
- THEN printf("\n%s:%16t",cursym->n_un.n_name);
- FI
+ if (init==0 && (exact=(findsym(dot,ptype)==0)) && maxoff) {
+ _printf("\n%s:%16t",cursym->n_un.n_name);
+ }
/*now loop over format*/
- WHILE *fp ANDF errflg==0
- DO IF digit(modifier = *fp)
- THEN fcount = 0;
- WHILE digit(modifier = *fp++)
- DO fcount *= 10;
+ while (*fp && errflg==0) {
+ if (digit(modifier = *fp)) {
+ fcount = 0;
+ while (digit(modifier = *fp++)) {
+ fcount *= 10;
fcount += modifier-'0';
- OD
+ }
fp--;
- IF fcount==0 THEN fcount = 1; FI
- ELSE fcount = 1;
- FI
-
- IF *fp==0 THEN break; FI
- IF exact ANDF dot==savdot ANDF itype==ISP ANDF cursym->n_un.n_name[0]=='_' ANDF *fp=='i'
- THEN exform(1,"x",itype,ptype); fp++; printc(EOR); /* entry mask */
- ELSE fp=exform(fcount,fp,itype,ptype);
- FI
- OD
+ if (fcount==0) { fcount = 1; }
+ }
+ else {
+ fcount = 1;
+ }
+
+ if (*fp==0) { break; }
+ if (exact && dot==savdot && itype==_ISP && cursym->n_un.n_name[0]=='_' && *fp=='i') {
+ exform(1,"x",itype,ptype); fp++; printc('\n'); /* entry mask */
+ }
+ else {
+ fp=exform(fcount,fp,itype,ptype);
+ }
+ }
dotinc=dot-savdot;
dot=savdot;
- IF errflg
- THEN IF icount<0
- THEN errflg=0; break;
- ELSE error(errflg);
- FI
- FI
- IF --icount
- THEN dot=inkdot(dotinc);
- FI
- IF mkfault THEN error(0); FI
- OD
+ if (errflg) {
+ if (icount<0) {
+ errflg=0; break;
+ }
+ else {
+ error(errflg);
+ }
+ }
+ if (--icount) {
+ dot=inkdot(dotinc);
+ }
+ if (mkfault) { error(0); }
+ }
}
-STRING
+char*CHECKME
exform(fcount,ifp,itype,ptype)
-INT fcount;
-STRING ifp;
+short fcount;
+char *ifp;
{
/* execute single format item `fcount' times
* sets `dotinc' and moves `dot'
* returns address of next format item
*/
- POS w;
- L_INT savdot, wx;
- STRING fp;
- CHAR c, modifier, longpr;
- L_REAL fw;
+ unsigned w;
+ long savdot, wx;
+ char *fp;
+ char c, modifier, longpr;
+ double fw;
struct{
- L_INT sa;
- INT sb,sc;
+ long sa;
+ short sb,sc;
};
- WHILE fcount>0
- DO fp = ifp; c = *fp;
+ while (fcount>0) {
+ fp = ifp; c = *fp;
longpr=(c>='A')&(c<='Z')|(c=='f')|(c=='4')|(c=='p');
- IF itype==NSP ORF *fp=='a'
- THEN wx=dot; w=dot;
- ELSE w=get(dot,itype);
- IF longpr
- THEN wx=itol(get(inkdot(2),itype),w);
- ELSE wx=w;
- FI
- FI
- IF c=='F'
- THEN fw.sb=get(inkdot(4),itype);
+ if (itype==NSP || *fp=='a') {
+ wx=dot; w=dot;
+ }
+ else {
+ w=get(dot,itype);
+ if (longpr) {
+ wx=itol(get(inkdot(2),itype),w);
+ }
+ else {
+ wx=w;
+ }
+ }
+ if (c=='F') {
+ fw.sb=get(inkdot(4),itype);
fw.sc=get(inkdot(6),itype);
- FI
- IF errflg THEN return(fp); FI
- IF mkfault THEN error(0); FI
+ }
+ if (errflg) { return(fp); }
+ if (mkfault) { error(0); }
var[0]=wx;
modifier = *fp++;
dotinc=(longpr?4:2);;
- IF charpos()==0 ANDF modifier!='a' THEN printf("%16m"); FI
+ if (charpos()==0 && modifier!='a') { _printf("%16m"); }
switch(modifier) {
- case SP: case TB:
+ case ' ': case '\t':
break;
case 't': case 'T':
- printf("%T",fcount); return(fp);
+ _printf("%T",fcount); return(fp);
case 'r': case 'R':
- printf("%M",fcount); return(fp);
+ _printf("%M",fcount); return(fp);
case 'a':
psymoff(dot,ptype,":%16t"); dotinc=0; break;
psymoff(var[0],ptype,"%16t"); break;
case 'u':
- printf("%-8u",w); break;
+ _printf("%-8u",w); break;
case 'U':
- printf("%-16U",wx); break;
+ _printf("%-16U",wx); break;
case 'c': case 'C':
- IF modifier=='C'
- THEN printesc(w&LOBYTE);
- ELSE printc(w&LOBYTE);
- FI
+ if (modifier=='C') {
+ printesc(w&0377);
+ }
+ else {
+ printc(w&0377);
+ }
dotinc=1; break;
case 'b': case 'B':
- printf("%-8o", w&LOBYTE); dotinc=1; break;
+ _printf("%-8o", w&0377); dotinc=1; break;
case '1':
- printf("%-8r", w&LOBYTE); dotinc=1; break;
+ _printf("%-8r", w&0377); dotinc=1; break;
case '2':
case 'w':
- printf("%-8r", w); break;
+ _printf("%-8r", w); break;
case '4':
case 'W':
- printf("%-16R", wx); break;
+ _printf("%-16R", wx); break;
case 's': case 'S':
savdot=dot; dotinc=1;
- WHILE (c=get(dot,itype)&LOBYTE) ANDF errflg==0
- DO dot=inkdot(1);
- IF modifier == 'S'
- THEN printesc(c);
- ELSE printc(c);
- FI
+ while ((c=get(dot,itype)&0377) && errflg==0) {
+ dot=inkdot(1);
+ if (modifier == 'S') {
+ printesc(c);
+ }
+ else {
+ printc(c);
+ }
endline();
- OD
+ }
dotinc=dot-savdot+1; dot=savdot; break;
case 'x':
- printf("%-8x",w); break;
+ _printf("%-8x",w); break;
case 'X':
- printf("%-16X", wx); break;
+ _printf("%-16X", wx); break;
case 'Y':
- printf("%-24Y", wx); break;
+ _printf("%-24Y", wx); break;
case 'q':
- printf("%-8q", w); break;
+ _printf("%-8q", w); break;
case 'Q':
- printf("%-16Q", wx); break;
+ _printf("%-16Q", wx); break;
case 'o':
- printf("%-8o", w); break;
+ _printf("%-8o", w); break;
case 'O':
- printf("%-16O", wx); break;
+ _printf("%-16O", wx); break;
case 'i':
- printins(0,itype,w); printc(EOR); break;
+ printins(0,itype,w); printc('\n'); break;
case 'd':
- printf("%-8d", w); break;
+ _printf("%-8d", w); break;
case 'D':
- printf("%-16D", wx); break;
+ _printf("%-16D", wx); break;
case 'f':
fw = 0;
fw.sa = wx;
- IF (wx & ~0xFFFF00FF) == 0x8000
- THEN printf("(reserved oprnd)");
- ELSE printf("%-16.9f", fw);
- FI
+ if ((wx & ~0xFFFF00FF) == 0x8000) {
+ _printf("(reserved oprnd)");
+ }
+ else {
+ _printf("%-16.9f", fw);
+ }
dotinc=4; break;
case 'F':
fw.sa = wx;
- IF (wx & ~0xFFFF00FF) == 0x8000
- THEN printf("%-32s", "(reserved oprnd)");
- ELSE printf("%-32.18F", fw);
- FI
+ if ((wx & ~0xFFFF00FF) == 0x8000) {
+ _printf("%-32s", "(reserved oprnd)");
+ }
+ else {
+ _printf("%-32.18F", fw);
+ }
dotinc=8; break;
case 'n': case 'N':
case '"':
dotinc=0;
- WHILE *fp != '"' ANDF *fp
- DO printc(*fp++); OD
- IF *fp THEN fp++; FI
+ while (*fp != '"' && *fp) { printc(*fp++); }
+ if (*fp) { fp++; }
break;
case '^':
default: error(BADMOD);
}
- IF itype!=NSP
- THEN dot=inkdot(dotinc);
- FI
+ if (itype!=NSP) {
+ dot=inkdot(dotinc);
+ }
fcount--; endline();
- OD
+ }
return(fp);
}
shell()
{
#ifndef EDDT
- INT rc, status, unixpid;
- STRING argp = lp;
- STRING getenv(), shell = getenv("SHELL");
+ short rc, status, unixpid;
+ char*CHECKME argp = lp;
+ char*CHECKME getenv(), shell = getenv("SHELL");
#ifdef VFORK
char oldstlp;
#endif
if (shell == 0)
shell = "/bin/sh";
- WHILE lastc!=EOR DO rdc(); OD
+ while (lastc!='\n') { rdc(); }
#ifndef VFORK
- IF (unixpid=fork())==0
+ if ((unixpid=fork())==0
#else
oldstlp = *lp;
- IF (unixpid=vfork())==0
-#endif
- THEN signal(SIGINT,sigint); signal(SIGQUIT,sigqit);
+ if ((unixpid=vfork())==0
+#endif) {
+ signal(SIGINT,sigint); signal(SIGQUIT,sigqit);
*lp=0; execl(shell, "sh", "-c", argp, 0);
_exit(16);
#ifndef VFORK
- ELIF unixpid == -1
+ }
+ else if (unixpid == -1
#else
- ELIF *lp = oldstlp, unixpid == -1
-#endif
- THEN error(NOFORK);
- ELSE signal(SIGINT,1);
- WHILE (rc = wait(&status)) != unixpid ANDF rc != -1 DONE
+ }
+ else if (*lp = oldstlp, unixpid == -1
+#endif) {
+ error(NOFORK);
+ }
+ else {
+ signal(SIGINT,1);
+ while ((rc = wait(&status)) != unixpid && rc != -1);
signal(SIGINT,sigint);
prints("!"); lp--;
- FI
+ }
#endif
}
printesc(c)
{
- c &= STRIP;
- IF c==0177 THEN printf("^?");
- ELIF c<SP
- THEN printf("^%c", c + '@');
- ELSE printc(c);
- FI
+ c &= 0177;
+ if (c==0177) {
+ _printf("^?");
+ }
+ else if (c<' ') {
+ _printf("^%c", c + '@');
+ }
+ else {
+ printc(c);
+ }
}
-L_INT inkdot(incr)
+long inkdot(incr)
{
- L_INT newdot;
+ long newdot;
newdot=dot+incr;
- IF (dot NEQ newdot) >> 24 THEN error(ADWRAP); FI
+ if ((dot ^ newdot) >> 24) { error(ADWRAP); }
return(newdot);
}
/* head.h 4.1 81/05/14 */
-ADDR maxoff;
-ADDR localval;
+intptr_t maxoff;
+intptr_t localval;
struct nlist *symtab, *esymtab;
struct nlist *cursym;
int xargc;
-MAP txtmap;
-MAP datmap;
-INT wtflag;
-INT fcor;
-INT fsym;
-L_INT maxfile;
-L_INT maxstor;
-INT signo;
+struct map txtmap;
+struct map datmap;
+short wtflag;
+short fcor;
+short fsym;
+long maxfile;
+long maxstor;
+short signo;
union {
struct user U;
#include "defs.h"
-INT mkfault;
-CHAR line[LINSIZ];
-INT infile;
-CHAR *lp;
-CHAR peekc,lastc = EOR;
-INT eof;
+short mkfault;
+char line[LINSIZ];
+short infile;
+char *lp;
+char peekc,lastc = '\n';
+short eof;
/* input routines */
eol(c)
-CHAR c;
+char c;
{
- return(c==EOR ORF c==';');
+ return(c=='\n' || c==';');
}
rdc()
-{ REP readchar();
- PER lastc==SP ORF lastc==TB
- DONE
+{ do {NEWLINE readchar();
+ } while (lastc==' ' || lastc=='\t');
return(lastc);
}
readchar()
{
- IF eof
- THEN lastc=0;
- ELSE IF lp==0
- THEN lp=line;
- REP eof = read(infile,lp,1)==0;
- IF mkfault THEN error(0); FI
- PER eof==0 ANDF *lp++!=EOR DONE
+ if (eof) {
+ lastc=0;
+ }
+ else {
+ if (lp==0) {
+ lp=line;
+ do {
+ eof = read(infile,lp,1)==0;
+ if (mkfault) { error(0); }
+ } while (eof==0 && *lp++!='\n');
*lp=0; lp=line;
- FI
- IF lastc = peekc THEN peekc=0;
- ELIF lastc = *lp THEN lp++;
- FI
- FI
+ }
+ if (lastc = peekc) {
+ peekc=0;
+ }
+ else if (lastc = *lp) {
+ lp++;
+ }
+ }
return(lastc);
}
nextchar()
{
- IF eol(rdc())
- THEN lp--; return(0);
- ELSE return(lastc);
- FI
+ if (eol(rdc())) {
+ lp--; return(0);
+ }
+ else {
+ return(lastc);
+ }
}
quotchar()
{
- IF readchar()=='\\'
- THEN return(readchar());
- ELIF lastc=='\''
- THEN return(0);
- ELSE return(lastc);
- FI
+ if (readchar()=='\\') {
+ return(readchar());
+ }
+ else if (lastc=='\'') {
+ return(0);
+ }
+ else {
+ return(lastc);
+ }
}
getformat(deformat)
-STRING deformat;
+char *deformat;
{
- REG STRING fptr;
- REG BOOL quote;
- fptr=deformat; quote=FALSE;
- WHILE (quote ? readchar()!=EOR : !eol(readchar()))
- DO IF (*fptr++ = lastc)=='"'
- THEN quote = ~quote;
- FI
- OD
+ register char *fptr;
+ register bool quote;
+ fptr=deformat; quote=0;
+ while ((quote ? readchar()!='\n' : !eol(readchar()))) {
+ if ((*fptr++ = lastc)=='"') {
+ quote = ~quote;
+ }
+ }
lp--;
- IF fptr!=deformat THEN *fptr++ = '\0'; FI
+ if (fptr!=deformat) { *fptr++ = '\0'; }
}
*/
#include "defs.h"
-MSG NOEOR;
+char NOEOR[];
-INT mkfault;
-INT executing;
-INT infile;
-CHAR *lp;
-L_INT maxoff;
-L_INT maxpos;
-ADDR sigint;
-ADDR sigqit;
-INT wtflag;
-L_INT maxfile;
-STRING errflg;
-L_INT exitflg;
+short mkfault;
+short executing;
+short infile;
+char *lp;
+long maxoff;
+long maxpos;
+intptr_t sigint;
+intptr_t sigqit;
+short wtflag;
+long maxfile;
+char *errflg;
+long exitflg;
-CHAR lastc;
-INT eof;
+char lastc;
+short eof;
-INT lastcom;
+short lastcom;
long maxoff = MAXOFF;
long maxpos = MAXPOS;
for (;;) {
flushbuf();
if (errflg) {
- printf("%s\n", errflg);
+ _printf("%s\n", errflg);
exitflg = errflg;
errflg = 0;
}
exit(exitflg);
}
-L_INT
+long
round(a,b)
-REG L_INT a, b;
+register long a, b;
{
- REG L_INT w;
+ register long w;
w = (a/b)*b;
- IF a!=w THEN w += b; FI
+ if (a!=w) { w += b; }
return(w);
}
#include "mac.h"
#include "mode.h"
-MSG VERSION = "\nVERSION VM/VAX4.3 DATE 8/11/83\n";
+char[]CHECKME VERSION = "\nVERSION VM/VAX4.3 DATE 8/11/83\n";
-MSG BADMOD = "bad modifier";
-MSG BADCOM = "bad command";
-MSG BADSYM = "symbol not found";
-MSG BADLOC = "automatic variable not found";
-MSG NOCFN = "c routine not found";
-MSG NOMATCH = "cannot locate value";
-MSG NOBKPT = "no breakpoint set";
-MSG BADKET = "unexpected ')'";
-MSG NOADR = "address expected";
-MSG NOPCS = "no process";
-MSG BADVAR = "bad variable";
-MSG EXBKPT = "too many breakpoints";
-MSG A68BAD = "bad a68 frame";
-MSG A68LNK = "bad a68 link";
-MSG ADWRAP = "address wrap around";
-MSG BADEQ = "unexpected `='";
-MSG BADWAIT = "wait error: process disappeared!";
-MSG ENDPCS = "process terminated";
-MSG NOFORK = "try again";
-MSG BADSYN = "syntax error";
-MSG NOEOR = "newline expected";
-MSG SZBKPT = "bkpt: command too long";
-MSG BADFIL = "bad file format";
-MSG BADNAM = "not enough space for symbols";
-MSG LONGFIL = "filename too long";
-MSG NOTOPEN = "cannot open";
-MSG BADMAG = "bad core magic number";
-MSG TOODEEP = "$<< nesting too deep";
+char[]CHECKME BADMOD = "bad modifier";
+char[]CHECKME BADCOM = "bad command";
+char[]CHECKME BADSYM = "symbol not found";
+char[]CHECKME BADLOC = "automatic variable not found";
+char[]CHECKME NOCFN = "c routine not found";
+char[]CHECKME NOMATCH = "cannot locate value";
+char[]CHECKME NOBKPT = "no breakpoint set";
+char[]CHECKME BADKET = "unexpected ')'";
+char[]CHECKME NOADR = "address expected";
+char[]CHECKME NOPCS = "no process";
+char[]CHECKME BADVAR = "bad variable";
+char[]CHECKME EXBKPT = "too many breakpoints";
+char[]CHECKME A68BAD = "bad a68 frame";
+char[]CHECKME A68LNK = "bad a68 link";
+char[]CHECKME ADWRAP = "address wrap around";
+char[]CHECKME BADEQ = "unexpected `='";
+char[]CHECKME BADWAIT = "wait error: process disappeared!";
+char[]CHECKME ENDPCS = "process terminated";
+char[]CHECKME NOFORK = "try again";
+char[]CHECKME BADSYN = "syntax error";
+char[]CHECKME NOEOR = "newline expected";
+char[]CHECKME SZBKPT = "bkpt: command too long";
+char[]CHECKME BADFIL = "bad file format";
+char[]CHECKME BADNAM = "not enough space for symbols";
+char[]CHECKME LONGFIL = "filename too long";
+char[]CHECKME NOTOPEN = "cannot open";
+char[]CHECKME BADMAG = "bad core magic number";
+char[]CHECKME TOODEEP = "$<< nesting too deep";
/* file address maps */
struct map {
- L_INT b1;
- L_INT e1;
- L_INT f1;
- L_INT b2;
- L_INT e2;
- L_INT f2;
- INT ufd;
+ long b1;
+ long e1;
+ long f1;
+ long b2;
+ long e2;
+ long f2;
+ short ufd;
};
struct bkpt {
- ADDR loc;
- ADDR ins;
- INT count;
- INT initcnt;
- INT flag;
- CHAR comm[MAXCOM];
- BKPT *nxtbkpt;
+ intptr_t loc;
+ intptr_t ins;
+ short count;
+ short initcnt;
+ short flag;
+ char comm[MAXCOM];
+ struct bkpt *nxtbkpt;
};
struct reglist {
- STRING rname;
- INT roffs;
+ char *rname;
+ short roffs;
int *rkern;
};
#include "head.h"
#endif SDB
-L_INT dot;
-INT dotinc;
-L_INT insoutvar[36];
+long dot;
+short dotinc;
+long insoutvar[36];
#ifdef ADB
-L_INT var[36];
+long var[36];
#endif ADB
#undef INSTTAB
#include "instrs.h"
-STRING regname[];
-STRING fltimm[];
-POS type, space, incp;
+char*CHECKME regname[];
+char*CHECKME fltimm[];
+unsigned type, space, incp;
/*
* Definitions for registers and for operand classes
*/
mkioptab()
{
- REG struct insttab *p;
+ register struct insttab *p;
int mapchar;
for(p = insttab; p->iname; p++){
char *indexreg; /* print of which register indexes */
char *indexed; /* we indexed */
char *operandout();
- REG u_char *ap;
- REG struct insttab *ip;
+ register u_char *ap;
+ register struct insttab *ip;
u_char optype;
int mapchar;
#ifdef SDB
procp = adrtoprocp(dot);
if (procp->paddr == dot){
- printf("0x%04.4x", ins);
+ _printf("0x%04.4x", ins);
incp = 2;
goto ret;
}
}
}
if (ioptab[mapchar][ins] == 0){
- printf("<undefined operator byte>: %x", ins);
+ _printf("<undefined operator byte>: %x", ins);
goto ret;
}
ip = &insttab[ioptab[mapchar][ins] - 1];
- printf("%s\t", ip->iname);
+ _printf("%s\t", ip->iname);
for (ap = ip->argtype, argno = 0; argno < ip->nargs; argno++, ap++) {
savevar(0x80000000); /* an illegal symbol */
}
indexreg = operandout(mode, optype);
if (indexed)
- printf("[%s]", indexed);
+ _printf("[%s]", indexed);
indexed = indexreg;
} while(indexed);
}
long limit;
{
int i;
- POS baseincp;
- POS advincp;
+ unsigned baseincp;
+ unsigned advincp;
struct as_number *valuep;
#define OSIZE (sizeof(short))
argno = 0;
baseincp = incp;
for (i = 0; i <= limit; i++) {
- printc(EOR);
+ printc('\n');
#ifdef SDB
- printf(" %d: ", i + base);
+ _printf(" %d: ", i + base);
#endif SDB
#ifdef ADB
- printf(" %R: ", i + base);
+ _printf(" %R: ", i + base);
#endif ADB
valuep = snarfreloc(OSIZE, 0);
advincp = incp;
numberp snarf(nbytes)
int nbytes;
{
- REG int i;
+ register int i;
static struct as_number backnumber;
static struct as_number znumber; /* init'ed to 0 */
case OC_INDEX:
return(r); /* will be printed later */
case OC_REG:
- printf("%s", r);
+ _printf("%s", r);
return(0);
case OC_DREG:
- printf("(%s)", r);
+ _printf("(%s)", r);
return(0);
case OC_ADREG:
- printf("-(%s)", r);
+ _printf("-(%s)", r);
return(0);
case OC_DAIREG:
printc('*');
if (regnumber == R_PC){
pcimmediate(mode, optype);
} else {
- printf("(%s)+", r);
+ _printf("(%s)+", r);
}
return(0);
case OC_DBDISP:
case OC_LDISP:
case OC_DLDISP:
if (regnumber == R_PC){
- /* PC offset addressing */
+ /* _PC offset addressing */
valuep->num_ulong[0] += inkdot(incp);
}
}
if (regnumber == R_PC)
psymoff(valuep->num_ulong[0], type, &insoutfmt[0]);
else { /* } */
- printf(LPRMODE, valuep->num_ulong[0]);
- printf(insoutfmt);
+ _printf(LPRMODE, valuep->num_ulong[0]);
+ _printf(insoutfmt);
#endif ADB
#ifdef SDB
if(psymoff(valuep->num_ulong[0], regnumber, &insoutfmt[0])
&& (regnumber != R_PC)){
#endif SDB
- printf("(%s)", insregname(regnumber));
+ _printf("(%s)", insregname(regnumber));
}
savevar((long)valuep->num_ulong[0]);
}
case TYPD:
case TYPG:
case TYPH:
- printf("$%s", fltimm[mode]);
+ _printf("$%s", fltimm[mode]);
break;
default:
#ifdef ADB
- printf("$%r", mode);
+ _printf("$%r", mode);
#endif ADB
#ifdef SDB
- printf("$%d", mode);
+ _printf("$%d", mode);
#endif SDB
break;
}
int nbytes;
printc('$');
- if (mode == OC_CONS(OC_DAIREG, R_PC)){ /* PC absolute, always 4 bytes*/
+ if (mode == OC_CONS(OC_DAIREG, R_PC)){ /* _PC absolute, always 4 bytes*/
dispaddress(snarfreloc(4), mode);
return;
}
{
numberp valuep;
int leading_zero = 1;
- REG int bindex;
- REG int nindex;
- REG int ch;
+ register int bindex;
+ register int nindex;
+ register int ch;
valuep = snarf(nbytes);
switch(A_TYPEXT(optype)){
case TYPF:
- printf("0f%f", valuep->num_num.numFf_float.Ff_value);
+ _printf("0f%f", valuep->num_num.numFf_float.Ff_value);
break;
case TYPD:
- printf("0d%f", valuep->num_num.numFd_float.Fd_value);
+ _printf("0d%f", valuep->num_num.numFd_float.Fd_value);
break;
case TYPG:
- printf("0g::"); goto qprint;
+ _printf("0g::"); goto qprint;
case TYPH:
- printf("0h::"); goto qprint;
+ _printf("0h::"); goto qprint;
case TYPQ:
case TYPO:
qprint:
}
#ifdef SDB
-L_INT inkdot(incr)
+long inkdot(incr)
int incr;
{
- L_INT newdot;
+ long newdot;
newdot = dot + incr;
return(newdot);
printc(c)
char c;
{
- printf("%c", c);
+ _printf("%c", c);
}
psymoff(v, regnumber, fmt)
- L_INT v;
+ long v;
char *fmt;
{
struct proct *procp;
- REG int diff;
+ register int diff;
if (fmt[0] == 'i') {
switch(regnumber){
case 12: /* parameter */
- if ((diff = adrtoparam((ADDR) v, adrtoprocp(dot)))
+ if ((diff = adrtoparam((intptr_t) v, adrtoprocp(dot)))
!= -1) {
- printf("%s", sl_name);
+ _printf("%s", sl_name);
prdiff(diff);
return(0);
}
break;
case 13: /* local */
- if ((diff = adrtolocal((ADDR) -v, adrtoprocp(dot))
+ if ((diff = adrtolocal((intptr_t) -v, adrtoprocp(dot))
) != -1) {
- printf("%s", sl_name);
+ _printf("%s", sl_name);
prdiff(diff);
return(0);
}
break;
}
if (v < firstdata) {
- if ((procp = adrtoprocp((ADDR) v)) != badproc) {
+ if ((procp = adrtoprocp((intptr_t) v)) != badproc) {
prlnoff(procp, v);
return(0);
}
} else {
- if ((diff = adrtoext((ADDR) v)) != -1) {
- printf("%s", sl_name);
+ if ((diff = adrtoext((intptr_t) v)) != -1) {
+ _printf("%s", sl_name);
prdiff(diff);
return(0);
}
prdiff(diff)
{
if (diff) {
- printf("+");
+ _printf("+");
prhex(diff);
}
}
1, "30",
1, "stty",
1, "gtty",
- 0, "access",
+ 0, "_access",
0, "nice",
0, "sleep",
0, "sync",
0, "63",
};
-STRING regname[] = { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
+char*CHECKME regname[] = { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
"r8", "r9", "r10","r11","ap", "fp", "sp", "pc"};
-STRING fltimm[] = {
+char*CHECKME fltimm[] = {
"0.5", "0.5625", "0.625", "0.6875", "0.75", "0.8125", "0.875", "0.9375",
"1.0", "1.125", "1.25", "1.375", "1.5", "1.625", "1.75", "1.875",
"2.0", "2.25", "2.5", "2.75", "3.0", "3.25", "3.5", "3.75",
};
#ifdef SDB
-REGLIST reglist [] = {
- "p1lr", P1LR,
- "p1br",P1BR,
- "p0lr", P0LR,
- "p0br",P0BR,
- "ksp",KSP,
- "esp",ESP,
- "ssp",SSP,
- "psl", PSL,
- "pc", PC,
- "usp",USP,
- "fp", FP,
- "ap", AP,
- "r11", R11,
- "r10", R10,
- "r9", R9,
- "r8", R8,
- "r7", R7,
- "r6", R6,
- "r5", R5,
- "r4", R4,
- "r3", R3,
- "r2", R2,
- "r1", R1,
- "r0", R0,
+struct reglist reglist [] = {
+ "p1lr", _P1LR,
+ "p1br",_P1BR,
+ "p0lr", _P0LR,
+ "p0br",_P0BR,
+ "ksp",_KSP,
+ "esp",_ESP,
+ "ssp",_SSP,
+ "psl", _PSL,
+ "pc", _PC,
+ "usp",_USP,
+ "fp", _FP,
+ "ap", _AP,
+ "r11", _R11,
+ "r10", _R10,
+ "r9", _R9,
+ "r8", _R8,
+ "r7", _R7,
+ "r6", _R6,
+ "r5", _R5,
+ "r4", _R4,
+ "r3", _R3,
+ "r2", _R2,
+ "r1", _R1,
+ "r0", _R0,
};
#endif SDB
#include <stdio.h>
-INT mkfault;
-INT infile;
-INT outfile = 1;
-L_INT maxpos;
-L_INT maxoff;
-INT radix = 16;
+short mkfault;
+short infile;
+short outfile = 1;
+long maxpos;
+long maxoff;
+short radix = 16;
-CHAR printbuf[MAXLIN];
-CHAR *printptr = printbuf;
-CHAR *digitptr;
-MSG TOODEEP;
+char printbuf[MAXLIN];
+char *printptr = printbuf;
+char *digitptr;
+char TOODEEP[];
eqstr(s1, s2)
- REG STRING s1, s2;
+ register char*CHECKME s1, s2;
{
- REG STRING es1;
- WHILE *s1++ == *s2
- DO IF *s2++ == 0
- THEN return(1);
- FI
- OD
+ register char *es1;
+ while (*s1++ == *s2) {
+ if (*s2++ == 0) {
+ return(1);
+ }
+ }
return(0);
}
length(s)
- REG STRING s;
+ register char *s;
{
- INT n = 0;
- WHILE *s++ DO n++; OD
+ short n = 0;
+ while (*s++) { n++; }
return(n);
}
printc(c)
- CHAR c;
+ char c;
{
- CHAR d;
- STRING q;
- INT posn, tabs, p;
+ char d;
+ char *q;
+ short posn, tabs, p;
- IF mkfault
- THEN return;
- ELIF (*printptr=c)==EOR
- THEN tabs=0; posn=0; q=printbuf;
- FOR p=0; p<printptr-printbuf; p++
- DO d=printbuf[p];
- IF (p&7)==0 ANDF posn
- THEN tabs++; posn=0;
- FI
- IF d==SP
- THEN posn++;
- ELSE WHILE tabs>0 DO *q++=TB; tabs--; OD
- WHILE posn>0 DO *q++=SP; posn--; OD
+ if (mkfault) {
+ return;
+ }
+ else if ((*printptr=c)=='\n') {
+ tabs=0; posn=0; q=printbuf;
+ for (p=0; p<printptr-printbuf; p++) {
+ d=printbuf[p];
+ if ((p&7)==0 && posn) {
+ tabs++; posn=0;
+ }
+ if (d==' ') {
+ posn++;
+ }
+ else {
+ while (tabs>0) { *q++='\t'; tabs--; }
+ while (posn>0) { *q++=' '; posn--; }
*q++=d;
- FI
- OD
- *q++=EOR;
+ }
+ }
+ *q++='\n';
#ifdef EDDT
printptr=printbuf; do putchar(*printptr++); while (printptr<q);
#else
write(outfile,printbuf,q-printbuf);
#endif
printptr=printbuf;
- ELIF c==TB
- THEN *printptr++=SP;
- WHILE (printptr-printbuf)&7 DO *printptr++=SP; OD
- ELIF c
- THEN printptr++;
- FI
- IF printptr >= &printbuf[MAXLIN-9] THEN
+ }
+ else if (c=='\t') {
+ *printptr++=' ';
+ while ((printptr-printbuf)&7) { *printptr++=' '; }
+ }
+ else if (c) {
+ printptr++;
+ }
+ if (printptr >= &printbuf[MAXLIN-9]) {
+
write(outfile, printbuf, printptr - printbuf);
printptr = printbuf;
- FI
+ }
}
charpos()
}
flushbuf()
-{ IF printptr!=printbuf
- THEN printc(EOR);
- FI
+{ if (printptr!=printbuf) {
+ printc('\n');
+ }
}
-printf(fmat,a1)
- STRING fmat;
- STRING *a1;
+_printf(fmat,a1)
+ char *fmat;
+ char*CHECKME *a1;
{
- STRING fptr, s;
- INT *vptr;
- L_INT *dptr;
- L_REAL *rptr;
- INT width, prec;
- CHAR c, adj;
- INT x, decpt, n;
- L_INT lx;
- CHAR digits[64];
+ char*CHECKME fptr, s;
+ short *vptr;
+ long *dptr;
+ double *rptr;
+ short width, prec;
+ char c, adj;
+ short x, decpt, n;
+ long lx;
+ char digits[64];
fptr = fmat; dptr = vptr = &a1;
- WHILE c = *fptr++
- DO IF c!='%'
- THEN printc(c);
- ELSE IF *fptr=='-' THEN adj='l'; fptr++; ELSE adj='r'; FI
+ while (c = *fptr++) {
+ if (c!='%') {
+ printc(c);
+ }
+ else {
+ if (*fptr=='-') { adj='l'; fptr++; }NEWLINEelse { adj='r'; }
width=convert(&fptr);
- IF *fptr=='.' THEN fptr++; prec=convert(&fptr); ELSE prec = -1; FI
+ if (*fptr=='.') { fptr++; prec=convert(&fptr); }NEWLINEelse { prec = -1; }
digitptr=digits;
#ifndef vax
dptr=rptr=vptr; lx = *dptr; x = *vptr++;
s=ecvt(*rptr, prec, &decpt, &n);
*digitptr++=(n?'-':'+');
*digitptr++ = (decpt<=0 ? '0' : *s++);
- IF decpt>0 THEN decpt--; FI
+ if (decpt>0) { decpt--; }
*digitptr++ = '.';
- WHILE *s ANDF prec-- DO *digitptr++ = *s++; OD
- WHILE *--digitptr=='0' DONE
+ while (*s && prec--) { *digitptr++ = *s++; }
+ while (*--digitptr=='0');
digitptr += (digitptr-digits>=3 ? 1 : 2);
- IF decpt
- THEN *digitptr++ = 'e'; printnum(decpt,'d',10);
- FI
+ if (decpt) {
+ *digitptr++ = 'e'; printnum(decpt,'d',10);
+ }
s=0; prec = -1; break;
#endif
#endif
width=x; break;
case 'T':
case 't':
- IF c=='T'
- THEN width=x;
+ if (c=='T') {
+ width=x;
#ifndef vax
- ELSE vptr--;
+ }
+ else {
+ vptr--;
#else
- ELSE dptr--;
+ }
+ else {
+ dptr--;
#endif
- FI
- IF width
- THEN width -= charpos()%width;
- FI
+ }
+ if (width) {
+ width -= charpos()%width;
+ }
break;
default:
#ifndef vax
#endif
}
- IF s==0
- THEN *digitptr=0; s=digits;
- FI
+ if (s==0) {
+ *digitptr=0; s=digits;
+ }
n=length(s);
- n=(prec<n ANDF prec>=0 ? prec : n);
+ n=(prec<n && prec>=0 ? prec : n);
width -= n;
- IF adj=='r'
- THEN WHILE width-- > 0
- DO printc(SP); OD
- FI
- WHILE n-- DO printc(*s++); OD
- WHILE width-- > 0 DO printc(SP); OD
+ if (adj=='r') {
+ while (width-- > 0) { printc(' '); }
+ }
+ while (n--) { printc(*s++); }
+ while (width-- > 0) { printc(' '); }
digitptr=digits;
- FI
- OD
+ }
+ }
}
printdate(tvec)
- L_INT tvec;
+ long tvec;
{
- REG INT i;
- REG STRING timeptr;
+ register short i;
+ register char *timeptr;
#ifndef EDDT
timeptr = ctime(&tvec);
#else
timeptr="????????????????????????";
#endif
- FOR i=20; i<24; i++ DO *digitptr++ = *(timeptr+i); OD
- FOR i=3; i<19; i++ DO *digitptr++ = *(timeptr+i); OD
+ for (i=20; i<24; i++) { *digitptr++ = *(timeptr+i); }
+ for (i=3; i<19; i++) { *digitptr++ = *(timeptr+i); }
} /*printdate*/
prints(s)
char *s;
-{ printf("%s",s);
+{ _printf("%s",s);
}
newline()
{
- printc(EOR);
+ printc('\n');
}
convert(cp)
-REG STRING *cp;
+register char*CHECKME *cp;
{
- REG CHAR c;
- INT n;
+ register char c;
+ short n;
n=0;
- WHILE ((c = *(*cp)++)>='0') ANDF (c<='9') DO n=n*10+c-'0'; OD
+ while (((c = *(*cp)++)>='0') && (c<='9')) { n=n*10+c-'0'; }
(*cp)--;
return(n);
}
printnum(n,fmat,base)
- REG INT n;
+ register short n;
{
- REG CHAR k;
- REG INT *dptr;
- INT digs[15];
+ register char k;
+ register short *dptr;
+ short digs[15];
dptr=digs;
- IF n<0 ANDF fmat=='d' THEN n = -n; *digitptr++ = '-'; FI
+ if (n<0 && fmat=='d') { n = -n; *digitptr++ = '-'; }
n &= 0xffff;
- WHILE n
- DO *dptr++ = ((POS)(n&0xffff))%base;
- n=((POS)(n&0xffff))/base;
- OD
- IF dptr==digs THEN *dptr++=0; FI
- WHILE dptr!=digs
- DO k = *--dptr;
+ while (n) {
+ *dptr++ = ((unsigned)(n&0xffff))%base;
+ n=((unsigned)(n&0xffff))/base;
+ }
+ if (dptr==digs) { *dptr++=0; }
+ while (dptr!=digs) {
+ k = *--dptr;
*digitptr++ = (k+(k<=9 ? '0' : 'a'-10));
- OD
+ }
}
printoct(o,s)
- L_INT o;
- INT s;
+ long o;
+ short s;
{
- INT i;
- L_INT po = o;
- CHAR digs[12];
+ short i;
+ long po = o;
+ char digs[12];
- IF s
- THEN IF po<0
- THEN po = -po; *digitptr++='-';
- ELSE IF s>0 THEN *digitptr++='+'; FI
- FI
- FI
- FOR i=0;i<=11;i++
- DO digs[i] = po&7; po >>= 3; OD
+ if (s) {
+ if (po<0) {
+ po = -po; *digitptr++='-';
+ }
+ else {
+ if (s>0) { *digitptr++='+'; }
+ }
+ }
+ for (i=0;i<=11;i++) { digs[i] = po&7; po >>= 3; }
digs[10] &= 03; digs[11]=0;
- FOR i=11;i>=0;i--
- DO IF digs[i] THEN break; FI OD
- FOR i++;i>=0;i--
- DO *digitptr++=digs[i]+'0'; OD
+ for (i=11;i>=0;i--) {
+ if (digs[i]) { break; } }
+ for (i++;i>=0;i--) { *digitptr++=digs[i]+'0'; }
}
#ifndef vax
printdbl(lx,ly,fmat,base)
-INT lx, ly; char fmat; int base;
+short lx, ly; char fmat; int base;
#else
printdbl(lxy,fmat,base)
-L_INT lxy; char fmat; int base;
+long lxy; char fmat; int base;
#endif
{ int digs[20]; int *dptr; char k;
#ifndef MULD2
sprintf(cp1,base==16 ? "%x" : "%D",lxy);
cp1=digs; while (*digitptr++= *cp1++); --digitptr;
#else
- L_REAL f ,g; long q;
+ double f ,g; long q;
#ifdef vax
- INT lx,ly;
+ short lx,ly;
ly=lxy; lx=(lxy>>16)&0xFFFF;
#endif
dptr=digs;
- IF fmat=='D' ORF fmat=='r'
- THEN f=itol(lx,ly);
- IF f<0 THEN *digitptr++='-'; f = -f; FI
- ELSE
- IF lx==-1
- THEN *digitptr++='-'; f=leng(-ly);
- ELSE f=leng(lx); f *= itol(1,0); f += leng(ly);
- FI
- IF fmat=='x' THEN *digitptr++='#'; FI
- FI
- WHILE f
- DO q=f/base; g=q;
+ if (fmat=='D' || fmat=='r') {
+ f=itol(lx,ly);
+ if (f<0) { *digitptr++='-'; f = -f; }
+ }
+ else {
+
+ if (lx==-1) {
+ *digitptr++='-'; f=leng(-ly);
+ }
+ else {
+ f=leng(lx); f *= itol(1,0); f += leng(ly);
+ }
+ if (fmat=='x') { *digitptr++='#'; }
+ }
+ while (f) {
+ q=f/base; g=q;
*dptr++ = f-g*base;
f=q;
- OD
- IF dptr==digs ORF dptr[-1]>9 THEN *dptr++=0; FI
- WHILE dptr!=digs
- DO k = *--dptr;
+ }
+ if (dptr==digs || dptr[-1]>9) { *dptr++=0; }
+ while (dptr!=digs) {
+ k = *--dptr;
*digitptr++ = (k+(k<=9 ? '0' : 'a'-10));
- OD
+ }
#endif
}
iclose(stack, err)
{
- IF err
- THEN IF infile
- THEN close(infile); infile=0;
- FI
- WHILE --ifiledepth >= 0
- DO IF istack[ifiledepth].fd
- THEN close(istack[ifiledepth].fd);
- FI
- OD
+ if (err) {
+ if (infile) {
+ close(infile); infile=0;
+ }
+ while (--ifiledepth >= 0) {
+ if (istack[ifiledepth].fd) {
+ close(istack[ifiledepth].fd);
+ }
+ }
ifiledepth = 0;
- ELIF stack == 0
- THEN IF infile
- THEN close(infile); infile=0;
- FI
- ELIF stack > 0
- THEN IF ifiledepth >= MAXIFD
- THEN error(TOODEEP);
- FI
+ }
+ else if (stack == 0) {
+ if (infile) {
+ close(infile); infile=0;
+ }
+ }
+ else if (stack > 0) {
+ if (ifiledepth >= MAXIFD) {
+ error(TOODEEP);
+ }
istack[ifiledepth].fd = infile;
istack[ifiledepth].r9 = var[9];
ifiledepth++;
infile = 0;
- ELSE IF infile
- THEN close(infile); infile=0;
- FI
- IF ifiledepth > 0
- THEN infile = istack[--ifiledepth].fd;
+ }
+ else {
+ if (infile) {
+ close(infile); infile=0;
+ }
+ if (ifiledepth > 0) {
+ infile = istack[--ifiledepth].fd;
var[9] = istack[ifiledepth].r9;
- FI
- FI
+ }
+ }
}
oclose()
{
- IF outfile!=1
- THEN flushbuf(); close(outfile); outfile=1;
- FI
+ if (outfile!=1) {
+ flushbuf(); close(outfile); outfile=1;
+ }
}
endline()
{
if (maxpos <= charpos())
- printf("\n");
+ _printf("\n");
}
#include "defs.h"
-MSG NOBKPT;
-MSG SZBKPT;
-MSG EXBKPT;
-MSG NOPCS;
-MSG BADMOD;
+char NOBKPT[];
+char SZBKPT[];
+char EXBKPT[];
+char NOPCS[];
+char BADMOD[];
/* breakpoints */
-BKPTR bkpthead;
+struct bkpt *bkpthead;
-CHAR *lp;
-CHAR lastc;
+char *lp;
+char lastc;
-INT signo;
-L_INT dot;
-INT pid;
-L_INT cntval;
-L_INT loopcnt;
+short signo;
+long dot;
+short pid;
+long cntval;
+long loopcnt;
-L_INT entrypt;
-INT adrflg;
+long entrypt;
+short adrflg;
subpcs(modif)
{
- REG INT check;
- INT execsig,runmode;
- REG BKPTR bkptr;
- STRING comptr;
+ register short check;
+ short execsig,runmode;
+ register struct bkpt *bkptr;
+ char *comptr;
execsig=0; loopcnt=cntval;
switch (modif) {
/* delete breakpoint */
case 'd': case 'D':
- IF (bkptr=scanbkpt(dot))
- THEN bkptr->flag=0; return;
- ELSE error(NOBKPT);
- FI
+ if ((bkptr=scanbkpt(dot))) {
+ bkptr->flag=0; return;
+ }
+ else {
+ error(NOBKPT);
+ }
/* set breakpoint */
case 'b': case 'B':
- IF (bkptr=scanbkpt(dot))
- THEN bkptr->flag=0;
- FI
- FOR bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt
- DO IF bkptr->flag == 0
- THEN break;
- FI
- OD
- IF bkptr==0
- THEN IF (bkptr=sbrk(sizeof *bkptr)) == -1
- THEN error(SZBKPT);
- ELSE bkptr->nxtbkpt=bkpthead;
+ if ((bkptr=scanbkpt(dot))) {
+ bkptr->flag=0;
+ }
+ for (bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt) {
+ if (bkptr->flag == 0) {
+ break;
+ }
+ }
+ if (bkptr==0) {
+ if ((bkptr=sbrk(sizeof *bkptr)) == -1) {
+ error(SZBKPT);
+ }
+ else {
+ bkptr->nxtbkpt=bkpthead;
bkpthead=bkptr;
- FI
- FI
+ }
+ }
bkptr->loc = dot;
bkptr->initcnt = bkptr->count = cntval;
bkptr->flag = BKPTSET;
check=MAXCOM-1; comptr=bkptr->comm; rdc(); lp--;
- REP *comptr++ = readchar();
- PER check-- ANDF lastc!=EOR DONE
+ do {
+ *comptr++ = readchar();
+ } while (check-- && lastc!='\n');
*comptr=0; lp--;
- IF check
- THEN return;
- ELSE error(EXBKPT);
- FI
+ if (check) {
+ return;
+ }
+ else {
+ error(EXBKPT);
+ }
/* exit */
case 'k' :case 'K':
- IF pid
- THEN printf("%d: killed", pid); endpcs(); return;
- FI
+ if (pid) {
+ _printf("%d: killed", pid); endpcs(); return;
+ }
error(NOPCS);
/* run program */
case 'r': case 'R':
endpcs();
setup(); runmode=CONTIN;
- IF adrflg
- THEN IF !scanbkpt(dot) THEN loopcnt++; FI
- ELSE IF !scanbkpt(entrypt+2) THEN loopcnt++; FI
- FI
+ if (adrflg) {
+ if (!scanbkpt(dot)) { loopcnt++; }
+ }
+ else {
+ if (!scanbkpt(entrypt+2)) { loopcnt++; }
+ }
break;
/* single step */
case 's': case 'S':
- IF pid
- THEN
+ if (pid) {
+
runmode=SINGLE; execsig=getsig(signo);
- ELSE setup(); loopcnt--;
- FI
+ }
+ else {
+ setup(); loopcnt--;
+ }
break;
/* continue with optional signal */
case 'c': case 'C': case 0:
- IF pid==0 THEN error(NOPCS); FI
+ if (pid==0) { error(NOPCS); }
runmode=CONTIN; execsig=getsig(signo);
break;
default: error(BADMOD);
}
- IF loopcnt>0 ANDF runpcs(runmode,execsig)
- THEN printf("breakpoint%16t");
- ELSE printf("stopped at%16t");
- FI
+ if (loopcnt>0 && runpcs(runmode,execsig)) {
+ _printf("breakpoint%16t");
+ }
+ else {
+ _printf("stopped at%16t");
+ }
delbp();
printpc();
}
*/
#include "defs.h"
-MSG LONGFIL;
-MSG NOTOPEN;
-MSG A68BAD;
-MSG A68LNK;
-MSG BADMOD;
+char LONGFIL[];
+char NOTOPEN[];
+char A68BAD[];
+char A68LNK[];
+char BADMOD[];
-MAP txtmap;
-MAP datmap;
+struct map txtmap;
+struct map datmap;
-ADDR lastframe;
-ADDR callpc;
+intptr_t lastframe;
+intptr_t callpc;
-INT infile;
-INT outfile;
-CHAR *lp;
-L_INT maxoff;
-L_INT maxpos;
-INT radix;
+short infile;
+short outfile;
+char *lp;
+long maxoff;
+long maxpos;
+short radix;
/* symbol management */
-L_INT localval;
+long localval;
/* breakpoints */
-BKPTR bkpthead;
-
-REGLIST reglist [] = {
- "p1lr", P1LR, &pcb.pcb_p1lr,
- "p1br", P1BR, &pcb.pcb_p1br,
- "p0lr", P0LR, &pcb.pcb_p0lr,
- "p0br", P0BR, &pcb.pcb_p0br,
- "ksp", KSP, &pcb.pcb_ksp,
- "esp", ESP, &pcb.pcb_esp,
- "ssp", SSP, &pcb.pcb_ssp,
- "psl", PSL, &pcb.pcb_psl,
- "pc", PC, &pcb.pcb_pc,
- "usp", USP, &pcb.pcb_usp,
- "fp", FP, &pcb.pcb_fp,
- "ap", AP, &pcb.pcb_ap,
- "r11", R11, &pcb.pcb_r11,
- "r10", R10, &pcb.pcb_r10,
- "r9", R9, &pcb.pcb_r9,
- "r8", R8, &pcb.pcb_r8,
- "r7", R7, &pcb.pcb_r7,
- "r6", R6, &pcb.pcb_r6,
- "r5", R5, &pcb.pcb_r5,
- "r4", R4, &pcb.pcb_r4,
- "r3", R3, &pcb.pcb_r3,
- "r2", R2, &pcb.pcb_r2,
- "r1", R1, &pcb.pcb_r1,
- "r0", R0, &pcb.pcb_r0,
+struct bkpt *bkpthead;
+
+struct reglist reglist [] = {
+ "p1lr", _P1LR, &pcb.pcb_p1lr,
+ "p1br", _P1BR, &pcb.pcb_p1br,
+ "p0lr", _P0LR, &pcb.pcb_p0lr,
+ "p0br", _P0BR, &pcb.pcb_p0br,
+ "ksp", _KSP, &pcb.pcb_ksp,
+ "esp", _ESP, &pcb.pcb_esp,
+ "ssp", _SSP, &pcb.pcb_ssp,
+ "psl", _PSL, &pcb.pcb_psl,
+ "pc", _PC, &pcb.pcb_pc,
+ "usp", _USP, &pcb.pcb_usp,
+ "fp", _FP, &pcb.pcb_fp,
+ "ap", _AP, &pcb.pcb_ap,
+ "r11", _R11, &pcb.pcb_r11,
+ "r10", _R10, &pcb.pcb_r10,
+ "r9", _R9, &pcb.pcb_r9,
+ "r8", _R8, &pcb.pcb_r8,
+ "r7", _R7, &pcb.pcb_r7,
+ "r6", _R6, &pcb.pcb_r6,
+ "r5", _R5, &pcb.pcb_r5,
+ "r4", _R4, &pcb.pcb_r4,
+ "r3", _R3, &pcb.pcb_r3,
+ "r2", _R2, &pcb.pcb_r2,
+ "r1", _R1, &pcb.pcb_r1,
+ "r0", _R0, &pcb.pcb_r0,
};
char lastc;
-INT fcor;
-STRING errflg;
-INT signo;
-INT sigcode;
+short fcor;
+char *errflg;
+short signo;
+short sigcode;
-L_INT dot;
-L_INT var[];
-STRING symfil;
-STRING corfil;
-INT pid;
-L_INT adrval;
-INT adrflg;
-L_INT cntval;
-INT cntflg;
+long dot;
+long var[];
+char *symfil;
+char *corfil;
+short pid;
+long adrval;
+short adrflg;
+long cntval;
+short cntflg;
-STRING signals[] = {
+char*CHECKME signals[] = {
"",
"hangup",
"interrupt",
printtrace(modif)
{
- INT narg, i, stat, name, limit;
- POS dynam;
- REG BKPTR bkptr;
- CHAR hi, lo;
- ADDR word;
- STRING comptr;
- ADDR argp, frame, link;
+ short narg, i, stat, name, limit;
+ unsigned dynam;
+ register struct bkpt *bkptr;
+ char hi, lo;
+ intptr_t word;
+ char *comptr;
+ intptr_t argp, frame, link;
register struct nlist *sp;
- INT stack;
- INT ntramp;
+ short stack;
+ short ntramp;
- IF cntflg==0 THEN cntval = -1; FI
+ if (cntflg==0) { cntval = -1; }
switch (modif) {
case '<':
- IF cntval == 0
- THEN WHILE readchar() != EOR
- DO OD
+ if (cntval == 0) {
+ while (readchar() != '\n') { }
lp--;
break;
- FI
- IF rdc() == '<'
- THEN stack = 1;
- ELSE stack = 0; lp--;
- FI
+ }
+ if (rdc() == '<') {
+ stack = 1;
+ }
+ else {
+ stack = 0; lp--;
+ }
/* fall thru... */
case '>':
- {CHAR file[64];
- CHAR Ifile[128];
- extern CHAR *Ipath;
- INT index;
+ {char file[64];
+ char Ifile[128];
+ extern char *Ipath;
+ short index;
index=0;
- IF rdc()!=EOR
- THEN REP file[index++]=lastc;
- IF index>=63 THEN error(LONGFIL); FI
- PER readchar()!=EOR DONE
+ if (rdc()!='\n') {
+ do {
+ file[index++]=lastc;
+ if (index>=63) { error(LONGFIL); }
+ } while (readchar()!='\n');
file[index]=0;
- IF modif=='<'
- THEN IF Ipath THEN
+ if (modif=='<') {
+ if (Ipath) {
+
strcpy(Ifile, Ipath);
strcat(Ifile, "/");
strcat(Ifile, file);
- FI
- IF strcmp(file, "-")!=0
- THEN iclose(stack, 0);
+ }
+ if (strcmp(file, "-")!=0) {
+ iclose(stack, 0);
infile=open(file,0);
- IF infile<0
- THEN infile=open(Ifile,0);
- FI
- ELSE lseek(infile, 0L, 0);
- FI
- IF infile<0
- THEN infile=0; error(NOTOPEN);
- ELSE IF cntflg
- THEN var[9] = cntval;
- ELSE var[9] = 1;
- FI
- FI
- ELSE oclose();
+ if (infile<0) {
+ infile=open(Ifile,0);
+ }
+ }
+ else {
+ lseek(infile, 0L, 0);
+ }
+ if (infile<0) {
+ infile=0; error(NOTOPEN);
+ }
+ else {
+ if (cntflg) {
+ var[9] = cntval;
+ }
+ else {
+ var[9] = 1;
+ }
+ }
+ }
+ else {
+ oclose();
outfile=open(file,1);
- IF outfile<0
- THEN outfile=creat(file,0644);
+ if (outfile<0) {
+ outfile=creat(file,0644);
#ifndef EDDT
- ELSE lseek(outfile,0L,2);
+ }
+ else {
+ lseek(outfile,0L,2);
#endif
- FI
- FI
-
- ELSE IF modif == '<'
- THEN iclose(-1, 0);
- ELSE oclose();
- FI
- FI
+ }
+ }
+
+ }
+ else {
+ if (modif == '<') {
+ iclose(-1, 0);
+ }
+ else {
+ oclose();
+ }
+ }
lp--;
}
break;
case 'p':
- IF kernel == 0
- THEN printf("not debugging kernel\n");
- ELSE IF adrflg
- THEN int pte = access(RD, dot, DSP, 0);
+ if (kernel == 0) {
+ _printf("not debugging kernel\n");
+ }
+ else {
+ if (adrflg) {
+ int pte = _access(RD, dot, DSP, 0);
masterpcbb = (pte&PG_PFNUM)*512;
- FI
+ }
getpcb();
- FI
+ }
break;
case 'd':
- IF adrflg
- THEN IF adrval < 2 ORF adrval > 16
- THEN printf("must have 2 <= radix <= 16");
+ if (adrflg) {
+ if (adrval < 2 || adrval > 16) {
+ _printf("must have 2 <= radix <= 16");
break;
- FI
- printf("radix=%d base ten",radix=adrval);
- FI
+ }
+ _printf("radix=%d base ten",radix=adrval);
+ }
break;
case 'q': case 'Q': case '%':
case 'v': case 'V':
prints("variables\n");
- FOR i=0;i<=35;i++
- DO IF var[i]
- THEN printc((i<=9 ? '0' : 'a'-10) + i);
- printf(" = %x\n",var[i]);
- FI
- OD
+ for (i=0;i<=35;i++) {
+ if (var[i]) {
+ printc((i<=9 ? '0' : 'a'-10) + i);
+ _printf(" = %x\n",var[i]);
+ }
+ }
break;
case 'm': case 'M':
break;
case 0: case '?':
- IF pid
- THEN printf("pcs id = %d\n",pid);
- ELSE prints("no process\n");
- FI
+ if (pid) {
+ _printf("pcs id = %d\n",pid);
+ }
+ else {
+ prints("no process\n");
+ }
sigprint(); flushbuf();
case 'r': case 'R':
return;
case 'c': case 'C':
- IF adrflg
- THEN frame=adrval;
+ if (adrflg) {
+ frame=adrval;
word=get(adrval+6,DSP)&0xFFFF;
- IF word&0x2000
- THEN /* 'calls', can figure out argp */
+ if (word&0x2000) {
+ /* 'calls', can figure out argp */
argp=adrval+20+((word>>14)&3); word &= 0xFFF;
- WHILE word
- DO IF word&1
- THEN argp+=4;
- FI
+ while (word) {
+ if (word&1) {
+ argp+=4;
+ }
word>>=1;
- OD
- ELSE /* 'callg', can't tell where argp is */
+ }
+ }
+ else {
+ /* 'callg', can't tell where argp is */
argp=frame;
- FI
+ }
callpc=get(frame+16,DSP);
- ELIF kcore
- THEN argp = pcb.pcb_ap;
+ }
+ else if (kcore) {
+ argp = pcb.pcb_ap;
frame = pcb.pcb_fp;
callpc = pcb.pcb_pc;
- ELSE argp= *(ADDR *)(((ADDR)&u)+AP);
- frame= *(ADDR *)(((ADDR)&u)+FP);
- callpc= *(ADDR *)(((ADDR)&u)+PC);
- FI
+ }
+ else {
+ argp= *(intptr_t *)(((intptr_t)&u)+_AP);
+ frame= *(intptr_t *)(((intptr_t)&u)+_FP);
+ callpc= *(intptr_t *)(((intptr_t)&u)+_PC);
+ }
lastframe=0;
ntramp = 0;
- WHILE cntval--
- DO char *name;
+ while (cntval--) {
+ char *name;
chkerr();
/* if in extended pcb must be signal trampoline code */
- IF KERNOFF - ctob(UPAGES) < callpc ANDF
- (unsigned)callpc < KERNOFF
- THEN name = "sigtramp";
+ if (KERNOFF - ctob(UPAGES) < callpc &&
+ (unsigned)callpc < KERNOFF) {
+ name = "sigtramp";
ntramp++;
- ELSE ntramp = 0;
+ }
+ else {
+ ntramp = 0;
findsym(callpc,ISYM);
- IF cursym ANDF
- !strcmp(cursym->n_un.n_name, "start")
- THEN break;
- FI
- IF cursym
- THEN name = cursym->n_un.n_name;
- ELSE name = "?";
- FI
- FI
- printf("%s(", name);
- narg = get(argp,DSP); IF narg&~0xFF THEN narg=0; FI
- LOOP IF narg==0 THEN break; FI
- printf("%R", get(argp += 4, DSP));
- IF --narg!=0 THEN printc(','); FI
- POOL
- IF ntramp == 1
- THEN callpc=get(frame+92, DSP);
- ELSE callpc=get(frame+16, DSP);
- FI
- IF callpc != 0
- THEN prints(") from ");
+ if (cursym &&
+ !strcmp(cursym->n_un.n_name, "start")) {
+ break;
+ }
+ if (cursym) {
+ name = cursym->n_un.n_name;
+ }
+ else {
+ name = "?";
+ }
+ }
+ _printf("%s(", name);
+ narg = get(argp,DSP); if (narg&~0xFF) { narg=0; }
+ for(;;) {
+ if (narg==0) { break; }
+ _printf("%R", get(argp += 4, DSP));
+ if (--narg!=0) { printc(','); }
+ }
+ if (ntramp == 1) {
+ callpc=get(frame+92, DSP);
+ }
+ else {
+ callpc=get(frame+16, DSP);
+ }
+ if (callpc != 0) {
+ prints(") from ");
psymoff(callpc, ISYM, "\n");
- ELSE prints(")\n");
- FI
-
- IF modif=='C'
- THEN WHILE localsym(frame,argp)
- DO word=get(localval,DSP);
- printf("%8t%s:%10t",
+ }
+ else {
+ prints(")\n");
+ }
+
+ if (modif=='C') {
+ while (localsym(frame,argp)) {
+ word=get(localval,DSP);
+ _printf("%8t%s:%10t",
cursym->n_un.n_name);
- IF errflg
- THEN prints("?\n"); errflg=0;
- ELSE printf("%R\n",word);
- FI
- OD
- FI
+ if (errflg) {
+ prints("?\n"); errflg=0;
+ }
+ else {
+ _printf("%R\n",word);
+ }
+ }
+ }
argp=get(frame+8, DSP);
lastframe=frame;
- frame=get(frame+12, DSP)&EVEN;
- IF frame==0 THEN break; FI
- IF !adrflg ANDF !INSTACK(frame)
- THEN IF !kcore ORF !kstackaddr(frame)
- THEN break;
- FI
- FI
- OD
+ frame=get(frame+12, DSP)&-2;
+ if (frame==0) { break; }
+ if (!adrflg && !INSTACK(frame)) {
+ if (!kcore || !kstackaddr(frame)) {
+ break;
+ }
+ }
+ }
break;
/*print externals*/
case 'e': case 'E':
- FOR sp = symtab; sp < esymtab; sp++
- DO IF sp->n_type == (N_DATA|N_EXT) ORF
- sp->n_type == (N_BSS|N_EXT)
- THEN printf("%s:%12t%R\n", sp->n_un.n_name,
+ for (sp = symtab; sp < esymtab; sp++) {
+ if (sp->n_type == (N_DATA|N_EXT) ||
+ sp->n_type == (N_BSS|N_EXT)) {
+ _printf("%s:%12t%R\n", sp->n_un.n_name,
get(sp->n_value,DSP));
- FI
- OD
+ }
+ }
break;
case 'a': case 'A':
/*print breakpoints*/
case 'b': case 'B':
- printf("breakpoints\ncount%8tbkpt%24tcommand\n");
- FOR bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt
- DO IF bkptr->flag
- THEN printf("%-8.8d",bkptr->count);
+ _printf("breakpoints\ncount%8tbkpt%24tcommand\n");
+ for (bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt) {
+ if (bkptr->flag) {
+ _printf("%-8.8d",bkptr->count);
psymoff(leng(bkptr->loc),ISYM,"%24t");
comptr=bkptr->comm;
- WHILE *comptr DO printc(*comptr++); OD
- FI
- OD
+ while (*comptr) { printc(*comptr++); }
+ }
+ }
break;
default:
}
printmap(s,amap)
-STRING s; MAP *amap;
+char *s; struct map *amap;
{
int file;
file=amap->ufd;
- printf("%s%12t`%s'\n", s,
+ _printf("%s%12t`%s'\n", s,
(file<0 ? "-" : (file==fcor ? corfil : symfil)));
- printf("b1 = %-16R",amap->b1);
- printf("e1 = %-16R",amap->e1);
- printf("f1 = %-16R",amap->f1);
- printf("\nb2 = %-16R",amap->b2);
- printf("e2 = %-16R",amap->e2);
- printf("f2 = %-16R",amap->f2);
- printc(EOR);
+ _printf("b1 = %-16R",amap->b1);
+ _printf("e1 = %-16R",amap->e1);
+ _printf("f1 = %-16R",amap->f1);
+ _printf("\nb2 = %-16R",amap->b2);
+ _printf("e2 = %-16R",amap->e2);
+ _printf("f2 = %-16R",amap->f2);
+ printc('\n');
}
printregs()
{
- REG REGPTR p;
- L_INT v;
-
- FOR p=reglist; p < ®list[24]; p++
- DO v = kcore ? *p->rkern : *(ADDR *)(((ADDR)&u)+p->roffs);
- printf("%s%6t%R %16t", p->rname, v);
- valpr(v,(p->roffs==PC?ISYM:DSYM));
- printc(EOR);
- OD
+ register struct reglist *p;
+ long v;
+
+ for (p=reglist; p < ®list[24]; p++) {
+ v = kcore ? *p->rkern : *(intptr_t *)(((intptr_t)&u)+p->roffs);
+ _printf("%s%6t%R %16t", p->rname, v);
+ valpr(v,(p->roffs==_PC?ISYM:DSYM));
+ printc('\n');
+ }
printpc();
}
getreg(regnam) {
- REG REGPTR p;
- REG STRING regptr;
- CHAR *olp;
- CHAR regnxt;
+ register struct reglist *p;
+ register char *regptr;
+ char *olp;
+ char regnxt;
olp=lp;
- FOR p=reglist; p < ®list[24]; p++
- DO regptr=p->rname;
- IF (regnam == *regptr++)
- THEN
- WHILE *regptr
- DO IF (regnxt=readchar()) != *regptr++
- THEN --regptr; break;
- FI
- OD
- IF *regptr
- THEN lp=olp;
- ELSE
+ for (p=reglist; p < ®list[24]; p++) {
+ regptr=p->rname;
+ if ((regnam == *regptr++)) {
+
+ while (*regptr) {
+ if ((regnxt=readchar()) != *regptr++) {
+ --regptr; break;
+ }
+ }
+ if (*regptr) {
+ lp=olp;
+ }
+ else {
+
int i = kcore ? (int)p->rkern : p->roffs;
return (i);
- FI
- FI
- OD
+ }
+ }
+ }
lp=olp;
return(0);
}
printpc()
{
- dot= *(ADDR *)(((ADDR)&u)+PC);
- psymoff(dot,ISYM,":%16t"); printins(0,ISP,chkget(dot,ISP));
- printc(EOR);
+ dot= *(intptr_t *)(((intptr_t)&u)+_PC);
+ psymoff(dot,ISYM,":%16t"); printins(0,_ISP,chkget(dot,_ISP));
+ printc('\n');
}
char *illinames[] = {
sigprint()
{
- IF (signo>=0) ANDF (signo<sizeof signals/sizeof signals[0])
- THEN prints(signals[signo]); FI
+ if ((signo>=0) && (signo<sizeof signals/sizeof signals[0])) { prints(signals[signo]); }
switch (signo) {
case SIGFPE:
- IF (sigcode > 0 &&
- sigcode < sizeof fpenames / sizeof fpenames[0]) THEN
+ if ((sigcode > 0 &&
+ sigcode < sizeof fpenames / sizeof fpenames[0])) {
+
prints(" ("); prints(fpenames[sigcode]); prints(")");
- FI
+ }
break;
case SIGILL:
- IF (sigcode >= 0 &&
- sigcode < sizeof illinames / sizeof illinames[0]) THEN
+ if ((sigcode >= 0 &&
+ sigcode < sizeof illinames / sizeof illinames[0])) {
+
prints(" ("); prints(illinames[sigcode]); prints(")");
- FI
+ }
break;
}
}
#include "defs.h"
-extern MAP txtmap;
+extern struct map txtmap;
-MSG NOFORK;
-MSG ENDPCS;
-MSG BADWAIT;
+char NOFORK[];
+char ENDPCS[];
+char BADWAIT[];
-CHAR *lp;
-ADDR sigint;
-ADDR sigqit;
+char *lp;
+intptr_t sigint;
+intptr_t sigqit;
/* breakpoints */
-BKPTR bkpthead;
+struct bkpt *bkpthead;
-REGLIST reglist[];
+struct reglist reglist[];
-CHAR lastc;
+char lastc;
-INT fcor;
-INT fsym;
-STRING errflg;
-INT errno;
-INT signo;
-INT sigcode;
+short fcor;
+short fsym;
+char *errflg;
+short errno;
+short signo;
+short sigcode;
-L_INT dot;
-STRING symfil;
-INT wtflag;
-L_INT pid;
-L_INT expv;
-INT adrflg;
-L_INT loopcnt;
+long dot;
+char *symfil;
+short wtflag;
+long pid;
+long expv;
+short adrflg;
+long loopcnt;
{ return(expr(0) ? expv : sig);
}
-ADDR userpc = 1;
+intptr_t userpc = 1;
runpcs(runmode,execsig)
{
- INT rc;
- REG BKPTR bkpt;
- IF adrflg THEN userpc=dot; FI
- printf("%s: running\n", symfil);
+ short rc;
+ register struct bkpt *bkpt;
+ if (adrflg) { userpc=dot; }
+ _printf("%s: running\n", symfil);
- WHILE --loopcnt>=0
- DO
+ while (--loopcnt>=0) {
+
#ifdef DEBUG
- printf("\ncontinue %x %d\n",userpc,execsig);
+ _printf("\ncontinue %x %d\n",userpc,execsig);
#endif
- IF runmode==SINGLE
- THEN delbp(); /* hardware handles single-stepping */
- ELSE /* continuing from a breakpoint is hard */
- IF bkpt=scanbkpt(userpc)
- THEN execbkpt(bkpt,execsig); execsig=0;
- FI
+ if (runmode==SINGLE) {
+ delbp(); /* hardware handles single-stepping */
+ }
+ else {
+ /* continuing from a breakpoint is hard */
+ if (bkpt=scanbkpt(userpc)) {
+ execbkpt(bkpt,execsig); execsig=0;
+ }
setbp();
- FI
+ }
ptrace(runmode,pid,userpc,execsig);
bpwait(); chkerr(); execsig=0; delbp(); readregs();
- IF (signo==0) ANDF (bkpt=scanbkpt(userpc))
- THEN /* stopped by BPT instruction */
+ if ((signo==0) && (bkpt=scanbkpt(userpc))) {
+ /* stopped by BPT instruction */
#ifdef DEBUG
- printf("\n BPT code; '%s'%o'%o'%d",
- bkpt->comm,bkpt->comm[0],EOR,bkpt->flag);
+ _printf("\n BPT code; '%s'%o'%o'%d",
+ bkpt->comm,bkpt->comm[0],'\n',bkpt->flag);
#endif
dot=bkpt->loc;
- IF bkpt->flag==BKPTEXEC
- ORF ((bkpt->flag=BKPTEXEC)
- ANDF bkpt->comm[0]!=EOR
- ANDF command(bkpt->comm,':')
- ANDF --bkpt->count)
- THEN execbkpt(bkpt,execsig); execsig=0; loopcnt++;
- ELSE bkpt->count=bkpt->initcnt; rc=1;
- FI
- ELSE execsig=signo; rc=0;
- FI
- OD
+ if (bkpt->flag==BKPTEXEC
+ || ((bkpt->flag=BKPTEXEC)
+ && bkpt->comm[0]!='\n'
+ && command(bkpt->comm,':')
+ && --bkpt->count)) {
+ execbkpt(bkpt,execsig); execsig=0; loopcnt++;
+ }
+ else {
+ bkpt->count=bkpt->initcnt; rc=1;
+ }
+ }
+ else {
+ execsig=signo; rc=0;
+ }
+ }
return(rc);
}
#define BPOUT 0
#define BPIN 1
-INT bpstate = BPOUT;
+short bpstate = BPOUT;
endpcs()
{
- REG BKPTR bkptr;
- IF pid
- THEN ptrace(PT_KILL,pid,0,0); pid=0; userpc=1;
- FOR bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt
- DO IF bkptr->flag
- THEN bkptr->flag=BKPTSET;
- FI
- OD
- FI
+ register struct bkpt *bkptr;
+ if (pid) {
+ ptrace(PT_KILL,pid,0,0); pid=0; userpc=1;
+ for (bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt) {
+ if (bkptr->flag) {
+ bkptr->flag=BKPTSET;
+ }
+ }
+ }
bpstate=BPOUT;
}
{
close(fsym); fsym = -1;
#ifndef VFORK
- IF (pid = fork()) == 0
+ if ((pid = fork()) == 0
#else
- IF (pid = vfork()) == 0
-#endif
- THEN ptrace(PT_TRACE_ME,0,0,0);
+ if ((pid = vfork()) == 0
+#endif) {
+ ptrace(PT_TRACE_ME,0,0,0);
#ifdef VFORK
signal(SIGTRAP,nullsig);
#endif
signal(SIGINT,sigint); signal(SIGQUIT,sigqit);
doexec(); exit(0);
- ELIF pid == -1
- THEN error(NOFORK);
- ELSE bpwait(); readregs(); lp[0]=EOR; lp[1]=0;
+ }
+ else if (pid == -1) {
+ error(NOFORK);
+ }
+ else {
+ bpwait(); readregs(); lp[0]='\n'; lp[1]=0;
fsym=open(symfil,wtflag);
- IF errflg
- THEN printf("%s: cannot execute\n",symfil);
+ if (errflg) {
+ _printf("%s: cannot execute\n",symfil);
endpcs(); error(0);
- FI
- FI
+ }
+ }
bpstate=BPOUT;
}
execbkpt(bkptr,execsig)
-BKPTR bkptr;
+struct bkpt *bkptr;
{
#ifdef DEBUG
- printf("exbkpt: %d\n",bkptr->count);
+ _printf("exbkpt: %d\n",bkptr->count);
#endif
delbp();
ptrace(PT_STEP,pid,bkptr->loc,execsig);
doexec()
{
- STRING argl[MAXARG];
- CHAR args[LINSIZ];
- STRING p, *ap, filnam;
- extern STRING environ;
+ char*CHECKME argl[MAXARG];
+ char args[LINSIZ];
+ char*CHECKME p, *ap, filnam;
+ extern char *environ;
ap=argl; p=args;
*ap++=symfil;
- REP IF rdc()==EOR THEN break; FI
+ do {
+ if (rdc()=='\n') { break; }
*ap = p;
/*
* First thing is to look for direction characters
* and get filename. Do not use up the args for filenames.
* Then get rid of spaces before next args.
*/
- IF lastc=='<'
- THEN REP readchar(); PER lastc==SP ORF lastc==TB DONE
+ if (lastc=='<') {
+ do { readchar(); } while (lastc==' ' || lastc=='\t');
filnam = p;
- WHILE lastc!=EOR ANDF lastc!=SP ANDF lastc!=TB ANDF lastc!='>'
- DO *p++=lastc; readchar(); OD
+ while (lastc!='\n' && lastc!=' ' && lastc!='\t' && lastc!='>') { *p++=lastc; readchar(); }
*p = 0;
close(0);
- IF open(filnam,0)<0
- THEN printf("%s: cannot open\n",filnam); _exit(0);
- FI
+ if (open(filnam,0)<0) {
+ _printf("%s: cannot open\n",filnam); _exit(0);
+ }
p = *ap;
- ELIF lastc=='>'
- THEN REP readchar(); PER lastc==SP ORF lastc==TB DONE
+ }
+ else if (lastc=='>') {
+ do { readchar(); } while (lastc==' ' || lastc=='\t');
filnam = p;
- WHILE lastc!=EOR ANDF lastc!=SP ANDF lastc!=TB ANDF lastc!='<'
- DO *p++=lastc; readchar(); OD
+ while (lastc!='\n' && lastc!=' ' && lastc!='\t' && lastc!='<') { *p++=lastc; readchar(); }
*p = '\0';
close(1);
- IF creat(filnam,0666)<0
- THEN printf("%s: cannot create\n",filnam); _exit(0);
- FI
+ if (creat(filnam,0666)<0) {
+ _printf("%s: cannot create\n",filnam); _exit(0);
+ }
p = *ap;
- ELSE
- WHILE lastc!=EOR ANDF lastc!=SP ANDF lastc!=TB ANDF lastc!='>' ANDF lastc!='<'
- DO *p++=lastc; readchar(); OD
+ }
+ else {
+
+ while (lastc!='\n' && lastc!=' ' && lastc!='\t' && lastc!='>' && lastc!='<') { *p++=lastc; readchar(); }
*p++ = '\0';
- ap++;
- FI
- PER lastc!=EOR DONE
+ ap++;
+ }
+ } while (lastc!='\n');
*ap++=0;
exect(symfil, argl, environ);
perror(symfil);
}
-BKPTR scanbkpt(adr)
-ADDR adr;
+struct bkpt*CHECKME scanbkpt(adr)
+intptr_t adr;
{
- REG BKPTR bkptr;
- FOR bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt
- DO IF bkptr->flag ANDF bkptr->loc==adr
- THEN break;
- FI
- OD
+ register struct bkpt *bkptr;
+ for (bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt) {
+ if (bkptr->flag && bkptr->loc==adr) {
+ break;
+ }
+ }
return(bkptr);
}
delbp()
{
- REG ADDR a;
- REG BKPTR bkptr;
- IF bpstate!=BPOUT
- THEN
- FOR bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt
- DO IF bkptr->flag
- THEN a=bkptr->loc;
- IF a < txtmap.e1 THEN
+ register intptr_t a;
+ register struct bkpt *bkptr;
+ if (bpstate!=BPOUT) {
+
+ for (bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt) {
+ if (bkptr->flag) {
+ a=bkptr->loc;
+ if (a < txtmap.e1) {
+
ptrace(PT_WRITE_I,pid,a,bkptr->ins);
- ELSE
+ }
+ else {
+
ptrace(PT_WRITE_D,pid,a,bkptr->ins);
- FI
- FI
- OD
+ }
+ }
+ }
bpstate=BPOUT;
- FI
+ }
}
#ifdef vax
setbp()
{
- REG ADDR a;
- REG BKPTR bkptr;
-
- IF bpstate!=BPIN
- THEN
- FOR bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt
- DO IF bkptr->flag
- THEN a = bkptr->loc;
- IF a < txtmap.e1 THEN
+ register intptr_t a;
+ register struct bkpt *bkptr;
+
+ if (bpstate!=BPIN) {
+
+ for (bkptr=bkpthead; bkptr; bkptr=bkptr->nxtbkpt) {
+ if (bkptr->flag) {
+ a = bkptr->loc;
+ if (a < txtmap.e1) {
+
bkptr->ins = ptrace(PT_READ_I, pid, a, 0);
ptrace(PT_WRITE_I, pid, a, SETBP(bkptr->ins));
- ELSE
+ }
+ else {
+
bkptr->ins = ptrace(PT_READ_D, pid, a, 0);
ptrace(PT_WRITE_D, pid, a, SETBP(bkptr->ins));
- FI
- IF errno
- THEN prints("cannot set breakpoint: ");
+ }
+ if (errno) {
+ prints("cannot set breakpoint: ");
psymoff(bkptr->loc,ISYM,"\n");
- FI
- FI
- OD
+ }
+ }
+ }
bpstate=BPIN;
- FI
+ }
}
bpwait()
{
- REG ADDR w;
- ADDR stat;
+ register intptr_t w;
+ intptr_t stat;
signal(SIGINT, 1);
- WHILE (w = wait(&stat))!=pid ANDF w != -1 DONE
+ while ((w = wait(&stat))!=pid && w != -1);
signal(SIGINT,sigint);
- IF w == -1
- THEN pid=0;
+ if (w == -1) {
+ pid=0;
errflg=BADWAIT;
- ELIF (stat & 0177) != 0177
- THEN sigcode = 0;
- IF signo = stat&0177
- THEN sigprint();
- FI
- IF stat&0200
- THEN prints(" - core dumped");
+ }
+ else if ((stat & 0177) != 0177) {
+ sigcode = 0;
+ if (signo = stat&0177) {
+ sigprint();
+ }
+ if (stat&0200) {
+ prints(" - core dumped");
close(fcor);
setcor();
- FI
+ }
pid=0;
errflg=ENDPCS;
- ELSE signo = stat>>8;
+ }
+ else {
+ signo = stat>>8;
sigcode = ptrace(PT_READ_U, pid, &((struct user *)0)->u_code, 0);
- IF signo!=SIGTRAP
- THEN sigprint();
- ELSE signo=0;
- FI
+ if (signo!=SIGTRAP) {
+ sigprint();
+ }
+ else {
+ signo=0;
+ }
flushbuf();
- FI
+ }
}
readregs()
{
- /*get REG values from pcs*/
- REG i;
- FOR i=24; --i>=0;
- DO *(ADDR *)(((ADDR)&u)+reglist[i].roffs) =
+ /*get register values from pcs*/
+ register i;
+ for (i=24; --i>=0;) {
+ *(intptr_t *)(((intptr_t)&u)+reglist[i].roffs) =
ptrace(PT_READ_U, pid, reglist[i].roffs, 0);
- OD
- userpc= *(ADDR *)(((ADDR)&u)+PC);
+ }
+ userpc= *(intptr_t *)(((intptr_t)&u)+_PC);
}
off_t datbas; /* offset of the base of the data segment */
off_t stksiz; /* stack size in the core image */
-INT sigcode; /* belongs in head.h */
+short sigcode; /* belongs in head.h */
char *symfil = "a.out";
char *corfil = "core";
}
return;
readerr:
- printf("Error reading symbol|string table\n");
+ _printf("Error reading symbol|string table\n");
exit(1);
nospac:
- printf("Not enough space for symbol|string table\n");
+ _printf("Not enough space for symbol|string table\n");
exit(1);
oldfmt:
- printf("Old format a.out - no string table\n");
+ _printf("Old format a.out - no string table\n");
exit(1);
}
sbr = cursym->n_value;
lookup("_Syssize");
slr = cursym->n_value;
- printf("sbr %x slr %x\n", sbr, slr);
+ _printf("sbr %x slr %x\n", sbr, slr);
lookup("_masterpaddr");
physrw(fcor, KVTOPH(cursym->n_value), &masterpcbb, 1);
masterpcbb = (masterpcbb&PG_PFNUM)*NBPG;
lseek(fcor, KVTOPH(masterpcbb), L_SET);
read(fcor, &pcb, sizeof (struct pcb));
pcb.pcb_p0lr &= ~AST_CLR;
- printf("p0br %x p0lr %x p1br %x p1lr %x\n",
+ _printf("p0br %x p0lr %x p1br %x p1lr %x\n",
pcb.pcb_p0br, pcb.pcb_p0lr, pcb.pcb_p1br, pcb.pcb_p1lr);
}
*cp = '?';
if (*cp)
*cp = '\0';
- printf("panic: %s\n", buf);
+ _printf("panic: %s\n", buf);
/*
* After a panic, look at the top of the rpb stack to
* find a stack frame. If this was a clean crash,
fp = checkintstack();
/* search kernel stack? */
if (fp == 0) {
- printf("can't locate stack frame\n");
+ _printf("can't locate stack frame\n");
return;
}
/* probably shouldn't clobber pcb, but for now this is easy */
if (wtflag)
fsym = create(filnam);
if (fsym < 0)
- printf("cannot open `%s'\n", filnam);
+ _printf("cannot open `%s'\n", filnam);
}
return (fsym);
}
cursym = 0;
if (symtab)
for (sp = symtab; sp < esymtab; sp++)
- /* SHOULD DO SOME OF EQSYM INLINE TO SAVE TIME */
+ /* SHOULD) {
+ SOME OF EQSYM INLINE TO SAVE TIME */
if ((sp->n_type&N_STAB)==0 && eqsym(sp->n_un.n_name, symstr, '_'))
return(cursym = sp);
return (0);
* Return 0 at end of file.
*/
localsym(cframe, cargp)
- ADDR cframe, cargp;
+ intptr_t cframe, cargp;
{
register int type;
register struct nlist *sp;
if (v)
w = findsym(v, type);
if (v==0 || w >= maxoff || (INKERNEL(v) && KVTOPH(v) < maxoff && w))
- printf(LPRMODE, v);
+ _printf(LPRMODE, v);
else {
- printf("%s", cursym->n_un.n_name);
+ _printf("%s", cursym->n_un.n_name);
if (w)
- printf(OFFMODE, w);
+ _printf(OFFMODE, w);
}
- printf(s);
+ _printf(s);
}
/*
d = findsym(v, idsp);
if (d >= maxoff)
return;
- printf("%s", cursym->n_un.n_name);
+ _printf("%s", cursym->n_un.n_name);
if (d)
- printf(OFFMODE, d);
+ _printf(OFFMODE, d);
}
public / 43bsd.git / commitdiff