/* mipsdasm.c - a MIPS opcode disassembler */
/* Version 0.1 26-DEC-00 */
/* Copyright © 2000 Sean Riddle */

/* based on 6809dasm.c */

/* Freely distributable on any medium given all copyrights are retained */
/* by the author and no charge greater than $7.00 is made for obtaining */
/* this software */

/* Please send all bug reports, update ideas and data files to: */
/* seanriddle@home.com */

/* the data files must be kept compatible across systems! */

/* usage: mipsdasm <file> [<data file>] */
/* output to stdout, so use redirection */

/* The optional data file contains 7 types of lines: */
/* o Remarks - these are lines beginning with a semi-colon (;) */
/*   they are completely ignored. */
/* o 1 ORG line - gives the origin of the code; this is the starting */
/*   address to be used for the disassembly. */
/* o COMMENT lines - used to add comments to the end of lines of the */
/*   disassembly. */
/* o COMMENTLINE lines - provide full-line comments to be included before */
/*   a given address in the disassembly. */
/* o DATA lines - mark sections as data.  These sections will not be */
/*   disassembled, but dumped as hex data instead. */
/* o ASCII lines - mark sections as text.  These sections will not be */
/*   disassembled, but printed as text instead. */
/* o ROT13 lines - subtracts 13 from the text */
/* See sample data files (*.dat) for examples. */

/* current limitations: */
/* o number of LABEL, DATA/ASCII, COMMENT and COMMENTLINE lines determined */
/*   at compile-time - see MAXLABEL, MAXDATA, MAXCOMMENT and MAXCOMMLINE */
/* o all DATA/ASCII lines in data file must be sorted in ascending */
/*   address order */
/* o ditto for COMMENT and COMMENTLINE lines */
/* o if a DATA/ASCII area is preceded by what mipsdasm thinks is code */
/*   that continues into the DATA/ASCII area, the data will not be marked */
/*   as such, and an error will be printed.  If this is the case, mark the */
/*   line before the data as data also. */

/* to do: */
/* o sort comment, ascii, data lines */
/* o look at JMP and JSR addresses- set to code unless overridden */
/*   in data file */
/* o perhaps a 'scan' that creates a first-guess .dat file? */
/*   generate dummy labels, mark code, find ASCII, etc. */

/* Visual c++ 6 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

/* a few of my datatypes (from Amiga) */
#define TRUE (1==1)
#define FALSE (!TRUE)
typedef short BOOL;                                    /* boolean quantity */
typedef unsigned char UBYTE;                    /* unsigned 8-bit quantity */

/* array sizes for labels, DATA/ASCII definitions and COMMENT/COMMENTLINE */
#define MAXLABEL 999
#define MAXDATA 999                           /* both DATA and ASCII lines */
#define MAXCOMMENT 999
#define MAXCOMMLINE 999

/* output listing spacing */
#define TABOPNAME 22
#define TABOPERAND 28
#define TABCOMM 55

#define OPNAMETAB (TABOPNAME-1)
#define OPERANDTAB (TABOPERAND-1)
#define COMMTAB (TABCOMM-1)

typedef struct {                                       /* opcode structure */
   UBYTE opcode;
   char name[10];
   BOOL src;	/* display flags */
   BOOL trg;
   BOOL dst;
   char mode;	/* I=imm, B=branch, S=shift, P=page select, C=cop bra, J=jump, Z=cop # */
} opcodeinfo;
   
#define NUMPAGES 6
/* number of opcodes in each page */
#define NUMMAINOPS 41
#define NUMPG0OPS 28
#define NUMPG1OPS 4
#define NUMCOPOPS 9
#define NUMCOP0OPS 7
#define NUMFPOPS 26

