/*
cpm

CP/M emulator.
Written by D'Arcy J.M. Cain
darcy@druid

*/

#define         CPM_DATA

#include        <stdio.h>
#include        <string.h>
#include        <stdlib.h>
#include        <unistd.h>
#include        <ctype.h>
#include        <errno.h>
#include        <termio.h>
#include        <signal.h>
#include        <time.h>
#include        <sys/stat.h>
#include        <fcntl.h>
#include        "cpm.h"

#define         FILLER_SIZE     (16 - sizeof(FILE *))

FILE    **fcb_fp(byte *fcb)
{
       return((FILE **)(fcb + 16));
}

#define         FCB_DR(x)               (x)[0]          /* drive: 0 = def, 1 = A, 2 = B, etc */
#define         FCB_NAME(x)             ((x) + 1)       /* file name up to 8 characters */
#define         FCB_TYP(x)              ((x) + 9)       /* file type up to 3 characters */
#define         FCB_EX(x)               (x)[12]         /* extent number */
#define         FCB_S1(x)               (x)[13]
#define         FCB_S2(x)               (x)[14]
#define         FCB_RC(x)               (x)[15]         /* record count for extent "ex" */
#define         FCB_FP(x)               (*fcb_fp(x))/* internal use only */
#define         FCB_CR(x)               (x)[32]         /* current record */
#define         FCB_R0(x)               (x)[33]         /* record number */
#define         FCB_R1(x)               (x)[34]         /* R0 + (R1 << 8) + ((R2  & 1) << 16) */
#define         FCB_R2(x)               (x)[35]
#define         FCB_RR(x)               (long)((x)[33] + ((x)[34]<<8) + (((x)[35] & 1)<<16))

#ifdef          CPM_DEBUG
#define         dump_registers(output)
       fprintf(output, reg_dump, A, BC, DE, HL, SP, PC,
                                       SIGN ? 'S' : '-',
                                       ZERO ? 'Z' : '-',
                                       HALF_CARRY ? 'H' : '-',
                                       PARITY ? 'P' : '-',
                                       BCD ? 'N' : '-',
                                       CARRY ? 'C' : '-',
                                       ram[PC], dasm

static int              dasm_flag = 0;
static const char       *reg_dump =
       "A=%02.2x BC=%4.4x DE=%04.4x HL=%04.4x SP=%04.4x PC=%04.4x %c%c%c%c%c%c %02.2x %srn";
#else
#define         dump_registers(output)
#endif

extern char             *optarg;
struct termio   old_term, termp;
static int              user_break;

#ifndef         COMPILE_TEST
static byte             *dma;
static char             *tail;
static int              out_delim = '$', def_drive = 1;
static FILE             *reader = NULL, *punch = NULL, *list = NULL;
#endif

/* clean up routine */
static void     cleanup(int sig)
{
       if (sig == SIGINT)
       {
               user_break = 1;
               signal(SIGINT, cleanup);
               return;
       }

       ioctl(0, TCSETA, &old_term);
       printf("nWe now return you to your regularly scheduled OSn");
       exit(0);
}

#ifndef         COMPILE_TEST

/* get a character from the terminal */
static int              getch(int check)
{
#if 0
       byte    c = 0;
       int             ret_val;

       while ((ret_val = read(0, &c, 1)) != 1)
               if (ret_val == -1 && errno == EINTR)
                       return(-1);

       return(c);
#else
       static unsigned char    buf[1024];
       static int                              index = 0, sz = 0;
       int                                             err_ret;

       if (index != sz)
               return(buf[check ? index : index++]);

       index = 0;

       /* first try to get everything that's waiting */
       fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NDELAY);
       sz = read(0, buf, 1024);
       err_ret = errno;

       if (fcntl(0, F_SETFL, fcntl(0, F_GETFL) & ~O_NDELAY) < 0)
               return(-1);

       /* error other than no data ready? */
       if (sz == -1)
       {
               sz = 0;
               return(-1);
       }

       /* no data ready */
       if (!sz)
       {
               if (check)
                       return(0);

               /* protect against signals */
               while ((sz = read(0, buf, 1)) == 0)
                       ;

               if (sz != 1)
               {
                       sz = 0;
                       return(-1);
               }
       }

       return(buf[check ? index : index++]);
#endif
}


/* How CP/M drives map to Unix: */
/* below is an array of 17 strings.  This corresponds to the allowable */
/* drive names in CP/M (A to P) plus the default drive which actually */
/* is a duplicate of one of the next 16.  At startup, The current Unix */
/* directory is copied into cpm_drive[1] and becomes drive A.  This may */
/* be modified by the startup sequence.  As well, the other drives may */
/* be set up to other directories.  At the end of the startup sequence */
/* the "strcpy(cpm_drive[0], cpm_drive[1]) causes drive A to be the CP/M */
/* default drive.  From that point on, a switch to a new drive involves */
/* simply copying that drive's directory into cpm_drive[0].  I did this */
/* in this way since I expect changing drives to occur less frequently */
/* than accessing files. */

