Many casts added to the core files, and various other tweaks

to make them compile as either C or C++.

src/build/file2str.c

@@ -59,7 +59,7 @@ int main(int argc, char *argv[])
 	fseek(src, 0, SEEK_SET);
 
 	/* allocate memory */
-	buffer = malloc(bytes + 1);
+	buffer = (unsigned char *)malloc(bytes + 1);
 	if (buffer == NULL)
 	{
 		fprintf(stderr, "Out of memory allocating %d byte buffer\n", bytes);

src/build/png2bdc.c

@@ -128,10 +128,10 @@ static int render_font_save_cached(render_font *font, const char *filename, UINT
 			numchars++;
 
 	/* allocate an array to hold the character data */
-	chartable = malloc(numchars * CACHED_CHAR_SIZE);
+	chartable = (UINT8 *)malloc(numchars * CACHED_CHAR_SIZE);
 
 	/* allocate a temp buffer to compress into */
-	tempbuffer = malloc(65536);
+	tempbuffer = (UINT8 *)malloc(65536);
 	if (chartable == NULL || tempbuffer == NULL)
 		goto error;
 
@@ -405,7 +405,7 @@ int main(int argc, char *argv[])
     bdcname = argv[argc - 1];
 
 	/* allocate a font */
-	font = malloc(sizeof(*font));
+	font = (render_font *)malloc(sizeof(*font));
 	if (font == NULL)
 		return 1;
 	memset(font, 0, sizeof(*font));

src/build/verinfo.c

@@ -233,7 +233,7 @@ int main(int argc, char *argv[])
 	fseek(f, 0, SEEK_SET);
 
 	// allocate a buffer
-	buffer = malloc(size + 1);
+	buffer = (char *)malloc(size + 1);
 	if (buffer == NULL)
 	{
 		fclose(f);

src/emu/audit.c

@@ -82,7 +82,7 @@ int audit_images(core_options *options, const game_driver *gamedrv, UINT32 valid
 	if (records > 0)
 	{
 		/* allocate memory for the records */
-		*audit = malloc_or_die(sizeof(**audit) * records);
+		*audit = (audit_record *)malloc_or_die(sizeof(**audit) * records);
 		memset(*audit, 0, sizeof(**audit) * records);
 		record = *audit;
 
@@ -163,7 +163,7 @@ int audit_samples(core_options *options, const game_driver *gamedrv, audit_recor
 		goto skip;
 
 	/* allocate memory for the records */
-	*audit = malloc_or_die(sizeof(**audit) * records);
+	*audit = (audit_record *)malloc_or_die(sizeof(**audit) * records);
 	memset(*audit, 0, sizeof(**audit) * records);
 	record = *audit;
 

src/emu/cheat.c

@@ -82,6 +82,7 @@ enum _script_state
 	SCRIPT_STATE_COUNT
 };
 typedef enum _script_state script_state;
+DECLARE_ENUM_OPERATORS(script_state)
 
 
 
@@ -265,7 +266,7 @@ void cheat_init(running_machine *machine)
 	add_exit_callback(machine, cheat_exit);
 
 	/* allocate memory */
-	cheatinfo = auto_malloc(sizeof(*cheatinfo));
+	cheatinfo = (cheat_private *)auto_malloc(sizeof(*cheatinfo));
 	memset(cheatinfo, 0, sizeof(*cheatinfo));
 	machine->cheat_data = cheatinfo;
 
@@ -343,7 +344,7 @@ void cheat_render_text(running_machine *machine)
 void *cheat_get_next_menu_entry(running_machine *machine, void *previous, const char **description, const char **state, UINT32 *flags)
 {
 	cheat_private *cheatinfo = machine->cheat_data;
-	cheat_entry *preventry = previous;
+	cheat_entry *preventry = (cheat_entry *)previous;
 	cheat_entry *cheat;
 
 	/* NULL previous means get the first */
@@ -455,7 +456,7 @@ void *cheat_get_next_menu_entry(running_machine *machine, void *previous, const
 int cheat_activate(running_machine *machine, void *entry)
 {
 	cheat_private *cheatinfo = machine->cheat_data;
-	cheat_entry *cheat = entry;
+	cheat_entry *cheat = (cheat_entry *)entry;
 	int changed = FALSE;
 
 	/* if we have no parameter and no run or off script, but we do have an on script, it's a oneshot cheat */
@@ -479,7 +480,7 @@ int cheat_activate(running_machine *machine, void *entry)
 int cheat_select_default_state(running_machine *machine, void *entry)
 {
 	cheat_private *cheatinfo = machine->cheat_data;
-	cheat_entry *cheat = entry;
+	cheat_entry *cheat = (cheat_entry *)entry;
 	int changed = FALSE;
 
 	/* if we have no parameter and no run or off script, it's either text or a oneshot cheat */
@@ -508,7 +509,7 @@ int cheat_select_default_state(running_machine *machine, void *entry)
 int cheat_select_previous_state(running_machine *machine, void *entry)
 {
 	cheat_private *cheatinfo = machine->cheat_data;
-	cheat_entry *cheat = entry;
+	cheat_entry *cheat = (cheat_entry *)entry;
 	int changed = FALSE;
 
 	/* if we have no parameter and no run or off script, it's either text or a oneshot cheat */
@@ -584,7 +585,7 @@ int cheat_select_previous_state(running_machine *machine, void *entry)
 int cheat_select_next_state(running_machine *machine, void *entry)
 {
 	cheat_private *cheatinfo = machine->cheat_data;
-	cheat_entry *cheat = entry;
+	cheat_entry *cheat = (cheat_entry *)entry;
 	int changed = FALSE;
 
 	/* if we have no parameter and no run or off script, it's a oneshot cheat */
@@ -937,7 +938,7 @@ static cheat_entry *cheat_entry_load(running_machine *machine, const char *filen
 	}
 
 	/* allocate memory for the cheat */
-	cheat = malloc_or_die(sizeof(*cheat) + (tempcount - 1) * sizeof(cheat->tempvar));
+	cheat = (cheat_entry *)malloc_or_die(sizeof(*cheat) + (tempcount - 1) * sizeof(cheat->tempvar));
 	memset(cheat, 0, sizeof(*cheat) + (tempcount - 1) * sizeof(cheat->tempvar));
 	cheat->numtemp = tempcount;
 
@@ -1108,7 +1109,7 @@ static cheat_parameter *cheat_parameter_load(const char *filename, xml_data_node
 	cheat_parameter *param;
 
 	/* allocate memory for it */
-	param = malloc_or_die(sizeof(*param));
+	param = (cheat_parameter *)malloc_or_die(sizeof(*param));
 	memset(param, 0, sizeof(*param));
 
 	/* read the core attributes */
@@ -1126,7 +1127,7 @@ static cheat_parameter *cheat_parameter_load(const char *filename, xml_data_node
 		parameter_item *curitem;
 
 		/* allocate memory for it */
-		curitem = malloc_or_die(sizeof(*curitem));
+		curitem = (parameter_item *)malloc_or_die(sizeof(*curitem));
 		memset(curitem, 0, sizeof(*curitem));
 
 		/* check for NULL text */
@@ -1237,7 +1238,7 @@ static cheat_script *cheat_script_load(running_machine *machine, const char *fil
 	const char *state;
 
 	/* allocate memory for it */
-	script = malloc_or_die(sizeof(*script));
+	script = (cheat_script *)malloc_or_die(sizeof(*script));
 	memset(script, 0, sizeof(*script));
 
 	/* read the core attributes */
@@ -1352,7 +1353,7 @@ static script_entry *script_entry_load(running_machine *machine, const char *fil
 	EXPRERR experr;
 
 	/* allocate memory for it */
-	entry = malloc_or_die(sizeof(*entry));
+	entry = (script_entry *)malloc_or_die(sizeof(*entry));
 	memset(entry, 0, sizeof(*entry));
 
 	/* read the condition if present */
@@ -1422,7 +1423,7 @@ static script_entry *script_entry_load(running_machine *machine, const char *fil
 			output_argument *curarg;
 
 			/* allocate memory for it */
-			curarg = malloc_or_die(sizeof(*curarg));
+			curarg = (output_argument *)malloc_or_die(sizeof(*curarg));
 			memset(curarg, 0, sizeof(*curarg));
 
 			/* first extract attributes */

src/emu/clifront.c

@@ -440,7 +440,7 @@ int cli_info_listclones(core_options *options, const char *gamename)
 
 int cli_info_listbrothers(core_options *options, const char *gamename)
 {
-	UINT8 *didit = malloc_or_die(driver_list_get_count(drivers));
+	UINT8 *didit = (UINT8 *)malloc_or_die(driver_list_get_count(drivers));
 	astring *filename = astring_alloc();
 	int drvindex, count = 0;
 
@@ -954,7 +954,7 @@ static void identify_data(const char *name, const UINT8 *data, int length, romid
 	{
 		/* now determine the new data length and allocate temporary memory for it */
 		length = jedbin_output(&jed, NULL, 0);
-		tempjed = malloc(length);
+		tempjed = (UINT8 *)malloc(length);
 		if (tempjed == NULL)
 			return;
 

src/emu/config.c

@@ -92,7 +92,7 @@ void config_register(running_machine *machine, const char *nodename, config_call
 	config_type **ptype;
 
 	/* allocate a new type */
-	newtype = auto_malloc(sizeof(*newtype));
+	newtype = (config_type *)auto_malloc(sizeof(*newtype));
 	newtype->next = NULL;
 	newtype->name = nodename;
 	newtype->load = load;

src/emu/cpu/e132xs/e132xs.c

@@ -631,7 +631,7 @@ static void adjust_timer_interrupt(hyperstone_state *cpustate)
 
 static TIMER_CALLBACK( e132xs_timer_callback )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	hyperstone_state *cpustate = device->token;
 	int update = param;
 

src/emu/cpu/m68000/m68kmake.c

@@ -808,7 +808,7 @@ static void add_opcode_output_table_entry(opcode_struct* op, char* name)
  */
 static int DECL_SPEC compare_nof_true_bits(const void* aptr, const void* bptr)
 {
-	const opcode_struct *a = aptr, *b = bptr;
+	const opcode_struct *a = (const opcode_struct *)aptr, *b = (const opcode_struct *)bptr;
 	if(a->bits != b->bits)
 		return a->bits - b->bits;
 	if(a->op_mask != b->op_mask)
@@ -863,7 +863,7 @@ static void set_opcode_struct(opcode_struct* src, opcode_struct* dst, int ea_mod
 static void generate_opcode_handler(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* opinfo, int ea_mode)
 {
 	char str[MAX_LINE_LENGTH+1];
-	opcode_struct* op = malloc(sizeof(opcode_struct));
+	opcode_struct* op = (opcode_struct *)malloc(sizeof(opcode_struct));
 
 	/* Set the opcode structure and write the tables, prototypes, etc */
 	set_opcode_struct(opinfo, op, ea_mode);
@@ -956,7 +956,7 @@ static void generate_opcode_cc_variants(FILE* filep, body_struct* body, replace_
 	char replnot[20];
 	int i;
 	int old_length = replace->length;
-	opcode_struct* op = malloc(sizeof(opcode_struct));
+	opcode_struct* op = (opcode_struct *)malloc(sizeof(opcode_struct));
 
 	*op = *op_in;
 
@@ -995,8 +995,8 @@ static void process_opcode_handlers(FILE* filep)
 	char oper_spec_proc[MAX_LINE_LENGTH+1];
 	char oper_spec_ea[MAX_LINE_LENGTH+1];
 	opcode_struct* opinfo;
-	replace_struct* replace = malloc(sizeof(replace_struct));
+	replace_struct* replace = (replace_struct*)malloc(sizeof(replace_struct));
-	body_struct* body = malloc(sizeof(body_struct));
+	body_struct* body = (body_struct*)malloc(sizeof(body_struct));
 
 	for(;;)
 	{

src/emu/cpu/mcs48/mcs48.c

@@ -1192,7 +1192,7 @@ UINT8 upi41_master_r(const device_config *device, UINT8 a0)
 
 static TIMER_CALLBACK( master_callback )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	mcs48_state *cpustate = device->token;
 	UINT8 a0 = (param >> 8) & 1;
 	UINT8 data = param;

src/emu/cpu/mips/mips3com.c

@@ -706,7 +706,7 @@ void mips3com_get_info(mips3_state *mips, UINT32 state, cpuinfo *info)
 
 static TIMER_CALLBACK( compare_int_callback )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	cpu_set_input_line(device, MIPS3_IRQ5, ASSERT_LINE);
 }
 

src/emu/cpu/tms57002/tmsmake.c

@@ -101,7 +101,7 @@ static char *sconcat(char *dest, const char *src)
   char *r;
   int len = strlen(src);
   int pos = dest ? strlen(dest) : 0;
-  r = realloc(dest, pos+len+2);
+  r = (char *)realloc(dest, pos+len+2);
   memcpy(r + pos, src, len);
   r[pos+len] = '\n';
   r[pos+len+1] = 0;

src/emu/cpuexec.c

@@ -223,7 +223,7 @@ void cpuexec_init(running_machine *machine)
 	attotime min_quantum;
 
 	/* allocate global state */
-	machine->cpuexec_data = auto_malloc(sizeof(*machine->cpuexec_data));
+	machine->cpuexec_data = (cpuexec_private *)auto_malloc(sizeof(*machine->cpuexec_data));
 	memset(machine->cpuexec_data, 0, sizeof(*machine->cpuexec_data));
 
 	/* set the core scheduling quantum */
@@ -457,7 +457,7 @@ static DEVICE_START( cpu )
 	assert(device->machine->config != NULL);
 
 	/* get pointers to our data */
-	config = device->inline_config;
+	config = (const cpu_config *)device->inline_config;
 	header = cpu_get_class_header(device);
 	classdata = get_class_data(device);
 
@@ -553,7 +553,7 @@ static DEVICE_START( cpu )
 static DEVICE_RESET( cpu )
 {
 	cpu_class_data *classdata = get_class_data(device);
-	const cpu_config *config = device->inline_config;
+	const cpu_config *config = (const cpu_config *)device->inline_config;
 	cpu_reset_func reset;
 	int line;
 
@@ -685,7 +685,7 @@ static DEVICE_SET_INFO( cpu )
 
 DEVICE_GET_INFO( cpu )
 {
-	const cpu_config *config = (device != NULL) ? device->inline_config : NULL;
+	const cpu_config *config = (device != NULL) ? (const cpu_config *)device->inline_config : NULL;
 	cpuinfo cinfo = { 0 };
 
 	switch (state)
@@ -1363,7 +1363,7 @@ static void on_vblank(const device_config *device, void *param, int vblank_state
 		/* find any CPUs that have this screen as their VBLANK interrupt source */
 		for (cpu = device->machine->cpu[0]; cpu != NULL; cpu = cpu->typenext)
 		{
-			const cpu_config *config = cpu->inline_config;
+			const cpu_config *config = (const cpu_config *)cpu->inline_config;
 			cpu_class_data *classdata = get_class_data(cpu);
 			int cpu_interested;
 
@@ -1410,8 +1410,8 @@ static void on_vblank(const device_config *device, void *param, int vblank_state
 
 static TIMER_CALLBACK( trigger_partial_frame_interrupt )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
-	const cpu_config *config = device->inline_config;
+	const cpu_config *config = (const cpu_config *)device->inline_config;
 	cpu_class_data *classdata = get_class_data(device);
 
 	if (classdata->iloops == 0)
@@ -1436,8 +1436,8 @@ static TIMER_CALLBACK( trigger_partial_frame_interrupt )
 
 static TIMER_CALLBACK( trigger_periodic_interrupt )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
-	const cpu_config *config = device->inline_config;
+	const cpu_config *config = (const cpu_config *)device->inline_config;
 
 	/* bail if there is no routine */
 	if (config->timed_interrupt != NULL && !cpu_is_suspended(device, SUSPEND_REASON_HALT | SUSPEND_REASON_RESET | SUSPEND_REASON_DISABLE))
@@ -1462,7 +1462,7 @@ static TIMER_CALLBACK( triggertime_callback )
 
 static TIMER_CALLBACK( empty_event_queue )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	cpu_class_data *classdata = get_class_data(device);
 	cpu_input_data *inputline = &classdata->input[param];
 	int curevent;

src/emu/debug/debugcmd.c

@@ -322,7 +322,7 @@ static UINT64 execute_if(void *globalref, void *ref, UINT32 params, const UINT64
 
 static UINT64 global_get(void *globalref, void *ref)
 {
-	global_entry *global = ref;
+	global_entry *global = (global_entry *)ref;
 	switch (global->size)
 	{
 		case 1:		return *(UINT8 *)global->base;
@@ -340,7 +340,7 @@ static UINT64 global_get(void *globalref, void *ref)
 
 static void global_set(void *globalref, void *ref, UINT64 value)
 {
-	global_entry *global = ref;
+	global_entry *global = (global_entry *)ref;
 	switch (global->size)
 	{
 		case 1:		*(UINT8 *)global->base = value;	break;

src/emu/debug/debugcon.c

@@ -404,7 +404,7 @@ void debug_console_register_command(running_machine *machine, const char *comman
 	assert_always(mame_get_phase(machine) == MAME_PHASE_INIT, "Can only call debug_console_register_command() at init time!");
 	assert_always((machine->debug_flags & DEBUG_FLAG_ENABLED) != 0, "Cannot call debug_console_register_command() when debugger is not running");
 
-	cmd = auto_malloc(sizeof(*cmd));
+	cmd = (debug_command *)auto_malloc(sizeof(*cmd));
 	memset(cmd, 0, sizeof(*cmd));
 
 	/* fill in the command */

src/emu/debug/debugcpu.c

@@ -158,7 +158,7 @@ void debug_cpu_init(running_machine *machine)
 	int regnum;
 
 	/* allocate and reset globals */
-	machine->debugcpu_data = global = auto_malloc(sizeof(*global));
+	machine->debugcpu_data = global = (debugcpu_private *)auto_malloc(sizeof(*global));
 	memset(global, 0, sizeof(*global));
 	global->execution_state = EXECUTION_STATE_STOPPED;
 	global->bpindex = 1;
@@ -190,7 +190,7 @@ void debug_cpu_init(running_machine *machine)
 		cpu_debug_data *info;
 
 		/* allocate some information */
-		info = auto_malloc(sizeof(*info));
+		info = (cpu_debug_data *)auto_malloc(sizeof(*info));
 		memset(info, 0, sizeof(*info));
 		classheader->debug = info;
 
@@ -983,7 +983,7 @@ int debug_cpu_breakpoint_set(const device_config *device, offs_t address, parsed
 	assert_always(device != NULL, "debug_cpu_breakpoint_set() called with invalid cpu!");
 
 	/* allocate breakpoint */
-	bp = malloc_or_die(sizeof(*bp));
+	bp = (debug_cpu_breakpoint *)malloc_or_die(sizeof(*bp));
 	bp->index = global->bpindex++;
 	bp->enabled = TRUE;
 	bp->address = address;
@@ -991,7 +991,7 @@ int debug_cpu_breakpoint_set(const device_config *device, offs_t address, parsed
 	bp->action = NULL;
 	if (action != NULL)
 	{
-		bp->action = malloc_or_die(strlen(action) + 1);
+		bp->action = (char *)malloc_or_die(strlen(action) + 1);
 		strcpy(bp->action, action);
 	}
 
@@ -1087,7 +1087,7 @@ int debug_cpu_watchpoint_set(const address_space *space, int type, offs_t addres
 {
 	debugcpu_private *global = space->machine->debugcpu_data;
 	cpu_debug_data *info = cpu_get_debug_data(space->cpu);
-	debug_cpu_watchpoint *wp = malloc_or_die(sizeof(*wp));
+	debug_cpu_watchpoint *wp = (debug_cpu_watchpoint *)malloc_or_die(sizeof(*wp));
 
 	/* fill in the structure */
 	wp->index = global->wpindex++;
@@ -1099,7 +1099,7 @@ int debug_cpu_watchpoint_set(const address_space *space, int type, offs_t addres
 	wp->action = NULL;
 	if (action != NULL)
 	{
-		wp->action = malloc_or_die(strlen(action) + 1);
+		wp->action = (char *)malloc_or_die(strlen(action) + 1);
 		strcpy(wp->action, action);
 	}
 
@@ -1245,7 +1245,7 @@ void debug_cpu_trace(const device_config *device, FILE *file, int trace_over, co
 	info->trace.trace_over_target = ~0;
 	if (action != NULL)
 	{
-		info->trace.action = malloc_or_die(strlen(action) + 1);
+		info->trace.action = (char *)malloc_or_die(strlen(action) + 1);
 		strcpy(info->trace.action, action);
 	}
 
@@ -1313,7 +1313,7 @@ int debug_cpu_hotspot_track(const device_config *device, int numspots, int thres
 	if (numspots > 0)
 	{
 		/* allocate memory for hotspots */
-		info->hotspots = malloc_or_die(sizeof(*info->hotspots) * numspots);
+		info->hotspots = (debug_hotspot_entry *)malloc_or_die(sizeof(*info->hotspots) * numspots);
 		memset(info->hotspots, 0xff, sizeof(*info->hotspots) * numspots);
 
 		/* fill in the info */
@@ -2429,7 +2429,7 @@ static const device_config *expression_cpu_index(running_machine *machine, const
 
 static UINT64 expression_read_memory(void *param, const char *name, int space, UINT32 address, int size)
 {
-	running_machine *machine = param;
+	running_machine *machine = (running_machine *)param;
 	const device_config *cpu = NULL;
 
 	switch (space)
@@ -2532,9 +2532,9 @@ static UINT64 expression_read_program_direct(const address_space *space, int opc
 
 			/* get the base of memory, aligned to the address minus the lowbits */
 			if (opcode & 1)
-				base = memory_decrypted_read_ptr(space, address & ~lowmask);
+				base = (UINT8 *)memory_decrypted_read_ptr(space, address & ~lowmask);
 			else
-				base = memory_get_read_ptr(space, address & ~lowmask);
+				base = (UINT8 *)memory_get_read_ptr(space, address & ~lowmask);
 
 			/* if we have a valid base, return the appropriate byte */
 			if (base != NULL)
@@ -2634,7 +2634,7 @@ static UINT64 expression_read_eeprom(running_machine *machine, offs_t address, i
 
 static void expression_write_memory(void *param, const char *name, int space, UINT32 address, int size, UINT64 data)
 {
-	running_machine *machine = param;
+	running_machine *machine = (running_machine *)param;
 	const device_config *cpu = NULL;
 
 	switch (space)
@@ -2743,9 +2743,9 @@ static void expression_write_program_direct(const address_space *space, int opco
 
 			/* get the base of memory, aligned to the address minus the lowbits */
 			if (opcode & 1)
-				base = memory_decrypted_read_ptr(space, address & ~lowmask);
+				base = (UINT8 *)memory_decrypted_read_ptr(space, address & ~lowmask);
 			else
-				base = memory_get_read_ptr(space, address & ~lowmask);
+				base = (UINT8 *)memory_get_read_ptr(space, address & ~lowmask);
 
 			/* if we have a valid base, write the appropriate byte */
 			if (base != NULL)
@@ -2866,7 +2866,7 @@ static void expression_write_eeprom(running_machine *machine, offs_t address, in
 
 static EXPRERR expression_validate(void *param, const char *name, int space)
 {
-	running_machine *machine = param;
+	running_machine *machine = (running_machine *)param;
 	const device_config *cpu = NULL;
 
 	switch (space)
@@ -2928,7 +2928,7 @@ static EXPRERR expression_validate(void *param, const char *name, int space)
 
 static UINT64 get_wpaddr(void *globalref, void *ref)
 {
-	running_machine *machine = globalref;
+	running_machine *machine = (running_machine *)globalref;
 	return machine->debugcpu_data->wpaddr;
 }
 
@@ -2940,7 +2940,7 @@ static UINT64 get_wpaddr(void *globalref, void *ref)
 
 static UINT64 get_wpdata(void *globalref, void *ref)
 {
-	running_machine *machine = globalref;
+	running_machine *machine = (running_machine *)globalref;
 	return machine->debugcpu_data->wpdata;
 }
 
@@ -2952,7 +2952,7 @@ static UINT64 get_wpdata(void *globalref, void *ref)
 
 static UINT64 get_cpunum(void *globalref, void *ref)
 {
-	running_machine *machine = globalref;
+	running_machine *machine = (running_machine *)globalref;
 	return cpu_get_index(machine->debugcpu_data->visiblecpu);
 }
 
@@ -2985,7 +2985,7 @@ static void set_tempvar(void *globalref, void *ref, UINT64 value)
 
 static UINT64 get_beamx(void *globalref, void *ref)
 {
-	const device_config *screen = ref;
+	const device_config *screen = (const device_config *)ref;
 	return (screen != NULL) ? video_screen_get_hpos(screen) : 0;
 }
 
@@ -2996,7 +2996,7 @@ static UINT64 get_beamx(void *globalref, void *ref)
 
 static UINT64 get_beamy(void *globalref, void *ref)
 {
-	const device_config *screen = ref;
+	const device_config *screen = (const device_config *)ref;
 	return (screen != NULL) ? video_screen_get_vpos(screen) : 0;
 }
 
@@ -3007,7 +3007,7 @@ static UINT64 get_beamy(void *globalref, void *ref)
 
 static UINT64 get_frame(void *globalref, void *ref)
 {
-	const device_config *screen = ref;
+	const device_config *screen = (const device_config *)ref;
 	return (screen != NULL) ? video_screen_get_frame_number(screen) : 0;
 }
 
@@ -3019,7 +3019,7 @@ static UINT64 get_frame(void *globalref, void *ref)
 
 static UINT64 get_current_pc(void *globalref, void *ref)
 {
-	const device_config *device = globalref;
+	const device_config *device = (const device_config *)globalref;
 	return cpu_get_pc(device);
 }
 
@@ -3031,7 +3031,7 @@ static UINT64 get_current_pc(void *globalref, void *ref)
 
 static UINT64 get_cycles(void *globalref, void *ref)
 {
-	const device_config *device = globalref;
+	const device_config *device = (const device_config *)globalref;
 	return *cpu_get_icount_ptr(device);
 }
 
@@ -3043,7 +3043,7 @@ static UINT64 get_cycles(void *globalref, void *ref)
 
 static UINT64 get_logunmap(void *globalref, void *ref)
 {
-	const address_space *space = ref;
+	const address_space *space = (const address_space *)ref;
 	return (space != NULL) ? memory_get_log_unmap(space) : TRUE;
 }
 
@@ -3055,7 +3055,7 @@ static UINT64 get_logunmap(void *globalref, void *ref)
 
 static void set_logunmap(void *globalref, void *ref, UINT64 value)
 {
-	const address_space *space = ref;
+	const address_space *space = (const address_space *)ref;
 	if (space != NULL)
 		memory_set_log_unmap(space, value ? 1 : 0);
 }
@@ -3068,7 +3068,7 @@ static void set_logunmap(void *globalref, void *ref, UINT64 value)
 
 static UINT64 get_cpu_reg(void *globalref, void *ref)
 {
-	const device_config *device = globalref;
+	const device_config *device = (const device_config *)globalref;
 	return cpu_get_reg(device, (FPTR)ref);
 }
 
@@ -3080,6 +3080,6 @@ static UINT64 get_cpu_reg(void *globalref, void *ref)
 
 static void set_cpu_reg(void *globalref, void *ref, UINT64 value)
 {
-	const device_config *device = globalref;
+	const device_config *device = (const device_config *)globalref;
 	cpu_set_reg(device, (FPTR)ref, value);
 }

src/emu/debug/debugvw.c

@@ -342,7 +342,7 @@ void debug_view_init(running_machine *machine)
 	debugvw_private *global;
 
 	/* allocate memory for our globals */
-	global = machine->debugvw_data = auto_malloc(sizeof(*machine->debugvw_data));
+	global = machine->debugvw_data = (debugvw_private *)auto_malloc(sizeof(*machine->debugvw_data));
 	memset(global, 0, sizeof(*global));
 
 	/* register for some manual cleanup */
@@ -387,7 +387,7 @@ debug_view *debug_view_alloc(running_machine *machine, int type, debug_view_osd_
 	assert(type >= 0 && type < ARRAY_LENGTH(callback_table));
 
 	/* allocate memory for the view */
-	view = malloc(sizeof(*view));
+	view = (debug_view *)malloc(sizeof(*view));
 	if (view == NULL)
 		return NULL;
 	memset(view, 0, sizeof(*view));
@@ -405,7 +405,7 @@ debug_view *debug_view_alloc(running_machine *machine, int type, debug_view_osd_
 
 	/* allocate memory for the buffer */
 	view->viewdata_size = view->visible.y * view->visible.x;
-	view->viewdata = malloc(sizeof(view->viewdata[0]) * view->viewdata_size);
+	view->viewdata = (debug_view_char *)malloc(sizeof(view->viewdata[0]) * view->viewdata_size);
 	if (view->viewdata == NULL)
 	{
 		free(view);
@@ -499,7 +499,7 @@ void debug_view_end_update(debug_view *view)
 			if (size > view->viewdata_size)
 			{
 				view->viewdata_size = size;
-				view->viewdata = realloc(view->viewdata, sizeof(view->viewdata[0]) * view->viewdata_size);
+				view->viewdata = (debug_view_char *)realloc(view->viewdata, sizeof(view->viewdata[0]) * view->viewdata_size);
 			}
 
 			/* update the view */
@@ -908,7 +908,7 @@ static int textbuf_view_alloc(debug_view *view, text_buffer *textbuf)
 	debug_view_textbuf *textdata;
 
 	/* allocate memory */
-	textdata = malloc(sizeof(*textdata));
+	textdata = (debug_view_textbuf *)malloc(sizeof(*textdata));
 	if (textdata == NULL)
 		return FALSE;
 	memset(textdata, 0, sizeof(*textdata));
@@ -930,7 +930,7 @@ static int textbuf_view_alloc(debug_view *view, text_buffer *textbuf)
 
 static void textbuf_view_free(debug_view *view)
 {
-	debug_view_textbuf *textdata = view->extra_data;
+	debug_view_textbuf *textdata = (debug_view_textbuf *)view->extra_data;
 
 	/* free any memory we callocated */
 	if (textdata != NULL)
@@ -946,7 +946,7 @@ static void textbuf_view_free(debug_view *view)
 
 static void textbuf_view_update(debug_view *view)
 {
-	debug_view_textbuf *textdata = view->extra_data;
+	debug_view_textbuf *textdata = (debug_view_textbuf *)view->extra_data;
 	debug_view_char *dest = view->viewdata;
 	UINT32 curseq = 0, row;
 
@@ -1014,7 +1014,7 @@ static void textbuf_view_update(debug_view *view)
 
 static void textbuf_view_notify(debug_view *view, view_notification type)
 {
-	debug_view_textbuf *textdata = view->extra_data;
+	debug_view_textbuf *textdata = (debug_view_textbuf *)view->extra_data;
 
 	if (type == VIEW_NOTIFY_VISIBLE_CHANGED)
 	{
@@ -1053,7 +1053,7 @@ static const registers_subview_item *registers_view_enumerate_subviews(running_m
 
 		/* determine the string and allocate a subview large enough */
 		astring_printf(tempstring, "CPU '%s' (%s)", cpu->tag, cpu_get_name(cpu));
-		subview = auto_malloc(sizeof(*subview) + astring_len(tempstring));
+		subview = (registers_subview_item *)auto_malloc(sizeof(*subview) + astring_len(tempstring));
 		memset(subview, 0, sizeof(*subview));
 
 		/* populate the subview */
@@ -1087,7 +1087,7 @@ static int registers_view_alloc(debug_view *view)
 		return FALSE;
 
 	/* allocate memory */
-	regdata = malloc(sizeof(*regdata));
+	regdata = (debug_view_registers *)malloc(sizeof(*regdata));
 	if (regdata == NULL)
 		return FALSE;
 	memset(regdata, 0, sizeof(*regdata));
@@ -1108,7 +1108,7 @@ static int registers_view_alloc(debug_view *view)
 
 static void registers_view_free(debug_view *view)
 {
-	debug_view_registers *regdata = view->extra_data;
+	debug_view_registers *regdata = (debug_view_registers *)view->extra_data;
 
 	/* free any memory we callocated */
 	if (regdata != NULL)
@@ -1124,7 +1124,7 @@ static void registers_view_free(debug_view *view)
 
 static void registers_view_add_register(debug_view *view, int regnum, const char *str)
 {
-	debug_view_registers *regdata = view->extra_data;
+	debug_view_registers *regdata = (debug_view_registers *)view->extra_data;
 	int tagstart, taglen, valstart, vallen;
 	const char *colon;
 
@@ -1183,7 +1183,7 @@ static void registers_view_add_register(debug_view *view, int regnum, const char
 
 static void registers_view_recompute(debug_view *view)
 {
-	debug_view_registers *regdata = view->extra_data;
+	debug_view_registers *regdata = (debug_view_registers *)view->extra_data;
 	int regnum, maxtaglen, maxvallen;
 	const cpu_state_table *table;
 
@@ -1296,7 +1296,7 @@ static void registers_view_recompute(debug_view *view)
 static void registers_view_update(debug_view *view)
 {
 	const device_config *screen = view->machine->primary_screen;
-	debug_view_registers *regdata = view->extra_data;
+	debug_view_registers *regdata = (debug_view_registers *)view->extra_data;
 	debug_view_char *dest = view->viewdata;
 	UINT64 total_cycles;
 	UINT32 row, i;
@@ -1434,7 +1434,7 @@ const registers_subview_item *registers_view_get_subview_list(debug_view *view)
 
 int registers_view_get_subview(debug_view *view)
 {
-	debug_view_registers *regdata = view->extra_data;
+	debug_view_registers *regdata = (debug_view_registers *)view->extra_data;
 	const registers_subview_item *subview;
 	int index = 0;
 
@@ -1460,7 +1460,7 @@ int registers_view_get_subview(debug_view *view)
 void registers_view_set_subview(debug_view *view, int index)
 {
 	const registers_subview_item *subview = registers_view_get_subview_by_index(view->machine->debugvw_data->registers_subviews, index);
-	debug_view_registers *regdata = view->extra_data;
+	debug_view_registers *regdata = (debug_view_registers *)view->extra_data;
 
 	assert(view->type == DVT_REGISTERS);
 	assert(subview != NULL);
@@ -1506,7 +1506,7 @@ static const disasm_subview_item *disasm_view_enumerate_subviews(running_machine
 
 			/* determine the string and allocate a subview large enough */
 			astring_printf(tempstring, "CPU '%s' (%s)", cpu->tag, cpu_get_name(cpu));
-			subview = auto_malloc(sizeof(*subview) + astring_len(tempstring));
+			subview = (disasm_subview_item *)auto_malloc(sizeof(*subview) + astring_len(tempstring));
 			memset(subview, 0, sizeof(*subview));
 
 			/* populate the subview */
@@ -1543,7 +1543,7 @@ static int disasm_view_alloc(debug_view *view)
 		return FALSE;
 
 	/* allocate disasm */
-	dasmdata = malloc(sizeof(*dasmdata));
+	dasmdata = (debug_view_disasm *)malloc(sizeof(*dasmdata));
 	if (dasmdata == NULL)
 		return FALSE;
 	memset(dasmdata, 0, sizeof(*dasmdata));
@@ -1580,7 +1580,7 @@ static int disasm_view_alloc(debug_view *view)
 
 static void disasm_view_free(debug_view *view)
 {
-	debug_view_disasm *dasmdata = view->extra_data;
+	debug_view_disasm *dasmdata = (debug_view_disasm *)view->extra_data;
 
 	/* free any disasm we callocated */
 	if (dasmdata != NULL)
@@ -1615,7 +1615,7 @@ static void disasm_view_notify(debug_view *view, view_notification type)
 
 static void disasm_view_char(debug_view *view, int chval)
 {
-	debug_view_disasm *dasmdata = view->extra_data;
+	debug_view_disasm *dasmdata = (debug_view_disasm *)view->extra_data;
 	debug_view_xy origcursor = view->cursor;
 	UINT8 end_buffer = 3;
 	INT32 temp;
@@ -1824,7 +1824,7 @@ static void disasm_view_generate_bytes(const address_space *space, offs_t pcbyte
 
 static int disasm_view_recompute(debug_view *view, offs_t pc, int startline, int lines)
 {
-	debug_view_disasm *dasmdata = view->extra_data;
+	debug_view_disasm *dasmdata = (debug_view_disasm *)view->extra_data;
 	const address_space *space = dasmdata->space;
 	int minbytes, maxbytes, maxbytes_clamped;
 	int changed = FALSE;
@@ -1864,12 +1864,12 @@ static int disasm_view_recompute(debug_view *view, offs_t pc, int startline, int
 		/* allocate address array */
 		if (dasmdata->byteaddress != NULL)
 			free(dasmdata->byteaddress);
-		dasmdata->byteaddress = malloc_or_die(sizeof(dasmdata->byteaddress[0]) * dasmdata->allocated.y);
+		dasmdata->byteaddress = (offs_t *)malloc_or_die(sizeof(dasmdata->byteaddress[0]) * dasmdata->allocated.y);
 
 		/* allocate disassembly buffer */
 		if (dasmdata->dasm != NULL)
 			free(dasmdata->dasm);
-		dasmdata->dasm = malloc_or_die(sizeof(dasmdata->dasm[0]) * dasmdata->allocated.x * dasmdata->allocated.y);
+		dasmdata->dasm = (char *)malloc_or_die(sizeof(dasmdata->dasm[0]) * dasmdata->allocated.x * dasmdata->allocated.y);
 	}
 
 	/* iterate over lines */
@@ -1955,7 +1955,7 @@ static int disasm_view_recompute(debug_view *view, offs_t pc, int startline, int
 
 static void disasm_view_update(debug_view *view)
 {
-	debug_view_disasm *dasmdata = view->extra_data;
+	debug_view_disasm *dasmdata = (debug_view_disasm *)view->extra_data;
 	const address_space *space = dasmdata->space;
 	debug_view_char *dest = view->viewdata;
 	int recomputed_this_time = FALSE;
@@ -2163,7 +2163,7 @@ const disasm_subview_item *disasm_view_get_subview_list(debug_view *view)
 
 int disasm_view_get_subview(debug_view *view)
 {
-	debug_view_disasm *dasmdata = view->extra_data;
+	debug_view_disasm *dasmdata = (debug_view_disasm *)view->extra_data;
 	const disasm_subview_item *subview;
 	int index = 0;
 
@@ -2188,7 +2188,7 @@ int disasm_view_get_subview(debug_view *view)
 
 const char *disasm_view_get_expression(debug_view *view)
 {
-	debug_view_disasm *dasmdata = view->extra_data;
+	debug_view_disasm *dasmdata = (debug_view_disasm *)view->extra_data;
 	assert(view->type == DVT_DISASSEMBLY);
 	debug_view_begin_update(view);
 	debug_view_end_update(view);
@@ -2203,7 +2203,7 @@ const char *disasm_view_get_expression(debug_view *view)
 
 disasm_right_column disasm_view_get_right_column(debug_view *view)
 {
-	debug_view_disasm *dasmdata = view->extra_data;
+	debug_view_disasm *dasmdata = (debug_view_disasm *)view->extra_data;
 	assert(view->type == DVT_DISASSEMBLY);
 	debug_view_begin_update(view);
 	debug_view_end_update(view);
@@ -2219,7 +2219,7 @@ disasm_right_column disasm_view_get_right_column(debug_view *view)
 
 UINT32 disasm_view_get_backward_steps(debug_view *view)
 {
-	debug_view_disasm *dasmdata = view->extra_data;
+	debug_view_disasm *dasmdata = (debug_view_disasm *)view->extra_data;
 	assert(view->type == DVT_DISASSEMBLY);
 	debug_view_begin_update(view);
 	debug_view_end_update(view);
@@ -2235,7 +2235,7 @@ UINT32 disasm_view_get_backward_steps(debug_view *view)
 
 UINT32 disasm_view_get_disasm_width(debug_view *view)
 {
-	debug_view_disasm *dasmdata = view->extra_data;
+	debug_view_disasm *dasmdata = (debug_view_disasm *)view->extra_data;
 	assert(view->type == DVT_DISASSEMBLY);
 	debug_view_begin_update(view);
 	debug_view_end_update(view);
@@ -2251,7 +2251,7 @@ UINT32 disasm_view_get_disasm_width(debug_view *view)
 
 offs_t disasm_view_get_selected_address(debug_view *view)
 {
-	debug_view_disasm *dasmdata = view->extra_data;
+	debug_view_disasm *dasmdata = (debug_view_disasm *)view->extra_data;
 	assert(view->type == DVT_DISASSEMBLY);
 	debug_view_begin_update(view);
 	debug_view_end_update(view);
@@ -2267,7 +2267,7 @@ offs_t disasm_view_get_selected_address(debug_view *view)
 void disasm_view_set_subview(debug_view *view, int index)
 {
 	const disasm_subview_item *subview = disasm_view_get_subview_by_index(view->machine->debugvw_data->disasm_subviews, index);
-	debug_view_disasm *dasmdata = view->extra_data;
+	debug_view_disasm *dasmdata = (debug_view_disasm *)view->extra_data;
 
 	assert(view->type == DVT_DISASSEMBLY);
 	assert(subview != NULL);
@@ -2295,7 +2295,7 @@ void disasm_view_set_subview(debug_view *view, int index)
 
 void disasm_view_set_expression(debug_view *view, const char *expression)
 {
-	debug_view_disasm *dasmdata = view->extra_data;
+	debug_view_disasm *dasmdata = (debug_view_disasm *)view->extra_data;
 
 	assert(view->type == DVT_DISASSEMBLY);
 	assert(expression != NULL);
@@ -2314,7 +2314,7 @@ void disasm_view_set_expression(debug_view *view, const char *expression)
 
 void disasm_view_set_right_column(debug_view *view, disasm_right_column contents)
 {
-	debug_view_disasm *dasmdata = view->extra_data;
+	debug_view_disasm *dasmdata = (debug_view_disasm *)view->extra_data;
 
 	assert(view->type == DVT_DISASSEMBLY);
 	assert(contents == DASM_RIGHTCOL_RAW || contents == DASM_RIGHTCOL_ENCRYPTED || contents == DASM_RIGHTCOL_COMMENTS);
@@ -2337,7 +2337,7 @@ void disasm_view_set_right_column(debug_view *view, disasm_right_column contents
 
 void disasm_view_set_backward_steps(debug_view *view, UINT32 steps)
 {
-	debug_view_disasm *dasmdata = view->extra_data;
+	debug_view_disasm *dasmdata = (debug_view_disasm *)view->extra_data;
 
 	assert(view->type == DVT_DISASSEMBLY);
 
@@ -2359,7 +2359,7 @@ void disasm_view_set_backward_steps(debug_view *view, UINT32 steps)
 
 void disasm_view_set_disasm_width(debug_view *view, UINT32 width)
 {
-	debug_view_disasm *dasmdata = view->extra_data;
+	debug_view_disasm *dasmdata = (debug_view_disasm *)view->extra_data;
 
 	assert(view->type == DVT_DISASSEMBLY);
 
@@ -2381,7 +2381,7 @@ void disasm_view_set_disasm_width(debug_view *view, UINT32 width)
 
 void disasm_view_set_selected_address(debug_view *view, offs_t address)
 {
-	debug_view_disasm *dasmdata = view->extra_data;
+	debug_view_disasm *dasmdata = (debug_view_disasm *)view->extra_data;
 	offs_t byteaddress = memory_address_to_byte(dasmdata->space, address) & dasmdata->space->logbytemask;
 	int line;
 
@@ -2429,7 +2429,7 @@ static const memory_subview_item *memory_view_enumerate_subviews(running_machine
 
 				/* determine the string and allocate a subview large enough */
 				astring_printf(tempstring, "CPU '%s' (%s) %s memory", cpu->tag, cpu_get_name(cpu), space->name);
-				subview = auto_malloc(sizeof(*subview) + astring_len(tempstring));
+				subview = (memory_subview_item *)auto_malloc(sizeof(*subview) + astring_len(tempstring));
 				memset(subview, 0, sizeof(*subview));
 
 				/* populate the subview */
@@ -2459,7 +2459,7 @@ static const memory_subview_item *memory_view_enumerate_subviews(running_machine
 
 			/* determine the string and allocate a subview large enough */
 			astring_printf(tempstring, "Region '%s'", rgntag);
-			subview = auto_malloc(sizeof(*subview) + astring_len(tempstring));
+			subview = (memory_subview_item *)auto_malloc(sizeof(*subview) + astring_len(tempstring));
 			memset(subview, 0, sizeof(*subview));
 
 			/* populate the subview */
@@ -2497,7 +2497,7 @@ static const memory_subview_item *memory_view_enumerate_subviews(running_machine
 
 			/* determine the string and allocate a subview large enough */
 			astring_printf(tempstring, "%s", strrchr(name, '/') + 1);
-			subview = auto_malloc(sizeof(*subview) + astring_len(tempstring));
+			subview = (memory_subview_item *)auto_malloc(sizeof(*subview) + astring_len(tempstring));
 			memset(subview, 0, sizeof(*subview));
 
 			/* populate the subview */
@@ -2536,7 +2536,7 @@ static int memory_view_alloc(debug_view *view)
 		return FALSE;
 
 	/* allocate memory */
-	memdata = malloc(sizeof(*memdata));
+	memdata = (debug_view_memory *)malloc(sizeof(*memdata));
 	if (memdata == NULL)
 		return FALSE;
 	memset(memdata, 0, sizeof(*memdata));
@@ -2570,7 +2570,7 @@ static int memory_view_alloc(debug_view *view)
 
 static void memory_view_free(debug_view *view)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 
 	/* free any memory we allocated */
 	if (memdata != NULL)
@@ -2608,7 +2608,7 @@ static void memory_view_notify(debug_view *view, view_notification type)
 
 static void memory_view_update(debug_view *view)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 	const address_space *space = memdata->desc->space;
 	const memory_view_pos *posdata;
 	UINT32 row;
@@ -2704,7 +2704,7 @@ static void memory_view_update(debug_view *view)
 static void memory_view_char(debug_view *view, int chval)
 {
 	static const char hexvals[] = "0123456789abcdef";
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 	offs_t address;
 	char *hexchar;
 	int ismapped;
@@ -2777,7 +2777,7 @@ static void memory_view_char(debug_view *view, int chval)
 			break;
 
 		default:
-			hexchar = strchr(hexvals, tolower(chval));
+			hexchar = (char *)strchr(hexvals, tolower(chval));
 			if (hexchar == NULL)
 				break;
 			ismapped = memory_view_read(memdata, memdata->bytes_per_chunk, address, &data);
@@ -2824,7 +2824,7 @@ static void memory_view_char(debug_view *view, int chval)
 
 static void memory_view_recompute(debug_view *view)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 	const address_space *space = memdata->desc->space;
 	offs_t cursoraddr;
 	UINT8 cursorshift;
@@ -2904,7 +2904,7 @@ static void memory_view_recompute(debug_view *view)
 
 static int memory_view_needs_recompute(debug_view *view)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 	const address_space *space = memdata->desc->space;
 	int recompute = view->recompute;
 
@@ -2931,7 +2931,7 @@ static int memory_view_needs_recompute(debug_view *view)
 
 static void memory_view_get_cursor_pos(debug_view *view, offs_t *address, UINT8 *shift)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 	const memory_view_pos *posdata = &memory_pos_table[memdata->bytes_per_chunk];
 	int xposition, chunknum, chunkoffs;
 
@@ -2967,7 +2967,7 @@ static void memory_view_get_cursor_pos(debug_view *view, offs_t *address, UINT8
 
 static void memory_view_set_cursor_pos(debug_view *view, offs_t address, UINT8 shift)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 	const memory_view_pos *posdata = &memory_pos_table[memdata->bytes_per_chunk];
 	int chunknum;
 
@@ -3131,7 +3131,7 @@ const memory_subview_item *memory_view_get_subview_list(debug_view *view)
 
 int memory_view_get_subview(debug_view *view)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 
 	assert(view->type == DVT_MEMORY);
 	debug_view_begin_update(view);
@@ -3148,7 +3148,7 @@ int memory_view_get_subview(debug_view *view)
 
 const char *memory_view_get_expression(debug_view *view)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 	assert(view->type == DVT_MEMORY);
 	debug_view_begin_update(view);
 	debug_view_end_update(view);
@@ -3163,7 +3163,7 @@ const char *memory_view_get_expression(debug_view *view)
 
 UINT8 memory_view_get_bytes_per_chunk(debug_view *view)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 	assert(view->type == DVT_MEMORY);
 	debug_view_begin_update(view);
 	debug_view_end_update(view);
@@ -3178,7 +3178,7 @@ UINT8 memory_view_get_bytes_per_chunk(debug_view *view)
 
 UINT32 memory_view_get_chunks_per_row(debug_view *view)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 	assert(view->type == DVT_MEMORY);
 	debug_view_begin_update(view);
 	debug_view_end_update(view);
@@ -3193,7 +3193,7 @@ UINT32 memory_view_get_chunks_per_row(debug_view *view)
 
 UINT8 memory_view_get_reverse(debug_view *view)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 	assert(view->type == DVT_MEMORY);
 	debug_view_begin_update(view);
 	debug_view_end_update(view);
@@ -3209,7 +3209,7 @@ UINT8 memory_view_get_reverse(debug_view *view)
 
 UINT8 memory_view_get_ascii(debug_view *view)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 	assert(view->type == DVT_MEMORY);
 	debug_view_begin_update(view);
 	debug_view_end_update(view);
@@ -3225,7 +3225,7 @@ UINT8 memory_view_get_ascii(debug_view *view)
 
 UINT8 memory_view_get_physical(debug_view *view)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 	assert(view->type == DVT_MEMORY);
 	debug_view_begin_update(view);
 	debug_view_end_update(view);
@@ -3241,7 +3241,7 @@ UINT8 memory_view_get_physical(debug_view *view)
 void memory_view_set_subview(debug_view *view, int index)
 {
 	const memory_subview_item *subview = memory_view_get_subview_by_index(view->machine->debugvw_data->memory_subviews, index);
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 
 	assert(view->type == DVT_MEMORY);
 	assert(subview != NULL);
@@ -3271,7 +3271,7 @@ void memory_view_set_subview(debug_view *view, int index)
 
 void memory_view_set_expression(debug_view *view, const char *expression)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 
 	assert(view->type == DVT_MEMORY);
 	assert(expression != NULL);
@@ -3290,7 +3290,7 @@ void memory_view_set_expression(debug_view *view, const char *expression)
 
 void memory_view_set_bytes_per_chunk(debug_view *view, UINT8 chunkbytes)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 
 	assert(view->type == DVT_MEMORY);
 	assert(chunkbytes < ARRAY_LENGTH(memory_pos_table) && memory_pos_table[chunkbytes].spacing != 0);
@@ -3325,7 +3325,7 @@ void memory_view_set_bytes_per_chunk(debug_view *view, UINT8 chunkbytes)
 
 void memory_view_set_chunks_per_row(debug_view *view, UINT32 rowchunks)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 
 	assert(view->type == DVT_MEMORY);
 
@@ -3354,7 +3354,7 @@ void memory_view_set_chunks_per_row(debug_view *view, UINT32 rowchunks)
 
 void memory_view_set_reverse(debug_view *view, UINT8 reverse)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 
 	assert(view->type == DVT_MEMORY);
 
@@ -3381,7 +3381,7 @@ void memory_view_set_reverse(debug_view *view, UINT8 reverse)
 
 void memory_view_set_ascii(debug_view *view, UINT8 ascii)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 
 	assert(view->type == DVT_MEMORY);
 
@@ -3408,7 +3408,7 @@ void memory_view_set_ascii(debug_view *view, UINT8 ascii)
 
 void memory_view_set_physical(debug_view *view, UINT8 physical)
 {
-	debug_view_memory *memdata = view->extra_data;
+	debug_view_memory *memdata = (debug_view_memory *)view->extra_data;
 
 	assert(view->type == DVT_MEMORY);
 

src/emu/debug/express.c

@@ -304,7 +304,7 @@ INLINE EXPRERR pop_token_lval(parsed_expression *expr, parse_token *token, const
 	/* to be an lval, the token must be a valid read/write symbol or a memory token */
 	if (token->type == TOK_SYMBOL)
 	{
-		symbol_entry *symbol = token->value.p;
+		symbol_entry *symbol = (symbol_entry *)token->value.p;
 		if (symbol == NULL || symbol->type != SMT_REGISTER || symbol->info.reg.setter == NULL)
 			return MAKE_EXPRERR_NOT_LVAL(token->offset);
 	}
@@ -332,7 +332,7 @@ INLINE EXPRERR pop_token_rval(parsed_expression *expr, parse_token *token, const
 	/* symbol tokens get resolved down to number tokens */
 	if (token->type == TOK_SYMBOL)
 	{
-		symbol_entry *symbol = token->value.p;
+		symbol_entry *symbol = (symbol_entry *)token->value.p;
 		if (symbol == NULL || (symbol->type != SMT_REGISTER && symbol->type != SMT_VALUE))
 			return MAKE_EXPRERR_NOT_RVAL(token->offset);
 		token->type = TOK_NUMBER;
@@ -371,7 +371,7 @@ INLINE UINT64 get_lval_value(parsed_expression *expr, parse_token *token, const
 {
 	if (token->type == TOK_SYMBOL)
 	{
-		symbol_entry *symbol = token->value.p;
+		symbol_entry *symbol = (symbol_entry *)token->value.p;
 		if (symbol != NULL && symbol->type == SMT_REGISTER)
 			return (*symbol->info.reg.getter)(symbol->table->globalref, symbol->ref);
 	}
@@ -396,7 +396,7 @@ INLINE void set_lval_value(parsed_expression *expr, parse_token *token, const sy
 {
 	if (token->type == TOK_SYMBOL)
 	{
-		symbol_entry *symbol = token->value.p;
+		symbol_entry *symbol = (symbol_entry *)token->value.p;
 		if (symbol != NULL && symbol->type == SMT_REGISTER && symbol->info.reg.setter)
 			(*symbol->info.reg.setter)(symbol->table->globalref, symbol->ref, value);
 	}
@@ -618,7 +618,7 @@ static EXPRERR parse_string_into_tokens(const char *stringstart, parsed_expressi
 	expr->table = table;
 
 	/* make a copy of the original string */
-	expr->original_string = malloc(strlen(stringstart) + 1);
+	expr->original_string = (char *)malloc(strlen(stringstart) + 1);
 	if (!expr->original_string)
 		return MAKE_EXPRERR_OUT_OF_MEMORY(0);
 	strcpy(expr->original_string, stringstart);
@@ -1214,7 +1214,7 @@ static EXPRERR execute_function(parsed_expression *expr, parse_token *token)
 		/* if it is a function symbol, break out of the loop */
 		if (peek->type == TOK_SYMBOL)
 		{
-			symbol = peek->value.p;
+			symbol = (symbol_entry *)peek->value.p;
 			if (symbol != NULL && symbol->type == SMT_FUNCTION)
 			{
 				pop_token(expr, &t1);
@@ -1666,7 +1666,7 @@ static char *add_expression_string(parsed_expression *expr, const char *string,
 	expression_string *expstring;
 
 	/* allocate memory */
-	expstring = malloc(sizeof(expression_string) + length);
+	expstring = (expression_string *)malloc(sizeof(expression_string) + length);
 	if (expstring == NULL)
 		return NULL;
 
@@ -1800,7 +1800,7 @@ EXPRERR expression_parse(const char *expression, const symbol_table *table, cons
 		goto cleanup;
 
 	/* allocate memory for the result */
-	*result = malloc(sizeof(temp_expression));
+	*result = (parsed_expression *)malloc(sizeof(temp_expression));
 	if (!*result)
 	{
 		exprerr = MAKE_EXPRERR_OUT_OF_MEMORY(0);
@@ -1920,7 +1920,7 @@ symbol_table *symtable_alloc(symbol_table *parent, void *globalref)
 	symbol_table *table;
 
 	/* allocate memory for the table */
-	table = malloc(sizeof(*table));
+	table = (symbol_table *)malloc(sizeof(*table));
 	if (!table)
 		return NULL;
 
@@ -1980,13 +1980,13 @@ int symtable_add(symbol_table *table, const char *name, const symbol_entry *entr
 	}
 
 	/* otherwise, allocate a new entry */
-	symbol = malloc(sizeof(*symbol));
+	symbol = (internal_symbol_entry *)malloc(sizeof(*symbol));
 	if (!symbol)
 		return 0;
 	memset(symbol, 0, sizeof(*symbol));
 
 	/* allocate space for a copy of the string */
-	newstring = malloc(strlen(name) + 1);
+	newstring = (char *)malloc(strlen(name) + 1);
 	if (!newstring)
 	{
 		free(symbol);

src/emu/debug/textbuf.c

@@ -88,12 +88,12 @@ text_buffer *text_buffer_alloc(UINT32 bytes, UINT32 lines)
 	text_buffer *text;
 
 	/* allocate memory for the text buffer object */
-	text = malloc(sizeof(*text));
+	text = (text_buffer *)malloc(sizeof(*text));
 	if (!text)
 		return NULL;
 
 	/* allocate memory for the buffer itself */
-	text->buffer = malloc(bytes);
+	text->buffer = (char *)malloc(bytes);
 	if (!text->buffer)
 	{
 		free(text);
@@ -101,7 +101,7 @@ text_buffer *text_buffer_alloc(UINT32 bytes, UINT32 lines)
 	}
 
 	/* allocate memory for the lines array */
-	text->lineoffs = malloc(lines * sizeof(text->lineoffs[0]));
+	text->lineoffs = (INT32 *)malloc(lines * sizeof(text->lineoffs[0]));
 	if (!text->lineoffs)
 	{
 		free(text->buffer);

src/emu/debugger.c

@@ -75,7 +75,7 @@ void debugger_init(running_machine *machine)
 
 		/* allocate a new entry for our global list */
 		add_exit_callback(machine, debugger_exit);
-		entry = malloc_or_die(sizeof(*entry));
+		entry = (machine_entry *)malloc_or_die(sizeof(*entry));
 		entry->next = machine_list;
 		entry->machine = machine;
 		machine_list = entry;

src/emu/devcb.c

@@ -31,7 +31,7 @@ static READ_LINE_DEVICE_HANDLER( trampoline_read_port_to_read_line )
 static READ_LINE_DEVICE_HANDLER( trampoline_read8_to_read_line )
 {
 	const devcb_resolved_read_line *resolved = (const devcb_resolved_read_line *)device;
-	return ((*resolved->real.readdevice)(resolved->realtarget, 0) & 1) ? ASSERT_LINE : CLEAR_LINE;
+	return ((*resolved->real.readdevice)((const device_config *)resolved->realtarget, 0) & 1) ? ASSERT_LINE : CLEAR_LINE;
 }
 
 void devcb_resolve_read_line(devcb_resolved_read_line *resolved, const devcb_read_line *config, const device_config *device)
@@ -95,13 +95,13 @@ void devcb_resolve_read_line(devcb_resolved_read_line *resolved, const devcb_rea
 static WRITE_LINE_DEVICE_HANDLER( trampoline_write8_to_write_line )
 {
 	const devcb_resolved_write_line *resolved = (const devcb_resolved_write_line *)device;
-	(*resolved->real.writedevice)(resolved->realtarget, 0, state);
+	(*resolved->real.writedevice)((const device_config *)resolved->realtarget, 0, state);
 }
 
 static WRITE_LINE_DEVICE_HANDLER( trampoline_writecpu_to_write_line )
 {
 	const devcb_resolved_write_line *resolved = (const devcb_resolved_write_line *)device;
-	const device_config *cpu = resolved->realtarget;
+	const device_config *cpu = (const device_config *)resolved->realtarget;
 	cpu_set_input_line(cpu, resolved->real.writeline, state ? ASSERT_LINE : CLEAR_LINE);
 }
 
@@ -176,7 +176,7 @@ static READ8_DEVICE_HANDLER( trampoline_read_port_to_read8 )
 static READ8_DEVICE_HANDLER( trampoline_read_line_to_read8 )
 {
 	const devcb_resolved_read8 *resolved = (const devcb_resolved_read8 *)device;
-	return (*resolved->real.readline)(resolved->realtarget);
+	return (*resolved->real.readline)((const device_config *)resolved->realtarget);
 }
 
 void devcb_resolve_read8(devcb_resolved_read8 *resolved, const devcb_read8 *config, const device_config *device)
@@ -238,7 +238,7 @@ void devcb_resolve_read8(devcb_resolved_read8 *resolved, const devcb_read8 *conf
 static WRITE8_DEVICE_HANDLER( trampoline_write_line_to_write8 )
 {
 	const devcb_resolved_write8 *resolved = (const devcb_resolved_write8 *)device;
-	(*resolved->real.writeline)(resolved->realtarget, (data & 1) ? ASSERT_LINE : CLEAR_LINE);
+	(*resolved->real.writeline)((const device_config *)resolved->realtarget, (data & 1) ? ASSERT_LINE : CLEAR_LINE);
 }
 
 void devcb_resolve_write8(devcb_resolved_write8 *resolved, const devcb_write8 *config, const device_config *device)

src/emu/devintrf.c

@@ -111,7 +111,7 @@ device_config *device_list_add(device_config **listheadptr, const device_config
 	configlen = (UINT32)devtype_get_info_int(type, DEVINFO_INT_INLINE_CONFIG_BYTES);
 
 	/* allocate a new device */
-	device = malloc_or_die(sizeof(*device) + strlen(tag) + configlen);
+	device = (device_config *)malloc_or_die(sizeof(*device) + strlen(tag) + configlen);
 
 	/* populate device relationships */
 	device->next = NULL;
@@ -121,7 +121,7 @@ device_config *device_list_add(device_config **listheadptr, const device_config
 
 	/* populate device properties */
 	device->type = type;
-	device->devclass = devtype_get_info_int(type, DEVINFO_INT_CLASS);
+	device->devclass = (device_class)(INT32)devtype_get_info_int(type, DEVINFO_INT_CLASS);
 	device->set_info = (device_set_info_func)devtype_get_info_fct(type, DEVINFO_FCT_SET_INFO);
 	device->execute = NULL;
 

src/emu/drawgfx.c

@@ -90,7 +90,7 @@ gfx_element *gfx_element_alloc(running_machine *machine, const gfx_layout *gl, c
 	gfx_element *gfx;
 
 	/* allocate memory for the gfx_element structure */
-	gfx = malloc_or_die(sizeof(*gfx));
+	gfx = (gfx_element *)malloc_or_die(sizeof(*gfx));
 	memset(gfx, 0, sizeof(*gfx));
 
 	/* fill in the data */
@@ -120,7 +120,7 @@ gfx_element *gfx_element_alloc(running_machine *machine, const gfx_layout *gl, c
 		}
 		else
 		{
-			UINT32 *buffer = malloc_or_die(sizeof(buffer[0]) * gfx->layout.width);
+			UINT32 *buffer = (UINT32 *)malloc_or_die(sizeof(buffer[0]) * gfx->layout.width);
 			memcpy(buffer, gfx->layout.extxoffs, sizeof(gfx->layout.extxoffs[0]) * gfx->layout.width);
 			gfx->layout.extxoffs = buffer;
 		}
@@ -135,7 +135,7 @@ gfx_element *gfx_element_alloc(running_machine *machine, const gfx_layout *gl, c
 		}
 		else
 		{
-			UINT32 *buffer = malloc_or_die(sizeof(buffer[0]) * gfx->layout.height);
+			UINT32 *buffer = (UINT32 *)malloc_or_die(sizeof(buffer[0]) * gfx->layout.height);
 			memcpy(buffer, gfx->layout.extyoffs, sizeof(gfx->layout.extyoffs[0]) * gfx->layout.height);
 			gfx->layout.extyoffs = buffer;
 		}
@@ -143,10 +143,10 @@ gfx_element *gfx_element_alloc(running_machine *machine, const gfx_layout *gl, c
 
 	/* allocate a pen usage array for entries with 32 pens or less */
 	if (gfx->color_depth <= 32)
-		gfx->pen_usage = malloc_or_die(gfx->total_elements * sizeof(*gfx->pen_usage));
+		gfx->pen_usage = (UINT32 *)malloc_or_die(gfx->total_elements * sizeof(*gfx->pen_usage));
 
 	/* allocate a dirty array */
-	gfx->dirty = malloc_or_die(gfx->total_elements * sizeof(*gfx->dirty));
+	gfx->dirty = (UINT8 *)malloc_or_die(gfx->total_elements * sizeof(*gfx->dirty));
 	memset(gfx->dirty, 1, gfx->total_elements * sizeof(*gfx->dirty));
 
 	/* raw graphics case */
@@ -173,7 +173,7 @@ gfx_element *gfx_element_alloc(running_machine *machine, const gfx_layout *gl, c
 		gfx->char_modulo = gfx->line_modulo * gfx->origheight;
 
 		/* allocate memory for the data */
-		gfx->gfxdata = malloc_or_die(gfx->total_elements * gfx->char_modulo);
+		gfx->gfxdata = (UINT8 *)malloc_or_die(gfx->total_elements * gfx->char_modulo);
 	}
 
 	return gfx;

src/emu/driver.c

@@ -114,7 +114,7 @@ void driver_list_get_approx_matches(const game_driver * const driverlist[], cons
 		int shufnum;
 
 		/* allocate a temporary list */
-		templist = malloc_or_die(driver_list_get_count(driverlist) * sizeof(*templist));
+		templist = (const game_driver **)malloc_or_die(driver_list_get_count(driverlist) * sizeof(*templist));
 
 		/* build up a list of valid entries */
 		for (drvnum = driver_count = 0; driverlist[drvnum] != NULL; drvnum++)
@@ -145,7 +145,7 @@ void driver_list_get_approx_matches(const game_driver * const driverlist[], cons
 	}
 
 	/* allocate some temp memory */
-	penalty = malloc_or_die(matches * sizeof(*penalty));
+	penalty = (int *)malloc_or_die(matches * sizeof(*penalty));
 
 	/* initialize everyone's states */
 	for (matchnum = 0; matchnum < matches; matchnum++)

src/emu/emupal.c

@@ -95,14 +95,14 @@ static void configure_rgb_shadows(running_machine *machine, int mode, float fact
 
 void palette_init(running_machine *machine)
 {
-	int format;
+	palette_private *palette = (palette_private *)auto_malloc(sizeof(*palette));
-	palette_private *palette = auto_malloc(sizeof(*palette));
 	const device_config *device = video_screen_first(machine->config);
+	bitmap_format format;
 
 	/* get the format from the first screen, or use BITMAP_FORMAT_INVALID, if screenless */
 	if (device != NULL)
 	{
-		screen_config *config = device->inline_config;
+		screen_config *config = (screen_config *)device->inline_config;
 		format = config->format;
 	}
 	else
@@ -146,8 +146,8 @@ void palette_init(running_machine *machine)
 
 		/* set up save/restore of the palette */
 		numcolors = palette_get_num_colors(machine->palette);
-		palette->save_pen = auto_malloc(sizeof(*palette->save_pen) * numcolors);
+		palette->save_pen = (pen_t *)auto_malloc(sizeof(*palette->save_pen) * numcolors);
-		palette->save_bright = auto_malloc(sizeof(*palette->save_bright) * numcolors);
+		palette->save_bright = (float *)auto_malloc(sizeof(*palette->save_bright) * numcolors);
 		state_save_register_global_pointer(machine, palette->save_pen, numcolors);
 		state_save_register_global_pointer(machine, palette->save_bright, numcolors);
 		state_save_register_presave(machine, palette_presave, palette);
@@ -330,7 +330,7 @@ colortable_t *colortable_alloc(running_machine *machine, UINT32 palettesize)
 	assert(palettesize > 0);
 
 	/* allocate the colortable */
-	ctable = auto_malloc(sizeof(*ctable));
+	ctable = (colortable_t *)auto_malloc(sizeof(*ctable));
 	memset(ctable, 0, sizeof(*ctable));
 
 	/* fill in the basics */
@@ -339,13 +339,13 @@ colortable_t *colortable_alloc(running_machine *machine, UINT32 palettesize)
 	ctable->palentries = palettesize;
 
 	/* allocate the raw colortable */
-	ctable->raw = auto_malloc(ctable->entries * sizeof(*ctable->raw));
+	ctable->raw = (UINT16 *)auto_malloc(ctable->entries * sizeof(*ctable->raw));
 	for (index = 0; index < ctable->entries; index++)
 		ctable->raw[index] = index % ctable->palentries;
 	state_save_register_global_pointer(machine, ctable->raw, ctable->entries);
 
 	/* allocate the palette */
-	ctable->palette = auto_malloc(ctable->palentries * sizeof(*ctable->palette));
+	ctable->palette = (rgb_t *)auto_malloc(ctable->palentries * sizeof(*ctable->palette));
 	for (index = 0; index < ctable->palentries; index++)
 		ctable->palette[index] = MAKE_ARGB(0x80,0xff,0xff,0xff);
 	state_save_register_global_pointer(machine, ctable->palette, ctable->palentries);
@@ -536,7 +536,7 @@ pen_t get_white_pen(running_machine *machine)
 static void palette_presave(running_machine *machine, void *param)
 {
 	int numcolors = palette_get_num_colors(machine->palette);
-	palette_private *palette = param;
+	palette_private *palette = (palette_private *)param;
 	int index;
 
 	/* fill the save arrays with updated pen and brightness information */
@@ -556,7 +556,7 @@ static void palette_presave(running_machine *machine, void *param)
 static void palette_postload(running_machine *machine, void *param)
 {
 	int numcolors = palette_get_num_colors(machine->palette);
-	palette_private *palette = param;
+	palette_private *palette = (palette_private *)param;
 	int index;
 
 	/* reset the pen and brightness for each entry */
@@ -660,7 +660,7 @@ static void allocate_color_tables(running_machine *machine, palette_private *pal
 	{
 		case BITMAP_FORMAT_INDEXED16:
 			/* create a dummy 1:1 mapping */
-			machine->pens = pentable = auto_malloc((total_colors + 2) * sizeof(machine->pens[0]));
+			machine->pens = pentable = (pen_t *)auto_malloc((total_colors + 2) * sizeof(machine->pens[0]));
 			for (i = 0; i < total_colors + 2; i++)
 				pentable[i] = i;
 			break;
@@ -690,7 +690,7 @@ static void allocate_shadow_tables(running_machine *machine, palette_private *pa
 	/* if we have shadows, allocate shadow tables */
 	if (machine->config->video_attributes & VIDEO_HAS_SHADOWS)
 	{
-		pen_t *table = auto_malloc(65536 * sizeof(*table));
+		pen_t *table = (pen_t *)auto_malloc(65536 * sizeof(*table));
 		int i;
 
 		/* palettized mode gets a single 64k table in slots 0 and 2 */
@@ -713,7 +713,7 @@ static void allocate_shadow_tables(running_machine *machine, palette_private *pa
 	/* if we have hilights, allocate shadow tables */
 	if (machine->config->video_attributes & VIDEO_HAS_HIGHLIGHTS)
 	{
-		pen_t *table = auto_malloc(65536 * sizeof(*table));
+		pen_t *table = (pen_t *)auto_malloc(65536 * sizeof(*table));
 		int i;
 
 		/* palettized mode gets a single 64k table in slots 1 and 3 */

src/emu/fileio.c

@@ -181,7 +181,7 @@ file_error mame_fopen_ram(const void *data, UINT32 length, UINT32 openflags, mam
 	file_error filerr;
 
 	/* allocate the file itself */
-	*file = malloc(sizeof(**file));
+	*file = (mame_file *)malloc(sizeof(**file));
 	if (*file == NULL)
 		return FILERR_OUT_OF_MEMORY;
 
@@ -222,7 +222,7 @@ static file_error fopen_internal(core_options *opts, const char *searchpath, con
 		return FILERR_INVALID_ACCESS;
 
 	/* allocate the file itself */
-	*file = malloc(sizeof(**file));
+	*file = (mame_file *)malloc(sizeof(**file));
 	if (*file == NULL)
 		return FILERR_OUT_OF_MEMORY;
 
@@ -651,7 +651,7 @@ mame_path *mame_openpath(core_options *opts, const char *searchpath)
 	mame_path *path;
 
 	/* allocate a new mame_path */
-	path = malloc(sizeof(*path));
+	path = (mame_path *)malloc(sizeof(*path));
 	if (path == NULL)
 		return NULL;
 	memset(path, 0, sizeof(*path));
@@ -779,7 +779,7 @@ const char *mame_fhash(mame_file *file, UINT32 functions)
 		return file->hash;
 
 	/* read the data if we can */
-	filedata = core_fbuffer(file->file);
+	filedata = (const UINT8 *)core_fbuffer(file->file);
 	if (filedata == NULL)
 		return file->hash;
 
@@ -853,7 +853,7 @@ static file_error load_zipped_file(mame_file *file)
 	assert(file->zipfile != NULL);
 
 	/* allocate some memory */
-	file->zipdata = malloc(file->ziplength);
+	file->zipdata = (UINT8 *)malloc(file->ziplength);
 	if (file->zipdata == NULL)
 		return FILERR_OUT_OF_MEMORY;
 

src/emu/hash.c

@@ -459,7 +459,7 @@ int hash_data_extract_binary_checksum(const char* data, unsigned int function, u
 
 int hash_data_has_info(const char* data, unsigned int info)
 {
-	char* res = strstr(data, info_strings[info]);
+	char* res = (char*)strstr(data, info_strings[info]);
 
 	if (!res)
 		return 0;

src/emu/info.c

@@ -601,7 +601,7 @@ static void print_game_display(FILE *out, const game_driver *game, const machine
 	/* iterate over screens */
 	for (screen = video_screen_first(config); screen != NULL; screen = video_screen_next(screen))
 	{
-		const screen_config *scrconfig = screen->inline_config;
+		const screen_config *scrconfig = (const screen_config *)screen->inline_config;
 
 		fprintf(out, "\t\t<display");
 

src/emu/inptport.c

@@ -624,7 +624,7 @@ time_t input_port_init(running_machine *machine, const input_port_token *tokens)
 	time_t basetime;
 
 	/* allocate memory for our data structure */
-	machine->input_port_data = auto_malloc(sizeof(*machine->input_port_data));
+	machine->input_port_data = (input_port_private *)auto_malloc(sizeof(*machine->input_port_data));
 	memset(machine->input_port_data, 0, sizeof(*machine->input_port_data));
 	portdata = machine->input_port_data;
 
@@ -857,7 +857,7 @@ void input_field_set_user_settings(const input_field_config *field, const input_
 	/* copy the basics */
 	for (seqtype = 0; seqtype < ARRAY_LENGTH(settings->seq); seqtype++)
 	{
-		const input_seq *defseq = input_type_seq(field->port->machine, field->type, field->player, seqtype);
+		const input_seq *defseq = input_type_seq(field->port->machine, field->type, field->player, (input_seq_type)seqtype);
 		if (input_seq_cmp(defseq, &settings->seq[seqtype]) == 0)
 			field->state->seq[seqtype] = default_seq;
 		else
@@ -1500,7 +1500,7 @@ static void init_port_types(running_machine *machine)
 	for (typenum = 0; typenum < ARRAY_LENGTH(core_types); typenum++)
 	{
 		/* allocate memory for the state and link it to the end of the list */
-		*stateptr = auto_malloc(sizeof(**stateptr));
+		*stateptr = (input_type_state *)auto_malloc(sizeof(**stateptr));
 		memset(*stateptr, 0, sizeof(**stateptr));
 
 		/* copy the type description and link the previous description to it */
@@ -1550,7 +1550,7 @@ static void init_port_state(running_machine *machine)
 		input_port_state *portstate;
 
 		/* allocate a new input_port_info structure */
-		portstate = auto_malloc(sizeof(*portstate));
+		portstate = (input_port_state *)auto_malloc(sizeof(*portstate));
 		memset(portstate, 0, sizeof(*portstate));
 		((input_port_config *)port)->state = portstate;
 		((input_port_config *)port)->machine = machine;
@@ -1567,7 +1567,7 @@ static void init_port_state(running_machine *machine)
 			int seqtype;
 
 			/* allocate a new input_field_info structure */
-			fieldstate = auto_malloc(sizeof(*fieldstate));
+			fieldstate = (input_field_state *)auto_malloc(sizeof(*fieldstate));
 			memset(fieldstate, 0, sizeof(*fieldstate));
 			((input_field_config *)field)->state = fieldstate;
 
@@ -1714,7 +1714,7 @@ static callback_field_info *init_field_callback_info(const input_field_config *f
 	input_port_value mask;
 
 	/* allocate memory */
-	info = auto_malloc(sizeof(*info));
+	info = (callback_field_info *)auto_malloc(sizeof(*info));
 	memset(info, 0, sizeof(*info));
 
 	/* fill in the data */
@@ -1737,7 +1737,7 @@ static analog_field_state *init_field_analog_state(const input_field_config *fie
 	input_port_value mask;
 
 	/* allocate memory */
-	state = auto_malloc(sizeof(*state));
+	state = (analog_field_state *)auto_malloc(sizeof(*state));
 	memset(state, 0, sizeof(*state));
 
 	/* compute the shift amount and number of bits */
@@ -2403,7 +2403,7 @@ static input_port_config *port_config_detokenize(input_port_config *listhead, co
 				TOKEN_GET_UINT64_UNPACK2(ipt, mask, 32, defval, 32);
 
 				if (curport == NULL)
-					return error_buf_append(errorbuf, errorbuflen, "INPUT_TOKEN_FIELD encountered with no active port (mask=%X defval=%X)\n", mask, defval);
+					return (input_port_config *)error_buf_append(errorbuf, errorbuflen, "INPUT_TOKEN_FIELD encountered with no active port (mask=%X defval=%X)\n", mask, defval);
 
 				if (curfield != NULL)
 					field_config_insert(curfield, &maskbits, errorbuf, errorbuflen);
@@ -2953,7 +2953,7 @@ static input_port_config *port_config_alloc(const input_port_config **listhead)
 	input_port_config *config;
 
 	/* allocate memory */
-	config = malloc_or_die(sizeof(*config));
+	config = (input_port_config *)malloc_or_die(sizeof(*config));
 	memset(config, 0, sizeof(*config));
 
 	/* add it to the tail */
@@ -3015,7 +3015,7 @@ static input_field_config *field_config_alloc(input_port_config *port, int type,
 	int seqtype;
 
 	/* allocate memory */
-	config = malloc_or_die(sizeof(*config));
+	config = (input_field_config *)malloc_or_die(sizeof(*config));
 	memset(config, 0, sizeof(*config));
 
 	/* fill in the basic field values */
@@ -3123,7 +3123,7 @@ static input_setting_config *setting_config_alloc(input_field_config *field, inp
 	input_setting_config *config;
 
 	/* allocate memory */
-	config = malloc_or_die(sizeof(*config));
+	config = (input_setting_config *)malloc_or_die(sizeof(*config));
 	memset(config, 0, sizeof(*config));
 
 	/* fill in the basic setting values */
@@ -3183,7 +3183,7 @@ static const input_field_diplocation *diplocation_list_alloc(const input_field_c
 		const char *comma, *colon, *number;
 
 		/* allocate a new entry */
-		*tailptr = malloc_or_die(sizeof(**tailptr));
+		*tailptr = (input_field_diplocation *)malloc_or_die(sizeof(**tailptr));
 		memset(*tailptr, 0, sizeof(**tailptr));
 		entries++;
 
@@ -3203,7 +3203,7 @@ static const input_field_diplocation *diplocation_list_alloc(const input_field_c
 		/* allocate and copy the name if it is present */
 		if (colon != NULL)
 		{
-			(*tailptr)->swname = lastname = malloc_or_die(colon - tempbuf + 1);
+			(*tailptr)->swname = lastname = (char *)malloc_or_die(colon - tempbuf + 1);
 			strncpy(lastname, tempbuf, colon - tempbuf);
 			lastname[colon - tempbuf] = 0;
 			number = colon + 1;
@@ -3218,7 +3218,7 @@ static const input_field_diplocation *diplocation_list_alloc(const input_field_c
 				error_buf_append(errorbuf, errorbuflen, "Switch location '%s' missing switch name!\n", location);
 				lastname = (char *)"UNK";
 			}
-			(*tailptr)->swname = namecopy = malloc_or_die(strlen(lastname) + 1);
+			(*tailptr)->swname = namecopy = (char *)malloc_or_die(strlen(lastname) + 1);
 			strcpy(namecopy, lastname);
 		}
 
@@ -3450,8 +3450,8 @@ static void load_remap_table(running_machine *machine, xml_data_node *parentnode
 		int remapnum;
 
 		/* allocate tables */
-		oldtable = malloc_or_die(count * sizeof(*oldtable));
+		oldtable = (input_code *)malloc_or_die(count * sizeof(*oldtable));
-		newtable = malloc_or_die(count * sizeof(*newtable));
+		newtable = (input_code *)malloc_or_die(count * sizeof(*newtable));
 
 		/* build up the remap table */
 		count = 0;

src/emu/inptport.h

@@ -59,6 +59,7 @@ enum _input_seq_type
 	SEQ_TYPE_TOTAL
 };
 typedef enum _input_seq_type input_seq_type;
+DECLARE_ENUM_OPERATORS(input_seq_type)
 
 
 /* conditions for DIP switches */

src/emu/input.c

@@ -677,7 +677,7 @@ static void input_frame(running_machine *machine)
 			int changed = FALSE;
 
 			/* update the state of all the keys and see if any changed state */
-			for (itemid = ITEM_ID_INVALID + 1; itemid <= device->maxitem; itemid++)
+			for (itemid = ITEM_ID_FIRST_VALID; itemid <= device->maxitem; itemid++)
 			{
 				input_device_item *item = device->item[itemid];
 				if (item != NULL && item->itemclass == ITEM_CLASS_SWITCH)
@@ -695,7 +695,7 @@ static void input_frame(running_machine *machine)
 			}
 
 			/* if the keyboard state is stable, copy it over */
-			for (itemid = ITEM_ID_INVALID + 1; itemid <= device->maxitem; itemid++)
+			for (itemid = ITEM_ID_FIRST_VALID; itemid <= device->maxitem; itemid++)
 			{
 				input_device_item *item = device->item[itemid];
 				if (item != NULL && item->itemclass == ITEM_CLASS_SWITCH)
@@ -729,7 +729,7 @@ input_device *input_device_add(running_machine *machine, input_device_class devc
 	assert(devclass != DEVICE_CLASS_INVALID && devclass < DEVICE_CLASS_MAXIMUM);
 
 	/* allocate a new device */
-	devlist->list = auto_realloc(devlist->list, (devlist->count + 1) * sizeof(devlist->list[0]));
+	devlist->list = (input_device *)auto_realloc(devlist->list, (devlist->count + 1) * sizeof(devlist->list[0]));
 	device = &devlist->list[devlist->count++];
 	memset(device, 0, sizeof(*device));
 
@@ -769,7 +769,7 @@ void input_device_item_add(input_device *device, const char *name, void *interna
 
 	/* if we have a generic ID, pick a new internal one */
 	if (itemid >= ITEM_ID_OTHER_SWITCH && itemid <= ITEM_ID_OTHER_AXIS_RELATIVE)
-		for (itemid = ITEM_ID_MAXIMUM + 1; itemid <= ITEM_ID_ABSOLUTE_MAXIMUM; itemid++)
+		for (itemid = (input_item_id)(ITEM_ID_MAXIMUM + 1); itemid <= ITEM_ID_ABSOLUTE_MAXIMUM; itemid++)
 			if (device->item[itemid] == NULL)
 				break;
 	assert(itemid <= ITEM_ID_ABSOLUTE_MAXIMUM);
@@ -778,7 +778,7 @@ void input_device_item_add(input_device *device, const char *name, void *interna
 	assert(device->item[itemid] == NULL);
 
 	/* allocate a new item and copy data into it */
-	item = auto_malloc(sizeof(*item));
+	item = (input_device_item *)auto_malloc(sizeof(*item));
 	memset(item, 0, sizeof(*item));
 	device->item[itemid] = item;
 	device->maxitem = MAX(device->maxitem, itemid);
@@ -947,7 +947,7 @@ input_code input_code_from_input_item_id(input_item_id itemid)
 	input_device_class devclass;
 
 	/* iterate over device classes and devices */
-	for (devclass = DEVICE_CLASS_INVALID + 1; devclass < DEVICE_CLASS_MAXIMUM; devclass++)
+	for (devclass = DEVICE_CLASS_FIRST_VALID; devclass < DEVICE_CLASS_MAXIMUM; devclass++)
 	{
 		input_device_list *devlist = &device_list[devclass];
 		int devnum;
@@ -977,7 +977,7 @@ input_code input_code_poll_switches(int reset)
 		code_pressed_memory_reset();
 
 	/* iterate over device classes and devices */
-	for (devclass = DEVICE_CLASS_INVALID + 1; devclass < DEVICE_CLASS_MAXIMUM; devclass++)
+	for (devclass = DEVICE_CLASS_FIRST_VALID; devclass < DEVICE_CLASS_MAXIMUM; devclass++)
 	{
 		input_device_list *devlist = &device_list[devclass];
 		int devnum;
@@ -989,7 +989,7 @@ input_code input_code_poll_switches(int reset)
 			input_item_id itemid;
 
 			/* iterate over items within each device */
-			for (itemid = ITEM_ID_INVALID + 1; itemid <= device->maxitem; itemid++)
+			for (itemid = ITEM_ID_FIRST_VALID; itemid <= device->maxitem; itemid++)
 			{
 				input_device_item *item = device->item[itemid];
 				if (item != NULL)
@@ -1072,7 +1072,7 @@ input_code input_code_poll_keyboard_switches(int reset)
 		input_item_id itemid;
 
 		/* iterate over items within each device */
-		for (itemid = ITEM_ID_INVALID + 1; itemid <= device->maxitem; itemid++)
+		for (itemid = ITEM_ID_FIRST_VALID; itemid <= device->maxitem; itemid++)
 		{
 			input_device_item *item = device->item[itemid];
 			if (item != NULL && item->itemclass == ITEM_CLASS_SWITCH)
@@ -1098,7 +1098,7 @@ input_code input_code_poll_axes(int reset)
 	input_device_class devclass;
 
 	/* iterate over device classes and devices */
-	for (devclass = DEVICE_CLASS_INVALID + 1; devclass < DEVICE_CLASS_MAXIMUM; devclass++)
+	for (devclass = DEVICE_CLASS_FIRST_VALID; devclass < DEVICE_CLASS_MAXIMUM; devclass++)
 	{
 		input_device_list *devlist = &device_list[devclass];
 		int devnum;
@@ -1110,7 +1110,7 @@ input_code input_code_poll_axes(int reset)
 			input_item_id itemid;
 
 			/* iterate over items within each device */
-			for (itemid = ITEM_ID_INVALID + 1; itemid <= device->maxitem; itemid++)
+			for (itemid = ITEM_ID_FIRST_VALID; itemid <= device->maxitem; itemid++)
 			{
 				input_device_item *item = device->item[itemid];
 				if (item != NULL)
@@ -1292,7 +1292,7 @@ input_code input_code_from_token(const char *_token)
 	for (numtokens = 0; numtokens < ARRAY_LENGTH(token); )
 	{
 		/* make a token up to the next underscore */
-		char *score = strchr(_token, '_');
+		char *score = (char *)strchr(_token, '_');
 		token[numtokens++] = astring_dupch(_token, (score == NULL) ? strlen(_token) : (score - _token));
 
 		/* if we hit the end, we're done, else advance our pointer */
@@ -1323,7 +1323,7 @@ input_code input_code_from_token(const char *_token)
 
 	/* if we're a standard code, default the itemclass based on it */
 	if (standard)
-		itemclass = input_item_standard_class(devclass, itemid);
+		itemclass = input_item_standard_class((input_device_class)devclass, (input_item_id)itemid);
 
 	/* otherwise, keep parsing */
 	else
@@ -1336,7 +1336,7 @@ input_code input_code_from_token(const char *_token)
 		device = &device_list[devclass].list[devindex];
 
 		/* if not a standard code, look it up in the device specific codes */
-		for (itemid = ITEM_ID_INVALID + 1; itemid <= device->maxitem; itemid++)
+		for (itemid = ITEM_ID_FIRST_VALID; itemid <= device->maxitem; itemid++)
 		{
 			input_device_item *item = device->item[itemid];
 			if (item != NULL && item->token != NULL && astring_cmp(token[curtok], item->token) == 0)

src/emu/input.h

@@ -74,13 +74,15 @@
 enum _input_device_class
 {
 	DEVICE_CLASS_INVALID,
-	DEVICE_CLASS_KEYBOARD,
+	DEVICE_CLASS_FIRST_VALID,
+	DEVICE_CLASS_KEYBOARD = DEVICE_CLASS_FIRST_VALID,
 	DEVICE_CLASS_MOUSE,
 	DEVICE_CLASS_LIGHTGUN,
 	DEVICE_CLASS_JOYSTICK,
 	DEVICE_CLASS_MAXIMUM
 };
 typedef enum _input_device_class input_device_class;
+DECLARE_ENUM_OPERATORS(input_device_class)
 
 
 /* input item classes */
@@ -114,9 +116,10 @@ typedef enum _input_item_modifier input_item_modifier;
 enum _input_item_id
 {
 	ITEM_ID_INVALID,
+	ITEM_ID_FIRST_VALID,
 
 	/* standard keyboard IDs */
-	ITEM_ID_A,
+	ITEM_ID_A = ITEM_ID_FIRST_VALID,
 	ITEM_ID_B,
 	ITEM_ID_C,
 	ITEM_ID_D,
@@ -334,6 +337,7 @@ enum _input_item_id
 	ITEM_ID_ABSOLUTE_MAXIMUM = 0xfff
 };
 typedef enum _input_item_id input_item_id;
+DECLARE_ENUM_OPERATORS(input_item_id)
 
 
 /* expanded codes referencing specific devices for input definitions */

src/emu/inputseq.c

@@ -361,7 +361,7 @@ int input_seq_poll(input_seq *finalseq)
 				{
 					/* increment the modifier, wrapping back to none */
 					input_item_modifier oldmod = INPUT_CODE_MODIFIER(lastcode);
-					input_item_modifier newmod = (oldmod < ITEM_MODIFIER_NEG) ? oldmod + 1 : ITEM_MODIFIER_NONE;
+					input_item_modifier newmod = (oldmod < ITEM_MODIFIER_NEG) ? (input_item_modifier)(oldmod + 1) : ITEM_MODIFIER_NONE;
 					newcode = INPUT_CODE_SET_MODIFIER(newcode, newmod);
 
 					/* back up over the previous code so we can re-append */
@@ -511,7 +511,7 @@ astring *input_seq_to_tokens(astring *string, const input_seq *seq)
 
 int input_seq_from_tokens(const char *string, input_seq *seq)
 {
-	char *strcopy = malloc_or_die(strlen(string) + 1);
+	char *strcopy = (char *)malloc_or_die(strlen(string) + 1);
 	char *str = strcopy;
 	int result = FALSE;
 

src/emu/machine/6522via.c

@@ -380,7 +380,7 @@ static void via_shift(const device_config *device)
 
 static TIMER_CALLBACK( via_shift_callback )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	via_shift(device);
 }
 
@@ -391,7 +391,7 @@ static TIMER_CALLBACK( via_shift_callback )
 
 static TIMER_CALLBACK( via_t1_timeout )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	via6522_t *v = get_token(device);
 
 	if (T1_CONTINUOUS (v->acr))
@@ -424,7 +424,7 @@ static TIMER_CALLBACK( via_t1_timeout )
 
 static TIMER_CALLBACK( via_t2_timeout )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	via6522_t *v = get_token(device);
 
 	v->t2_active = 0;

src/emu/machine/6526cia.c

@@ -448,7 +448,7 @@ static void cia_timer_underflow(const device_config *device, int timer)
 
 static TIMER_CALLBACK( cia_timer_proc )
 {
-	cia_timer *timer = ptr;
+	cia_timer *timer = (cia_timer *)ptr;
 	cia_state *cia = timer->cia;
 
 	cia_timer_underflow(cia->device, timer - cia->timer);
@@ -554,7 +554,7 @@ void cia_clock_tod(const device_config *device)
 
 static TIMER_CALLBACK( cia_clock_tod_callback )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	cia_clock_tod(device);
 }
 

src/emu/machine/6532riot.c

@@ -166,7 +166,7 @@ INLINE UINT8 get_timer(riot6532_state *riot)
 
 static TIMER_CALLBACK( timer_end_callback )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	riot6532_state *riot = get_safe_token(device);
 
 	assert(riot->timerstate != TIMER_IDLE);
@@ -434,7 +434,7 @@ static DEVICE_START( riot6532 )
 
 	/* set static values */
 	riot->device = device;
-	riot->intf = device->static_config;
+	riot->intf = (riot6532_interface *)device->static_config;
 	riot->index = device_list_index(device->machine->config->devicelist, RIOT6532, device->tag);
 
 	/* configure the ports */

src/emu/machine/6840ptm.c

@@ -355,7 +355,7 @@ static void reload_count(running_machine *machine, int which, int idx)
 	if (idx == 2) duration = attotime_mul(duration, currptr->t3_divisor);
 	PLOG(("MC6840 #%d: reload_count(%d): output = %lf\n", which, idx, attotime_to_double(duration)));
 
-	if (!currptr->control_reg[idx] & 0x02)
+	if (!(currptr->control_reg[idx] & 0x02))
 	{
 		if (!currptr->intf->external_clock[idx])
 		{
@@ -739,7 +739,7 @@ void ptm6840_set_ext_clock(int which, int counter, int clock)
 	ptm6840 *currptr = ptm + which;
 	currptr->external_clock[counter] = clock;
 
-	if (!currptr->control_reg[counter] & 0x02)
+	if (!(currptr->control_reg[counter] & 0x02))
 	{
 		if (!currptr->intf->external_clock[counter])
 		{

src/emu/machine/6850acia.c

@@ -39,12 +39,13 @@ enum serial_state
 	STOP2,
 };
 
-enum parity_type
+enum _parity_type
 {
 	NONE,
 	ODD,
 	EVEN
 };
+typedef enum _parity_type parity_type;
 
 typedef struct _acia6850_t acia6850_t;
 struct _acia6850_t
@@ -80,7 +81,7 @@ struct _acia6850_t
 
 	/* TX/RX state */
 	int	bits;
-	enum 	parity_type parity;
+	parity_type parity;
 	int	stopbits;
 	int tx_int;
 
@@ -295,7 +296,7 @@ WRITE8_DEVICE_HANDLER( acia6850_ctrl_w )
 	wordsel = (data & CR4_2) >> 2;
 
 	acia_p->bits = ACIA6850_WORD[wordsel][0];
-	acia_p->parity = ACIA6850_WORD[wordsel][1];
+	acia_p->parity = (parity_type)ACIA6850_WORD[wordsel][1];
 	acia_p->stopbits = ACIA6850_WORD[wordsel][2];
 
 	// Transmitter Control Bits
@@ -565,7 +566,7 @@ static void tx_tick(const device_config *device)
 
 static TIMER_CALLBACK( transmit_event )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	acia6850_t *acia_p = get_token(device);
 	tx_tick(device);
 	acia_p->tx_counter = 0;
@@ -756,7 +757,7 @@ static void rx_tick(const device_config *device)
 
 static TIMER_CALLBACK( receive_event )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	acia6850_t *acia_p = get_token(device);
 	rx_tick(device);
 	acia_p->rx_counter = 0;

src/emu/machine/68681.c

@@ -120,7 +120,7 @@ static void duart68681_update_interrupts(duart68681_state *duart68681)
 
 static TIMER_CALLBACK( duart_timer_callback )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	duart68681_state	*duart68681 = get_safe_token(device);
 
 	duart68681->ISR |= INT_COUNTER_READY;
@@ -275,7 +275,7 @@ static UINT8 duart68681_read_rx_fifo(duart68681_state *duart68681, int ch)
 
 static TIMER_CALLBACK( tx_timer_callback )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	duart68681_state	*duart68681 = get_safe_token(device);
 	int ch = param & 1;
 
@@ -592,7 +592,7 @@ static DEVICE_RESET(duart68681)
 	duart68681_state *duart68681 = get_safe_token(device);
 
 	memset(duart68681, 0, sizeof(duart68681_state));
-	duart68681->duart_config = device->static_config;
+	duart68681->duart_config = (const duart68681_config *)device->static_config;
 	duart68681->device = device;
 	duart68681->IVR = 0x0f;
 

src/emu/machine/74123.c

@@ -73,7 +73,7 @@ static int timer_running(ttl74123_t *chip)
 
 static TIMER_CALLBACK( output_callback )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	ttl74123_t *chip = get_safe_token(device);
 
 	chip->intf->output_changed_cb(device, 0, param);
@@ -93,7 +93,7 @@ static void set_output(const device_config *device)
 
 static TIMER_CALLBACK( clear_callback )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	ttl74123_t *chip = get_safe_token(device);
 	int output = timer_running(chip);
 
@@ -191,7 +191,7 @@ static DEVICE_START( ttl74123 )
 	ttl74123_t *chip = get_safe_token(device);
 
 	/* validate arguments */
-	chip->intf = device->static_config;
+	chip->intf = (ttl74123_config *)device->static_config;
 
 	assert_always(chip->intf, "No interface specified");
 	assert_always((chip->intf->connection_type != TTL74123_GROUNDED) || (chip->intf->cap >= CAP_U(0.01)), "Only capacitors >= 0.01uF supported for GROUNDED type");

src/emu/machine/8237dma.c

@@ -114,7 +114,7 @@ static int dma8237_do_operation(const device_config *device, int channel)
 
 static TIMER_CALLBACK( dma8237_timerproc )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	dma8237_t	*dma8237 = get_safe_token(device);
 	int channel = param % 4;
 	int done;
@@ -134,7 +134,7 @@ static TIMER_CALLBACK( dma8237_timerproc )
 
 static TIMER_CALLBACK( dma8237_msbflip_timerproc )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	dma8237_t	*dma8237 = get_safe_token(device);
 	dma8237->msb ^= 1;
 }
@@ -394,7 +394,7 @@ void dma8237_run_transfer(const device_config *device, int channel)
 static DEVICE_START( dma8237 ) {
 	dma8237_t	*dma8237 = get_safe_token(device);
 
-	dma8237->intf = device->static_config;
+	dma8237->intf = (struct dma8237_interface *)device->static_config;
 }
 
 

src/emu/machine/8255ppi.c

@@ -501,7 +501,7 @@ UINT8 ppi8255_get_port_c( const device_config *device ) {
 static DEVICE_START( ppi8255 ) {
 	ppi8255_t	*ppi8255 = get_safe_token(device);
 
-	ppi8255->intf = device->static_config;
+	ppi8255->intf = (const ppi8255_interface *)device->static_config;
 
 	devcb_resolve_read8(&ppi8255->port_read[0], &ppi8255->intf->port_a_read, device);
 	devcb_resolve_read8(&ppi8255->port_read[1], &ppi8255->intf->port_b_read, device);

src/emu/machine/8257dma.c

@@ -153,7 +153,7 @@ static int dma8257_do_operation(const device_config *device, int channel)
 
 static TIMER_CALLBACK( dma8257_timerproc )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	dma8257_t *dma8257 = get_safe_token(device);
 	int i, channel = 0, rr;
 	int done;
@@ -186,7 +186,7 @@ static TIMER_CALLBACK( dma8257_timerproc )
 
 static TIMER_CALLBACK( dma8257_msbflip_timerproc )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	dma8257_t *dma8257 = get_safe_token(device);
 	dma8257->msb ^= 1;
 }
@@ -324,7 +324,7 @@ WRITE8_DEVICE_HANDLER( dma8257_w )
 
 static TIMER_CALLBACK( dma8257_drq_write_callback )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	dma8257_t *dma8257 = get_safe_token(device);
 	int channel = param >> 1;
 	int state = param & 0x01;
@@ -368,7 +368,7 @@ static DEVICE_START( dma8257 )
 	assert(device->tag != NULL);
 
 	//dma8257->device_type = device_type;
-	dma8257->intf = device->static_config;
+	dma8257->intf = (dma8257_interface *)device->static_config;
 
 	dma8257->status = 0x0f;
 	dma8257->timer = timer_alloc(device->machine, dma8257_timerproc, (void *) device);

src/emu/machine/at28c16.c

@@ -137,15 +137,15 @@ static DEVICE_START(at28c16)
 	assert(device->machine != NULL);
 	assert(device->machine->config != NULL);
 
-	c->data = auto_malloc( SIZE_DATA );
+	c->data = (UINT8 *)auto_malloc( SIZE_DATA );
-	c->id = auto_malloc( SIZE_ID );
+	c->id = (UINT8 *)auto_malloc( SIZE_ID );
 	c->a9_12v = 0;
 	c->oe_12v = 0;
 	c->last_write = -1;
 	c->write_timer = timer_alloc(device->machine,  write_finished, c );
 	c->default_data = device->region;
 
-	config = device->inline_config;
+	config = (const at28c16_config *)device->inline_config;
 	if (config->id != NULL)
 		c->default_id = memory_region( device->machine, config->id );
 

src/emu/machine/cdp1852.c

@@ -75,7 +75,7 @@ static void set_sr_line(cdp1852_t *cdp1852, int level)
 
 static TIMER_CALLBACK( cdp1852_scan_tick )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	cdp1852_t *cdp1852 = get_safe_token(device);
 
 	switch (cdp1852->mode)
@@ -161,7 +161,7 @@ static DEVICE_START( cdp1852 )
 	devcb_resolve_write_line(&cdp1852->out_sr_func, &intf->out_sr_func, device);
 
 	/* set initial values */
-	cdp1852->mode = intf->mode;
+	cdp1852->mode = (cdp1852_mode)intf->mode;
 
 	if (device->clock > 0)
 	{

src/emu/machine/cdp1852.h

@@ -49,11 +49,11 @@
     TYPE DEFINITIONS
 ***************************************************************************/
 
-typedef enum _cdp1852_mode cdp1852_mode;
 enum _cdp1852_mode {
 	CDP1852_MODE_INPUT = 0,
 	CDP1852_MODE_OUTPUT
 };
+typedef enum _cdp1852_mode cdp1852_mode;
 
 typedef struct _cdp1852_interface cdp1852_interface;
 struct _cdp1852_interface

src/emu/machine/cr589.c

@@ -20,7 +20,7 @@ static int cr589_exec_command( SCSIInstance *scsiInstance, UINT8 *statusCode )
 {
 	UINT8 *command;
 	int commandLength;
-	SCSICr589 *our_this = SCSIThis( &SCSIClassCr589, scsiInstance );
+	SCSICr589 *our_this = (SCSICr589 *)SCSIThis( &SCSIClassCr589, scsiInstance );
 	SCSIGetCommand( scsiInstance, &command, &commandLength );
 
 	switch( command[ 0 ] )
@@ -48,7 +48,7 @@ static void cr589_read_data( SCSIInstance *scsiInstance, UINT8 *data, int dataLe
 {
 	UINT8 *command;
 	int commandLength;
-	SCSICr589 *our_this = SCSIThis( &SCSIClassCr589, scsiInstance );
+	SCSICr589 *our_this = (SCSICr589 *)SCSIThis( &SCSIClassCr589, scsiInstance );
 	SCSIGetCommand( scsiInstance, &command, &commandLength );
 
 	switch( command[ 0 ] )
@@ -81,7 +81,7 @@ static void cr589_write_data( SCSIInstance *scsiInstance, UINT8 *data, int dataL
 {
 	UINT8 *command;
 	int commandLength;
-	SCSICr589 *our_this = SCSIThis( &SCSIClassCr589, scsiInstance );
+	SCSICr589 *our_this = (SCSICr589 *)SCSIThis( &SCSIClassCr589, scsiInstance );
 	SCSIGetCommand( scsiInstance, &command, &commandLength );
 
 	switch( command[ 0 ] )
@@ -111,7 +111,7 @@ static void cr589_write_data( SCSIInstance *scsiInstance, UINT8 *data, int dataL
 static void cr589_alloc_instance( SCSIInstance *scsiInstance, const char *diskregion )
 {
 	running_machine *machine = scsiInstance->machine;
-	SCSICr589 *our_this = SCSIThis( &SCSIClassCr589, scsiInstance );
+	SCSICr589 *our_this = (SCSICr589 *)SCSIThis( &SCSIClassCr589, scsiInstance );
 
 	our_this->download = 0;
 	memcpy( &our_this->buffer[ identity_offset ], "MATSHITACD-ROM CR-589   GS0N", 28 );
@@ -128,24 +128,24 @@ static int cr589_dispatch( int operation, void *file, INT64 intparm, void *ptrpa
 	switch( operation )
 	{
 		case SCSIOP_EXEC_COMMAND:
-			return cr589_exec_command( file, ptrparm );
+			return cr589_exec_command( (SCSIInstance *)file, (UINT8 *)ptrparm );
 
 		case SCSIOP_READ_DATA:
-			cr589_read_data( file, ptrparm, intparm );
+			cr589_read_data( (SCSIInstance *)file, (UINT8 *)ptrparm, intparm );
 			return 0;
 
 		case SCSIOP_WRITE_DATA:
-			cr589_write_data( file, ptrparm, intparm );
+			cr589_write_data( (SCSIInstance *)file, (UINT8 *)ptrparm, intparm );
 			return 0;
 
 		case SCSIOP_ALLOC_INSTANCE:
-			params = ptrparm;
+			params = (SCSIAllocInstanceParams *)ptrparm;
-			SCSIBase( &SCSIClassCr589, operation, file, intparm, ptrparm );
+			SCSIBase( &SCSIClassCr589, operation, (SCSIInstance *)file, intparm, (UINT8 *)ptrparm );
 			cr589_alloc_instance( params->instance, params->diskregion );
 			return 0;
 	}
 
-	return SCSIBase( &SCSIClassCr589, operation, file, intparm, ptrparm );
+	return SCSIBase( &SCSIClassCr589, operation, (SCSIInstance *)file, intparm, (UINT8 *)ptrparm );
 }
 
 const SCSIClass SCSIClassCr589 =

src/emu/machine/f3853.c

@@ -83,7 +83,7 @@ static void f3853_timer_start(const device_config *device, UINT8 value)
 
 static TIMER_CALLBACK( f3853_timer_callback )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	f3853_t	*f3853 = get_safe_token( device );
 
     if (f3853->timer_enable)
@@ -167,7 +167,7 @@ static DEVICE_START( f3853 )
 	UINT8 reg=0xfe;
 	int i;
 
-	f3853->config = device->static_config;
+	f3853->config = (const f3853_config *)device->static_config;
 
 	for (i=254/*known to get 0xfe after 255 cycles*/; i>=0; i--)
 	{

src/emu/machine/generic.c

@@ -373,7 +373,7 @@ NVRAM_HANDLER( generic_randfill )
 		mame_fread(file, nvram_select(), generic_nvram_size);
 	else
 	{
-		UINT8 *nvram = nvram_select();
+		UINT8 *nvram = (UINT8 *)nvram_select();
 		for (i = 0; i < generic_nvram_size; i++)
 			nvram[i] = mame_rand(machine);
 	}
@@ -570,7 +570,7 @@ static void interrupt_reset(running_machine *machine)
 
 static TIMER_CALLBACK( clear_all_lines )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	int inputcount = cpu_get_input_lines(device);
 	int line;
 
@@ -587,7 +587,7 @@ static TIMER_CALLBACK( clear_all_lines )
 
 static TIMER_CALLBACK( irq_pulse_clear )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	int irqline = param;
 	cpu_set_input_line(device, irqline, CLEAR_LINE);
 }
@@ -770,6 +770,6 @@ READ32_HANDLER( watchdog_reset32_r ) { watchdog_reset(space->machine); return 0x
 
 CUSTOM_INPUT( custom_port_read )
 {
-	const char *tag = param;
+	const char *tag = (const char *)param;
 	return input_port_read(field->port->machine, tag);
 }

src/emu/machine/i2cmem.c

@@ -86,12 +86,12 @@ void i2cmem_init( running_machine *machine, int chip, int slave_address, int pag
 
 	if( data == NULL )
 	{
-		data = auto_malloc( data_size );
+		data = (unsigned char *)auto_malloc( data_size );
 	}
 
 	if( page_size > 0 )
 	{
-		page = auto_malloc( page_size );
+		page = (unsigned char *)auto_malloc( page_size );
 	}
 
 	c->slave_address = slave_address;

src/emu/machine/idectrl.c

@@ -196,7 +196,7 @@ INLINE ide_state *get_safe_token(const device_config *device)
 
 INLINE void signal_interrupt(ide_state *ide)
 {
-	const ide_config *config = ide->device->inline_config;
+	const ide_config *config = (const ide_config *)ide->device->inline_config;
 
 	LOG(("IDE interrupt assert\n"));
 
@@ -210,7 +210,7 @@ INLINE void signal_interrupt(ide_state *ide)
 
 INLINE void clear_interrupt(ide_state *ide)
 {
-	const ide_config *config = ide->device->inline_config;
+	const ide_config *config = (const ide_config *)ide->device->inline_config;
 
 	LOG(("IDE interrupt clear\n"));
 
@@ -228,7 +228,7 @@ INLINE void clear_interrupt(ide_state *ide)
 
 static TIMER_CALLBACK( delayed_interrupt )
 {
-	ide_state *ide = ptr;
+	ide_state *ide = (ide_state *)ptr;
 	ide->status &= ~IDE_STATUS_BUSY;
 	signal_interrupt(ide);
 }
@@ -236,7 +236,7 @@ static TIMER_CALLBACK( delayed_interrupt )
 
 static TIMER_CALLBACK( delayed_interrupt_buffer_ready )
 {
-	ide_state *ide = ptr;
+	ide_state *ide = (ide_state *)ptr;
 	ide->status &= ~IDE_STATUS_BUSY;
 	ide->status |= IDE_STATUS_BUFFER_READY;
 	signal_interrupt(ide);
@@ -289,7 +289,7 @@ void ide_set_user_password(const device_config *device, const UINT8 *password)
 
 static TIMER_CALLBACK( reset_callback )
 {
-	device_reset(ptr);
+	device_reset((const device_config *)ptr);
 }
 
 
@@ -595,7 +595,7 @@ static void ide_build_features(ide_state *ide)
 
 static TIMER_CALLBACK( security_error_done )
 {
-	ide_state *ide = ptr;
+	ide_state *ide = (ide_state *)ptr;
 
 	/* clear error state */
 	ide->status &= ~IDE_STATUS_ERROR;
@@ -763,7 +763,7 @@ static void read_sector_done(ide_state *ide)
 
 static TIMER_CALLBACK( read_sector_done_callback )
 {
-	read_sector_done(ptr);
+	read_sector_done((ide_state *)ptr);
 }
 
 
@@ -965,7 +965,7 @@ static void write_sector_done(ide_state *ide)
 
 static TIMER_CALLBACK( write_sector_done_callback )
 {
-	write_sector_done(ptr);
+	write_sector_done((ide_state *)ptr);
 }
 
 
@@ -1677,7 +1677,7 @@ static DEVICE_START( ide_controller )
 	ide->device = device;
 
 	/* set MAME harddisk handle */
-	config = device->inline_config;
+	config = (const ide_config *)device->inline_config;
 	ide->disk = hard_disk_open(get_disk_handle((config->master != NULL) ? config->master : device->tag));
 	assert_always(config->slave == NULL, "IDE controller does not yet support slave drives\n");
 

src/emu/machine/intelfsh.c

@@ -50,7 +50,7 @@ static struct flash_chip chips[FLASH_CHIPS_MAX];
 
 static TIMER_CALLBACK( erase_finished )
 {
-	struct flash_chip *c = ptr;
+	struct flash_chip *c = (struct flash_chip *)ptr;
 
 	switch( c->flash_mode )
 	{
@@ -159,13 +159,13 @@ UINT32 intelflash_read(int chip, UINT32 address)
 		{
 		case 8:
 			{
-				UINT8 *flash_memory = c->flash_memory;
+				UINT8 *flash_memory = (UINT8 *)c->flash_memory;
 				data = flash_memory[ address ];
 			}
 			break;
 		case 16:
 			{
-				UINT16 *flash_memory = c->flash_memory;
+				UINT16 *flash_memory = (UINT16 *)c->flash_memory;
 				data = flash_memory[ address ];
 			}
 			break;
@@ -345,13 +345,13 @@ void intelflash_write(int chip, UINT32 address, UINT32 data)
 			{
 			case 8:
 				{
-					UINT8 *flash_memory = c->flash_memory;
+					UINT8 *flash_memory = (UINT8 *)c->flash_memory;
 					memset( &flash_memory[ address & ~0xffff ], 0xff, 64 * 1024 );
 				}
 				break;
 			case 16:
 				{
-					UINT16 *flash_memory = c->flash_memory;
+					UINT16 *flash_memory = (UINT16 *)c->flash_memory;
 					memset( &flash_memory[ address & ~0x7fff ], 0xff, 64 * 1024 );
 				}
 				break;
@@ -372,7 +372,7 @@ void intelflash_write(int chip, UINT32 address, UINT32 data)
 		{
 		case 8:
 			{
-				UINT8 *flash_memory = c->flash_memory;
+				UINT8 *flash_memory = (UINT8 *)c->flash_memory;
 				flash_memory[ address ] = data;
 			}
 			break;
@@ -387,13 +387,13 @@ void intelflash_write(int chip, UINT32 address, UINT32 data)
 		{
 		case 8:
 			{
-				UINT8 *flash_memory = c->flash_memory;
+				UINT8 *flash_memory = (UINT8 *)c->flash_memory;
 				flash_memory[ address ] = data;
 			}
 			break;
 		case 16:
 			{
-				UINT16 *flash_memory = c->flash_memory;
+				UINT16 *flash_memory = (UINT16 *)c->flash_memory;
 				flash_memory[ address ] = data;
 			}
 			break;
@@ -412,13 +412,13 @@ void intelflash_write(int chip, UINT32 address, UINT32 data)
 			{
 			case 8:
 				{
-					UINT8 *flash_memory = c->flash_memory;
+					UINT8 *flash_memory = (UINT8 *)c->flash_memory;
 					memset( &flash_memory[ address & ~0xffff ], 0xff, 64 * 1024 );
 				}
 				break;
 			case 16:
 				{
-					UINT16 *flash_memory = c->flash_memory;
+					UINT16 *flash_memory = (UINT16 *)c->flash_memory;
 					memset( &flash_memory[ address & ~0x7fff ], 0xff, 64 * 1024 );
 				}
 				break;

src/emu/machine/latch8.c

@@ -51,7 +51,7 @@ static void update(const device_config *device, UINT8 new_val, UINT8 mask)
 
 static TIMER_CALLBACK( latch8_timerproc )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	UINT8 new_val = param & 0xFF;
 	UINT8 mask = param >> 8;
 
@@ -96,7 +96,7 @@ READ8_DEVICE_HANDLER( latch8_r )
 		}
 	}
 
-	return (res & ~latch8->intf->maskout) ^ latch8->intf->xor;
+	return (res & ~latch8->intf->maskout) ^ latch8->intf->xorvalue;
 }
 
 
@@ -188,7 +188,7 @@ static DEVICE_START( latch8 )
 	int i;
 
 	/* validate arguments */
-	latch8->intf = device->inline_config;
+	latch8->intf = (latch8_config *)device->inline_config;
 
 	latch8->value = 0x0;
 

src/emu/machine/latch8.h

@@ -36,7 +36,7 @@ struct _latch8_config
 {
 	/* only for byte reads, does not affect bit reads and node_map */
 	UINT32					maskout;
-	UINT32					xor;  /* after mask */
+	UINT32					xorvalue;  /* after mask */
 	UINT32					nosync;
 	UINT32					node_map[8];
 	const char *			node_device[8];
@@ -57,7 +57,7 @@ struct _latch8_config
 
 /* Bit mask specifying bits to be inverted */
 #define MDRV_LATCH8_INVERT(_xor) \
-	MDRV_DEVICE_CONFIG_DATA32(latch8_config, xor, _xor)
+	MDRV_DEVICE_CONFIG_DATA32(latch8_config, xorvalue, _xor)
 
 /* Bit mask specifying bits not needing cpu synchronization. */
 #define MDRV_LATCH8_NOSYNC(_nosync) \

src/emu/machine/ldcore.c

@@ -197,7 +197,7 @@ INLINE void update_audio(laserdisc_state *ld)
 	ldcore_data *ldcore = ld->core;
 	if (ldcore->audiocustom != NULL)
 	{
-		sound_token *token = ldcore->audiocustom->token;
+		sound_token *token = (sound_token *)ldcore->audiocustom->token;
 		stream_update(token->stream);
 	}
 }
@@ -290,7 +290,7 @@ static void update_slider_pos(ldcore_data *ldcore, attotime curtime)
 
 static void vblank_state_changed(const device_config *screen, void *param, int vblank_state)
 {
-	const device_config *device = param;
+	const device_config *device = (const device_config *)param;
 	laserdisc_state *ld = get_safe_token(device);
 	ldcore_data *ldcore = ld->core;
 	attotime curtime = timer_get_time(screen->machine);
@@ -318,7 +318,7 @@ static void vblank_state_changed(const device_config *screen, void *param, int v
 
 static TIMER_CALLBACK( perform_player_update )
 {
-	laserdisc_state *ld = ptr;
+	laserdisc_state *ld = (laserdisc_state *)ptr;
 	ldcore_data *ldcore = ld->core;
 	attotime curtime = timer_get_time(machine);
 
@@ -940,7 +940,7 @@ static void process_track_data(const device_config *device)
 
 static DEVICE_START( laserdisc_sound )
 {
-	sound_token *token = device->token;
+	sound_token *token = (sound_token *)device->token;
 	token->stream = stream_create(device, 0, 2, 48000, token, custom_stream_callback);
 	token->ld = NULL;
 }
@@ -975,7 +975,7 @@ DEVICE_GET_INFO( laserdisc_sound )
 
 static STREAM_UPDATE( custom_stream_callback )
 {
-	sound_token *token = param;
+	sound_token *token = (sound_token *)param;
 	laserdisc_state *ld = token->ld;
 	ldcore_data *ldcore = ld->core;
 	stream_sample_t *dst0 = outputs[0];
@@ -1103,7 +1103,7 @@ static void configuration_save(running_machine *machine, int config_type, xml_da
 	/* iterate over disc devices */
 	for (device = device_list_first(machine->config->devicelist, LASERDISC); device != NULL; device = device_list_next(device, LASERDISC))
 	{
-		laserdisc_config *origconfig = device->inline_config;
+		laserdisc_config *origconfig = (laserdisc_config *)device->inline_config;
 		laserdisc_state *ld = get_safe_token(device);
 		ldcore_data *ldcore = ld->core;
 		xml_data_node *overnode;
@@ -1195,7 +1195,7 @@ VIDEO_UPDATE( laserdisc )
 	if (laserdisc != NULL)
 	{
 		const rectangle *visarea = video_screen_get_visible_area(screen);
-		laserdisc_state *ld = laserdisc->token;
+		laserdisc_state *ld = (laserdisc_state *)laserdisc->token;
 		ldcore_data *ldcore = ld->core;
 		bitmap_t *overbitmap = ldcore->overbitmap[ldcore->overindex];
 		bitmap_t *vidbitmap = NULL;
@@ -1299,7 +1299,7 @@ void laserdisc_set_config(const device_config *device, const laserdisc_config *c
 
 static void init_disc(const device_config *device)
 {
-	const laserdisc_config *config = device->inline_config;
+	const laserdisc_config *config = (const laserdisc_config *)device->inline_config;
 	laserdisc_state *ld = get_safe_token(device);
 	ldcore_data *ldcore = ld->core;
 	chd_error err;
@@ -1349,7 +1349,7 @@ static void init_disc(const device_config *device)
 		ldcore->chdtracks = totalhunks / 2;
 
 		/* allocate memory for the precomputed per-frame metadata */
-		ldcore->vbidata = auto_malloc(totalhunks * VBI_PACKED_BYTES);
+		ldcore->vbidata = (UINT8 *)auto_malloc(totalhunks * VBI_PACKED_BYTES);
 		err = chd_get_metadata(ldcore->disc, AV_LD_METADATA_TAG, 0, ldcore->vbidata, totalhunks * VBI_PACKED_BYTES, &vbilength, NULL, NULL);
 		if (err != CHDERR_NONE || vbilength != totalhunks * VBI_PACKED_BYTES)
 			fatalerror("Precomputed VBI metadata missing or incorrect size");
@@ -1382,7 +1382,7 @@ static void init_video(const device_config *device)
 		fillbitmap_yuy16(frame->bitmap, 40, 109, 240);
 
 		/* make a copy of the bitmap that clips out the VBI and horizontal blanking areas */
-		frame->visbitmap = auto_malloc(sizeof(*frame->visbitmap));
+		frame->visbitmap = (bitmap_t *)auto_malloc(sizeof(*frame->visbitmap));
 		*frame->visbitmap = *frame->bitmap;
 		frame->visbitmap->base = BITMAP_ADDR16(frame->visbitmap, 44, frame->bitmap->width * 8 / 720);
 		frame->visbitmap->height -= 44;
@@ -1410,8 +1410,8 @@ static void init_video(const device_config *device)
 	if (ldcore->config.overwidth > 0 && ldcore->config.overheight > 0 && ldcore->config.overupdate != NULL)
 	{
 		ldcore->overenable = TRUE;
-		ldcore->overbitmap[0] = auto_bitmap_alloc(ldcore->config.overwidth, ldcore->config.overheight, ldcore->config.overformat);
+		ldcore->overbitmap[0] = auto_bitmap_alloc(ldcore->config.overwidth, ldcore->config.overheight, (bitmap_format)ldcore->config.overformat);
-		ldcore->overbitmap[1] = auto_bitmap_alloc(ldcore->config.overwidth, ldcore->config.overheight, ldcore->config.overformat);
+		ldcore->overbitmap[1] = auto_bitmap_alloc(ldcore->config.overwidth, ldcore->config.overheight, (bitmap_format)ldcore->config.overformat);
 		ldcore->overtex = render_texture_alloc(NULL, NULL);
 		if (ldcore->overtex == NULL)
 			fatalerror("Out of memory allocating overlay texture");
@@ -1435,8 +1435,8 @@ static void init_audio(const device_config *device)
 	/* allocate audio buffers */
 	ldcore->audiomaxsamples = ((UINT64)ldcore->samplerate * 1000000 + ldcore->fps_times_1million - 1) / ldcore->fps_times_1million;
 	ldcore->audiobufsize = ldcore->audiomaxsamples * 4;
-	ldcore->audiobuffer[0] = auto_malloc(ldcore->audiobufsize * sizeof(ldcore->audiobuffer[0][0]));
+	ldcore->audiobuffer[0] = (INT16 *)auto_malloc(ldcore->audiobufsize * sizeof(ldcore->audiobuffer[0][0]));
-	ldcore->audiobuffer[1] = auto_malloc(ldcore->audiobufsize * sizeof(ldcore->audiobuffer[1][0]));
+	ldcore->audiobuffer[1] = (INT16 *)auto_malloc(ldcore->audiobufsize * sizeof(ldcore->audiobuffer[1][0]));
 }
 
 
@@ -1451,7 +1451,7 @@ static void init_audio(const device_config *device)
 
 static DEVICE_START( laserdisc )
 {
-	const laserdisc_config *config = device->inline_config;
+	const laserdisc_config *config = (const laserdisc_config *)device->inline_config;
 	laserdisc_state *ld = get_safe_token(device);
 	ldcore_data *ldcore;
 	int statesize;
@@ -1470,7 +1470,7 @@ static DEVICE_START( laserdisc )
 	ld->device = device;
 
 	/* allocate memory for the core state */
-	ld->core = auto_malloc(sizeof(*ld->core));
+	ld->core = (ldcore_data *)auto_malloc(sizeof(*ld->core));
 	memset(ld->core, 0, sizeof(*ld->core));
 	ldcore = ld->core;
 
@@ -1478,7 +1478,7 @@ static DEVICE_START( laserdisc )
 	statesize = 0;
 	for (index = 0; index < ARRAY_LENGTH(player_interfaces); index++)
 		statesize = MAX(statesize, player_interfaces[index]->statesize);
-	ld->player = auto_malloc(statesize);
+	ld->player = (ldplayer_data *)auto_malloc(statesize);
 	memset(ld->player, 0, statesize);
 
 	/* copy config data to the live state */
@@ -1549,7 +1549,7 @@ static DEVICE_RESET( laserdisc )
 	/* attempt to wire up the audio */
 	if (ldcore->audiocustom != NULL)
 	{
-		sound_token *token = ldcore->audiocustom->token;
+		sound_token *token = (sound_token *)ldcore->audiocustom->token;
 		token->ld = ld;
 		stream_set_sample_rate(token->stream, ldcore->samplerate);
 	}
@@ -1608,8 +1608,8 @@ DEVICE_GET_INFO( laserdisc )
 	/* if we have a device, figure out where our config lives */
 	if (device != NULL)
 	{
-		laserdisc_state *ld = device->token;
+		laserdisc_state *ld = (laserdisc_state *)device->token;
-		config = device->inline_config;
+		config = (const laserdisc_config *)device->inline_config;
 		if (ld != NULL && ld->core != NULL)
 		{
 			config = &ld->core->config;

src/emu/machine/ldcore.h

@@ -137,7 +137,7 @@ typedef void (*laserdisc_init_func)(laserdisc_state *ld);
 typedef void (*laserdisc_vsync_func)(laserdisc_state *ld, const vbi_metadata *vbi, int fieldnum, attotime curtime);
 typedef INT32 (*laserdisc_update_func)(laserdisc_state *ld, const vbi_metadata *vbi, int fieldnum, attotime curtime);
 typedef void (*laserdisc_overlay_func)(laserdisc_state *ld, bitmap_t *bitmap);
-typedef void (*laserdisc_w_func)(laserdisc_state *ld, UINT8 prev, UINT8 new);
+typedef void (*laserdisc_w_func)(laserdisc_state *ld, UINT8 prev, UINT8 newval);
 typedef UINT8 (*laserdisc_r_func)(laserdisc_state *ld);
 
 

src/emu/machine/ldpr8210.c

@@ -521,7 +521,7 @@ static void pr8210_control_w(laserdisc_state *ld, UINT8 prev, UINT8 data)
 
 static TIMER_CALLBACK( vsync_off )
 {
-	laserdisc_state *ld = ptr;
+	laserdisc_state *ld = (laserdisc_state *)ptr;
 	ld->player->vsync = FALSE;
 }
 
@@ -535,7 +535,7 @@ static TIMER_CALLBACK( vsync_off )
 
 static TIMER_CALLBACK( vbi_data_fetch )
 {
-	laserdisc_state *ld = ptr;
+	laserdisc_state *ld = (laserdisc_state *)ptr;
 	ldplayer_data *player = ld->player;
 	UINT8 focus_on = !(player->port1 & 0x08);
 	UINT8 laser_on = !(player->port2 & 0x01);
@@ -1097,7 +1097,7 @@ static void simutrek_init(laserdisc_state *ld)
 
 static TIMER_CALLBACK( irq_off )
 {
-	laserdisc_state *ld = ptr;
+	laserdisc_state *ld = (laserdisc_state *)ptr;
 	ldplayer_data *player = ld->player;
 	cpu_set_input_line(player->simutrek.cpu, MCS48_INPUT_IRQ, CLEAR_LINE);
 	if (LOG_SIMUTREK)
@@ -1181,7 +1181,7 @@ static void simutrek_data_w(laserdisc_state *ld, UINT8 prev, UINT8 data)
 
 static TIMER_CALLBACK( simutrek_latched_data_w )
 {
-	laserdisc_state *ld = ptr;
+	laserdisc_state *ld = (laserdisc_state *)ptr;
 	ldplayer_data *player = ld->player;
 
 	/* store the data and set the ready flag */

src/emu/machine/ldv1000.c

@@ -333,7 +333,7 @@ static UINT8 ldv1000_status_r(laserdisc_state *ld)
 
 static TIMER_CALLBACK( vsync_off )
 {
-	laserdisc_state *ld = ptr;
+	laserdisc_state *ld = (laserdisc_state *)ptr;
 	ld->player->vsync = FALSE;
 }
 
@@ -347,7 +347,7 @@ static TIMER_CALLBACK( vsync_off )
 
 static TIMER_CALLBACK( vbi_data_fetch )
 {
-	laserdisc_state *ld = ptr;
+	laserdisc_state *ld = (laserdisc_state *)ptr;
 	ldplayer_data *player = ld->player;
 	UINT8 focus_on = !(player->portb1 & 0x01);
 	UINT8 laser_on = (player->portb1 & 0x40);
@@ -398,7 +398,7 @@ static TIMER_CALLBACK( vbi_data_fetch )
 
 static TIMER_DEVICE_CALLBACK( multijump_timer )
 {
-	laserdisc_state *ld = ptr;
+	laserdisc_state *ld = (laserdisc_state *)ptr;
 	ldplayer_data *player = ld->player;
 	int direction;
 

src/emu/machine/ldvp931.c

@@ -321,7 +321,7 @@ static UINT8 vp931_data_ready(laserdisc_state *ld)
 
 static TIMER_CALLBACK( vbi_data_fetch )
 {
-	laserdisc_state *ld = ptr;
+	laserdisc_state *ld = (laserdisc_state *)ptr;
 	ldplayer_data *player = ld->player;
 	int which = param & 3;
 	int line = param >> 2;
@@ -364,7 +364,7 @@ static TIMER_CALLBACK( vbi_data_fetch )
 
 static TIMER_CALLBACK( deferred_data_w )
 {
-	laserdisc_state *ld = ptr;
+	laserdisc_state *ld = (laserdisc_state *)ptr;
 	ldplayer_data *player = ld->player;
 
 	/* set the value and mark it pending */
@@ -389,7 +389,7 @@ static TIMER_CALLBACK( deferred_data_w )
 
 static TIMER_CALLBACK( irq_off )
 {
-	laserdisc_state *ld = ptr;
+	laserdisc_state *ld = (laserdisc_state *)ptr;
 	cpu_set_input_line(ld->player->cpu, MCS48_INPUT_IRQ, CLEAR_LINE);
 }
 
@@ -401,7 +401,7 @@ static TIMER_CALLBACK( irq_off )
 
 static TIMER_CALLBACK( datastrobe_off )
 {
-	laserdisc_state *ld = ptr;
+	laserdisc_state *ld = (laserdisc_state *)ptr;
 	ld->player->datastrobe = 0;
 }
 
@@ -412,7 +412,7 @@ static TIMER_CALLBACK( datastrobe_off )
 
 static TIMER_CALLBACK( erp_off )
 {
-	laserdisc_state *ld = ptr;
+	laserdisc_state *ld = (laserdisc_state *)ptr;
 	ld->player->daticerp = 0;
 }
 
@@ -423,7 +423,7 @@ static TIMER_CALLBACK( erp_off )
 
 static TIMER_DEVICE_CALLBACK( track_timer )
 {
-	laserdisc_state *ld = ptr;
+	laserdisc_state *ld = (laserdisc_state *)ptr;
 	ldplayer_data *player = ld->player;
 
 	/* advance by the count and toggle the state */

src/emu/machine/mc146818.c

@@ -199,7 +199,7 @@ static TIMER_CALLBACK( mc146818_timer )
 
 void mc146818_init(running_machine *machine, MC146818_TYPE type)
 {
-	mc146818 = auto_malloc(sizeof(*mc146818));
+	mc146818 = (struct mc146818_chip *)auto_malloc(sizeof(*mc146818));
 	memset(mc146818, 0, sizeof(*mc146818));
 	mc146818->type = type;
 	mc146818->last_refresh = timer_get_time(machine);

src/emu/machine/pci.c

@@ -211,7 +211,7 @@ static DEVICE_START( pci_bus )
 	assert(device->machine->config != NULL);
 
 	/* store a pointer back to the device */
-	pcibus->config = device->inline_config;
+	pcibus->config = (const pci_bus_config *)device->inline_config;
 	pcibus->busdevice = device;
 	pcibus->devicenum = -1;
 

src/emu/machine/pic8259.c

@@ -80,7 +80,7 @@ INLINE pic8259_t *get_safe_token(const device_config *device) {
 
 static TIMER_CALLBACK( pic8259_timerproc )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	pic8259_t	*pic8259 = get_safe_token(device);
 	int irq;
 	UINT8 mask;
@@ -394,7 +394,7 @@ WRITE8_DEVICE_HANDLER( pic8259_w )
 static DEVICE_START( pic8259 ) {
 	pic8259_t	*pic8259 = get_safe_token(device);
 
-	pic8259->intf = device->static_config;
+	pic8259->intf = (const struct pic8259_interface *)device->static_config;
 
 	pic8259->timer = timer_alloc( device->machine, pic8259_timerproc, (void *)device );
 }

src/emu/machine/pit8253.c

@@ -657,7 +657,7 @@ static void	update(const device_config *device, struct pit8253_timer *timer)
 
 static TIMER_CALLBACK( update_timer_cb )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	pit8253_t	*pit8253 = get_safe_token(device);
 	struct pit8253_timer *timer = get_timer(pit8253,param);
 
@@ -1042,7 +1042,7 @@ static void common_start( const device_config *device, int device_type ) {
 	pit8253_t	*pit8253 = get_safe_token(device);
 	int			timerno;
 
-	pit8253->config = device->static_config;
+	pit8253->config = (const struct pit8253_config *)device->static_config;
 	pit8253->device_type = device_type;
 
 	/* register for state saving */

src/emu/machine/scsicd.c

@@ -42,7 +42,7 @@ static int scsicd_exec_command( SCSIInstance *scsiInstance, UINT8 *statusCode )
 {
 	UINT8 *command;
 	int commandLength;
-	SCSICd *our_this = SCSIThis( &SCSIClassCDROM, scsiInstance );
+	SCSICd *our_this = (SCSICd *)SCSIThis( &SCSIClassCDROM, scsiInstance );
 
 	cdrom_file *cdrom = our_this->cdrom;
 	const device_config *cdda;
@@ -310,7 +310,7 @@ static void scsicd_read_data( SCSIInstance *scsiInstance, UINT8 *data, int dataL
 {
 	UINT8 *command;
 	int commandLength;
-	SCSICd *our_this = SCSIThis( &SCSIClassCDROM, scsiInstance );
+	SCSICd *our_this = (SCSICd *)SCSIThis( &SCSIClassCDROM, scsiInstance );
 
 	int i;
 	UINT32 last_phys_frame;
@@ -629,7 +629,7 @@ static void scsicd_write_data( SCSIInstance *scsiInstance, UINT8 *data, int data
 {
 	UINT8 *command;
 	int commandLength;
-	SCSICd *our_this = SCSIThis( &SCSIClassCDROM, scsiInstance );
+	SCSICd *our_this = (SCSICd *)SCSIThis( &SCSIClassCDROM, scsiInstance );
 	SCSIGetCommand( scsiInstance, &command, &commandLength );
 
 	switch (command[ 0 ])
@@ -673,7 +673,7 @@ static void scsicd_write_data( SCSIInstance *scsiInstance, UINT8 *data, int data
 static void scsicd_alloc_instance( SCSIInstance *scsiInstance, const char *diskregion )
 {
 	running_machine *machine = scsiInstance->machine;
-	SCSICd *our_this = SCSIThis( &SCSIClassCDROM, scsiInstance );
+	SCSICd *our_this = (SCSICd *)SCSIThis( &SCSIClassCDROM, scsiInstance );
 
 	our_this->lba = 0;
 	our_this->blocks = 0;
@@ -707,7 +707,7 @@ static void scsicd_alloc_instance( SCSIInstance *scsiInstance, const char *diskr
 static void scsicd_delete_instance( SCSIInstance *scsiInstance )
 {
 #ifndef MESS
-	SCSICd *our_this = SCSIThis( &SCSIClassCDROM, scsiInstance );
+	SCSICd *our_this = (SCSICd *)SCSIThis( &SCSIClassCDROM, scsiInstance );
 	if( our_this->cdrom )
 	{
 		cdrom_close( our_this->cdrom );
@@ -717,13 +717,13 @@ static void scsicd_delete_instance( SCSIInstance *scsiInstance )
 
 static void scsicd_get_device( SCSIInstance *scsiInstance, cdrom_file **cdrom )
 {
-	SCSICd *our_this = SCSIThis( &SCSIClassCDROM, scsiInstance );
+	SCSICd *our_this = (SCSICd *)SCSIThis( &SCSIClassCDROM, scsiInstance );
 	*cdrom = our_this->cdrom;
 }
 
 static void scsicd_set_device( SCSIInstance *scsiInstance, cdrom_file *cdrom )
 {
-	SCSICd *our_this = SCSIThis( &SCSIClassCDROM, scsiInstance );
+	SCSICd *our_this = (SCSICd *)SCSIThis( &SCSIClassCDROM, scsiInstance );
 	our_this->cdrom = cdrom;
 }
 
@@ -734,36 +734,36 @@ static int scsicd_dispatch(int operation, void *file, INT64 intparm, void *ptrpa
 	switch (operation)
 	{
 		case SCSIOP_EXEC_COMMAND:
-			return scsicd_exec_command( file, ptrparm );
+			return scsicd_exec_command( (SCSIInstance *)file, (UINT8 *)ptrparm );
 
 		case SCSIOP_READ_DATA:
-			scsicd_read_data( file, ptrparm, intparm );
+			scsicd_read_data( (SCSIInstance *)file, (UINT8 *)ptrparm, intparm );
 			return 0;
 
 		case SCSIOP_WRITE_DATA:
-			scsicd_write_data( file, ptrparm, intparm );
+			scsicd_write_data( (SCSIInstance *)file, (UINT8 *)ptrparm, intparm );
 			return 0;
 
 		case SCSIOP_ALLOC_INSTANCE:
-			params = ptrparm;
+			params = (SCSIAllocInstanceParams *)ptrparm;
-			SCSIBase( &SCSIClassCDROM, operation, file, intparm, ptrparm );
+			SCSIBase( &SCSIClassCDROM, operation, (SCSIInstance *)file, intparm, (UINT8 *)ptrparm );
 			scsicd_alloc_instance( params->instance, params->diskregion );
 			return 0;
 
 		case SCSIOP_DELETE_INSTANCE:
-			scsicd_delete_instance( file );
+			scsicd_delete_instance( (SCSIInstance *)file );
 			break;
 
 		case SCSIOP_GET_DEVICE:
-			scsicd_get_device( file, ptrparm );
+			scsicd_get_device( (SCSIInstance *)file, (cdrom_file **)ptrparm );
 			return 0;
 
 		case SCSIOP_SET_DEVICE:
-			scsicd_set_device( file, ptrparm );
+			scsicd_set_device( (SCSIInstance *)file, (cdrom_file *)ptrparm );
 			return 0;
 	}
 
-	return SCSIBase( &SCSIClassCDROM, operation, file, intparm, ptrparm );
+	return SCSIBase( &SCSIClassCDROM, operation, (SCSIInstance *)file, intparm, (UINT8 *)ptrparm );
 }
 
 const SCSIClass SCSIClassCDROM =

src/emu/machine/scsidev.c

@@ -17,7 +17,7 @@ static int scsidev_exec_command( SCSIInstance *scsiInstance, UINT8 *statusCode )
 {
 	UINT8 *command;
 	int commandLength;
-//  SCSIDev *our_this = SCSIThis( &SCSIClassDevice, scsiInstance );
+//  SCSIDev *our_this = (SCSIDev *)SCSIThis( &SCSIClassDevice, scsiInstance );
 	SCSIGetCommand( scsiInstance, &command, &commandLength );
 
 	switch( command[ 0 ] )
@@ -36,7 +36,7 @@ static void scsidev_read_data( SCSIInstance *scsiInstance, UINT8 *data, int data
 {
 	UINT8 *command;
 	int commandLength;
-//  SCSIDev *our_this = SCSIThis( &SCSIClassDevice, scsiInstance );
+//  SCSIDev *our_this = (SCSIDev *)SCSIThis( &SCSIClassDevice, scsiInstance );
 	SCSIGetCommand( scsiInstance, &command, &commandLength );
 
 	switch( command[ 0 ] )
@@ -51,7 +51,7 @@ static void scsidev_write_data( SCSIInstance *scsiInstance, UINT8 *data, int dat
 {
 	UINT8 *command;
 	int commandLength;
-//  SCSIDev *our_this = SCSIThis( &SCSIClassDevice, scsiInstance );
+//  SCSIDev *our_this = (SCSIDev *)SCSIThis( &SCSIClassDevice, scsiInstance );
 	SCSIGetCommand( scsiInstance, &command, &commandLength );
 
 	switch( command[ 0 ] )
@@ -64,19 +64,19 @@ static void scsidev_write_data( SCSIInstance *scsiInstance, UINT8 *data, int dat
 
 static void scsidev_set_phase( SCSIInstance *scsiInstance, int phase )
 {
-	SCSIDev *our_this = SCSIThis( &SCSIClassDevice, scsiInstance );
+	SCSIDev *our_this = (SCSIDev *)SCSIThis( &SCSIClassDevice, scsiInstance );
 	our_this->phase = phase;
 }
 
 static int scsidev_get_phase( SCSIInstance *scsiInstance )
 {
-	SCSIDev *our_this = SCSIThis( &SCSIClassDevice, scsiInstance );
+	SCSIDev *our_this = (SCSIDev *)SCSIThis( &SCSIClassDevice, scsiInstance );
 	return our_this->phase;
 }
 
 static void scsidev_set_command( SCSIInstance *scsiInstance, void *command, int commandLength )
 {
-	SCSIDev *our_this = SCSIThis( &SCSIClassDevice, scsiInstance );
+	SCSIDev *our_this = (SCSIDev *)SCSIThis( &SCSIClassDevice, scsiInstance );
 
 	if( commandLength > sizeof( our_this->command ) )
 	{
@@ -92,7 +92,7 @@ static void scsidev_set_command( SCSIInstance *scsiInstance, void *command, int
 
 static int scsidev_get_command( SCSIInstance *scsiInstance, void **command )
 {
-	SCSIDev *our_this = SCSIThis( &SCSIClassDevice, scsiInstance );
+	SCSIDev *our_this = (SCSIDev *)SCSIThis( &SCSIClassDevice, scsiInstance );
 	*command = our_this->command;
 	return our_this->commandLength;
 }
@@ -100,7 +100,7 @@ static int scsidev_get_command( SCSIInstance *scsiInstance, void **command )
 static void scsidev_alloc_instance( SCSIInstance *scsiInstance, const char *diskregion )
 {
 	running_machine *machine = scsiInstance->machine;
-	SCSIDev *our_this = SCSIThis( &SCSIClassDevice, scsiInstance );
+	SCSIDev *our_this = (SCSIDev *)SCSIThis( &SCSIClassDevice, scsiInstance );
 
 	state_save_register_item_array( machine, "scsidev", diskregion, 0, our_this->command );
 	state_save_register_item( machine, "scsidev", diskregion, 0, our_this->commandLength );
@@ -114,38 +114,38 @@ static int scsidev_dispatch( int operation, void *file, INT64 intparm, void *ptr
 	switch( operation )
 	{
 		case SCSIOP_EXEC_COMMAND:
-			return scsidev_exec_command( file, ptrparm );
+			return scsidev_exec_command( (SCSIInstance *)file, (UINT8 *)ptrparm );
 
 		case SCSIOP_READ_DATA:
-			scsidev_read_data( file, ptrparm, intparm );
+			scsidev_read_data( (SCSIInstance *)file, (UINT8 *)ptrparm, intparm );
 			break;
 
 		case SCSIOP_WRITE_DATA:
-			scsidev_write_data( file, ptrparm, intparm );
+			scsidev_write_data( (SCSIInstance *)file, (UINT8 *)ptrparm, intparm );
 			break;
 
 		case SCSIOP_SET_PHASE:
-			scsidev_set_phase( file, intparm );
+			scsidev_set_phase( (SCSIInstance *)file, intparm );
 			return 0;
 
 		case SCSIOP_GET_PHASE:
-			return scsidev_get_phase( file );
+			return scsidev_get_phase( (SCSIInstance *)file );
 
 		case SCSIOP_SET_COMMAND:
-			scsidev_set_command( file, ptrparm, intparm );
+			scsidev_set_command( (SCSIInstance *)file, (UINT8 *)ptrparm, intparm );
 			return 0;
 
 		case SCSIOP_GET_COMMAND:
-			return scsidev_get_command( file, ptrparm );
+			return scsidev_get_command( (SCSIInstance *)file, (void **)ptrparm );
 
 		case SCSIOP_ALLOC_INSTANCE:
-			params = ptrparm;
+			params = (SCSIAllocInstanceParams *)ptrparm;
-			params->instance = SCSIMalloc( params->machine, file );
+			params->instance = SCSIMalloc( params->machine, (const SCSIClass *)file );
 			scsidev_alloc_instance( params->instance, params->diskregion );
 			return 0;
 
 		case SCSIOP_DELETE_INSTANCE:
-			free( file );
+			free( (SCSIInstance *)file );
 			return 0;
 	}
 	return 0;

src/emu/machine/scsihd.c

@@ -27,7 +27,7 @@ static int scsihd_exec_command( SCSIInstance *scsiInstance, UINT8 *statusCode )
 {
 	UINT8 *command;
 	int commandLength;
-	SCSIHd *our_this = SCSIThis( &SCSIClassHARDDISK, scsiInstance );
+	SCSIHd *our_this = (SCSIHd *)SCSIThis( &SCSIClassHARDDISK, scsiInstance );
 	SCSIGetCommand( scsiInstance, &command, &commandLength );
 
 	switch ( command[0] )
@@ -103,7 +103,7 @@ static void scsihd_read_data( SCSIInstance *scsiInstance, UINT8 *data, int dataL
 	int i;
 	UINT8 *command;
 	int commandLength;
-	SCSIHd *our_this = SCSIThis( &SCSIClassHARDDISK, scsiInstance );
+	SCSIHd *our_this = (SCSIHd *)SCSIThis( &SCSIClassHARDDISK, scsiInstance );
 	SCSIGetCommand( scsiInstance, &command, &commandLength );
 
 	switch ( command[0] )
@@ -194,7 +194,7 @@ static void scsihd_write_data( SCSIInstance *scsiInstance, UINT8 *data, int data
 {
 	UINT8 *command;
 	int commandLength;
-	SCSIHd *our_this = SCSIThis( &SCSIClassHARDDISK, scsiInstance );
+	SCSIHd *our_this = (SCSIHd *)SCSIThis( &SCSIClassHARDDISK, scsiInstance );
 	SCSIGetCommand( scsiInstance, &command, &commandLength );
 
 	switch ( command[0] )
@@ -225,7 +225,7 @@ static void scsihd_write_data( SCSIInstance *scsiInstance, UINT8 *data, int data
 static void scsihd_alloc_instance( SCSIInstance *scsiInstance, const char *diskregion )
 {
 	running_machine *machine = scsiInstance->machine;
-	SCSIHd *our_this = SCSIThis( &SCSIClassHARDDISK, scsiInstance );
+	SCSIHd *our_this = (SCSIHd *)SCSIThis( &SCSIClassHARDDISK, scsiInstance );
 
 	our_this->lba = 0;
 	our_this->blocks = 0;
@@ -249,7 +249,7 @@ static void scsihd_alloc_instance( SCSIInstance *scsiInstance, const char *diskr
 static void scsihd_delete_instance( SCSIInstance *scsiInstance )
 {
 #ifndef MESS
-	SCSIHd *our_this = SCSIThis( &SCSIClassHARDDISK, scsiInstance );
+	SCSIHd *our_this = (SCSIHd *)SCSIThis( &SCSIClassHARDDISK, scsiInstance );
 
 	if( our_this->disk )
 	{
@@ -260,13 +260,13 @@ static void scsihd_delete_instance( SCSIInstance *scsiInstance )
 
 static void scsihd_get_device( SCSIInstance *scsiInstance, hard_disk_file **disk )
 {
-	SCSIHd *our_this = SCSIThis( &SCSIClassHARDDISK, scsiInstance );
+	SCSIHd *our_this = (SCSIHd *)SCSIThis( &SCSIClassHARDDISK, scsiInstance );
 	*disk = our_this->disk;
 }
 
 static void scsihd_set_device( SCSIInstance *scsiInstance, hard_disk_file *disk )
 {
-	SCSIHd *our_this = SCSIThis( &SCSIClassHARDDISK, scsiInstance );
+	SCSIHd *our_this = (SCSIHd *)SCSIThis( &SCSIClassHARDDISK, scsiInstance );
 	our_this->disk = disk;
 }
 
@@ -277,36 +277,36 @@ static int scsihd_dispatch(int operation, void *file, INT64 intparm, void *ptrpa
 	switch (operation)
 	{
 		case SCSIOP_EXEC_COMMAND:
-			return scsihd_exec_command( file, ptrparm );
+			return scsihd_exec_command( (SCSIInstance *)file, (UINT8 *)ptrparm );
 
 		case SCSIOP_READ_DATA:
-			scsihd_read_data( file, ptrparm, intparm );
+			scsihd_read_data( (SCSIInstance *)file, (UINT8 *)ptrparm, intparm );
 			return 0;
 
 		case SCSIOP_WRITE_DATA:
-			scsihd_write_data( file, ptrparm, intparm );
+			scsihd_write_data( (SCSIInstance *)file, (UINT8 *)ptrparm, intparm );
 			return 0;
 
 		case SCSIOP_ALLOC_INSTANCE:
-			params = ptrparm;
+			params = (SCSIAllocInstanceParams *)ptrparm;
-			SCSIBase( &SCSIClassHARDDISK, operation, file, intparm, ptrparm );
+			SCSIBase( &SCSIClassHARDDISK, operation, (SCSIInstance *)file, intparm, (UINT8 *)ptrparm );
 			scsihd_alloc_instance( params->instance, params->diskregion );
 			return 0;
 
 		case SCSIOP_DELETE_INSTANCE:
-			scsihd_delete_instance( file );
+			scsihd_delete_instance( (SCSIInstance *)file );
 			break;
 
 		case SCSIOP_GET_DEVICE:
-			scsihd_get_device( file, ptrparm );
+			scsihd_get_device( (SCSIInstance *)file, (hard_disk_file **)ptrparm );
 			return 0;
 
 		case SCSIOP_SET_DEVICE:
-			scsihd_set_device( file, ptrparm );
+			scsihd_set_device( (SCSIInstance *)file, (hard_disk_file *)ptrparm );
 			return 0;
 	}
 
-	return SCSIBase( &SCSIClassHARDDISK, operation, file, intparm, ptrparm );
+	return SCSIBase( &SCSIClassHARDDISK, operation, (SCSIInstance *)file, intparm, (UINT8 *)ptrparm );
 }
 
 const SCSIClass SCSIClassHARDDISK =

src/emu/machine/smc91c9x.c

@@ -510,7 +510,7 @@ WRITE16_DEVICE_HANDLER( smc91c9x_w )
 
 static DEVICE_START( smc91c9x )
 {
-	const smc91c9x_config *config = device->inline_config;
+	const smc91c9x_config *config = (const smc91c9x_config *)device->inline_config;
 	smc91c9x_state *smc = get_safe_token(device);
 
 	/* validate some basic stuff */

src/emu/machine/timekpr.c

@@ -308,7 +308,7 @@ static DEVICE_START(timekeeper)
 	c->month = make_bcd( systime.local_time.month + 1 );
 	c->year = make_bcd( systime.local_time.year % 100 );
 	c->century = make_bcd( systime.local_time.year / 100 );
-	c->data = auto_malloc( c->size );
+	c->data = (UINT8 *)auto_malloc( c->size );
 
 	c->default_data = device->region;
 	if (c->default_data != NULL)

src/emu/machine/wd33c93.c

@@ -798,7 +798,7 @@ void wd33c93_init( running_machine *machine, const struct WD33C93interface *inte
 	/* allocate a timer for commands */
 	scsi_data.cmd_timer = timer_alloc(machine, wd33c93_complete_cb, NULL);
 
-	scsi_data.temp_input = auto_malloc( TEMP_INPUT_LEN );
+	scsi_data.temp_input = (UINT8 *)auto_malloc( TEMP_INPUT_LEN );
 
 //  state_save_register_item_array(machine, "wd33c93", NULL, 0, scsi_data);
 }

src/emu/machine/x2212.c

@@ -88,12 +88,12 @@ static DEVICE_START(x2212)
 	assert(device->machine != NULL);
 	assert(device->machine->config != NULL);
 
-	c->sram = auto_malloc( SIZE_DATA );
+	c->sram = (UINT8 *)auto_malloc( SIZE_DATA );
-	c->e2prom = auto_malloc( SIZE_DATA );
+	c->e2prom = (UINT8 *)auto_malloc( SIZE_DATA );
 	c->store = 1;
 	c->array_recall = 1;
 
-	config = device->static_config;
+	config = (const x2212_config *)device->static_config;
 	if( config != NULL && config->data != NULL )
 	{
 		c->default_data = memory_region( device->machine, config->data );

src/emu/machine/x76f041.c

@@ -115,7 +115,7 @@ void x76f041_init( running_machine *machine, int chip, UINT8 *data )
 
 	if( data == NULL )
 	{
-		data = auto_malloc(
+		data = (UINT8 *)auto_malloc(
 			SIZE_RESPONSE_TO_RESET +
 			SIZE_READ_PASSWORD +
 			SIZE_WRITE_PASSWORD +

src/emu/machine/x76f100.c

@@ -84,7 +84,7 @@ void x76f100_init( running_machine *machine, int chip, UINT8 *data )
 
 	if( data == NULL )
 	{
-		data = auto_malloc(
+		data = (UINT8 *)auto_malloc(
 			SIZE_RESPONSE_TO_RESET +
 			SIZE_READ_PASSWORD +
 			SIZE_WRITE_PASSWORD +

src/emu/machine/z80ctc.c

@@ -138,7 +138,7 @@ static void interrupt_check(const device_config *device)
 
 static TIMER_CALLBACK( timercallback )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	z80ctc *ctc = get_safe_token(device);
 	ctc_channel *channel = &ctc->channel[param];
 
@@ -461,7 +461,7 @@ static void z80ctc_irq_reti(const device_config *device)
 
 static DEVICE_START( z80ctc )
 {
-	const z80ctc_interface *intf = device->static_config;
+	const z80ctc_interface *intf = (const z80ctc_interface *)device->static_config;
 	astring *tempstring = astring_alloc();
 	z80ctc *ctc = get_safe_token(device);
 	int ch;

src/emu/machine/z80dma.c

@@ -201,7 +201,7 @@ static int z80dma_do_write(const device_config *device)
 
 static TIMER_CALLBACK( z80dma_timerproc )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	z80dma_t *cntx = get_safe_token(device);
 	int done;
 
@@ -390,7 +390,7 @@ WRITE8_DEVICE_HANDLER( z80dma_w )
 
 static TIMER_CALLBACK( z80dma_rdy_write_callback )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	int state = param & 0x01;
 	z80dma_t *cntx = get_safe_token(device);
 
@@ -447,7 +447,7 @@ static DEVICE_START( z80dma )
 	assert(device != NULL);
 	assert(device->tag != NULL);
 
-	z80dma->intf = device->static_config;
+	z80dma->intf = (const z80dma_interface *)device->static_config;
 
 	z80dma->timer = timer_alloc(device->machine, z80dma_timerproc, (void *) device);
 

src/emu/machine/z80pio.c

@@ -535,7 +535,7 @@ WRITE8_DEVICE_HANDLER(z80pio_w)
 
 static DEVICE_START( z80pio )
 {
-	const z80pio_interface *intf = device->static_config;
+	const z80pio_interface *intf = (const z80pio_interface *)device->static_config;
 	z80pio_t *z80pio = get_safe_token( device );
 
 	z80pio->intr = intf->intr;

src/emu/machine/z80sio.c

@@ -524,7 +524,7 @@ READ8_DEVICE_HANDLER( z80sio_get_rts )
 
 static TIMER_CALLBACK( change_input_line )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	z80sio *sio = get_safe_token(device);
 	sio_channel *chan = &sio->chan[param & 1];
 	UINT8 line = (param >> 8) & 0xff;
@@ -607,7 +607,7 @@ WRITE8_DEVICE_HANDLER( z80sio_receive_data )
 
 static TIMER_CALLBACK( serial_callback )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	z80sio *sio = get_safe_token(device);
 	sio_channel *chan = &sio->chan[param];
 	int ch = param;
@@ -782,7 +782,7 @@ static void z80sio_irq_reti(const device_config *device)
 
 static DEVICE_START( z80sio )
 {
-	const z80sio_interface *intf = device->static_config;
+	const z80sio_interface *intf = (const z80sio_interface *)device->static_config;
 	astring *tempstring = astring_alloc();
 	z80sio *sio = get_safe_token(device);
 	void *ptr = (void *)device;

src/emu/mame.c

@@ -458,7 +458,7 @@ void add_frame_callback(running_machine *machine, void (*callback)(running_machi
 	assert_always(mame_get_phase(machine) == MAME_PHASE_INIT, "Can only call add_frame_callback at init time!");
 
 	/* allocate memory */
-	cb = malloc_or_die(sizeof(*cb));
+	cb = (callback_item *)malloc_or_die(sizeof(*cb));
 
 	/* add us to the end of the list */
 	cb->func.frame = callback;
@@ -481,7 +481,7 @@ void add_reset_callback(running_machine *machine, void (*callback)(running_machi
 	assert_always(mame_get_phase(machine) == MAME_PHASE_INIT, "Can only call add_reset_callback at init time!");
 
 	/* allocate memory */
-	cb = malloc_or_die(sizeof(*cb));
+	cb = (callback_item *)malloc_or_die(sizeof(*cb));
 
 	/* add us to the end of the list */
 	cb->func.reset = callback;
@@ -504,7 +504,7 @@ void add_pause_callback(running_machine *machine, void (*callback)(running_machi
 	assert_always(mame_get_phase(machine) == MAME_PHASE_INIT, "Can only call add_pause_callback at init time!");
 
 	/* allocate memory */
-	cb = malloc_or_die(sizeof(*cb));
+	cb = (callback_item *)malloc_or_die(sizeof(*cb));
 
 	/* add us to the end of the list */
 	cb->func.pause = callback;
@@ -527,7 +527,7 @@ void add_exit_callback(running_machine *machine, void (*callback)(running_machin
 	assert_always(mame_get_phase(machine) == MAME_PHASE_INIT, "Can only call add_exit_callback at init time!");
 
 	/* allocate memory */
-	cb = malloc_or_die(sizeof(*cb));
+	cb = (callback_item *)malloc_or_die(sizeof(*cb));
 
 	/* add us to the head of the list */
 	cb->func.exit = callback;
@@ -782,7 +782,7 @@ UINT8 *memory_region_alloc(running_machine *machine, const char *name, UINT32 le
     		fatalerror("memory_region_alloc called with duplicate region name \"%s\"\n", name);
 
 	/* allocate the region */
-	info = malloc_or_die(sizeof(*info) + length);
+	info = (region_info *)malloc_or_die(sizeof(*info) + length);
 	info->next = NULL;
 	info->name = astring_dupc(name);
 	info->length = length;
@@ -1247,7 +1247,7 @@ void add_logerror_callback(running_machine *machine, void (*callback)(running_ma
 
 	assert_always(mame_get_phase(machine) == MAME_PHASE_INIT, "Can only call add_logerror_callback at init time!");
 
-	cb = auto_malloc(sizeof(*cb));
+	cb = (callback_item *)auto_malloc(sizeof(*cb));
 	cb->func.log = callback;
 	cb->next = NULL;
 
@@ -1318,7 +1318,7 @@ void mame_parse_ini_files(core_options *options, const game_driver *driver)
 		config = machine_config_alloc(driver->machine_config);
 		for (device = video_screen_first(config); device != NULL; device = video_screen_next(device))
 		{
-			const screen_config *scrconfig = device->inline_config;
+			const screen_config *scrconfig = (const screen_config *)device->inline_config;
 			if (scrconfig->type == SCREEN_TYPE_VECTOR)
 			{
 				parse_ini_file(options, "vector");
@@ -1387,13 +1387,13 @@ static running_machine *create_machine(const game_driver *driver)
 	int cpunum;
 
 	/* allocate memory for the machine */
-	machine = malloc(sizeof(*machine));
+	machine = (running_machine *)malloc(sizeof(*machine));
 	if (machine == NULL)
 		goto error;
 	memset(machine, 0, sizeof(*machine));
 
 	/* allocate memory for the internal mame_data */
-	machine->mame_data = malloc(sizeof(*machine->mame_data));
+	machine->mame_data = (mame_private *)malloc(sizeof(*machine->mame_data));
 	if (machine->mame_data == NULL)
 		goto error;
 	memset(machine->mame_data, 0, sizeof(*machine->mame_data));

src/emu/mamecore.h

@@ -174,6 +174,18 @@ enum
     COMMON MACROS
 ***************************************************************************/
 
+/* Macro for declaring enumerator operators for easier porting */
+#ifdef __cplusplus
+#define DECLARE_ENUM_OPERATORS(type) \
+inline void operator++(type &value) { value = (type)((int)value + 1); } \
+inline void operator++(type &value, int) { value = (type)((int)value + 1); } \
+inline void operator--(type &value) { value = (type)((int)value - 1); } \
+inline void operator--(type &value, int) { value = (type)((int)value - 1); }
+#else
+#define DECLARE_ENUM_OPERATORS(type)
+#endif
+
+
 /* Standard MAME assertion macros */
 #undef assert
 #undef assert_always
@@ -182,7 +194,7 @@ enum
 #define assert(x)	do { if (!(x)) fatalerror("assert: %s:%d: %s", __FILE__, __LINE__, #x); } while (0)
 #define assert_always(x, msg) do { if (!(x)) fatalerror("Fatal error: %s\nCaused by assert: %s:%d: %s", msg, __FILE__, __LINE__, #x); } while (0)
 #else
-#define assert(x)
+#define assert(x)	do { } while (0)
 #define assert_always(x, msg) do { if (!(x)) fatalerror("Fatal error: %s (%s:%d)", msg, __FILE__, __LINE__); } while (0)
 #endif
 

src/emu/mconfig.c

@@ -69,7 +69,7 @@ machine_config *machine_config_alloc(const machine_config_token *tokens)
 	machine_config *config;
 
 	/* allocate a new configuration object */
-	config = malloc_or_die(sizeof(*config));
+	config = (machine_config *)malloc_or_die(sizeof(*config));
 	memset(config, 0, sizeof(*config));
 
 	/* parse tokens into the config */
@@ -318,7 +318,7 @@ static void machine_config_detokenize(machine_config *config, const machine_conf
 	if (depth == 0)
 		for (device = config->devicelist; device != NULL; device = device->next)
 		{
-			tokens = device_get_info_ptr(device, DEVINFO_PTR_MACHINE_CONFIG);
+			tokens = (const machine_config_token *)device_get_info_ptr(device, DEVINFO_PTR_MACHINE_CONFIG);
 			if (tokens != NULL)
 				machine_config_detokenize(config, tokens, device, depth + 1);
 		}

src/emu/memory.c

@@ -441,7 +441,7 @@ INLINE void add_bank_reference(bank_info *bank, const address_space *space)
 			return;
 
 	/* allocate a new entry and fill it */
-	(*refptr) = malloc_or_die(sizeof(**refptr));
+	(*refptr) = (bank_reference *)malloc_or_die(sizeof(**refptr));
 	(*refptr)->next = NULL;
 	(*refptr)->space = space;
 }
@@ -471,7 +471,7 @@ INLINE UINT8 read_byte_generic(const address_space *space, offs_t byteaddress)
 	if (entry < STATIC_RAM)
 		result = (*handler->bankbaseptr)[byteoffset];
 	else
-		result = (*handler->handler.read.shandler8)(handler->object, byteoffset);
+		result = (*handler->handler.read.shandler8)((const address_space *)handler->object, byteoffset);
 
 	profiler_mark(PROFILER_END);
 	return result;
@@ -501,7 +501,7 @@ INLINE void write_byte_generic(const address_space *space, offs_t byteaddress, U
 	if (entry < STATIC_RAM)
 		(*handler->bankbaseptr)[byteoffset] = data;
 	else
-		(*handler->handler.write.shandler8)(handler->object, byteoffset, data);
+		(*handler->handler.write.shandler8)((const address_space *)handler->object, byteoffset, data);
 
 	profiler_mark(PROFILER_END);
 }
@@ -531,7 +531,7 @@ INLINE UINT16 read_word_generic(const address_space *space, offs_t byteaddress,
 	if (entry < STATIC_RAM)
 		result = *(UINT16 *)&(*handler->bankbaseptr)[byteoffset & ~1];
 	else
-		result = (*handler->handler.read.shandler16)(handler->object, byteoffset >> 1, mem_mask);
+		result = (*handler->handler.read.shandler16)((const address_space *)handler->object, byteoffset >> 1, mem_mask);
 
 	profiler_mark(PROFILER_END);
 	return result;
@@ -564,7 +564,7 @@ INLINE void write_word_generic(const address_space *space, offs_t byteaddress, U
 		*dest = (*dest & ~mem_mask) | (data & mem_mask);
 	}
 	else
-		(*handler->handler.write.shandler16)(handler->object, byteoffset >> 1, data, mem_mask);
+		(*handler->handler.write.shandler16)((const address_space *)handler->object, byteoffset >> 1, data, mem_mask);
 
 	profiler_mark(PROFILER_END);
 }
@@ -594,7 +594,7 @@ INLINE UINT32 read_dword_generic(const address_space *space, offs_t byteaddress,
 	if (entry < STATIC_RAM)
 		result = *(UINT32 *)&(*handler->bankbaseptr)[byteoffset & ~3];
 	else
-		result = (*handler->handler.read.shandler32)(handler->object, byteoffset >> 2, mem_mask);
+		result = (*handler->handler.read.shandler32)((const address_space *)handler->object, byteoffset >> 2, mem_mask);
 
 	profiler_mark(PROFILER_END);
 	return result;
@@ -627,7 +627,7 @@ INLINE void write_dword_generic(const address_space *space, offs_t byteaddress,
 		*dest = (*dest & ~mem_mask) | (data & mem_mask);
 	}
 	else
-		(*handler->handler.write.shandler32)(handler->object, byteoffset >> 2, data, mem_mask);
+		(*handler->handler.write.shandler32)((const address_space *)handler->object, byteoffset >> 2, data, mem_mask);
 
 	profiler_mark(PROFILER_END);
 }
@@ -657,7 +657,7 @@ INLINE UINT64 read_qword_generic(const address_space *space, offs_t byteaddress,
 	if (entry < STATIC_RAM)
 		result = *(UINT64 *)&(*handler->bankbaseptr)[byteoffset & ~7];
 	else
-		result = (*handler->handler.read.shandler64)(handler->object, byteoffset >> 3, mem_mask);
+		result = (*handler->handler.read.shandler64)((const address_space *)handler->object, byteoffset >> 3, mem_mask);
 
 	profiler_mark(PROFILER_END);
 	return result;
@@ -690,7 +690,7 @@ INLINE void write_qword_generic(const address_space *space, offs_t byteaddress,
 		*dest = (*dest & ~mem_mask) | (data & mem_mask);
 	}
 	else
-		(*handler->handler.write.shandler64)(handler->object, offset >> 3, data, mem_mask);
+		(*handler->handler.write.shandler64)((const address_space *)handler->object, offset >> 3, data, mem_mask);
 
 	profiler_mark(PROFILER_END);
 }
@@ -712,7 +712,7 @@ void memory_init(running_machine *machine)
 	add_exit_callback(machine, memory_exit);
 
 	/* allocate our private data */
-	memdata = machine->memory_data = auto_malloc(sizeof(*machine->memory_data));
+	memdata = machine->memory_data = (memory_private *)auto_malloc(sizeof(*machine->memory_data));
 	memset(memdata, 0, sizeof(*memdata));
 
 	/* build up the cpudata array with info about all CPUs and address spaces */
@@ -765,11 +765,11 @@ const address_space *memory_find_address_space(const device_config *cpu, int spa
 
 address_map *address_map_alloc(const device_config *device, const game_driver *driver, int spacenum)
 {
-	const cpu_config *cpuconfig = device->inline_config;
+	const cpu_config *cpuconfig = (const cpu_config *)device->inline_config;
 	const addrmap_token *internal_map;
 	address_map *map;
 
-	map = malloc_or_die(sizeof(*map));
+	map = (address_map *)malloc_or_die(sizeof(*map));
 	memset(map, 0, sizeof(*map));
 
 	/* append the internal CPU map (first so it takes priority) */
@@ -1027,7 +1027,7 @@ void memory_configure_bank(running_machine *machine, int banknum, int startentry
 
 	/* if we have no bankptr yet, set it to the first entry */
 	if (memdata->bank_ptr[banknum] == NULL)
-		memdata->bank_ptr[banknum] = bank->entry[0];
+		memdata->bank_ptr[banknum] = (UINT8 *)bank->entry[0];
 }
 
 
@@ -1058,7 +1058,7 @@ void memory_configure_bank_decrypted(running_machine *machine, int banknum, int
 
 	/* if we have no bankptr yet, set it to the first entry */
 	if (memdata->bankd_ptr[banknum] == NULL)
-		memdata->bankd_ptr[banknum] = bank->entryd[0];
+		memdata->bankd_ptr[banknum] = (UINT8 *)bank->entryd[0];
 }
 
 
@@ -1085,8 +1085,8 @@ void memory_set_bank(running_machine *machine, int banknum, int entrynum)
 
 	/* set the base */
 	bank->curentry = entrynum;
-	memdata->bank_ptr[banknum] = bank->entry[entrynum];
+	memdata->bank_ptr[banknum] = (UINT8 *)bank->entry[entrynum];
-	memdata->bankd_ptr[banknum] = bank->entryd[entrynum];
+	memdata->bankd_ptr[banknum] = (UINT8 *)bank->entryd[entrynum];
 
 	/* invalidate all the direct references to any referenced address spaces */
 	for (ref = bank->reflist; ref != NULL; ref = ref->next)
@@ -1134,7 +1134,7 @@ void memory_set_bankptr(running_machine *machine, int banknum, void *base)
 		validate_auto_malloc_memory(base, bank->byteend - bank->bytestart + 1);
 
 	/* set the base */
-	memdata->bank_ptr[banknum] = base;
+	memdata->bank_ptr[banknum] = (UINT8 *)base;
 
 	/* invalidate all the direct references to any referenced address spaces */
 	for (ref = bank->reflist; ref != NULL; ref = ref->next)
@@ -1181,7 +1181,7 @@ UINT8 *_memory_install_handler8(const address_space *space, offs_t addrstart, of
 	if (whandler != NULL)
 		space_map_range(spacerw, ROW_WRITE, 8, 0, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, spacerw, whandler_name);
 	mem_dump(space->machine);
-	return space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart));
+	return (UINT8 *)space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart));
 }
 
 
@@ -1198,7 +1198,7 @@ UINT16 *_memory_install_handler16(const address_space *space, offs_t addrstart,
 	if (whandler != NULL)
 		space_map_range(spacerw, ROW_WRITE, 16, 0, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, spacerw, whandler_name);
 	mem_dump(space->machine);
-	return space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart));
+	return (UINT16 *)space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart));
 }
 
 
@@ -1215,7 +1215,7 @@ UINT32 *_memory_install_handler32(const address_space *space, offs_t addrstart,
 	if (whandler != NULL)
 		space_map_range(spacerw, ROW_WRITE, 32, 0, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, spacerw, whandler_name);
 	mem_dump(space->machine);
-	return space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart));
+	return (UINT32 *)space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart));
 }
 
 
@@ -1232,7 +1232,7 @@ UINT64 *_memory_install_handler64(const address_space *space, offs_t addrstart,
 	if (whandler != NULL)
 		space_map_range(spacerw, ROW_WRITE, 64, 0, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, spacerw, whandler_name);
 	mem_dump(space->machine);
-	return space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart));
+	return (UINT64 *)space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart));
 }
 
 
@@ -1270,7 +1270,7 @@ UINT8 *_memory_install_device_handler8(const address_space *space, const device_
 	if (whandler != NULL)
 		space_map_range(spacerw, ROW_WRITE, 8, 0, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, (void *)device, whandler_name);
 	mem_dump(space->machine);
-	return space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart));
+	return (UINT8 *)space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart));
 }
 
 
@@ -1287,7 +1287,7 @@ UINT16 *_memory_install_device_handler16(const address_space *space, const devic
 	if (whandler != NULL)
 		space_map_range(spacerw, ROW_WRITE, 16, 0, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, (void *)device, whandler_name);
 	mem_dump(space->machine);
-	return space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart));
+	return (UINT16 *)space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart));
 }
 
 
@@ -1304,7 +1304,7 @@ UINT32 *_memory_install_device_handler32(const address_space *space, const devic
 	if (whandler != NULL)
 		space_map_range(spacerw, ROW_WRITE, 32, 0, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, (void *)device, whandler_name);
 	mem_dump(space->machine);
-	return space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart));
+	return (UINT32 *)space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart));
 }
 
 
@@ -1321,7 +1321,7 @@ UINT64 *_memory_install_device_handler64(const address_space *space, const devic
 	if (whandler != NULL)
 		space_map_range(spacerw, ROW_WRITE, 64, 0, addrstart, addrend, addrmask, addrmirror, (genf *)whandler, (void *)device, whandler_name);
 	mem_dump(space->machine);
-	return space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart));
+	return (UINT64 *)space_find_backing_memory(spacerw, memory_address_to_byte(spacerw, addrstart));
 }
 
 
@@ -1494,7 +1494,7 @@ static void memory_init_spaces(running_machine *machine)
 	int spacenum;
 
 	/* create a global watchpoint-filled table */
-	memdata->wptable = auto_malloc(1 << LEVEL1_BITS);
+	memdata->wptable = (UINT8 *)auto_malloc(1 << LEVEL1_BITS);
 	memset(memdata->wptable, STATIC_WATCHPOINT, 1 << LEVEL1_BITS);
 
 	/* loop over CPUs */
@@ -1502,7 +1502,7 @@ static void memory_init_spaces(running_machine *machine)
 		for (spacenum = 0; spacenum < ADDRESS_SPACES; spacenum++)
 			if (cpu_get_addrbus_width(device, spacenum) > 0)
 			{
-				address_space *space = malloc_or_die(sizeof(*space));
+				address_space *space = (address_space *)malloc_or_die(sizeof(*space));
 				int logbits = cpu_get_logaddr_width(device, spacenum);
 				int ashift = cpu_get_addrbus_shift(device, spacenum);
 				int abits = cpu_get_addrbus_width(device, spacenum);
@@ -1536,15 +1536,15 @@ static void memory_init_spaces(running_machine *machine)
 				space->log_unmap = TRUE;
 
 				/* allocate subtable information; we malloc this manually because it will be realloc'ed */
-				space->read.subtable = auto_malloc(sizeof(*space->read.subtable) * SUBTABLE_COUNT);
+				space->read.subtable = (subtable_data *)auto_malloc(sizeof(*space->read.subtable) * SUBTABLE_COUNT);
 				memset(space->read.subtable, 0, sizeof(*space->read.subtable) * SUBTABLE_COUNT);
-				space->write.subtable = auto_malloc(sizeof(*space->write.subtable) * SUBTABLE_COUNT);
+				space->write.subtable = (subtable_data *)auto_malloc(sizeof(*space->write.subtable) * SUBTABLE_COUNT);
 				memset(space->write.subtable, 0, sizeof(*space->write.subtable) * SUBTABLE_COUNT);
 
 				/* allocate the handler table */
-				space->read.handlers[0] = auto_malloc(sizeof(*space->read.handlers[0]) * ARRAY_LENGTH(space->read.handlers));
+				space->read.handlers[0] = (handler_data *)auto_malloc(sizeof(*space->read.handlers[0]) * ARRAY_LENGTH(space->read.handlers));
 				memset(space->read.handlers[0], 0, sizeof(*space->read.handlers[0]) * ARRAY_LENGTH(space->read.handlers));
-				space->write.handlers[0] = auto_malloc(sizeof(*space->write.handlers[0]) * ARRAY_LENGTH(space->write.handlers));
+				space->write.handlers[0] = (handler_data *)auto_malloc(sizeof(*space->write.handlers[0]) * ARRAY_LENGTH(space->write.handlers));
 				memset(space->write.handlers[0], 0, sizeof(*space->write.handlers[0]) * ARRAY_LENGTH(space->write.handlers));
 				for (entrynum = 1; entrynum < ARRAY_LENGTH(space->read.handlers); entrynum++)
 				{
@@ -1568,8 +1568,8 @@ static void memory_init_spaces(running_machine *machine)
 				space->write.handlers[STATIC_WATCHPOINT]->bytemask = ~0;
 
 				/* allocate memory; these aren't auto-malloc'ed as we need to expand them */
-				space->read.table = malloc_or_die(1 << LEVEL1_BITS);
+				space->read.table = (UINT8 *)malloc_or_die(1 << LEVEL1_BITS);
-				space->write.table = malloc_or_die(1 << LEVEL1_BITS);
+				space->write.table = (UINT8 *)malloc_or_die(1 << LEVEL1_BITS);
 
 				/* initialize everything to unmapped */
 				memset(space->read.table, STATIC_UNMAP, 1 << LEVEL1_BITS);
@@ -1836,7 +1836,7 @@ static void memory_init_allocate(running_machine *machine)
 			block = block_allocate(space, curbytestart, curbyteend, NULL);
 
 			/* assign memory that intersected the new block */
-			unassigned = block_assign_intersecting(space, curbytestart, curbyteend, block);
+			unassigned = block_assign_intersecting(space, curbytestart, curbyteend, (UINT8 *)block);
 		}
 	}
 }
@@ -1888,7 +1888,7 @@ static void memory_init_locate(running_machine *machine)
 				for (entry = ref->space->map->entrylist; entry != NULL; entry = entry->next)
 					if (entry->bytestart == bank->bytestart)
 					{
-						memdata->bank_ptr[banknum] = entry->memory;
+						memdata->bank_ptr[banknum] = (UINT8 *)entry->memory;
 						foundit = TRUE;
 		 				VPRINTF(("assigned bank %d pointer to memory from range %08X-%08X [%p]\n", banknum, entry->addrstart, entry->addrend, entry->memory));
 						break;
@@ -1896,7 +1896,7 @@ static void memory_init_locate(running_machine *machine)
 
 			/* if the entry was set ahead of time, override the automatically found pointer */
 			if (!bank->dynamic && bank->curentry != MAX_BANK_ENTRIES)
-				memdata->bank_ptr[banknum] = bank->entry[bank->curentry];
+				memdata->bank_ptr[banknum] = (UINT8 *)bank->entry[bank->curentry];
 		}
 	}
 
@@ -2059,7 +2059,7 @@ static void map_detokenize(address_map *map, const game_driver *driver, const ch
 
 			/* start a new range */
 			case ADDRMAP_TOKEN_RANGE:
-				entry = *entryptr = malloc_or_die(sizeof(**entryptr));
+				entry = *entryptr = (address_map_entry *)malloc_or_die(sizeof(**entryptr));
 				entryptr = &entry->next;
 				memset(entry, 0, sizeof(*entry));
 				TOKEN_GET_UINT64_UNPACK2(tokens, entry->addrstart, 32, entry->addrend, 32);
@@ -2200,7 +2200,7 @@ static void space_map_range_private(address_space *space, read_or_write readorwr
 		/* assign a bank to the adjusted addresses */
 		handler = (genf *)bank_assign_dynamic(space, readorwrite, bytestart, byteend);
 		if (memdata->bank_ptr[HANDLER_TO_BANK(handler)] == NULL)
-			memdata->bank_ptr[HANDLER_TO_BANK(handler)] = space_find_backing_memory(space, bytestart);
+			memdata->bank_ptr[HANDLER_TO_BANK(handler)] = (UINT8 *)space_find_backing_memory(space, bytestart);
 	}
 
 	/* then do a normal installation */
@@ -2433,7 +2433,7 @@ static STATE_POSTLOAD( bank_reattach )
 		{
 			/* if this entry has a changed entry, set the appropriate pointer */
 			if (bank->curentry != MAX_BANK_ENTRIES)
-				memdata->bank_ptr[banknum] = bank->entry[bank->curentry];
+				memdata->bank_ptr[banknum] = (UINT8 *)bank->entry[bank->curentry];
 		}
 	}
 }
@@ -2816,7 +2816,7 @@ static UINT8 subtable_alloc(address_table *tabledata)
 				if (subindex >= tabledata->subtable_alloc)
 				{
 					tabledata->subtable_alloc += SUBTABLE_ALLOC;
-					tabledata->table = realloc(tabledata->table, (1 << LEVEL1_BITS) + (tabledata->subtable_alloc << LEVEL2_BITS));
+					tabledata->table = (UINT8 *)realloc(tabledata->table, (1 << LEVEL1_BITS) + (tabledata->subtable_alloc << LEVEL2_BITS));
 					if (!tabledata->table)
 						fatalerror("error: ran out of memory allocating memory subtable");
 				}
@@ -3030,7 +3030,7 @@ static direct_range *direct_range_find(address_space *space, offs_t byteaddress,
 	if (range != NULL)
 		space->direct.freerangelist = range->next;
 	else
-		range = malloc_or_die(sizeof(*range));
+		range = (direct_range *)malloc_or_die(sizeof(*range));
 
 	/* fill in the range */
 	table_derive_range(&space->read, byteaddress, &range->bytestart, &range->byteend);
@@ -3102,7 +3102,7 @@ static void *block_allocate(const address_space *space, offs_t bytestart, offs_t
 		bytestoalloc += byteend - bytestart + 1;
 
 	/* allocate and clear the memory */
-	block = malloc_or_die(bytestoalloc);
+	block = (memory_block *)malloc_or_die(bytestoalloc);
 	memset(block, 0, bytestoalloc);
 	if (allocatemem)
 		memory = block + 1;
@@ -3134,7 +3134,7 @@ static void *block_allocate(const address_space *space, offs_t bytestart, offs_t
 	block->isallocated = allocatemem;
 	block->bytestart = bytestart;
 	block->byteend = byteend;
-	block->data = memory;
+	block->data = (UINT8 *)memory;
 
 	/* attach us to the head of the list */
 	block->next = memdata->memory_block_list;
@@ -3534,7 +3534,7 @@ static READ16_HANDLER( stub_read8_from_16 )
 	{
 		int shift = *subshift++;
 		if ((UINT8)(mem_mask >> shift) != 0)
-			result |= (*handler->subhandler.read.shandler8)(handler->subobject, offset) << shift;
+			result |= (*handler->subhandler.read.shandler8)((const address_space *)handler->subobject, offset) << shift;
 		offset++;
 	}
 	return result;
@@ -3558,7 +3558,7 @@ static READ32_HANDLER( stub_read8_from_32 )
 	{
 		int shift = *subshift++;
 		if ((UINT8)(mem_mask >> shift) != 0)
-			result |= (*handler->subhandler.read.shandler8)(handler->subobject, offset) << shift;
+			result |= (*handler->subhandler.read.shandler8)((const address_space *)handler->subobject, offset) << shift;
 		offset++;
 	}
 	return result;
@@ -3582,7 +3582,7 @@ static READ64_HANDLER( stub_read8_from_64 )
 	{
 		int shift = *subshift++;
 		if ((UINT8)(mem_mask >> shift) != 0)
-			result |= (UINT64)(*handler->subhandler.read.shandler8)(handler->subobject, offset) << shift;
+			result |= (UINT64)(*handler->subhandler.read.shandler8)((const address_space *)handler->subobject, offset) << shift;
 		offset++;
 	}
 	return result;
@@ -3606,7 +3606,7 @@ static READ32_HANDLER( stub_read16_from_32 )
 	{
 		int shift = *subshift++;
 		if ((UINT16)(mem_mask >> shift) != 0)
-			result |= (*handler->subhandler.read.shandler16)(handler->subobject, offset, mem_mask >> shift) << shift;
+			result |= (*handler->subhandler.read.shandler16)((const address_space *)handler->subobject, offset, mem_mask >> shift) << shift;
 		offset++;
 	}
 	return result;
@@ -3630,7 +3630,7 @@ static READ64_HANDLER( stub_read16_from_64 )
 	{
 		int shift = *subshift++;
 		if ((UINT16)(mem_mask >> shift) != 0)
-			result |= (UINT64)(*handler->subhandler.read.shandler16)(handler->subobject, offset, mem_mask >> shift) << shift;
+			result |= (UINT64)(*handler->subhandler.read.shandler16)((const address_space *)handler->subobject, offset, mem_mask >> shift) << shift;
 		offset++;
 	}
 	return result;
@@ -3654,7 +3654,7 @@ static READ64_HANDLER( stub_read32_from_64 )
 	{
 		int shift = *subshift++;
 		if ((UINT32)(mem_mask >> shift) != 0)
-			result |= (UINT64)(*handler->subhandler.read.shandler32)(handler->subobject, offset, mem_mask >> shift) << shift;
+			result |= (UINT64)(*handler->subhandler.read.shandler32)((const address_space *)handler->subobject, offset, mem_mask >> shift) << shift;
 		offset++;
 	}
 	return result;
@@ -3682,7 +3682,7 @@ static WRITE16_HANDLER( stub_write8_from_16 )
 	{
 		int shift = *subshift++;
 		if ((UINT8)(mem_mask >> shift) != 0)
-			(*handler->subhandler.write.shandler8)(handler->subobject, offset, data >> shift);
+			(*handler->subhandler.write.shandler8)((const address_space *)handler->subobject, offset, data >> shift);
 		offset++;
 	}
 }
@@ -3704,7 +3704,7 @@ static WRITE32_HANDLER( stub_write8_from_32 )
 	{
 		int shift = *subshift++;
 		if ((UINT8)(mem_mask >> shift) != 0)
-			(*handler->subhandler.write.shandler8)(handler->subobject, offset, data >> shift);
+			(*handler->subhandler.write.shandler8)((const address_space *)handler->subobject, offset, data >> shift);
 		offset++;
 	}
 }
@@ -3726,7 +3726,7 @@ static WRITE64_HANDLER( stub_write8_from_64 )
 	{
 		int shift = *subshift++;
 		if ((UINT8)(mem_mask >> shift) != 0)
-			(*handler->subhandler.write.shandler8)(handler->subobject, offset, data >> shift);
+			(*handler->subhandler.write.shandler8)((const address_space *)handler->subobject, offset, data >> shift);
 		offset++;
 	}
 }
@@ -3748,7 +3748,7 @@ static WRITE32_HANDLER( stub_write16_from_32 )
 	{
 		int shift = *subshift++;
 		if ((UINT16)(mem_mask >> shift) != 0)
-			(*handler->subhandler.write.shandler16)(handler->subobject, offset, data >> shift, mem_mask >> shift);
+			(*handler->subhandler.write.shandler16)((const address_space *)handler->subobject, offset, data >> shift, mem_mask >> shift);
 		offset++;
 	}
 }
@@ -3770,7 +3770,7 @@ static WRITE64_HANDLER( stub_write16_from_64 )
 	{
 		int shift = *subshift++;
 		if ((UINT16)(mem_mask >> shift) != 0)
-			(*handler->subhandler.write.shandler16)(handler->subobject, offset, data >> shift, mem_mask >> shift);
+			(*handler->subhandler.write.shandler16)((const address_space *)handler->subobject, offset, data >> shift, mem_mask >> shift);
 		offset++;
 	}
 }
@@ -3792,7 +3792,7 @@ static WRITE64_HANDLER( stub_write32_from_64 )
 	{
 		int shift = *subshift++;
 		if ((UINT32)(mem_mask >> shift) != 0)
-			(*handler->subhandler.write.shandler32)(handler->subobject, offset, data >> shift, mem_mask >> shift);
+			(*handler->subhandler.write.shandler32)((const address_space *)handler->subobject, offset, data >> shift, mem_mask >> shift);
 		offset++;
 	}
 }

src/emu/output.c

@@ -78,7 +78,7 @@ static void output_exit(running_machine *machine);
 
 INLINE const char *copy_string(const char *string)
 {
-	char *newstring = malloc_or_die(strlen(string) + 1);
+	char *newstring = (char *)malloc_or_die(strlen(string) + 1);
 	strcpy(newstring, string);
 	return newstring;
 }
@@ -118,7 +118,7 @@ INLINE output_item *find_item(const char *string)
 
 INLINE output_item *create_new_item(const char *outname, INT32 value)
 {
-	output_item *item = malloc_or_die(sizeof(*item));
+	output_item *item = (output_item *)malloc_or_die(sizeof(*item));
 	UINT32 hash = get_hash(outname);
 
 	/* fill in the data */
@@ -343,7 +343,7 @@ void output_set_notifier(const char *outname, output_notifier_func callback, voi
 	/* find the end of the list and add to it */
 	while (*headptr != NULL)
 		headptr = &(*headptr)->next;
-	*headptr = malloc_or_die(sizeof(**headptr));
+	*headptr = (output_notify *)malloc_or_die(sizeof(**headptr));
 
 	/* fill in the new record */
 	(*headptr)->next = NULL;

src/emu/render.c

@@ -343,7 +343,7 @@ INLINE container_item *alloc_container_item(void)
 	if (result != NULL)
 		container_item_free_list = result->next;
 	else
-		result = malloc_or_die(sizeof(*result));
+		result = (container_item *)malloc_or_die(sizeof(*result));
 
 	memset(result, 0, sizeof(*result));
 	return result;
@@ -375,7 +375,7 @@ INLINE render_primitive *alloc_render_primitive(int type)
 	if (result != NULL)
 		render_primitive_free_list = result->next;
 	else
-		result = malloc_or_die(sizeof(*result));
+		result = (render_primitive *)malloc_or_die(sizeof(*result));
 
 	/* clear to 0 */
 	memset(result, 0, sizeof(*result));
@@ -426,7 +426,7 @@ INLINE void add_render_ref(render_ref **list, void *refptr)
 	if (ref != NULL)
 		render_ref_free_list = ref->next;
 	else
-		ref = malloc_or_die(sizeof(*ref));
+		ref = (render_ref *)malloc_or_die(sizeof(*ref));
 
 	/* set the refptr and link us into the list */
 	ref->refptr = refptr;
@@ -1073,7 +1073,7 @@ render_target *render_target_alloc(running_machine *machine, const char *layoutf
 	int listnum;
 
 	/* allocate memory for the target */
-	target = malloc_or_die(sizeof(*target));
+	target = (render_target *)malloc_or_die(sizeof(*target));
 	memset(target, 0, sizeof(*target));
 
 	/* add it to the end of the list */
@@ -1468,7 +1468,7 @@ void render_target_get_minimum_size(render_target *target, INT32 *minwidth, INT3
 			if (item->element == NULL)
 			{
 				const device_config *screen = device_list_find_by_index(target->machine->config->devicelist, VIDEO_SCREEN, item->index);
-				const screen_config *scrconfig = screen->inline_config;
+				const screen_config *scrconfig = (const screen_config *)screen->inline_config;
 				const rectangle vectorvis = { 0, 639, 0, 479 };
 				const rectangle *visarea = NULL;
 				render_container *container = get_screen_container_by_index(item->index);
@@ -2433,7 +2433,7 @@ render_texture *render_texture_alloc(texture_scaler_func scaler, void *param)
 		int texnum;
 
 		/* allocate a new group */
-		texture = malloc_or_die(sizeof(*texture) * TEXTURE_GROUP_SIZE);
+		texture = (render_texture *)malloc_or_die(sizeof(*texture) * TEXTURE_GROUP_SIZE);
 		memset(texture, 0, sizeof(*texture) * TEXTURE_GROUP_SIZE);
 
 		/* add them to the list */
@@ -2672,7 +2672,7 @@ static const rgb_t *texture_get_adjusted_palette(render_texture *texture, render
 			numentries = palette_get_num_colors(texture->palette) * palette_get_num_groups(texture->palette);
 			if (texture->bcglookup == NULL || texture->bcglookup_entries < numentries)
 			{
-				texture->bcglookup = realloc(texture->bcglookup, numentries * sizeof(*texture->bcglookup));
+				texture->bcglookup = (rgb_t *)realloc(texture->bcglookup, numentries * sizeof(*texture->bcglookup));
 				texture->bcglookup_entries = numentries;
 			}
 			for (index = 0; index < numentries; index++)
@@ -2699,7 +2699,7 @@ static const rgb_t *texture_get_adjusted_palette(render_texture *texture, render
 			adjusted = palette_entry_list_adjusted(texture->palette);
 			if (texture->bcglookup == NULL || texture->bcglookup_entries < 4 * 32)
 			{
-				texture->bcglookup = realloc(texture->bcglookup, 4 * 32 * sizeof(*texture->bcglookup));
+				texture->bcglookup = (rgb_t *)realloc(texture->bcglookup, 4 * 32 * sizeof(*texture->bcglookup));
 				texture->bcglookup_entries = 4 * 32;
 			}
 
@@ -2731,7 +2731,7 @@ static const rgb_t *texture_get_adjusted_palette(render_texture *texture, render
 			adjusted = palette_entry_list_adjusted(texture->palette);
 			if (texture->bcglookup == NULL || texture->bcglookup_entries < 4 * 256)
 			{
-				texture->bcglookup = realloc(texture->bcglookup, 4 * 256 * sizeof(*texture->bcglookup));
+				texture->bcglookup = (rgb_t *)realloc(texture->bcglookup, 4 * 256 * sizeof(*texture->bcglookup));
 				texture->bcglookup_entries = 4 * 256;
 			}
 
@@ -2770,7 +2770,7 @@ static render_container *render_container_alloc(running_machine *machine)
 	int color;
 
 	/* allocate and clear memory */
-	container = malloc_or_die(sizeof(*container));
+	container = (render_container *)malloc_or_die(sizeof(*container));
 	memset(container, 0, sizeof(*container));
 
 	/* default values */

src/emu/rendfont.c

@@ -141,7 +141,7 @@ render_font *render_font_alloc(const char *filename)
 	render_font *font;
 
 	/* allocate and clear memory */
-	font = malloc_or_die(sizeof(*font));
+	font = (render_font *)malloc_or_die(sizeof(*font));
 	memset(font, 0, sizeof(*font));
 
 	/* attempt to load the cached version of the font first */
@@ -150,7 +150,7 @@ render_font *render_font_alloc(const char *filename)
 
 	/* if we failed, clean up and realloc */
 	render_font_free(font);
-	font = malloc_or_die(sizeof(*font));
+	font = (render_font *)malloc_or_die(sizeof(*font));
 	memset(font, 0, sizeof(*font));
 
 	/* load the raw data instead */
@@ -434,7 +434,7 @@ static int render_font_load_cached_bdf(render_font *font, const char *filename)
 
 	/* determine the file size and allocate memory */
 	font->rawsize = mame_fsize(file);
-	data = malloc_or_die(font->rawsize + 1);
+	data = (char *)malloc_or_die(font->rawsize + 1);
 
 	/* read and hash the first chunk */
 	bytes = mame_fread(file, data, MIN(CACHED_BDF_HASH_SIZE, font->rawsize));
@@ -584,7 +584,7 @@ static int render_font_load_bdf(render_font *font)
 				/* if we don't have a subtable yet, make one */
 				if (font->chars[charnum / 256] == NULL)
 				{
-					font->chars[charnum / 256] = malloc_or_die(256 * sizeof(font->chars[0][0]));
+					font->chars[charnum / 256] = (render_font_char *)malloc_or_die(256 * sizeof(font->chars[0][0]));
 					memset(font->chars[charnum / 256], 0, 256 * sizeof(font->chars[0][0]));
 				}
 
@@ -642,7 +642,7 @@ static int render_font_load_cached(render_font *font, mame_file *file, UINT32 ha
 		goto error;
 
 	/* now read the rest of the data */
-	data = malloc_or_die(filesize - CACHED_HEADER_SIZE);
+	data = (UINT8 *)malloc_or_die(filesize - CACHED_HEADER_SIZE);
 	bytes_read = mame_fread(file, data, filesize - CACHED_HEADER_SIZE);
 	if (bytes_read != filesize - CACHED_HEADER_SIZE)
 		goto error;
@@ -658,7 +658,7 @@ static int render_font_load_cached(render_font *font, mame_file *file, UINT32 ha
 		/* if we don't have a subtable yet, make one */
 		if (font->chars[chnum / 256] == NULL)
 		{
-			font->chars[chnum / 256] = malloc_or_die(256 * sizeof(font->chars[0][0]));
+			font->chars[chnum / 256] = (render_font_char *)malloc_or_die(256 * sizeof(font->chars[0][0]));
 			memset(font->chars[chnum / 256], 0, 256 * sizeof(font->chars[0][0]));
 		}
 
@@ -728,11 +728,11 @@ static int render_font_save_cached(render_font *font, const char *filename, UINT
 	}
 
 	/* allocate an array to hold the character data */
-	chartable = malloc_or_die(numchars * CACHED_CHAR_SIZE);
+	chartable = (UINT8 *)malloc_or_die(numchars * CACHED_CHAR_SIZE);
 	memset(chartable, 0, numchars * CACHED_CHAR_SIZE);
 
 	/* allocate a temp buffer to compress into */
-	tempbuffer = malloc_or_die(65536);
+	tempbuffer = (UINT8 *)malloc_or_die(65536);
 
 	/* write the header */
 	dest = tempbuffer;

src/emu/rendlay.c

@@ -217,7 +217,7 @@ INLINE void reduce_fraction(int *num, int *den)
 
 INLINE const char *copy_string(const char *string)
 {
-	char *newstring = malloc_or_die(strlen(string) + 1);
+	char *newstring = (char *)malloc_or_die(strlen(string) + 1);
 	strcpy(newstring, string);
 	return newstring;
 }
@@ -348,7 +348,7 @@ void layout_view_recompute(layout_view *view, int layerconfig)
 
 static void layout_element_scale(bitmap_t *dest, const bitmap_t *source, const rectangle *sbounds, void *param)
 {
-	element_texture *elemtex = param;
+	element_texture *elemtex = (element_texture *)param;
 	element_component *component;
 
 	/* iterate over components that are part of the current state */
@@ -1340,7 +1340,7 @@ static int get_variable_value(const machine_config *config, const char *string,
 	for (device = video_screen_first(config); device != NULL; device = video_screen_next(device))
 	{
 		int scrnum = device_list_index(config->devicelist, VIDEO_SCREEN, device->tag);
-		const screen_config *scrconfig = device->inline_config;
+		const screen_config *scrconfig = (const screen_config *)device->inline_config;
 
 		/* native X aspect factor */
 		sprintf(temp, "~scr%dnativexaspect~", scrnum);
@@ -1509,7 +1509,7 @@ layout_file *layout_file_load(const machine_config *config, const char *dirname,
 		return NULL;
 
 	/* allocate the layout group object first */
-	file = malloc_or_die(sizeof(*file));
+	file = (layout_file *)malloc_or_die(sizeof(*file));
 	memset(file, 0, sizeof(*file));
 
 	/* find the layout node */
@@ -1579,7 +1579,7 @@ static layout_element *load_layout_element(const machine_config *config, xml_dat
 	int first;
 
 	/* allocate a new element */
-	element = malloc_or_die(sizeof(*element));
+	element = (layout_element *)malloc_or_die(sizeof(*element));
 	memset(element, 0, sizeof(*element));
 
 	/* extract the name */
@@ -1642,7 +1642,7 @@ static layout_element *load_layout_element(const machine_config *config, xml_dat
 	}
 
 	/* allocate an array of element textures for the states */
-	element->elemtex = malloc_or_die((element->maxstate + 1) * sizeof(element->elemtex[0]));
+	element->elemtex = (element_texture *)malloc_or_die((element->maxstate + 1) * sizeof(element->elemtex[0]));
 	for (state = 0; state <= element->maxstate; state++)
 	{
 		element->elemtex[state].element = element;
@@ -1668,7 +1668,7 @@ static element_component *load_element_component(const machine_config *config, x
 	element_component *component;
 
 	/* allocate memory for the component */
-	component = malloc_or_die(sizeof(*component));
+	component = (element_component *)malloc_or_die(sizeof(*component));
 	memset(component, 0, sizeof(*component));
 
 	/* fetch common data */
@@ -1699,7 +1699,7 @@ static element_component *load_element_component(const machine_config *config, x
 
 		/* allocate a copy of the string */
 		component->type = COMPONENT_TYPE_TEXT;
-		string = malloc_or_die(strlen(text) + 1);
+		string = (char *)malloc_or_die(strlen(text) + 1);
 		strcpy(string, text);
 		component->string = string;
 	}
@@ -1756,7 +1756,7 @@ static layout_view *load_layout_view(const machine_config *config, xml_data_node
 	int layer;
 
 	/* first allocate memory */
-	view = malloc_or_die(sizeof(*view));
+	view = (layout_view *)malloc_or_die(sizeof(*view));
 	memset(view, 0, sizeof(*view));
 
 	/* allocate a copy of the name */
@@ -1810,7 +1810,7 @@ static view_item *load_view_item(const machine_config *config, xml_data_node *it
 	const char *name;
 
 	/* allocate a new item */
-	item = malloc_or_die(sizeof(*item));
+	item = (view_item *)malloc_or_die(sizeof(*item));
 	memset(item, 0, sizeof(*item));
 
 	/* allocate a copy of the output name */

src/emu/rendutil.c

@@ -83,9 +83,9 @@ void render_resample_argb_bitmap_hq(void *dest, UINT32 drowpixels, UINT32 dwidth
 
 	/* if the source is higher res than the target, use full averaging */
 	if (dx > 0x1000 || dy > 0x1000)
-		resample_argb_bitmap_average(dest, drowpixels, dwidth, dheight, sbase, source->rowpixels, swidth, sheight, color, dx, dy);
+		resample_argb_bitmap_average((UINT32 *)dest, drowpixels, dwidth, dheight, sbase, source->rowpixels, swidth, sheight, color, dx, dy);
 	else
-		resample_argb_bitmap_bilinear(dest, drowpixels, dwidth, dheight, sbase, source->rowpixels, swidth, sheight, color, dx, dy);
+		resample_argb_bitmap_bilinear((UINT32 *)dest, drowpixels, dwidth, dheight, sbase, source->rowpixels, swidth, sheight, color, dx, dy);
 }
 
 

src/emu/restrack.c

@@ -20,13 +20,13 @@
     TYPE DEFINITIONS
 ***************************************************************************/
 
-typedef enum _memory_block_overlap memory_block_overlap;
 enum _memory_block_overlap
 {
 	OVERLAP_NONE,
 	OVERLAP_PARTIAL,
 	OVERLAP_FULL
 };
+typedef enum _memory_block_overlap memory_block_overlap;
 
 
 
@@ -260,7 +260,7 @@ char *auto_strdup_allow_null_file_line(const char *str, const char *file, int li
 
 astring *auto_astring_alloc_file_line(const char *file, int line)
 {
-	return restrack_register_object(OBJTYPE_ASTRING, astring_alloc(), 0, file, line);
+	return (astring *)restrack_register_object(OBJTYPE_ASTRING, astring_alloc(), 0, file, line);
 }
 
 
@@ -271,7 +271,7 @@ astring *auto_astring_alloc_file_line(const char *file, int line)
 
 bitmap_t *auto_bitmap_alloc_file_line(int width, int height, bitmap_format format, const char *file, int line)
 {
-	return restrack_register_object(OBJTYPE_BITMAP, bitmap_alloc(width, height, format), width * height, file, line);
+	return (bitmap_t *)restrack_register_object(OBJTYPE_BITMAP, bitmap_alloc(width, height, format), width * height, file, line);
 }
 
 
@@ -317,7 +317,7 @@ void validate_auto_malloc_memory(void *memory, size_t memory_size)
 
 static void astring_destructor(void *object, size_t size)
 {
-	astring_free(object);
+	astring_free((astring *)object);
 }
 
 
@@ -328,7 +328,7 @@ static void astring_destructor(void *object, size_t size)
 
 static void bitmap_destructor(void *object, size_t size)
 {
-	bitmap_free(object);
+	bitmap_free((bitmap_t *)object);
 }
 
 
@@ -341,7 +341,7 @@ static memory_block_overlap pool_contains_block(object_pool *pool, void *ptr, si
 {
 	memory_block_overlap overlap = OVERLAP_NONE;
 	object_pool_iterator *iter;
-	UINT8 *ptrstart = ptr;
+	UINT8 *ptrstart = (UINT8 *)ptr;
 	UINT8 *ptrend = ptrstart + size - 1;
 	void *blockptr = NULL;
 	size_t blocksize = 0;

src/emu/romload.c

@@ -125,7 +125,7 @@ void set_disk_handle(const char *region, mame_file *file, chd_file *chdfile)
 	chd.origfile = file;
 
 	/* we're okay, add to the list of disks */
-	*chd_list_tailptr = auto_malloc(sizeof(**chd_list_tailptr));
+	*chd_list_tailptr = (open_chd *)auto_malloc(sizeof(**chd_list_tailptr));
 	**chd_list_tailptr = chd;
 	chd_list_tailptr = &(*chd_list_tailptr)->next;
 }
@@ -165,7 +165,7 @@ const rom_source *rom_first_source(const game_driver *drv, const machine_config
 	if (config != NULL)
 		for (device = config->devicelist; device != NULL; device = device->next)
 		{
-			const rom_entry *devromp = device_get_info_ptr(device, DEVINFO_PTR_ROM_REGION);
+			const rom_entry *devromp = (const rom_entry *)device_get_info_ptr(device, DEVINFO_PTR_ROM_REGION);
 			if (devromp != NULL)
 				return (rom_source *)device;
 		}
@@ -191,7 +191,7 @@ const rom_source *rom_next_source(const game_driver *drv, const machine_config *
 	/* look for further devices with ROM definitions */
 	for ( ; device != NULL; device = device->next)
 	{
-		const rom_entry *devromp = device_get_info_ptr(device, DEVINFO_PTR_ROM_REGION);
+		const rom_entry *devromp = (const rom_entry *)device_get_info_ptr(device, DEVINFO_PTR_ROM_REGION);
 		if (devromp != NULL)
 			return (rom_source *)device;
 	}
@@ -211,7 +211,7 @@ const rom_entry *rom_first_region(const game_driver *drv, const rom_source *sour
 	if (source == NULL || rom_source_is_gamedrv(drv, source))
 		romp = drv->rom;
 	else
-		romp = device_get_info_ptr((const device_config *)source, DEVINFO_PTR_ROM_REGION);
+		romp = (const rom_entry *)device_get_info_ptr((const device_config *)source, DEVINFO_PTR_ROM_REGION);
 
 	return (romp != NULL && !ROMENTRY_ISEND(romp)) ? romp : NULL;
 }
@@ -757,7 +757,7 @@ static int read_rom_data(rom_load_data *romdata, const rom_entry *romp)
 
 	/* use a temporary buffer for complex loads */
 	tempbufsize = MIN(TEMPBUFFER_MAX_SIZE, numbytes);
-	tempbuf = malloc_or_die(tempbufsize);
+	tempbuf = (UINT8 *)malloc_or_die(tempbufsize);
 
 	/* chunky reads for complex loads */
 	skip += groupsize;
@@ -1225,7 +1225,7 @@ static void process_disk_entries(rom_load_data *romdata, const char *regiontag,
 
 			/* we're okay, add to the list of disks */
 			LOG(("Assigning to handle %d\n", DISK_GETINDEX(romp)));
-			*chd_list_tailptr = auto_malloc(sizeof(**chd_list_tailptr));
+			*chd_list_tailptr = (open_chd *)auto_malloc(sizeof(**chd_list_tailptr));
 			**chd_list_tailptr = chd;
 			chd_list_tailptr = &(*chd_list_tailptr)->next;
 		}

src/emu/sound.c

@@ -166,7 +166,7 @@ INLINE speaker_info *index_to_input(running_machine *machine, int index, int *in
 	/* scan through the speakers until we find the indexed input */
 	for (curspeak = speaker_output_first(machine->config); curspeak != NULL; curspeak = speaker_output_next(curspeak))
 	{
-		speaker_info *info = curspeak->token;
+		speaker_info *info = (speaker_info *)curspeak->token;
 		if (index < count + info->inputs)
 		{
 			*input = index - count;
@@ -202,9 +202,9 @@ void sound_init(running_machine *machine)
 	VPRINTF(("total speakers = %d\n", speaker_output_count(machine->config)));
 
 	/* allocate memory for mix buffers */
-	leftmix = auto_malloc(machine->sample_rate * sizeof(*leftmix));
+	leftmix = (INT32 *)auto_malloc(machine->sample_rate * sizeof(*leftmix));
-	rightmix = auto_malloc(machine->sample_rate * sizeof(*rightmix));
+	rightmix = (INT32 *)auto_malloc(machine->sample_rate * sizeof(*rightmix));
-	finalmix = auto_malloc(machine->sample_rate * sizeof(*finalmix));
+	finalmix = (INT16 *)auto_malloc(machine->sample_rate * sizeof(*finalmix));
 
 	/* allocate a global timer for sound timing */
 	sound_update_timer = timer_alloc(machine, sound_update, NULL);
@@ -270,7 +270,7 @@ static DEVICE_START( sound )
 	assert(device->machine->config != NULL);
 
 	/* get pointers to our data */
-	config = device->inline_config;
+	config = (const sound_config *)device->inline_config;
 	classdata = get_class_data(device);
 
 	/* get the chip's start function */
@@ -324,7 +324,7 @@ static DEVICE_START( sound )
 
 static DEVICE_CUSTOM_CONFIG( sound )
 {
-	sound_config *config = device->inline_config;
+	sound_config *config = (sound_config *)device->inline_config;
 
 	switch (entrytype)
 	{
@@ -341,7 +341,7 @@ static DEVICE_CUSTOM_CONFIG( sound )
 
 			/* allocate a new route */
 			for (routeptr = &config->routelist; *routeptr != NULL; routeptr = &(*routeptr)->next) ;
-			*routeptr = malloc_or_die(sizeof(**routeptr));
+			*routeptr = (sound_route *)malloc_or_die(sizeof(**routeptr));
 			(*routeptr)->next = NULL;
 			(*routeptr)->output = output;
 			(*routeptr)->input = input;
@@ -372,7 +372,7 @@ static DEVICE_CUSTOM_CONFIG( sound )
 
 DEVICE_GET_INFO( sound )
 {
-	const sound_config *config = (device != NULL) ? device->inline_config : NULL;
+	const sound_config *config = (device != NULL) ? (const sound_config *)device->inline_config : NULL;
 
 	switch (state)
 	{
@@ -425,7 +425,7 @@ static void route_sound(running_machine *machine)
 	/* first count up the inputs for each speaker */
 	for (sound = sound_first(machine->config); sound != NULL; sound = sound_next(sound))
 	{
-		const sound_config *config = sound->inline_config;
+		const sound_config *config = (const sound_config *)sound->inline_config;
 		int numoutputs = stream_get_device_outputs(sound);
 		const sound_route *route;
 
@@ -452,7 +452,7 @@ static void route_sound(running_machine *machine)
 		{
 			info->mixer_stream = stream_create(curspeak, info->inputs, 1, machine->sample_rate, info, mixer_update);
 			state_save_register_postload(machine, mixer_postload, info->mixer_stream);
-			info->input = auto_malloc(info->inputs * sizeof(*info->input));
+			info->input = (speaker_input *)auto_malloc(info->inputs * sizeof(*info->input));
 			info->inputs = 0;
 		}
 		else
@@ -462,7 +462,7 @@ static void route_sound(running_machine *machine)
 	/* iterate again over all the sound chips */
 	for (sound = sound_first(machine->config); sound != NULL; sound = sound_next(sound))
 	{
-		const sound_config *config = sound->inline_config;
+		const sound_config *config = (const sound_config *)sound->inline_config;
 		int numoutputs = stream_get_device_outputs(sound);
 		const sound_route *route;
 
@@ -693,7 +693,7 @@ static TIMER_CALLBACK( sound_update )
 	/* force all the speaker streams to generate the proper number of samples */
 	for (curspeak = speaker_output_first(machine->config); curspeak != NULL; curspeak = speaker_output_next(curspeak))
 	{
-		speaker_info *spk = curspeak->token;
+		speaker_info *spk = (speaker_info *)curspeak->token;
 		const stream_sample_t *stream_buf;
 
 		/* get the output buffer */
@@ -801,7 +801,7 @@ static TIMER_CALLBACK( sound_update )
 
 static STREAM_UPDATE( mixer_update )
 {
-	speaker_info *speaker = param;
+	speaker_info *speaker = (speaker_info *)param;
 	int numinputs = speaker->inputs;
 	int pos;
 
@@ -828,7 +828,7 @@ static STREAM_UPDATE( mixer_update )
 
 static STATE_POSTLOAD( mixer_postload )
 {
-	sound_stream *stream = param;
+	sound_stream *stream = (sound_stream *)param;
 	stream_set_sample_rate(stream, machine->sample_rate);
 }
 
@@ -845,10 +845,10 @@ static STATE_POSTLOAD( mixer_postload )
 
 static DEVICE_START( speaker_output )
 {
-	speaker_info *info = device->token;
+	speaker_info *info = (speaker_info *)device->token;
 
 	/* copy in all the relevant info */
-	info->speaker = device->inline_config;
+	info->speaker = (const speaker_config *)device->inline_config;
 	info->tag = device->tag;
 }
 
@@ -937,7 +937,7 @@ int sound_get_user_gain_count(running_machine *machine)
 	/* count up the number of speaker inputs */
 	for (curspeak = speaker_output_first(machine->config); curspeak != NULL; curspeak = speaker_output_next(curspeak))
 	{
-		speaker_info *info = curspeak->token;
+		speaker_info *info = (speaker_info *)curspeak->token;
 		count += info->inputs;
 	}
 	return count;

src/emu/sound/cdp1869.c

@@ -157,7 +157,7 @@ static void update_prd_changed_timer(cdp1869_t *cdp1869)
 
 static TIMER_CALLBACK( prd_changed_tick )
 {
-	const device_config *device = ptr;
+	const device_config *device = (const device_config *)ptr;
 	cdp1869_t *cdp1869 = get_safe_token(device);
 
 	devcb_call_write_line(&cdp1869->out_prd_func, param);

src/emu/sound/filter.c

@@ -2,7 +2,7 @@
 #include "filter.h"
 
 static filter* filter_alloc(void) {
-	filter* f = malloc_or_die(sizeof(filter));
+	filter* f = (filter *)malloc_or_die(sizeof(filter));
 	return f;
 }
 
@@ -20,7 +20,7 @@ void filter_state_reset(filter* f, filter_state* s) {
 
 filter_state* filter_state_alloc(void) {
 	int i;
-        filter_state* s = malloc_or_die(sizeof(filter_state));
+        filter_state* s = (filter_state *)malloc_or_die(sizeof(filter_state));
 	s->prev_mac = 0;
 	for(i=0;i<FILTER_ORDER_MAX;++i)
 		s->xprev[i] = 0;

src/emu/sound/flt_rc.c

@@ -28,7 +28,7 @@ static STREAM_UPDATE( filter_rc_update )
 {
 	stream_sample_t *src = inputs[0];
 	stream_sample_t *dst = outputs[0];
-	filter_rc_state *info = param;
+	filter_rc_state *info = (filter_rc_state *)param;
 	int memory = info->memory;
 
 	switch (info->type)
@@ -93,7 +93,7 @@ static void set_RC_info(filter_rc_state *info, int type, double R1, double R2, d
 static DEVICE_START( filter_rc )
 {
 	filter_rc_state *info = get_safe_token(device);
-	const flt_rc_config *conf = device->static_config;
+	const flt_rc_config *conf = (const flt_rc_config *)device->static_config;
 
 	info->device = device;
 	info->stream = stream_create(device, 1, 1, device->machine->sample_rate, info, filter_rc_update);

src/emu/sound/flt_vol.c

@@ -25,7 +25,7 @@ static STREAM_UPDATE( filter_volume_update )
 {
 	stream_sample_t *src = inputs[0];
 	stream_sample_t *dst = outputs[0];
-	filter_volume_state *info = param;
+	filter_volume_state *info = (filter_volume_state *)param;
 
 	while (samples--)
 		*dst++ = (*src++ * info->gain) >> 8;

src/emu/sound/wavwrite.c

@@ -126,7 +126,7 @@ void wav_add_data_32(wav_file *wav, INT32 *data, int samples, int shift)
 	if (!wav) return;
 
 	/* allocate temp memory */
-	temp = malloc(samples * sizeof(temp[0]));
+	temp = (INT16 *)malloc(samples * sizeof(temp[0]));
 	if (!temp)
 		return;
 
@@ -154,7 +154,7 @@ void wav_add_data_16lr(wav_file *wav, INT16 *left, INT16 *right, int samples)
 	if (!wav) return;
 
 	/* allocate temp memory */
-	temp = malloc(samples * 2 * sizeof(temp[0]));
+	temp = (INT16 *)malloc(samples * 2 * sizeof(temp[0]));
 	if (!temp)
 		return;
 
@@ -179,7 +179,7 @@ void wav_add_data_32lr(wav_file *wav, INT32 *left, INT32 *right, int samples, in
 	if (!wav) return;
 
 	/* allocate temp memory */
-	temp = malloc(samples * 2 * sizeof(temp[0]));
+	temp = (INT16 *)malloc(samples * 2 * sizeof(temp[0]));
 	if (!temp)
 		return;
 

src/emu/state.c

@@ -133,19 +133,19 @@ INLINE void flip_data(state_entry *entry)
 	switch (entry->typesize)
 	{
 		case 2:
-			data16 = entry->data;
+			data16 = (UINT16 *)entry->data;
 			for (count = 0; count < entry->typecount; count++)
 				data16[count] = FLIPENDIAN_INT16(data16[count]);
 			break;
 
 		case 4:
-			data32 = entry->data;
+			data32 = (UINT32 *)entry->data;
 			for (count = 0; count < entry->typecount; count++)
 				data32[count] = FLIPENDIAN_INT32(data32[count]);
 			break;
 
 		case 8:
-			data64 = entry->data;
+			data64 = (UINT64 *)entry->data;
 			for (count = 0; count < entry->typecount; count++)
 				data64[count] = FLIPENDIAN_INT64(data64[count]);
 			break;
@@ -165,7 +165,7 @@ INLINE void flip_data(state_entry *entry)
 
 void state_init(running_machine *machine)
 {
-	machine->state_data = auto_malloc(sizeof(*machine->state_data));
+	machine->state_data = (state_private *)auto_malloc(sizeof(*machine->state_data));
 	memset(machine->state_data, 0, sizeof(*machine->state_data));
 }
 
@@ -264,7 +264,7 @@ void state_save_register_memory(running_machine *machine, const char *module, co
 
 	/* didn't find one; allocate a new one */
 	next = *entryptr;
-	*entryptr = malloc_or_die(sizeof(**entryptr));
+	*entryptr = (state_entry *)malloc_or_die(sizeof(**entryptr));
 	memset(*entryptr, 0, sizeof(**entryptr));
 
 	/* fill in the rest */
@@ -314,7 +314,7 @@ void state_save_register_presave(running_machine *machine, state_presave_func fu
 			fatalerror("Duplicate save state function (%p, %p)", param, func);
 
 	/* allocate a new entry */
-	*cbptr = malloc_or_die(sizeof(state_callback));
+	*cbptr = (state_callback *)malloc_or_die(sizeof(state_callback));
 
 	/* fill it in */
 	(*cbptr)->next         = NULL;
@@ -345,7 +345,7 @@ void state_save_register_postload(running_machine *machine, state_postload_func
 			fatalerror("Duplicate save state function (%p, %p)", param, func);
 
 	/* allocate a new entry */
-	*cbptr = malloc_or_die(sizeof(state_callback));
+	*cbptr = (state_callback *)malloc_or_die(sizeof(state_callback));
 
 	/* fill it in */
 	(*cbptr)->next          = NULL;

src/emu/state.h

@@ -52,7 +52,7 @@ typedef enum _state_save_error state_save_error;
 
 
 #define IS_COMPATIBLE_TYPE(_valtype, _checktype)										\
-	(sizeof(_valtype) == sizeof(_checktype) && TYPES_COMPATIBLE(typeof(_valtype), _checktype))
+	(sizeof(_valtype) == sizeof(_checktype) && TYPES_COMPATIBLE(_valtype, _checktype))
 
 #define IS_VALID_SAVE_TYPE(_valtype)													\
 	(IS_COMPATIBLE_TYPE(_valtype, double) || IS_COMPATIBLE_TYPE(_valtype, float)  ||	\

src/emu/streams.c

@@ -218,7 +218,7 @@ void streams_init(running_machine *machine)
 	streams_private *strdata;
 
 	/* allocate memory for our private data */
-	strdata = auto_malloc(sizeof(*strdata));
+	strdata = (streams_private *)auto_malloc(sizeof(*strdata));
 	memset(strdata, 0, sizeof(*strdata));
 
 	/* reset globals */
@@ -343,7 +343,7 @@ sound_stream *stream_create(const device_config *device, int inputs, int outputs
 	char statetag[30];
 
 	/* allocate memory */
-	stream = auto_malloc(sizeof(*stream));
+	stream = (sound_stream *)auto_malloc(sizeof(*stream));
 	memset(stream, 0, sizeof(*stream));
 
 	VPRINTF(("stream_create(%d, %d, %d) => %p\n", inputs, outputs, sample_rate, stream));
@@ -365,9 +365,9 @@ sound_stream *stream_create(const device_config *device, int inputs, int outputs
 	/* allocate space for the inputs */
 	if (inputs > 0)
 	{
-		stream->input = auto_malloc(inputs * sizeof(*stream->input));
+		stream->input = (stream_input *)auto_malloc(inputs * sizeof(*stream->input));
 		memset(stream->input, 0, inputs * sizeof(*stream->input));
-		stream->input_array = auto_malloc(inputs * sizeof(*stream->input_array));
+		stream->input_array = (stream_sample_t **)auto_malloc(inputs * sizeof(*stream->input_array));
 		memset(stream->input_array, 0, inputs * sizeof(*stream->input_array));
 	}
 
@@ -382,9 +382,9 @@ sound_stream *stream_create(const device_config *device, int inputs, int outputs
 	/* allocate space for the outputs */
 	if (outputs > 0)
 	{
-		stream->output = auto_malloc(outputs * sizeof(*stream->output));
+		stream->output = (stream_output *)auto_malloc(outputs * sizeof(*stream->output));
 		memset(stream->output, 0, outputs * sizeof(*stream->output));
-		stream->output_array = auto_malloc(outputs * sizeof(*stream->output_array));
+		stream->output_array = (stream_sample_t **)auto_malloc(outputs * sizeof(*stream->output_array));
 		memset(stream->output_array, 0, outputs * sizeof(*stream->output_array));
 	}
 
@@ -698,7 +698,7 @@ void stream_set_output_gain(sound_stream *stream, int output, float gain)
 static STATE_POSTLOAD( stream_postload )
 {
 	streams_private *strdata = machine->streams_data;
-	sound_stream *stream = param;
+	sound_stream *stream = (sound_stream *)param;
 	int outputnum;
 
 	/* recompute the same rate information */
@@ -737,7 +737,7 @@ static void allocate_resample_buffers(streams_private *strdata, sound_stream *st
 		for (inputnum = 0; inputnum < stream->inputs; inputnum++)
 		{
 			stream_input *input = &stream->input[inputnum];
-			input->resample = auto_realloc(input->resample, stream->resample_bufalloc * sizeof(input->resample[0]));
+			input->resample = (stream_sample_t *)auto_realloc(input->resample, stream->resample_bufalloc * sizeof(input->resample[0]));
 		}
 	}
 }
@@ -767,7 +767,7 @@ static void allocate_output_buffers(streams_private *strdata, sound_stream *stre
 		for (outputnum = 0; outputnum < stream->outputs; outputnum++)
 		{
 			stream_output *output = &stream->output[outputnum];
-			output->buffer = auto_realloc(output->buffer, stream->output_bufalloc * sizeof(output->buffer[0]));
+			output->buffer = (stream_sample_t *)auto_realloc(output->buffer, stream->output_bufalloc * sizeof(output->buffer[0]));
 			memset(&output->buffer[oldsize], 0, (stream->output_bufalloc - oldsize) * sizeof(output->buffer[0]));
 		}
 	}

src/emu/tilemap.c

@@ -324,7 +324,7 @@ tilemap *tilemap_create(running_machine *machine, tile_get_info_func tile_get_in
 	int group;
 
 	/* allocate the tilemap itself */
-	tmap = malloc_or_die(sizeof(*tmap));
+	tmap = (tilemap *)malloc_or_die(sizeof(*tmap));
 	memset(tmap, 0, sizeof(*tmap));
 
 	/* fill in the basic metrics */
@@ -354,18 +354,18 @@ tilemap *tilemap_create(running_machine *machine, tile_get_info_func tile_get_in
 	/* initialize scroll information */
 	tmap->scrollrows = 1;
 	tmap->scrollcols = 1;
-	tmap->rowscroll = malloc_or_die(tmap->height * sizeof(*tmap->rowscroll));
+	tmap->rowscroll = (INT32 *)malloc_or_die(tmap->height * sizeof(*tmap->rowscroll));
 	memset(tmap->rowscroll, 0, tmap->height * sizeof(*tmap->rowscroll));
-	tmap->colscroll = malloc_or_die(tmap->width * sizeof(*tmap->colscroll));
+	tmap->colscroll = (INT32 *)malloc_or_die(tmap->width * sizeof(*tmap->colscroll));
 	memset(tmap->colscroll, 0, tmap->width * sizeof(*tmap->colscroll));
 
 	/* allocate the pixel data cache */
 	tmap->pixmap = bitmap_alloc(tmap->width, tmap->height, BITMAP_FORMAT_INDEXED16);
 
 	/* allocate transparency mapping data */
-	tmap->tileflags = malloc_or_die(tmap->max_logical_index);
+	tmap->tileflags = (UINT8 *)malloc_or_die(tmap->max_logical_index);
 	tmap->flagsmap = bitmap_alloc(tmap->width, tmap->height, BITMAP_FORMAT_INDEXED8);
-	tmap->pen_to_flags = malloc_or_die(sizeof(tmap->pen_to_flags[0]) * MAX_PEN_TO_FLAGS * TILEMAP_NUM_GROUPS);
+	tmap->pen_to_flags = (UINT8 *)malloc_or_die(sizeof(tmap->pen_to_flags[0]) * MAX_PEN_TO_FLAGS * TILEMAP_NUM_GROUPS);
 	memset(tmap->pen_to_flags, 0, sizeof(tmap->pen_to_flags[0]) * MAX_PEN_TO_FLAGS * TILEMAP_NUM_GROUPS);
 	for (group = 0; group < TILEMAP_NUM_GROUPS; group++)
 		tilemap_map_pens_to_layer(tmap, group, 0, 0, TILEMAP_PIXEL_LAYER0);
@@ -1095,7 +1095,7 @@ static void tilemap_exit(running_machine *machine)
 static STATE_POSTLOAD( tilemap_postload )
 {
 	/* recompute the mappings for this tilemap */
-	tilemap *tmap = param;
+	tilemap *tmap = (tilemap *)param;
 	mappings_update(tmap);
 }
 
@@ -1157,8 +1157,8 @@ static void mappings_create(tilemap *tmap)
 	tmap->max_memory_index++;
 
 	/* allocate the necessary mappings */
-	tmap->memory_to_logical = malloc_or_die(tmap->max_memory_index * sizeof(*tmap->memory_to_logical));
+	tmap->memory_to_logical = (tilemap_logical_index *)malloc_or_die(tmap->max_memory_index * sizeof(*tmap->memory_to_logical));
-	tmap->logical_to_memory = malloc_or_die(tmap->max_logical_index * sizeof(*tmap->logical_to_memory));
+	tmap->logical_to_memory = (tilemap_memory_index *)malloc_or_die(tmap->max_logical_index * sizeof(*tmap->logical_to_memory));
 
 	/* update the mappings */
 	mappings_update(tmap);
@@ -1969,7 +1969,7 @@ static void scanline_draw_masked_null(void *dest, const UINT16 *source, const UI
 
 static void scanline_draw_opaque_ind16(void *_dest, const UINT16 *source, int count, const pen_t *pens, UINT8 *pri, UINT32 pcode, UINT8 alpha)
 {
-	UINT16 *dest = _dest;
+	UINT16 *dest = (UINT16 *)_dest;
 	int pal = pcode >> 16;
 	int i;
 
@@ -2012,7 +2012,7 @@ static void scanline_draw_opaque_ind16(void *_dest, const UINT16 *source, int co
 
 static void scanline_draw_masked_ind16(void *_dest, const UINT16 *source, const UINT8 *maskptr, int mask, int value, int count, const pen_t *pens, UINT8 *pri, UINT32 pcode, UINT8 alpha)
 {
-	UINT16 *dest = _dest;
+	UINT16 *dest = (UINT16 *)_dest;
 	int pal = pcode >> 16;
 	int i;
 
@@ -2046,7 +2046,7 @@ static void scanline_draw_masked_ind16(void *_dest, const UINT16 *source, const
 static void scanline_draw_opaque_rgb16(void *_dest, const UINT16 *source, int count, const pen_t *pens, UINT8 *pri, UINT32 pcode, UINT8 alpha)
 {
 	const pen_t *clut = &pens[pcode >> 16];
-	UINT16 *dest = _dest;
+	UINT16 *dest = (UINT16 *)_dest;
 	int i;
 
 	/* priority case */
@@ -2076,7 +2076,7 @@ static void scanline_draw_opaque_rgb16(void *_dest, const UINT16 *source, int co
 static void scanline_draw_masked_rgb16(void *_dest, const UINT16 *source, const UINT8 *maskptr, int mask, int value, int count, const pen_t *pens, UINT8 *pri, UINT32 pcode, UINT8 alpha)
 {
 	const pen_t *clut = &pens[pcode >> 16];
-	UINT16 *dest = _dest;
+	UINT16 *dest = (UINT16 *)_dest;
 	int i;
 
 	/* priority case */
@@ -2108,7 +2108,7 @@ static void scanline_draw_masked_rgb16(void *_dest, const UINT16 *source, const
 static void scanline_draw_opaque_rgb16_alpha(void *_dest, const UINT16 *source, int count, const pen_t *pens, UINT8 *pri, UINT32 pcode, UINT8 alpha)
 {
 	const pen_t *clut = &pens[pcode >> 16];
-	UINT16 *dest = _dest;
+	UINT16 *dest = (UINT16 *)_dest;
 	int i;
 
 	/* priority case */
@@ -2139,7 +2139,7 @@ static void scanline_draw_opaque_rgb16_alpha(void *_dest, const UINT16 *source,
 static void scanline_draw_masked_rgb16_alpha(void *_dest, const UINT16 *source, const UINT8 *maskptr, int mask, int value, int count, const pen_t *pens, UINT8 *pri, UINT32 pcode, UINT8 alpha)
 {
 	const pen_t *clut = &pens[pcode >> 16];
-	UINT16 *dest = _dest;
+	UINT16 *dest = (UINT16 *)_dest;
 	int i;
 
 	/* priority case */
@@ -2171,7 +2171,7 @@ static void scanline_draw_masked_rgb16_alpha(void *_dest, const UINT16 *source,
 static void scanline_draw_opaque_rgb32(void *_dest, const UINT16 *source, int count, const pen_t *pens, UINT8 *pri, UINT32 pcode, UINT8 alpha)
 {
 	const pen_t *clut = &pens[pcode >> 16];
-	UINT32 *dest = _dest;
+	UINT32 *dest = (UINT32 *)_dest;
 	int i;
 
 	/* priority case */
@@ -2201,7 +2201,7 @@ static void scanline_draw_opaque_rgb32(void *_dest, const UINT16 *source, int co
 static void scanline_draw_masked_rgb32(void *_dest, const UINT16 *source, const UINT8 *maskptr, int mask, int value, int count, const pen_t *pens, UINT8 *pri, UINT32 pcode, UINT8 alpha)
 {
 	const pen_t *clut = &pens[pcode >> 16];
-	UINT32 *dest = _dest;
+	UINT32 *dest = (UINT32 *)_dest;
 	int i;
 
 	/* priority case */
@@ -2233,7 +2233,7 @@ static void scanline_draw_masked_rgb32(void *_dest, const UINT16 *source, const
 static void scanline_draw_opaque_rgb32_alpha(void *_dest, const UINT16 *source, int count, const pen_t *pens, UINT8 *pri, UINT32 pcode, UINT8 alpha)
 {
 	const pen_t *clut = &pens[pcode >> 16];
-	UINT32 *dest = _dest;
+	UINT32 *dest = (UINT32 *)_dest;
 	int i;
 
 	/* priority case */
@@ -2264,7 +2264,7 @@ static void scanline_draw_opaque_rgb32_alpha(void *_dest, const UINT16 *source,
 static void scanline_draw_masked_rgb32_alpha(void *_dest, const UINT16 *source, const UINT8 *maskptr, int mask, int value, int count, const pen_t *pens, UINT8 *pri, UINT32 pcode, UINT8 alpha)
 {
 	const pen_t *clut = &pens[pcode >> 16];
-	UINT32 *dest = _dest;
+	UINT32 *dest = (UINT32 *)_dest;
 	int i;
 
 	/* priority case */

src/emu/timer.c

@@ -300,7 +300,7 @@ void timer_init(running_machine *machine)
 	int i;
 
 	/* allocate global data */
-	global = machine->timer_data = auto_malloc(sizeof(*global));
+	global = machine->timer_data = (timer_private *)auto_malloc(sizeof(*global));
 	memset(global, 0, sizeof(*global));
 
 	/* we need to wait until the first call to timer_cyclestorun before using real CPU times */
@@ -339,7 +339,7 @@ void timer_init(running_machine *machine)
 
 void timer_destructor(void *ptr, size_t size)
 {
-	timer_remove(ptr);
+	timer_remove((emu_timer *)ptr);
 }
 
 
@@ -1056,9 +1056,9 @@ attotime timer_device_firetime(const device_config *timer)
 
 static TIMER_CALLBACK( periodic_timer_device_timer_callback )
 {
-	const device_config *timer = ptr;
+	const device_config *timer = (const device_config *)ptr;
 	timer_state *state = get_safe_token(timer);
-	timer_config *config = timer->inline_config;
+	timer_config *config = (timer_config *)timer->inline_config;
 
 	/* call the real callback */
 	config->callback(timer, state->ptr, state->param);
@@ -1074,9 +1074,9 @@ static TIMER_CALLBACK( periodic_timer_device_timer_callback )
 static TIMER_CALLBACK( scanline_timer_device_timer_callback )
 {
 	int next_vpos;
-	const device_config *timer = ptr;
+	const device_config *timer = (const device_config *)ptr;
 	timer_state *state = get_safe_token(timer);
-	timer_config *config = timer->inline_config;
+	timer_config *config = (timer_config *)timer->inline_config;
 
 	/* get the screen device and verify it */
 	const device_config *screen = devtag_get_device(timer->machine, config->screen);
@@ -1173,7 +1173,7 @@ static DEVICE_START( timer )
 	assert(device->machine->config != NULL);
 
 	/* get and validate the configuration */
-	config = device->inline_config;
+	config = (timer_config *)device->inline_config;
 	assert(config->type == TIMER_TYPE_PERIODIC || config->type == TIMER_TYPE_SCANLINE || config->type == TIMER_TYPE_GENERIC);
 	assert(config->callback != NULL);
 

src/emu/ui.c

@@ -1059,7 +1059,7 @@ astring *game_info_astring(running_machine *machine, astring *string)
 
 		for (screen = video_screen_first(machine->config); screen != NULL; screen = video_screen_next(screen))
 		{
-			const screen_config *scrconfig = screen->inline_config;
+			const screen_config *scrconfig = (const screen_config *)screen->inline_config;
 
 			if (scrcount > 1)
 			{
@@ -1414,7 +1414,7 @@ const slider_state *ui_get_slider_list(void)
 static slider_state *slider_alloc(const char *title, INT32 minval, INT32 defval, INT32 maxval, INT32 incval, slider_update update, void *arg)
 {
 	int size = sizeof(slider_state) + strlen(title);
-	slider_state *state = auto_malloc(size);
+	slider_state *state = (slider_state *)auto_malloc(size);
 	memset(state, 0, size);
 
 	state->minval = minval;
@@ -1488,7 +1488,7 @@ static slider_state *slider_init(running_machine *machine)
 	/* add screen parameters */
 	for (device = video_screen_first(machine->config); device != NULL; device = video_screen_next(device))
 	{
-		const screen_config *scrconfig = device->inline_config;
+		const screen_config *scrconfig = (const screen_config *)device->inline_config;
 		int defxscale = floor(scrconfig->xscale * 1000.0f + 0.5f);
 		int defyscale = floor(scrconfig->yscale * 1000.0f + 0.5f);
 		int defxoffset = floor(scrconfig->xoffset * 1000.0f + 0.5f);
@@ -1531,7 +1531,7 @@ static slider_state *slider_init(running_machine *machine)
 
 	for (device = device_list_first(machine->config->devicelist, LASERDISC); device != NULL; device = device_list_next(device, LASERDISC))
 	{
-		const laserdisc_config *config = device->inline_config;
+		const laserdisc_config *config = (const laserdisc_config *)device->inline_config;
 		if (config->overupdate != NULL)
 		{
 			int defxscale = floor(config->overscalex * 1000.0f + 0.5f);
@@ -1558,7 +1558,7 @@ static slider_state *slider_init(running_machine *machine)
 
 	for (device = video_screen_first(machine->config); device != NULL; device = video_screen_next(device))
 	{
-		const screen_config *scrconfig = device->inline_config;
+		const screen_config *scrconfig = (const screen_config *)device->inline_config;
 		if (scrconfig->type == SCREEN_TYPE_VECTOR)
 		{
 			/* add flicker control */
@@ -1628,7 +1628,7 @@ static INT32 slider_mixervol(running_machine *machine, void *arg, astring *strin
 
 static INT32 slider_adjuster(running_machine *machine, void *arg, astring *string, INT32 newval)
 {
-	const input_field_config *field = arg;
+	const input_field_config *field = (const input_field_config *)arg;
 	input_field_user_settings settings;
 
 	input_field_get_user_settings(field, &settings);
@@ -1665,8 +1665,8 @@ static INT32 slider_overclock(running_machine *machine, void *arg, astring *stri
 
 static INT32 slider_refresh(running_machine *machine, void *arg, astring *string, INT32 newval)
 {
-	const device_config *screen = arg;
+	const device_config *screen = (const device_config *)arg;
-	const screen_config *scrconfig = screen->inline_config;
+	const screen_config *scrconfig = (const screen_config *)screen->inline_config;
 	double defrefresh = ATTOSECONDS_TO_HZ(scrconfig->refresh);
 	double refresh;
 
@@ -1692,7 +1692,7 @@ static INT32 slider_refresh(running_machine *machine, void *arg, astring *string
 
 static INT32 slider_brightness(running_machine *machine, void *arg, astring *string, INT32 newval)
 {
-	const device_config *screen = arg;
+	const device_config *screen = (const device_config *)arg;
 	render_container *container = render_container_get_screen(screen);
 	render_container_user_settings settings;
 
@@ -1715,7 +1715,7 @@ static INT32 slider_brightness(running_machine *machine, void *arg, astring *str
 
 static INT32 slider_contrast(running_machine *machine, void *arg, astring *string, INT32 newval)
 {
-	const device_config *screen = arg;
+	const device_config *screen = (const device_config *)arg;
 	render_container *container = render_container_get_screen(screen);
 	render_container_user_settings settings;
 
@@ -1737,7 +1737,7 @@ static INT32 slider_contrast(running_machine *machine, void *arg, astring *strin
 
 static INT32 slider_gamma(running_machine *machine, void *arg, astring *string, INT32 newval)
 {
-	const device_config *screen = arg;
+	const device_config *screen = (const device_config *)arg;
 	render_container *container = render_container_get_screen(screen);
 	render_container_user_settings settings;
 
@@ -1760,7 +1760,7 @@ static INT32 slider_gamma(running_machine *machine, void *arg, astring *string,
 
 static INT32 slider_xscale(running_machine *machine, void *arg, astring *string, INT32 newval)
 {
-	const device_config *screen = arg;
+	const device_config *screen = (const device_config *)arg;
 	render_container *container = render_container_get_screen(screen);
 	render_container_user_settings settings;
 
@@ -1783,7 +1783,7 @@ static INT32 slider_xscale(running_machine *machine, void *arg, astring *string,
 
 static INT32 slider_yscale(running_machine *machine, void *arg, astring *string, INT32 newval)
 {
-	const device_config *screen = arg;
+	const device_config *screen = (const device_config *)arg;
 	render_container *container = render_container_get_screen(screen);
 	render_container_user_settings settings;
 
@@ -1806,7 +1806,7 @@ static INT32 slider_yscale(running_machine *machine, void *arg, astring *string,
 
 static INT32 slider_xoffset(running_machine *machine, void *arg, astring *string, INT32 newval)
 {
-	const device_config *screen = arg;
+	const device_config *screen = (const device_config *)arg;
 	render_container *container = render_container_get_screen(screen);
 	render_container_user_settings settings;
 
@@ -1829,7 +1829,7 @@ static INT32 slider_xoffset(running_machine *machine, void *arg, astring *string
 
 static INT32 slider_yoffset(running_machine *machine, void *arg, astring *string, INT32 newval)
 {
-	const device_config *screen = arg;
+	const device_config *screen = (const device_config *)arg;
 	render_container *container = render_container_get_screen(screen);
 	render_container_user_settings settings;
 
@@ -1852,7 +1852,7 @@ static INT32 slider_yoffset(running_machine *machine, void *arg, astring *string
 
 static INT32 slider_overxscale(running_machine *machine, void *arg, astring *string, INT32 newval)
 {
-	const device_config *laserdisc = arg;
+	const device_config *laserdisc = (const device_config *)arg;
 	laserdisc_config settings;
 
 	laserdisc_get_config(laserdisc, &settings);
@@ -1874,7 +1874,7 @@ static INT32 slider_overxscale(running_machine *machine, void *arg, astring *str
 
 static INT32 slider_overyscale(running_machine *machine, void *arg, astring *string, INT32 newval)
 {
-	const device_config *laserdisc = arg;
+	const device_config *laserdisc = (const device_config *)arg;
 	laserdisc_config settings;
 
 	laserdisc_get_config(laserdisc, &settings);
@@ -1896,7 +1896,7 @@ static INT32 slider_overyscale(running_machine *machine, void *arg, astring *str
 
 static INT32 slider_overxoffset(running_machine *machine, void *arg, astring *string, INT32 newval)
 {
-	const device_config *laserdisc = arg;
+	const device_config *laserdisc = (const device_config *)arg;
 	laserdisc_config settings;
 
 	laserdisc_get_config(laserdisc, &settings);
@@ -1918,7 +1918,7 @@ static INT32 slider_overxoffset(running_machine *machine, void *arg, astring *st
 
 static INT32 slider_overyoffset(running_machine *machine, void *arg, astring *string, INT32 newval)
 {
-	const device_config *laserdisc = arg;
+	const device_config *laserdisc = (const device_config *)arg;
 	laserdisc_config settings;
 
 	laserdisc_get_config(laserdisc, &settings);

src/emu/uigfx.c

@@ -379,8 +379,8 @@ static void palette_handle_keys(running_machine *machine, ui_gfx_state *state)
 	/* clamp within range */
 	if (state->palette.which < 0)
 		state->palette.which = 1;
-	if (state->palette.which > (machine->colortable != NULL))
+	if (state->palette.which > (int)(machine->colortable != NULL))
-		state->palette.which = (machine->colortable != NULL);
+		state->palette.which = (int)(machine->colortable != NULL);
 
 	/* cache some info in locals */
 	total = state->palette.which ? colortable_palette_get_size(machine->colortable) : machine->config->total_colors;