int numops[NUMPAGES]={
   NUMMAINOPS,NUMPG0OPS,NUMPG1OPS,NUMCOPOPS,NUMCOP0OPS,NUMFPOPS,
};
/* these tables gleaned from a few net sources- probably some errors */
/*			 src   trg   dst   mode */
opcodeinfo mainopcodes[NUMMAINOPS]={
	0,"PG0",FALSE,FALSE,FALSE,'P',
	1,"PG1",FALSE,FALSE,FALSE,'P',
	2,"J",FALSE,FALSE,FALSE,'J',
	3,"JAL",FALSE,FALSE,FALSE,'J',
	4,"BEQ",TRUE,TRUE,FALSE,'B',
	5,"BNE",TRUE,TRUE,FALSE,'B',
	6,"BLEZ",TRUE,FALSE,FALSE,'B',
	7,"BGTZ",TRUE,FALSE,FALSE,'B',
	8,"ADDI",TRUE,TRUE,FALSE,'I',
	9,"ADDIU",TRUE,TRUE,FALSE,'I',
	10,"SLTI",TRUE,TRUE,FALSE,'I',
	11,"SLTIU",TRUE,TRUE,FALSE,'I',
	12,"ANDI",TRUE,TRUE,FALSE,'I',
	13,"ORI",TRUE,TRUE,FALSE,'I',
	14,"XORI",TRUE,TRUE,FALSE,'I',
	15,"LUI",FALSE,TRUE,FALSE,'I',
	16,"COP",FALSE,FALSE,FALSE,'P',
	17,"COP",FALSE,FALSE,FALSE,'P',
	18,"COP",FALSE,FALSE,FALSE,'P',
	19,"COP",FALSE,FALSE,FALSE,'P',
	32,"LB",TRUE,TRUE,FALSE,'O', /* signed? */
	33,"LH",TRUE,TRUE,FALSE,'O', /* signed? */
	34,"LWL",TRUE,TRUE,FALSE,'O', /* signed? */
	35,"LW",TRUE,TRUE,FALSE,'O', /* signed? */
	36,"LBU",TRUE,TRUE,FALSE,'O', /* signed? */
	37,"LHU",TRUE,TRUE,FALSE,'O', /* signed? */
	38,"LWR",TRUE,TRUE,FALSE,'O', /* signed? */
	39,"LWU",TRUE,TRUE,FALSE,'O', /* signed? */
	40,"SB",TRUE,TRUE,FALSE,'O', /* signed? */
	41,"SH",TRUE,TRUE,FALSE,'O', /* signed? */
	42,"SWL",TRUE,TRUE,FALSE,'O', /* signed? */
	43,"SW",TRUE,TRUE,FALSE,'O', /* signed? */
	46,"SWR",TRUE,TRUE,FALSE,'O', /* signed? */
	48,"LWC0",TRUE,TRUE,FALSE,'O', /* signed? */
	49,"LWC1",TRUE,TRUE,FALSE,'O', /* signed? */
	50,"LWC2",TRUE,TRUE,FALSE,'O', /* signed? */
	51,"LWC3",TRUE,TRUE,FALSE,'O', /* signed? */
	56,"SWC0",TRUE,TRUE,FALSE,'O', /* signed? */
	57,"SWC1",TRUE,TRUE,FALSE,'O', /* signed? */
	58,"SWC2",TRUE,TRUE,FALSE,'O', /* signed? */
	59,"SWC3",TRUE,TRUE,FALSE,'O', /* signed? */
};
/*			 src   trg   dst   mode */
opcodeinfo pg0opcodes[NUMPG0OPS]={
	0,"SLL",FALSE,TRUE,TRUE,'S',
	2,"SRL",FALSE,TRUE,TRUE,'S',
	3,"SRA",FALSE,TRUE,TRUE,'S',
	4,"SLLV",TRUE,TRUE,TRUE,'S',
	6,"SRLV",TRUE,TRUE,TRUE,'S',
	7,"SRAV",TRUE,TRUE,TRUE,'S',
	8,"JR",TRUE,FALSE,FALSE,'J',
	9,"JALR",TRUE,FALSE,TRUE,'J',
	12,"SYSCALL",FALSE,FALSE,FALSE,' ',
	13,"BREAK",FALSE,FALSE,FALSE,' ',
	16,"MFHI",FALSE,FALSE,TRUE,' ',
	17,"MTHI",TRUE,FALSE,FALSE,' ',
	18,"MFLO",FALSE,FALSE,TRUE,' ',
	19,"MTLO",TRUE,FALSE,FALSE,' ',
	24,"MULT",TRUE,TRUE,FALSE,' ',
	25,"MULTU",TRUE,TRUE,FALSE,' ',
	26,"DIV",TRUE,TRUE,FALSE,' ',
	27,"DIVU",TRUE,TRUE,FALSE,' ',
	32,"ADD",TRUE,TRUE,TRUE,' ',
	33,"ADDU",TRUE,TRUE,TRUE,' ',
	34,"SUB",TRUE,TRUE,TRUE,' ',
	35,"SUBU",TRUE,TRUE,TRUE,' ',
	36,"AND",TRUE,TRUE,TRUE,' ',
	37,"OR",TRUE,TRUE,TRUE,' ',
	38,"XOR",TRUE,TRUE,TRUE,' ',
	39,"NOR",TRUE,TRUE,TRUE,' ',
	42,"SLT",TRUE,TRUE,TRUE,' ',
	43,"SLTU",TRUE,TRUE,TRUE,' ',
};
/*			 src   trg   dst   mode */
opcodeinfo pg1opcodes[NUMPG1OPS]={
	0,"BLTZ",TRUE,FALSE,FALSE,'B',
	1,"BGEZ",TRUE,FALSE,FALSE,'B',
	16,"BLTZAL",TRUE,FALSE,FALSE,'B',
	17,"BGEZAL",TRUE,FALSE,FALSE,'B',
};
/*			 src   trg   dst   mode */
opcodeinfo copopcodes[NUMCOPOPS]={
	0,"MFC",FALSE,TRUE,TRUE,'Z',
	1,"DMFC",FALSE,TRUE,TRUE,'Z',
	2,"CFC",FALSE,FALSE,FALSE,'Z',
	4,"MTC",FALSE,TRUE,TRUE,'Z',
	5,"DMTC",FALSE,TRUE,TRUE,'Z',
	6,"CTC",FALSE,FALSE,FALSE,'Z',
	8,"BC",FALSE,FALSE,FALSE,'C',		/* funky bczf/bczt */
	16,"COP0",FALSE,FALSE,FALSE,' ',
	17,"FP",FALSE,FALSE,FALSE,' ',
};

