home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume6 / 68kdisasm / patch01 next >
Encoding:
Internet Message Format  |  1989-02-09  |  44.3 KB

  1. Path: uunet!allbery
  2. From: allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc)
  3. Newsgroups: comp.sources.misc
  4. Subject: v06i038: 68K COFF dissassembler - patch 1
  5. Message-ID: <48167@uunet.UU.NET>
  6. Date: 4 Feb 89 03:25:21 GMT
  7. Sender: allbery@uunet.UU.NET
  8. Reply-To: alex@umbc3.umbc.edu (Alex S. Crain)
  9. Lines: 1941
  10. Approved: allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc)
  11.  
  12. Posting-number: Volume 6, Issue 38
  13. Submitted-by: alex@umbc3.umbc.edu (Alex S. Crain)
  14. Archive-name: 68kdisasm/patch01
  15.  
  16.     These patches are for the 68K COFF dissassembler that passed through
  17. here some time ago. It makes the dissassembler pretty specific to AT&Ts
  18. UNIX-PC, but if you have one of those, it does some pretty neat stuff. See
  19. the ChangeLog file for details.
  20.  
  21.                     :alex
  22. Alex Crain
  23. Systems Programmer            alex@umbc3.umbc.edu       (NEW DOMAIN!)
  24. Univ Md Baltimore County        nerwin!alex@umbc3.umbc.edu
  25.  
  26.     BTW: some of this code is copyrighted to various people. I didn't
  27. remove any copyrights, but I don't think that I added any here, and at this
  28. point, if you can pull a profit off this sucker, you diserve the bread you 
  29. get. Course, you've gotta maintain it :-).
  30.  
  31. ------------------------------ snip,snip,snip ---------------------------------
  32. #!/bin/sh
  33. # shar:    Shell Archiver  (v1.22)
  34. #
  35. #    Run the following text with /bin/sh to create:
  36. #      ChangeLog
  37. #      DIFFS
  38. #      Makefile
  39. #      README.diffs
  40. #      constant.c
  41. #      kernal.h
  42. #      parseifile.h
  43. #      parseifile.y
  44. #
  45. sed 's/^X//' << 'SHAR_EOF' > ChangeLog &&
  46. XWed Jan 18 00:45:24 1989  Alex  (alex at nerwin)
  47. X
  48. X    * constant.c [lookp_address ()] - change to return a value for any
  49. X    legal shlib address (0x300000 -> 0x380000), instead of the first &
  50. X    last symbols.
  51. X
  52. X    * kernal.h - fill this file with interesting addresses.
  53. X
  54. X    * alloc.c [mkdref ()] allow for addresses to point to objects of
  55. X    length 0.
  56. X
  57. XTue Jan 17 11:14:21 1989  Alex  (alex at nerwin)
  58. X
  59. X    * main.c [doopts ()] - added two globals, kernal and dup_error,
  60. X    which are turned on with -k and -D respectively, to turn on kernal
  61. X    symbol lookup and DUP??? symbol names (and errors).
  62. X
  63. X    * robj.c [dosymb ()] - added a test for dup_error in the case of
  64. X    duplicate symbols. If dup_error is not set, duplicate symbols are
  65. X    simply ignores.
  66. X
  67. XMon Jan 16 23:53:26 1989  Alex  (alex at nerwin)
  68. X
  69. X    * constant.c [replaces syms.c] - instead of syms.c, generate
  70. X    shlib.h in the same manner. include this file, along with kernal.h
  71. X    into constants.c which contains the lookup code. lookup_address ()
  72. X    looks up an address in he shared library symbols (shlib.h) and
  73. X    returns a symbol and option offset in a single string. 
  74. X    lookup_kernal_address () is simular but does not calculate an
  75. X    offset, retunring 0 if the address is not found.
  76. X
  77. X    * iset.c - many small changes
  78. X    [prea ()] - output a '&' before a constant hex address.
  79. X    [pmovc ()] - format MOVEC as MOV
  80. X    [pcs2 ()] - movm becomes mov.m, ouput a '%' before dest register name.
  81. X
  82. XSun Jan 15 22:37:48 1989  Alex  (alex at nerwin)
  83. X
  84. X    * syms.c [lookup_address()] - this now returns either:
  85. X         a) a symbol name
  86. X         b) a symbol name + an offset as a single string ("%s+0x%x")
  87. X         c) (char *) 0 if the given address is greater then the larest
  88. X         known symbol value.
  89. X
  90. X
  91. XMon Jan  9 00:08:25 1989  Alex  (alex at nerwin)
  92. X
  93. X    * parseifile.c [new file] - generate a file containing a sorted,
  94. X    initialized array of shared library symbols that can be loaded
  95. X    into the disassembler.
  96. X    
  97. X    * syms.c [new file] - generated by parseifile.
  98. X
  99. X    * iset.c [paddr()] - try to resolve unknown hex addresses by 
  100. X    first looking them up in the initialized array with
  101. X    lookup_address(). If this doesn't work, try to generate a label
  102. X    for the address with mkdlab(). At this point we are only printing
  103. X    absolute address that don't exist in the text or data areas, and
  104. X    arn't referenced in /lib/shlib.ifile.
  105. X
  106. X    * prin.c [pdata(), pbss()] - teach the print routines about 0
  107. X    length objects. We handle these by searhingthrough memory to find
  108. X    the next object, and using the difference as the size of the
  109. X    current one.
  110. X
  111. X    * prin.c [ptext()] - add a _start symbol to the beginning of the
  112. X    text area. Don't verify the entry point, though.
  113. X
  114. SHAR_EOF
  115. chmod 0666 ChangeLog || echo "restore of ChangeLog fails"
  116. sed 's/^X//' << 'SHAR_EOF' > DIFFS &&
  117. X*** olddis/alloc.c    Fri Jan 20 11:13:48 1989
  118. X--- test/alloc.c    Sat Jan 21 20:45:31 1989
  119. X***************
  120. X*** 286,292
  121. X      if  (dent.d_type != D_BYTE)  {
  122. X          if  (dent.d_type != wsize)  {
  123. X              if  (dent.d_type == D_ADDR)  {
  124. X!                 if  (wsize != D_LONG)
  125. X                      unimpl("Addr word usage");
  126. X              }
  127. X              else  if  (dent.d_type > wsize)  {
  128. X
  129. X--- 286,292 -----
  130. X      if  (dent.d_type != D_BYTE)  {
  131. X          if  (dent.d_type != wsize)  {
  132. X              if  (dent.d_type == D_ADDR)  {
  133. X!                 if  (wsize != D_LONG && size > 0)
  134. X                      unimpl("Addr word usage");
  135. X              }
  136. X              else  if  (dent.d_type > wsize)  {
  137. X*** olddis/conv.c    Fri Jan 20 11:13:49 1989
  138. X--- test/conv.c    Sun Jan 22 22:13:47 1989
  139. X***************
  140. X*** 9,15
  141. X      unsigned suntype;
  142. X  
  143. X      /*    everything in shlib is an external constant    */
  144. X!     if (sym->n_value >= 0x300000) {
  145. X      sym->n_scnum = N_ABS;
  146. X           sym->n_sclass = C_EXT;
  147. X      }
  148. X
  149. X--- 9,15 -----
  150. X      unsigned suntype;
  151. X  
  152. X      /*    everything in shlib is an external constant    */
  153. X!     if (sym->n_value >= 0x300000 && sym->n_value < 0x380000) {
  154. X      sym->n_scnum = N_ABS;
  155. X           sym->n_sclass = C_EXT;
  156. X      }
  157. X*** olddis/heur.c    Fri Jan 20 11:13:59 1989
  158. X--- test/heur.c    Sun Jan 22 19:06:25 1989
  159. X***************
  160. X*** 312,318
  161. X      int    lng;
  162. X      long    npos;
  163. X  
  164. X!     while  (pos < endt)  {
  165. X          gette(&mainfile, pos, &tent);
  166. X          if  (tent.t_amap)    /*  Been here  */
  167. X              return;
  168. X
  169. X--- 312,318 -----
  170. X      int    lng;
  171. X      long    npos;
  172. X  
  173. X!     while  (pos && pos < endt)  {
  174. X          gette(&mainfile, pos, &tent);
  175. X          if  (tent.t_amap)    /*  Been here  */
  176. X              return;
  177. X***************
  178. X*** 362,368
  179. X      int    lng;
  180. X      
  181. X      endt = mainfile.ef_tbase + mainfile.ef_tsize;
  182. X!     pos = mainfile.ef_entry;
  183. X  nextv:
  184. X      for  (;  pos < endt;)  {
  185. X          gette(&mainfile, pos, &tent);
  186. X
  187. X--- 362,369 -----
  188. X      int    lng;
  189. X      
  190. X      endt = mainfile.ef_tbase + mainfile.ef_tsize;
  191. X!     if ((pos = mainfile.ef_entry) == 0) 
  192. X!         pos = mainfile.ef_tbase;
  193. X  nextv:
  194. X      for  (;  pos < endt;)  {
  195. X          gette(&mainfile, pos, &tent);
  196. X*** olddis/iset.c    Fri Jan 20 11:13:20 1989
  197. X--- test/iset.c    Tue Jan 24 12:52:24 1989
  198. X***************
  199. X*** 35,40
  200. X  void    mkdref();
  201. X  long    gettw();
  202. X  symbol    textlab();
  203. X  
  204. X  int    l1(), l2(), el1(), lea(), lmove(), lcbch(), jj();
  205. X  int    limed(), lsbit(), lmvml(), lone(), loone(), lonew(), lonel();
  206. X
  207. X--- 35,41 -----
  208. X  void    mkdref();
  209. X  long    gettw();
  210. X  symbol    textlab();
  211. X+ char *    lookup_address(), * lookup_kernal_address ();
  212. X  
  213. X  int    l1(), l2(), el1(), lea(), lmove(), lcbch(), jj();
  214. X  int    limed(), lsbit(), lmvml(), lone(), loone(), lonew(), lonel();
  215. X***************
  216. X*** 104,111
  217. X      0xf100, 0x5000, lone,  pqu,   "add",
  218. X      0xf100, 0x5100, lone,  pqu,   "sub",
  219. X      0xf100, 0x7000, l1,    pmqu,  0,
  220. X!     0xf1c0, 0x80c0, lonew, podreg,"divu",
  221. X!     0xf1c0, 0x81c0, lonew, podreg,"divs",
  222. X      0xf1f0, 0x8100, l1,    ptreg, "sbcd",
  223. X      0xf000, 0x8000, loone, pomode,"or",
  224. X      0xf1f0, 0x9100, l1,    ptreg, "subx.b",
  225. X
  226. X--- 105,112 -----
  227. X      0xf100, 0x5000, lone,  pqu,   "add",
  228. X      0xf100, 0x5100, lone,  pqu,   "sub",
  229. X      0xf100, 0x7000, l1,    pmqu,  0,
  230. X!     0xf1c0, 0x80c0, lonew, podreg,"divu.w",
  231. X!     0xf1c0, 0x81c0, lonew, podreg,"divs.w",
  232. X      0xf1f0, 0x8100, l1,    ptreg, "sbcd",
  233. X      0xf000, 0x8000, loone, pomode,"or",
  234. X      0xf1f0, 0x9100, l1,    ptreg, "subx.b",
  235. X***************
  236. X*** 118,125
  237. X      0xf100, 0xb000, loone, pomode,"cmp",
  238. X      0xf1c0, 0xb1c0, loone, pomode,"cmp",
  239. X      0xf100, 0xb100, loone, pomode,"eor",
  240. X!     0xf1c0, 0xc0c0, lonew, podreg,"mulu",
  241. X!     0xf1c0, 0xc1c0, lonew, podreg,"muls",
  242. X      0xf1f0, 0xc100, l1,    ptreg, "abcd",
  243. X      0xf130, 0xc100, l1,    pexg,  0,
  244. X      0xf000, 0xc000, loone, pomode,"and",
  245. X
  246. X--- 119,126 -----
  247. X      0xf100, 0xb000, loone, pomode,"cmp",
  248. X      0xf1c0, 0xb1c0, loone, pomode,"cmp",
  249. X      0xf100, 0xb100, loone, pomode,"eor",
  250. X!     0xf1c0, 0xc0c0, lonew, podreg,"mulu.w",
  251. X!     0xf1c0, 0xc1c0, lonew, podreg,"muls.w",
  252. X      0xf1f0, 0xc100, l1,    ptreg, "abcd",
  253. X      0xf130, 0xc100, l1,    pexg,  0,
  254. X      0xf000, 0xc000, loone, pomode,"and",
  255. X***************
  256. X*** 420,426
  257. X   */
  258. X  
  259. X  void prind(n)
  260. X! unsigned short n;
  261. X  {
  262. X      if ((short) n > -128 && (short) n < 128)
  263. X          (void) printf("%d", (long) ((short) n));
  264. X
  265. X--- 421,427 -----
  266. X   */
  267. X  
  268. X  void prind(n)
  269. X!      long n;
  270. X  {
  271. X     if (n & 0x8000) n |= 0xffff0000;
  272. X     (void) printf (((n > 128 || n < -128) ? "0x%x" : "%d"), n);
  273. X***************
  274. X*** 422,431
  275. X  void prind(n)
  276. X  unsigned short n;
  277. X  {
  278. X!     if ((short) n > -128 && (short) n < 128)
  279. X!         (void) printf("%d", (long) ((short) n));
  280. X!     else
  281. X!         (void) printf("0x%x",(unsigned long) n);
  282. X  }
  283. X     
  284. X  int    findleng(tc)
  285. X
  286. X--- 423,430 -----
  287. X  void prind(n)
  288. X       long n;
  289. X  {
  290. X!    if (n & 0x8000) n |= 0xffff0000;
  291. X!    (void) printf (((n > 128 || n < -128) ? "0x%x" : "%d"), n);
  292. X  }
  293. X         
  294. X  
  295. X***************
  296. X*** 446,453
  297. X  char * reg;
  298. X  unsigned  disp;
  299. X  {
  300. X- int    szc;
  301. X- 
  302. X      (void) printf("%d(%s,", disp & 0xff, reg);
  303. X      if  (disp & 0x8000) {
  304. X          (void) fputs(areg[(disp >> 12) & 0x7]);
  305. X
  306. X--- 446,451 -----
  307. X  char * reg;
  308. X  unsigned  disp;
  309. X  {
  310. X      (void) printf("%d(%s,", disp & 0xff, reg);
  311. X      if  (disp & 0x8000) {
  312. X          (void) fputs(areg[(disp >> 12) & 0x7], stdout);
  313. X***************
  314. X*** 450,456
  315. X  
  316. X      (void) printf("%d(%s,", disp & 0xff, reg);
  317. X      if  (disp & 0x8000) {
  318. X!         (void) fputs(areg[(disp >> 12) & 0x7]);
  319. X          (void) putchar('.');
  320. X      }
  321. X      else
  322. X
  323. X--- 448,454 -----
  324. X  {
  325. X      (void) printf("%d(%s,", disp & 0xff, reg);
  326. X      if  (disp & 0x8000) {
  327. X!         (void) fputs(areg[(disp >> 12) & 0x7], stdout);
  328. X          (void) putchar('.');
  329. X      }
  330. X      else
  331. X***************
  332. X*** 466,471
  333. X  {
  334. X      t_entry    tent;
  335. X      symbol    symb;
  336. X  
  337. X      gette(&mainfile, pos, &tent);
  338. X      if  (tent.t_relsymb != NULL)  {
  339. X
  340. X--- 464,473 -----
  341. X  {
  342. X      t_entry    tent;
  343. X      symbol    symb;
  344. X+     long t_pos;
  345. X+     int pass2 = 0, i;
  346. X+     char *p;
  347. X+     extern char kernal;
  348. X  
  349. X       start:
  350. X      /*
  351. X***************
  352. X*** 467,472
  353. X      t_entry    tent;
  354. X      symbol    symb;
  355. X  
  356. X      gette(&mainfile, pos, &tent);
  357. X      if  (tent.t_relsymb != NULL)  {
  358. X          symb = tent.t_relsymb;
  359. X
  360. X--- 469,479 -----
  361. X      char *p;
  362. X      extern char kernal;
  363. X  
  364. X+      start:
  365. X+     /*
  366. X+      *  look up the address and see if it has a label. 
  367. X+      *  If so, print the label and return.
  368. X+      */
  369. X      gette(&mainfile, pos, &tent);
  370. X      if  (tent.t_relsymb != NULL)  {
  371. X          symb = tent.t_relsymb;
  372. X***************
  373. X*** 478,484
  374. X              (void) printf("+0x%x", tent.t_reldisp);
  375. X          return;
  376. X      }
  377. X!     if ((pos = gettw(&mainfile, pos, R_LONG)) >= 0x290000)
  378. X       {
  379. X          register int i;
  380. X          for (i=0; i < abstab.c_int; i++)
  381. X
  382. X--- 485,515 -----
  383. X              (void) printf("+0x%x", tent.t_reldisp);
  384. X          return;
  385. X      }
  386. X! 
  387. X!     /*
  388. X!      *  No label, so calculate the address to print (like gettw)
  389. X!      *
  390. X!      */
  391. X!     t_pos = tent.t_contents;
  392. X!     gette(&mainfile, pos+2, &tent);
  393. X!     t_pos = (t_pos << 16) + tent.t_contents;
  394. X! 
  395. X!     /*
  396. X!      *  check the list of absolute symbols.
  397. X!      */
  398. X! 
  399. X!     for (i=0; i < abstab.c_int; i++)
  400. X!            if (abstab.c_symb[i]->s_value == t_pos)
  401. X!         {         
  402. X!            (void) fputs(abstab.c_symb[i]->s_name, stdout);
  403. X!            return;
  404. X!         }
  405. X! 
  406. X!     /*
  407. X!      *  check the list of shlib constants.
  408. X!      */
  409. X! 
  410. X!     if (p = lookup_address(t_pos))
  411. X       {
  412. X          (void) fputs(p, stdout);
  413. X          return;
  414. X***************
  415. X*** 480,492
  416. X      }
  417. X      if ((pos = gettw(&mainfile, pos, R_LONG)) >= 0x290000)
  418. X       {
  419. X!         register int i;
  420. X!         for (i=0; i < abstab.c_int; i++)
  421. X!             if (abstab.c_symb[i]->s_value == pos)
  422. X!          {         
  423. X!             (void) fputs(abstab.c_symb[i]->s_name, stdout);
  424. X!             return;
  425. X!          }
  426. X       }
  427. X      (void) printf("0x%x", pos);
  428. X  }
  429. X
  430. X--- 511,518 -----
  431. X  
  432. X      if (p = lookup_address(t_pos))
  433. X       {
  434. X!         (void) fputs(p, stdout);
  435. X!         return;
  436. X       }
  437. X  
  438. X      /*
  439. X***************
  440. X*** 488,494
  441. X              return;
  442. X           }
  443. X       }
  444. X!     (void) printf("0x%x", pos);
  445. X  }
  446. X  
  447. X  int    prea(ea, pos, sz)
  448. X
  449. X--- 514,547 -----
  450. X          (void) fputs(p, stdout);
  451. X          return;
  452. X       }
  453. X! 
  454. X!     /*
  455. X!      *  If this is kernal code, lookup our kernal addresses.
  456. X!      */
  457. X! 
  458. X!     if (kernal && (p = lookup_kernal_address(t_pos)))
  459. X!      {
  460. X!         (void) fputs (p, stdout);
  461. X!         return;
  462. X!      }
  463. X! 
  464. X!     /* If we've tried this already, just print the address and return. */
  465. X!     if (pass2)
  466. X!      {
  467. X!         (void) printf("&0x%x", t_pos); 
  468. X!         return;
  469. X!      }
  470. X! 
  471. X!     /* we couldn't match up the address with anything, so decide that
  472. X!        its data and give it a label. Its really too late to do this, 
  473. X!        because by the time this gets called, we cant do backward 
  474. X!        referencing. */
  475. X! 
  476. X!     mkdref(pos,0);
  477. X!     pass2 = 1;
  478. X!     goto start;
  479. X! 
  480. X!     /*NOTREACHED*/
  481. X  }
  482. X  
  483. X  int    prea(ea, pos, sz)
  484. X***************
  485. X*** 529,534
  486. X          switch  (reg)  {
  487. X          case  0:
  488. X              disp = gettw(&mainfile, pos, R_WORD);
  489. X              (void) prind(disp);
  490. X              (void) putchar('.');
  491. X              (void) putchar('w');
  492. X
  493. X--- 582,588 -----
  494. X          switch  (reg)  {
  495. X          case  0:
  496. X              disp = gettw(&mainfile, pos, R_WORD);
  497. X+             (void) putchar('&');
  498. X              (void) prind(disp);
  499. X              return    2;
  500. X          case  1:
  501. X***************
  502. X*** 530,537
  503. X          case  0:
  504. X              disp = gettw(&mainfile, pos, R_WORD);
  505. X              (void) prind(disp);
  506. X-             (void) putchar('.');
  507. X-             (void) putchar('w');
  508. X              return    2;
  509. X          case  1:
  510. X              paddr(pos);
  511. X
  512. X--- 584,589 -----
  513. X              disp = gettw(&mainfile, pos, R_WORD);
  514. X              (void) putchar('&');
  515. X              (void) prind(disp);
  516. X              return    2;
  517. X          case  1:
  518. X              paddr(pos);
  519. X***************
  520. X*** 538,544
  521. X              return    4;
  522. X          case  2:{
  523. X              symbol symb;
  524. X!             register int addr;
  525. X              disp = 
  526. X                  ((short) gettw(&mainfile, pos, R_WORD));
  527. X                if ((addr=pos+disp) < 0  ||  
  528. X
  529. X--- 590,596 -----
  530. X              return    4;
  531. X          case  2:{
  532. X              symbol symb;
  533. X!             register long addr;
  534. X              disp = 
  535. X                  ((short) gettw(&mainfile, pos, R_WORD));
  536. X                if ((addr=pos+disp) < 0  ||  
  537. X***************
  538. X*** 570,577
  539. X              piword("%pc", (unsigned)gettw(&mainfile, pos, R_WORD));
  540. X              return    2;
  541. X          case  4:
  542. X!             (void) putchar('&');
  543. X!             if  (sz < 4)
  544. X                  (void) prind(gettw(&mainfile, pos, R_WORD));
  545. X              else
  546. X                  paddr(pos);
  547. X
  548. X--- 622,629 -----
  549. X              piword("%pc", (unsigned)gettw(&mainfile, pos, R_WORD));
  550. X              return    2;
  551. X          case  4:
  552. X!             if  (sz < 4) {
  553. X!                 (void) putchar('&');
  554. X                  (void) prind(gettw(&mainfile, pos, R_WORD));
  555. X              }
  556. X              else
  557. X***************
  558. X*** 573,578
  559. X              (void) putchar('&');
  560. X              if  (sz < 4)
  561. X                  (void) prind(gettw(&mainfile, pos, R_WORD));
  562. X              else
  563. X                  paddr(pos);
  564. X              return    sz;
  565. X
  566. X--- 625,631 -----
  567. X              if  (sz < 4) {
  568. X                  (void) putchar('&');
  569. X                  (void) prind(gettw(&mainfile, pos, R_WORD));
  570. X+             }
  571. X              else
  572. X                  paddr(pos);
  573. X              return    sz;
  574. X***************
  575. X*** 692,698
  576. X      int    disp = gettw(&mainfile, pos+2, R_WORD);
  577. X      int    ctrl = ((disp >> 10) & 2) | (disp & 1);
  578. X  
  579. X!     (void) fputs("movc\t", stdout);
  580. X      if  ((te->t_contents & 1) == 0)
  581. X          (void) fputs(creg[ctrl], stdout);
  582. X      if  (disp & 0x8000)
  583. X
  584. X--- 745,751 -----
  585. X      int    disp = gettw(&mainfile, pos+2, R_WORD);
  586. X      int    ctrl = ((disp >> 10) & 2) | (disp & 1);
  587. X  
  588. X!     (void) fputs("mov\t", stdout);
  589. X      if  ((te->t_contents & 1) == 0)
  590. X          (void) fputs(creg[ctrl], stdout);
  591. X      if  (disp & 0x8000)
  592. X***************
  593. X*** 714,720
  594. X  
  595. X      /* we need to swith the operands to compare instrucions. */
  596. X      if (strcmp (optab[te->t_iindex].prarg, "cmp")) {
  597. X!         (void) printf("%s.%c\t&", optab[te->t_iindex].prarg, sz);
  598. X          if  (sz == 'l')  {
  599. X              paddr(pos+2);
  600. X              (void) putchar(',');
  601. X
  602. X--- 767,773 -----
  603. X  
  604. X      /* we need to swith the operands to compare instrucions. */
  605. X      if (strcmp (optab[te->t_iindex].prarg, "cmp")) {
  606. X!         (void) printf("%s.%c\t", optab[te->t_iindex].prarg, sz);
  607. X          if  (sz == 'l')  {
  608. X              paddr(pos+2);
  609. X              (void) putchar(',');
  610. X***************
  611. X*** 721,726
  612. X              (void) prea(te->t_contents, pos+4, 4);
  613. X          }
  614. X          else  {
  615. X              (void) prind(gettw(&mainfile, pos+2, R_WORD));
  616. X              (void) putchar(',');
  617. X              (void) prea(te->t_contents, pos+2, 2);
  618. X
  619. X--- 774,780 -----
  620. X              (void) prea(te->t_contents, pos+4, 4);
  621. X          }
  622. X          else  {
  623. X+                 (void) putchar('&');
  624. X              (void) prind(gettw(&mainfile, pos+2, R_WORD));
  625. X              (void) putchar(',');
  626. X              (void) prea(te->t_contents, pos+2, 2);
  627. X***************
  628. X*** 731,737
  629. X          if  (sz == 'l')  {
  630. X              (void) prea(te->t_contents, pos+4, 4);
  631. X              (void) putchar(',');
  632. X-             (void) putchar('&');
  633. X              paddr(pos+2);
  634. X          }
  635. X          else  {
  636. X
  637. X--- 785,790 -----
  638. X          if  (sz == 'l')  {
  639. X              (void) prea(te->t_contents, pos+4, 4);
  640. X              (void) putchar(',');
  641. X              paddr(pos+2);
  642. X          }
  643. X          else  {
  644. X***************
  645. X*** 804,810
  646. X  {
  647. X      unsigned  tc  =  te->t_contents;
  648. X      
  649. X!     (void) fputs("movw\t", stdout);
  650. X      if  ((tc & 0xffc0) == 0x40c0)  {
  651. X          (void) fputs("%sr,", stdout);
  652. X          (void) prea(tc, pos, 2);
  653. X
  654. X--- 857,863 -----
  655. X  {
  656. X      unsigned  tc  =  te->t_contents;
  657. X      
  658. X!     (void) fputs("mov.w\t", stdout);
  659. X      if  ((tc & 0xffc0) == 0x40c0)  {
  660. X          (void) fputs("%sr,", stdout);
  661. X          (void) prea(tc, pos, 2);
  662. X***************
  663. X*** 812,817
  664. X      else  {
  665. X          (void) prea(tc, pos, 2);
  666. X          (void) putchar(',');
  667. X          (void) fputs(optab[te->t_iindex].prarg, stdout);
  668. X      }
  669. X  }
  670. X
  671. X--- 865,871 -----
  672. X      else  {
  673. X          (void) prea(tc, pos, 2);
  674. X          (void) putchar(',');
  675. X+         (void) putchar('%');
  676. X          (void) fputs(optab[te->t_iindex].prarg, stdout);
  677. X      }
  678. X  }
  679. X***************
  680. X*** 831,837
  681. X  t_entry    *te;
  682. X  long    pos;
  683. X  {
  684. X!     if (! strncmp(optab[te->t_iindex].prarg, "tas") && 
  685. X          (te->t_contents & 0x3f) == 0x3c) {
  686. X          symbol symb;
  687. X          t_entry tstr;
  688. X
  689. X--- 885,891 -----
  690. X  t_entry    *te;
  691. X  long    pos;
  692. X  {
  693. X!     if (! strcmp(optab[te->t_iindex].prarg, "tas") && 
  694. X          (te->t_contents & 0x3f) == 0x3c) {
  695. X          symbol symb;
  696. X          t_entry tstr;
  697. X***************
  698. X*** 836,843
  699. X          symbol symb;
  700. X          t_entry tstr;
  701. X          int counter = te->t_lng -2;
  702. X!         int offset = (pos += 4);
  703. X!         int dest;
  704. X          char * sw_label;
  705. X  
  706. X          (void) printf("swbeg\t&%d\n", counter);
  707. X
  708. X--- 890,897 -----
  709. X          symbol symb;
  710. X          t_entry tstr;
  711. X          int counter = te->t_lng -2;
  712. X!         long offset = (pos += 4);
  713. X!         long dest;
  714. X          char * sw_label;
  715. X  
  716. X          (void) printf("swbeg\t&%d\n", counter);
  717. X***************
  718. X*** 843,849
  719. X          (void) printf("swbeg\t&%d\n", counter);
  720. X  
  721. X          symb = textlab(pos, pos);
  722. X!         printf("%s:\n", sw_label = symb->s_name);
  723. X  
  724. X          while (counter--) {
  725. X              gette(&mainfile, pos, &tstr);
  726. X
  727. X--- 897,903 -----
  728. X          (void) printf("swbeg\t&%d\n", counter);
  729. X  
  730. X          symb = textlab(pos, pos);
  731. X!         (void) printf("%s:\n", sw_label = symb->s_name);
  732. X  
  733. X          while (counter--) {
  734. X              gette(&mainfile, pos, &tstr);
  735. X***************
  736. X*** 854,860
  737. X                    || dest >= mainfile.ef_tbase+mainfile.ef_tsize
  738. X                    || (dest & 1) != 0 )) {
  739. X                  if (symb = textlab(dest,offset))
  740. X!                     printf("\tshort\t%s-%s\n", 
  741. X                          symb->s_name,sw_label);
  742. X                  else
  743. X                      printf("\tshort\t0x%x\t# Can't label destination.\n", 
  744. X
  745. X--- 908,914 -----
  746. X                    || dest >= mainfile.ef_tbase+mainfile.ef_tsize
  747. X                    || (dest & 1) != 0 )) {
  748. X                  if (symb = textlab(dest,offset))
  749. X!                     (void) printf("\tshort\t%s-%s\n", 
  750. X                          symb->s_name,sw_label);
  751. X                  else
  752. X                      (void) printf("\tshort\t0x%x\t# Can't label destination.\n", 
  753. X***************
  754. X*** 857,863
  755. X                      printf("\tshort\t%s-%s\n", 
  756. X                          symb->s_name,sw_label);
  757. X                  else
  758. X!                     printf("\tshort\t0x%x\t# Can't label destination.\n", 
  759. X                              tstr.t_contents);
  760. X              }
  761. X              else 
  762. X
  763. X--- 911,917 -----
  764. X                      (void) printf("\tshort\t%s-%s\n", 
  765. X                          symb->s_name,sw_label);
  766. X                  else
  767. X!                     (void) printf("\tshort\t0x%x\t# Can't label destination.\n", 
  768. X                              tstr.t_contents);
  769. X              }
  770. X              else 
  771. X***************
  772. X*** 861,867
  773. X                              tstr.t_contents);
  774. X              }
  775. X              else 
  776. X!                 printf("\tshort\t0x%x\t# Illegal address\n", 
  777. X                          tstr.t_contents);
  778. X              pos += 2;
  779. X          }
  780. X
  781. X--- 915,921 -----
  782. X                              tstr.t_contents);
  783. X              }
  784. X              else 
  785. X!                 (void) printf("\tshort\t0x%x\t# Illegal address\n", 
  786. X                          tstr.t_contents);
  787. X              pos += 2;
  788. X          }
  789. X***************
  790. X*** 964,971
  791. X  t_entry    *te;
  792. X  long    pos;
  793. X  {
  794. X!     (void) printf("link\t%s,&%d", areg[te->t_contents & 0x7],
  795. X!                 gettw(&mainfile, pos+2, R_WORD));
  796. X  }
  797. X  
  798. X  
  799. X
  800. X--- 1018,1025 -----
  801. X  t_entry    *te;
  802. X  long    pos;
  803. X  {
  804. X!     (void) printf("link\t%s,&", areg[te->t_contents & 0x7]);
  805. X!     prind (gettw(&mainfile, pos+2, R_WORD));
  806. X  }
  807. X  
  808. X  
  809. X*** olddis/libmtch.c    Fri Jan 20 11:13:25 1989
  810. X--- test/libmtch.c    Sat Jan 21 20:45:34 1989
  811. X***************
  812. X*** 102,108
  813. X      char    *bp, *ep = NULL, *pathb, *pathe, *fullpath = NULL;
  814. X      static    char    *pathn;
  815. X      extern    char    *getenv();
  816. X-      char    magic[8];
  817. X      struct    ar_hdr    arhdr;
  818. X      LDFILE *ldptr;
  819. X  
  820. X
  821. X--- 102,107 -----
  822. X      char    *bp, *ep = NULL, *pathb, *pathe, *fullpath = NULL;
  823. X      static    char    *pathn;
  824. X      extern    char    *getenv();
  825. X      struct    ar_hdr    arhdr;
  826. X      LDFILE *ldptr;
  827. X  
  828. X***************
  829. X*** 153,160
  830. X  found:
  831. X  
  832. X      str = fullpath? fullpath: str;
  833. X!      if  (FREAD(magic, sizeof(magic),1,ldptr) != 1  ||
  834. X!          strcmp(magic, ARMAG) != 0)  {
  835. X          if  (ep != NULL)  {
  836. X              (void) fprintf(stderr, "%s is not library file\n", str);
  837. X              exit(103);
  838. X
  839. X--- 152,158 -----
  840. X  found:
  841. X  
  842. X      str = fullpath? fullpath: str;
  843. X!      if  (TYPE(ldptr) != ARTYPE) {
  844. X          if  (ep != NULL)  {
  845. X              (void) fprintf(stderr, "%s is not library file\n", str);
  846. X              exit(103);
  847. X*** olddis/main.c    Fri Jan 20 11:14:02 1989
  848. X--- test/main.c    Sat Jan 21 20:45:35 1989
  849. X***************
  850. X*** 46,51
  851. X  int    rel;            /*  File being analysed is relocatable  */
  852. X  int    lpos;
  853. X  char    shlibout;        /*  output values for shlib constants */
  854. X  
  855. X  symbol    dosymb();
  856. X  struct    libit    *getfnam();
  857. X
  858. X--- 46,53 -----
  859. X  int    rel;            /*  File being analysed is relocatable  */
  860. X  int    lpos;
  861. X  char    shlibout;        /*  output values for shlib constants */
  862. X+ char    kernal;
  863. X+ char    dup_error;
  864. X  
  865. X  symbol    dosymb();
  866. X  struct    libit    *getfnam();
  867. X***************
  868. X*** 50,55
  869. X  symbol    dosymb();
  870. X  struct    libit    *getfnam();
  871. X  
  872. X  /*
  873. X   *    Get hex characters, also allowing for 'k' and 'm'.
  874. X   */
  875. X
  876. X--- 52,58 -----
  877. X  symbol    dosymb();
  878. X  struct    libit    *getfnam();
  879. X  
  880. X+ #if 0
  881. X  /*
  882. X   *    Get hex characters, also allowing for 'k' and 'm'.
  883. X   */
  884. X***************
  885. X*** 95,100
  886. X          }
  887. X      }
  888. X  }
  889. X  
  890. X  /*
  891. X   *    Process entry line options.  Return number dealt with.
  892. X
  893. X--- 98,104 -----
  894. X          }
  895. X      }
  896. X  }
  897. X+ #endif
  898. X  
  899. X  /*
  900. X   *    Process entry line options.  Return number dealt with.
  901. X***************
  902. X*** 136,141
  903. X              shlibout++;
  904. X              goto  nx;
  905. X  
  906. X          case  'a':
  907. X              noabs++;
  908. X              goto  nx;
  909. X
  910. X--- 140,153 -----
  911. X              shlibout++;
  912. X              goto  nx;
  913. X  
  914. X+         case 'k':
  915. X+             kernal++;
  916. X+             goto nx;
  917. X+ 
  918. X+         case 'D':
  919. X+             dup_error++;
  920. X+             goto nx;
  921. X+ 
  922. X          case  'a':
  923. X              noabs++;
  924. X              goto  nx;
  925. X***************
  926. X*** 227,233
  927. X      }
  928. X      
  929. X      lfd = getfnam(argv[1]);
  930. X!     if  (TYPE(lfd->ldptr) == ARTYPE)  {
  931. X          (void) fprintf(stderr, "Main file (%s) cannot be library\n", argv[1]);
  932. X          exit(2);
  933. X      }
  934. X
  935. X--- 239,245 -----
  936. X      }
  937. X      
  938. X      lfd = getfnam(argv[1]);
  939. X!     if  (TYPE(lfd->ldptr) == ARTYPE && lfd->lf_name[0])  {
  940. X          (void) fprintf(stderr, "Main file (%s) cannot be library\n", argv[1]);
  941. X          exit(2);
  942. X      }
  943. X***************
  944. X*** 305,308
  945. X      pbss(&mainfile);
  946. X      bfclose(&mainfile);
  947. X      exit(0);
  948. X  }
  949. X
  950. X--- 317,321 -----
  951. X      pbss(&mainfile);
  952. X      bfclose(&mainfile);
  953. X      exit(0);
  954. X+     /* NOTREACHED */
  955. X  }
  956. X*** olddis/prin.c    Fri Jan 20 11:14:05 1989
  957. X--- test/prin.c    Sat Jan 21 20:45:35 1989
  958. X***************
  959. X*** 102,108
  960. X      register  long    tpos, endt;
  961. X      t_entry    tstr;
  962. X  
  963. X!     (void) fputs("\ttext\n", stdout);
  964. X      
  965. X      tpos = fid->ef_tbase;
  966. X      endt = tpos + fid->ef_tsize;
  967. X
  968. X--- 102,108 -----
  969. X      register  long    tpos, endt;
  970. X      t_entry    tstr;
  971. X  
  972. X!     (void) fputs("\tglobal _start\n_start:\n\ttext\n", stdout);
  973. X      
  974. X      tpos = fid->ef_tbase;
  975. X      endt = tpos + fid->ef_tsize;
  976. X***************
  977. X*** 142,148
  978. X  {
  979. X      register  long    dpos, endd;
  980. X      register  int    lng, ccnt;
  981. X-     unsigned  ctyp;
  982. X      int    had, par, inc;
  983. X      char    *msg;
  984. X      d_entry    dstr;
  985. X
  986. X--- 142,147 -----
  987. X  {
  988. X      register  long    dpos, endd;
  989. X      register  int    lng, ccnt;
  990. X      int    had, par, inc;
  991. X      char    *msg;
  992. X      d_entry    dstr;
  993. X***************
  994. X*** 156,162
  995. X          
  996. X          getde(fid, dpos, &dstr);
  997. X          plabs(dstr.d_lab, S_DATA);
  998. X!             
  999. X          switch  (dstr.d_type)  {
  1000. X          case  D_CONT:
  1001. X              (void) fprintf(stderr, "Data sync error\n");
  1002. X
  1003. X--- 155,161 -----
  1004. X          
  1005. X          getde(fid, dpos, &dstr);
  1006. X          plabs(dstr.d_lab, S_DATA);
  1007. X! 
  1008. X          switch  (dstr.d_type)  {
  1009. X          case  D_CONT:
  1010. X              (void) fprintf(stderr, "Data sync error\n");
  1011. X***************
  1012. X*** 165,171
  1013. X              
  1014. X          case  D_ASC:
  1015. X          case  D_ASCZ:
  1016. X-             ctyp = dstr.d_type;
  1017. X              lng = dstr.d_lng;
  1018. X          nextline:
  1019. X              (void) fputs("\tbyte\t", stdout);
  1020. X
  1021. X--- 164,169 -----
  1022. X              
  1023. X          case  D_ASC:
  1024. X          case  D_ASCZ:
  1025. X              lng = dstr.d_lng;
  1026. X          nextline:
  1027. X              if (lng > 0)
  1028. X***************
  1029. X*** 168,176
  1030. X              ctyp = dstr.d_type;
  1031. X              lng = dstr.d_lng;
  1032. X          nextline:
  1033. X!             (void) fputs("\tbyte\t", stdout);
  1034. X!             ccnt=0;
  1035. X!             while  (lng > 0)  {
  1036. X                  if (ccnt) (void) putchar(',');
  1037. X                  getde(fid, dpos, &dstr);
  1038. X                  switch  (dstr.d_contents)  {
  1039. X
  1040. X--- 166,177 -----
  1041. X          case  D_ASCZ:
  1042. X              lng = dstr.d_lng;
  1043. X          nextline:
  1044. X!             if (lng > 0)
  1045. X!              {
  1046. X!                 (void) fputs("\tbyte\t", stdout);
  1047. X!                 ccnt=0;
  1048. X!                 while  (lng > 0)  
  1049. X!                  {
  1050. X                  if (ccnt) (void) putchar(',');
  1051. X                  getde(fid, dpos, &dstr);
  1052. X                  switch  (dstr.d_contents)  {
  1053. X***************
  1054. X*** 228,234
  1055. X                      (void) putchar('\n');
  1056. X                      goto nextline;
  1057. X                  }
  1058. X!             }
  1059. X              (void) putchar('\n');
  1060. X              break;
  1061. X  
  1062. X
  1063. X--- 229,245 -----
  1064. X                      (void) putchar('\n');
  1065. X                      goto nextline;
  1066. X                  }
  1067. X!                  }
  1068. X!              }
  1069. X!             else
  1070. X!              {
  1071. X!                 int last = dpos;
  1072. X!                 do {            
  1073. X!                    dpos += 2;
  1074. X!                    getde(fid, dpos, &dstr);
  1075. X!                 } while(dpos < endd && dstr.d_lab == (symbol) 0);
  1076. X!                 (void) printf("\tspace\t%d\n", dpos - last);
  1077. X!              }
  1078. X              (void) putchar('\n');
  1079. X              break;
  1080. X  
  1081. X***************
  1082. X*** 249,261
  1083. X              par = R_LONG;
  1084. X              inc = 4;
  1085. X          wrest:
  1086. X!             (void) putchar('\t');
  1087. X!             (void) fputs(msg, stdout);
  1088. X!             (void) putchar('\t');
  1089. X!             lng = dstr.d_lng;
  1090. X!             lpos = 16;
  1091. X!             had = 0;
  1092. X!             while  (lng > 0)  {
  1093. X                  if  (lpos > LINELNG) {
  1094. X                      (void) putchar('\n');
  1095. X                      (void) putchar('\t');
  1096. X
  1097. X--- 260,275 -----
  1098. X              par = R_LONG;
  1099. X              inc = 4;
  1100. X          wrest:
  1101. X!             if (lng > 0)
  1102. X!              {
  1103. X!                 (void) putchar('\t');
  1104. X!                 (void) fputs(msg, stdout);
  1105. X!                 (void) putchar('\t');
  1106. X!                 lng = dstr.d_lng;
  1107. X!                 lpos = 16;
  1108. X!                 had = 0;
  1109. X!                 while  (lng > 0)  
  1110. X!                  {
  1111. X                  if  (lpos > LINELNG) {
  1112. X                      (void) putchar('\n');
  1113. X                      (void) putchar('\t');
  1114. X***************
  1115. X*** 272,278
  1116. X                  lng -= inc;
  1117. X                  dpos += inc;
  1118. X                  had++;
  1119. X!             }
  1120. X              (void) putchar('\n');
  1121. X              break;
  1122. X  
  1123. X
  1124. X--- 286,302 -----
  1125. X                  lng -= inc;
  1126. X                  dpos += inc;
  1127. X                  had++;
  1128. X!                  }
  1129. X!              }
  1130. X!             else
  1131. X!              {
  1132. X!                 int last = dpos;
  1133. X!                 do {            
  1134. X!                    dpos += 2;
  1135. X!                    getde(fid, dpos, &dstr);
  1136. X!                 } while(dpos < endd && dstr.d_lab == (symbol) 0);
  1137. X!                 (void) printf("\tspace\t%d\n", dpos - last);
  1138. X!              }
  1139. X              (void) putchar('\n');
  1140. X              break;
  1141. X  
  1142. X***************
  1143. X*** 323,330
  1144. X      while  (bpos < endb)  {
  1145. X          getde(fid, bpos, &bstr);
  1146. X          plabs(bstr.d_lab, S_BSS);
  1147. X!         (void) printf("\tspace\t%d\n", bstr.d_lng);
  1148. X!         bpos += bstr.d_lng;
  1149. X      }
  1150. X      
  1151. X      getde(fid, endb, &bstr);
  1152. X
  1153. X--- 347,366 -----
  1154. X      while  (bpos < endb)  {
  1155. X          getde(fid, bpos, &bstr);
  1156. X          plabs(bstr.d_lab, S_BSS);
  1157. X!         if (bstr.d_lng)
  1158. X!          {
  1159. X!             (void) printf("\tspace\t%d\n", bstr.d_lng);
  1160. X!             bpos += bstr.d_lng;
  1161. X!          }
  1162. X!         else
  1163. X!          {
  1164. X!             int last = bpos;
  1165. X!             do {            
  1166. X!                bpos += 2;
  1167. X!                getde(fid, bpos, &bstr);
  1168. X!             } while(bpos < endb && bstr.d_lab == (symbol) 0);
  1169. X!             (void) printf("\tspace\t%d\n", bpos - last);
  1170. X!          }
  1171. X      }
  1172. X      
  1173. X      getde(fid, endb, &bstr);
  1174. X*** olddis/robj.c    Fri Jan 20 11:13:34 1989
  1175. X--- test/robj.c    Sat Jan 21 20:45:37 1989
  1176. X***************
  1177. X*** 36,43
  1178. X  long    gettw(), getdw();
  1179. X  void    reallst(), lclash(), nomem(), unimpl();
  1180. X  void    addit();
  1181. X! char    *malloc();
  1182. X! long    lseek();
  1183. X  
  1184. X  int    par_entry, par_round, nmods, donedrel, donebrel;
  1185. X  struct    commit    abstab, comtab, dreltab;
  1186. X
  1187. X--- 36,42 -----
  1188. X  long    gettw(), getdw();
  1189. X  void    reallst(), lclash(), nomem(), unimpl();
  1190. X  void    addit();
  1191. X! unsigned convtosun();
  1192. X  
  1193. X  int    nmods, donedrel, donebrel;
  1194. X  struct    commit    abstab, comtab, dreltab;
  1195. X***************
  1196. X*** 39,45
  1197. X  char    *malloc();
  1198. X  long    lseek();
  1199. X  
  1200. X! int    par_entry, par_round, nmods, donedrel, donebrel;
  1201. X  struct    commit    abstab, comtab, dreltab;
  1202. X  long    trelpos, drelpos, brelpos;
  1203. X  
  1204. X
  1205. X--- 38,44 -----
  1206. X  void    addit();
  1207. X  unsigned convtosun();
  1208. X  
  1209. X! int    nmods, donedrel, donebrel;
  1210. X  struct    commit    abstab, comtab, dreltab;
  1211. X  long    trelpos, drelpos, brelpos;
  1212. X  
  1213. X***************
  1214. X*** 378,383
  1215. X  {
  1216. X      t_entry    tstr;
  1217. X      d_entry    dstr;
  1218. X      
  1219. X      if  (!sy->s_newsym)  {
  1220. X           if  (type & S_EXT)  {
  1221. X
  1222. X--- 377,383 -----
  1223. X  {
  1224. X      t_entry    tstr;
  1225. X      d_entry    dstr;
  1226. X+     extern char dup_error;
  1227. X      
  1228. X      if  (!sy->s_newsym) {
  1229. X         if (dup_error)  {
  1230. X***************
  1231. X*** 379,392
  1232. X      t_entry    tstr;
  1233. X      d_entry    dstr;
  1234. X      
  1235. X!     if  (!sy->s_newsym)  {
  1236. X!          if  (type & S_EXT)  {
  1237. X!             (void) fprintf(stderr, "Duplicate symbol %s\n", sy->s_name);
  1238. X!             /* exit(10);  temporary? */
  1239. X!         }
  1240. X!         if  (++sy->s_defs > nmods)
  1241. X!             nmods = sy->s_defs;
  1242. X!         sy = inventsymb("DUP");
  1243. X      }
  1244. X  
  1245. X      sy->s_value = val;
  1246. X
  1247. X--- 379,396 -----
  1248. X      d_entry    dstr;
  1249. X      extern char dup_error;
  1250. X      
  1251. X!     if  (!sy->s_newsym) {
  1252. X!        if (dup_error)  {
  1253. X!           if  (type & S_EXT)  {
  1254. X!          (void) fprintf(stderr, "Duplicate symbol %s\n", sy->s_name);
  1255. X!          /* exit(10);  temporary? */
  1256. X!           }
  1257. X!           if  (++sy->s_defs > nmods)
  1258. X!            nmods = sy->s_defs;
  1259. X!           sy = inventsymb("DUP");
  1260. X!        }
  1261. X!        else
  1262. X!            return sy;
  1263. X      }
  1264. X  
  1265. X      sy->s_value = val;
  1266. X***************
  1267. X*** 656,662
  1268. X   */
  1269. X  /* trelpos, drelpos ??? */
  1270. X  
  1271. X! rrell2(ldptr, ldptr2, outf)
  1272. X  LDFILE *ldptr,*ldptr2;    /*  a.out file (possibly in library)  */
  1273. X  ef_fid    outf;        /*  Output file descriptor  */
  1274. X  {
  1275. X
  1276. X--- 660,666 -----
  1277. X   */
  1278. X  /* trelpos, drelpos ??? */
  1279. X  
  1280. X! void rrell2(ldptr, ldptr2, outf)
  1281. X  LDFILE *ldptr,*ldptr2;    /*  a.out file (possibly in library)  */
  1282. X  ef_fid    outf;        /*  Output file descriptor  */
  1283. X  {
  1284. X***************
  1285. X*** 667,673
  1286. X      struct syment isym;
  1287. X      int nreloc;
  1288. X      unsigned rtype;
  1289. X-     register  long    size;
  1290. X      register  symbol  csymb;
  1291. X      long    pos, mpos, mval, lval;
  1292. X      int    dhere = 0;        /*  Mark whether bss done  */
  1293. X
  1294. X--- 671,676 -----
  1295. X      struct syment isym;
  1296. X      int nreloc;
  1297. X      unsigned rtype;
  1298. X      register  symbol  csymb;
  1299. X      long    pos, mpos, mval, lval;
  1300. X      int    dhere = 0;        /*  Mark whether bss done  */
  1301. X***************
  1302. X*** 675,681
  1303. X      ldshread(ldptr,1,&tsect);
  1304. X      ldshread(ldptr,2,&dsect);
  1305. X       if  (tsect.s_nreloc <= 0  &&  dsect.s_nreloc <= 0)
  1306. X!         return    0;
  1307. X  
  1308. X      nreloc = tsect.s_nreloc;
  1309. X  
  1310. X
  1311. X--- 678,684 -----
  1312. X      ldshread(ldptr,1,&tsect);
  1313. X      ldshread(ldptr,2,&dsect);
  1314. X       if  (tsect.s_nreloc <= 0  &&  dsect.s_nreloc <= 0)
  1315. X!         return;
  1316. X  
  1317. X      nreloc = tsect.s_nreloc;
  1318. X  
  1319. X*** olddis/unc.h    Fri Jan 20 11:14:07 1989
  1320. X--- test/unc.h    Sat Jan 21 20:45:38 1989
  1321. X***************
  1322. X*** 178,180
  1323. X  #define S_FN   0x1f        /* file name symbol */
  1324. X  #define S_EXT  01        /* external bit, or'ed in */
  1325. X  #define S_TYPE 0x1e        /* mask for all the type bits */
  1326. X
  1327. X--- 178,185 -----
  1328. X  #define S_FN   0x1f        /* file name symbol */
  1329. X  #define S_EXT  01        /* external bit, or'ed in */
  1330. X  #define S_TYPE 0x1e        /* mask for all the type bits */
  1331. X+ 
  1332. X+ 
  1333. X+ char * malloc();
  1334. X+ void free (), exit ();
  1335. X+ long lseek();
  1336. SHAR_EOF
  1337. chmod 0666 DIFFS || echo "restore of DIFFS fails"
  1338. sed 's/^X//' << 'SHAR_EOF' > Makefile &&
  1339. XCC=gcc
  1340. XLD=/bin/ld
  1341. XCFLAGS=-O -fwritable-strings
  1342. XLDFLAGS=
  1343. XOBJS=    alloc.o file.o libmtch.o robj.o iset.o prin.o heur.o main.o \
  1344. X    conv.o constant.o
  1345. XSHAREDLIB=/lib/shlib.ifile /lib/crt0s.o
  1346. XLIBS=-lgcc
  1347. X#SHAREDLIB=/lib/crt0.o
  1348. X#LIBS=-lc
  1349. X
  1350. Xdis:    $(OBJS)
  1351. X    $(LD) $(LDFLAGS) -o dis $(OBJS) $(SHAREDLIB) -lld $(LIBS)
  1352. X
  1353. X$(OBJS): unc.h
  1354. X
  1355. Xshlib.h: parseifile
  1356. X    ./parseifile > shlib.h
  1357. X
  1358. Xparseifile: y.tab.o
  1359. X    $(LD) $(LDFLAGS) -o parseifile y.tab.o $(SHAREDLIB) $(LIBS)
  1360. X
  1361. Xy.tab.o: y.tab.c
  1362. X    $(CC) $(CFLAGS) -c y.tab.c
  1363. X
  1364. Xy.tab.c: parseifile.y parseifile.h
  1365. X    yacc -v parseifile.y
  1366. X
  1367. Xconstant.c: shlib.h
  1368. X
  1369. SHAR_EOF
  1370. chmod 0666 Makefile || echo "restore of Makefile fails"
  1371. sed 's/^X//' << 'SHAR_EOF' > README.diffs &&
  1372. X
  1373. XThis distribution cantains the file of patches (DIFFS), 4 new source files
  1374. X(constant.c kernal.h parseifile.y parseifile.h) and the change log (ChangeLog).
  1375. XThe documentation (man pages? wee don't need no stinkin' man pages!) is
  1376. Xforthcoming.
  1377. X
  1378. SHAR_EOF
  1379. chmod 0666 README.diffs || echo "restore of README.diffs fails"
  1380. sed 's/^X//' << 'SHAR_EOF' > constant.c &&
  1381. Xstruct symbol {
  1382. X   int address;
  1383. X   char * name;
  1384. X};
  1385. X
  1386. X#include "shlib.h"
  1387. X
  1388. Xchar *
  1389. Xlookup_address(n)
  1390. X  long int n;
  1391. X{
  1392. X   struct symbol * lo = symtab,
  1393. X            * hi = &symtab[TABLE_SIZE],
  1394. X         * mid;
  1395. X   char * new, * malloc ();
  1396. X
  1397. X   if (n < 0x300000 || n > 0x380000)
  1398. X       return (char *) 0;
  1399. X
  1400. X   while (lo <= hi)
  1401. X    {
  1402. X       mid = lo + (hi - lo)/2;
  1403. X       if (n == mid->address)
  1404. X       return mid->name;
  1405. X       else if (n > mid->address)
  1406. X       lo = mid + 1;
  1407. X       else
  1408. X       hi = mid - 1;
  1409. X    }
  1410. X   mid = (hi > lo ? lo : hi);
  1411. X   new = malloc ((unsigned) strlen (mid->name) + 10);
  1412. X   sprintf(new, "%s+0x%x", mid->name, n - mid->address);
  1413. X   return new;
  1414. X}
  1415. X
  1416. X#include "kernal.h"
  1417. X
  1418. Xchar *
  1419. Xlookup_kernal_address(n)
  1420. X  long int n;
  1421. X{
  1422. X   struct symbol * lo = kerntab,
  1423. X            * hi = &kerntab[KERNAL_TABLE_SIZE],
  1424. X         * mid;
  1425. X
  1426. X   while (lo <= hi)
  1427. X    {
  1428. X       mid = lo + (hi - lo)/2;
  1429. X       if (n == mid->address)
  1430. X       return mid->name;
  1431. X       else if (n > mid->address)
  1432. X       lo = mid + 1;
  1433. X       else
  1434. X       hi = mid - 1;
  1435. X    }
  1436. X
  1437. X   return (char *) 0;
  1438. X}
  1439. X
  1440. SHAR_EOF
  1441. chmod 0666 constant.c || echo "restore of constant.c fails"
  1442. sed 's/^X//' << 'SHAR_EOF' > kernal.h &&
  1443. X/*
  1444. X  kernal.h - interesting kernal addresses from various header files.
  1445. X
  1446. X  This file is probably extremly dependant on the OS version. As distributed
  1447. X  is was created from the 3.51 header files. I did my best to be accurate, but
  1448. X  there may be typos (i did check).
  1449. X*/
  1450. X
  1451. X#define KERNAL_TABLE_SIZE 142
  1452. X
  1453. Xstruct symbol kerntab[] = {
  1454. X   {0x70000, "VPG_BASE"},
  1455. X   {0x70900, "u.u_rsav"},
  1456. X   {0x70934, "u.u_qsav"},
  1457. X   {0x70968, "u.u_ssav"},
  1458. X   {0x7099C, "u.u_segflg"},
  1459. X   {0x7099D, "u.u_error"},
  1460. X   {0x7099E, "u.u_uid"},
  1461. X   {0x709A0, "u.u_gid"},
  1462. X   {0x709A2, "u.u_ruid"},
  1463. X   {0x709A4, "u.u_rgid"},
  1464. X   {0x709A6, "u.u_procp"},
  1465. X   {0x709AA, "u.u_ap"},
  1466. X   {0x709AE, "u.u_rval1"},
  1467. X   {0x709B2, "u.u_rval2"},
  1468. X   {0x709B6, "u.u_base"},
  1469. X   {0x709BA, "u.u_count"},
  1470. X   {0x709BE, "u.u_offset"},
  1471. X   {0x709C2, "u.u_fmode"},
  1472. X   {0x709C4, "u.u_pbsize"},
  1473. X   {0x709C6, "u.u_pboff"},
  1474. X   {0x709C8, "u.u_pbdev"},
  1475. X   {0x709CA, "u.u_rablock"},
  1476. X   {0x709CE, "u.u_errcnt"},
  1477. X   {0x709D0, "u.u_cdir"},
  1478. X   {0x709D4, "u.u_rdir"},
  1479. X   {0x709D8, "u.u_dirp"},
  1480. X   {0x709E8, "u.u_pdir"},
  1481. X   {0x709EC, "u.u_ofile"},
  1482. X   {0x709F0, "u.u_pofile"},
  1483. X   {0x709f4, "u.FillerYUK"},
  1484. X   {0x70A54, "u.u_arg"},
  1485. X   {0x70A7C, "u_tsize"},
  1486. X   {0x70A80, "u_dsize"},
  1487. X   {0x70A84, "u_ssize"},
  1488. X   {0x70A88, "u_lsize"},
  1489. X   {0x70A8C, "u.u_signal"},
  1490. X   {0x70B0C, "u.u_utime"},
  1491. X   {0x70B10, "u.u_stime"},
  1492. X   {0x70B14, "u.u_cutime"},
  1493. X   {0x70B18, "u.u_cstime"},
  1494. X   {0x70B1C, "u.u_ar0"},
  1495. X   {0x70B20, "u.u_prof.pr_base"},
  1496. X   {0x70B24, "u.u_prof.pr_size"},
  1497. X   {0x70B28, "u.u_prof.pr_off"},
  1498. X   {0x70B2C, "u.u_prof.pr_scale"},
  1499. X   {0x70B30, "u.u_ttyp"},
  1500. X   {0x70B34, "u.u_ttyd"},
  1501. X   {0x70B36, "u.u_exdata.ux_mag"},
  1502. X   {0x70B38, "u.u_exdata.ux_stamp"},
  1503. X   {0x70B3A, "u.u_exdata.ux_tsize"},
  1504. X   {0x70B3E, "u.u_exdata.ux_dsize"},
  1505. X   {0x70B42, "u.u_exdata.ux_bsize"},
  1506. X   {0x70B46, "u.u_exdata.ux_ssize"},
  1507. X   {0x70B4A, "u.u_exdata.ux_entloc"},
  1508. X   {0x70B4E, "u.u_exdata.ux_unused"},
  1509. X   {0x70B52, "u.u_exdata.ux_relflag"},
  1510. X   {0x70B56, "u.u_xlsize"},
  1511. X   {0x70B5A, "u.u_comm"},
  1512. X   {0x70B68, "u.u_start"},
  1513. X   {0x70B6C, "u.u_ticks"},
  1514. X   {0x70B70, "u.u_mem"},
  1515. X   {0x70B74, "u.u_ior"},
  1516. X   {0x70B78, "u.u_iow"},
  1517. X   {0x70B7C, "u.u_iosw"},
  1518. X   {0x70B80, "u.u_ioch"},
  1519. X   {0x70B84, "u.u_acflag"},
  1520. X   {0x70B86, "u.u_cmask"},
  1521. X   {0x70B88, "u.u_limit"},
  1522. X   {0x70B90, "u.u_limit[LIM_NORAISE]"},
  1523. X   {0x70B90, "u.u_limit[LIM_FSIZE]"},
  1524. X   {0x70B90, "u.u_limit[LIM_CPU]"},
  1525. X   {0x70B90, "u.u_limit[LIM_DATA]"},
  1526. X   {0x70B90, "u.u_limit[LIM_STACK]"},
  1527. X   {0x70B90, "u.u_limit[LIM_CORE]"},
  1528. X   {0x70B90, "u.u_limit[LIM_MAXRSS]"},
  1529. X   {0x70ba4, "u.u_dmap"},
  1530. X   {0x70bca, "u.u_smap"},
  1531. X   {0x70bf0, "u.u_cdmap"},
  1532. X   {0x70C16, "u.u_csmap"},
  1533. X   {0x70C3C, "u.u_outtime"},
  1534. X   {0x70C40, "u.u_usize"},
  1535. X   {0x70C42, "u.u_lock"},
  1536. X   {0x70E00, "VPTE_BASE"},
  1537. X   {0x400000, "PG_BASE"},
  1538. X   {0x4000C0, "DMA_MAP"},
  1539. X   {0x4000DC, "DMA_UPTR"},
  1540. X   {0x4000E0, "UPTE"},
  1541. X   {0x400100, "USER_MAP"},
  1542. X   {0x400600, "MAP_TOP"},
  1543. X   {0x410000, "GSR_ADDR"},
  1544. X   {0x420000, "VIDMEM"},    
  1545. X   {0x430000, "BUS0_ADDR"},
  1546. X   {0x440000, "BUS1_ADDR"},
  1547. X   {0x450000, "PHONE_STATUS"},
  1548. X   {0x460000, "DMA_CNT"},
  1549. X   {0x470000, "LP_STATUS_ADDR"},
  1550. X   {0x480000, "RTC_WRITE_ADDRESS"},
  1551. X   {0x490000, "HNDSET_RELAY"},
  1552. X   {0x491000, "LINE_SELECT"},
  1553. X   {0x492000, "HOOK1_RELAY"},
  1554. X   {0x493000, "HOOK2_RELAY"},
  1555. X   {0x494000, "LINE1_ACTIVE"},
  1556. X   {0x495000, "LINE2_ACTIVE"},
  1557. X   {0x496000, "A_LEAD1_RELAY"},
  1558. X   {0x497000, "A_LEAD2_RELAY"},
  1559. X   {0x4A0000, "MCR_ADDR"},
  1560. X   {0x4B0000, "A_BAUD_ADDR"},
  1561. X   {0x4B0400, "DIALER_LOWER"},
  1562. X   {0x4B0800, "DIALER_HIGHER"},
  1563. X   {0x4C0000, "CSR_ADDR"},
  1564. X   {0x4D0000, "DMA_LOADDR"},
  1565. X   {0x4D4000, "DMA_HIADDR"},
  1566. X   {0x4E0000, "DISK_CNTRL"},
  1567. X   {0x4f0000, "LP_DATA_ADDR"},
  1568. X   {0xE00000, "HD_BASE"},
  1569. X   {0xE10000, "FD_BASE"},
  1570. X   {0xE20000, "MCR2_ADDR"},
  1571. X   {0xE30000, "RTC_READ_ADDDR"},
  1572. X   {0xE40000, "SYSERR_GCR_ADDR"},
  1573. X   {0xE41000, "PE_INT_GCR_ADDR"},
  1574. X   {0xE42000, "PE_FRC_GCR_ADDR"},
  1575. X   {0xE43000, "ROM_GCR_ADDR"},
  1576. X   {0xE44000, "L1MD_GCR_ADDR"},
  1577. X   {0xE45000, "L2MD_GCR_ADDR"},
  1578. X   {0xE46000, "DNCT_GCR_ADDR"},
  1579. X   {0xE50000, "A_DATA_ADDR"},
  1580. X   {0xE50002, "B_DATA_ADDR"},
  1581. X   {0xE50004, "A_CMND_ADDR"},
  1582. X   {0xE50006, "B_CMND_ADDR"},
  1583. X   {0xE60000, "SCM_0W_Control"},
  1584. X   {0xE61000, "SCM_1W_Control"},
  1585. X   {0xE62000, "SCM_2R_Control"},
  1586. X   {0xE63000, "SCM_3R_Control"},
  1587. X   {0xE64000, "SCM_4W_Control"},
  1588. X   {0xE65000, "SCM_5W_Control"},
  1589. X   {0xE66000, "SCM_6W_Control"},
  1590. X   {0xE68000, "SCM_8W_Control"},
  1591. X   {0xE69000, "SCM_9W_Control"},
  1592. X   {0xE6A000, "SCM_10R_Control"},
  1593. X   {0xE70000, "C_CMND_ADDR"},
  1594. X   {0xE70002, "C_DATA_ADDR"},
  1595. X   {0x7fffffff, "CDLIMIT"},
  1596. X};
  1597. SHAR_EOF
  1598. chmod 0666 kernal.h || echo "restore of kernal.h fails"
  1599. sed 's/^X//' << 'SHAR_EOF' > parseifile.h &&
  1600. X/*
  1601. X * parseifile.h - header file for parseifile.y
  1602. X *
  1603. X * Written by Alex Crain
  1604. X *
  1605. X */
  1606. X
  1607. X#define DEFAULT_IFILE "/lib/shlib.ifile"
  1608. X#define DEFAULT_TABLE_SIZE 2500
  1609. X
  1610. X#define HEADER    "\
  1611. X/*\n\
  1612. X *  This is a computer generated file.\n\
  1613. X *\n\
  1614. X *  The file contains a table declaration and accessor function for adding\n\
  1615. X *  builting symbol values to the 68k dissassembler.\n\
  1616. X *\n\
  1617. X *  This file is generated by the parseifile program, written by Alex Crain.\n\
  1618. X *\n\
  1619. X */\n\
  1620. X"
  1621. SHAR_EOF
  1622. chmod 0666 parseifile.h || echo "restore of parseifile.h fails"
  1623. sed 's/^X//' << 'SHAR_EOF' > parseifile.y &&
  1624. X%{
  1625. X
  1626. X/* 
  1627. X * ifile processor for unix-pc disassembler
  1628. X *
  1629. X * Written by Alex Crain - January 1988
  1630. X *
  1631. X * Copyright 1988 Alex Crain
  1632. X */
  1633. X
  1634. X#include <stdio.h>
  1635. X#include <string.h>
  1636. X#include <ctype.h>
  1637. X#include "parseifile.h"
  1638. X
  1639. Xchar * malloc ();
  1640. Xlong strtol ();
  1641. Xint GetC (), NextC (), yylex ();
  1642. Xvoid fatal (), gen_file (), UnGetC (), sort_symbols (), exit (), free ();
  1643. X
  1644. X#define yyerror(MSG) fatal (MSG)
  1645. X
  1646. Xstruct symbol {
  1647. X   long address;
  1648. X   char * name;
  1649. X};
  1650. X
  1651. Xstatic char * ifile_name = DEFAULT_IFILE;
  1652. Xstatic FILE * ifile;
  1653. Xstatic struct symbol * symtab;
  1654. Xstatic int table_size = 0, max_table_size = DEFAULT_TABLE_SIZE;
  1655. X
  1656. Xextern int yydebug;
  1657. X#define YYDEBUG 1
  1658. X
  1659. Xvoid
  1660. Xmain (argc, argv)
  1661. Xint argc;
  1662. Xchar ** argv;
  1663. X{
  1664. X   int c;
  1665. X   extern char * optarg;
  1666. X
  1667. X   yydebug = 0;
  1668. X
  1669. X   while ((c = getopt (argc, argv, "df:s:")) != EOF)
  1670. X       switch (c)
  1671. X    {
  1672. X    case 'd':
  1673. X       yydebug = 1;
  1674. X       break;
  1675. X    case 'f':
  1676. X       ifile_name = optarg;
  1677. X       break;
  1678. X    case 's':
  1679. X       max_table_size = strtol (optarg, (char **) 0, 0);
  1680. X       break;
  1681. X    case '?':
  1682. X       fatal ("Usage: parseifile [-d] [-f ifile] [-s table-size].");
  1683. X    }
  1684. X   
  1685. X   if ((ifile = fopen (ifile_name, "r")) == NULL)
  1686. X       fatal ("Cannot open ifile.");
  1687. X
  1688. X   symtab = (struct symbol *) malloc (sizeof(struct symbol) * max_table_size);
  1689. X   if (symtab == NULL)
  1690. X       fatal ("Out of memory.");
  1691. X
  1692. X   (void) yyparse ();
  1693. X   sort_symbols ();
  1694. X   gen_file ();
  1695. X   exit (0);
  1696. X   /*NOTREACHED*/
  1697. X}
  1698. X
  1699. X%}
  1700. X
  1701. X%union {
  1702. X    long    integer;
  1703. X    char *    string;
  1704. X}
  1705. X
  1706. X%token FLAG
  1707. X%token '{'
  1708. X%token '}'
  1709. X%token '='
  1710. X%token '+'
  1711. X%token ';'
  1712. X%token <string> SOMETHING
  1713. X
  1714. X%type <integer> expression
  1715. X
  1716. X%%
  1717. X
  1718. Xfile
  1719. X    : definitions
  1720. X    ;
  1721. X
  1722. Xdefinitions
  1723. X    : definition
  1724. X    | definitions definition
  1725. X    ;
  1726. X
  1727. Xdefinition
  1728. X    : directive
  1729. X    | assignment
  1730. X    | FLAG
  1731. X    ;
  1732. X
  1733. Xdirective
  1734. X    : SOMETHING block
  1735. X        { if ($1) (void) free ($1); }
  1736. X    ;
  1737. X
  1738. Xassignment
  1739. X    : SOMETHING '=' expression ';'
  1740. X        { add_symbol ($1, $3); }
  1741. X    ;
  1742. X
  1743. Xexpression 
  1744. X    : SOMETHING
  1745. X        { if (isdigit ($1[0]))
  1746. X              $$ = strtol ($1, (char **)0, 0);
  1747. X          else
  1748. X              $$ = lookup_symbol ($1);
  1749. X          (void) free ($1);
  1750. X        }
  1751. X    | expression '+' SOMETHING
  1752. X        { if (isdigit ($3[0]))
  1753. X              $$ = $1 + strtol ($3, (char **)0, 0);
  1754. X          else
  1755. X              $$ = $1 + lookup_symbol ($3);
  1756. X          (void) free ($3);
  1757. X        }
  1758. X    ;      
  1759. X
  1760. Xblock
  1761. X    : '{' stuff_list '}'
  1762. X    | '{' '}'
  1763. X    ;
  1764. X
  1765. Xstuff_list
  1766. X    : stuff
  1767. X    | stuff_list stuff
  1768. X    ;
  1769. X
  1770. Xstuff
  1771. X    : SOMETHING
  1772. X        { if ($1) (void) free ($1); }
  1773. X    | block
  1774. X    | '+'
  1775. X    | '='
  1776. X    | ';'
  1777. X    ;
  1778. X
  1779. X%%
  1780. X
  1781. Xint lookahead = 0;
  1782. Xint yylineno = 0;
  1783. X
  1784. Xint
  1785. XGetC ()
  1786. X{
  1787. X   int c;
  1788. X
  1789. X   if (lookahead)
  1790. X    {
  1791. X       c = lookahead;
  1792. X       lookahead = 0;
  1793. X    }
  1794. X   else
  1795. X    {
  1796. X       c = getc (ifile);
  1797. X       if (c == '\n')
  1798. X       yylineno++;
  1799. X    }
  1800. X   return c;
  1801. X}
  1802. X
  1803. Xint
  1804. XNextC ()
  1805. X{
  1806. X   if (! lookahead)
  1807. X       lookahead = getc (ifile);
  1808. X   return lookahead;
  1809. X}
  1810. X
  1811. Xvoid 
  1812. XUnGetC (c)
  1813. X  int c;
  1814. X{
  1815. X   lookahead = c;
  1816. X}
  1817. X
  1818. Xint
  1819. Xyylex ()
  1820. X{
  1821. X   int c;
  1822. X   static char buffer[128];
  1823. X
  1824. X start:
  1825. X   while (((c = GetC ()) != EOF) && isspace (c));
  1826. X   if (c == '/' && NextC () == '*')
  1827. X    {
  1828. X       do {
  1829. X      c=GetC (); 
  1830. X       } while (c != EOF && (c != '*' || NextC () != '/'));
  1831. X       c = GetC ();
  1832. X       goto start;
  1833. X    }
  1834. X      
  1835. X   if (isalnum (c) || c == '_')
  1836. X    {
  1837. X       int i = 0;
  1838. X
  1839. X       while ((isalnum (c) || c == '_') && i < 128)
  1840. X    {
  1841. X       buffer[i++] = c;
  1842. X       c = GetC ();
  1843. X    }
  1844. X       UnGetC (c);
  1845. X       buffer[i] = '\0';
  1846. X       yylval.string = malloc (sizeof (buffer) + 1);
  1847. X       if (yylval.string)
  1848. X       (void) strcpy (yylval.string, buffer);
  1849. X       else
  1850. X       fatal ("Out of memory.");
  1851. X       if (yydebug) 
  1852. X       (void) printf ("(%s)", buffer);
  1853. X       return SOMETHING;
  1854. X    }
  1855. X
  1856. X   if (c == '-')
  1857. X    {
  1858. X       while ((c = GetC ()) != EOF && c != '\n');
  1859. X       return FLAG;
  1860. X    }
  1861. X
  1862. X   switch (c)
  1863. X    {
  1864. X    case '{':
  1865. X    case '}':
  1866. X    case '+':
  1867. X    case '=':
  1868. X    case ';':
  1869. X       return c;
  1870. X    case EOF:
  1871. X       return EOF;
  1872. X    default:
  1873. X       yylval.string = (char *) 0;
  1874. X       return SOMETHING;
  1875. X    }
  1876. X}
  1877. X
  1878. Xvoid
  1879. Xadd_symbol (symbol,address)
  1880. X  char * symbol;
  1881. X  long address;
  1882. X{
  1883. X   symtab[table_size].name = symbol;
  1884. X   symtab[table_size].address = address;
  1885. X   table_size++;
  1886. X}
  1887. X
  1888. Xvoid
  1889. Xgen_file ()
  1890. X{
  1891. X   int i;
  1892. X
  1893. X   (void) puts (HEADER);
  1894. X   (void) printf ("#define TABLE_SIZE %d\n", table_size);
  1895. X   (void) puts ("struct symbol symtab[] = {");
  1896. X   for (i=0; i<table_size; i++)
  1897. X       (void) printf ("{0x%x,\"%s\"},\n", symtab[i].address, symtab[i].name);
  1898. X   (void) puts ("};");
  1899. X}
  1900. X
  1901. Xvoid
  1902. Xfatal (msg)
  1903. X  char * msg;
  1904. X{
  1905. X   (void) fputs ("pareifile: ", stderr);
  1906. X   if (yylineno)
  1907. X       (void) fprintf (stderr, "[line %d]: ", yylineno);
  1908. X   (void) fputs (msg, stderr);
  1909. X   (void) putc('\n', stderr);
  1910. X   (void) exit (1);
  1911. X
  1912. X}
  1913. X
  1914. Xlong
  1915. Xlookup_symbol(s)
  1916. X  char * s;
  1917. X{
  1918. X   int i = 0;
  1919. X
  1920. X   while (i < table_size)
  1921. X    {
  1922. X       if (strcmp (symtab[i].name, s))
  1923. X       i++;
  1924. X       else
  1925. X       return symtab[i].address;
  1926. X    }
  1927. X   fatal ("unreferenced symbol.");
  1928. X   /*NOTREACHED*/
  1929. X}
  1930. X       
  1931. X       
  1932. Xvoid 
  1933. Xsort_symbols ()
  1934. X{
  1935. X   int i, j;
  1936. X   for (i = table_size - 1; i; i--)
  1937. X       for (j = 0; j < table_size - 1; j++)
  1938. X       if (symtab[j].address > symtab[j+1].address)
  1939. X        {
  1940. X           union { long l; char * s; } temp;
  1941. X           
  1942. X           temp.l = symtab[j].address;
  1943. X           symtab[j].address = symtab[j+1].address;
  1944. X           symtab[j+1].address = temp.l;
  1945. X           temp.s = symtab[j].name;
  1946. X           symtab[j].name = symtab[j+1].name;
  1947. X           symtab[j+1].name = temp.s;
  1948. X        }
  1949. X}
  1950. SHAR_EOF
  1951. chmod 0666 parseifile.y || echo "restore of parseifile.y fails"
  1952. exit 0
  1953.