static char             cpm_drive[17][128];

/* take a string, terminate it at the first white space and return the
  string that follows.  I.E: "DIR *.COM" puts a 0 in the first space
  and returns a pointer to "*.COM".  Note that "DIR" returns a pointer
  to a NULL string - NOT a NULL pointer. */
static char     *chop_cmd(char *buf)
{
       char    *ptr = buf;

       /* discard leading space */
       while (isspace(*ptr))
               ptr++;

       /* quad left the string */
       strcpy(buf, ptr);

       /* terminate first word */
       ptr = buf;
       while (!isspace(*ptr) && *ptr)
               ptr++;

       /* is there more? */
       if (*ptr)
       {
               /* terminate first word */
               *ptr++ = 0;

               /* skip any leading space */
               while (isspace(*ptr))
                       ptr++;

       }

       return(ptr);
}

/* given a drive unit (0 - 16) and a file name, returns Unix file name */
static char *mk_name(int dr, char *fname)
{
       static char     full_name[148];

       sprintf(full_name, "%s/%s", cpm_drive[dr], fname);
       return(full_name);
}

/* given a file spec in standard CP/M format returns Unix file name */
static char     *real_name(char *fname)
{
       /* does it include a drive letter? */
       if (fname[1] == ':')
               return(mk_name(*fname & 0x0f, fname + 2));

       /* else use default drive */
       /* return(mk_name(0, fname)); */
       return(fname);
}


/* given a pointer to an FCB, returns real file name */
static char     *fcb2real(byte *buf)
{
       char    temp[16], *p = temp;
       int             k = 0;

       for (k = 0; k < 8; k++)
               if (!isspace(FCB_NAME(buf)[k]))
                       *p++ = tolower(FCB_NAME(buf)[k]);

       *p++ = '.';

       for (k = 0; k < 3; k++)
               if (!isspace(FCB_TYP(buf)[k]))
                       *p++ = tolower(FCB_TYP(buf)[k]);

       *p-- = 0;

       if (*p == '.')
               *p = 0;

       return(mk_name(FCB_DR(buf), temp));
}

/* calls system command with CP/M file name converted to Unix */
static void             fsystem(const char *s, char *file)
{
       char    command[256];

       sprintf(command, s, real_name(file));
       ioctl(0, TCSETAW, &old_term);
       system(command);
       ioctl(0, TCSETAW, &termp);
}

/* formats a CP/M file name into an FCB */
static void     mk_fcb(byte *buf, char *fname)
{
       char    *p = fname;
       int             k, l;

       /* clear FCB to start with */
       memset(buf, 0, 16);

       /* check for drive name */
       if (p[1] == ':')
       {
               FCB_DR(buf) = *p & 0x0f;
               p += 2;
       }

       k = l = 0;

       /* format primary name */
       for (k = 0; k < 8; k++)
       {
               if ((p[l] == '.') || (p[l] == 0))
                       while (k < 8)
                               FCB_NAME(buf)[k++] = ' ';
               else if (p[l] == '*')
               {
                       while (k < 8)
                               FCB_NAME(buf)[k++] = '?';

                       while (p[l] && (p[l] != '.'))
                               l++;
               }
               else
                       FCB_NAME(buf)[k] = p[l];

               l++;
       }

       /* format file type */
       for (k = 0; k < 3; k++)
       {
               if ((p[l] == '.') || (p[l] == 0))
                       while (k < 3)
                               FCB_TYP(buf)[k++] = ' ';
               else if (p[l] == '*')
                       while (k < 3)
                               FCB_TYP(buf)[k++] = '?';
               else
                       FCB_TYP(buf)[k] = p[l];

               l++;
       }

       return;
}

/* add extension to file name.  replace current one if necessary */
static void     addext(char *s1, const char *s2)
{
       char    *p;

       if ((p = strchr(s1, '.')) == NULL)
               strcat(s1, ".");

       strcat(s1, s2);
}


/* get a string */
static int              get_str(char *buffer, int maxlen)
{
       int             k = 0, c;

       /* break will interrupt input as if nothing entered */
       while ((c = getch(0)) != 'r' && c != 'n' && c != -1)
       {
               if (k == maxlen)
                       c = 'a';
               else if (c == 'b')
               {
                       if (k)
                       {
                               fprintf(stderr, "b b");
                               k--;
                       }
               }
               else
               {
                       fputc(c, stdout);
                       buffer[k++] = c;
               }

       }

       fprintf(stderr, "rn");
       return(c == -1 ? 0 : k);
}