/*			 src   trg   dst   mode */
opcodeinfo cop0opcodes[NUMCOP0OPS]={
	0,"COP0",FALSE,FALSE,FALSE,' ',
	1,"TLBR",FALSE,FALSE,FALSE,' ',
	2,"TLBWI",FALSE,FALSE,FALSE,' ',
	6,"TLBWR",FALSE,FALSE,FALSE,' ',
	8,"TLBP",FALSE,FALSE,FALSE,' ',
	16,"RFE",FALSE,FALSE,FALSE,' ',
	24,"ERET",FALSE,FALSE,FALSE,' ',
};

/*			 src   trg   dst   mode */
opcodeinfo fpopcodes[NUMFPOPS]={
	0,"ADD",TRUE,TRUE,TRUE,'F',
	1,"SUB",TRUE,TRUE,TRUE,'F',
	2,"MUL",TRUE,TRUE,TRUE,'F',
	3,"DIV",TRUE,TRUE,TRUE,'F',
	5,"ABS",TRUE,FALSE,TRUE,'F',
	6,"MOV",TRUE,FALSE,TRUE,'F',
	7,"NEG",TRUE,FALSE,TRUE,'F',
	32,"CVT.S",TRUE,FALSE,TRUE,'F',
	33,"CVT.D",TRUE,FALSE,TRUE,'F',
	36,"CVT.W",TRUE,FALSE,TRUE,'F',
	48,"C.F",TRUE,TRUE,FALSE,'F',
	49,"C.UN",TRUE,TRUE,FALSE,'F',
	50,"C.EQ",TRUE,TRUE,FALSE,'F',
	51,"C.UEQ",TRUE,TRUE,FALSE,'F',
	52,"C.OLT",TRUE,TRUE,FALSE,'F',
	53,"C.ULT",TRUE,TRUE,FALSE,'F',
	54,"C.OLE",TRUE,TRUE,FALSE,'F',
	55,"C.ULE",TRUE,TRUE,FALSE,'F',
	56,"C.ST",TRUE,TRUE,FALSE,'F',
	57,"C.NGLE",TRUE,TRUE,FALSE,'F',
	58,"C.SEQ",TRUE,TRUE,FALSE,'F',
	59,"C.NGL",TRUE,TRUE,FALSE,'F',
	60,"C.LT",TRUE,TRUE,FALSE,'F',
	61,"C.NGE",TRUE,TRUE,FALSE,'F',
	62,"C.LE",TRUE,TRUE,FALSE,'F',
	63,"C.NGT",TRUE,TRUE,FALSE,'F',
};
   
opcodeinfo *pgpointers[NUMPAGES]={
   mainopcodes,pg0opcodes,pg1opcodes,copopcodes,cop0opcodes,fpopcodes
};

unsigned int count;                             /* current program counter for disasm */

/* getword() - get 32 bits from a file, and increment the byte counter */
unsigned int getword(FILE *fp) {
	unsigned int w;
	int i;

	count+=4;
	w=0;
	for(i=0;(i<4)&&!feof(fp);i++) {
		w<<=8;
		w=w|getc(fp);
	}
	return(w);
}


#ifdef NOCONST
   #define const
#endif
const char *regs[32]={"zero","at","v0","v1","a0","a1","a2","a3",
	"t0","t1","t2","t3","t4","t5","t6","t7","s0","s1","s2","s3","s4","s5","s6","s7",
	"t8","t9","k0","k1","gp","sp","fp","ra"};
      
#define LABELSIZE 40
/* label structure */
struct lastruct {
   unsigned int lab;                                    /* label address */
   char label[LABELSIZE];                                    /* label text */
} *labarray=NULL;
int numlab=0;                                  /* number of labels defined */

#ifndef AMIGA
/* hmmm, these aren't ANSI */
/* stricmp() - compare two strings, case insensitive */
int stricmp(const char *s1, const char *s2) {
   for(;toupper(*s1)==toupper(*s2);++s1,++s2)
      if(*s1=='\0')
         return(0);
   return((toupper(*(unsigned char *)s1)<toupper(*(unsigned char *)s2))?-1:1);
}


/* strnicmp() - compare two strings, case insensitive, length limited */
int strnicmp(const char *s1, const char *s2, size_t n) {
   for(;0<n;++s1,++s2,--n)
      if(toupper(*s1)!=toupper(*s2))
         return((toupper(*(unsigned char *)s1)<
               toupper(*(unsigned char *)s2))?-1:1);
      else if(*s1=='\0')
         return(0);
   return(0);
}
#endif


char labtemp[LABELSIZE+15];                   /* global return for checklabs() - tsk */

