/*
**  fp880709/010413  convert binary file to sxf, fpc, dmp & hex
*/

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

#define S1F 1
#define S2F 2
#define S3F 3
#define FPC 4
#define DMP 5
#define HEX 6

                                                /* fpc type defs        */
#define ABS 0
#define DAT 1
#define REL 2
#define HDR 3
#define REP 4


FILE *ifp;
FILE *ofp;
unsigned char buf[33];


unsigned long gethex(char *p, int n)
{
 unsigned long h = 0;
 int i = 0;
 char c;

 while((n==0)||(i<n))
 {
  if(!(isxdigit(c=toascii(*p))))
   break; 
  if(isdigit(c))
   h = (h<<4)+(c-'0');
  else
   h = (h<<4)+(toupper(c)-'A'+10);
  p++;
  i++;
 }
 return(h);
}


/*
**      output ascii string
*/

unsigned char outdst(char len, long adr, char *ptr)
{
 int i;

 fprintf(ofp, "%08lX  ", adr);
 for(i=0; i<(int)len; i++)
  fprintf(ofp, "%02X ", ptr[i]&255);
 for(; i<16; i++)
   fprintf(ofp, "   ");
 fprintf(ofp, "  ");
 for(i=0; i<(int)len; i++)
 {
  if(isprint(toascii(ptr[i])))
   fprintf(ofp, "%c", toascii(ptr[i]));
  else
   fprintf(ofp, " ");
 }
 for(; i<16; i++)
   fprintf(ofp, " ");
 fprintf(ofp, "\n");
 return(len);
}


/*
**      output intel hex string
*/

unsigned char outist(unsigned char typ, unsigned char len, long adr, unsigned char *ptr)
{
 int i;
 unsigned char chk;

 switch(typ)
 {
  case 0 :
   fprintf(ofp, ":%02X%04X00", len&255, adr&65535);
   chk=len;
   chk+=(adr/256)&255;
   chk+=(adr%256)&255;
   for(i=0; i<(int)len; i++)
   {
    chk+=ptr[i];
    fprintf(ofp, "%02X", ptr[i]&255);
   }
   fprintf(ofp, "%02X\n", (-chk)&255);
   break;
  case 1 :
   fprintf(ofp, ":00000001FF\n");
   return(0);
  case 2 :
  case 3 :
   chk=2+typ+(unsigned char)(adr>>4)+(unsigned char)(adr>>12);
   fprintf(ofp, ":020000%02X%04X%02X\n", typ, (unsigned int)(adr>>4), (-chk)&255);
   return(0);
  case 4 :
  case 5 :
   chk=2+typ+(unsigned char)(adr>>16)+(unsigned char)(adr>>24);
   fprintf(ofp, ":020000%02X%04X%02X\n", typ, (unsigned int)(adr>>16), (-chk)&255);
   return(0);
 }
 return(len);
}


/*
**      output long in FPC to outfile
**      dig must be 5
*/
void putfpc(unsigned long fpc, unsigned int dig)
{
 if(dig>1)
  putfpc(fpc/85L, dig-1);
 dig=fpc%85L;
 fputc(dig<5 ? dig+'%' : dig+'%'+1, ofp);
}



/*
**       output FPC string
*/

unsigned char outfpc(unsigned short typ, unsigned char len, unsigned long adr, unsigned char *ptr)
{
 unsigned char chk;                             /* check byte           */
 unsigned long hed;                             /* fpc string header    */
 unsigned long val;                             /* 4 bytes in a long    */
 int i, j;                                      /* counters             */

 fprintf(ofp, "$");                             /* fpc string intro     */
 hed = (unsigned long)typ;                      /* some common things   */
 chk =-(unsigned char)typ-(unsigned char)(typ>>8);
 switch(typ)
 {
  case ABS :                                    /* abs address & data   */
  case REL :                                    /* rel address & data   */
   if(len>251)
   {
    putfpc(0x0200ffffL, 5);                        /* error indicator      */
    break;
   }
   chk-= (len+4);
   chk-= (unsigned char)adr;
   chk-= (unsigned char)(adr>>8);
   chk-= (unsigned char)(adr>>16);
   chk-= (unsigned char)(adr>>24);
   for(i=0; i<len; i++)
    chk-=(ptr[i]);
   hed|=((unsigned long)chk)<<24;
   hed|=((unsigned long)(len+4))<<16;
   putfpc(hed, 5);
   putfpc(adr, 5);
   i=0;
   val=0L;
   while(i<len)
   {
    for(j=0; j<4; j++)
     val=(val<<8)|((unsigned long)ptr[i++]);
    putfpc(val, 5);
   }
   break;
  case DAT :                                    /* data only            */
  case HDR :                                    /* header               */
   chk-= len;
   for(i=0; i<len; i++)
    chk-=ptr[i];
   hed|=((unsigned long)chk)<<24;
   hed|=((unsigned long)len)<<16;
   putfpc(hed, 5);
   i=0;
   val=0L;
   while(i < len)
   {
    for(j=0; j<4; j++)
     val=(val<<8)|((unsigned long)ptr[i++]);
    putfpc(val, 5);
   }
   break;
  case REP :                                    /* repeated data        */
   chk-= (len+4);
   chk-= ptr[0];
   hed|=((unsigned long)chk)<<24;
   hed|= 4L<<16;
   val = (unsigned long)ptr[0];
   val|=((unsigned long)len)<<16;
   putfpc(hed, 5);
   putfpc(val, 5);
   break;
  default :
   putfpc(0x0200ffffL, 5);
   break;
 }
 fprintf(ofp, "\n");                            /* new line             */
 return(len);                                   /* return length        */
}