/* see if character waiting */
#define         kbhit()         ioctl(0, FIORDCHK, NULL)

/* Convert string to lower case */
static void             strtolow(char *s)
{
       while (*s)
       {
               *s = tolower(*s);
               s++;
       }
}

/* Convert string to upper case */
static void             strtoup(char *s)
{
       while (*s)
       {
               *s = toupper(*s);
               s++;
       }
}


#ifdef  CPM_DEBUG
#define         is_breakpoint(x)        breakpoint(0, (x))
#define         list_breakpoints()      breakpoint(0, 0)
#define         add_breakpoint(x)       breakpoint(1, (x))
#define         del_breakpoint(x)       breakpoint(2, (x))

static int              breakpoint(int cmd, int bpoint)
{
       static int      bp[64];
       int                     k;

       switch(cmd)
       {
               case 0:         /* set breakpoint if not 0 or print all */
                       for (k = 0; k < 64; k++)
                       {
                               if (bp[k])
                               {
                                       if (!bpoint)
                                               fprintf(stderr, "Breakpoint %2d: 0x%04.4xrn");
                                       else if (bp[k] == bpoint)
                                               return(1);
                               }
                       }

                       return(0);

               case 1:         /* add breakpoint */
                       /* check if already in table */
                       for (k = 0; k < 64; k++)
                               if (bp[k] == bpoint)
                                       return(k);

                       /* else put it there if there is room */
                       for (k = 0; k < 64; k++)
                       {
                               if (!bp[k])
                               {
                                       bp[k] = bpoint;
                                       return(k);
                               }
                       }

                       fprintf(stderr, "Too many breakpointsrn");
                       return(-1);

               case 2:         /* delete a breakpoint */
                       for (k = 0; k < 64; k++)
                               if (bp[k] == bpoint)
                                       bp[k] = 0;

                       return(0);
       }

       return(-1);
}


static int              debugger(void)
{
       char    entry[128], *ptr;
       int             c;

       user_break = 0;

       for (;;)
       {
               fprintf(stderr, "rnDEBUG> ");
               ptr = entry;

               while ((c = getch(0)) != 'n')
               {
                       if (c == -1)
                               return(1);

                       if ((*ptr = c) == 'b')
                       {
                               if (ptr > entry)
                               {
                                       fprintf(stderr, "b b");
                                       ptr--;
                               }
                       }
                       else
                               fputc(*ptr++, stdout);
               }

               *ptr = 0;
               strtolow(entry);
               fprintf(stderr, "rn");

               if (!*entry)
                       ;
               else if (*entry == 'g')
                       return(0);
               else if (*entry == 'q')
                       return(1);
               else if (*entry == 'r')
                       dump_registers(stdout);
               else if (*entry == '+')
                       add_breakpoint(atoi(entry + 1));
               else if (*entry == '-')
                       del_breakpoint(atoi(entry + 1));
               else if (*entry == 'l')
                       list_breakpoints();
               else if (isdigit(*entry))
                       dasm_flag = *entry - '0';
               else if (*entry == '?')
               {
                       printf("  g     Run from current PCrn");
                       printf("  q     Quit to command interpreterrn");
                       printf("  r     Dump registersrn");
                       printf("  +###  Add breakpoint at numberrrn");
                       printf("  -###  Delete breakpoint at numberrn");
                       printf("  l     list current breakpointsrn");
                       printf("  ###   Set debug level to numberrn");
               }
               else
                       fprintf(stderr, "aUnknown command: %cn", *entry);
       }
}
#endif  /* CPM_DEBUG */

