guifuncs.c

linux下的任天堂模拟器代码。供大家参考。

void CheatCodeSave()
{
  FILE *fp = 0;

  GUICBHold=0;

  if (NumCheats)
  {
    cheatdata[6]=254;
    cheatdata[7]=252;

    setextension(ZSaveName, "cht");

    if ((fp = fopen_dir(ZSramPath,ZSaveName,"wb")))
    {
      fwrite(cheatdata, 1, 28*NumCheats, fp);
      fclose(fp);
    }
  }
}

extern unsigned char CheatOn;
void DisableCheatsOnLoad(), EnableCheatsOnLoad();
extern unsigned int GUIcurrentcheatcursloc;

void CheatCodeLoad()
{
  FILE *fp = 0;
  unsigned int cheat_file_size, i, j, k;

  setextension(ZSaveName, "cht");
  GUICBHold = 0;

  if ((fp = fopen_dir(ZSramPath,ZSaveName,"rb")))
  {
    asm_call(DisableCheatsOnLoad);

    cheat_file_size = fread(cheatdata, 1, 255*28, fp);
    fclose(fp);

    if(cheatdata[6]==254 && cheatdata[7]==252)
      NumCheats = cheat_file_size / 28;
    else
    {
      NumCheats = cheat_file_size / 18;
      i = 28 * NumCheats;
      j = cheat_file_size - (cheat_file_size % 18);

      do
      {
        i-=28;
        j-=18;

        for (k=6;k>0;k--) cheatdata[i+k-1]=cheatdata[j+k-1];
        for (k=12;k>0;k--) cheatdata[i+k+7]=cheatdata[j+k+5];
        for (k=8;k>0;k--) cheatdata[i+k+19] = 0;
      } while(i>0);
    }

    asm_call(EnableCheatsOnLoad);

    if (NumCheats <= GUIcurrentcheatcursloc) GUIcurrentcheatcursloc=NumCheats-1;
    if (NumCheats) CheatOn=1;
    else GUIcurrentcheatcursloc=CheatOn=0;
  }
}

extern unsigned char *vidbuffer;

void SaveCheatSearchFile()
{
  FILE *fp = 0;

  if ((fp = fopen_dir(ZCfgPath,"tmpchtsr.___","wb")))
  {
    fwrite(vidbuffer+129600, 1, 65536*2+32768, fp);
    fclose(fp);
  }
}

void LoadCheatSearchFile()
{
  FILE *fp = 0;

  if ((fp = fopen_dir(ZCfgPath,"tmpchtsr.___","rb")))
  {
    fread(vidbuffer+129600, 1, 65536*2+32768, fp);
    fclose(fp);
  }
}

extern unsigned char *spcBuffera;

void dumpsound()
{
  FILE *fp = fopen_dir(ZSpcPath, "sounddmp.raw", "wb");
  if (fp)
  {
    fwrite(spcBuffera, 1, 65536*4+4096, fp);
    fclose(fp);
  }
}

static bool snes_extension_match(const char *filename)
{
  char *dot = strrchr(filename, '.');
  if (dot)
  {
    dot++;
    if (!strcasecmp(dot, "sfc") ||
        !strcasecmp(dot, "jma") ||
        !strcasecmp(dot, "zip") ||
        !strcasecmp(dot, "gz") ||
        !strcasecmp(dot, "st") ||
        !strcasecmp(dot, "bs") ||
        !strcasecmp(dot, "smc") ||
        !strcasecmp(dot, "swc") ||
        !strcasecmp(dot, "fig") ||
        !strcasecmp(dot, "dx2") ||
        !strcasecmp(dot, "ufo") ||
        !strcasecmp(dot, "gd3") ||
        !strcasecmp(dot, "gd7") ||
        !strcasecmp(dot, "mgd") ||
        !strcasecmp(dot, "mgh") ||
        !strcasecmp(dot, "048") ||
        !strcasecmp(dot, "058") ||
        !strcasecmp(dot, "078") ||
        !strcasecmp(dot, "bin") ||
        !strcasecmp(dot, "usa") ||
        !strcasecmp(dot, "eur") ||
        !strcasecmp(dot, "jap") ||
        !strcasecmp(dot, "aus") ||
        !strcasecmp(dot, "1") ||
        !strcasecmp(dot, "a"))
    {
      return(true);
    }
  }
  return(false);
}

