return true;
}
-uae_u8 *save_a2065 (int *len, uae_u8 *dstptr)
+uae_u8 *save_a2065 (size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak,*dst;
if (z) {
int size = zfile_size32(z);
if (series2) {
- int total = 0;
+ size_t total = 0;
int seekpos = 0;
size = zfile_size32(z);
if (size > 16384 + 4096) {
seekpos = 16384;
}
while (total < 32768 - 4096) {
- int prevtotal = total;
+ size_t prevtotal = total;
zfile_fseek(z, seekpos, SEEK_SET);
total += zfile_fread(wd->rom + total, 1, wd->rom_size - total >= wd->rom_size ? wd->rom_size : wd->rom_size - total, z);
if (prevtotal == total)
if (!cd32_flashfile)
cd32_flashfile = zfile_fopen (path, _T("wb"), 0);
if (cd32_flashfile) {
- int size = zfile_fread(cd32_nvram, 1, currprefs.cs_cd32nvram_size, cd32_flashfile);
+ size_t size = zfile_fread(cd32_nvram, 1, currprefs.cs_cd32nvram_size, cd32_flashfile);
if (size == currprefs.cs_cd32nvram_size && maxlen > currprefs.cs_cd32nvram_size)
size += zfile_fread(cubo_nvram, 1, maxlen - currprefs.cs_cd32nvram_size, cd32_flashfile);
if (size < maxlen)
#ifdef SAVESTATE
-uae_u8 *save_akiko (int *len, uae_u8 *dstptr)
+uae_u8 *save_akiko (size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
int i;
action_replay_flag = ACTION_REPLAY_ACTIVE;
}
-uae_u8 *save_hrtmon (int *len, uae_u8 *dstptr)
+uae_u8 *save_hrtmon(size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
return src;
}
-uae_u8 *save_action_replay (int *len, uae_u8 *dstptr)
+uae_u8 *save_action_replay(size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
0x4400,0x84C1,0x8581,0x4540,0x8701,0x47C0,0x4680,0x8641,
0x8201,0x42C0,0x4380,0x8341,0x4100,0x81C1,0x8081,0x4040
};
- register USHORT CRC = 0;
+ USHORT CRC = 0;
while(size--)
CRC = (USHORT) (CRCTab[((CRC ^ *mem++) & 255)] ^ ((CRC >> 8) & 255));
/* ------------------------------------------------------------------------ */
static int sort_by_ascii(char **a, char **b)
{
- register char *p, *q;
- register int c1, c2;
+ char *p, *q;
+ int c1, c2;
p = *a, q = *b;
if (generic_format) {
void finish_sp(struct string_pool *sp, int *v_count, char ***v_vector)
{
int i;
- register char *p;
+ char *p;
char **v;
v = (char **) xmalloc(char*, sp->n + 1);
static struct ripped_sample *ripped_samples;
-void write_wavheader (struct zfile *wavfile, uae_u32 size, uae_u32 freq)
+void write_wavheader (struct zfile *wavfile, size_t size, uae_u32 freq)
{
uae_u16 tw;
- uae_u32 tl;
+ size_t tl;
int bits = 8, channels = 1;
zfile_fseek (wavfile, 0, SEEK_SET);
return src;
}
-uae_u8 *save_audio (int nr, int *len, uae_u8 *dstptr)
+uae_u8 *save_audio (int nr, size_t *len, uae_u8 *dstptr)
{
struct audio_channel_data *acd = audio_channel + nr;
uae_u8 *dst, *dstbak;
return src;
}
-uae_u8 *save_blitter (int *len, uae_u8 *dstptr)
+uae_u8 *save_blitter (size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak,*dst;
int forced;
return src;
}
-uae_u8 *save_blitter_new(int *len, uae_u8 *dstptr)
+uae_u8 *save_blitter_new(size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak,*dst;
if (dstptr)
}
}
-uae_u8 *save_cd (int num, int *len)
+uae_u8 *save_cd (int num, size_t *len)
{
struct blkdevstate *st = &state[num];
uae_u8 *dstbak, *dst;
static void cdtv_battram_reset (void)
{
struct zfile *f;
- int v;
+ size_t v;
memset (cdtv_battram, 0, CDTV_NVRAM_SIZE);
cfgfile_resolve_path_out_load(currprefs.flashfile, flashfilepath, MAX_DPATH, PATH_ROM);
#ifdef SAVESTATE
-uae_u8 *save_cdtv_dmac (int *len, uae_u8 *dstptr)
+uae_u8 *save_cdtv_dmac (size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
return src;
}
-uae_u8 *save_cdtv (int *len, uae_u8 *dstptr)
+uae_u8 *save_cdtv (size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
static void cdtvcr_battram_reset (void)
{
struct zfile *f;
- int v;
+ size_t v;
memset (cdtvcr_ram, 0, CDTVCR_RAM_SIZE);
cfgfile_resolve_path_out_load(currprefs.flashfile, flashfilepath, MAX_DPATH, PATH_ROM);
free (str);
}
-const TCHAR *cfgfile_getconfigdata(int *len)
+const TCHAR *cfgfile_getconfigdata(size_t *len)
{
- *len = -1;
+ *len = 0;
if (!configstore)
return NULL;
return (TCHAR*)zfile_get_data_pointer(configstore, len);
}
}
-uae_u8 *save_configuration (int *len, bool fullconfig)
+uae_u8 *save_configuration (size_t *len, bool fullconfig)
{
int tmpsize = 100000;
uae_u8 *dstbak, *dst, *p;
return src;
}
-uae_u8 *save_cia (int num, int *len, uae_u8 *dstptr)
+uae_u8 *save_cia (int num, size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak,*dst, b;
uae_u16 t;
return dstbak;
}
-uae_u8 *save_keyboard (int *len, uae_u8 *dstptr)
+uae_u8 *save_keyboard (size_t *len, uae_u8 *dstptr)
{
uae_u8 *dst, *dstbak;
if (dstptr)
#define SW save_u16
#define SL save_u32
-uae_u8 *save_custom(int *len, uae_u8 *dstptr, int full)
+uae_u8 *save_custom(size_t *len, uae_u8 *dstptr, int full)
{
uae_u8 *dstbak, *dst;
int i, dummy;
return src;
}
-uae_u8 *save_custom_agacolors(int *len, uae_u8 *dstptr)
+uae_u8 *save_custom_agacolors(size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
return src;
}
-uae_u8 *save_custom_sprite(int num, int *len, uae_u8 *dstptr)
+uae_u8 *save_custom_sprite(int num, size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
struct sprite *s = &spr[num];
return src;
}
-uae_u8 *save_custom_extra(int *len, uae_u8 *dstptr)
+uae_u8 *save_custom_extra(size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
}
return src;
}
-uae_u8 *save_custom_event_delay(int *len, uae_u8 *dstptr)
+uae_u8 *save_custom_event_delay(size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
int cnt = 0;
}
-uae_u8 *save_cycles(int *len, uae_u8 *dstptr)
+uae_u8 *save_cycles(size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
if (dstptr)
return readnum (c, size, '$');
}
-static int next_string (TCHAR **c, TCHAR *out, int max, int forceupper)
+static size_t next_string (TCHAR **c, TCHAR *out, int max, int forceupper)
{
TCHAR *p = out;
int startmarker = 0;
static void dump_custom_regs(bool aga, bool ext)
{
- int len;
+ size_t len;
uae_u8 *p1, *p2, *p3, *p4;
TCHAR extra1[256], extra2[256];
}
}
-uae_u8 *save_debug_memwatch (int *len, uae_u8 *dstptr)
+uae_u8 *save_debug_memwatch (size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
int total;
typedef enum { ADF_NONE = -1, ADF_NORMAL, ADF_EXT1, ADF_EXT2, ADF_FDI, ADF_IPF, ADF_SCP, ADF_CATWEASEL, ADF_PCDOS, ADF_KICK, ADF_SKICK, ADF_NORMAL_HEADER, ADF_FLOPPYBRIDGE } drive_filetype;
typedef struct {
+ int drvnum;
struct zfile *diskfile;
struct zfile *writediskfile;
struct zfile *pcdecodedfile;
static int dirhash (const uae_char *name)
{
- unsigned long hash;
+ uae_u32 hash;
int i;
hash = strlen (name);
*/
static void drive_settype_id (drive *drv)
{
- int drvnum = drv - &floppy[0];
+ size_t drvnum = drv - &floppy[0];
int t = currprefs.floppyslots[drvnum].dfxtype;
#ifdef FLOPPYBRIDGE
{
case ADF_IPF:
#ifdef CAPS
- caps_unloadimage (drv - floppy);
+ caps_unloadimage(drv->drvnum);
#endif
break;
case ADF_SCP:
#ifdef SCP
- scp_close (drv - floppy);
+ scp_close(drv->drvnum);
#endif
break;
case ADF_FDI:
#ifdef FDI2RAW
- fdi2raw_header_free (drv->fdi);
+ fdi2raw_header_free(drv->fdi);
drv->fdi = 0;
#endif
break;
}
/* code for track display */
-static void update_drive_gui (int num, bool force)
+static void update_drive_gui(int num, bool force)
{
drive *drv = floppy + num;
bool writ = dskdmaen == DSKDMA_WRITE && drv->state && !((selected | disabled) & (1 << num));
{
bool wrprot = 0;
- drv->writediskfile = getexistingwritefile(p, currprefs.floppyslots[drv - &floppy[0]].df, drv - &floppy[0], &wrprot);
+ drv->writediskfile = getexistingwritefile(p, currprefs.floppyslots[drv->drvnum].df, drv->drvnum, &wrprot);
if (drv->writediskfile) {
drv->wrprot = wrprot;
if (!read_header_ext2 (drv->writediskfile, drv->writetrackdata, &drv->write_num_tracks, 0)) {
drv->prevtracklen = 0;
drive_settype_id(drv); /* Set DD or HD drive */
- update_drive_gui(drv - floppy, false);
- update_disk_statusline(drv - floppy);
+ update_drive_gui(drv->drvnum, false);
+ update_disk_statusline(drv->drvnum);
drive_fill_bigbuf(drv, fake ? -1 : 1);
return 1;
} else if (strncmp ((char*)buffer, "CAPS", 4) == 0) {
drv->wrprot = true;
- if (!caps_loadimage (drv->diskfile, drv - floppy, &num_tracks)) {
- zfile_fclose (drv->diskfile);
+ if (!caps_loadimage(drv->diskfile, drv->drvnum, &num_tracks)) {
+ zfile_fclose(drv->diskfile);
drv->diskfile = 0;
return 0;
}
#ifdef SCP
} else if (strncmp ((char*)buffer, "SCP", 3) == 0) {
drv->wrprot = true;
- if (!scp_open (drv->diskfile, drv - floppy, &num_tracks)) {
- zfile_fclose (drv->diskfile);
+ if (!scp_open(drv->diskfile, drv->drvnum, &num_tracks)) {
+ zfile_fclose(drv->diskfile);
drv->diskfile = 0;
return 0;
}
if (!fake) {
#ifdef DRIVESOUND
if (isfloppysound (drv))
- driveclick_insert (drv - floppy, 0);
+ driveclick_insert(drv->drvnum, 0);
#endif
- update_drive_gui (drv - floppy, false);
- update_disk_statusline(drv - floppy);
+ update_drive_gui(drv->drvnum, false);
+ update_disk_statusline(drv->drvnum);
}
return 1;
}
drv->cyl--;
#ifdef DRIVESOUND
if (isfloppysound (drv))
- driveclick_click (drv - floppy, drv->cyl);
+ driveclick_click(drv->drvnum, drv->cyl);
#endif
}
/* else
write_log (_T("program tried to step over track %d PC %08x\n"), maxtrack, M68K_GETPC);
#ifdef DRIVESOUND
if (isfloppysound (drv))
- driveclick_click (drv - floppy, drv->cyl);
+ driveclick_click(drv->drvnum, drv->cyl);
#endif
}
rand_shifter (drv);
rand_shifter (drv);
#ifdef DRIVESOUND
if (isfloppysound (drv))
- driveclick_motor (drv - floppy, drv->dskready_down_time == 0 ? 2 : 1);
+ driveclick_motor(drv->drvnum, drv->dskready_down_time == 0 ? 2 : 1);
#endif
if (disk_debug_logging > 2)
write_log (_T(" ->motor on"));
#endif
drv->dskready_down_time = DSKREADY_DOWN_TIME * 312 + (uaerand() & 511);
#ifdef DRIVESOUND
- driveclick_motor (drv - floppy, 0);
+ driveclick_motor(drv->drvnum, 0);
#endif
#ifdef DEBUG_DRIVE_ID
write_log (_T("drive_motor: Selected DF%d: reset id shift reg.\n"),drv-floppy);
write_log (_T(" ->motor off"));
if (currprefs.cpu_model <= 68010 && currprefs.m68k_speed == 0) {
drv->motordelay = 1;
- event2_newevent2 (30, drv - floppy, motordelay_func);
+ event2_newevent2(30, drv->drvnum, motordelay_func);
}
}
drv->motoroff = off;
} else if (drv->filetype == ADF_IPF) {
#ifdef CAPS
- caps_loadtrack (drv->bigmfmbuf, drv->tracktiming, drv - floppy, tr, &drv->tracklen, &drv->multi_revolution, &drv->skipoffset, &drv->lastrev, retrytrack);
+ caps_loadtrack(drv->bigmfmbuf, drv->tracktiming, drv->drvnum, tr, &drv->tracklen, &drv->multi_revolution, &drv->skipoffset, &drv->lastrev, retrytrack);
#endif
} else if (drv->filetype == ADF_SCP) {
#ifdef SCP
- scp_loadtrack (drv->bigmfmbuf, drv->tracktiming, drv - floppy, tr, &drv->tracklen, &drv->multi_revolution, &drv->skipoffset, &drv->lastrev, retrytrack);
+ scp_loadtrack(drv->bigmfmbuf, drv->tracktiming, drv->drvnum, tr, &drv->tracklen, &drv->multi_revolution, &drv->skipoffset, &drv->lastrev, retrytrack);
#endif
} else if (drv->filetype == ADF_FDI) {
#ifdef FDI2RAW
- fdi2raw_loadtrack (drv->fdi, drv->bigmfmbuf, drv->tracktiming, tr, &drv->tracklen, &drv->indexoffset, &drv->multi_revolution, 1);
+ fdi2raw_loadtrack(drv->fdi, drv->bigmfmbuf, drv->tracktiming, tr, &drv->tracklen, &drv->indexoffset, &drv->multi_revolution, 1);
#endif
} else if (ti->type == TRACK_PCDOS) {
- decode_pcdos (drv);
+ decode_pcdos(drv);
} else if (ti->type == TRACK_AMIGADOS) {
- decode_amigados (drv);
+ decode_amigados(drv);
} else if (ti->type == TRACK_DISKSPARE) {
- decode_diskspare (drv);
+ decode_diskspare(drv);
} else if (ti->type == TRACK_NONE) {
drv->diskfile = f;
drv->filetype = ADF_EXT2;
- read_header_ext2 (drv->diskfile, drv->trackdata, &drv->num_tracks, &drv->ddhd);
+ read_header_ext2(drv->diskfile, drv->trackdata, &drv->num_tracks, &drv->ddhd);
- drive_write_data (drv);
+ drive_write_data(drv);
#ifdef RETROPLATFORM
- rp_disk_image_change (drv - &floppy[0], name, false);
+ rp_disk_image_change(drv->drvnum, name, false);
#endif
- drive_fill_bigbuf (drv, 1);
+ drive_fill_bigbuf(drv, 1);
return true;
}
{
#ifdef DRIVESOUND
if (isfloppysound (drv))
- driveclick_insert (drv - floppy, 1);
+ driveclick_insert(drv->drvnum, 1);
#endif
if (drv->diskfile || drv->filetype >= 0)
statusline_add_message(STATUSTYPE_FLOPPY, _T("DF%d: -"), drv - floppy);
drive_settype_id (drv); /* Back to 35 DD */
if (disk_debug_logging > 0)
write_log (_T("eject drive %ld\n"), drv - &floppy[0]);
- gui_disk_image_change(drv - floppy, NULL, drv->wrprot);
- inprec_recorddiskchange (drv - floppy, NULL, false);
+ gui_disk_image_change(drv->drvnum, NULL, drv->wrprot);
+ inprec_recorddiskchange (drv->drvnum, NULL, false);
}
static void floppy_get_bootblock (uae_u8 *dst, bool ffs, bool bootable)
{
case ADF_IPF:
#ifdef CAPS
- caps_loadrevolution (drv->bigmfmbuf, drv->tracktiming, drv - floppy, drv->cyl * 2 + side, &drv->tracklen, &drv->lastrev, drv->track_access_done);
+ caps_loadrevolution(drv->bigmfmbuf, drv->tracktiming, drv->drvnum, drv->cyl * 2 + side, &drv->tracklen, &drv->lastrev, drv->track_access_done);
#endif
break;
case ADF_SCP:
#ifdef SCP
- scp_loadrevolution (drv->bigmfmbuf, drv - floppy, drv->tracktiming, &drv->tracklen);
+ scp_loadrevolution(drv->bigmfmbuf, drv->drvnum, drv->tracktiming, &drv->tracklen);
#endif
break;
case ADF_FDI:
{
for (int dr = MAX_FLOPPY_DRIVES - 1; dr >= 0; dr--) {
drive *drv = &floppy[dr];
+ drv->drvnum = dr;
/* reset all drive types to 3.5 DD */
drive_settype_id (drv);
if (!drive_insert (drv, &currprefs, dr, currprefs.floppyslots[dr].df, false, currprefs.floppyslots[dr].forcedwriteprotect))
return src;
}
-uae_u8 *save_disk (int num, int *len, uae_u8 *dstptr, bool usepath)
+uae_u8 *save_disk (int num, size_t*len, uae_u8 *dstptr, bool usepath)
{
uae_u8 *dstbak,*dst;
drive *drv = &floppy[num];
return dstbak;
}
-uae_u8 *save_disk2 (int num, int *len, uae_u8 *dstptr)
+uae_u8 *save_disk2 (int num, size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak,*dst;
drive *drv = &floppy[num];
return src;
}
-uae_u8 *save_floppy (int *len, uae_u8 *dstptr)
+uae_u8 *save_floppy (size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
static void mix (void)
{
- int total = ((uae_u8*)paula_sndbufpt - (uae_u8*)paula_sndbuffer) / (get_audio_nativechannels (currprefs.sound_stereo) * 2);
+ size_t total = ((uae_u8*)paula_sndbufpt - (uae_u8*)paula_sndbuffer) / (get_audio_nativechannels (currprefs.sound_stereo) * 2);
while (clickcnt < total) {
clickbuffer[clickcnt++] = getsample ();
}
return -1;
if (cd->zorro >= 4)
return -2;
- if (cd->rc)
+ if (cd->rc && cd->rc->back)
return cd->rc->back->device_order;
int devnum = (cd->flags >> 16) & 255;
if (!_tcsicmp(cd->name, _T("Z2Fast")))
#endif
_tcscpy(label, aci->cst->name);
}
- if (cd->rc && !label[0]) {
+ if (cd->rc && !label[0] && cd->rc->back) {
const struct expansionromtype *ert = get_device_expansion_rom(cd->rc->back->device_type);
if (ert) {
_tcscpy(label, ert->friendlyname);
/* State save/restore code. */
-uae_u8 *save_fram (int *len, int num)
+uae_u8 *save_fram(size_t *len, int num)
{
*len = fastmem_bank[num].allocated_size;
return fastmem_bank[num].baseaddr;
}
-uae_u8 *save_zram (int *len, int num)
+uae_u8 *save_zram(size_t *len, int num)
{
if (num < 0) {
*len = z3chipmem_bank.allocated_size;
return z3fastmem_bank[num].baseaddr;
}
-uae_u8 *save_pram (int *len)
+uae_u8 *save_pram(size_t *len)
{
*len = gfxmem_banks[0]->allocated_size;
return gfxmem_banks[0]->baseaddr;
}
-void restore_fram (int len, size_t filepos, int num)
+void restore_fram(int len, size_t filepos, int num)
{
fast_filepos[num] = filepos;
changed_prefs.fastmem[num].size = len;
}
-void restore_zram (int len, size_t filepos, int num)
+void restore_zram(int len, size_t filepos, int num)
{
if (num == -1) {
z3_fileposchip = filepos;
}
}
-void restore_pram (int len, size_t filepos)
+void restore_pram(int len, size_t filepos)
{
p96_filepos = filepos;
changed_prefs.rtgboards[0].rtgmem_size = len;
}
-uae_u8 *save_expansion (int *len, uae_u8 *dstptr)
+uae_u8 *save_expansion(size_t *len, uae_u8 *dstptr)
{
uae_u8 *dst, *dstbak;
if (dstptr)
return dstbak;
}
-uae_u8 *restore_expansion (uae_u8 *src)
+uae_u8 *restore_expansion(uae_u8 *src)
{
fastmem_bank[0].start = restore_u32 ();
z3fastmem_bank[0].start = restore_u32 ();
return src;
}
-uae_u8 *save_expansion_boards(int *len, uae_u8 *dstptr, int cardnum)
+uae_u8 *save_expansion_boards(size_t *len, uae_u8 *dstptr, int cardnum)
{
uae_u8 *dst, *dstbak;
if (cardnum >= cardno)
static TCHAR *new_filesys_root_path, *new_filesys_fs_path;
-uae_u8 *save_filesys_common (int *len)
+uae_u8 *save_filesys_common(size_t *len)
{
uae_u8 *dstbak, *dst;
if (nr_units () == 0)
return dstbak;
}
-uae_u8 *restore_filesys_common (uae_u8 *src)
+uae_u8 *restore_filesys_common(uae_u8 *src)
{
if (restore_u32 () != 2)
return src;
return src;
}
-uae_u8 *save_filesys_paths(int num, int *len)
+uae_u8 *save_filesys_paths(int num, size_t *len)
{
uae_u8 *dstbak, *dst;
UnitInfo *ui;
return dstbak;
}
-uae_u8 *save_filesys (int num, int *len)
+uae_u8 *save_filesys(int num, size_t *len)
{
uae_u8 *dstbak, *dst;
UnitInfo *ui;
return src;
}
-uae_u8 *restore_filesys (uae_u8 *src)
+uae_u8 *restore_filesys(uae_u8 *src)
{
int type, devno;
UnitInfo *ui;
return src;
}
-uae_u8 *save_fpu (int *len, uae_u8 *dstptr)
+uae_u8 *save_fpu(size_t *len, uae_u8 *dstptr)
{
uae_u32 w1, w2, w3, v;
uae_u8 *dstbak, *dst;
device_add_exit(gayle_free);
}
-uae_u8 *save_gayle (int *len, uae_u8 *dstptr)
+uae_u8 *save_gayle(size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
return dstbak;
}
-uae_u8 *save_gayle_ide (int num, int *len, uae_u8 *dstptr)
+uae_u8 *save_gayle_ide(int num, size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
struct ide_hdf *ide;
void audio_deactivate (void);
void audio_vsync (void);
void audio_sampleripper(int);
-void write_wavheader (struct zfile *wavfile, uae_u32 size, uae_u32 freq);
+void write_wavheader (struct zfile *wavfile, size_t size, uae_u32 freq);
int audio_is_pull(void);
int audio_pull_buffer(void);
extern void cfgfile_compatibility_romtype(struct uae_prefs *p);
extern void cfgfile_compatibility_rtg(struct uae_prefs *p);
extern bool cfgfile_detect_art(struct uae_prefs *p, TCHAR *path);
-extern const TCHAR *cfgfile_getconfigdata(int *len);
+extern const TCHAR *cfgfile_getconfigdata(size_t *len);
extern bool cfgfile_createconfigstore(struct uae_prefs *p);
extern void cfgfile_get_shader_config(struct uae_prefs *p, int rtg);
#ifndef UAE_ROMMGR_H
#define UAE_ROMMGR_H
-extern int decode_cloanto_rom_do (uae_u8 *mem, int size, int real_size);
+extern int decode_cloanto_rom_do(uae_u8 *mem, int size, int real_size);
#define ROMTYPE_SUB_MASK 0x000000ff
#define ROMTYPE_GROUP_MASK 0x003fff00
#define restore_store_pos() restore_store_pos_func (&src)
#define restore_store_size() restore_store_size_func (&src)
-extern void save_u64_func (uae_u8 **, uae_u64);
-extern void save_u32_func (uae_u8 **, uae_u32);
-extern void save_u16_func (uae_u8 **, uae_u16);
-extern void save_u8_func (uae_u8 **, uae_u8);
+extern void save_u64_func(uae_u8 **, uae_u64);
+extern void save_u32t_func(uae_u8 **, size_t);
+extern void save_u32_func(uae_u8 **, uae_u32);
+extern void save_u16_func(uae_u8 **, uae_u16);
+extern void save_u8_func(uae_u8 **, uae_u8);
-extern uae_u64 restore_u64_func (uae_u8 **);
-extern uae_u32 restore_u32_func (uae_u8 **);
-extern uae_u16 restore_u16_func (uae_u8 **);
-extern uae_u8 restore_u8_func (uae_u8 **);
+extern uae_u64 restore_u64_func(uae_u8 **);
+extern uae_u32 restore_u32_func(uae_u8 **);
+extern uae_u16 restore_u16_func(uae_u8 **);
+extern uae_u8 restore_u8_func(uae_u8 **);
-extern void save_string_func (uae_u8 **, const TCHAR*);
-extern TCHAR *restore_string_func (uae_u8 **);
+extern void save_string_func(uae_u8 **, const TCHAR*);
+extern TCHAR *restore_string_func(uae_u8 **);
#define SAVESTATE_PATH 0
#define SAVESTATE_PATH_FLOPPY 1
extern TCHAR *restore_path_func(uae_u8 **, int type);
extern TCHAR *restore_path_full_func(uae_u8 **);
-#define save_u64(x) save_u64_func (&dst, (x))
-#define save_u32(x) save_u32_func (&dst, (x))
-#define save_u16(x) save_u16_func (&dst, (x))
-#define save_u8(x) save_u8_func (&dst, (x))
+#define save_u64(x) save_u64_func(&dst, (x))
+#define save_u32(x) save_u32_func(&dst, (x))
+#define save_u32t(x) save_u32t_func(&dst, (x))
+#define save_u16(x) save_u16_func(&dst, (x))
+#define save_u8(x) save_u8_func(&dst, (x))
-#define restore_u64() restore_u64_func (&src)
-#define restore_u64to32() (uae_u32)restore_u64_func (&src)
-#define restore_u32() restore_u32_func (&src)
-#define restore_u16() restore_u16_func (&src)
-#define restore_u8() restore_u8_func (&src)
+#define restore_u64() restore_u64_func(&src)
+#define restore_u64to32() (uae_u32)restore_u64_func(&src)
+#define restore_u32() restore_u32_func(&src)
+#define restore_u16() restore_u16_func(&src)
+#define restore_u8() restore_u8_func(&src)
-#define save_string(x) save_string_func (&dst, (x))
-#define restore_string() restore_string_func (&src)
-
-#define save_path(x, p) save_path_func (&dst, (x), p)
-#define save_path_full(x, p) save_path_full_func (&dst, (x), p)
-#define restore_path(p) restore_path_func (&src, p)
-#define restore_path_full() restore_path_full_func (&src)
+#define save_string(x) save_string_func(&dst, (x))
+#define restore_string() restore_string_func(&src)
+#define save_path(x, p) save_path_func(&dst, (x), p)
+#define save_path_full(x, p) save_path_full_func(&dst, (x), p)
+#define restore_path(p) restore_path_func(&src, p)
+#define restore_path_full() restore_path_full_func(&src)
/* save, restore and initialize routines for Amiga's subsystems */
-extern uae_u8 *restore_cpu (uae_u8 *);
-extern void restore_cpu_finish (void);
-extern uae_u8 *save_cpu (int *, uae_u8 *);
-extern uae_u8 *restore_cpu_extra (uae_u8 *);
-extern uae_u8 *save_cpu_extra (int *, uae_u8 *);
-extern uae_u8 *save_cpu_trace (int *, uae_u8 *);
-extern uae_u8 *restore_cpu_trace (uae_u8 *);
-
-extern uae_u8 *restore_mmu (uae_u8 *);
-extern uae_u8 *save_mmu (int *, uae_u8 *);
-
-extern uae_u8 *restore_fpu (uae_u8 *);
-extern uae_u8 *save_fpu (int *, uae_u8 *);
-
-extern uae_u8 *restore_disk (int, uae_u8 *);
-extern uae_u8 *save_disk (int, int *, uae_u8 *, bool);
-extern uae_u8 *restore_floppy (uae_u8 *src);
-extern uae_u8 *save_floppy (int *len, uae_u8 *);
-extern uae_u8 *save_disk2 (int num, int *len, uae_u8 *dstptr);
-extern uae_u8 *restore_disk2 (int num,uae_u8 *src);
-extern void DISK_save_custom (uae_u32 *pdskpt, uae_u16 *pdsklen, uae_u16 *pdsksync, uae_u16 *pdskbytr);
-extern void DISK_restore_custom (uae_u32 pdskpt, uae_u16 pdsklength, uae_u16 pdskbytr);
-extern void restore_disk_finish (void);
-
-extern uae_u8 *restore_custom (uae_u8 *);
-extern uae_u8 *save_custom (int *, uae_u8 *, int);
-extern uae_u8 *restore_custom_extra (uae_u8 *);
-extern uae_u8 *save_custom_extra (int *, uae_u8 *);
+extern uae_u8 *restore_cpu(uae_u8 *);
+extern void restore_cpu_finish(void);
+extern uae_u8 *save_cpu(size_t *, uae_u8 *);
+extern uae_u8 *restore_cpu_extra(uae_u8 *);
+extern uae_u8 *save_cpu_extra(size_t *, uae_u8 *);
+extern uae_u8 *save_cpu_trace(size_t *, uae_u8 *);
+extern uae_u8 *restore_cpu_trace(uae_u8 *);
+
+extern uae_u8 *restore_mmu(uae_u8 *);
+extern uae_u8 *save_mmu(size_t *, uae_u8 *);
+
+extern uae_u8 *restore_fpu(uae_u8 *);
+extern uae_u8 *save_fpu(size_t *, uae_u8 *);
+
+extern uae_u8 *restore_disk(int, uae_u8 *);
+extern uae_u8 *save_disk(int, size_t *, uae_u8 *, bool);
+extern uae_u8 *restore_floppy(uae_u8 *src);
+extern uae_u8 *save_floppy(size_t *len, uae_u8 *);
+extern uae_u8 *save_disk2(int num, size_t *len, uae_u8 *dstptr);
+extern uae_u8 *restore_disk2(int num, uae_u8 *src);
+extern void DISK_save_custom (uae_u32 *pdskpt, uae_u16 *pdsklen, uae_u16 *pdsksync, uae_u16 *pdskbytr);
+extern void DISK_restore_custom (uae_u32 pdskpt, uae_u16 pdsklength, uae_u16 pdskbytr);
+extern void restore_disk_finish(void);
+
+extern uae_u8 *restore_custom(uae_u8 *);
+extern uae_u8 *save_custom(size_t *, uae_u8 *, int);
+extern uae_u8 *restore_custom_extra(uae_u8 *);
+extern uae_u8 *save_custom_extra(size_t *, uae_u8 *);
extern void restore_custom_finish(void);
-extern uae_u8 *restore_custom_sprite (int num, uae_u8 *src);
-extern uae_u8 *save_custom_sprite (int num, int *len, uae_u8 *);
+extern uae_u8 *restore_custom_sprite(int num, uae_u8 *src);
+extern uae_u8 *save_custom_sprite(int num, size_t *len, uae_u8 *);
extern uae_u8 *restore_custom_agacolors (uae_u8 *src);
-extern uae_u8 *save_custom_agacolors (int *len, uae_u8 *);
+extern uae_u8 *save_custom_agacolors(size_t *len, uae_u8 *);
extern uae_u8 *restore_custom_event_delay (uae_u8 *src);
-extern uae_u8 *save_custom_event_delay (int *len, uae_u8 *dstptr);
+extern uae_u8 *save_custom_event_delay(size_t *len, uae_u8 *dstptr);
extern uae_u8 *restore_blitter (uae_u8 *src);
-extern uae_u8 *save_blitter (int *len, uae_u8 *);
+extern uae_u8 *save_blitter (size_t *len, uae_u8 *);
extern uae_u8 *restore_blitter_new (uae_u8 *src);
-extern uae_u8 *save_blitter_new (int *len, uae_u8 *);
+extern uae_u8 *save_blitter_new (size_t *len, uae_u8 *);
extern void restore_blitter_finish (void);
-extern uae_u8 *restore_audio (int, uae_u8 *);
-extern uae_u8 *save_audio (int, int *, uae_u8 *);
-extern void restore_audio_finish (void);
+extern uae_u8 *restore_audio(int, uae_u8 *);
+extern uae_u8 *save_audio(int, size_t *, uae_u8 *);
+extern void restore_audio_finish(void);
-extern uae_u8 *restore_cia (int, uae_u8 *);
-extern uae_u8 *save_cia (int, int *, uae_u8 *);
-extern void restore_cia_finish (void);
-extern void restore_cia_start (void);
+extern uae_u8 *restore_cia(int, uae_u8 *);
+extern uae_u8 *save_cia(int, size_t *, uae_u8 *);
+extern void restore_cia_finish(void);
+extern void restore_cia_start(void);
-extern uae_u8 *restore_expansion (uae_u8 *);
-extern uae_u8 *save_expansion (int *, uae_u8 *);
+extern uae_u8 *restore_expansion(uae_u8 *);
+extern uae_u8 *save_expansion(size_t *, uae_u8 *);
-extern uae_u8 *restore_p96 (uae_u8 *);
-extern uae_u8 *save_p96 (int *, uae_u8 *);
-extern void restore_p96_finish (void);
+extern uae_u8 *restore_p96(uae_u8 *);
+extern uae_u8 *save_p96(size_t *, uae_u8 *);
+extern void restore_p96_finish(void);
-extern uae_u8 *restore_keyboard (uae_u8 *);
-extern uae_u8 *save_keyboard (int *,uae_u8*);
+extern uae_u8 *restore_keyboard(uae_u8 *);
+extern uae_u8 *save_keyboard(size_t *,uae_u8*);
-extern uae_u8 *restore_akiko (uae_u8 *src);
-extern uae_u8 *save_akiko (int *len, uae_u8*);
+extern uae_u8 *restore_akiko(uae_u8 *src);
+extern uae_u8 *save_akiko(size_t *len, uae_u8*);
extern void restore_akiko_finish(void);
extern void restore_akiko_final(void);
-extern uae_u8 *restore_cdtv (uae_u8 *src);
-extern uae_u8 *save_cdtv (int *len, uae_u8*);
+extern uae_u8 *restore_cdtv(uae_u8 *src);
+extern uae_u8 *save_cdtv(size_t *len, uae_u8*);
extern void restore_cdtv_finish(void);
extern void restore_cdtv_final(void);
-extern uae_u8 *restore_cdtv_dmac (uae_u8 *src);
-extern uae_u8 *save_cdtv_dmac (int *len, uae_u8*);
-extern uae_u8 *restore_scsi_dmac (int wdtype, uae_u8 *src);
-extern uae_u8 *save_scsi_dmac (int wdtype, int *len, uae_u8*);
+extern uae_u8 *restore_cdtv_dmac(uae_u8 *src);
+extern uae_u8 *save_cdtv_dmac(size_t *len, uae_u8*);
+extern uae_u8 *restore_scsi_dmac(int wdtype, uae_u8 *src);
+extern uae_u8 *save_scsi_dmac(int wdtype, int *len, uae_u8*);
-extern uae_u8 *save_scsi_device (int wdtype, int num, int *len, uae_u8 *dstptr);
-extern uae_u8 *restore_scsi_device (int wdtype, uae_u8 *src);
+extern uae_u8 *save_scsi_device(int wdtype, int num, size_t *len, uae_u8 *dstptr);
+extern uae_u8 *restore_scsi_device(int wdtype, uae_u8 *src);
-extern uae_u8 *save_scsidev (int num, int *len, uae_u8 *dstptr);
-extern uae_u8 *restore_scsidev (uae_u8 *src);
+extern uae_u8 *save_scsidev(int num, size_t *len, uae_u8 *dstptr);
+extern uae_u8 *restore_scsidev(uae_u8 *src);
-extern uae_u8 *restore_filesys (uae_u8 *src);
-extern uae_u8 *save_filesys (int num, int *len);
-extern uae_u8 *restore_filesys_common (uae_u8 *src);
-extern uae_u8 *save_filesys_common (int *len);
+extern uae_u8 *restore_filesys(uae_u8 *src);
+extern uae_u8 *save_filesys(int num, size_t *len);
+extern uae_u8 *restore_filesys_common(uae_u8 *src);
+extern uae_u8 *save_filesys_common(size_t *len);
extern uae_u8 *restore_filesys_paths(uae_u8 *src);
-extern uae_u8 *save_filesys_paths(int num, int *len);
+extern uae_u8 *save_filesys_paths(int num, size_t *len);
extern int save_filesys_cando(void);
extern uae_u8 *restore_gayle(uae_u8 *src);
-extern uae_u8 *save_gayle (int *len, uae_u8*);
-extern uae_u8 *restore_gayle_ide (uae_u8 *src);
-extern uae_u8 *save_gayle_ide (int num, int *len, uae_u8*);
+extern uae_u8 *save_gayle(size_t *len, uae_u8*);
+extern uae_u8 *restore_gayle_ide(uae_u8 *src);
+extern uae_u8 *save_gayle_ide(int num, size_t *len, uae_u8*);
-extern uae_u8 *save_cd (int num, int *len);
-extern uae_u8 *restore_cd (int, uae_u8 *src);
-extern void restore_cd_finish (void);
+extern uae_u8 *save_cd(int num, size_t *len);
+extern uae_u8 *restore_cd(int, uae_u8 *src);
+extern void restore_cd_finish(void);
-extern uae_u8 *save_configuration (int *len, bool fullconfig);
-extern uae_u8 *restore_configuration (uae_u8 *src);
-extern uae_u8 *save_log (int, int *len);
+extern uae_u8 *save_configuration(size_t *len, bool fullconfig);
+extern uae_u8 *restore_configuration(uae_u8 *src);
+extern uae_u8 *save_log(int, size_t *len);
//extern uae_u8 *restore_log (uae_u8 *src);
-extern uae_u8 *restore_input (uae_u8 *src);
-extern uae_u8 *save_input (int *len, uae_u8 *dstptr);
+extern uae_u8 *restore_input(uae_u8 *src);
+extern uae_u8 *save_input(size_t *len, uae_u8 *dstptr);
-extern uae_u8 *restore_inputstate (uae_u8 *src);
-extern uae_u8 *save_inputstate (int *len, uae_u8 *dstptr);
-extern void clear_inputstate (void);
+extern uae_u8 *restore_inputstate(uae_u8 *src);
+extern uae_u8 *save_inputstate(size_t *len, uae_u8 *dstptr);
+extern void clear_inputstate(void);
-extern uae_u8 *save_a2065 (int *len, uae_u8 *dstptr);
-extern uae_u8 *restore_a2065 (uae_u8 *src);
-extern void restore_a2065_finish (void);
+extern uae_u8 *save_a2065(size_t *len, uae_u8 *dstptr);
+extern uae_u8 *restore_a2065(uae_u8 *src);
+extern void restore_a2065_finish(void);
-extern uae_u8 *restore_debug_memwatch (uae_u8 *src);
-extern uae_u8 *save_debug_memwatch (int *len, uae_u8 *dstptr);
-extern void restore_debug_memwatch_finish (void);
+extern uae_u8 *restore_debug_memwatch(uae_u8 *src);
+extern uae_u8 *save_debug_memwatch(size_t *len, uae_u8 *dstptr);
+extern void restore_debug_memwatch_finish(void);
-extern uae_u8 *save_screenshot(int monid, int *len);
+extern uae_u8 *save_screenshot(int monid, size_t *len);
-extern uae_u8 *save_cycles (int *len, uae_u8 *dstptr);
-extern uae_u8 *restore_cycles (uae_u8 *src);
+extern uae_u8 *save_cycles(size_t *len, uae_u8 *dstptr);
+extern uae_u8 *restore_cycles(uae_u8 *src);
-extern void restore_cram (int, size_t);
-extern void restore_bram (int, size_t);
-extern void restore_fram (int, size_t, int);
-extern void restore_zram (int, size_t, int);
-extern void restore_bootrom (int, size_t);
-extern void restore_pram (int, size_t);
-extern void restore_a3000lram (int, size_t);
-extern void restore_a3000hram (int, size_t);
+extern void restore_cram(int, size_t);
+extern void restore_bram(int, size_t);
+extern void restore_fram(int, size_t, int);
+extern void restore_zram(int, size_t, int);
+extern void restore_bootrom(int, size_t);
+extern void restore_pram(int, size_t);
+extern void restore_a3000lram(int, size_t);
+extern void restore_a3000hram(int, size_t);
extern void restore_ram (size_t, uae_u8*);
-extern uae_u8 *save_cram (int *);
-extern uae_u8 *save_bram (int *);
-extern uae_u8 *save_fram (int *, int);
-extern uae_u8 *save_zram (int *, int);
-extern uae_u8 *save_bootrom (int *);
-extern uae_u8 *save_pram (int *);
-extern uae_u8 *save_a3000lram (int *);
-extern uae_u8 *save_a3000hram (int *);
+extern uae_u8 *save_cram(size_t *);
+extern uae_u8 *save_bram(size_t *);
+extern uae_u8 *save_fram(size_t *, int);
+extern uae_u8 *save_zram(size_t *, int);
+extern uae_u8 *save_bootrom(size_t *);
+extern uae_u8 *save_pram(size_t *);
+extern uae_u8 *save_a3000lram (size_t *);
+extern uae_u8 *save_a3000hram (size_t *);
-extern uae_u8 *restore_rom (uae_u8 *);
-extern uae_u8 *save_rom (int, int *, uae_u8 *);
+extern uae_u8 *restore_rom(uae_u8 *);
+extern uae_u8 *save_rom(int, size_t *, uae_u8 *);
-extern uae_u8 *save_expansion_boards(int*, uae_u8*, int);
+extern uae_u8 *save_expansion_boards(size_t *, uae_u8*, int);
extern uae_u8 *restore_expansion_boards(uae_u8*);
#if 0
extern uae_u8 *save_expansion_info_old(int*, uae_u8*);
extern void restore_expansion_finish(void);
extern uae_u8 *restore_action_replay (uae_u8 *);
-extern uae_u8 *save_action_replay (int *, uae_u8 *);
+extern uae_u8 *save_action_replay (size_t *, uae_u8 *);
extern uae_u8 *restore_hrtmon (uae_u8 *);
-extern uae_u8 *save_hrtmon (int *, uae_u8 *);
+extern uae_u8 *save_hrtmon (size_t *, uae_u8 *);
extern void restore_ar_finish (void);
extern void savestate_initsave (const TCHAR *filename, int docompress, int nodialogs, bool save);
extern uae_u8 *zfile_load_data(const TCHAR *name, const uae_u8 *data,int datalen, int *outlen);
extern uae_u8 *zfile_load_file(const TCHAR *name, int *outlen);
extern struct zfile *zfile_fopen_parent(struct zfile*, const TCHAR*, uae_u64 offset, uae_u64 size);
-extern uae_u8 *zfile_get_data_pointer(struct zfile *z, int *len);
+extern uae_u8 *zfile_get_data_pointer(struct zfile *z, size_t *len);
extern int zfile_exists (const TCHAR *name);
extern void zfile_fclose (struct zfile *z);
extern void zfile_exit(void);
extern int execute_command(TCHAR *);
extern int zfile_iscompressed(struct zfile *z);
-extern int zfile_zcompress(struct zfile *dst, void *src, int size);
+extern int zfile_zcompress(struct zfile *dst, void *src, size_t size);
extern int zfile_zuncompress(void *dst, int dstsize, struct zfile *src, int srcsize);
extern int zfile_gettype(struct zfile *z);
extern int zfile_zopen(const TCHAR *name, zfile_callback zc, void *user);
FILE *f = _tfopen(path, _T("rb"));
if (!f)
return NULL;
- int v = fread(tmp, 1, sizeof tmp, f);
+ size_t v = fread(tmp, 1, sizeof tmp, f);
fclose (f);
if (v == 3 && tmp[0] == 0xef && tmp[1] == 0xbb && tmp[2] == 0xbf) {
f = _tfopen (path, _T("rt, ccs=UTF-8"));
}
return src;
}
-uae_u8 *save_input (int *len, uae_u8 *dstptr)
+uae_u8 *save_input (size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
// for state recorder use only!
-uae_u8 *save_inputstate (int *len, uae_u8 *dstptr)
+uae_u8 *save_inputstate (size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
_tcscat (tmp, _T(".log.txt"));
struct zfile *zfd = zfile_fopen (tmp, _T("wb"));
if (zfd) {
- int loglen;
+ size_t loglen;
uae_u8 *log;
loglen = 0;
log = save_log (TRUE, &loglen);
static inline void raw_jl(uae_u32 t)
{
raw_jcc_l_oponly(NATIVE_CC_LT);
- emit_long(t-(uintptr)target-4);
+ emit_long(t-(uae_u32)(uintptr)target-4);
}
static inline void raw_jz(uae_u32 t)
{
raw_jz_l_oponly();
- emit_long(t-(uintptr)target-4);
+ emit_long(t-(uae_u32)(uintptr)target-4);
}
static inline void raw_jnz(uae_u32 t)
{
raw_jnz_l_oponly();
- emit_long(t-(uintptr)target-4);
+ emit_long(t-(uae_u32)(uintptr)target-4);
}
static inline void raw_jcc_b_oponly(int cc)
#define USE_JIT
#endif
+#define JITPTR (uae_u32)(uintptr)
+
#ifdef USE_JIT
#ifdef JIT_DEBUG
case PC16:
comprintf("\tint %sa = scratchie++;\n", name);
- comprintf("\tuae_u32 address = start_pc + ((char *)comp_pc_p - (char *)start_pc_p) + m68k_pc_offset;\n");
+ comprintf("\tuae_u32 address = (uae_u32)(start_pc + ((char *)comp_pc_p - (char *)start_pc_p) + m68k_pc_offset);\n");
comprintf("\tuae_s32 PC16off = (uae_s32)(uae_s16)%s;\n", gen_nextiword());
comprintf("\tmov_l_ri(%sa, address + PC16off);\n", name);
break;
case PC8r:
comprintf("\tint pctmp = scratchie++;\n");
comprintf("\tint %sa = scratchie++;\n", name);
- comprintf("\tuae_u32 address = start_pc + ((char *)comp_pc_p - (char *)start_pc_p) + m68k_pc_offset;\n");
+ comprintf("\tuae_u32 address = (uae_u32)(start_pc + ((char *)comp_pc_p - (char *)start_pc_p) + m68k_pc_offset);\n");
start_brace();
comprintf("\tmov_l_ri(pctmp,address);\n");
comprintf(" int srca = scratchie++;\n");
comprintf(" mov_l_rm(srca, (uintptr)®s.vbr);\n");
comprintf(" mov_l_brR(srca, srca, MEMBaseDiff + trapno * 4); mid_bswap_32(srca);\n");
- comprintf(" mov_l_mr((uintptr)®s.pc, srca);\n");
+ comprintf(" mov_l_mr(JITPTR ®s.pc, srca);\n");
comprintf(" get_n_addr_jmp(srca, PC_P, scratchie);\n");
- comprintf(" mov_l_mr((uintptr)®s.pc_oldp, PC_P);\n");
+ comprintf(" mov_l_mr(JITPTR ®s.pc_oldp, PC_P);\n");
gen_update_next_handler();
disasm_this_inst(); /* for debugging only */
/*
start_brace();
comprintf("\tint newad=scratchie++;\n"
"\treadlong(SP_REG,newad,scratchie);\n"
- "\tmov_l_mr((uintptr)®s.pc,newad);\n"
+ "\tmov_l_mr(JITPTR ®s.pc,newad);\n"
"\tget_n_addr_jmp(newad,PC_P,scratchie);\n"
- "\tmov_l_mr((uintptr)®s.pc_oldp,PC_P);\n"
+ "\tmov_l_mr(JITPTR ®s.pc_oldp,PC_P);\n"
"\tm68k_pc_offset=0;\n"
"\tadd_l(SP_REG,offs);\n");
gen_update_next_handler();
#endif
comprintf("\tint newad=scratchie++;\n"
"\treadlong(SP_REG,newad,scratchie);\n"
- "\tmov_l_mr((uintptr)®s.pc,newad);\n"
+ "\tmov_l_mr(JITPTR ®s.pc,newad);\n"
"\tget_n_addr_jmp(newad,PC_P,scratchie);\n"
- "\tmov_l_mr((uintptr)®s.pc_oldp,PC_P);\n"
+ "\tmov_l_mr(JITPTR ®s.pc_oldp,PC_P);\n"
"\tm68k_pc_offset=0;\n"
"\tlea_l_brr(SP_REG,SP_REG,4);\n");
gen_update_next_handler();
isjump;
genamode(curi->smode, "srcreg", curi->size, "src", GENA_GETV_NO_FETCH, GENA_MOVEM_DO_INC);
start_brace();
- comprintf("\tuae_u32 retadd=start_pc+((char *)comp_pc_p-(char *)start_pc_p)+m68k_pc_offset;\n");
+ comprintf("\tuae_u32 retadd=(uae_u32)(start_pc+((char *)comp_pc_p-(char *)start_pc_p)+m68k_pc_offset);\n");
comprintf("\tint ret=scratchie++;\n"
"\tmov_l_ri(ret,retadd);\n"
"\tsub_l_ri(SP_REG,4);\n"
"\twritelong_clobber(SP_REG,ret,scratchie);\n");
- comprintf("\tmov_l_mr((uintptr)®s.pc,srca);\n"
+ comprintf("\tmov_l_mr(JITPTR ®s.pc,srca);\n"
"\tget_n_addr_jmp(srca,PC_P,scratchie);\n"
- "\tmov_l_mr((uintptr)®s.pc_oldp,PC_P);\n"
+ "\tmov_l_mr(JITPTR ®s.pc_oldp,PC_P);\n"
"\tm68k_pc_offset=0;\n");
gen_update_next_handler();
break;
#endif
isjump;
genamode(curi->smode, "srcreg", curi->size, "src", GENA_GETV_NO_FETCH, GENA_MOVEM_DO_INC);
- comprintf("\tmov_l_mr((uintptr)®s.pc,srca);\n"
+ comprintf("\tmov_l_mr(JITPTR ®s.pc,srca);\n"
"\tget_n_addr_jmp(srca,PC_P,scratchie);\n"
- "\tmov_l_mr((uintptr)®s.pc_oldp,PC_P);\n"
+ "\tmov_l_mr(JITPTR ®s.pc_oldp,PC_P);\n"
"\tm68k_pc_offset=0;\n");
gen_update_next_handler();
break;
is_const_jump;
genamode(curi->smode, "srcreg", curi->size, "src", GENA_GETV_FETCH, GENA_MOVEM_DO_INC);
start_brace();
- comprintf("\tuae_u32 retadd=start_pc+((char *)comp_pc_p-(char *)start_pc_p)+m68k_pc_offset;\n");
+ comprintf("\tuae_u32 retadd=(uae_u32)(start_pc+((char *)comp_pc_p-(char *)start_pc_p)+m68k_pc_offset);\n");
comprintf("\tint ret=scratchie++;\n"
"\tmov_l_ri(ret,retadd);\n"
"\tsub_l_ri(SP_REG,4);\n"
comprintf("\tsub_l_ri(src,m68k_pc_offset-m68k_pc_offset_thisinst-2);\n");
/* Leave the following as "add" --- it will allow it to be optimized
away due to src being a constant ;-) */
- comprintf("\tadd_l_ri(src,(uintptr)comp_pc_p);\n");
- comprintf("\tmov_l_ri(PC_P,(uintptr)comp_pc_p);\n");
+ comprintf("\tadd_l_ri(src,JITPTR comp_pc_p);\n");
+ comprintf("\tmov_l_ri(PC_P,JITPTR comp_pc_p);\n");
/* Now they are both constant. Might as well fold in m68k_pc_offset */
comprintf("\tadd_l_ri(src,m68k_pc_offset);\n");
comprintf("\tadd_l_ri(PC_P,m68k_pc_offset);\n");
default: assert(0); /* Seems this only comes in word flavour */
}
comprintf("\tsub_l_ri(offs,m68k_pc_offset-m68k_pc_offset_thisinst-2);\n");
- comprintf("\tadd_l_ri(offs,(uintptr)comp_pc_p);\n"); /* New PC,
+ comprintf("\tadd_l_ri(offs,JITPTR comp_pc_p);\n"); /* New PC,
once the
offset_68k is
* also added */
/* memory save/restore code */
-uae_u8 *save_bootrom (int *len)
+uae_u8 *save_bootrom(size_t *len)
{
if (!uae_boot_rom_type)
return 0;
return rtarea_bank.baseaddr;
}
-uae_u8 *save_cram (int *len)
+uae_u8 *save_cram(size_t *len)
{
*len = chipmem_bank.allocated_size;
return chipmem_bank.baseaddr;
}
-uae_u8 *save_bram (int *len)
+uae_u8 *save_bram(size_t *len)
{
*len = bogomem_bank.allocated_size;
return bogomem_bank.baseaddr;
}
-static uae_u8 *save_mem25bitram (int *len)
+static uae_u8 *save_mem25bitram(size_t *len)
{
*len = mem25bit_bank.allocated_size;
return mem25bit_bank.baseaddr;
}
-uae_u8 *save_a3000lram (int *len)
+uae_u8 *save_a3000lram(size_t *len)
{
*len = a3000lmem_bank.allocated_size;
return a3000lmem_bank.baseaddr;
}
-uae_u8 *save_a3000hram (int *len)
+uae_u8 *save_a3000hram(size_t *len)
{
*len = a3000hmem_bank.allocated_size;
return a3000hmem_bank.baseaddr;
}
-void restore_bootrom (int len, size_t filepos)
+void restore_bootrom(int len, size_t filepos)
{
bootrom_filepos = filepos;
}
-void restore_cram (int len, size_t filepos)
+void restore_cram(int len, size_t filepos)
{
chip_filepos = filepos;
changed_prefs.chipmem.size = len;
}
-void restore_bram (int len, size_t filepos)
+void restore_bram(int len, size_t filepos)
{
bogo_filepos = filepos;
changed_prefs.bogomem.size = len;
}
-void restore_a3000lram (int len, size_t filepos)
+void restore_a3000lram(int len, size_t filepos)
{
a3000lmem_filepos = filepos;
changed_prefs.mbresmem_low.size = len;
}
-void restore_a3000hram (int len, size_t filepos)
+void restore_a3000hram(int len, size_t filepos)
{
a3000hmem_filepos = filepos;
changed_prefs.mbresmem_high.size = len;
}
-uae_u8 *restore_rom (uae_u8 *src)
+uae_u8 *restore_rom(uae_u8 *src)
{
uae_u32 crc32, mem_start, mem_size, mem_type, version;
TCHAR *s, *romn;
return src;
}
-uae_u8 *save_rom (int first, int *len, uae_u8 *dstptr)
+uae_u8 *save_rom(int first, size_t *len, uae_u8 *dstptr)
{
static int count;
uae_u8 *dst, *dstbak;
//activate_debugger ();
}
-uae_u8 *save_cpu_trace (int *len, uae_u8 *dstptr)
+uae_u8 *save_cpu_trace(size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
return dstbak;
}
-uae_u8 *restore_cpu_trace (uae_u8 *src)
+uae_u8 *restore_cpu_trace(uae_u8 *src)
{
cpu_tracer = 0;
cputrace.state = 0;
return src;
}
-uae_u8 *restore_cpu_extra (uae_u8 *src)
+uae_u8 *restore_cpu_extra(uae_u8 *src)
{
restore_u32 ();
uae_u32 flags = restore_u32 ();
return src;
}
-uae_u8 *save_cpu_extra (int *len, uae_u8 *dstptr)
+uae_u8 *save_cpu_extra(size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
uae_u32 flags;
return dstbak;
}
-uae_u8 *save_cpu (int *len, uae_u8 *dstptr)
+uae_u8 *save_cpu(size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
int model, khz;
return dstbak;
}
-uae_u8 *save_mmu (int *len, uae_u8 *dstptr)
+uae_u8 *save_mmu(size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
int model;
return dstbak;
}
-uae_u8 *restore_mmu (uae_u8 *src)
+uae_u8 *restore_mmu(uae_u8 *src)
{
int flags, model;
}
static void ShowCustomSmall(HWND hwnd)
{
- int len, i, j, cnt;
+ int i, j, cnt;
+ size_t len;
uae_u8 *p1, *p2, *p3, *p4;
TCHAR out[MAX_LINEWIDTH + 1];
{
int line = 0;
HWND hMisc;
- int len, i;
+ int i;
+ size_t len;
uae_u8 *p, *p2;
hMisc = GetDlgItem(hDbgWnd, IDC_DBG_MISC);
static void ShowCustom(void)
{
- int len, i, j, end;
+ int i, j, end;
+ size_t len;
uae_u8 *p1, *p2, *p3, *p4;
ULBSINIT(GetDlgItem(hDbgWnd, IDC_DBG_CUSTOM));
{
FILE *f;
uae_u8 tmp[4];
- int v;
+ size_t v;
f = _tfopen (name, _T("rb"));
if (!f)
{
TCHAR p1[MAX_DPATH];
TCHAR p2[MAX_DPATH];
- int len, cnt;
+ int cnt;
+ size_t len;
my_canonicalize_path(path1, p1, sizeof p1 / sizeof (TCHAR));
my_canonicalize_path(path2, p2, sizeof p2 / sizeof (TCHAR));
static TCHAR *make_uaefsdbpath (const TCHAR *dir, const TCHAR *name)
{
- int len;
+ size_t len;
TCHAR *p;
len = _tcslen (dir) + 1 + 1;
/* Return nonzero for any name we can't create on the native filesystem. */
static int fsdb_name_invalid_2x (const TCHAR *n, int dir)
{
- int i;
+ size_t i;
static char s1[MAX_DPATH];
static WCHAR s2[MAX_DPATH];
TCHAR a = n[0];
TCHAR b = (a == '\0' ? a : n[1]);
TCHAR c = (b == '\0' ? b : n[2]);
TCHAR d = (c == '\0' ? c : n[3]);
- int l = _tcslen (n), ll;
+ size_t l = _tcslen(n);
+ int ll;
/* the reserved fsdb filename */
if (_tcscmp (n, FSDB_FILE) == 0)
static void checkhdname(struct uae_driveinfo *udi)
{
int cnt = 1;
- int off = _tcslen(udi->device_name);
+ size_t off = _tcslen(udi->device_name);
TCHAR tmp[MAX_DPATH];
_tcscpy(tmp, udi->device_name);
udi->device_name[0] = 0;
}
zfile_fseek(zf, 0, SEEK_SET);
for (;;) {
- int count = zfile_fread(mp3buf, 1, MP3_BLOCK_SIZE, zf);
+ size_t count = zfile_fread(mp3buf, 1, MP3_BLOCK_SIZE, zf);
if (count != MP3_BLOCK_SIZE)
break;
// convert the data
return src;
}
-uae_u8 *save_p96 (int *len, uae_u8 *dstptr)
+uae_u8 *save_p96 (size_t *len, uae_u8 *dstptr)
{
struct amigadisplay *ad = &adisplays[0];
struct picasso96_state_struct *state = &picasso96_state[0];
static void trimws (TCHAR *s)
{
/* Delete trailing whitespace. */
- int len = _tcslen (s);
+ size_t len = _tcslen (s);
while (len > 0 && _tcscspn (s + len - 1, _T("\t \r\n")) == 0)
s[--len] = '\0';
}
{
int num = HIBYTE(wParam);
int cat = LOBYTE(wParam);
- uae_u32 mask = lParam;
+ uae_u32 mask = (uae_u32)lParam;
write_log(_T("DEVICEACTIVITY %04x %08x (%d,%d)\n"), wParam, lParam, num, cat);
if (cat != RP_DEVICECATEGORY_INPUTPORT && cat != RP_DEVICECATEGORY_MULTITAPPORT) {
write_log(_T("DEVICEACTIVITY Not RP_DEVICECATEGORY_INPUTPORT or RP_DEVICECATEGORY_MULTITAPPORT.\n"));
struct extoverlay eo = { 0 };
if (!D3D_extoverlay)
return 0;
- eo.idx = wParam;
+ eo.idx = (int)wParam;
eo.xpos = LOWORD(lParam);
eo.ypos = HIWORD(lParam);
int ret = D3D_extoverlay(&eo);
if (!D3D_extoverlay)
return 0;
delayed_refresh = gett();
- eo.idx = wParam;
+ eo.idx = (int)wParam;
eo.width = -1;
eo.height = -1;
return D3D_extoverlay(&eo);
rp_mouse ();
}
-void rp_activate (int active, LPARAM lParam)
+void rp_activate (WPARAM active, LPARAM lParam)
{
if (!cando ())
return;
extern int rp_close (void);
extern void rp_fixup_options (struct uae_prefs*);
extern void rp_pause (int paused);
-extern void rp_activate (int, LPARAM);
+extern void rp_activate (WPARAM, LPARAM);
extern void rp_mouse_capture (int);
extern void rp_mouse_magic (int);
extern void rp_turbo_cpu (int);
screenshot_free();
}
-uae_u8 *save_screenshot(int monid, int *len)
+uae_u8 *save_screenshot(int monid, size_t *len)
{
#if 0
struct amigadisplay *ad = &adisplays[monid];
case ENET_EVENT_TYPE_RECEIVE:
{
uae_u8 *p = evt.packet->data;
- int len = evt.packet->dataLength;
+ size_t len = evt.packet->dataLength;
if (len == 6 && !memcmp (p, "UAE_", 4)) {
if (((enet_receive_off_w + 1) & 0xff) != enet_receive_off_r) {
enet_receive[enet_receive_off_w++] = (p[4] << 8) | p[5];
WCHAR *au_fs (const char *s)
{
- int i, len;
+ size_t i, len;
WCHAR *d;
len = strlen (s);
}
#endif
-static void resizing(struct AmigaMonitor *mon, int mode, RECT *r)
+static void resizing(struct AmigaMonitor *mon, WPARAM mode, RECT *r)
{
int nw = (r->right - r->left) + mon->ratio_adjust_x;
int nh = (r->bottom - r->top) + mon->ratio_adjust_y;
debugfile = 0;
}
-uae_u8 *save_log (int bootlog, int *len)
+uae_u8 *save_log(int bootlog, size_t *len)
{
FILE *f;
uae_u8 *dst = NULL;
MINIDUMP_USER_STREAM_INFORMATION musi, *musip;
MINIDUMP_USER_STREAM mus[3], *musp;
uae_u8 *log;
- int len;
+ size_t len;
musip = NULL;
musi.UserStreamArray = mus;
}
static void saveconfig (FILE *f)
{
- int len;
+ size_t len;
uae_u8 *s;
s = save_configuration (&len, true);
}
static void zipconfig(const char *name, zipFile zf)
{
- int len;
+ size_t len;
uae_u8 *s;
zip_fileinfo zi;
HMENU hMenu; /* Dialog menu */
UINT xBaseUnit; /* Dialog units (depends on the font) */
UINT yBaseUnit;
- INT idResult; /* EndDialog() result / default pushbutton ID */
+ LONG_PTR idResult; /* EndDialog() result / default pushbutton ID */
UINT flags; /* EndDialog() called for this dialog */
} DIALOGINFO;
for (int i = 0; i < nr->setparamcnt; i++) {
HWND hwnd = GetDlgItem(hDlg, nr->setparam_id[i]);
if (hwnd) {
- int v = SendMessage(hwnd, CB_GETITEMHEIGHT, -1, NULL);
+ int v = (int)SendMessage(hwnd, CB_GETITEMHEIGHT, -1, NULL);
if (v > 0 && mmy(v) > v)
SendMessage(hwnd, CB_SETITEMHEIGHT, -1, mmy(v));
}
* format independent of host machine's endianness */
static uae_u8 *storepos;
-void save_store_pos_func (uae_u8 **dstp)
+void save_store_pos_func(uae_u8 **dstp)
{
storepos = *dstp;
*dstp += 4;
}
-void save_store_size_func (uae_u8 **dstp)
+void save_store_size_func(uae_u8 **dstp)
{
uae_u8 *p = storepos;
- save_u32_func (&p, *dstp - storepos);
+ save_u32t_func(&p, *dstp - storepos);
}
-void restore_store_pos_func (uae_u8 **srcp)
+void restore_store_pos_func(uae_u8 **srcp)
{
storepos = *srcp;
*srcp += 4;
}
-void restore_store_size_func (uae_u8 **srcp)
+void restore_store_size_func(uae_u8 **srcp)
{
uae_u8 *p = storepos;
uae_u32 len = restore_u32_func (&p);
*srcp = storepos + len;
}
-void save_u32_func (uae_u8 **dstp, uae_u32 v)
+void save_u32t_func(uae_u8** dstp, size_t vv)
+{
+ uae_u32 v = (uae_u32)vv;
+ uae_u8* dst = *dstp;
+ *dst++ = (uae_u8)(v >> 24);
+ *dst++ = (uae_u8)(v >> 16);
+ *dst++ = (uae_u8)(v >> 8);
+ *dst++ = (uae_u8)(v >> 0);
+ *dstp = dst;
+}
+void save_u32_func(uae_u8 **dstp, uae_u32 v)
{
uae_u8 *dst = *dstp;
*dst++ = (uae_u8)(v >> 24);
*dst++ = (uae_u8)(v >> 0);
*dstp = dst;
}
-void save_u64_func (uae_u8 **dstp, uae_u64 v)
+void save_u64_func(uae_u8 **dstp, uae_u64 v)
{
save_u32_func (dstp, (uae_u32)(v >> 32));
save_u32_func (dstp, (uae_u32)v);
}
-void save_u16_func (uae_u8 **dstp, uae_u16 v)
+void save_u16_func(uae_u8 **dstp, uae_u16 v)
{
uae_u8 *dst = *dstp;
*dst++ = (uae_u8)(v >> 8);
*dst++ = (uae_u8)(v >> 0);
*dstp = dst;
}
-void save_u8_func (uae_u8 **dstp, uae_u8 v)
+void save_u8_func(uae_u8 **dstp, uae_u8 v)
{
uae_u8 *dst = *dstp;
*dst++ = v;
/* read and write IFF-style hunks */
-static void save_chunk (struct zfile *f, uae_u8 *chunk, unsigned int len, const TCHAR *name, int compress)
+static void save_chunk (struct zfile *f, uae_u8 *chunk, size_t len, const TCHAR *name, int compress)
{
uae_u8 tmp[8], *dst;
uae_u8 zero[4]= { 0, 0, 0, 0 };
uae_u32 flags;
- unsigned int pos;
- unsigned int chunklen, len2;
+ size_t pos;
+ size_t chunklen, len2;
char *s;
if (!chunk)
/* chunk size */
dst = &tmp[0];
chunklen = len + 4 + 4 + 4;
- save_u32 (chunklen);
+ save_u32t(chunklen);
zfile_fwrite (&tmp[0], 1, 4, f);
/* chunk flags */
flags = 0;
dst = &tmp[0];
- save_u32 (flags | compress);
+ save_u32(flags | compress);
zfile_fwrite (&tmp[0], 1, 4, f);
/* chunk data */
if (compress) {
- int tmplen = len;
+ size_t tmplen = len;
size_t opos;
dst = &tmp[0];
- save_u32 (len);
+ save_u32t(len);
opos = zfile_ftell32(f);
- zfile_fwrite (&tmp[0], 1, 4, f);
- len = zfile_zcompress (f, chunk, len);
+ zfile_fwrite(&tmp[0], 1, 4, f);
+ len = zfile_zcompress(f, chunk, len);
if (len > 0) {
zfile_fseek (f, pos, SEEK_SET);
dst = &tmp[0];
- save_u32 (len + 4 + 4 + 4 + 4);
+ save_u32t(len + 4 + 4 + 4 + 4);
zfile_fwrite (&tmp[0], 1, 4, f);
zfile_fseek (f, 0, SEEK_END);
} else {
static void save_rams (struct zfile *f, int comp)
{
uae_u8 *dst;
- int len;
+ size_t len;
dst = save_cram (&len);
save_chunk (f, dst, len, _T("CRAM"), comp);
TCHAR tmp[100];
uae_u8 *dst;
TCHAR name[5];
- int i, len;
+ int i;
+ size_t len;
write_log (_T("STATESAVE (%s):\n"), f ? zfile_getname (f) : _T("<internal>"));
dst = header;
pos = zfile_ftell32(f);
save_rams (f, -1);
if (savestate_specialdump == 2) {
- int len, len2, i;
+ size_t len, len2, i;
uae_u8 *tmp;
len = zfile_ftell32(f) - pos;
tmp = xmalloc (uae_u8, len);
void savestate_rewind (void)
{
- int len, i, dummy;
+ int len, i;
uae_u8 *p, *p2;
struct staterecord *st;
int pos;
bool rewind = false;
+ size_t dummy;
if (hsync_counter % currprefs.statecapturerate <= 25 && rewindmode <= -2) {
pos = replaycounter - 2;
#define BS 10000
-STATIC_INLINE int bufcheck (struct staterecord *sr, uae_u8 *p, int len)
+STATIC_INLINE int bufcheck(struct staterecord *sr, uae_u8 *p, size_t len)
{
if (p - sr->data + BS + len >= sr->len)
return 1;
void savestate_capture (int force)
{
uae_u8 *p, *p2, *p3, *dst;
- int i, len, tlen, retrycnt;
+ size_t len, tlen;
+ int i, retrycnt;
struct staterecord *st;
bool firstcapture = false;
for (i = 0; i < 8; i++) {
if (bufcheck (st, p, 0))
goto retry;
- save_custom_sprite (i, &len, p);
+ save_custom_sprite(i, &len, p);
tlen += len;
p += len;
}
p += len;
}
- if (bufcheck (st, p, len))
+ if (bufcheck(st, p, len))
goto retry;
save_cia (0, &len, p);
tlen += len;
p += len;
- if (bufcheck (st, p, len))
+ if (bufcheck(st, p, len))
goto retry;
save_cia (1, &len, p);
tlen += len;
p += len;
- if (bufcheck (st, p, len))
+ if (bufcheck(st, p, len))
goto retry;
save_keyboard (&len, p);
tlen += len;
p += len;
- if (bufcheck (st, p, len))
+ if (bufcheck(st, p, len))
goto retry;
save_inputstate (&len, p);
tlen += len;
}
#endif
- dst = save_cram (&len);
- if (bufcheck (st, p, len))
+ dst = save_cram(&len);
+ if (bufcheck(st, p, len))
goto retry;
- save_u32_func (&p, len);
- memcpy (p, dst, len);
+ save_u32t_func(&p, len);
+ memcpy(p, dst, len);
tlen += len + 4;
p += len;
- dst = save_bram (&len);
- if (bufcheck (st, p, len))
+ dst = save_bram(&len);
+ if (bufcheck(st, p, len))
goto retry;
- save_u32_func (&p, len);
- memcpy (p, dst, len);
+ save_u32t_func(&p, len);
+ memcpy(p, dst, len);
tlen += len + 4;
p += len;
#ifdef AUTOCONFIG
- dst = save_fram (&len, 0);
- if (bufcheck (st, p, len))
+ dst = save_fram(&len, 0);
+ if (bufcheck(st, p, len))
goto retry;
- save_u32_func (&p, len);
- memcpy (p, dst, len);
+ save_u32t_func(&p, len);
+ memcpy(p, dst, len);
tlen += len + 4;
p += len;
- dst = save_zram (&len, 0);
- if (bufcheck (st, p, len))
+ dst = save_zram(&len, 0);
+ if (bufcheck(st, p, len))
goto retry;
- save_u32_func (&p, len);
- memcpy (p, dst, len);
+ save_u32t_func(&p, len);
+ memcpy(p, dst, len);
tlen += len + 4;
p += len;
#endif
p += len;
}
}
- save_u32_func (&p, tlen);
+ save_u32t_func(&p, tlen);
st->end = p;
st->inuse = 1;
st->inprecoffset = inprec_getposition ();
dev_reset ();
}
-uae_u8 *save_scsidev (int num, int *len, uae_u8 *dstptr)
+uae_u8 *save_scsidev (int num, size_t *len, uae_u8 *dstptr)
{
uae_u8 *dstbak, *dst;
struct priv_devstruct *pdev;
struct png_cb
{
uae_u8 *ptr;
- int size;
+ size_t size;
};
static void __cdecl readcallback(png_structp png_ptr, png_bytep out, png_size_t count)
volatile bool trap_done;
uae_u32 calllib_regs[16];
uae_u8 calllib_reg_inuse[16];
- int tindex;
+ size_t tindex;
int tcnt;
TRAP_CALLBACK callback;
void *callback_ud;
static void hardware_trap_thread(void *arg)
{
- int tid = (uae_u32)arg;
+ size_t tid = (size_t)arg;
for (;;) {
TrapContext *ctx = (TrapContext*)read_comm_pipe_pvoid_blocking(&trap_thread_pipe[tid]);
if (!ctx)
}
/* dump file use only */
-uae_u8 *zfile_get_data_pointer(struct zfile *z, int *len)
+uae_u8 *zfile_get_data_pointer(struct zfile *z, size_t *len)
{
if (!z->data)
return NULL;
- *len = (int)z->size;
+ *len = z->size;
return z->data;
}
return 0;
}
-int zfile_zcompress (struct zfile *f, void *src, int size)
+int zfile_zcompress(struct zfile *f, void *src, size_t size)
{
int v;
z_stream zs;
projects / francis / winuae.git / commitdiff