/* run a program */
static int      run(char *program)
{
       byte    *mem_ptr = ram + 0x100;
       char    *fn, fn2[128];
       int             c, k, pc;
       FILE    *fp;
       byte    *fcb = NULL;
       long    f_pos;
       struct stat     s;


       /* find the program name */
       strcpy((char *)(mem_ptr), program);
       addext((char *)(mem_ptr), "com");

       /* open the command file - return error if not found */
       if ((fp = fopen((char *)(mem_ptr), "rb")) == NULL)
               return(-1);

       /* load command into memory */
       while (fread(mem_ptr, 1, 0x100, fp))
       {
               if (mem_ptr > (ram + 0xf000))
               {
                       fprintf(stderr, "aCommand file too bigrn");
                       return(-2);
               }

               mem_ptr += 0x100;
       }

       fclose(fp);
       PC = 0x100;

       /* BDOS, BIOS and default stack */
#if defined(USUAL_MICROSOFT_STUPIDITY)
       for (k = BIOS; k < 0x10000; k += 3)
       {
               ram[k] = 0xc3;  /* JP */
               ram[k + 1] = k & 0xff;
               ram[k + 2] = k >> 8;
       }

       for (k = BDOS - 0x10; k < BDOS; k++)
               ram[k] = 0;

       SP = BDOS - 0x10;
#else
       for (k = 0xfff0; k < 0x10000; k++)
               ram[k] = 0;

       SP = 0xfff0;
#endif

       strcpy((char *)(ram + 0x80), tail);
       mem_ptr = (byte *)(chop_cmd(tail));
       mk_fcb(ram + 0x5c, tail);
       mk_fcb(ram + 0x6c, (char *)(mem_ptr));
       memcpy(ram, page_zero, sizeof(page_zero));
       dma = ram + 0x80;


       /* run program.  loop stops if PC = 0 - "JP 0" e.g. */
       while (PC)
       {

#ifdef  CPM_DEBUG
               if (dasm_flag > 1)
                       dump_registers(stderr);

               if ((user_break && debugger()) || is_breakpoint(PC))
#else
               if (user_break)
#endif
               {
                       fprintf(stderr, "rnna* Program Interrupted by user *rn", ram[PC]);
                       dump_registers(stderr);
                       return(-5);
               }

               pc = PC;

               /* check if PC = BDOS entry point */
               if (PC == BDOS)
               {
                       /* do CP/M service if so */
                       switch (C)
                       {
                               case 0:                                         /* system reset */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: System resetrn");
#endif
                                       return(0);

                               case 1:                                         /* conin */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Console inrn");
#endif

                                       if ((A = getch(0)) == -1)
                                               A = '*';

                                       fputc(A, stdout);
                                       break;

                               case 2:                                         /* conout */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Console out (%c)rn", E >= ' ' ? E : '.');
#endif

                                       fputc(E, stdout);
                                       break;

                               case 3:                                         /* RDR */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Reader inrn");
#endif

                                       if (reader != NULL)
                                               A = fgetc(reader);
                                       break;

                               case 4:                                         /* PUN */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Punch out (%c)rn", E >= ' ' ? E : '.');
#endif

                                       if (punch != NULL)
                                               fputc(E, punch);
                                       break;

                               case 5:                                         /* LST */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: List out (%c)rn", E >= ' ' ? E : '.');
#endif

                                       if (list != NULL)
                                               fputc(E, list);
                                       break;

                               case 6:                                         /* CONIO */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                       {
                                               fprintf(stderr, "BDOS: Conio ");
                                               if (E == 0xff)
                                                       fprintf(stderr, "inrn");
                                               else
                                                       fprintf(stderr, "out (%c)rn", E >= ' ' ? E : '.');
                                       }
#endif

                                       if (E == 0xff)
                                       {
                                               if ((A = getch(1)) != 0)
                                                       A = getch(0);
                                       }
                                       else
                                               fputc(E, stdout);

                                       break;

                               case 7:                                         /* get IOBYTE */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Get IOBYTErn");
#endif

                                       A = 0x95;
                                       break;

                               case 8:                                         /* set IOBYTE */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Set IOBYTErn");
#endif

                                       break;

                               case 28:                                        /* write protect disk */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Write protect diskrn");
#endif

                                       break;

                               case 9:                                         /* prstr */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Print stringrn");
#endif

                                       mem_ptr = ram + DE;
                                       while (*mem_ptr != out_delim)
                                               fputc(*mem_ptr++, stdout);
                                       break;

                               case 10:                                        /* rdstr */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Read console bufferrn");
#endif

                                       ram[DE + 1] = get_str((char *)(ram) + DE + 2, ram[DE]);
                                       break;

                               case 11:                                /* CONSTAT */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Get console statusrn");
#endif

                                       A = kbhit() ? 0xff : 0;
                                       break;

                               case 12:                                /* VERSION */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Return version numberrn");
#endif

                                       HL = 0x0022;
                                       break;

                               case 13:                                /* RSTDSK */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Reset disk systemrn");
#endif

                                       break;

                               case 14:                                /* SELDSK */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Select disk %c:rn", E + 'A');
#endif

                                       k = E + 1;
                                       A = 0xff;

                                       if ((k < 1) || (k > 16))
                                               H = 4;
                                       else if (*cpm_drive[k] == 0)
                                               H = 1;
                                       else
                                       {
                                               def_drive = k;
                                               strcpy(cpm_drive[0], cpm_drive[k]);
                                               A = 0;
                                       }
                                       break;

                               case 15:                                /* OPENF */
                                       fcb = ram + DE;
                                       fn = fcb2real(fcb);
                                       memset(&FCB_FP(fcb), 0, 24);

#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Open file %srn", fn);
#endif

                                       A = 0xff;

                                       if (strchr(fn, '?') != NULL)
                                               HL = 9;
                                       else if ((FCB_DR(fcb) < 0) || (FCB_DR(fcb) > 16))
                                               HL = 4;
                                       else if (*cpm_drive[FCB_DR(fcb)] == 0)
                                               HL = 1;
                                       else if ((FCB_FP(fcb) = fopen(fn, "r+")) == NULL)
                                               HL = 0;
                                       else
                                               A = HL = 0;

                                       break;

                               case 16:
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Close filern");
#endif

                                       fcb = ram + DE;

                                       if (FCB_FP(fcb) != NULL)
                                               fclose(FCB_FP(fcb));

                                       FCB_FP(fcb) = 0;
                                       break;

                               case 19:
                                       fcb = ram + DE;

#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Delete file %srn",
                                                                                                                       fcb2real(fcb));
#endif

                                       unlink(fcb2real(fcb));
                                       FCB_FP(fcb) = NULL;
                                       break;

                               case 20:                                        /* READ */
                               case 33:                                        /* READ RANDOM */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                       {
                                               fprintf(stderr, "BDOS: Read ");
                                               if (C == 20)
                                                       fprintf(stderr, "sequential");
                                               else
                                                       fprintf(stderr, "random");
                                       }
#endif

                                       fcb = ram + DE;
                                       memset(dma, 0x1a, 0x80);

                                       if (C == 33)
                                       {
                                               f_pos = FCB_RR(fcb);
                                               fseek(FCB_FP(fcb), f_pos * 0x80, SEEK_SET);
                                       }

                                       if (fread(dma, 1, 0x80, FCB_FP(fcb)) == 0)
                                               A = 1;
                                       else
                                               A = 0;

                                       break;

                               case 21:                                        /* WRITE */
                               case 34:                                        /* WRITE RANDOM */
                               case 40:                                        /* Write Random Zero Fill */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                       {
                                               fprintf(stderr, "BDOS: Write ");
                                               if (C == 21)
                                                       fprintf(stderr, "sequentialrn");

       else if (C == 34)
                                                       fprintf(stderr, "randomrn");
                                               else
                                                       fprintf(stderr, "random with zero fillrn");
                                       }
#endif

                                       fcb = ram + DE;

                                       if (C == 34)
                                       {
                                               f_pos = FCB_RR(fcb);
                                               fseek(FCB_FP(fcb), f_pos * 0x80, SEEK_SET);
                                       }

                                       if (fwrite(dma, 1, 0x80, FCB_FP(fcb)) == 0)
                                               A = 1;
                                       else
                                               A = 0;

                                       break;

                               case 22:                                        /* MAKEF */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Make file %srn",
                                                                                               fcb2real(fcb));
#endif

                                       fcb = ram + DE;
                                       fn = fcb2real(fcb);

                                       if ((FCB_FP(fcb) = fopen(fn, "r")) != NULL)
                                       {
                                               fclose(FCB_FP(fcb));
                                               A = 0xff;
                                               HL = 8;
                                               break;
                                       }

                                       memset(&FCB_FP(fcb), 0, 24);
                                       A = 0xff;

                                       if (strchr(fn, '?') != NULL)
                                               HL = 9;
                                       else if ((FCB_DR(fcb) < 0) || (FCB_DR(fcb) > 16))
                                               HL = 4;
                                       else if (*cpm_drive[FCB_DR(fcb)] == 0)
                                               HL = 1;
                                       else if ((FCB_FP(fcb) = fopen(fn, "w")) == NULL)
                                               HL = 1;
                                       else
                                               A = HL = 0;

#ifdef  CPM_DEBUG
                                       if (HL == 1 && dasm_flag)
                                               fprintf(stderr, "Can't open %s: %srn",
                                                                                               fn, strerror(errno));
#endif
                                       break;

                               case 23:                                        /* RENAME */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Rename filern");
#endif

                                       fcb = ram + DE;
                                       strcpy(fn2, fcb2real(fcb));
                                       fn = fcb2real(fcb + 16);

                                       if (link(fn2, fn) == -1)
                                               A = 0xff;
                                       else
                                       {
                                               unlink(fn2);
                                               A = 0;
                                       }
                                       break;

                               case 24:                                        /* get log in vector */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Get login vectorrn");
#endif

                                       c = 1;
                                       HL = 0;

                                       for (k = 1; k <= 16; k++)
                                       {
                                               if (*cpm_drive[k])
                                                       HL |= c;

                                               c <<= 1;
                                       }

                                       A = L;
                                       break;

                               case 25:
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Return current diskrn");
#endif

                                       A = def_drive - 1;
                                       break;

                               case 26:
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Set DMA addressrn");
#endif

                                       dma = ram + DE;
                                       break;

                               case 29:                                        /*  get R/O vector */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Get read only vectorrn");
#endif

                                       HL = 0;
                                       break;

                               case 32:                                        /* set/get user code */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Set/get user codern");
#endif
                                       if (E == 0xff)
                                               A = 0;

                                       break;

                               case 35:                                        /* get file size */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Compute file sizern");
#endif
                                       fcb = ram + DE;
                                       if (stat(fcb2real(fcb), &s) == -1)
                                       {
                                               A = 0xff;
                                               break;
                                       }

                                       A = 0;
                                       /* fall through */

                               case 36:                                        /* set random record */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Set random recordrn");
#endif

                                       if (C == 36)
                                       {
                                               fcb = ram + DE;
                                               s.st_size = ftell(FCB_FP(fcb));
                                       }

                                       s.st_size >>= 7;
                                       FCB_R0(fcb) = s.st_size & 0xff;
                                       s.st_size >>= 8;
                                       FCB_R1(fcb) = s.st_size & 0xff;
                                       s.st_size >>= 8;
                                       FCB_R2(fcb) = s.st_size & 1;

                                       break;

                               case 37:                                        /* reset drive */
#ifdef  CPM_DEBUG
                                       if (dasm_flag)
                                               fprintf(stderr, "BDOS: Reset drivern");
#endif

                                       A = 0;
                                       break;

                               default:
                                       fprintf(stderr, "arnInvalid BDOS call %drn", C);
                                       return(-3);
                       }
               }
               else if (PC >= BIOS)
               {
                       if (PC % 3)
                       {
                               fprintf(stderr, "arnInvalid BIOS jump 0%04.4xrn", pc);
                               PC = pc;
                               dump_registers(stderr);
                               return(-5);
                       }

#ifdef  CPM_DEBUG
                       if (dasm_flag)
                               fprintf(stderr, "BIOS: Function %drn",
                                                       (PC - BIOS)/(unsigned)(3));
#endif

                       switch (PC)
                       {
                               case bios(0):   /* BOOT */
                               case bios(1):   /* WBOOT */
                                       return(0);

                               case bios(2):   /* CONST */
                                       if ((A = getch(1)) != 0)
                                               A = 0xff;

                                       break;

                               case bios(3):   /* CONIN */
                                       A = getch(0);
                                       break;

                               case bios(4):   /* CONOUT */
                                       fputc(C, stdout);
                                       break;

                               case bios(5):   /* LIST */
                                       fputc(C, list);
                                       break;

                               case bios(6):   /* PUNCH */
                                       fputc(C, punch);
                                       break;

                               case bios(7):   /* READER */
                                       A = fgetc(reader);
                                       break;

                               case bios(15):  /* LISTST */
                                       A = 0xff;               /* it's always ready */
                                       break;

                               default:
                                       PC = pc;
                                       fprintf(stderr, "Unimplemented BIOS jmp 0%04.4xH (%d)rn",
                                                                               PC, (PC - BIOS)/(size_t)(3));
                                       dump_registers(stderr);
                                       return(-6);
                       }
               }

               if (decode())
               {
                       PC = pc;
                       fprintf(stderr, "arnInvalid processor instruction 0x%02.2xrn", ram[PC]);
                       dump_registers(stderr);
                       return(-4);
               }