#define HEADER_SIZE 512
#define INFO_LEN (0xFF - 0xC0)
#define INAME_LEN 21

static const char *get_rom_name(const char *filename, char *namebuffer, struct stat *filestats)
{
  int InfoScore(char *);
  unsigned int sum(unsigned char *array, unsigned int size);

  char *last_dot = strrchr(filename, '.');
  if (!last_dot || (strcasecmp(last_dot, ".zip") && strcasecmp(last_dot, ".gz") && strcasecmp(last_dot, ".jma")))
  {
    if ((filestats->st_size >= 0x8000) && (filestats->st_size <= 0x600000+HEADER_SIZE))
    {
      FILE *fp = fopen_dir(ZRomPath, filename, "rb");
      if (fp)
      {
        unsigned char HeaderBuffer[HEADER_SIZE];
        int HeaderSize = 0, HasHeadScore = 0, NoHeadScore = 0, HeadRemain = filestats->st_size & 0x7FFF;
        bool EHi = false;

        switch(HeadRemain)
        {
          case 0:
            NoHeadScore += 3;
            break;

          case HEADER_SIZE:
            HasHeadScore += 2;
            break;
        }

        fread(HeaderBuffer, 1, HEADER_SIZE, fp);

        if (sum(HeaderBuffer, HEADER_SIZE) < 2500) { HasHeadScore += 2; }

        //SMC/SWC Header
        if (HeaderBuffer[8] == 0xAA && HeaderBuffer[9] == 0xBB && HeaderBuffer[10]== 4)
        {
          HasHeadScore += 3;
        }
        //FIG Header
        else if ((HeaderBuffer[4] == 0x77 && HeaderBuffer[5] == 0x83) ||
                 (HeaderBuffer[4] == 0xDD && HeaderBuffer[5] == 0x82) ||
                 (HeaderBuffer[4] == 0xDD && HeaderBuffer[5] == 2) ||
                 (HeaderBuffer[4] == 0xF7 && HeaderBuffer[5] == 0x83) ||
                 (HeaderBuffer[4] == 0xFD && HeaderBuffer[5] == 0x82) ||
                 (HeaderBuffer[4] == 0x00 && HeaderBuffer[5] == 0x80) ||
                 (HeaderBuffer[4] == 0x47 && HeaderBuffer[5] == 0x83) ||
                 (HeaderBuffer[4] == 0x11 && HeaderBuffer[5] == 2))
        {
          HasHeadScore += 2;
        }
        else if (!strncmp("GAME DOCTOR SF 3", (char *)HeaderBuffer, 16))
        {
          HasHeadScore += 5;
        }

        HeaderSize = HasHeadScore > NoHeadScore ? HEADER_SIZE : 0;

        if (filestats->st_size - HeaderSize >= 0x500000)
        {
          fseek(fp, 0x40FFC0 + HeaderSize, SEEK_SET);
          fread(HeaderBuffer, 1, INFO_LEN, fp);
          if (InfoScore((char *)HeaderBuffer) > 1)
          {
            EHi = true;
            strncpy(namebuffer, (char *)HeaderBuffer, INAME_LEN);
          }
        }

        if (!EHi)
        {
          if (filestats->st_size - HeaderSize >= 0x10000)
          {
            char LoHead[INFO_LEN], HiHead[INFO_LEN];
            int LoScore, HiScore;

            fseek(fp, 0x7FC0 + HeaderSize, SEEK_SET);
            fread(LoHead, 1, INFO_LEN, fp);
            LoScore = InfoScore(LoHead);

            fseek(fp, 0xFFC0 + HeaderSize, SEEK_SET);
            fread(HiHead, 1, INFO_LEN, fp);
            HiScore = InfoScore(HiHead);

            strncpy(namebuffer, LoScore > HiScore ? LoHead : HiHead, INAME_LEN);

            if (filestats->st_size - HeaderSize >= 0x20000)
            {
              int IntLScore;
              fseek(fp, (filestats->st_size - HeaderSize) / 2 + 0x7FC0 + HeaderSize, SEEK_SET);
              fread(LoHead, 1, INFO_LEN, fp);
              IntLScore = InfoScore(LoHead) / 2;

              if (IntLScore > LoScore && IntLScore > HiScore)
              {
                strncpy(namebuffer, LoHead, INAME_LEN);
              }
            }
          }
          else //ROM only has one block
          {
            fseek(fp, 0x7FC0 + HeaderSize, SEEK_SET);
            fread(namebuffer, INAME_LEN, 1, fp);
          }
        }
        fclose(fp);
      }
      else //Couldn't open file
      {
        strcpy(namebuffer, "** READ FAILURE **");
      }
    }
    else //Smaller than a block, or Larger than 6MB
    {
      strcpy(namebuffer, "** INVALID FILE **");
    }
  }
  else //Compressed archive
  {
    return(filename);
  }
  namebuffer[21] = 0;
  return(namebuffer);
}