/* checklabs() - check the defined labels from data file */
/* substitute label for address if found */
char *checklabs(unsigned int address,BOOL lab2) {
   int i;
   
   labtemp[0]='\0';
   for(i=0;i<numlab;i++) {
        if(address==labarray[i].lab) {
			if(lab2)
				sprintf(labtemp,"%s:\n%08X: ",labarray[i].label,address);
			else
				sprintf(labtemp,"%s",labarray[i].label);
           i=numlab+1;
        }
   }
   if(i==numlab) {
	if(lab2)
		   sprintf(labtemp,"%08X: ",address);
	else
			sprintf(labtemp,"%08X",address);
   }
   return(labtemp);
}


UBYTE xl=0;	/* extra line after J/JR/BRA */

/* printoperands() - print operands for the given opcode */
void printoperands(unsigned int opcode,FILE *fp,char *str) {
   int i;
   char out2[80];
   UBYTE op1,trg,src,dst,page,opn;
   unsigned short rel;
   char comma[2];
   char ddd[3];
   char zzz[2];

   comma[0]=0;
   comma[1]=0;
   ddd[0]=0;
   ddd[1]=0;
   ddd[2]=0;
   zzz[1]=0;

   opn=(opcode>>26)&0x3f;
   for(i=0;(i<numops[0])&&(mainopcodes[i].opcode!=opn);i++)
	   ;
   if(i<numops[0]) {
	   trg=(opcode>>16)&0x1f;
	   src=(opcode>>21)&0x1f;
	   dst=(opcode>>11)&0x1f;
	   if(!strcmp(mainopcodes[i].name,"PG0")) {
		   page=1;
		   opn=opcode&0x3f;
	   } else if(!strcmp(mainopcodes[i].name,"PG1")) {
		   page=2;
		   opn=(opcode>>16)&0x1f;
	   } else if(!strcmp(mainopcodes[i].name,"COP")) {
		   page=3;
		   opn=(opcode>>21)&0x1f;
		   for(i=0;(i<numops[page])&&(copopcodes[i].opcode!=opn);i++)
			   ;
		   if(i<numops[page]) {
			   if(!strcmp(copopcodes[i].name,"COP0")) {
				   page=4;
				   opn=opcode&0x1f;
				} else if(!strcmp(copopcodes[i].name,"FP")) {
				   page=5;
				   opn=opcode&0x3f;
				   ddd[0]='.';
				   if((opcode>>21)&1==0)
					   ddd[1]='S';
					else
						ddd[1]='D';
				   src=(opcode>>11)&0x1f;
				   dst=(opcode>>6)&0x1f;
				}
		   }
	   } else
		   page=0;

	   for(i=0;(i<numops[page])&&(pgpointers[page][i].opcode!=opn);i++)
		   ;
		op1=i;
		
	   if(opcode==0)
		   strcat(str,"NOOP");
	   else {
		   if(op1==numops[page])
			   strcat(str,"???");
		   else {
				sprintf(out2,"%s",pgpointers[page][op1].name);
				strcat(str,out2);

			   if(pgpointers[page][op1].mode=='S') {	/* shift = D,T,S,# */
				   for(i=strlen(out2);i<10;i++)
					   strcat(str," ");
				   if(pgpointers[page][op1].dst) {
					   sprintf(out2,"%s $%s",comma,regs[dst]);
					   strcat(str,out2);
					   comma[0]=',';
				   }

				   if(pgpointers[page][op1].trg) {
					   sprintf(out2,"%s $%s",comma,regs[trg]);
					   strcat(str,out2);
					   comma[0]=',';
				   }

				   if(pgpointers[page][op1].src) {
					   sprintf(out2,"%s $%s",comma,regs[src]);
					   strcat(str,out2);
					   comma[0]=',';
				   }
					   sprintf(out2,"%s #%04X",comma,(opcode>>6)&0x1f);
					   strcat(str,out2);
			   } else if(pgpointers[page][op1].mode=='O') {	/* offset = T,D,#(S) */
				   for(i=strlen(out2);i<10;i++)
					   strcat(str," ");
				   if(pgpointers[page][op1].trg) {
					   sprintf(out2,"%s $%s",comma,regs[trg]);
					   strcat(str,out2);
					   comma[0]=',';
				   }

				   if(pgpointers[page][op1].dst) {
					   sprintf(out2,"%s $%s",comma,regs[dst]);
					   strcat(str,out2);
					   comma[0]=',';
				   }

				   sprintf(out2,"%s #%04X",comma,opcode&0xffff);
				   strcat(str,out2);

				   if(pgpointers[page][op1].src) {
					   sprintf(out2," ($%s)",regs[src]);
					   strcat(str,out2);
					   comma[0]=',';
				   }
			   } else if(pgpointers[page][op1].mode=='B') {	/* branch = D,S,T,# */
				   for(i=strlen(out2);i<10;i++)
					   strcat(str," ");
				   if(pgpointers[page][op1].dst) {
					   sprintf(out2,"%s $%s",comma,regs[dst]);
					   strcat(str,out2);
					   comma[0]=',';
				   }

				   if(pgpointers[page][op1].src) {
					   sprintf(out2,"%s $%s",comma,regs[src]);
					   strcat(str,out2);
					   comma[0]=',';
				   }

				   if(pgpointers[page][op1].trg) {
					   sprintf(out2,"%s $%s",comma,regs[trg]);
					   strcat(str,out2);
					   comma[0]=',';
				   }
					strcat(str,comma);
					strcat(str," ");
					rel=opcode&0xffff;
					sprintf(out2,checklabs(count+4*((rel<32768) ? rel : rel-65536),FALSE));
					strcat(str,out2);	
					if((opn==4)&&(src==trg))
						xl=1;					
			   } else if(pgpointers[page][op1].mode=='F') {	/* float = D,S,T,# */
				   strcat(str,ddd);
				   for(i=strlen(out2);i<10;i++)
					   strcat(str," ");
				   if(pgpointers[page][op1].dst) {
					   sprintf(out2,"%s $%s",comma,regs[dst]);
					   strcat(str,out2);
					   comma[0]=',';
				   }

				   if(pgpointers[page][op1].src) {
					   sprintf(out2," ($%s)",regs[src]);
					   strcat(str,out2);
					   comma[0]=',';
				   }

				   if(pgpointers[page][op1].trg) {
					   sprintf(out2,"%s $%s",comma,regs[trg]);
					   strcat(str,out2);
					   comma[0]=',';
				   }

			   } else if((pgpointers[page][op1].mode=='C')||
					(pgpointers[page][op1].mode=='Z')) {	/* cop : use Z */
				   zzz[0]=((opcode>>26)&0x3)|'0';
				   strcat(str,zzz);
				   if(pgpointers[page][op1].mode=='C') {
					   if(((opcode>>16)&0x1)==0)
						   strcat(str,"F");
					   else
						   strcat(str,"T");
					   for(i=strlen(out2)+2;i<10;i++)
						   strcat(str," ");
						rel=opcode&0xffff;
						sprintf(out2,checklabs(count+4*((rel<32768) ? rel : rel-65536),FALSE));
						strcat(str,out2);	
				   } else {
					   for(i=strlen(out2)+1;i<10;i++)
						   strcat(str," ");
				   }
			   } else if(pgpointers[page][op1].mode=='J') {	/* jump = S D target */
				   for(i=strlen(out2);i<10;i++)
					   strcat(str," ");
				   if(pgpointers[page][op1].src) {
					   sprintf(out2,"%s $%s",comma,regs[src]);
					   strcat(str,out2);
					   comma[0]=',';
				   }

				   if(pgpointers[page][op1].dst) {
					   sprintf(out2,"%s $%s",comma,regs[dst]);
					   strcat(str,out2);
					   comma[0]=',';
				   }

				   if(!pgpointers[page][op1].src) {
					   sprintf(out2,"%s %s",comma,checklabs(((opcode&0x3ffffff)<<2)|(count&0xf0000000),FALSE));
					   strcat(str,out2);
				   }
					if((opn==2)||(opn==8))
						xl=1;
			   } else if(pgpointers[page][op1].mode=='I') {	/* imm = D,T,S,Imm */
				   for(i=strlen(out2);i<10;i++)
					   strcat(str," ");
				   if(pgpointers[page][op1].dst) {
					   sprintf(out2,"%s $%s",comma,regs[dst]);
					   strcat(str,out2);
					   comma[0]=',';
				   }

				   if(pgpointers[page][op1].trg) {
					   sprintf(out2,"%s $%s",comma,regs[trg]);
					   strcat(str,out2);
					   comma[0]=',';
				   }

				   if(pgpointers[page][op1].src) {
					   sprintf(out2,"%s $%s",comma,regs[src]);
					   strcat(str,out2);
					   comma[0]=',';
				   }

				   sprintf(out2,"%s #%04X",comma,opcode&0xffff);
				   strcat(str,out2);
			   } else {	/* default is D,S,T */
				   for(i=strlen(out2);i<10;i++)
					   strcat(str," ");
				   if(pgpointers[page][op1].dst) {
					   sprintf(out2,"%s $%s",comma,regs[dst]);
					   strcat(str,out2);
					   comma[0]=',';
				   }

				   if(pgpointers[page][op1].src) {
					   sprintf(out2,"%s $%s",comma,regs[src]);
					   strcat(str,out2);
					   comma[0]=',';
				   }

				   if(pgpointers[page][op1].trg) {
					   sprintf(out2,"%s $%s",comma,regs[trg]);
					   strcat(str,out2);
					   comma[0]=',';
				   }
			   }
			}
	   }
   } else
	   strcat(str,"???");  /* unknown (to me) opcode */
}

