sz81 Code

--- a
+++ b/sz81/common.c
@@ -0,0 +1,1429 @@
+/* z81/xz81, Linux console and X ZX81/ZX80 emulators.
+ * Copyright (C) 1994 Ian Collier. z81 changes (C) 1995-2004 Russell Marks.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *
+ * common.c - various routines/vars common to z81/xz81.
+ */
+
+#define Z81_VER		"2.1"
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <dirent.h>
+#include "common.h"
+#include "sound.h"
+#include "z80.h"
+#include "allmain.h"
+
+unsigned char mem[65536],*helpscrn;
+unsigned char keyports[9]={0xff,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff};
+
+/* this two work on a per-k basis, so we can support 1k etc. properly */
+unsigned char *memptr[64];
+int memattr[64];
+
+int help=0;
+int sound=0;
+int sound_vsync=0,sound_ay=0,sound_ay_type=AY_TYPE_NONE;
+int load_hook=1,save_hook=1;
+int vsync_visuals=0;
+int invert_screen=0;
+
+volatile int signal_int_flag=0;
+volatile int exit_program_flag=0;
+int interrupted=0;
+int nmigen=0,hsyncgen=0,vsync=0;
+int scrn_freq=2;
+int unexpanded=0;
+int taguladisp=0;
+int fakedispx=0,fakedispy=0;	/* set by main.c/xmain.c */
+
+/* for the printer */
+static int zxpframes,zxpcycles,zxpspeed,zxpnewspeed;
+static int zxpheight,zxppixel,zxpstylus;
+static FILE *zxpfile=NULL;
+static char *zxpfilename=NULL;
+static unsigned char zxpline[256];
+
+
+
+int refresh_screen=1;
+
+/* =1 if emulating ZX80 rather than ZX81 */
+int zx80=0;
+
+int ignore_esc=0;
+
+int autolist=0;
+int autoload=0;
+char autoload_filename[1024];
+
+
+/* not too many prototypes needed... :-) */
+char *load_selector(void);
+
+
+
+void sighandler(int a)
+{
+signal_int_flag=1;
+}
+
+
+char *libdir(char *file)
+{
+static char buf[1024];
+
+if(strlen(LIBDIR)+strlen(file)+2>sizeof(buf))
+  strcpy(buf,file);	/* we know file is a short constant */
+else
+  sprintf(buf,"%s/%s",LIBDIR,file);
+return(buf);
+}
+
+
+void autoload_setup(char *filename)
+{
+if(zx80 || (filename && strlen(filename)+1>sizeof(autoload_filename)))
+  return;
+autoload=1;
+if(filename)
+  strcpy(autoload_filename,filename);
+else
+  *autoload_filename=0;
+}
+
+
+static void exit_program_flag_set(int foo)
+{
+exit_program_flag=1;
+}
+
+
+void startsigsandtimer()
+{
+struct sigaction sa;
+struct itimerval itv;
+int f,tmp=1000/50;	/* 50 ints/sec */
+int badsig[]={SIGHUP,SIGINT,SIGQUIT,SIGILL,SIGSEGV,SIGTERM,SIGBUS};
+int numsig=sizeof(badsig)/sizeof(badsig[0]);
+
+sigemptyset(&sa.sa_mask);
+sa.sa_handler=exit_program_flag_set;
+/* it's a bit odd using SA_RESTART for one-off exit code,
+ * but Solaris's SA_RESETHAND behaviour *as documented* is bogus
+ * (even though it seems ok in practice), so we play it safe.
+ */
+sa.sa_flags=SA_RESTART;
+
+/* XXX this extra-careful masking stuff may be superfluous
+ * now it just sets an `exit soon' flag...
+ *
+ * handle all signals listed in badsig[], making sure that all
+ * signals in the list are blocked whenever handling one of them.
+ * There are two loops as sa_mask must be fully set before calling
+ * sigaction().
+ */
+for(f=0;f<numsig;f++)
+  sigaddset(&sa.sa_mask,badsig[f]);
+
+for(f=0;f<numsig;f++)
+  sigaction(badsig[f],&sa,NULL);
+
+#ifdef OSS_SOUND_SUPPORT
+/* no timer signals when sound is enabled */
+if(sound_enabled)
+  return;
+#endif
+
+sigemptyset(&sa.sa_mask);	/* SIGALRM implicit */
+sa.sa_handler=sighandler;
+sa.sa_flags=SA_RESTART;
+
+sigaction(SIGALRM,&sa,NULL);
+
+itv.it_interval.tv_sec=  tmp/1000;
+itv.it_interval.tv_usec=(tmp%1000)*1000;
+itv.it_value.tv_sec=itv.it_interval.tv_sec;
+itv.it_value.tv_usec=itv.it_interval.tv_usec;
+setitimer(ITIMER_REAL,&itv,NULL);
+}
+
+
+void loadrom(void)
+{
+FILE *in;
+char *fname=libdir(zx80?"zx80.rom":"zx81.rom");
+
+if((in=fopen(fname,"rb"))!=NULL)
+  {
+  int siz=(zx80?4096:8192);
+  
+  fread(mem,1,siz,in);
+  
+  /* fill first 16k with extra copies of it
+   * (not really needed given since improved memptr[] resolution,
+   * but what the heck :-))
+   */
+  memcpy(mem+siz,mem,siz);
+  if(zx80)
+    memcpy(mem+siz*2,mem,siz*2);
+  
+  fclose(in);
+  }
+else
+  {
+  fprintf(stderr,
+          "z81: couldn't load ROM file %s.\n"
+          "     You *must* install this for z81 to work.\n",
+          fname);
+  exit(1);
+  }
+}
+
+
+void zx81hacks()
+{
+/* patch save routine */
+if(save_hook)
+  {
+  mem[0x2fc]=0xed; mem[0x2fd]=0xfd;
+  mem[0x2fe]=0xc3; mem[0x2ff]=0x07; mem[0x300]=0x02;
+  }
+
+/* patch load routine */
+if(load_hook)
+  {
+  mem[0x347]=0xeb;
+  mem[0x348]=0xed; mem[0x349]=0xfc;
+  mem[0x34a]=0xc3; mem[0x34b]=0x07; mem[0x34c]=0x02;
+  }
+}
+
+
+void zx80hacks()
+{
+/* patch save routine */
+if(save_hook)
+  {
+  mem[0x1b6]=0xed; mem[0x1b7]=0xfd;
+  mem[0x1b8]=0xc3; mem[0x1b9]=0x83; mem[0x1ba]=0x02;
+  }
+
+/* patch load routine */
+if(load_hook)
+  {
+  mem[0x206]=0xed; mem[0x207]=0xfc;
+  mem[0x208]=0xc3; mem[0x209]=0x83; mem[0x20a]=0x02;
+  }
+}
+
+
+void initmem()
+{
+int f;
+int ramsize;
+int count;
+
+loadrom();
+memset(mem+0x4000,0,0xc000);
+
+/* ROM setup */
+count=0;
+for(f=0;f<16;f++)
+  {
+  memattr[f]=memattr[32+f]=0;
+  memptr[f]=memptr[32+f]=mem+1024*count;
+  count++;
+  if(count>=(zx80?4:8)) count=0;
+  }
+
+/* RAM setup */
+ramsize=16;
+if(unexpanded)
+  ramsize=1;
+count=0;
+for(f=16;f<32;f++)
+  {
+  memattr[f]=memattr[32+f]=1;
+  memptr[f]=memptr[32+f]=mem+1024*(16+count);
+  count++;
+  if(count>=ramsize) count=0;
+  }
+
+if(zx80)
+  zx80hacks();
+else
+  zx81hacks();
+}
+
+
+void loadhelp(void)
+{
+FILE *in;
+char buf[128];
+
+/* but first, set up location of help/selector */
+fakedispx=(ZX_VID_HMARGIN-FUDGE_FACTOR)/8;
+fakedispy=ZX_VID_MARGIN;
+
+if((in=fopen(libdir(zx80?"zx80kybd.pbm":"zx81kybd.pbm"),"rb"))!=NULL)
+  {
+  /* ditch header lines */
+  fgets(buf,sizeof(buf),in);
+  fgets(buf,sizeof(buf),in);
+  if((helpscrn=calloc(256*192/8,1))==NULL)
+    {
+    fprintf(stderr,"z81: couldn't allocate memory for help screen.\n");
+    exit(1);
+    }
+  fread(helpscrn,1,256*192/8,in);
+  fclose(in);
+  }
+else
+  {
+  fprintf(stderr,"z81: couldn't load help screen.\n");
+  exit(1);
+  }
+}
+
+
+
+void zxpopen(void)
+{
+zxpstylus=zxpspeed=zxpheight=zxpnewspeed=0;
+zxppixel=-1;
+
+if(!zxpfilename)
+  return;
+
+if((zxpfile=fopen(zxpfilename,"wb"))==NULL)
+  {
+  fprintf(stderr,"z81: couldn't open printer file, printing disabled\n");
+  return;
+  }
+
+/* we reserve 10 chars for height */
+fprintf(zxpfile,"P4\n256 %10d\n",0);
+}
+
+
+void zxpupdateheader(void)
+{
+long pos;
+
+if(!zxpfile || !zxpheight) return;
+
+pos=ftell(zxpfile);
+
+/* seek back to write the image height */
+if(fseek(zxpfile,strlen("P4\n256 "),SEEK_SET)!=0)
+  fprintf(stderr,"z81: warning: couldn't seek to write image height\n");
+else
+  {
+  /* I originally had spaces after the image height, but that actually
+   * breaks the format as defined in pbm(5) (not to mention breaking
+   * when read by zgv :-)). So they're now before the height.
+   */
+  fprintf(zxpfile,"%10d",zxpheight);
+  }
+
+if(fseek(zxpfile,pos,SEEK_SET)!=0)
+  {
+  fprintf(stderr,"z81: error: printer file re-seek failed, printout disabled!\n");
+  fclose(zxpfile);
+  zxpfile=NULL;
+  }
+}
+
+
+void zxpclose(void)
+{
+unsigned long tmp;
+int f;
+
+/* stop the printer */
+tmp=tstates;
+tstates=tsmax;
+out(0,0xfb,4);
+tstates=tmp;
+
+if(!zxpfile)
+  return;
+
+/* a blank line if we haven't actually printed anything :-) */
+if(!zxpheight)
+  {
+  zxpheight++;
+  for(f=0;f<32;f++)
+    fputc(0,zxpfile);
+  }
+
+/* write header */
+zxpupdateheader();
+
+fclose(zxpfile);
+zxpfile=NULL;
+}
+
+
+void zxpout(void)
+{
+int i,j,d;
+
+if(!zxpfile) return;
+
+zxpheight++;
+for(i=0;i<32;i++)
+  {
+  for(d=j=0;j<8;j++)
+    d=(d<<1)+(zxpline[i*8+j]?1:0);
+  fputc(d,zxpfile);
+  }
+}
+
+
+
+/* ZX Printer support, transliterated from IMC's xz80 by a bear of
+ * very little brain. :-) Or at least, I don't grok it that well.
+ * It works wonderfully though.
+ */
+int printer_inout(int is_out,int val)
+{
+/* Note that we go through the motions even if printer support isn't
+ * enabled, as the alternative would seem to be to crash... :-)
+ */
+if(!is_out)
+  {
+  /* input */
+  
+  if(!zxpspeed)
+    return 0x3e;
+  else
+    {
+    int frame=frames-zxpframes;
+    int cycles=tstates-zxpcycles;
+    int pix=zxppixel;
+    int sp=zxpnewspeed;
+    int x,ans;
+    int cpp=440/zxpspeed;
+      
+    if(frame>400)
+      frame=400;
+    cycles+=frame*tsmax;
+    x=cycles/cpp-64;        /* x-coordinate reached */
+      
+    while(x>320)
+      {           /* if we are on another line, */
+      pix=-1;              /* find out where we are */
+      x-=384;
+      if(sp)
+        {
+        x=(x+64)*cpp;
+        cpp=440/sp;
+        x=x/cpp-64;
+        sp=0;
+        }
+      }
+    if((x>-10 && x<0) | zxpstylus)
+      ans=0xbe;
+    else
+      ans=0x3e;
+    if(x>pix)
+      ans|=1;
+    return ans;
+    }
+  }
+
+
+/* output */
+
+if(!zxpspeed)
+  {
+  if(!(val&4))
+    {
+    zxpspeed=(val&2)?1:2;
+    zxpframes=frames;
+    zxpcycles=tstates;
+    zxpstylus=val&128;
+    zxppixel=-1;
+    }
+  }
+else
+  {
+  int frame=frames-zxpframes;
+  int cycles=tstates-zxpcycles;
+  int i,x;
+  int cpp=440/zxpspeed;
+      
+  if(frame>400)
+    frame=400; /* limit height of blank paper */
+  cycles+=frame*tsmax;
+  x=cycles/cpp-64;        /* x-coordinate reached */
+  for(i=zxppixel;i<x && i<256;i++)
+    if(i>=0)		/* should be, but just in case */
+      zxpline[i]=zxpstylus;
+  if(x>=256 && zxppixel<256)
+    zxpout();
+      
+  while(x>=320)
+    {          /* move to next line */
+    zxpcycles+=cpp*384;
+    if(zxpcycles>=tsmax)
+      zxpcycles-=tsmax,zxpframes++;
+    x-=384;
+    if(zxpnewspeed)
+      {
+      zxpspeed=zxpnewspeed;
+      zxpnewspeed=0;
+      x=(x+64)*cpp;
+      cpp=440/zxpspeed;
+      x=x/cpp-64;
+      }
+    for(i=0;i<x && i<256;i++)
+      zxpline[i]=zxpstylus;
+    if(x>=256)
+      zxpout();
+    }
+  if(x<0)
+    x=-1;
+  if(val&4)
+    {
+    if(x>=0 && x<256)
+      {
+      for(i=x;i<256;i++)
+        zxpline[i]=zxpstylus;
+      zxpout();
+      }
+    zxpspeed=zxpstylus=0;
+    
+    /* this is pretty frequent (on a per-char-line basis!),
+     * but it's the only time we can really do it automagically.
+     */
+    zxpupdateheader();
+    }
+  else
+    {
+    zxppixel=x;
+    zxpstylus=val&128;
+    if(x<0)
+      zxpspeed=(val&2)?1:2;
+    else
+      {
+      zxpnewspeed=(val&2)?1:2;
+      if(zxpnewspeed==zxpspeed)
+        zxpnewspeed=0;
+      }
+    }
+  } 
+
+return(0);
+}
+
+
+unsigned int in(int h,int l)
+{
+int ts=0;		/* additional cycles*256 */
+int tapezeromask=0x80;	/* = 0x80 if no tape noise (?) */
+
+if(!(l&4)) l=0xfb;
+if(!(l&1)) l=0xfe;
+
+switch(l)
+  {
+  case 0xfb:
+    return(printer_inout(0,0));
+    
+  case 0xfe:
+    /* also disables hsync/vsync if nmi off
+     * (yes, vsync requires nmi off too, Flight Simulation confirms this)
+     */
+    if(!nmigen)
+      {
+      hsyncgen=0;
+
+      /* if vsync was on before, record position */
+      if(!vsync)
+        vsync_raise();
+      vsync=1;
+#ifdef OSS_SOUND_SUPPORT
+      sound_beeper(vsync);
+#endif
+      }
+
+    switch(h)
+      {
+      case 0xfe:	return(ts|(keyports[0]^tapezeromask));
+      case 0xfd:	return(ts|(keyports[1]^tapezeromask));
+      case 0xfb:	return(ts|(keyports[2]^tapezeromask));
+      case 0xf7:	return(ts|(keyports[3]^tapezeromask));
+      case 0xef:	return(ts|(keyports[4]^tapezeromask));
+      case 0xdf:	return(ts|(keyports[5]^tapezeromask));
+      case 0xbf:	return(ts|(keyports[6]^tapezeromask));
+      case 0x7f:	return(ts|(keyports[7]^tapezeromask));
+      default:
+        {
+        int i,mask,retval=0xff;
+        
+        /* some games (e.g. ZX Galaxians) do smart-arse things
+         * like zero more than one bit. What we have to do to
+         * support this is AND together any for which the corresponding
+         * bit is zero.
+         */
+        for(i=0,mask=1;i<8;i++,mask<<=1)
+          if(!(h&mask))
+            retval&=keyports[i];
+        return(ts|(retval^tapezeromask));
+        }
+      }
+    break;
+  }
+
+return(ts|255);
+}
+
+
+unsigned int out(int h,int l,int a)
+{
+/* either in from fe or out to ff takes one extra cycle;
+ * experimentation strongly suggests not only that out to
+ * ff takes one extra, but that *all* outs do.
+ */
+int ts=1;	/* additional cycles */
+
+if(sound_ay && sound_ay_type==AY_TYPE_ZONX)
+  {
+  /* the examples in the manual (using DF/0F) and the
+   * documented ports (CF/0F) don't match, so decode is
+   * important for that.
+   */
+  if(!(l&0xf0))		/* not sure how many needed, so assume all 4 */
+    l=0x0f;
+  else
+    if(!(l&0x20))		/* bit 5 low is common to DF and CF */
+      l=0xdf;
+  }
+
+if(!(l&4)) l=0xfb;
+if(!(l&2)) l=0xfd;
+if(!(l&1)) l=0xfe;
+
+/*printf("out %2X\n",l);*/
+
+switch(l)
+  {
+  case 0x0f:		/* Zon X data */
+    if(sound_ay && sound_ay_type==AY_TYPE_ZONX)
+      sound_ay_write(ay_reg,a);
+    break;
+  case 0xdf:		/* Zon X reg. select */
+    if(sound_ay && sound_ay_type==AY_TYPE_ZONX)
+      ay_reg=(a&15);
+    break;
+  
+  case 0xfb:
+    return(ts|printer_inout(1,a));
+  case 0xfd:
+    nmigen=0;
+    break;
+  case 0xfe:
+    if(!zx80)
+      {
+      nmigen=1;
+      break;
+      }
+    /* falls through, if zx80 */
+  case 0xff:	/* XXX should *any* out turn off vsync? */
+    /* fill screen gap since last raising of vsync */
+    if(vsync)
+      vsync_lower();
+    vsync=0;
+    hsyncgen=1;
+#ifdef OSS_SOUND_SUPPORT
+    sound_beeper(vsync);
+#endif
+    break;
+  }
+
+return(ts);
+}
+
+
+/* the ZX81 char is used to index into this, to give the ascii.
+ * awkward chars are mapped to '_' (underscore), and the ZX81's
+ * all-caps is converted to lowercase.
+ * The mapping is also valid for the ZX80 for alphanumerics.
+ * WARNING: this only covers 0<=char<=63!
+ */
+static char zx2ascii[64]={
+/*  0- 9 */ ' ', '_', '_', '_', '_', '_', '_', '_', '_', '_', 
+/* 10-19 */ '_', '\'','#', '$', ':', '?', '(', ')', '>', '<', 
+/* 20-29 */ '=', '+', '-', '*', '/', ';', ',', '.', '0', '1', 
+/* 30-39 */ '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 
+/* 40-49 */ 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 
+/* 50-59 */ 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 
+/* 60-63 */ 'w', 'x', 'y', 'z'
+};
+
+
+void save_p(int a)
+{
+static unsigned char fname[256];
+unsigned char *ptr=mem+a,*dptr=fname;
+FILE *out;
+
+if(zx80)
+  strcpy(fname,"zx80prog.p");
+else
+  {
+  /* so the filename is at ptr, in the ZX81 char set, with the last char
+   * having bit 7 set. First, get that name in ASCII.
+   */
+  
+  memset(fname,0,sizeof(fname));
+  do
+    *dptr++=zx2ascii[(*ptr)&63];
+  while((*ptr++)<128 && dptr<fname+sizeof(fname)-3);
+  
+  /* add '.p' */
+  strcat(fname,".p");
+  }
+
+/* now open the file */
+if((out=fopen(fname,"wb"))==NULL)
+  return;
+
+/* work out how much to write, and write it.
+ * we need to write from 0x4009 (0x4000 on ZX80) to E_LINE inclusive.
+ */
+if(zx80)
+  fwrite(mem+0x4000,1,fetch2(16394)-0x4000+1,out);
+else
+  fwrite(mem+0x4009,1,fetch2(16404)-0x4009+1,out);
+
+fclose(out);
+}
+
+
+void load_p(int a)
+{
+static unsigned char fname[sizeof(autoload_filename)];
+unsigned char *ptr=mem+(a&32767),*dptr=fname;
+FILE *in;
+int got_ascii_already=0;
+
+if(zx80)
+  strcpy(fname,"zx80prog.p");
+else
+  {
+  if(a>=32768) 	/* they did LOAD "" */
+    {
+    got_ascii_already=1;
+    
+    if(autoload && !autolist)	/* autoload stuff did it */
+      {
+      refresh_screen=1;		/* make sure we redraw screen soon */
+      strcpy(fname,autoload_filename);	/* guaranteed to be ok */
+      
+      /* add .p if needed */
+      if(strlen(fname)<sizeof(fname)-3 &&
+         (strlen(fname)<=2 || strcasecmp(fname+strlen(fname)-2,".p")!=0))
+        strcat(fname,".p");
+      }
+    else /* user did it (or `-l') */
+      {
+      char *ret=load_selector();
+
+      if(ret==NULL || strlen(ret)+1>=sizeof(fname))
+        {
+        /* if autolist is aborted or goes wrong, we exit completely */
+        if(autolist)
+          exit_program();
+        return;
+        }
+
+      autoload=autolist=0;	/* in case it was `-l' */
+      strcpy(fname,ret);
+      }
+    }
+  
+  /* so the filename is at ptr, in the ZX81 char set, with the last char
+   * having bit 7 set. First, get that name in ASCII.
+   */
+  if(!got_ascii_already)
+    {
+    /* test for Xtender-style LOAD " STOP " to quit */
+    if(*ptr==227) exit_program();
+    
+    memset(fname,0,sizeof(fname));
+    do
+      *dptr++=zx2ascii[(*ptr)&63];
+    while((*ptr++)<128 && dptr<fname+sizeof(fname)-3);
+    
+    /* add '.p' */
+    strcat(fname,".p");
+    }
+  }
+
+/* now open the file */
+if((in=fopen(fname,"rb"))==NULL)
+  {
+  /* the partial snap will crash without a file, so reset */
+  if(autoload)
+    reset81(),autoload=0;
+  return;
+  }
+
+autoload=0;
+
+/* just read it all */
+fread(mem+(zx80?0x4000:0x4009),1,16384,in);
+
+fclose(in);
+
+/* XXX is this still valid given proper video? */
+/* don't ask me why, but the ZX80 ROM load routine does this if it
+ * works...
+ */
+if(zx80)
+  store(0x400b,fetch(0x400b)+1);
+}
+
+
+void overlay_help(void)
+{
+unsigned char *ptr,*optr;
+int y;
+
+ptr=helpscrn;
+optr=scrnbmp+fakedispy*ZX_VID_FULLWIDTH/8+fakedispx;
+
+for(y=0;y<192;y++)
+  {
+  memcpy(optr,ptr,32);
+  ptr+=32;
+  optr+=ZX_VID_FULLWIDTH/8;
+  }
+}
+
+
+void do_interrupt()
+{
+static int count=0;
+
+if(exit_program_flag)
+  exit_program();
+
+/* being careful here not to screw up any pending reset... */
+if(interrupted==1)
+  interrupted=0;
+
+/* only do screen update every 1/Nth */
+count++;
+if(count>=scrn_freq)
+  {
+  count=0;
+  if(help) overlay_help();
+  update_scrn();
+  }
+check_events();	/* on X checks events, on VGA scans kybd */
+}
+
+
+/* despite the name, this also works for the ZX80 :-) */
+void reset81()
+{
+interrupted=2;	/* will cause a reset */
+memset(mem+16384,0,49152);
+refresh_screen=1;
+if(sound_ay)
+  sound_ay_reset();
+}
+
+
+void usage_help(char *cmd)
+{
+printf("z81 " Z81_VER
+	" - copyright (C) 1994-2004 Ian Collier and Russell Marks.\n\n");
+printf("usage: %s [-hilLosSTuV] [-a sound_addon_type] [-p printout.pbm]\n"
+       "\t\t[-r refresh_rate] [filename.p]\n",
+       cmd);
+puts("\n"
+"	-a	emulate AY-chip-based sound addon chip, with\n"
+"		`sound_addon_type' specifying the addon from the types\n"
+"		below:\n"
+"\n"
+"		q	Quicksilva sound board\n"
+"		z	Bi-Pak Zon X-81\n"
+"\n"
+"		You can also enable ACB stereo, by adding `s' (e.g. `-a qs').\n"
+"	-h	this usage help.\n"
+"	-i	invert screen, giving a white-on-black display.\n"
+"	-l	boot directly to the `LOAD \"\"' file selector. This only\n"
+"		works when starting with `filename.p' would (see note below).\n"
+"	-L	disable LOAD hook. (Not terribly useful.)\n"
+"	-o	emulate `old ROM' machine, i.e. emulate a ZX80.\n"
+"	-p	emulate ZX Printer, with PBM output in specified file.\n"
+"		(Most picture viewers/converters can handle PBM files.)\n"
+"	-r	set how often the screen is redrawn in 1/50ths of a second.\n"
+"	-s	emulate VSYNC-based sound support (the usual kind).\n"
+"	-S	disable SAVE hook. Useful if you want to hear what SAVE\n"
+"		does when sound is enabled. :-) Use `-V' to see it too.\n"
+"	-T	toggle top bit of ULA-displayed bytes (mainly for debugging,\n"
+"		but also useful for checking the display's `shape').\n"
+"	-u	emulate unexpanded machine, e.g. a 1k ZX81.\n"
+"	-V	emulate VSYNC visuals, e.g. the patterns you get when you\n"
+"		LOAD or SAVE on the real machine, and the little flicker you\n"
+"		get when typing in a program line. (This tends to be a bit\n"
+"		annoying when typing in a program with the default frame-skip,\n"
+"		so it's disabled by default.)\n"
+"\n"
+"	filename.p\n"
+"		load the specified program instantly on startup;\n"
+"		this doesn't work when emulating a ZX80, or 1k ZX81.");
+}
+
+
+void parseoptions(int argc,char *argv[])
+{
+int done=0;
+
+opterr=0;
+
+do
+  switch(getopt(argc,argv,"a:hilLop:r:sSTuV"))
+    {
+    case 'a':
+      sound=1;
+      sound_ay=1;
+      switch(*optarg)
+        {
+        case 'q':
+          sound_ay_type=AY_TYPE_QUICKSILVA;
+          break;
+        case 'z':
+          sound_ay_type=AY_TYPE_ZONX;
+          break;
+        default:
+          fprintf(stderr,"z81: unrecognised sound addon type `%s'.\n",optarg);
+          exit(1);
+        }
+      if(*optarg && optarg[1]=='s')
+        sound_stereo=1,sound_stereo_acb=1;
+      break;
+    case 'h':
+      usage_help(argv[0]);
+      exit(1);
+    case 'i':	/* invert display */
+      invert_screen=1;
+      break;
+    case 'l':	/* autoload, but to file selector */
+      autolist=1;
+      break;
+    case 'L':	/* no LOAD hook */
+      load_hook=0;
+      break;
+    case 'o':	/* old rom machine, i.e. ZX80 */
+      zx80=1;
+      break;
+    case 'p':	/* printer support (and output filename) */
+      zxpfilename=optarg;
+      break;
+    case 'r':	/* refresh rate */
+      scrn_freq=atoi(optarg);
+      if(scrn_freq<1) scrn_freq=1;
+      if(scrn_freq>50) scrn_freq=50;
+      break;
+    case 's':	/* sound (!) - specifically, VSYNC-based sound */
+      sound=1;
+      sound_vsync=1;
+      break;
+    case 'S':	/* no SAVE hook */
+      save_hook=0;
+      break;
+    case 'T':	/* tag ULA bytes when displayed */
+      taguladisp=1;
+      break;
+    case 'u':	/* unexpanded (no RAM pack) */
+      unexpanded=1;
+      break;
+    case 'V':	/* emulate VSYNC visuals */
+      vsync_visuals=1;
+      break;
+    case '?':
+      switch(optopt)
+        {
+        case 'a':
+          fprintf(stderr,"z81: "
+                  "the -a option needs a sound addon type as argument "
+                  "(see man page).\n");
+          break;
+        case 'p':
+          fprintf(stderr,"z81: "
+                  "the -p option needs a PBM output filename as argument.\n");
+          break;
+        case 'r':
+          fprintf(stderr,"z81: "
+                  "the -r option needs a refresh rate as argument.\n");
+          break;
+        default:
+          fprintf(stderr,"z81: option `%c' not recognised.\n",optopt);
+        }
+      exit(1);
+    case -1:
+      done=1;
+    }
+while(!done);
+
+if(optind==argc-1 || autolist)	/* if filename or `-l' given... */
+  {
+  if(zx80 || unexpanded)
+    {
+    autolist=0;
+    fprintf(stderr,"z81: auto-loading not supported for ZX80 or 1k ZX81.\n");
+    }
+  else
+    {
+    if(!load_hook)
+      {
+      load_hook=1;
+      fprintf(stderr,"z81: warning: auto-load is re-enabling LOAD hook.\n");
+      }
+    autoload_setup(autolist?NULL:argv[optind]);
+    }
+  }
+}
+
+
+void frame_pause(void)
+{
+static int first=1;
+static sigset_t mask,oldmask;
+
+#ifdef OSS_SOUND_SUPPORT
+if(sound_enabled)
+  {
+  /* we block on the sound instead. It's a bit unpleasant,
+   * but it's the best way.
+   */
+  sound_frame();
+  
+  if(interrupted<2)
+    interrupted=1;
+  return;
+  }
+#endif
+
+/* we leave it blocked most of the time, only unblocking
+ * temporarily with sigsuspend().
+ */
+if(first)
+  {
+  first=0;
+  sigemptyset(&mask);
+  sigaddset(&mask,SIGALRM);
+  sigprocmask(SIG_BLOCK,&mask,&oldmask);
+  }
+
+/* the procmask stuff is to avoid a race condition */
+while(!signal_int_flag)
+  sigsuspend(&oldmask);
+
+signal_int_flag=0;
+
+if(interrupted<2)
+  interrupted=1;
+}
+
+
+
+static char ascii2zx[96]=
+  {
+   0, 0,11,12,13, 0, 0,11,16,17,23,21,26,22,27,24,
+  28,29,30,31,32,33,34,35,36,37,14,25,19,20,18,15,
+  23,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,
+  53,54,55,56,57,58,59,60,61,62,63,16,24,17,11,22,
+  11,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,
+  53,54,55,56,57,58,59,60,61,62,63,16,24,17,11, 0
+  };
+
+
+void draw_files(unsigned char *scrn,int top,int cursel,int numfiles,
+	char *filearr,int elmtsiz)
+{
+int x,y,n,xor,c,len;
+unsigned char *sptr;
+
+/* since this is quick and easy (and incrementally updated for us :-)),
+ * we redraw each time no matter what.
+ */
+
+/* clear filenames area */
+for(y=3;y<21;y++)
+  memset(scrn+1+y*33+1,0,30);
+
+n=top;
+for(y=3;y<21;y++,n++)
+  {
+  if(n>=numfiles) break;
+  xor=128*(n==cursel);
+  sptr=scrn+1+y*33+1;
+  len=strlen(filearr+elmtsiz*n);
+  if(len>30) len=30;
+  for(x=0;x<len;x++)
+    {
+    c=(filearr+elmtsiz*n)[x]-32;
+    if(c<0 || c>95) c=0;
+    c=ascii2zx[c];
+    *sptr++=(c^xor);
+    }
+  }
+}
+
+
+void draw_load_frame(unsigned char *scrn)
+{
+int x,y;
+unsigned char *sptr=scrn+1;
+/* these must be exactly 32 chars long */
+/*           01234567890123456789012345678901 */
+char *text1="    choose a program to load    ";
+char *text2=" q=up a=dn enter=load spc=abort ";
+
+memset(sptr,131,32);
+sptr[33*2]=7;
+memset(sptr+33*2+1,3,30);
+sptr[33*2+31]=132;
+for(y=3;y<21;y++)
+  sptr[33*y]=5,sptr[33*y+31]=133;
+sptr[33*21]=130;
+memset(sptr+33*21+1,131,30);
+sptr[33*21+31]=129;
+for(x=0;x<32;x++)
+  {
+  sptr[33   +x]=128+ascii2zx[text1[x]-32];
+  sptr[33*22+x]=128+ascii2zx[text2[x]-32];
+  }
+memset(sptr+33*23,3,32);
+}
+
+
+/* convert our text display to a bitmap in scrnbmp */
+void selscrn_to_scrnbmp(unsigned char *scrn)
+{
+unsigned char *cptr=mem+0x1e00;
+unsigned char *ptr,*optr,*optrsav;
+int x,y,b,c,d,inv;
+
+memset(scrnbmp,0,ZX_VID_FULLHEIGHT*ZX_VID_FULLWIDTH/8);
+
+ptr=scrn+1;
+optr=scrnbmp+fakedispy*ZX_VID_FULLWIDTH/8+fakedispx;
+
+for(y=0;y<24;y++,ptr++)
+  {
+  optrsav=optr;
+  for(x=0;x<32;x++,ptr++,optr++)
+    {
+    c=*ptr;
+    inv=(c&128); c&=63;
+    
+    for(b=0;b<8;b++,optr+=ZX_VID_FULLWIDTH/8)
+      {
+      d=cptr[c*8+b];
+      if(inv) d^=255;
+      *optr=d;
+      }
+    optr-=ZX_VID_FULLWIDTH;
+    }
+  
+  optr=optrsav+ZX_VID_FULLWIDTH;
+  }
+}
+
+
+/* simulate lastk generation from keyports[] */
+int make_lastk(void)
+{
+int y,b;
+int lastk0=0,lastk1=0;
+
+for(y=0;y<8;y++)		/* 8 half-rows */
+  {
+  b=(keyports[y]|0xe0);
+  
+  /* contribute to it if key was pressed */
+  if((b&31)!=31)
+    {
+    /* set y bit in lastk0 if not shift */
+    if(!(y==0 && ((b&31)|1)==31)) lastk0|=(1<<y);
+    
+    /* now set pos-in-half-row bit(s) in lastk1 */
+    b=(((~b)&31)<<1);
+    /* move bit 1 of b back down to bit 0 if it's shift bit */
+    if(y==0) b=((b&0xfc)|((b&2)>>1));
+  
+    lastk1|=b;
+    }
+  }
+
+return(0xffff^(lastk0|(lastk1<<8)));
+}
+
+
+/* wait for them to let go of all keys */
+void sel_waitnokeys(void)
+{
+while(make_lastk()!=0xffff)
+  {
+  frame_pause();
+  do_interrupt();
+  }
+}
+
+
+char *load_selector()
+{
+static char returned_filename[256];
+static unsigned char selscrn[33*24+1];	/* pseudo-DFILE */
+int f,height=18;
+char *files=NULL;
+int files_size,files_incr=0x2000;
+DIR *dirfile;
+struct dirent *entry;
+struct stat sbuf;
+int files_ofs,numfiles,len,maxlen;
+int top,cursel;
+int quit,got_one,isdir;
+char *filearr;
+char *ptr;
+int krwait=25,krwrep=3;	/* wait before key rpt and wait before next rpt */
+int krheld=0,krsubh=0;
+int oldkey,key,virtkey;
+
+/* should never get here if emulating ZX80, but FWIW... */
+if(zx80) return(NULL);
+
+/* usually won't need this on a 16k, but a 1k responds to LOAD ""
+ * much more quickly... :-)
+ */
+sel_waitnokeys();
+
+ignore_esc=1;		/* avoid possibility of esc screwing things up */
+
+oldkey=-1;
+
+do
+  {
+  if((dirfile=opendir("."))==NULL)
+    {
+    fprintf(stderr,"couldn't read current directory!\n");
+    ignore_esc=0;
+    return(NULL);
+    }
+
+  files_size=0x4000;
+  files_ofs=0;
+  if((files=malloc(files_size))==NULL)
+    {
+    fprintf(stderr,"not enough memory for file selector!\n");
+    ignore_esc=0;
+    return(NULL);
+    }
+
+  memset(selscrn,0,sizeof(selscrn));	/* blank our screen */
+  draw_load_frame(selscrn);	/* draw everything apart from files list */
+  /* force an update */
+  selscrn_to_scrnbmp(selscrn);
+  refresh_screen=1;
+  update_scrn();
+  
+  numfiles=0;
+  maxlen=-1;
+  top=cursel=0;
+  quit=got_one=0;
+
+  /* read list of .p files */
+  while((entry=readdir(dirfile))!=NULL)
+    {
+    isdir=0;
+
+    /* must be non-hidden dir (and not `.') or .p file */
+    len=strlen(entry->d_name);
+    if((stat(entry->d_name,&sbuf)!=-1 && (isdir=S_ISDIR(sbuf.st_mode)) &&
+        (strcmp(entry->d_name,"..")==0 || entry->d_name[0]!='.')) ||
+       (len>2 && (strcasecmp(entry->d_name+len-2,".p")==0)))
+      {
+      /* make array of filenames bigger if needed */
+      if(files_ofs+len+(isdir?3:1)>=files_size)
+        {
+        files_size+=files_incr;
+        if((files=realloc(files,files_size))==NULL)
+          {
+          fprintf(stderr,"not enough memory for file selector!\n");
+          ignore_esc=0;
+          closedir(dirfile);
+          return(NULL);
+          }
+        }
+    
+      /* copy filename */
+      if(isdir)
+        {
+        files[files_ofs]='(';
+        strcpy(files+files_ofs+1,entry->d_name);
+        strcat(files+files_ofs+1,")");
+        len+=2;
+        }
+      else
+        strcpy(files+files_ofs,entry->d_name);
+    
+      files_ofs+=len+1;
+      if(len+1>maxlen) maxlen=len+1;
+      numfiles++;
+      }
+    }
+
+  closedir(dirfile);
+
+  /* have to put them into something more like a normal array to
+   * use qsort...
+   * (I later realised I could just have sorted an array of pointers,
+   * but never mind, I've got the code to do it this way now. :-/)
+   */
+  if(numfiles==0 || (filearr=malloc(maxlen*numfiles))==NULL)
+    {
+    free(files);
+    if(numfiles!=0)
+      fprintf(stderr,"not enough memory for file selector!\n");
+    ignore_esc=0;
+    return(NULL);
+    }
+
+  /* copy filenames */
+  ptr=files;
+  for(f=0;f<numfiles;f++)
+    {
+    strcpy(filearr+maxlen*f,ptr);
+    ptr+=strlen(ptr)+1;
+    }
+
+  free(files);
+
+  /* and sort */
+  qsort(filearr,numfiles,maxlen,(int (*)(const void *,const void *))strcmp);
+
+
+  /* now do the file selector stuff */
+
+  while(!quit && !got_one)
+    {
+    /* draw file list */
+    draw_files(selscrn,top,cursel,numfiles,filearr,maxlen);
+    /* convert to graphics, in scrnbmp */
+    selscrn_to_scrnbmp(selscrn);
+
+    /* hang around, update real display, read keys */
+    frame_pause();
+    do_interrupt();
+    
+    key=make_lastk();
+  
+    /* auto-repeat stuff */
+    virtkey=key;
+    if(key!=oldkey)
+      krheld=0,krsubh=0;
+    else
+      {
+      krheld++;
+      if(krheld<krwait)
+        virtkey=-1;
+      else
+        if(krheld>krwait)
+          {
+          krsubh++;
+          if(krsubh<krwrep)
+            virtkey=-1;
+          else
+            krsubh=0;
+          }
+      }
+  
+    switch(virtkey)
+      {
+      case 0xfdfb:	/* q */
+        cursel--; break;
+      case 0xfdfd:	/* a */
+        cursel++; break;
+      case 0xfcfb:	/* shift(alt)-q */
+        cursel-=17; break;
+      case 0xfcfd:	/* shift(alt)-a */
+        cursel+=17; break;
+      case 0xfdbf:	/* enter */
+        got_one=1; break;
+      case 0xfd7f:	/* space */
+        quit=1; break;
+      }
+    if(cursel<0) cursel=0;
+    if(cursel>=numfiles) cursel=numfiles-1;
+    if(cursel<top) top--;
+    if(cursel>=top+height) top++;
+  
+    oldkey=key;
+    }
+
+  isdir=0;
+  if(got_one)
+    {
+    strcpy(returned_filename,ptr=filearr+cursel*maxlen);
+    if(*ptr=='(')
+      {
+      ptr[strlen(ptr)-1]=0;
+      if(stat(ptr+1,&sbuf)!=-1 && S_ISDIR(sbuf.st_mode))
+        {
+        isdir=1;
+        /* copy dir name instead */
+        strcpy(returned_filename,ptr+1);
+        }
+      }
+    }
+  free(filearr);
+
+  sel_waitnokeys();
+  
+  if(quit)
+    {
+    ignore_esc=0;
+    return(NULL);
+    }
+  }
+while(got_one && isdir && chdir(returned_filename)==0);
+
+/* if not a dir, return file to load */
+ignore_esc=0;
+
+/* or error, if the chdir() failed */
+if(got_one && isdir) return(NULL);
+
+return(returned_filename);
+}