/*
**        output hex string for  data i/o  format 95  (motorola)
**
**        typ=0 header
**        typ=1 16bit address
**        typ=2 24bit address
**        typ=3 32bit address
**        if len=0, end string is generated
**        len max=250, practical 32
**        returns: length
*/

unsigned char outhex(unsigned char typ, unsigned char len, unsigned long adr, unsigned char *ptr)
{
 unsigned char chk;
 unsigned char c;
 unsigned char i;

 if((typ==0)&&(len==0))
  return(0);                                    /* not allowed          */
 fprintf(ofp, "S%1d", len ? typ : 10-typ);
 chk=(unsigned char)(len+typ+2);
 fprintf(ofp, "%02X", chk&255);
 switch(typ)
 {
  case 3 :
   c=(unsigned char)((adr>>24)&255L);
   chk+=c;
   fprintf(ofp, "%02X", c&255);
  case 2 :
   c=(unsigned char)((adr>>16)&255L);
   chk+=c;
   fprintf(ofp, "%02X", c&255);
  case 1 :
   c=(unsigned char)((adr>>8)&255L);
   chk+=c;
   fprintf(ofp, "%02X", c&255);
   c=(unsigned char)(adr&255L);
   chk+=c;
   fprintf(ofp, "%02X", c&255);
   break;
  case 0 :
   fprintf(ofp, "0000");
   break;
 }
 for(i=0; i<len; i++)
 {
  c=ptr[i];
  chk+=c;
  fprintf(ofp, "%02X", c&255);
 }
 fprintf(ofp, "%02X\n", (~chk)&255);
 return(len);
}


/*
**      check file name extension
**      return value 0 if error
*/

int ckext(char *fname)
{
 int p;

 if((p=strlen(fname)-4)<0)
  return(0);
 if(strcmpi(&fname[p], ".s1f")==0)
  return(S1F);
 if(strcmpi(&fname[p], ".s2f")==0)
  return(S2F);
 if(strcmpi(&fname[p], ".s3f")==0)
  return(S3F);
 if(strcmpi(&fname[p], ".fpc")==0)
  return(FPC);
 if(strcmpi(&fname[p], ".dmp")==0)
  return(DMP);
 if(strcmpi(&fname[p], ".hex")==0)
  return(HEX);
 return(0);
}


void quit(int e, char *p)
{
 switch(e)
 {
  case 0 :
   fprintf(stderr, "ready\n");
   break;
  case 1 :
   fprintf(stderr, "Usage: unload infile outfile {options}\n");
   fprintf(stderr, "Infile is any binary file.\n");
   fprintf(stderr, "Outfile format depends on the file extension.\n");
   fprintf(stderr, ".S1F Motorola S1/S9 format (16-bit addresses)\n");
   fprintf(stderr, ".S2F Motorola S2/S8 format (24-bit addresses)\n");
   fprintf(stderr, ".S3F Motorola S3/S7 format (32-bit addresses)\n");
   fprintf(stderr, ".FPC Four Packed Code      (32-bit addresses)\n");
   fprintf(stderr, ".DMP dump in hex and ascii (32-bit addresses)\n");
   fprintf(stderr, ".HEX intel format       (16/32-bit addresses)\n");
   fprintf(stderr, "Header option: -h header\n");
   fprintf(stderr, "Header is a string <= 32-characters.\n");
   fprintf(stderr, "Offset option: -o offset\n");
   fprintf(stderr, "Offset is a hex number <= 32-bits.\n");
   fprintf(stderr, "FPC mode option: -0\n");
   fprintf(stderr, "Forces to generate FPC code 0 records only.\n");
   break;
  case 2 :
   fprintf(stderr, "can't open infile %s\n", p);
   break;
  case 3 :
   fprintf(stderr, "can't open outfile %s\n", p);
   break;
  case 4 :
   fprintf(stderr, "invalid outfile extension\n");
   break;
  case 5 :
   fprintf(stderr, "invalid infile extension\n");
   break;
  case 6 :
   fprintf(stderr, "address to large for selected format\n");
   break;
  case 7 :
   fprintf(stderr, "offset too large\n");
   break;
  case 8 :
   fprintf(stderr, "header too long\n");
   break;
  case 9 :
   fprintf(stderr, "hex format does not support header\n");
   break;
  case 10 :
   fprintf(stderr, "unknown option %s\n", p);
   break;
  case 11 :
   fprintf(stderr, "header may not start with hex digit for dump file\n");
   break;
  case 12 :
   fprintf(stderr, "header not allowed if -0 option used\n");
   break;
  default :
   fprintf(stderr, "undefined error %d %s\n", e, p);
   break;
 }
 exit(e);
}