#define DATA 0                                  /* type of data to display */
#define ASCII 1
#define ROT13 2

/* DATA/ASCII structure definition */
struct dastruct {
   unsigned int start;                /* beginning address of DATA/ASCII */
   unsigned int end;                                   /* ending address */
   unsigned short per_line;                   /* values to print on a line */
   short type;                                           /* DATA or ASCII ? */
} *dataarray=NULL;

#define COMMENTSIZE 80
/* COMMENT/COMMENTLINE structure definition */
struct castruct {
   unsigned int comline;                         /* comment line address */
   char comment[COMMENTSIZE];                              /* comment text */
} *commarray=NULL,*commlinearray=NULL;

char out[512],out2[80];                             /* temp string buffers */

void readdatafile(char *filename,
      unsigned int *org,int *numlab,int *numdata,int *numcomm,int *numcommline) {
   char line2[256];
   char *line;
   FILE *fp;
   int dataline,data,data2,per_line,i,k;
   unsigned int s;
   
   if(fp=fopen(filename,"r")) {                          /* read data file */
      while(fgets(line2,255,fp)) {
         while(strlen(line2)&&!isprint(line2[strlen(line2)-1])) /* strip cr */
            line2[strlen(line2)-1]='\0';
         for(s=0;s<strlen(line2);s++)
            if((line2[s]==';')||isalpha(line2[s])) {
               line= &(line2[s]);
               s=strlen(line2);
            }
         if(!strnicmp(line,"ORG ",4)) {
            if(*org==0xffffffff)
               sscanf(&line[4],"%X",org);
            else
               printf("More than one ORG line\n");
         } else if(!strnicmp(line,"LABEL ",6)) {
            if(*numlab<MAXLABEL) {
               sscanf(&line[6],"%X",&dataline);
               labarray[*numlab].lab=dataline;
               k=6;
               while(line[k]==' ')
                  k++;
               while(line[k]!=' ')
                  k++;
               while(line[k]==' ')
                  k++;
               strncpy(labarray[*numlab].label,&line[k],LABELSIZE);
               labarray[*numlab].label[LABELSIZE-1]=0;  /* just in case */
               for(i=0;i<*numlab;i++)
                  if(!strcmp(labarray[i].label,labarray[*numlab].label)) {
                     printf("duplicate label: %s\n",labarray[i].label);
                     break;
                  }
               if(i>=*numlab)   
                  (*numlab)++;
            } else
               printf("Too many labels\n");
         } else if(!strnicmp(line,"DATA ",5)) {
            if(*numdata<MAXDATA) {
               data2=0;
               sscanf(&line[5],"%X-%X",&data,&data2);
               k=5;
               while(line[k]==' ')
                  k++;
               while(line[k]!=' ')
                  k++;
               while(line[k]==' ')
                  k++;
               if (k < i)
                  sscanf(&(line[k]),"%d",&per_line);
               else
                  per_line = 0;
               if(data2<data)
                  data2=data;
               dataarray[*numdata].type=DATA;
               dataarray[*numdata].start=data;
               dataarray[*numdata].end=data2;
               dataarray[*numdata].per_line=per_line;
               if(((*numdata)&&(dataarray[*numdata-1].start<
                     dataarray[*numdata].start))||!*numdata)
                  (*numdata)++;
               else
                  printf("`%s'\nDATA out of order\n\n",line);
            } else
               printf("Too many DATA/ASCII lines\n");
         } else if(!strnicmp(line,"ASCII ",6)) {
            if(*numdata<MAXDATA) {
               data2=0;
               per_line=0;
               sscanf(&line[6],"%X-%X %d",&data,&data2,&per_line);
               if(data2<data)
                  data2=data;
               dataarray[*numdata].type=ASCII;
               dataarray[*numdata].start=data;
               dataarray[*numdata].end=data2;
               dataarray[*numdata].per_line=per_line;
               if(((*numdata)&&(dataarray[*numdata-1].start<
                     dataarray[*numdata].start))||!*numdata)
                  (*numdata)++;
               else if(*numdata)
                  printf("`%s'\nASCII out of order\n\n",line);
            } else
               printf("Too many DATA/ASCII lines\n");
         } else if(!strnicmp(line,"ROT13 ",6)) {
            if(*numdata<MAXDATA) {
               data2=0;
               per_line=0;
               sscanf(&line[6],"%X-%X %d",&data,&data2,&per_line);
               if(data2<data)
                  data2=data;
               dataarray[*numdata].type=ROT13;
               dataarray[*numdata].start=data;
               dataarray[*numdata].end=data2;
               dataarray[*numdata].per_line=per_line;
               if(((*numdata)&&(dataarray[*numdata-1].start<
                     dataarray[*numdata].start))||!*numdata)
                  (*numdata)++;
               else if(*numdata)
                  printf("`%s'\nROT13 out of order\n\n",line);
            } else
               printf("Too many DATA/ASCII lines\n");
         } else if(!strnicmp(line,"COMMENT ",8)) {
            if(*numcomm<MAXCOMMENT) {
               sscanf(&line[8],"%X",&dataline);
               commarray[*numcomm].comline=dataline;
                              
               k=8;
               while(line[k]==' ')
                  k++;
               while(line[k]!=' ')
                  k++;
               while(line[k]==' ')
                  k++;
               strncpy(commarray[*numcomm].comment,&line[k],COMMENTSIZE);
               commarray[*numcomm].comment[COMMENTSIZE-1]=0; /* in case */

               if(((*numcomm)&&(commarray[(*numcomm)-1].comline<=
                     commarray[*numcomm].comline))||!*numcomm)
                  (*numcomm)++;
               else
                  printf("`%s'\nCOMMENT out of order\n\n",line);
            } else
               printf("Too many COMMENT lines\n");
         } else if(!strnicmp(line,"COMMENTLINE ",12)) {
            if(*numcommline<MAXCOMMLINE) {
               sscanf(&line[12],"%X",&dataline);
               commlinearray[*numcommline].comline=dataline;
               k=12;
               while(line[k]==' ')
                  k++;
               while(line[k]!=' ')
                  k++;
               while(line[k]==' ')
                  k++;
               strncpy(commlinearray[*numcommline].comment,
                     &line[k],COMMENTSIZE);
               commlinearray[*numcommline].comment[COMMENTSIZE-1]=0;
               
               if(((*numcommline)&&(commlinearray[(*numcommline)-1].comline<=
                     commlinearray[*numcommline].comline))||!*numcommline)
                  (*numcommline)++;
               else
                  printf("`%s'\nCOMMENTLINE out of order\n\n",line);
            } else
               printf("Too many COMMENTLINE lines\n");
         } else if(line[0]==';')                    /* remark in data file */
            ;
         else if(strlen(line))
            printf("`%s'\nError in file `%s'\n\n",line,filename);
      }
      fclose(fp);
   } else
      fprintf(stderr,"Can't open file `%s'\n",filename);
}


