home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 1 / crawlyvol1.bin / program / compiler / sozobon / scsrc20 / szadb / adb1.c < prev    next >
C/C++ Source or Header  |  1991-03-01  |  8KB  |  526 lines
  1. /* Copyright (c) 1990,91 by Sozobon, Limited.  Authors: Johann Ruegg, Don Dugger
  2.  *
  3.  * Permission is granted to anyone to use this software for any purpose
  4.  * on any computer system, and to redistribute it freely, with the
  5.  * following restrictions:
  6.  * 1) No charge may be made other than reasonable charges for reproduction.
  7.  * 2) Modified versions must be clearly marked as such.
  8.  * 3) The authors are not responsible for any harmful consequences
  9.  *    of using this software, even if they result from defects in it.
  10.  *
  11.  *    adb1.c
  12.  */
  13.  
  14. #include <setjmp.h>
  15. #include "adb.h"
  16.  
  17. #define IN_ADB1
  18. #include "lang.h"
  19.  
  20. extern struct file binary;
  21.  
  22. extern long dot;
  23. extern int dotoff;
  24. extern long maxoff;
  25. extern int ibase;
  26.  
  27. extern int lastc;
  28. extern char sign;
  29.  
  30. extern jmp_buf jmpb;
  31.  
  32.  
  33. getfmt(fmt)
  34. char *fmt;
  35. {
  36.     char c;
  37.  
  38.     while ((*fmt = getchr()) != '\n')
  39.         fmt++;
  40.     *fmt = '\0';
  41.     pushc('\n');
  42.     return;
  43. }
  44.  
  45. long getdot(d, n)
  46. long d;
  47. int n;
  48. {
  49.     long l;
  50.  
  51.     l = dot;
  52.     if (n == 2)
  53.         l &= 0xffff;
  54.     else if (n == 1)
  55.         l &= 0xff;
  56.     return(l);
  57. }
  58.  
  59. unsigned char
  60. getb(fp)
  61. struct file *fp;
  62. {
  63.     long getn();
  64.  
  65.     return(getn(dot + dotoff, 1));
  66. }
  67.  
  68. unsigned int
  69. getwd()
  70. {
  71.     long getn();
  72.  
  73.     return(getn(dot + dotoff, 2));
  74. }
  75.  
  76. putn(v, d, n)
  77. long v, d;
  78. int n;
  79. {
  80.     union {
  81.         int i;
  82.         long l;
  83.     } no, val;
  84.     long b;
  85.     register int o;
  86.     char *p, *s;
  87.  
  88.     b = d >> LOGBS;
  89.     o = d & (BSIZE - 1);
  90.     switch (n) {
  91.  
  92.     case 2:
  93.         p = (char *)(&no.i);
  94.         val.i = v;
  95.         s = (char *)(&val.i);
  96.         break;
  97.     case 4:
  98.         p = (char *)(&no.l);
  99.         val.l = v;
  100.         s = (char *)(&val.l);
  101.         break;
  102.  
  103.     }
  104.     rdsub(d, p, n, 0);
  105.     dotoff += n;
  106.     switch (n) {
  107.  
  108.     case 2:
  109.         bcopy(s, p, n);
  110.         break;
  111.     case 4:
  112.         bcopy(s, p, n);
  113.         break;
  114.  
  115.     }
  116.     wrsub(p, d, n, 0);
  117.     return;
  118. }
  119.  
  120. long
  121. getn(d, n)
  122. unsigned long d;
  123. int n;
  124. {
  125.     unsigned long b, no;
  126.     register unsigned int o;
  127.     char *p;
  128.  
  129.     b = d >> LOGBS;
  130.     o = d & (BSIZE - 1);
  131.     rdsub(d, &b, n, 0);
  132.     p = (char *)&b;
  133.     dotoff += n;
  134.     switch (n) {
  135.  
  136.     case 1:
  137.         no = *p;
  138.         break;
  139.     case 2:
  140.         no = *(int *)p;
  141.         break;
  142.     case 4:
  143.         no = *(long *)p;
  144.         break;
  145.  
  146.     }
  147.     return(no);
  148. }
  149.  
  150. puto(n, s)
  151. unsigned long n;
  152. int s;
  153. {
  154.  
  155.     if (n > 0)
  156.         puto((n >> 3) & 0x1fffffff, --s);
  157.     else
  158.         while (s-- > 0)
  159.             putchr(' ');
  160.     putchr((char)((n & 7) + '0'));
  161.     return;
  162. }
  163.  
  164. putd(n, s)
  165. long n;
  166. int s;
  167. {
  168.  
  169.     if (n < 0) {
  170.         s--;
  171.         n = -n;
  172.         if (n < 0) {
  173.             while (s-- > 0)
  174.                 putchr(' ');
  175.             putchr('?');
  176.             return;
  177.         } else
  178.             sign = '-';
  179.     }
  180.     if (n > 9)
  181.         putd(n / 10, --s);
  182.     else
  183.         while (s-- > 0)
  184.             putchr(' ');
  185.     if (sign) {
  186.         putchr(sign);
  187.         sign = 0;
  188.     }
  189.     putchr((char)((n % 10) + '0'));
  190.     return;
  191. }
  192.  
  193. putx(n, s)
  194. unsigned long n;
  195. int s;
  196. {
  197.  
  198.     if (n > 0xf)
  199.         putx((n >> 4) & 0xfffffff, --s);
  200.     else {
  201.         while (s-- > 0)
  202.             putchr(' ');
  203.     }
  204.     putchr("0123456789abcdef"[n & 0xf]);
  205.     return;
  206. }
  207.  
  208. prtn(n, s)
  209. long n;
  210. int s;
  211. {
  212.  
  213.     switch (ibase) {
  214.  
  215.     case 8:
  216.         puto(n, s);
  217.         break;
  218.     case 10:
  219.         putd(n, s);
  220.         break;
  221.     default:
  222.     case 16:
  223.         putx(n, s);
  224.         break;
  225.  
  226.     }
  227.     return;
  228. }
  229.  
  230. prt(s)
  231. char *s;
  232. {
  233.  
  234.     while (*s)
  235.         putchr(*s++);
  236.     return;
  237. }
  238.  
  239. putchr(c)
  240. char c;
  241. {
  242.     putchar(c);
  243. }
  244.  
  245. relsym()
  246. {
  247.     register struct symbol *sp;
  248.     extern struct basepg *bpage;
  249.  
  250.     sp = binary.symptr;
  251.     while (sp) {
  252.         sp->value += (long)bpage->p_tbase;
  253.         sp = sp->next;
  254.     }
  255. }
  256.  
  257. setsym(fd, n)
  258. struct file *fd;
  259. int n;
  260. {
  261.     static struct filsym sym;
  262.     int rv;
  263.     char sname[NAMEMAX+1];
  264.     int slen;
  265.  
  266.     symstart(n, fd->fid);
  267.     for (;;) {
  268.         rv = sread(&sym);
  269.         if (rv != 1)
  270.             return rv;
  271.         if ((sym.flag & S_EXT) && 
  272.             (sym.flag & (S_DATA|S_TEXT|S_BSS))) {
  273.             if (sym.name[7]) {
  274.                 bcopy(sym.name, sname, 8);
  275.                 slen = 8;
  276.                 while (slen+8 <= NAMEMAX) {
  277.                     rv = sread(&sym);
  278.                     if (rv < 0)
  279.                         return rv;
  280.                     else if (rv == 0)
  281.                         break;
  282.                     if (sym.flag == S_EXTEND) {
  283.                         if (sym.name[7]) {
  284.                             bcopy(sym.name,
  285.                               &sname[slen], 8);
  286.                             slen += 8;
  287.                         } else {
  288.                             strcpy(&sname[slen],
  289.                                sym.name);
  290.                             slen += strlen(sym.name);
  291.                         }
  292.                     } else {
  293.                         unsread();
  294.                         break;
  295.                     }
  296.                 }
  297.                 sname[slen] = 0;
  298.             } else {
  299.                 slen = strlen(sym.name);
  300.                 strcpy(sname, sym.name);
  301.             }
  302.             addsym(&binary.symptr, &sym, sname, slen);
  303.         }
  304.     }
  305.     return 0;
  306. }
  307.  
  308. int sreuse = 0;
  309. int sleft = 0;
  310. int sfd = 0;
  311.  
  312. symstart(n, fd)
  313. {
  314.     sleft = n;
  315.     sfd = fd;
  316. }
  317.  
  318. sread(ptr)
  319. char *ptr;
  320. {
  321.     static struct filsym old;
  322.  
  323.     if (sreuse) {
  324.         sreuse = 0;
  325.         bcopy(&old, ptr, sizeof(old));
  326.         return 1;
  327.     }
  328.     if (sleft == 0)
  329.         return 0;
  330.     if (read(sfd, &old, sizeof(old)) != sizeof(old)) {
  331.         sleft = 0;
  332.         return -1;
  333.     }
  334.     sleft--;
  335.     bcopy(&old, ptr, sizeof(old));
  336.     return 1;
  337. }
  338.  
  339. unsread()
  340. {
  341.     sreuse = 1;
  342. }
  343.  
  344. addsym(spp, sym, name, slen)
  345. struct symbol **spp;
  346. struct filsym *sym;
  347. char *name;
  348. {
  349.     char *malloc();
  350.     register long v;
  351.     register int i;
  352.     struct symbol *p;
  353.     register struct symbol *sp;
  354.  
  355.     v = sym->value;
  356.     sp = *spp;
  357.     while (sp)
  358.         if (sp->value > v)
  359.             break;
  360.         else {
  361.             spp = &sp->next;
  362.             sp = *spp;
  363.         }
  364.     if ((p = (struct symbol *)malloc(sizeof(*p)+slen)) == 0) {
  365. /*        prtf("can't allocate %i bytes for symbol\n", sizeof(*p)); */
  366.         prtf(M1, sizeof(*p));
  367.         return;
  368.     }
  369.     p->next = sp;
  370.     *spp = p;
  371.     p->value = v;
  372.     bcopy(name, p->name, slen+1);
  373.     return;
  374. }
  375.  
  376. struct symbol *
  377. findnam(cp, sp)
  378. char *cp;
  379. struct symbol *sp;
  380. {
  381.     struct symbol *best;
  382.     int bestlen, newlen;
  383.  
  384.     best = 0;
  385.     bestlen = 0;
  386.     while (sp) {
  387.         if (strncmp(cp, sp->name, 8) == 0) {
  388.             newlen = matchlen(cp, sp->name);
  389.             if (newlen > bestlen) {
  390.                 best = sp;
  391.                 bestlen = newlen;
  392.             }
  393.         }
  394.         sp = sp->next;
  395.     }
  396.     return(best);
  397. }
  398.  
  399. matchlen(p, q)
  400. char *p, *q;
  401. {
  402.     int n = 0;
  403.  
  404.     while (*p) {
  405.         if (*p++ != *q++)
  406.             return n;
  407.         n++;
  408.     }
  409.     return n;
  410. }
  411.  
  412. struct symbol *
  413. findsym(v, sp)
  414. unsigned long v;
  415. struct symbol *sp;
  416. {
  417.     struct symbol *lp;
  418.     unsigned long val;
  419.  
  420.     lp = sp;
  421.     while (sp) {
  422.         val = sp->value;
  423.         if (val > v)
  424.             break;
  425.         else {
  426.             lp = sp;
  427.             sp = sp->next;
  428.         }
  429.     }
  430.     if (lp && v >= lp->value && v < lp->value + maxoff)
  431.         return(lp);
  432.     return(0);
  433. }
  434.  
  435. htoi(cp)
  436. char *cp;
  437. {
  438.     int n;
  439.     char c;
  440.  
  441.     n = 0;
  442.     while (type(c = *cp++) & HEXDIG) {
  443.         if (c >= 'a' && c <= 'f')
  444.             c -= 'a' - '9' - 1;
  445.         else if (c >= 'A' && c <= 'F')
  446.             c -= 'A' - '9' - 1;
  447.         n = (n << 4) + (c - '0');
  448.     }
  449.     return(n);
  450. }
  451.  
  452. prtsym(v, sp)
  453. unsigned long v;
  454. struct symbol *sp;
  455. {
  456.  
  457.     prt(sp->name);
  458.     if (v != sp->value) {
  459.         putchr('+');
  460.         prtn(v - sp->value, 0);
  461.     }
  462.     return;
  463. }
  464.  
  465. rdsub(from, to, n, pid)
  466. char *from, *to;
  467. int n, pid;
  468. {
  469.     long l[2];
  470.     register int off;
  471.  
  472.     off = (int)from & (sizeof(l[0]) - 1);
  473.     from -= off;
  474.     l[0] = ptrace(RD_DATA, pid, from, 0);
  475.     if ((off + n) > sizeof(l[0]))
  476.         l[1] = ptrace(RD_DATA, pid, from + sizeof(l[0]), 0);
  477.     bcopy((char *)l + off, to, n);
  478.     return;
  479. }
  480.  
  481. wrsub(from, to, n, pid)
  482. char *from, *to;
  483. int n, pid;
  484. {
  485.     long l[2];
  486.     register int off;
  487.  
  488.     off = (int)to & (sizeof(l[0]) - 1);
  489.     to -= off;
  490.     if (off || n != sizeof(l[0]))
  491.         l[0] = ptrace(RD_DATA, pid, to, 0);
  492.     if ((off + n) > sizeof(l[0]))
  493.         l[1] = ptrace(RD_DATA, pid, to + sizeof(l[0]), 0);
  494.     bcopy(from, (char *)l + off, n);
  495.     ptrace(WR_DATA, pid, to, l[0]);
  496.     if ((off + n) > sizeof(l[0]))
  497.         ptrace(WR_DATA, pid, to + sizeof(l[0]), l[1]);
  498.     return;
  499. }
  500.  
  501. cmdsreg(c,fmt,get)
  502. int c;
  503. char *fmt;
  504. long (*get)();
  505. {
  506.     char buf[10], *cp, c;
  507.     int i;
  508.     struct regs *rp, *findreg();    
  509.  
  510.     cp = buf;
  511.     i = 0;
  512.     while (i<5 && (c = getchr()) != '\n') {
  513.         i++;
  514.         *cp++ = c;
  515.     }
  516.     *cp = '\0';
  517.     if (c == '\n')
  518.         pushc('\n');
  519.  
  520.     if (rp = findreg(buf)) {
  521.         *rp->value = dot;
  522.         return;
  523.     }
  524.     error(BADRNAME);
  525. }
  526.