home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume15 / dis6502 < prev    next >
Text File  |  1988-06-06  |  33KB  |  1,379 lines
  1. Subject:  v15i044:  6502 disassembler
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rsalz@uunet.UU.NET
  5.  
  6. Submitted-by: Robert Bond <nscpdc.nsc.com!rgb>
  7. Posting-number: Volume 15, Issue 44
  8. Archive-name: dis6502
  9.  
  10.  
  11. This is a 6502 disassembler for the Atari 8 bit machines.  I submitted
  12. to comp.sources.unix because it runs on unix boxes, not on the 8
  13. bitters - it is too big.  I last posted it to net.sources before the
  14. big reorganization.  It has not changed since then but I have had
  15. requests lately that I submit it to comp.sources so that the
  16. archives will get it.
  17.  
  18. As always, if you have problems, let me know and I'll look at them.
  19. Maybe not fix, but certainly admire :-).  I like to hear from satisfied
  20. users, too.
  21.  
  22. Standard disclaimer -  
  23.  
  24. This software is in the public domain.  It is not National
  25. Semiconductor's product, and comes with no warranties.
  26.  
  27.                         Bob Bond
  28.  
  29.                         rgb@nscpdc.nsc.com
  30.                         tektronix!nscpdc!rgb
  31.                         nsc!nscpdc!rgb
  32.  
  33. # This is a shell archive.  Remove anything before this line
  34. # then unpack it by saving it in a file and typing "sh file"
  35. # (Files unpacked will be owned by you and have default permissions).
  36. # This archive contains the following files:
  37. #    ./Makefile
  38. #    ./dis.1
  39. #    ./dis.h
  40. #    ./main.c
  41. #    ./initopts.c
  42. #    ./lex.l
  43. #    ./ref.c
  44. #    ./print.c
  45. #    ./tbl.c
  46. #
  47. if `test ! -s ./Makefile`
  48. then
  49. echo "Extracting ./Makefile"
  50. cat > ./Makefile << '\SHAR\EOF\'
  51. OBJS = main.o initopts.o lex.o ref.o print.o tbl.o
  52. SRCS = dis.h main.c initopts.c lex.l ref.c print.c tbl.c 
  53. CFLAGS = -O
  54.  
  55. dis:        $(OBJS)
  56.         cc $(OBJS) -o dis
  57.  
  58. tbl.o:        dis.h tbl.c
  59.         cc -c tbl.c
  60.  
  61. initopts.o:    dis.h initopts.c
  62.  
  63. main.o:        dis.h main.c
  64.  
  65. lex.o:        lex.c
  66.  
  67. lex.c:        dis.h lex.l
  68.  
  69. ref.o:        dis.h ref.c
  70.  
  71. print.o:    dis.h print.c
  72.  
  73. dis.man:    dis.1
  74.         nroff -man dis.1 > dis.man
  75.  
  76. install:    dis
  77.         cp dis /a/rgb/bin/dis6502
  78.  
  79. clean:
  80.         rm -f $(OBJS) lex.c dis.man
  81.  
  82. clobber:    clean
  83.         rm -f dis
  84.  
  85. ckpt:        $(SRCS)
  86.         ci -l $(SRCS)
  87.  
  88. lint: dis.h main.c initopts.c lex.c ref.c print.c tbl.c 
  89.         lint  dis.h main.c initopts.c lex.c ref.c print.c tbl.c 
  90.  
  91. shar:        Makefile dis.1 $(SRCS)
  92.         shar -f shar Makefile dis.1 $(SRCS)
  93. \SHAR\EOF\
  94. else
  95.   echo "will not over write ./Makefile"
  96. fi
  97. if `test ! -s ./dis.1`
  98. then
  99. echo "Extracting ./dis.1"
  100. cat > ./dis.1 << '\SHAR\EOF\'
  101. .TH DIS6502 1 "1 OCT 1986"
  102. .UC 4
  103. .SH NAME
  104. dis6502 \- Disassemble 6502 object code
  105. .SH SYNOPSIS
  106. .I dis6502
  107. [
  108. .I \-b 
  109. ]
  110. [
  111. .I -p \fIpfile\fP 
  112. ]
  113. .I file
  114. .LP
  115. .SH DESCRIPTION
  116. .I  Dis6502
  117. disassembles 6502 binary files.  Binary formats understood include
  118. Atari binary files (L menu command) and boot files.
  119. Equate and control files can be included via the
  120. .I -p
  121. option to name well known locations and to control the disassembly
  122. process.  The output includes a cross reference.
  123. .PP
  124. The disassembly process is a two pass operation:  First the program
  125. flow is traced starting with the init and run parameters in the file
  126. headers.  The dump routine then prints out the information.
  127. .PP
  128. The command line options are:
  129. .TP
  130. .I \-b
  131. Assume that the file is a boot file, not a load file.
  132. .TP
  133. .I \-p \fIpfile\fP 
  134. Read in the predefine file \fIpfile\fP.
  135. Up to 20 \fI-p\fP options may be included.
  136. .PP
  137. Lines in pfile consist of:
  138. .PP
  139.  lineno name .eq number
  140. .PP
  141.  .stop number
  142. .PP
  143.  .trace number
  144. .PP 
  145. .I Lineno
  146. refers to a decimal number.  
  147. .I Number 
  148. may be a decimal number or
  149. may be a hexadecimal number (the first character of the number
  150. should be "$").  For example, "$21b5" is
  151. the hexadecimal number 21b5.
  152. .I Name
  153. is a sequence of numbers and characters starting with a
  154. letter.
  155. .I .trace 
  156. causes
  157. the trace process to continue at the address given.  
  158. .I .stop
  159. causes the
  160. trace process to stop at the address given.
  161. .SH AUTHOR
  162. Robert Bond
  163. .SH BUGS
  164. \SHAR\EOF\
  165. else
  166.   echo "will not over write ./dis.1"
  167. fi
  168. if `test ! -s ./dis.h`
  169. then
  170. echo "Extracting ./dis.h"
  171. cat > ./dis.h << '\SHAR\EOF\'
  172. #include <stdio.h>
  173.  
  174. #define NPREDEF 10
  175.  
  176. extern char *predef[];
  177. extern int  npredef;
  178. extern char *file;
  179. extern char *progname;
  180. extern int  bopt;
  181. extern unsigned char f[];
  182. extern unsigned char d[];
  183.  
  184. #define getword(x) (d[x] + (d[x+1] << 8))
  185. #define getbyte(x) (d[x])
  186.  
  187. /* f bits */
  188.  
  189. #define LOADED 1            /* Location loaded */
  190. #define JREF   2            /* Referenced as jump/branch dest */
  191. #define DREF   4            /* Referenced as data */
  192. #define SREF   8            /* Referenced as subroutine dest */
  193. #define NAMED  0x10            /* Has a name */
  194. #define TDONE  0x20            /* Has been traced */
  195. #define ISOP   0x40            /* Is a valid instruction opcode */
  196.  
  197. struct info {
  198.     char opn[4];
  199.     int  nb;
  200.     int  flag;
  201. };
  202.  
  203. extern struct info optbl[];
  204.  
  205. /* Flags */
  206.  
  207. /* Where control goes */
  208.  
  209. #define NORM 1
  210. #define JUMP 2
  211. #define FORK 4
  212. #define STOP 8
  213.  
  214. #define CTLMASK (NORM|JUMP|FORK|STOP)
  215.  
  216. /* Instruction format */
  217.  
  218. #define IMM  0x20
  219. #define ABS  0x40
  220. #define ACC  0x80
  221. #define IMP  0x100
  222. #define INX  0x200
  223. #define INY  0x400
  224. #define ZPX  0x800
  225. #define ABX  0x1000
  226. #define ABY  0x2000
  227. #define REL  0x4000
  228. #define IND  0x8000
  229. #define ZPY  0x10000
  230. #define ZPG  0x20000
  231. #define ILL  0x40000
  232.  
  233. #define ADRMASK (IMM|ABS|ACC|IMP|INX|INY|ZPX|ABX|ABY|REL|IND|ZPY|ZPG|ILL)
  234.  
  235. struct ref_chain {
  236.     struct ref_chain *next;
  237.     int who;
  238. };
  239.  
  240. struct ref_chain *get_ref();
  241. char *get_name();
  242.  
  243. /* lex junk */
  244.  
  245. #define EQ 256
  246. #define NUMBER 257
  247. #define NAME 258
  248. #define COMMENT 259
  249. #define LI 260
  250. #define TSTART 261
  251. #define TSTOP 262
  252.  
  253. extern FILE *yyin, *yyout;
  254. int lineno;
  255.  
  256. int yywrap(), yyerror();
  257. char *emalloc();
  258.  
  259. typedef union  {
  260.     int ival;
  261.     char *sval;
  262. } VALUE;
  263.  
  264. extern VALUE token;
  265. \SHAR\EOF\
  266. else
  267.   echo "will not over write ./dis.h"
  268. fi
  269. if `test ! -s ./main.c`
  270. then
  271. echo "Extracting ./main.c"
  272. cat > ./main.c << '\SHAR\EOF\'
  273. #include "dis.h"
  274.  
  275. #define NTSTART 20
  276.  
  277. char *cur_file = NULL;            /* the file thats open */
  278. int  pre_index = 0;
  279. int  tstart[NTSTART];            /* .trace directive keep locations */
  280. int  tstarti = 0;
  281.  
  282. VALUE token;
  283.  
  284. unsigned char d[0x10000];         /* The data */
  285. unsigned char f[0x10000];        /* Flags for memory usage */ 
  286.  
  287. #define RUNLOC  0x2e0
  288. #define INITLOC 0x2e2
  289.  
  290. main(argc, argv)
  291. int argc;
  292. char *argv[];
  293. {
  294.     int i;
  295.  
  296.     initopts(argc, argv);
  297.     if (npredef > 0) {
  298.         cur_file = predef[0];
  299.         pre_index++;
  300.         yyin = fopen(cur_file, "r");
  301.         if (!yyin)
  302.             crash ("Cant open predefine file");
  303.         get_predef();
  304.     }
  305.     if (bopt)
  306.         loadboot();
  307.     else
  308.         loadfile();
  309.  
  310.     for (i = 0; i<tstarti; i++)
  311.         start_trace(tstart[i], "*PTRACE*");
  312.  
  313.     dumpitout();
  314.     exit(0);
  315. }
  316.  
  317. crash(p)
  318. char *p;
  319. {
  320.     fprintf(stderr, "%s: %s\n", progname, p);
  321.     if (cur_file != NULL)
  322.         fprintf(stderr, "Line %d of %s\n", lineno+1, cur_file);
  323.     exit(1);
  324. }
  325.  
  326. get_predef()
  327. {
  328.     int loc;
  329.     char *name;
  330.  
  331.     for(;;) 
  332.         switch (yylex()) {
  333.         case '\n':
  334.             break;
  335.         case 0:
  336.             return;
  337.         case TSTART:
  338.             if (yylex() != NUMBER) 
  339.                 crash(".trace needs a number operand");
  340.             loc = token.ival;
  341.             if (loc > 0x10000 || loc < 0)
  342.                 crash("Number out of range");
  343.             if (tstarti == NTSTART) 
  344.                 crash("Too many .trace directives");
  345.             tstart[tstarti++] = loc;
  346.             while (yylex() != '\n')
  347.                 ;
  348.             break;
  349.         case TSTOP:
  350.             if (yylex() != NUMBER) 
  351.                 crash(".stop needs a number operand");
  352.             loc = token.ival;
  353.             if (loc > 0x10000 || loc < 0)
  354.                 crash("Number out of range");
  355.             f[loc] |= TDONE;
  356.             while (yylex() != '\n')
  357.                 ;
  358.             break;
  359.         case NUMBER:
  360.             switch (yylex()) {
  361.             case LI:
  362.             case COMMENT:
  363.                 while (yylex() != '\n')
  364.                     ;
  365.                 break;
  366.             case '\n':
  367.                 break;
  368.             case NAME:
  369.                 name = token.sval;
  370.                 if (yylex() != EQ) 
  371.                     crash("Only EQ and LI supported in defines file");
  372.                 if (yylex() != NUMBER)
  373.                     crash("EQ operand must be a number");
  374.                 loc = token.ival;
  375.                 if (loc > 0x10000 || loc < 0)
  376.                     crash("Number out of range");
  377.                 f[loc] |= NAMED;
  378.                 save_name(loc, name); 
  379.                 while (yylex() != '\n') 
  380.                     ;
  381.                 break;
  382.             default:
  383.                 crash("Invalid line in predef file");
  384.             }
  385.             break;
  386.         default:
  387.             crash("Invalid line in predef file");
  388.         }
  389. }
  390.  
  391. loadboot()
  392. {
  393.     struct boot_hdr {
  394.         unsigned char flags;
  395.         unsigned char nsec;
  396.         unsigned char base_low;
  397.         unsigned char base_hi;
  398.         unsigned char init_low;
  399.         unsigned char init_hi;
  400.     } bh;
  401.  
  402.     FILE *fp;
  403.     int base_addr;
  404.     register int i;
  405.     int len;
  406.  
  407.     fp = fopen(file, "r");
  408.     cur_file = NULL;
  409.     if (!fp) { 
  410.         fprintf(stderr, "Cant open %s\n", file);
  411.         exit(1);
  412.     }
  413.  
  414.     if(fread((char *)&bh, sizeof(bh), 1, fp) != 1) 
  415.         crash("Input too short");
  416.     
  417.     base_addr = bh.base_low + (bh.base_hi << 8);
  418.     len = bh.nsec * 128;
  419.     rewind(fp);
  420.     if (fread((char *)&d[base_addr], 1, len, fp) != len) 
  421.         crash("input too short");
  422.  
  423.     for(i = base_addr; len > 0; len--) 
  424.         f[i++] |= LOADED;
  425.  
  426.     start_trace(base_addr+6, "**BOOT**");
  427. }
  428.  
  429. loadfile()
  430. {
  431.     FILE *fp;
  432.     int base_addr;
  433.     int last_addr;
  434.     register int i;
  435.     int had_header;
  436.     int tmp;
  437.  
  438.     had_header = 0;
  439.     fp = fopen(file, "r");
  440.     cur_file = NULL;
  441.     if (!fp) { 
  442.         fprintf(stderr, "Cant open %s\n", file);
  443.         exit(1);
  444.     }
  445.     for(;;) {
  446.  
  447.         i = getc(fp);
  448.  
  449.         if (i == EOF) {
  450.             if (f[RUNLOC] & LOADED & f[RUNLOC+1]) {
  451.                 i = getword(RUNLOC);
  452.                 start_trace(i, "**RUN**");
  453.             }
  454.             return;
  455.         }
  456.  
  457.         i = i | (getc(fp) << 8);
  458.         if (i == 0xffff)  {
  459.             had_header = 1;
  460.             base_addr = getc(fp);
  461.             base_addr = base_addr | (getc(fp) << 8);
  462.             if (base_addr < 0 || base_addr > 0xffff) 
  463.                 crash("Invalid base addr in input file");
  464.         } else {
  465.             if (!had_header)
  466.                 crash("Invalid header in input file");
  467.             base_addr = i;
  468.         }
  469.  
  470.         last_addr = getc(fp);
  471.         last_addr = last_addr | (getc(fp) << 8);
  472.         if (last_addr < base_addr || last_addr > 0xffff) 
  473.             crash("Invalid length in input file");
  474.  
  475.         printf("Load:  %4x -> %4x\n", base_addr, last_addr);
  476.         for(i = base_addr; i <= last_addr; i++) {
  477.             tmp = getc(fp);
  478.             if (tmp == EOF) 
  479.                 crash("File too small");
  480.             d[i] = tmp;
  481.             f[i] |= LOADED;
  482.         }
  483.  
  484.         if (f[INITLOC] & LOADED & f[INITLOC+1])  {
  485.             i = getword(INITLOC);
  486.             start_trace(i, "**INIT**");
  487.         }
  488.  
  489.         f[INITLOC] &= ~LOADED;
  490.         f[INITLOC+1] &= ~LOADED;
  491.     }
  492.  
  493. }
  494.  
  495. start_trace(loc, name)
  496. int loc;
  497. char *name;
  498. {
  499.     printf("Trace: %4x %s\n", loc, name);
  500.     f[loc] |= (NAMED | SREF);
  501.     if (!get_name(loc))
  502.         save_name(loc, name);
  503.     save_ref(0, loc);
  504.     trace(loc);
  505. }
  506.     
  507. trace(addr)
  508. register int addr;
  509. {
  510.     int opcode;
  511.     register struct info *ip; 
  512.     int operand;
  513.     int istart;
  514.  
  515.     if (f[addr] & TDONE)
  516.         return;
  517.     else 
  518.         f[addr] |= TDONE;
  519.  
  520.     istart = addr;
  521.     opcode = getbyte(addr);
  522.     ip = &optbl[opcode];
  523.  
  524.     if (ip->flag & ILL)
  525.         return;
  526.  
  527.     f[addr] |= ISOP;
  528.  
  529.     addr++;
  530.  
  531.     /* Get the operand */
  532.  
  533.     switch(ip->nb) {
  534.         case 1:
  535.             break;
  536.         case 2:
  537.             operand = getbyte(addr);
  538.             f[addr++] |= TDONE;
  539.             break;
  540.         case 3:
  541.             operand = getword(addr);
  542.             f[addr++] |= TDONE;
  543.             f[addr++] |= TDONE;
  544.             break;
  545.     }
  546.  
  547.     /* Mark data references */
  548.  
  549.     switch (ip->flag & ADRMASK) {
  550.         case IMM:
  551.         case ACC:
  552.         case IMP:
  553.         case REL:
  554.         case IND:
  555.             break;
  556.         case ABS:
  557.             if (ip->flag & (JUMP | FORK))
  558.                 break;
  559.             /* Fall into */
  560.         case ABX:
  561.         case ABY:
  562.         case INX:
  563.         case INY:
  564.         case ZPG:
  565.         case ZPX:
  566.         case ZPY:
  567.             f[operand] |= DREF;
  568.             save_ref(istart, operand);
  569.             break;
  570.         default:
  571.             crash("Optable error");
  572.             break;
  573.     }
  574.  
  575.     /* Trace the next instruction */
  576.  
  577.     switch (ip->flag & CTLMASK) {
  578.         case NORM:
  579.             trace(addr);
  580.             break;
  581.         case JUMP:
  582.             f[operand] |= JREF;
  583.             save_ref(istart, operand);
  584.             trace(operand);
  585.             break;
  586.         case FORK:
  587.             if (ip->flag & REL) {
  588.                 if (operand > 127) 
  589.                     operand = (~0xff | operand);
  590.                 operand = operand + addr;
  591.                 f[operand] |= JREF;
  592.             } else {
  593.                 f[operand] |= SREF;
  594.             }
  595.             save_ref(istart, operand);
  596.             trace(operand);
  597.             trace(addr);
  598.             break;
  599.         case STOP:
  600.             break;
  601.         default:
  602.             crash("Optable error");
  603.             break;
  604.     }
  605. }
  606.  
  607. int
  608. yywrap()
  609. {
  610.     (void)fclose(yyin);
  611.     if (npredef == pre_index) {
  612.         return(1);
  613.     } else  {
  614.         lineno = 0;
  615.         cur_file = predef[pre_index];
  616.         pre_index++;
  617.         yyin = fopen(cur_file, "r");
  618.         if (!yyin) 
  619.             crash("Can't open predefines file");
  620.         return (0);
  621.     }
  622. }
  623. \SHAR\EOF\
  624. else
  625.   echo "will not over write ./main.c"
  626. fi
  627. if `test ! -s ./initopts.c`
  628. then
  629. echo "Extracting ./initopts.c"
  630. cat > ./initopts.c << '\SHAR\EOF\'
  631.  
  632. /* 
  633.  * 
  634.  *  dis [-p predefineds] file
  635.  *
  636.  *  The -p option may be repeated.
  637.  */
  638.  
  639. #include "dis.h"
  640.  
  641. char *predef[NPREDEF];
  642. int  npredef = 0;
  643. char *file;
  644. char *progname = "dis";
  645. int  bopt = 0;
  646.  
  647. initopts(argc,argv)
  648. int argc;
  649. char *argv[];
  650. {
  651.     int ai;
  652.     char *ca;
  653.     int fileset = 0;
  654.  
  655.     progname = argv[0];
  656.  
  657.     while (--argc) {
  658.         if ((*++argv)[0] == '-') {
  659.         ca = *argv;
  660.         for(ai = 1; ca[ai] != '\0'; ai++)
  661.                 switch (ca[ai]) {
  662.                 case 'p':
  663.             predef[npredef] = *++argv;
  664.             npredef++;
  665.                     argc--;
  666.                     break;
  667.         case 'b':
  668.             bopt = 1;
  669.             break;
  670.                 default: crash("Invalid option letter");
  671.                 }
  672.         } else if (!fileset) {
  673.         file = *argv;
  674.         fileset++;
  675.     } else crash("Usage: [-p predef] file");
  676.     }
  677.     if (!fileset)
  678.      crash("Usage: [-p predef] file");
  679. }
  680. \SHAR\EOF\
  681. else
  682.   echo "will not over write ./initopts.c"
  683. fi
  684. if `test ! -s ./lex.l`
  685. then
  686. echo "Extracting ./lex.l"
  687. cat > ./lex.l << '\SHAR\EOF\'
  688. %{
  689. #undef ECHO
  690. #include "dis.h"
  691. int lineno = 0;
  692. char *strcpy();
  693. %}
  694. %%
  695. [ \t] { ; }
  696. [\n] {    lineno++;
  697.                 return '\n';
  698. }
  699. \.EQ { 
  700.                 return EQ;
  701. }
  702. \.LI { 
  703.                 return LI;
  704. }
  705. \.eq { 
  706.                 return EQ;
  707. }
  708. \.li { 
  709.                 return LI;
  710. }
  711. ".trace" {
  712.                 return TSTART;
  713. }
  714. ".stop" {
  715.                 return TSTOP;
  716. }
  717. [0-9]+    {
  718.                 (void)sscanf(yytext, "%d", &token.ival); 
  719.                 return NUMBER;
  720. }
  721. \$[A-Fa-f0-9]+ {
  722.                 (void)sscanf(yytext+1, "%x", &token.ival);
  723.                 return NUMBER;
  724. }
  725. [A-Za-z][A-Za-z0-9_]* {
  726.                 token.sval = emalloc((unsigned) strlen(yytext)+1);
  727.                 (void)strcpy((char *)token.sval, (char *)yytext);
  728.                 return NAME;
  729. }
  730. \*.* {
  731.                 return COMMENT;
  732. }
  733. .            { return yytext[0]; }
  734. %%
  735.  
  736. char *
  737. emalloc(n)
  738. unsigned n;
  739. {
  740.     char *ptr, *malloc();
  741.  
  742.     if ((ptr = malloc(n)) == (char *) 0) {
  743.         (void) fprintf(stderr,"out of core");
  744.         exit(1);
  745.     }
  746.     return ptr;
  747. }
  748. \SHAR\EOF\
  749. else
  750.   echo "will not over write ./lex.l"
  751. fi
  752. if `test ! -s ./ref.c`
  753. then
  754. echo "Extracting ./ref.c"
  755. cat > ./ref.c << '\SHAR\EOF\'
  756. #include "dis.h"
  757.  
  758. #define HTSIZE 0x1000            /* Power of 2 */
  759. #define HTMASK (HTSIZE-1)
  760.  
  761. struct hashslot {
  762.     int addr;            /* The key */
  763.     struct ref_chain *ref;        /* Who references it */
  764.     char *name;            /* The symbolic name (if it has one) */
  765. };
  766.  
  767. struct   hashslot hashtbl[HTSIZE];    /* the hash table */
  768.  
  769. struct hashslot *
  770. hash(loc, allocate)
  771. int loc;
  772. int allocate;
  773. {
  774.     int probes;
  775.     register struct hashslot *hp;
  776.  
  777.     hp = &hashtbl[loc & HTMASK];
  778.     probes = 0;
  779.  
  780.     while (probes< HTSIZE) {
  781.         if (hp->addr == loc)
  782.             return(hp);
  783.         if (hp->name == NULL && hp->ref == NULL) {
  784.             if (allocate) {
  785.                 hp->addr = loc;
  786.                 return(hp);
  787.             } else {
  788.                 return(NULL);
  789.             }
  790.         }
  791.         hp++;
  792.         if (hp == &hashtbl[HTSIZE])
  793.             hp = &hashtbl[0];
  794.         probes++;
  795.     }
  796.  
  797.     crash("Hash table full");
  798.     /*NOTREACHED*/
  799. }
  800.  
  801. save_ref(refer, refee) 
  802. int refer;
  803. int refee;
  804. {
  805.     struct ref_chain *rc;
  806.     struct hashslot *hp;
  807.  
  808.     rc = (struct ref_chain *)emalloc(sizeof(*rc));
  809.     rc->who = refer;
  810.     hp = hash(refee, 1);
  811.     rc->next = hp->ref;
  812.     hp->ref = rc;
  813. }
  814.  
  815. save_name(loc, name)
  816. int loc;
  817. char *name;
  818. {
  819.     struct hashslot *hp;
  820.  
  821.     hp = hash(loc, 1);
  822.     hp->name = name;
  823. }
  824.  
  825. struct ref_chain *
  826. get_ref(loc)
  827. {
  828.     struct hashslot *hp;
  829.  
  830.     hp = hash(loc, 0);
  831.     if (!hp) 
  832.         return(NULL);
  833.     return(hp->ref);
  834. }
  835.  
  836. char *
  837. get_name(loc)
  838. {
  839.     struct hashslot *hp;
  840.  
  841.     hp = hash(loc, 0);
  842.     if (!hp) 
  843.         return(NULL);
  844.     return(hp->name);
  845. }
  846. \SHAR\EOF\
  847. else
  848.   echo "will not over write ./ref.c"
  849. fi
  850. if `test ! -s ./print.c`
  851. then
  852. echo "Extracting ./print.c"
  853. cat > ./print.c << '\SHAR\EOF\'
  854. #include <ctype.h>
  855. #include "dis.h"
  856.  
  857. char *strcpy();
  858. char *strcat();
  859.  
  860. dumpitout()
  861. {
  862.     int i;
  863.  
  864.     for(i = 0; i<0x10000;) {
  865.         if (f[i] & LOADED) {
  866.  
  867.             if (f[i] & SREF && f[i] & ISOP)
  868.                 printf("\n\n\n");
  869.  
  870.             printf("%04x  ",i);
  871.             print_bytes(i);
  872.             print_label(i);
  873.             if (f[i] & ISOP)
  874.                 i += print_inst(i);
  875.             else
  876.                 i += print_data(i);
  877.             printf("\n");
  878.  
  879.         } else {
  880.             i++;
  881.         }
  882.     }
  883.  
  884.     print_refs();
  885. }
  886.  
  887. pchar(c)
  888. int c;
  889. {
  890.     if (isascii(c) && isprint(c))
  891.         return(c);
  892.     return('.');
  893. }
  894.  
  895. char *
  896. lname(i)
  897. int i;
  898. {
  899.     static char buf[20];
  900.     char t;
  901.  
  902.     if (f[i] & NAMED) 
  903.         return(get_name(i));
  904.     if ((i > 0) && ((f[i-1] & (NAMED | DREF)) == (NAMED | DREF))) {
  905.         (void)strcpy(buf, get_name(i-1));
  906.         (void)strcat(buf, "+1");
  907.         return (buf);
  908.     }
  909.     if (f[i] & SREF)
  910.         t = 'S';
  911.     else if (f[i] & JREF)
  912.         t = 'L';
  913.     else if (f[i] & DREF)
  914.         t = 'D';
  915.     else 
  916.         t = 'X';
  917.     
  918.     (void)sprintf(buf, "%c%x", t, i);
  919.     return (buf);
  920. }
  921.  
  922. print_label(i)
  923. {
  924.     if (f[i] & (NAMED | JREF | SREF | DREF)) 
  925.         printf("%-10s", lname(i));
  926.     else
  927.         printf("%10s"," ");
  928. }
  929.  
  930. print_bytes(addr)
  931. int addr;
  932. {
  933.     register struct info *ip; 
  934.  
  935.     if ((f[addr] & ISOP) == 0) {
  936.         printf("           ");
  937.         return;
  938.     }
  939.  
  940.     ip = &optbl[getbyte(addr)];
  941.  
  942.     switch (ip->nb) {
  943.         case 1:
  944.             printf("%02x         ", getbyte(addr));
  945.             break;
  946.         case 2:
  947.             printf("%02x %02x      ", getbyte(addr), getbyte(addr+1));
  948.             break;
  949.         case 3:
  950.             printf("%02x %02x %02x   ", getbyte(addr), getbyte(addr+1), getbyte(addr+2));
  951.             break;
  952.     }
  953. }
  954.         
  955.  
  956. print_inst(addr)
  957. int addr;
  958. {
  959.     int opcode;
  960.     register struct info *ip; 
  961.     int operand;
  962.  
  963.     opcode = getbyte(addr);
  964.     ip = &optbl[opcode];
  965.  
  966.     printf("%s  ", ip->opn);
  967.  
  968.     addr++;
  969.  
  970.     switch(ip->nb) {
  971.         case 1:
  972.             break;
  973.         case 2:
  974.             operand = getbyte(addr);
  975.             break;
  976.         case 3:
  977.             operand = getword(addr);
  978.             break;
  979.     }
  980.  
  981.     if (ip->flag & REL) {
  982.         if (operand > 127) 
  983.             operand = (~0xff | operand);
  984.         operand = operand + ip->nb + addr - 1;
  985.     }
  986.  
  987.     switch (ip->flag & ADRMASK) {
  988.         case IMM:
  989.             printf("#$%02x                        * %d %c", operand, operand, pchar(operand));
  990.             break;
  991.         case ACC:
  992.         case IMP:
  993.             break;
  994.         case REL:
  995.         case ABS:
  996.         case ZPG:
  997.             printf("%s ", lname(operand));
  998.             break;
  999.         case IND:
  1000.             printf("(%s) ", lname(operand));
  1001.             break;
  1002.         case ABX:
  1003.         case ZPX:
  1004.             printf("%s,X ", lname(operand));
  1005.             break;
  1006.         case ABY:
  1007.         case ZPY:
  1008.             printf("%s,Y ", lname(operand));
  1009.             break;
  1010.         case INX:
  1011.             printf("(%s,X) ", lname(operand));
  1012.             break;
  1013.         case INY:
  1014.             printf("(%s),Y", lname(operand));
  1015.             break;
  1016.         default:
  1017.             break;
  1018.     }
  1019.  
  1020.     return(ip->nb);
  1021.  
  1022. }
  1023.  
  1024. print_data(i)
  1025. {
  1026.     int count;
  1027.     int j;
  1028.     int start;
  1029.  
  1030.     start = i;
  1031.     printf(".DB  %02x ", getbyte(i));
  1032.     count = 1;
  1033.     i++;
  1034.  
  1035.     for (j = 1; j < 8; j++) {
  1036.         if (f[i] & (JREF | SREF | DREF) || ((f[i] & LOADED) == 0)) 
  1037.             break;
  1038.         else
  1039.             printf("%02x ", getbyte(i));
  1040.         i++;
  1041.         count++;
  1042.     }
  1043.     for (j = count; j < 8; j++)
  1044.         printf("   ");
  1045.  
  1046.     printf("    * ");
  1047.  
  1048.     for (j = start; j < i ; j++) 
  1049.             printf("%c", pchar((int)getbyte(j)));
  1050.  
  1051.     return (count);
  1052. }
  1053.  
  1054. print_refs()
  1055. {
  1056.     char tname[50];
  1057.     char cmd[200];
  1058.     FILE *fp;
  1059.     register struct ref_chain *rp;
  1060.     register int i;
  1061.     int npline;
  1062.  
  1063.     (void)sprintf(tname, "dis.%d", getpid());
  1064.     (void)sprintf(cmd, "sort %s; rm %s", tname, tname);
  1065.  
  1066.     fp = fopen(tname, "w");
  1067.     if (!fp) 
  1068.         crash("Cant open temporary file/n");
  1069.  
  1070.     for (i = 0; i<0x10000; i++) {
  1071.         if(f[i] & (JREF|SREF|DREF)) {
  1072.             rp = get_ref(i);
  1073.             if (!rp) {
  1074.                 fprintf(stderr, "No ref %d\n", i);
  1075.                 break;
  1076.             }
  1077.  
  1078.             fprintf(fp, "%-8s  %04x   ", lname(i), i);
  1079.             npline = 0;
  1080.             while (rp) {
  1081.                 fprintf(fp, "%04x ", rp->who);
  1082.                 npline++;
  1083.                 if (npline == 12) {
  1084.                     fprintf(fp,"\n");
  1085.                     fprintf(fp,"%-8s  %04x   ",lname(i),i);
  1086.                     npline = 0;
  1087.                 }
  1088.                 rp = rp->next;
  1089.             }
  1090.             fprintf(fp, "\n");
  1091.         }
  1092.  
  1093.     }
  1094.  
  1095.     (void)fclose(fp);
  1096.  
  1097.     printf("\n\n\n\n\nCross References\n\n");
  1098.     printf("%-8s  Value  References\n", "Symbol");
  1099.     (void)fflush (stdout);
  1100.  
  1101.     (void)system(cmd);
  1102. }
  1103. \SHAR\EOF\
  1104. else
  1105.   echo "will not over write ./print.c"
  1106. fi
  1107. if `test ! -s ./tbl.c`
  1108. then
  1109. echo "Extracting ./tbl.c"
  1110. cat > ./tbl.c << '\SHAR\EOF\'
  1111. #include "dis.h"
  1112.  
  1113. struct info optbl[256] = {
  1114.     /* 00 */    { { 'B', 'R', 'K', 0, },  1, IMP|STOP, },
  1115.     /* 01 */    { { 'O', 'R', 'A', 0, },  2, INX|NORM, },
  1116.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1117.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1118.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1119.     /* 05 */    { { 'O', 'R', 'A', 0, },  2, ZPG|NORM, },
  1120.     /* 06 */    { { 'A', 'S', 'L', 0, },  2, ZPG|NORM, },
  1121.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1122.     /* 08 */    { { 'P', 'H', 'P', 0, },  1, IMP|NORM, },
  1123.     /* 09 */    { { 'O', 'R', 'A', 0, },  2, IMM|NORM, },
  1124.     /* 0a */    { { 'A', 'S', 'L', 0, },  1, ACC|NORM, },
  1125.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1126.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1127.     /* 0d */    { { 'O', 'R', 'A', 0, },  3, ABS|NORM, },
  1128.     /* 0e */    { { 'A', 'S', 'L', 0, },  3, ABS|NORM, },
  1129.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1130.     /* 10 */    { { 'B', 'P', 'L', 0, },  2, REL|FORK, },
  1131.     /* 11 */    { { 'O', 'R', 'A', 0, },  2, INY|NORM, },
  1132.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1133.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1134.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1135.     /* 15 */    { { 'O', 'R', 'A', 0, },  2, ZPX|NORM, },
  1136.     /* 16 */    { { 'A', 'S', 'L', 0, },  2, ZPX|NORM, },
  1137.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1138.     /* 18 */    { { 'C', 'L', 'C', 0, },  1, IMP|NORM, },
  1139.     /* 19 */    { { 'O', 'R', 'A', 0, },  3, ABY|NORM, },
  1140.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1141.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1142.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1143.     /* 1d */    { { 'O', 'R', 'A', 0, },  3, ABX|NORM, },
  1144.     /* 1e */    { { 'A', 'S', 'L', 0, },  3, ABX|NORM, },
  1145.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1146.     /* 20 */    { { 'J', 'S', 'R', 0, },  3, ABS|FORK, },
  1147.     /* 21 */    { { 'A', 'N', 'D', 0, },  2, INX|NORM, },
  1148.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1149.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1150.     /* 24 */    { { 'B', 'I', 'T', 0, },  2, ZPG|NORM, },
  1151.     /* 25 */    { { 'A', 'N', 'D', 0, },  2, ZPG|NORM, },
  1152.     /* 26 */    { { 'R', 'O', 'L', 0, },  2, ZPG|NORM, },
  1153.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1154.     /* 28 */    { { 'P', 'L', 'P', 0, },  1, IMP|NORM, },
  1155.     /* 29 */    { { 'A', 'N', 'D', 0, },  2, IMM|NORM, },
  1156.     /* 2a */    { { 'R', 'O', 'L', 0, },  1, ACC|NORM, },
  1157.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1158.     /* 2c */    { { 'B', 'I', 'T', 0, },  3, ABS|NORM, },
  1159.     /* 2d */    { { 'A', 'N', 'D', 0, },  3, ABS|NORM, },
  1160.     /* 2e */    { { 'R', 'O', 'L', 0, },  3, ABS|NORM, },
  1161.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1162.     /* 30 */    { { 'B', 'M', 'I', 0, },  2, REL|FORK, },
  1163.     /* 31 */    { { 'A', 'N', 'D', 0, },  2, INY|NORM, },
  1164.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1165.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1166.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1167.     /* 35 */    { { 'A', 'N', 'D', 0, },  2, ZPX|NORM, },
  1168.     /* 36 */    { { 'R', 'O', 'L', 0, },  2, ZPX|NORM, },
  1169.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1170.     /* 38 */    { { 'S', 'E', 'C', 0, },  1, IMP|NORM, },
  1171.     /* 39 */    { { 'A', 'N', 'D', 0, },  3, ABY|NORM, },
  1172.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1173.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1174.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1175.     /* 3d */    { { 'A', 'N', 'D', 0, },  3, ABX|NORM, },
  1176.     /* 3e */    { { 'R', 'O', 'L', 0, },  3, ABX|NORM, },
  1177.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1178.     /* 40 */    { { 'R', 'T', 'I', 0, },  1, IMP|STOP, },
  1179.     /* 41 */    { { 'E', 'O', 'R', 0, },  2, INX|NORM, },
  1180.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1181.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1182.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1183.     /* 45 */    { { 'E', 'O', 'R', 0, },  2, ZPG|NORM, },
  1184.     /* 46 */    { { 'L', 'S', 'R', 0, },  2, ZPG|NORM, },
  1185.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1186.     /* 48 */    { { 'P', 'H', 'A', 0, },  1, IMP|NORM, },
  1187.     /* 49 */    { { 'E', 'O', 'R', 0, },  2, IMM|NORM, },
  1188.     /* 4a */    { { 'L', 'S', 'R', 0, },  1, ACC|NORM, },
  1189.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1190.     /* 4c */    { { 'J', 'M', 'P', 0, },  3, ABS|JUMP, },
  1191.     /* 4d */    { { 'E', 'O', 'R', 0, },  3, ABS|NORM, },
  1192.     /* 4e */    { { 'L', 'S', 'R', 0, },  3, ABS|NORM, },
  1193.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1194.     /* 50 */    { { 'B', 'V', 'C', 0, },  2, REL|FORK, },
  1195.     /* 51 */    { { 'E', 'O', 'R', 0, },  2, INY|NORM, },
  1196.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1197.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1198.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1199.     /* 55 */    { { 'E', 'O', 'R', 0, },  2, ZPX|NORM, },
  1200.     /* 56 */    { { 'L', 'S', 'R', 0, },  2, ZPX|NORM, },
  1201.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1202.     /* 58 */    { { 'C', 'L', 'I', 0, },  1, IMP|NORM, },
  1203.     /* 59 */    { { 'E', 'O', 'R', 0, },  3, ABY|NORM, },
  1204.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1205.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1206.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1207.     /* 5d */    { { 'E', 'O', 'R', 0, },  3, ABX|NORM, },
  1208.     /* 5e */    { { 'L', 'S', 'R', 0, },  3, ABX|NORM, },
  1209.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1210.     /* 60 */    { { 'R', 'T', 'S', 0, },  1, IMP|STOP, },
  1211.     /* 61 */    { { 'A', 'D', 'C', 0, },  2, INX|NORM, },
  1212.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1213.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1214.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1215.     /* 65 */    { { 'A', 'D', 'C', 0, },  2, ZPG|NORM, },
  1216.     /* 66 */    { { 'R', 'O', 'R', 0, },  2, ZPG|NORM, },
  1217.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1218.     /* 68 */    { { 'P', 'L', 'A', 0, },  1, IMP|NORM, },
  1219.     /* 69 */    { { 'A', 'D', 'C', 0, },  2, IMM|NORM, },
  1220.     /* 6a */    { { 'R', 'O', 'R', 0, },  1, ACC|NORM, },
  1221.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1222.     /* 6c */    { { 'J', 'M', 'P', 0, },  3, IND|STOP, },
  1223.     /* 6d */    { { 'A', 'D', 'C', 0, },  3, ABS|NORM, },
  1224.     /* 6e */    { { 'R', 'O', 'R', 0, },  3, ABS|NORM, },
  1225.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1226.     /* 70 */    { { 'B', 'V', 'S', 0, },  2, REL|FORK, },
  1227.     /* 71 */    { { 'A', 'D', 'C', 0, },  2, INY|NORM, },
  1228.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1229.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1230.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1231.     /* 75 */    { { 'A', 'D', 'C', 0, },  2, ZPX|NORM, },
  1232.     /* 76 */    { { 'R', 'O', 'R', 0, },  2, ZPX|NORM, },
  1233.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1234.     /* 78 */    { { 'S', 'E', 'I', 0, },  1, IMP|NORM, },
  1235.     /* 79 */    { { 'A', 'D', 'C', 0, },  3, ABY|NORM, },
  1236.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1237.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1238.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1239.     /* 7d */    { { 'A', 'D', 'C', 0, },  3, ABX|NORM, },
  1240.     /* 7e */    { { 'R', 'O', 'R', 0, },  3, ABX|NORM, },
  1241.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1242.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1243.     /* 81 */    { { 'S', 'T', 'A', 0, },  2, INX|NORM, },
  1244.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1245.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1246.     /* 84 */    { { 'S', 'T', 'Y', 0, },  2, ZPG|NORM, },
  1247.     /* 85 */    { { 'S', 'T', 'A', 0, },  2, ZPG|NORM, },
  1248.     /* 86 */    { { 'S', 'T', 'X', 0, },  2, ZPG|NORM, },
  1249.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1250.     /* 88 */    { { 'D', 'E', 'Y', 0, },  1, IMP|NORM, },
  1251.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1252.     /* 8a */    { { 'T', 'X', 'A', 0, },  1, IMP|NORM, },
  1253.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1254.     /* 8c */    { { 'S', 'T', 'Y', 0, },  3, ABS|NORM, },
  1255.     /* 8d */    { { 'S', 'T', 'A', 0, },  3, ABS|NORM, },
  1256.     /* 8e */    { { 'S', 'T', 'X', 0, },  3, ABS|NORM, },
  1257.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1258.     /* 90 */    { { 'B', 'C', 'C', 0, },  2, REL|FORK, },
  1259.     /* 91 */    { { 'S', 'T', 'A', 0, },  2, INY|NORM, },
  1260.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1261.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1262.     /* 94 */    { { 'S', 'T', 'Y', 0, },  2, ZPX|NORM, },
  1263.     /* 95 */    { { 'S', 'T', 'A', 0, },  2, ZPX|NORM, },
  1264.     /* 96 */    { { 'S', 'T', 'X', 0, },  2, ZPY|NORM, },
  1265.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1266.     /* 98 */    { { 'T', 'Y', 'A', 0, },  1, IMP|NORM, },
  1267.     /* 99 */    { { 'S', 'T', 'A', 0, },  3, ABY|NORM, },
  1268.     /* 9a */    { { 'T', 'X', 'S', 0, },  1, IMP|NORM, },
  1269.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1270.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1271.     /* 9d */    { { 'S', 'T', 'A', 0, },  3, ABX|NORM, },
  1272.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1273.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1274.     /* a0 */    { { 'L', 'D', 'Y', 0, },  2, IMM|NORM, },
  1275.     /* a1 */    { { 'L', 'D', 'A', 0, },  2, INX|NORM, },
  1276.     /* a2 */    { { 'L', 'D', 'X', 0, },  2, IMM|NORM, },
  1277.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1278.     /* a4 */    { { 'L', 'D', 'Y', 0, },  2, ZPG|NORM, },
  1279.     /* a5 */    { { 'L', 'D', 'A', 0, },  2, ZPG|NORM, },
  1280.     /* a6 */    { { 'L', 'D', 'X', 0, },  2, ZPG|NORM, },
  1281.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1282.     /* a8 */    { { 'T', 'A', 'Y', 0, },  1, IMP|NORM, },
  1283.     /* a9 */    { { 'L', 'D', 'A', 0, },  2, IMM|NORM, },
  1284.     /* aa */    { { 'T', 'A', 'X', 0, },  1, IMP|NORM, },
  1285.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1286.     /* ac */    { { 'L', 'D', 'Y', 0, },  3, ABS|NORM, },
  1287.     /* ad */    { { 'L', 'D', 'A', 0, },  3, ABS|NORM, },
  1288.     /* ae */    { { 'L', 'D', 'X', 0, },  3, ABS|NORM, },
  1289.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1290.     /* b0 */    { { 'B', 'C', 'S', 0, },  2, REL|FORK, },
  1291.     /* b1 */    { { 'L', 'D', 'A', 0, },  2, INY|NORM, },
  1292.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1293.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1294.     /* b4 */    { { 'L', 'D', 'Y', 0, },  2, ZPX|NORM, },
  1295.     /* b5 */    { { 'L', 'D', 'A', 0, },  2, ZPX|NORM, },
  1296.     /* b6 */    { { 'L', 'D', 'X', 0, },  2, ZPY|NORM, },
  1297.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1298.     /* b8 */    { { 'C', 'L', 'V', 0, },  1, IMP|NORM, },
  1299.     /* b9 */    { { 'L', 'D', 'A', 0, },  3, ABY|NORM, },
  1300.     /* ba */    { { 'T', 'S', 'X', 0, },  1, IMP|NORM, },
  1301.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1302.     /* bc */    { { 'L', 'D', 'Y', 0, },  3, ABX|NORM, },
  1303.     /* bd */    { { 'L', 'D', 'A', 0, },  3, ABX|NORM, },
  1304.     /* be */    { { 'L', 'D', 'X', 0, },  3, ABY|NORM, },
  1305.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1306.     /* c0 */    { { 'C', 'P', 'Y', 0, },  2, IMM|NORM, },
  1307.     /* c1 */    { { 'C', 'M', 'P', 0, },  2, INX|NORM, },
  1308.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1309.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1310.     /* c4 */    { { 'C', 'P', 'Y', 0, },  2, ZPG|NORM, },
  1311.     /* c5 */    { { 'C', 'M', 'P', 0, },  2, ZPG|NORM, },
  1312.     /* c6 */    { { 'D', 'E', 'C', 0, },  2, ZPG|NORM, },
  1313.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1314.     /* c8 */    { { 'I', 'N', 'Y', 0, },  1, IMP|NORM, },
  1315.     /* c9 */    { { 'C', 'M', 'P', 0, },  2, IMM|NORM, },
  1316.     /* ca */    { { 'D', 'E', 'X', 0, },  1, IMP|NORM, },
  1317.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1318.     /* cc */    { { 'C', 'P', 'Y', 0, },  3, ABS|NORM, },
  1319.     /* cd */    { { 'C', 'M', 'P', 0, },  3, ABS|NORM, },
  1320.     /* ce */    { { 'D', 'E', 'C', 0, },  3, ABS|NORM, },
  1321.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1322.     /* d0 */    { { 'B', 'N', 'E', 0, },  2, REL|FORK, },
  1323.     /* d1 */    { { 'C', 'M', 'P', 0, },  2, INY|NORM, },
  1324.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1325.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1326.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1327.     /* d5 */    { { 'C', 'M', 'P', 0, },  2, ZPX|NORM, },
  1328.     /* d6 */    { { 'D', 'E', 'C', 0, },  2, ZPX|NORM, },
  1329.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1330.     /* d8 */    { { 'C', 'L', 'D', 0, },  1, IMP|NORM, },
  1331.     /* d9 */    { { 'C', 'M', 'P', 0, },  3, ABY|NORM, },
  1332.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1333.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1334.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1335.     /* dd */    { { 'C', 'M', 'P', 0, },  3, ABX|NORM, },
  1336.     /* de */    { { 'D', 'E', 'C', 0, },  3, ABX|NORM, },
  1337.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1338.     /* e0 */    { { 'C', 'P', 'X', 0, },  2, IMM|NORM, },
  1339.     /* e1 */    { { 'S', 'B', 'C', 0, },  2, INX|NORM, },
  1340.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1341.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1342.     /* e4 */    { { 'C', 'P', 'X', 0, },  2, ZPG|NORM, },
  1343.     /* e5 */    { { 'S', 'B', 'C', 0, },  2, ZPG|NORM, },
  1344.     /* e6 */    { { 'I', 'N', 'C', 0, },  2, ZPG|NORM, },
  1345.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1346.     /* e8 */    { { 'I', 'N', 'X', 0, },  1, IMP|NORM, },
  1347.     /* e9 */    { { 'S', 'B', 'C', 0, },  2, IMM|NORM, },
  1348.     /* ea */    { { 'N', 'O', 'P', 0, },  1, IMP|NORM, },
  1349.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1350.     /* ec */    { { 'C', 'P', 'X', 0, },  3, ABS|NORM, },
  1351.     /* ed */    { { 'S', 'B', 'C', 0, },  3, ABS|NORM, },
  1352.     /* ee */    { { 'I', 'N', 'C', 0, },  3, ABS|NORM, },
  1353.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1354.     /* f0 */    { { 'B', 'E', 'Q', 0, },  2, REL|FORK, },
  1355.     /* f1 */    { { 'S', 'B', 'C', 0, },  2, INY|NORM, },
  1356.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1357.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1358.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1359.     /* f5 */    { { 'S', 'B', 'C', 0, },  2, ZPX|NORM, },
  1360.     /* f6 */    { { 'I', 'N', 'C', 0, },  2, ZPX|NORM, },
  1361.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1362.     /* f8 */    { { 'S', 'E', 'D', 0, },  1, IMP|NORM, },
  1363.     /* f9 */    { { 'S', 'B', 'C', 0, },  3, ABY|NORM, },
  1364.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1365.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1366.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1367.     /* fd */    { { 'S', 'B', 'C', 0, },  3, ABX|NORM, },
  1368.     /* fe */    { { 'I', 'N', 'C', 0, },  3, ABX|NORM, },
  1369.     /* 00 */    { { '?', '?', '?', 0, },  1, ILL|NORM, },
  1370. };
  1371. \SHAR\EOF\
  1372. else
  1373.   echo "will not over write ./tbl.c"
  1374. fi
  1375. echo "Finished archive 1 of 1"
  1376. # if you want to concatenate archives, remove anything after this line
  1377. exit
  1378.  
  1379.