void docomment(unsigned int line,int *curcomm,int numcomm,int numoperands) {
   int  sp;
   BOOL first_comment = TRUE;

   if(!numcomm)
      return;
   if(*curcomm<numcomm) {                 /* see if we've passed a comment */
      while((line>commarray[*curcomm].comline+numoperands*4+4)&&
            (*curcomm<numcomm)) {
         printf("Error: missed a comment at %X, line=%X\n",
               commarray[*curcomm].comline,line);
         (*curcomm)++;
      }

      while((line<commarray[*curcomm].comline+numoperands*4)&&(line>=commarray[*curcomm].comline)&&
		(*curcomm<numcomm)) {
			if(first_comment!=TRUE) {
				printf("%s\n",out);
				out[0]='\0';
			}
         for(sp=strlen(out);sp<COMMTAB;sp++)
            strcat(out," ");
         strcat(out,";");
         strcat(out,commarray[*curcomm].comment);
         (*curcomm)++;
			first_comment=FALSE;
      }
   }
}


void docommline(unsigned int line,int *curcommline,int numcommline) {
   BOOL didone=FALSE;
   
   if(numcommline>0) {
      if(*curcommline<numcommline) {     /* see if we've passed a comment line*/
         while((line>commlinearray[*curcommline].comline+4)&&
               (*curcommline<numcommline)) {
            printf("Error: missed a comment line at %X, line=%X\n",
                  commlinearray[*curcommline].comline,line);
            (*curcommline)++;
         }
   
         while((line>=commlinearray[*curcommline].comline)&&(line<=commlinearray[*curcommline].comline+4)&&
               (*curcommline<numcommline)) {
            if(!didone)
               printf("\n");
            printf("*** %s\n",commlinearray[*curcommline].comment);
            (*curcommline)++;
            didone=TRUE;
         }
      }
   }
}