char **lf_names = 0; //Long File Names
char **et_names = 0; //Eight Three Names
char **i_names = 0; //Internal Names
char **d_names = 0; //Directory Names

char **selected_names = 0; //Used to point to requested one

#define LIST_LFN BIT(0)
#define LIST_ETN BIT(1)
#define LIST_IN  BIT(2)
#define LIST_DN  BIT(3)

#ifdef __MSDOS__
#define main_names et_names
#define LIST_MAIN LIST_ETN
#else
#define main_names lf_names
#define LIST_MAIN LIST_LFN
#endif

#ifndef _USE_LFN
#define _USE_LFN 1
#endif

#define swapper(array) if (array) { hold = array[x]; array[x] = array[y]; array[y] = hold; }

static void swapfiles(size_t x, size_t y)
{
  char *hold;
  swapper(lf_names);
  swapper(et_names);
  swapper(i_names);
}

static void swapdirs(size_t x, size_t y)
{
  char *hold = d_names[x];
  d_names[x] = d_names[y];
  d_names[y] = hold;
}

static void sort(intptr_t *array, int begin, int end, void (*swapfunc)(size_t, size_t))
{
  if (end > begin)
  {
    intptr_t *pivot = array + begin;
    int l = begin + 1;
    int r = end;
    while (l < r)
    {
      if (strcasecmp((const char *)*(array+l), (const char *)*pivot) <= 0)
      {
        l++;
      }
      else
      {
        r--;
        swapfunc(l, r);
      }
    }
    l--;
    swapfunc(begin, l);
    sort(array, begin, l, swapfunc);
    sort(array, r, end, swapfunc);
  }
}


void free_list(char ***list)
{
  char **p = *list;
  if (p)
  {
    p += 2;
    while (*p)
    {
      free(*p++);
    }
    free(*list);
    *list = 0;
  }
}

//A possible problem here would be if one of the list arrays got enlarged but a corosponding one ran out of memory
static void add_list(char ***reallist, const char *p)
{
  char **list = *reallist;
  if (!list)
  {
    if (!(list = malloc(1003*sizeof(void *)))) { return; }
    list[0] = (char *)2;
    list[1] = (char *)1002;
    list[2] = 0;
  }

  if (list[0] == list[1]-1)
  {
    char **p = realloc(list, ((size_t)list[1]+1000)*sizeof(void *));
    if (p)
    {
      list = p;
      list[1] += 1000;
    }