void main (int argc, char *argv[])
{
 int next;
 unsigned char m;
 unsigned char n;
 int i;
 int size;
 int fpce;
 long lincnt;
 long fsize;
 unsigned long address;
 unsigned long ihexlast;
 unsigned long sum;

 fprintf(stderr, "NFeRTARI unload 010413\n");
 if(argc<3)
  quit(1, argv[0]);
 if((ckext(argv[1]))!=0)
  quit(5, "");
 if((m=(unsigned char)ckext(argv[2]))==0)
  quit(4, "");
 if((ifp=fopen(argv[1], "rb"))==NULL)
  quit(2, argv[1]);
 fseek(ifp, 0L, 2);
 fsize=ftell(ifp);
 fseek(ifp, 0L, 0);
 fpce=1;
 address=0L;
 buf[0]='\0';
 next=3;
 while(next<argc)
 {
  if(strcmp("-o", argv[next])==0)
  {
   next++;
   if(argc<=next)
    quit(1, "");
   address=gethex(argv[next], 0);
   next++;
   continue;
  }
  if(strcmp("-h", argv[next])==0)
  {
   next++;
   if(argc<=next)
    quit(1, "");
   if(strlen(argv[next])>32)
    quit(8, "");
   strcpy(buf, argv[next]);
   next++;
   continue;
  }
  if(strcmp("-0", argv[next])==0)
  {
   next++;
   fpce=0;
   continue;
  }
  quit(10, argv[next]);
 }
 if((address+fsize)<fsize)
  quit(7, "");
 if((ofp=fopen(argv[2], "w"))==NULL)
  quit(3, argv[2]);
 size=32;
 switch(m)
 {
  case S1F :
   if((fsize+address)>65536L)
    quit(6, "");
  case S2F :
   if((fsize+address)>16777216L)
    quit(6, "");
  case S3F :
   if((n=(unsigned char)strlen(buf))!=0)
    outhex(0, n, 0L, buf);
   break;
  case FPC :
   if((n=(unsigned char)strlen(buf))!=0)
   {
    if(fpce==0)
     quit(12, "");
    outfpc(HDR, n, 0L, buf);
   }
   break;
  case DMP :
   if(buf[0]!='\0')
   {
    if(isxdigit(buf[0]))
     quit(11, "");
    fprintf(ofp, "%s\n", buf);
   }
   size=16;
   break;
  case HEX :
   if((n=(unsigned char)strlen(buf))!=0)
    quit(9, buf);
   ihexlast=address;
   if((fsize+address)>65536L)
    outist(4, 2, address, buf);
   break;
  default :
   break;
 }
 if(buf[0]!='\0')
  fprintf(stdout, "header        : %s\n", buf);
 fprintf(stdout, "length        : %8lX\n", fsize);
 fprintf(stdout, "offset        : %8lX\n", address);
 lincnt=0L;
 sum=0L;
 while((n=(unsigned char)fread(buf, 1, size, ifp))!=0)
 {
  for(i=0; i<(int)n; i++)
   sum+=(unsigned long)buf[i];
  switch(m)
  {
   case S1F :
   case S2F :
   case S3F :
    address+=(unsigned long)outhex(m, n, address, buf);
    break;
   case FPC :
    if(fpce==0)
      address+=(unsigned long)outfpc(ABS, n, address, buf);
    else
    {
     if((lincnt%16)==0L)
      outfpc(ABS, 0, address, buf);
     for(i=1; i<n; i++)
      if(buf[i]!=buf[0])
       break;
     if(i<n)
      address+=(unsigned long)outfpc(DAT, n, address, buf);
     else
      address+=(unsigned long)outfpc(REP, n, address, buf);
    }
    lincnt++;
    break;
   case DMP :
    address+=(unsigned long)outdst(   n, address, buf);
    break;
   case HEX :
    if((address>>16)!=(ihexlast>>16))
    {
     ihexlast=address;
     outist(4, 2, address, buf);
    }
    address+=(unsigned long)outist(0, n, address, buf);
    break;
   default :
    break;
  }
 }
 switch(m)
 {
  case S1F :
  case S2F :
  case S3F :
   outhex(m, 0, 0L, buf);
   break;
  case FPC :
   fprintf(ofp, "$%%%%%%%%%%\n");               /* end string           */
   break;
  case HEX :
   outist(1, 0, 0L, buf);
   break;
  default :
   break;
 }
 fclose (ifp);
 fclose (ofp);
 fprintf(stdout, "chksum        : %8lX\n", sum);
 quit(0, "");
}