char rot13(UBYTE data) {
	if(data>0)
		data-=13;
	else
		data='.';
   return(data);
}


char ascii(UBYTE data) {
	if((data<31)||(data>127))
		data='_';
	return(data);
}


BOOL newl=FALSE;
BOOL diddata=FALSE;

int dumpdata(unsigned int opcode,int *curdata,int numdata,FILE *fp,
      int *curcomm,int numcomm,int *curcommline,int numcommline) {
   int pnum,tnum;
   int numoperands,numbytes;
   int k;
   int numchars=4;
   unsigned int mdata;
   

	numbytes=(2+dataarray[*curdata].end-count);
	numoperands=(2+dataarray[*curdata].end-count)/4;

   pnum=dataarray[*curdata].per_line;       /* print up to pnum bytes data */
   if(dataarray[*curdata].type==DATA) {
      sprintf(out2,"%08X ",opcode);
      strcat(out,out2);
      if((pnum<1)||(pnum>24))
         pnum=15;                       /* no more than 24 bytes hex data */
   } else {
	   if(dataarray[*curdata].type==ASCII) {
         out2[0]=ascii((opcode>>24)&0xff);
         out2[1]=ascii((opcode>>16)&0xff);
         out2[2]=ascii((opcode>>8)&0xff);
         out2[3]=ascii(opcode&0xff);
	   } else {
         out2[0]=rot13((opcode>>24)&0xff);
         out2[1]=rot13((opcode>>16)&0xff);
         out2[2]=rot13((opcode>>8)&0xff);
         out2[3]=rot13(opcode&0xff);
	   }
      out2[4]=0;
      strcat(out,out2);
      if((pnum<1)||(pnum>70))
         pnum=40;                      /* no more than 70 bytes ASCII data */
   }
   if(pnum>numbytes)
		pnum=numbytes;
   newl=FALSE;
   tnum=(pnum>numoperands)?numoperands-2:pnum-1;
   for(k=0;k<numoperands;k++) {                        /* print the data */
      if((numchars>=pnum)||newl) {
        docomment(count,curcomm,numcomm,numbytes);
         docommline(count-tnum,curcommline,numcommline);
         printf("%s\n",out);
         sprintf(out,"%08X: ",count);
         numchars=0;
         newl=FALSE;
      }
	   numchars+=4;
		mdata=getword(fp);
      if(dataarray[*curdata].type==DATA)
         sprintf(out2,"%08X ",mdata);                         /* hex */
      else {
		  if(dataarray[*curdata].type==ASCII) {
			 out2[0]=ascii((mdata>>24)&0xff);
			 out2[1]=ascii((mdata>>16)&0xff);
			 out2[2]=ascii((mdata>>8)&0xff);
			 out2[3]=ascii(mdata&0xff);
		  } else {
			 out2[0]=rot13((mdata>>24)&0xff);
			 out2[1]=rot13((mdata>>16)&0xff);
			 out2[2]=rot13((mdata>>8)&0xff);
			 out2[3]=rot13(mdata&0xff);
		  }
         out2[4]='\0';
      }
      strcat(out,out2);
   }
   if(*curdata<numdata)
      (*curdata)++;
   diddata=TRUE;
   return(numbytes>1?numbytes-2:0);
}