#ifdef  CPM_DEBUG
               if (dasm_flag > 1 && pc >= BDOS)
                       getch(0);
#endif
       }

       return(0);
}
#endif

#ifndef COMPILE_TEST
static FILE     *open_device(const char *dev, const char *typ)
{
       FILE    *fp;

       if (*dev == '!')
               fp = popen(dev + 1, typ);
       else
               fp = fopen(dev, typ);

       if (fp != NULL)
               return(fp);

       fprintf(stderr, "Error on %srn", dev);
       perror("Can't open virtual device");
       exit(1);
       return(NULL);
}

static int      do_command(char *cmd_str)
{
       char    entry[256];
       FILE    *fp;

       /* allow comments */
       if ((*cmd_str == ';') || (*cmd_str == '#'))
               return(0);

       /* get our own copy of the command */
       strcpy(entry, cmd_str);

       /* request for Unix shell escape? */
       if (*entry == '!')
       {
               int             r;

               ioctl(0, TCSETA, &old_term);
               r = system(entry + 1);
               ioctl(0, TCSETA, &termp);
               return(r);
       }

       strtolow(entry);
       tail = chop_cmd(entry);
       user_break = 0;

       /* check for request to change default drive */
       if ((isspace(entry[2]) || (entry[2] == 0)) && (entry[1] == ':'))
       {
               *entry &= 0x0f;

               if ((*entry < 1) || (*entry > MAX_DRIVES) || *cpm_drive[*entry] == 0)
               {
                       fprintf(stderr, "arnInvalid drive specificationrn");
                       return(-1);
               }

               if (chdir(cpm_drive[*entry]))
               {
                       fprintf(stderr, "arnCan't change to drive %c: %srn",
                                               entry + '@', strerror(errno));
                       return(-1);
               }

               def_drive = *entry;
               strcpy(cpm_drive[0], cpm_drive[def_drive]);
               entry[0] = entry[1] = ' ';
               tail = chop_cmd(entry);
       }

       if (*entry == 0)
               return(0);

       /* handle some builtins */
       if (strcmp(entry, "dir") == 0)
               fsystem("ls -C %s", tail);
       else if (strcmp(entry, "dump") == 0)
               fsystem("hd %s", tail);
       else if (strcmp(entry, "ed") == 0)
               fsystem("$EDITOR %s", tail);
       else if (strcmp(entry, "era") == 0)
               fsystem("rm %s", tail);
#ifdef  CPM_DEBUG
       else if (strcmp(entry, "dasm") == 0)
       {
               if(++dasm_flag > 2)
                       dasm_flag = 0;

               fprintf(stderr, "DASM is %drn", dasm_flag);
       }
#endif
       else if (strcmp(entry, "save") == 0)
       {
               char    *fname = chop_cmd(tail);
               int             p = atoi(tail);

               if ((p == 0) || (*fname == 0))
                       fprintf(stderr, "Usage: SAVE #pages filenamern");
               else
               {
                       if ((fp = fopen(real_name(fname), "wb")) == NULL)
                               perror("aCan't open save file");
                       else
                       {
                               if (fwrite(ram + 256, 256, p, fp) != p)
                                       perror("aCan't write to file");

                               fclose(fp);
                       }
               }
       }
       else if (strcmp(entry, "type") == 0)
       {
               char    *ptr;

               while (*tail)
               {
                       ptr = tail;
                       tail = chop_cmd(ptr);
                       fsystem("cat %s", ptr);
               }
       }
       else if (strcmp(entry, "exit") == 0)
               cleanup(0);
       else
#ifdef  CPM_DEBUG
       {
               time_t  start = time(NULL);
               int             r = run(real_name(entry));

               fprintf(stderr, "Run took %ld secondsnr", time(NULL) - start);
               return(r);
       }
#else
               return(run(real_name(entry)));
#endif

       return(0);
}
#endif