void freearrays(void) {
   if(dataarray)
      free(dataarray);
   if(commarray)
      free(commarray);
   if(commlinearray)
      free(commlinearray);
   if(labarray)
      free(labarray);
}


BOOL mallocarrays(void) {
   BOOL gotit=FALSE;
   
   if(labarray=(struct lastruct *)malloc(sizeof(struct lastruct)*MAXLABEL))
      if(dataarray=(struct dastruct *)
            malloc(sizeof(struct dastruct)*MAXDATA))
         if(commarray=(struct castruct *)
               malloc(sizeof(struct castruct)*MAXCOMMENT))
            if(commlinearray=(struct castruct *)
                  malloc(sizeof(struct castruct)*MAXCOMMLINE))
               gotit=TRUE;
   if(!gotit)
      freearrays();
   return(gotit);
}


void main(int argc,char *argv[]) {
   int i,j,k;
   unsigned int opcode;
   FILE *fp;
   unsigned int org=0xffffffff;
   opcodeinfo *op;
   int numoperands;
   int numcomm=0,numdata=0,numcommline=0;
   int curcomm=0,curdata=0,curcommline=0;

   if(argc>1) {
      if(!stricmp(argv[1],"list")) {              /* show all instructions */
		  for(j=0;j<NUMPAGES;j++)
			for(i=0;i<numops[j];i++)
				printf("opcode %02X, operands %d, name %6s, mode %s, cycles %d\n",
                  pgpointers[j][i].opcode,pgpointers[j][i].name);
      } else {
         if(!mallocarrays()) {
            printf("Can't get memory for arrays\n");
            exit(20);
         }
         if(argc>2)
            readdatafile(argv[2],&org,&numlab,&numdata,&numcomm,&numcommline);
         if(org!=0xffffffff)                              /* int PC to ORG val or 0 */
            count=org;
         else
            count=0;

         for(k=0;k<numlab;k++) {                     /* print labels first */
            printf("%s EQU $%04X\n",labarray[k].label,labarray[k].lab);
         }
         if(numlab)
            printf("\n");
         printf("ORG $%08X\n",count);
                     
         if(fp=fopen(argv[1],"rb")) {                  /* open binary file */
            docommline(count,&curcommline,numcommline);
			opcode=getword(fp);
            while(!feof(fp)) {
               op=NULL;
               docommline(count,&curcommline,numcommline);

               sprintf(out,"%s",checklabs(count-4,TRUE)); /* if add lab, print */
               
               if(numdata) {
                  while(((count-4)>dataarray[curdata].end)&&
                        (curdata<numdata)) {
                     printf("Error: missed a data line, start=%X, end=%X\n",
                           dataarray[curdata].start,dataarray[curdata].end);
                     curdata++;
                  }
               }
               if(numdata&&
                     ((count-4)>=dataarray[curdata].start)&&  /* data? */
                     ((count-4)<=dataarray[curdata].end)) {
                  numoperands=dumpdata(opcode,&curdata,numdata,fp,
                        &curcomm,numcomm,&curcommline,numcommline);
                  i=numops[0]+1;             /* skip decoding as an opcode */
               } else {                    /* not data - search for opcode */
                  sprintf(out2,"%08X ",opcode);
                  strcat(out,out2);
                  printoperands(opcode,fp,out);
				  numoperands=0;
               }
		  docomment(count-4-numoperands,&curcomm,numcomm,numoperands+1);
			   if(xl==2) {
					strcat(out,"\n");
					xl=0;
			   }
			   if(xl==1)
				   xl=2;
               if(diddata) {
                  if(strlen(out)&&(out[strlen(out)-1]!='\n'))
                     strcat(out,"\n");
               }
               printf("%s\n",out);
               diddata=FALSE;
				opcode=getword(fp);
            }
            fclose(fp);
         } else
            fprintf(stderr,"Can't open file `%s'\n",argv[1]);
      }
   } else
      printf("Usage: `%s <file> [<datafile>]'\n",argv[0]);
   freearrays();
}