int             main(int argc, char **argv)
{
#ifdef  COMPILE_TEST
       /* test code useful for testing different architectures */
       int             test;

       dasm_flag = 1;
       test = (int)(&acc);
       printf("Position of A = %dn", (int)(&A) - test);
       printf("Position of FLAGS = %dn", (int)(&FLAGS) - test);

       test = (int)(&gr);
       printf("Position of B = %dn", (int)(&B) - test);
       printf("Position of C = %dn", (int)(&C) - test);
       printf("Position of BC = %dn", (int)(&BC) - test);
       printf("Position of D = %dn", (int)(&D) - test);
       printf("Position of E = %dn", (int)(&E) - test);
       printf("Position of DE = %dn", (int)(&DE) - test);
       printf("Position of H = %dn", (int)(&H) - test);
       printf("Position of L = %dn", (int)(&L) - test);
       printf("Position of HL = %dn", (int)(&HL) - test);

       AF = 0x1234;
       printf("AF = %04.4x, A = %02.2x, FLAGS = %02.2xn", AF, A, FLAGS);
       printf("Flags: S=%d Z=%d H=%d P=%d N=%d C=%dn",
                       SIGN, ZERO, HALF_CARRY, PARITY, BCD, CARRY);
       acc_bank = 1;
       AF = 0x4321;
       printf("AF = %04.4x, A = %02.2x, FLAGS = %02.2xn", AF, A, FLAGS);
       printf("Flags: S=%d Z=%d H=%d P=%d N=%d C=%dn",
                       SIGN, ZERO, HALF_CARRY, PARITY, BCD, CARRY);

       BC = 0x2345;
       printf("BC = %04.4x, B = %02.2x, C = %02.2xn", BC, B, C);
       gr_bank = 1;
       BC = 0x5432;
       printf("BC = %04.4x, B = %02.2x, C = %02.2xn", BC, B, C);
       gr_bank = 0;

       DE = 0x3456;
       printf("DE = %04.4x, D = %02.2x, E = %02.2xn", DE, D, E);
       gr_bank = 1;
       DE = 0x6543;
       printf("DE = %04.4x, D = %02.2x, E = %02.2xn", DE, D, E);
       gr_bank = 0;

       HL = 0x4567;
       printf("HL = %04.4x, H = %02.2x, L = %02.2xn", HL, H, L);
       gr_bank = 1;
       HL = 0x7654;
       printf("HL = %04.4x, H = %02.2x, L = %02.2xn", HL, H, L);
       gr_bank = 0;

       A = BC = DE = HL = SP = PC = 0;

       while (PC < TEST_SIZE)
       {
               dump_registers(stdout);

               if (decode())
               {
                       printf("* * * Processor error * * *n");
                       exit(1);
               }
       }

       dump_registers(stdout);

       for (test = 0; test < 0x10; test++)
               printf("%02.2x ", ram[test]);

       printf("n");
       for (test = 0xfff0; test < 0x10000; test++)
               printf("%02.2x ", ram[test]);

       printf("nTest code ended normallyn");
       return(0);
#else   /* COMPILE_TEST */

       char    entry[256] = "";
       int             c;

       /* make current directory the default one */
       getcwd(cpm_drive[1], 127);

       while ((c = getopt(argc, argv, "d:c:r:p:h")) != -1)
       {
               char    *ptr;
               int             k;

               switch (c)
               {
                       case 'd':
                               ptr = optarg + 2;

                               if (optarg[1] == ':')
                                       k = *optarg & 0x0f;
                               else
                               {
                                       k = 1;
                                       ptr = optarg;

                                       while ((k < 17) && (*cpm_drive[k]))
                                               k++;
                               }

                               if ((k < 1) || (k > 16))
                               {
                                       fprintf(stderr, "Can't set up %sn", optarg);
                                       exit(1);
                               }

                               strcpy(cpm_drive[k], ptr);
                               break;

                       case 'c':
                               strcpy(entry, optarg);
                               break;

                       case 'r':
                               reader = open_device(optarg, "r");
                               break;

                       case 'p':
                               punch = open_device(optarg, "w");
                               break;

                       case 'l':
                               list = open_device(optarg, "w");
                               break;

                       default:
                               fprintf(stderr, "Usage:n");
                               fprintf(stderr, "cpm [options]n");
                               fprintf(stderr, "  Options:n");
                               fprintf(stderr,
"    -d [d:]directory    map CP/M drive to Unix directory.  If then");
                               fprintf(stderr,
"                        second character is not a colon then the nextn");
                               fprintf(stderr,
"                        available drive letter is used otherwise then");
                               fprintf(stderr,
"                        letter preceding the colon is used.n");
                               fprintf(stderr,
"    -c command          runs the command file then exits.  builtinsn");
                               fprintf(stderr,
"                        not supported.  COM file must existn");
                               fprintf(stderr,
"    -[r|p|l] dev        This allows the I/O to be routed through then");
                               fprintf(stderr,
"                        Unix file system.  The devices mapped are asn");
                               fprintf(stderr,
"                        follows: r = RDR input, p = PUN output and l forn");
                               fprintf(stderr,
"                        LST output.  The dev argument is opened as a Unixn");
                               fprintf(stderr,
"                        file and I/O for specified device is done throughn");
                               fprintf(stderr,
"                        it.  If the first character is '!' then the restn");
                               fprintf(stderr,
"                        of the line is taken as a command and popen() isn");
                               fprintf(stderr,
"                        called to handle the I/O.n");
                               fprintf(stderr,
"    -h                  Show this help screenn");

                               exit(1);
               }
       }

       strcpy(cpm_drive[0], cpm_drive[1]);
       def_drive = 1;

       /* set up terminal */
       if (ioctl(0, TCGETA, &old_term) == -1)
       {
               perror("Can't get terminal parameters");
               exit(-1);
       }

       termp = old_term;
       termp.c_oflag =  0;
       termp.c_lflag =  ISIG;
       termp.c_cc[VEOF] = 1;
       termp.c_cc[VSWTCH] = -1;

       if (ioctl(0, TCSETAW, &termp) == -1)
       {
               perror("Can't set terminal parameters");
               exit(1);
       }

       signal(SIGHUP, cleanup);
       signal(SIGINT, cleanup);
       signal(SIGQUIT, cleanup);
       signal(SIGTERM, cleanup);

       setbuf(stdout, NULL);

       /* tell them who we are - note stderr */
       fprintf(stderr, "nCP/U - Control Program for Unixrn");
       fprintf(stderr, "CP/M emulator Version 0.920rn");
       fprintf(stderr, "Written by D'Arcy J.M. Cainrn");
       fprintf(stderr, "[email protected]");

       /* see if we have a command to run */
       if (*entry)
       {
               do_command(entry);
               ioctl(0, TCSETA, &old_term);
               return(0);
       }

       for (;;)
       {
               fprintf(stderr, "%c> ", def_drive + '@');
               entry[get_str(entry, 128)] = 0;

               if (*entry)
               {
                       if (do_command(entry) == -1)
                       {
                               chop_cmd(entry);
                               strtoup(entry);
                               fprintf(stderr, "%s?rn", entry);
                       }
               }
       }
#endif  /* COMPILE_TEST */
}

You are viewing proxied material from gopher.floodgap.com. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.