Previous 15994 Revisions Next

r8324 Sunday 27th June, 2010 at 09:09:05 UTC by Miodrag Milanović
Moved image related macros to diimage.h changed type to boolean and updated code.
[src/emu]devimage.c diimage.h image.c
[src/mess]mess.h
[src/mess/devices]aescart.c cartslot.c cassette.c chd_cd.c coco_vhd.c flopdrv.c harddriv.c kermit.c printer.c snapquik.c ti99cart.c xmodem.c z80bin.c
[src/mess/drivers]advision.c altair.c apexc.c arcadia.c astrocde.c atarist.c atom.c bbcbc.c bw2.c cgenie.c channelf.c coleco.c cosmicos.c crvision.c elf.c exelv.c gamepock.c gba.c gmaster.c jaguar.c lynx.c n64.c nc.c newbrain.c ng_aes.c ngp.c pasogo.c pegasus.c pockstat.c psx.c pv1000.c ql.c scv.c sg1000.c spectrum.c ssem.c super80.c supracan.c svision.c tm990189.c tmc1800.c tutor.c vboy.c vc4000.c vic20.c vidbrain.c vii.c vip.c vtech1.c
[src/mess/formats]atom_atm.c cbm_snqk.c comx35_comx.c m65_snqk.c spec_snqk.c studio2_st2.c ti85_ser.c timex_dck.c trs_cmd.c
[src/mess/machine]990_hd.c 990_tap.c 994x_ser.c a7800.c amstrad.c apple1.c ataricrt.c c16.c c64.c cbmb.c coco.c exidy.c galaxy.c gamecom.c gb.c genesis.c hp48.c intv.c kaypro.c kc.c lviv.c lynx.c mbee.c mekd2.c msx.c mtx.c nascom1.c nc.c nes.c pc.c pdp1.c pet.c pokemini.c poly88.c primo.c serial.c smartmed.c sms.c snescart.c svi318.c thomson.c ti85.c tx0.c vectrex.c vtech2.c wswan.c x68k_hdc.c z1013.c
[src/mess/tools/messtest]testmess.c

src/emu/diimage.h
r8323r8324
121121//  MACROS
122122//**************************************************************************
123123
124#define IMAGE_INIT_PASS      FALSE
125#define IMAGE_INIT_FAIL      TRUE
126#define IMAGE_VERIFY_PASS   FALSE
127#define IMAGE_VERIFY_FAIL   TRUE
128
124129#define DEVICE_IMAGE_LOAD_NAME(name)        device_load_##name
125130#define DEVICE_IMAGE_LOAD(name)             int DEVICE_IMAGE_LOAD_NAME(name)(device_image_interface &image)
126131
src/emu/devimage.c
r8323r8324
387387         }
388388      }
389389   }
390   return err ? FALSE : TRUE;
390   return err ? IMAGE_INIT_FAIL : IMAGE_INIT_PASS;
391391}
392392
393393
r8323r8324
409409
410410bool legacy_image_device_base::finish_load()
411411{
412    bool err = FALSE;
412    bool err = IMAGE_INIT_PASS;
413413
414414    if (m_is_loading)
415415    {
src/emu/image.c
r8323r8324
215215
216216      if ((image_name != NULL) && (image_name[0] != '\0'))
217217      {
218         bool result = FALSE;
219
220218         /* mark init state */
221219         image->set_init_phase();
222220         
223221         /* try to load this image */
224         result = image->load(image_name);
222         bool result = image->load(image_name);
225223
226224         /* did the image load fail? */
227         if (!result)
225         if (result)
228226         {
229227            /* retrieve image error message */
230228            const char *image_err = image->error();
src/mess/devices/harddriv.c
r8323r8324
141141
142142      image.seterror(IMAGE_ERROR_UNSPECIFIED, chd_get_error_string(err));
143143   }
144   return err ? INIT_FAIL : INIT_PASS;
144   return err ? IMAGE_INIT_FAIL : IMAGE_INIT_PASS;
145145}
146146
147147
r8323r8324
187187   return internal_load_mess_hd(image, metadata);
188188
189189error:
190   return INIT_FAIL;
190   return IMAGE_INIT_FAIL;
191191}
192192
193193
r8323r8324
346346
347347   /* call the parent load function */
348348   result = parent_load(image);
349   if (result != INIT_PASS)
349   if (result != IMAGE_INIT_PASS)
350350      return result;
351351
352352   /* configure IDE */
353353   /* FIXME IDE */
354354   /* ide_controller_init_custom(which_bus, intf, mess_hd_get_chd_file(image)); */
355355   /* ide_controller_reset(which_bus); */
356   return INIT_PASS;
356   return IMAGE_INIT_PASS;
357357#endif
358358   return device_load_mess_hd( image );
359359}
src/mess/devices/ti99cart.c
r8323r8324
677677static int assemble_std(running_device *image)
678678{
679679   assemble_common(image);
680   return INIT_PASS;
680   return IMAGE_INIT_PASS;
681681}
682682
683683/*
r8323r8324
721721
722722   clear_slot(cartsys, slotnumber);
723723
724   return INIT_PASS;
724   return IMAGE_INIT_PASS;
725725}
726726
727727/*****************************************************************************
r8323r8324
835835   if (cart->rom_ptr==NULL)
836836   {
837837      logerror("Missing ROM for paged cartridge");
838      return INIT_FAIL;
838      return IMAGE_INIT_FAIL;
839839   }
840840   if (cart->rom2_ptr==NULL)
841841   {
842842      logerror("Missing second ROM for paged cartridge");
843      return INIT_FAIL;
843      return IMAGE_INIT_FAIL;
844844   }
845845
846   return INIT_PASS;
846   return IMAGE_INIT_PASS;
847847}
848848
849849/*****************************************************************************
r8323r8324
991991      logerror("Missing GROM for Mini Memory");
992992      // should not fail here because there may be variations of
993993      // cartridges which do not use all parts
994//      return INIT_FAIL;
994//      return IMAGE_INIT_FAIL;
995995   }
996996   if (cart->rom_size==0)
997997   {
998998      logerror("Missing ROM for Mini Memory");
999//      return INIT_FAIL;
999//      return IMAGE_INIT_FAIL;
10001000   }
10011001   if (cart->ram_size==0)
10021002   {
10031003      logerror("Missing RAM for Mini Memory");
1004//      return INIT_FAIL;
1004//      return IMAGE_INIT_FAIL;
10051005   }
10061006
1007   return INIT_PASS;
1007   return IMAGE_INIT_PASS;
10081008}
10091009
10101010
r8323r8324
11871187   if (cart->ram_size==0)
11881188   {
11891189      logerror("Missing RAM for SuperSpace");
1190      return INIT_FAIL;
1190      return IMAGE_INIT_FAIL;
11911191   }
1192   return INIT_PASS;
1192   return IMAGE_INIT_PASS;
11931193}
11941194
11951195/*****************************************************************************
r8323r8324
13081308static int assemble_mbx(running_device *image)
13091309{
13101310   assemble_common(image);
1311   return INIT_PASS;
1311   return IMAGE_INIT_PASS;
13121312}
13131313
13141314/*****************************************************************************
r8323r8324
14651465   if (cart->rom_ptr==NULL)
14661466   {
14671467      logerror("Missing ROM for paged cartridge");
1468      return INIT_FAIL;
1468      return IMAGE_INIT_FAIL;
14691469   }
14701470   set_paged379i_bank(cart, 15);
1471   return INIT_PASS;
1471   return IMAGE_INIT_PASS;
14721472}
14731473
14741474/*****************************************************************************
r8323r8324
16171617   if (cart->rom_ptr==NULL)
16181618   {
16191619      logerror("Missing ROM for pagedcru cartridge");
1620      return INIT_FAIL;
1620      return IMAGE_INIT_FAIL;
16211621   }
16221622   cart->rom_page = 0;
1623   return INIT_PASS;
1623   return IMAGE_INIT_PASS;
16241624}
16251625
16261626/*****************************************************************************
r8323r8324
16501650   if (cart->grom_ptr==NULL)
16511651   {
16521652      logerror("Missing loader GROM for GRAM Kracker system");
1653      return INIT_FAIL;
1653      return IMAGE_INIT_FAIL;
16541654   }
16551655
16561656   if (cart->ram_size < 81920)
16571657   {
16581658      logerror("Missing or insufficient RAM for GRAM Kracker system");
1659      return INIT_FAIL;
1659      return IMAGE_INIT_FAIL;
16601660   }
16611661
16621662   // Caution: We are using the ram_socket for both grom and direct access.
r8323r8324
16831683         break;
16841684      }
16851685   }
1686   return INIT_PASS;
1686   return IMAGE_INIT_PASS;
16871687}
16881688
16891689/*
r8323r8324
20982098
20992099   result = load_legacy(image);
21002100
2101   if (result != INIT_FAIL)
2101   if (result != IMAGE_INIT_FAIL)
21022102      cartslots->legacy_slots++;
21032103   else
21042104   {
r8323r8324
21252125
21262126         // This is for legacy support. If we have no multicart left
21272127         // but there are still legacy dumps, we switch to legacy mode.
2128         if (result != INIT_FAIL)
2128         if (result != IMAGE_INIT_FAIL)
21292129            cartslots->multi_slots++;
21302130      }
21312131      else
r8323r8324
24832483
24842484   if (type == SLOTC_EMPTY)
24852485   {
2486      return INIT_FAIL;
2486      return IMAGE_INIT_FAIL;
24872487   }
24882488
24892489   id = get_index_from_tagname(image)-1;
r8323r8324
26182618         cartslots->cartridge[id].rom_size = filesize;
26192619         break;
26202620   }
2621   return INIT_PASS;
2621   return IMAGE_INIT_PASS;
26222622}
26232623
26242624static void unload_legacy(device_image_interface &image)
src/mess/devices/z80bin.c
r8323r8324
4444      {
4545         image->seterror(IMAGE_ERROR_INVALIDIMAGE, "Unexpected EOF while getting file name");
4646         image->message(" Unexpected EOF while getting file name");
47         return INIT_FAIL;
47         return IMAGE_INIT_FAIL;
4848      }
4949
5050      if (ch != '\0')
r8323r8324
5353         {
5454            image->seterror(IMAGE_ERROR_INVALIDIMAGE, "File name too long");
5555            image->message(" File name too long");
56            return INIT_FAIL;
56            return IMAGE_INIT_FAIL;
5757         }
5858
5959         pgmname[i] = ch;   /* build program name */
r8323r8324
6767   {
6868      image->seterror(IMAGE_ERROR_INVALIDIMAGE, "Unexpected EOF while getting file size");
6969      image->message(" Unexpected EOF while getting file size");
70      return INIT_FAIL;
70      return IMAGE_INIT_FAIL;
7171   }
7272
7373   exec_addr[0] = LITTLE_ENDIANIZE_INT16(args[0]);
r8323r8324
8787         snprintf(message, ARRAY_LENGTH(message), "%s: Unexpected EOF while writing byte to %04X", pgmname, (unsigned) j);
8888         image->seterror(IMAGE_ERROR_INVALIDIMAGE, message);
8989         image->message("%s: Unexpected EOF while writing byte to %04X", pgmname, (unsigned) j);
90         return INIT_FAIL;
90         return IMAGE_INIT_FAIL;
9191      }
9292      memory_write_byte(cputag_get_address_space(image->device().machine,"maincpu",ADDRESS_SPACE_PROGRAM), j, data);
9393   }
9494
95   return INIT_PASS;
95   return IMAGE_INIT_PASS;
9696}
9797
9898
r8323r8324
108108   int autorun;
109109
110110   /* load the binary into memory */
111   if (z80bin_load_file(&image, file_type, &exec_addr, &start_addr, &end_addr) == INIT_FAIL)
112      return INIT_FAIL;
111   if (z80bin_load_file(&image, file_type, &exec_addr, &start_addr, &end_addr) == IMAGE_INIT_FAIL)
112      return IMAGE_INIT_FAIL;
113113
114114   /* is this file executable? */
115115   if (exec_addr != 0xffff)
r8323r8324
131131      }
132132   }
133133
134   return INIT_PASS;
134   return IMAGE_INIT_PASS;
135135}
136136
137137
src/mess/devices/cassette.c
r8323r8324
303303   cassette->position = 0.0;
304304   cassette->position_time = attotime_to_double(timer_get_time(device->machine));
305305
306   return INIT_PASS;
306   return IMAGE_INIT_PASS;
307307
308308error:
309   return INIT_FAIL;
309   return IMAGE_INIT_FAIL;
310310}
311311
312312
src/mess/devices/flopdrv.c
r8323r8324
679679         floppy_get_tracks_per_disk(flopimg->floppy),
680680         floppy_get_heads_per_disk(flopimg->floppy));
681681   }
682   return INIT_PASS;
682   return IMAGE_INIT_PASS;
683683
684684error:
685685   for (i = 0; i < ARRAY_LENGTH(errmap); i++)
r8323r8324
687687      if (err == errmap[i].ferr)
688688         image->seterror(errmap[i].ierr, errmap[i].message);
689689   }
690   return INIT_FAIL;
690   return IMAGE_INIT_FAIL;
691691}
692692
693693static TIMER_CALLBACK( set_wpt )
r8323r8324
703703   floppy_drive *flopimg;
704704   int retVal = internal_floppy_device_load(&image, -1, NULL);
705705   flopimg = get_safe_token( &image.device() );
706   if (retVal==INIT_PASS) {
706   if (retVal==IMAGE_INIT_PASS) {
707707      /* if we have one of our hacky unload procs, call it */
708708      if (flopimg->load_proc)
709709         flopimg->load_proc(image);
src/mess/devices/xmodem.c
r8323r8324
315315   LOG(( "xmodem: image load\n" ));
316316   state->image = &image;
317317   xmodem_make_idle( state );
318   return INIT_PASS;
318   return IMAGE_INIT_PASS;
319319}
320320
321321static DEVICE_IMAGE_CREATE( xmodem )
r8323r8324
324324   LOG(( "xmodem: image create\n" ));
325325   state->image = &image;
326326   xmodem_make_idle( state );
327   return INIT_PASS;
327   return IMAGE_INIT_PASS;
328328}
329329
330330static DEVICE_IMAGE_UNLOAD( xmodem )
src/mess/devices/cartslot.c
r8323r8324
8080      if (flags & ROM_FULLSIZE)
8181      {
8282         if (image->length() != length)
83            return INIT_FAIL;
83            return IMAGE_INIT_FAIL;
8484      }
8585
8686      /* read the ROM */
r8323r8324
137137      clear_val = (flags & ROM_FILL_FF) ? 0xFF : 0x00;
138138      memset(ptr + pos, clear_val, length - pos);
139139   }
140   return INIT_PASS;
140   return IMAGE_INIT_PASS;
141141}
142142
143143
r8323r8324
175175      }
176176   }
177177
178   return INIT_PASS;
178   return IMAGE_INIT_PASS;
179179}
180180
181181
r8323r8324
293293     
294294      /* otherwise try the normal route */
295295      result = process_cartridge(&image, PROCESS_LOAD);
296      if (result != INIT_PASS)
296      if (result != IMAGE_INIT_PASS)
297297         return result;
298298   }
299299
300   return INIT_PASS;
300   return IMAGE_INIT_PASS;
301301}
302302
303303
src/mess/devices/kermit.c
r8323r8324
655655   LOG(( "kermit: image load\n" ));
656656   state->image = &image;
657657   kermit_reset( state );
658   return INIT_PASS;
658   return IMAGE_INIT_PASS;
659659}
660660
661661static DEVICE_IMAGE_CREATE( kermit )
r8323r8324
664664   LOG(( "kermit: image create\n" ));
665665   state->image = &image;
666666   kermit_reset( state );
667   return INIT_PASS;
667   return IMAGE_INIT_PASS;
668668}
669669
670670static DEVICE_IMAGE_UNLOAD( kermit )
src/mess/devices/chd_cd.c
r8323r8324
8383   if ( ! cdrom->cdrom_handle )
8484      goto error;
8585
86   return INIT_PASS;
86   return IMAGE_INIT_PASS;
8787
8888error:
8989   if ( chd )
9090      chd_close( chd );
9191   if ( err )
9292      image.seterror( IMAGE_ERROR_UNSPECIFIED, chd_get_error_string( err ) );
93   return INIT_FAIL;
93   return IMAGE_INIT_FAIL;
9494}
9595
9696
src/mess/devices/aescart.c
r8323r8324
263263//  printf("assemble_std, %s\n", image->tag);
264264   /*cart = */assemble_common(machine, image);
265265
266   return INIT_PASS;
266   return IMAGE_INIT_PASS;
267267}
268268
269269/*
r8323r8324
304304
305305//  clear_slot(cartsys, slotnumber);
306306
307   return INIT_PASS;
307   return IMAGE_INIT_PASS;
308308}
309309
310310/*****************************************************************************
r8323r8324
553553      // handle possible protection
554554      install_protection(image);
555555     
556      return INIT_PASS;
556      return IMAGE_INIT_PASS;
557557   }
558558
559559   if (pcbdev == NULL)
src/mess/devices/printer.c
r8323r8324
5656      conf->online(image, TRUE);
5757
5858   /* we don't need to do anything special */
59   return INIT_PASS;
59   return IMAGE_INIT_PASS;
6060}
6161
6262
src/mess/devices/coco_vhd.c
r8323r8324
105105   vhd->status = VHDSTATUS_POWER_ON_STATE;
106106   vhd->logical_record_number = 0;
107107   vhd->buffer_address = 0;
108   return INIT_PASS;
108   return IMAGE_INIT_PASS;
109109}
110110
111111
src/mess/devices/snapquik.c
r8323r8324
159159      attotime_make(config->delay_seconds, config->delay_attoseconds),
160160      0);
161161
162   return INIT_PASS;
162   return IMAGE_INIT_PASS;
163163}
164164
165165
src/mess/mess.h
r8323r8324
3232extern const char mess_disclaimer[];
3333
3434/***************************************************************************/
35
36/* IODevice Initialisation return values.  Use these to determine if */
37/* the emulation can continue if IODevice initialisation fails */
38#define INIT_PASS 0
39#define INIT_FAIL 1
40#define IMAGE_VERIFY_PASS 0
41#define IMAGE_VERIFY_FAIL 1
42
4335#endif /* __MESS_H__ */
src/mess/tools/messtest/testmess.c
r8323r8324
789789      switch(current_command->command_type)
790790      {
791791         case MESSTEST_COMMAND_IMAGE_CREATE:
792            success = (image_create(image, astring_c(filepath), format, NULL) == INIT_PASS);
792            success = (image_create(image, astring_c(filepath), format, NULL) == IMAGE_INIT_PASS);
793793            break;
794794
795795         case MESSTEST_COMMAND_IMAGE_LOAD:
796            success = (image_load(image, astring_c(filepath)) == INIT_PASS);
796            success = (image_load(image, astring_c(filepath)) == IMAGE_INIT_PASS);
797797            break;
798798
799799         default:
src/mess/machine/pdp1.c
r8323r8324
445445      break;
446446   }
447447
448   return INIT_PASS;
448   return IMAGE_INIT_PASS;
449449}
450450
451451DEVICE_IMAGE_UNLOAD( pdp1_tape )
r8323r8324
751751
752752   io_status |= io_st_tyo;
753753
754   return INIT_PASS;
754   return IMAGE_INIT_PASS;
755755}
756756
757757DEVICE_IMAGE_UNLOAD(pdp1_typewriter)
r8323r8324
10811081   /* open file */
10821082   parallel_drum.fd = &image;
10831083
1084   return INIT_PASS;
1084   return IMAGE_INIT_PASS;
10851085}
10861086
10871087DEVICE_IMAGE_UNLOAD(pdp1_drum)
src/mess/machine/ataricrt.c
r8323r8324
184184      a800_cart_is_16k = size > 0x2000;
185185      logerror("%s loaded left cartridge '%s' size %s\n", image.device().machine->gamedrv->name, image.filename() , (a800_cart_is_16k) ? "16K":"8K");
186186   }
187   return INIT_PASS;
187   return IMAGE_INIT_PASS;
188188}
189189
190190DEVICE_IMAGE_UNLOAD( a800_cart )
r8323r8324
251251      mame_fclose(basic_fp);
252252   }
253253
254   return INIT_PASS;
254   return IMAGE_INIT_PASS;
255255}
256256
257257
r8323r8324
292292   }
293293   logerror("%s loaded cartridge '%s' size %dK\n",
294294      image.device().machine->gamedrv->name, image.filename() , size/1024);
295   return INIT_PASS;
295   return IMAGE_INIT_PASS;
296296}
297297
298298DEVICE_IMAGE_UNLOAD( a5200_cart )
src/mess/machine/hp48.c
r8323r8324
10481048   if ( (size < 32*1024) || (size > conf->max_size) || (size & (size-1)) )
10491049   {
10501050      logerror( "hp48: image size for %s should be a power of two between %i and %i\n", conf->name, 32*1024, conf->max_size );
1051      return INIT_FAIL;
1051      return IMAGE_INIT_FAIL;
10521052   }
10531053
10541054   hp48_port_size[conf->port] = size;
r8323r8324
10561056   hp48_fill_port( image );
10571057   image.fread(hp48_port_data[conf->port], hp48_port_size[conf->port] );
10581058   hp48_decode_nibble( hp48_port_data[conf->port], hp48_port_data[conf->port], hp48_port_size[conf->port] );
1059   return INIT_PASS;
1059   return IMAGE_INIT_PASS;
10601060}
10611061
10621062static DEVICE_IMAGE_CREATE( hp48_port )
r8323r8324
10701070   if ( (size < 32*1024) || (size > conf->max_size) || (size & (size-1)) )
10711071   {
10721072      logerror( "hp48: image size for %s should be a power of two between %i and %i\n", conf->name, 32*1024, conf->max_size );
1073      return INIT_FAIL;
1073      return IMAGE_INIT_FAIL;
10741074   }
10751075
10761076   hp48_port_size[conf->port] = size;
10771077   hp48_port_write[conf->port] = 1;
10781078   hp48_fill_port( image );
1079   return INIT_PASS;
1079   return IMAGE_INIT_PASS;
10801080}
10811081
10821082static DEVICE_IMAGE_UNLOAD( hp48_port )
src/mess/machine/cbmb.c
r8323r8324
535535      /* Does cart contain any data? */
536536      cbmb_cbm_cart[0].chip = (UINT8*) image.image_malloc(size);
537537      if (!cbmb_cbm_cart[0].chip)
538         return INIT_FAIL;
538         return IMAGE_INIT_FAIL;
539539
540540      /* Store data, address & size */
541541      cbmb_cbm_cart[0].addr = address;
r8323r8324
543543      test = image.fread(cbmb_cbm_cart[0].chip, cbmb_cbm_cart[0].size);
544544
545545      if (test != cbmb_cbm_cart[0].size)
546         return INIT_FAIL;
546         return IMAGE_INIT_FAIL;
547547   }
548548
549549   /* Finally load the cart */
r8323r8324
552552//      memcpy(cbmb_memory + cbmb_cbm_cart[i].addr + 0xf0000, cbmb_cbm_cart[i].chip, cbmb_cbm_cart[i].size);
553553   memcpy(cbmb_memory + cbmb_cbm_cart[0].addr + 0xf0000, cbmb_cbm_cart[0].chip, cbmb_cbm_cart[0].size);
554554
555   return INIT_PASS;
555   return IMAGE_INIT_PASS;
556556}
557557
558558
src/mess/machine/mbee.c
r8323r8324
229229         if (image.fread(&data, 1) != 1)
230230         {
231231            image.message("Unexpected EOF");
232            return INIT_FAIL;
232            return IMAGE_INIT_FAIL;
233233         }
234234
235235         if ((j < mbee_size) || (j > 0xefff))
r8323r8324
237237         else
238238         {
239239            image.message("Not enough memory in this microbee");
240            return INIT_FAIL;
240            return IMAGE_INIT_FAIL;
241241         }
242242      }
243243
r8323r8324
259259         if (image.fread(&data, 1) != 1)
260260         {
261261            image.message("Unexpected EOF");
262            return INIT_FAIL;
262            return IMAGE_INIT_FAIL;
263263         }
264264
265265         if ((j < mbee_size) || (j > 0xefff))
r8323r8324
267267         else
268268         {
269269            image.message("Not enough memory in this microbee");
270            return INIT_FAIL;
270            return IMAGE_INIT_FAIL;
271271         }
272272      }
273273
274274      if (sw) cpu_set_reg(cpu, STATE_GENPC, 0x100);
275275   }
276276
277   return INIT_PASS;
277   return IMAGE_INIT_PASS;
278278}
src/mess/machine/pokemini.c
r8323r8324
14091409      if (size <= 0x2100)
14101410      {
14111411         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Invalid ROM image: ROM image is too small");
1412         return INIT_FAIL;
1412         return IMAGE_INIT_FAIL;
14131413      }
14141414
14151415      /* Verify that the image is not too big */
14161416      if (size > 0x1FFFFF)
14171417      {
14181418         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Invalid ROM image: ROM image is too big");
1419         return INIT_FAIL;
1419         return IMAGE_INIT_FAIL;
14201420      }
14211421
14221422      /* Skip the first 0x2100 bytes */
r8323r8324
14261426      if (size != image.fread( memory_region(image.device().machine, "maincpu") + 0x2100, size))
14271427      {
14281428         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Error occured while reading ROM image");
1429         return INIT_FAIL;
1429         return IMAGE_INIT_FAIL;
14301430      }
14311431   }
14321432   else
r8323r8324
14361436      memcpy(memory_region(image.device().machine, "maincpu") + 0x2100, cart_rom + 0x2100, cart_rom_size - 0x2100);
14371437   }
14381438
1439   return INIT_PASS;
1439   return IMAGE_INIT_PASS;
14401440}
14411441
14421442
src/mess/machine/coco.c
r8323r8324
668668   {
669669      if (LOG_PAK)
670670         logerror("Cannot load PAK files without at least 64k.\n");
671      return INIT_FAIL;
671      return IMAGE_INIT_FAIL;
672672   }
673673
674674   if (image.fread( &header, sizeof(header)) < sizeof(header))
675675   {
676676      if (LOG_PAK)
677677         logerror("Could not fully read PAK.\n");
678      return INIT_FAIL;
678      return IMAGE_INIT_FAIL;
679679   }
680680
681681   paklength = header.length ? LITTLE_ENDIANIZE_INT16(header.length) : 0x10000;
r8323r8324
685685   {
686686      if (LOG_PAK)
687687         logerror("Could not fully read PAK.\n");
688      return INIT_FAIL;
688      return IMAGE_INIT_FAIL;
689689   }
690690
691691   trailerlen = image.fread( trailerraw, sizeof(trailerraw));
r8323r8324
695695      {
696696         if (LOG_PAK)
697697            logerror("Invalid or unknown PAK trailer.\n");
698         return INIT_FAIL;
698         return IMAGE_INIT_FAIL;
699699      }
700700
701701      trailer_load = 1;
r8323r8324
705705   {
706706      if (LOG_PAK)
707707         logerror("Unexpected error while reading PAK.\n");
708      return INIT_FAIL;
708      return IMAGE_INIT_FAIL;
709709   }
710710
711711   /* Now that we are done reading the trailer; we can cap the length */
r8323r8324
726726
727727   /* Get the RAM portion */
728728   if (load_pak_into_region(image, &pakstart, &paklength, rambase, 0x0000, 0xff00))
729      return INIT_FAIL;
729      return IMAGE_INIT_FAIL;
730730
731731   memcpy(pakbase, rambase + 0xC000, 0x3F00);
732732
733733   if (trailer_load)
734734      pak_load_trailer(image.device().machine, &trailer);
735   return INIT_PASS;
735   return IMAGE_INIT_PASS;
736736}
737737
738738SNAPSHOT_LOAD ( coco_pak )
r8323r8324
795795         position += block_length;
796796      }
797797   }
798   return INIT_PASS;
798   return IMAGE_INIT_PASS;
799799}
800800
801801/***************************************************************************
r8323r8324
849849      dest += romsize;
850850      destlength -= romsize;
851851   }
852   return INIT_PASS;
852   return IMAGE_INIT_PASS;
853853}
854854
855855DEVICE_IMAGE_UNLOAD(coco_rom)
src/mess/machine/gb.c
r8323r8324
16581658   if ((filesize == 0) || ((filesize % 0x4000) != 0))
16591659   {
16601660      image.seterror(IMAGE_ERROR_UNSPECIFIED, "Invalid rom file size");
1661      return INIT_FAIL;
1661      return IMAGE_INIT_FAIL;
16621662   }
16631663
16641664   /* Claim memory */
r8323r8324
16731673      if (image.fread( gb_driver_data.gb_cart, filesize) != filesize)
16741674      {
16751675         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unable to fully read from file");
1676         return INIT_FAIL;
1676         return IMAGE_INIT_FAIL;
16771677      }
16781678   }
16791679   else
r8323r8324
17731773   if (gb_driver_data.MBCType == MBC_UNKNOWN)
17741774   {
17751775      image.seterror(IMAGE_ERROR_UNSUPPORTED, "Unknown mapper type");
1776      return INIT_FAIL;
1776      return IMAGE_INIT_FAIL;
17771777   }
17781778   if (gb_driver_data.MBCType == MBC_MMM01)
17791779   {
17801780//      image.seterror(IMAGE_ERROR_UNSUPPORTED, "Mapper MMM01 is not supported yet");
1781//      return INIT_FAIL;
1781//      return IMAGE_INIT_FAIL;
17821782   }
17831783   if (gb_driver_data.MBCType == MBC_MBC4)
17841784   {
17851785      image.seterror(IMAGE_ERROR_UNSUPPORTED, "Mapper MBC4 is not supported yet");
1786      return INIT_FAIL;
1786      return IMAGE_INIT_FAIL;
17871787   }
17881788   /* MBC7 support is still work-in-progress, so only enable it for debug builds */
17891789#ifndef MAME_DEBUG
17901790   if (gb_driver_data.MBCType == MBC_MBC7)
17911791   {
17921792      image.seterror(IMAGE_ERROR_UNSUPPORTED, "Mapper MBC7 is not supported yet");
1793      return INIT_FAIL;
1793      return IMAGE_INIT_FAIL;
17941794   }
17951795#endif
17961796
r8323r8324
19441944      image.battery_load(gb_driver_data.gb_cart_ram, gb_driver_data.RAMBanks * 0x2000, 0x00);
19451945   }
19461946
1947   return INIT_PASS;
1947   return IMAGE_INIT_PASS;
19481948}
19491949
19501950INTERRUPT_GEN( gb_scanline_interrupt )
r8323r8324
22292229   if ((filesize == 0) || ((filesize % 0x4000) != 0))
22302230   {
22312231      image.seterror(IMAGE_ERROR_UNSPECIFIED, "Invalid rom file size");
2232      return INIT_FAIL;
2232      return IMAGE_INIT_FAIL;
22332233   }
22342234
22352235   gb_driver_data.ROMBanks = filesize / 0x4000;
r8323r8324
22432243      if (image.fread( gb_driver_data.gb_cart, filesize) != filesize)
22442244      {
22452245         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unable to fully read from file");
2246         return INIT_FAIL;
2246         return IMAGE_INIT_FAIL;
22472247      }
22482248   }
22492249   else
r8323r8324
22732273
22742274   gb_driver_data.MBCType = MBC_MEGADUCK;
22752275
2276   return INIT_PASS;
2276   return IMAGE_INIT_PASS;
22772277}
src/mess/machine/990_hd.c
r8323r8324
249249         d->format = format_mame;    /* don't care */
250250         d->wp = 1;
251251         d->unsafe = 1;
252         return INIT_FAIL;
252         return IMAGE_INIT_FAIL;
253253      }
254254
255255      d->cylinders = get_UINT32BE(custom_header.cylinders);
r8323r8324
264264      d->hd_handle = NULL;
265265      d->wp = 1;
266266      d->unsafe = 1;
267      return INIT_FAIL;
267      return IMAGE_INIT_FAIL;
268268   }
269269
270270   /* tell whether the image is writable */
r8323r8324
274274   /* set attention line */
275275   hdc.w[0] |= (0x80 >> id);
276276
277   return INIT_PASS;
277   return IMAGE_INIT_PASS;
278278}
279279
280280/*
src/mess/machine/gamecom.c
r8323r8324
721721      default:                                       /* otherwise */
722722         logerror("Error loading cartridge: Invalid file size 0x%X\n", filesize);
723723         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unhandled cart size");
724         return INIT_FAIL;
724         return IMAGE_INIT_FAIL;
725725   }
726726
727727   if (image.software_entry() == NULL)
r8323r8324
729729      if (image.fread( cartridge1 + load_offset, filesize) != filesize)
730730      {
731731         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unable to load all of the cart");
732         return INIT_FAIL;
732         return IMAGE_INIT_FAIL;
733733      }
734734   }
735735   else
r8323r8324
741741   if (filesize < 0x080000) { memcpy(cartridge1 + 0x040000, cartridge1, 0x040000); } /* ->512KB */
742742   if (filesize < 0x100000) { memcpy(cartridge1 + 0x080000, cartridge1, 0x080000); } /* ->1MB */
743743   if (filesize < 0x1c0000) { memcpy(cartridge1 + 0x100000, cartridge1, 0x100000); } /* -> >=1.8MB */
744   return INIT_PASS;
744   return IMAGE_INIT_PASS;
745745}
746746
src/mess/machine/smartmed.c
r8323r8324
167167   bytes_read = image.fread(&custom_header, sizeof(custom_header));
168168   if (bytes_read != sizeof(custom_header))
169169   {
170      return INIT_FAIL;
170      return IMAGE_INIT_FAIL;
171171   }
172172
173173   if (custom_header.version > 1)
174174   {
175      return INIT_FAIL;
175      return IMAGE_INIT_FAIL;
176176   }
177177
178178   sm->page_data_size = get_UINT32BE(custom_header.page_data_size);
r8323r8324
205205   }
206206   image.fread(sm->data_ptr, sm->page_total_size*sm->num_pages);
207207
208   return INIT_PASS;
208   return IMAGE_INIT_PASS;
209209}
210210
211211static int detect_geometry( smartmedia_t *sm, UINT8 id1, UINT8 id2)
r8323r8324
245245   bytes_read = image.fread(&custom_header, sizeof(custom_header));
246246   if (bytes_read != sizeof(custom_header))
247247   {
248      return INIT_FAIL;
248      return IMAGE_INIT_FAIL;
249249   }
250250
251251   if (custom_header.data1[0] != 0xEC)
252252   {
253      return INIT_FAIL;
253      return IMAGE_INIT_FAIL;
254254   }
255255
256256   if (!detect_geometry( sm, custom_header.data1[0], custom_header.data1[1]))
257257   {
258      return INIT_FAIL;
258      return IMAGE_INIT_FAIL;
259259   }
260260
261261   sm->data_ptr = auto_alloc_array(device->machine, UINT8, sm->page_total_size*sm->num_pages);
r8323r8324
281281
282282   image.fread(sm->data_ptr, sm->page_total_size*sm->num_pages);
283283
284   return INIT_PASS;
284   return IMAGE_INIT_PASS;
285285}
286286
287287static DEVICE_IMAGE_LOAD( smartmedia )
r8323r8324
291291   // try format 1
292292   position = image.ftell();
293293   result = DEVICE_IMAGE_LOAD_NAME(smartmedia_format_1)(image);
294   if (result != INIT_PASS)
294   if (result != IMAGE_INIT_PASS)
295295   {
296296         // try format 2
297297         image.fseek( position, SEEK_SET);
src/mess/machine/serial.c
r8323r8324
610610   if (serial_device_load_internal(image, &data, &data_length))
611611   {
612612      data_stream_init(&ser->transmit, data, data_length);
613      return INIT_PASS;
613      return IMAGE_INIT_PASS;
614614   }
615615
616   return INIT_FAIL;
616   return IMAGE_INIT_FAIL;
617617}
618618
619619
src/mess/machine/thomson.c
r8323r8324
412412
413413static DEVICE_IMAGE_LOAD( thom_serial )
414414{
415   if ( device_load_serial( image ) != INIT_PASS )
415   if ( device_load_serial( image ) != IMAGE_INIT_PASS )
416416   {
417417      logerror( "thom_serial_load: could not load serial image in device\n");
418      return INIT_FAIL;
418      return IMAGE_INIT_FAIL;
419419   }
420420
421   return INIT_PASS;
421   return IMAGE_INIT_PASS;
422422}
423423
424424DEVICE_GET_INFO( thom_serial_cc90323 )
r8323r8324
499499   else
500500   {
501501      logerror( "to7_cartridge_load: invalid cartridge size %i\n", size );
502      return INIT_FAIL;
502      return IMAGE_INIT_FAIL;
503503   }
504504
505505   if ( image.fread( pos, size ) != size )
506506   {
507507      logerror( "to7_cartridge_load: read error\n" );
508      return INIT_FAIL;
508      return IMAGE_INIT_FAIL;
509509   }
510510
511511   /* extract name */
r8323r8324
523523
524524   PRINT (( "to7_cartridge_load: cartridge \"%s\" banks=%i, size=%i\n", name, thom_cart_nb_banks, size ));
525525
526   return INIT_PASS;
526   return IMAGE_INIT_PASS;
527527}
528528
529529
r8323r8324
20312031   else
20322032   {
20332033      logerror( "mo5_cartridge_load: invalid cartridge size %u\n", (unsigned) size );
2034      return INIT_FAIL;
2034      return IMAGE_INIT_FAIL;
20352035   }
20362036
20372037   if ( image.fread(pos, size ) != size )
20382038   {
20392039      logerror( "mo5_cartridge_load: read error\n" );
2040      return INIT_FAIL;
2040      return IMAGE_INIT_FAIL;
20412041   }
20422042
20432043   /* extract name */
r8323r8324
20552055
20562056   PRINT (( "mo5_cartridge_load: cartridge \"%s\" banks=%i, size=%u\n", name, thom_cart_nb_banks, (unsigned) size ));
20572057
2058   return INIT_PASS;
2058   return IMAGE_INIT_PASS;
20592059}
20602060
20612061
src/mess/machine/tx0.c
r8323r8324
240240      break;
241241   }
242242
243   return INIT_PASS;
243   return IMAGE_INIT_PASS;
244244}
245245
246246DEVICE_IMAGE_UNLOAD( tx0_tape )
r8323r8324
425425   /* open file */
426426   typewriter.fd = &image;
427427
428   return INIT_PASS;
428   return IMAGE_INIT_PASS;
429429}
430430
431431DEVICE_IMAGE_UNLOAD(tx0_typewriter)
r8323r8324
573573         schedule_select();
574574   }
575575
576   return INIT_PASS;
576   return IMAGE_INIT_PASS;
577577}
578578
579579DEVICE_IMAGE_UNLOAD( tx0_magtape )
src/mess/machine/pet.c
r8323r8324
880880      /* Does cart contain any data? */
881881      pet_cbm_cart[0].chip = (UINT8*) image.image_malloc(size);
882882      if (!pet_cbm_cart[0].chip)
883         return INIT_FAIL;
883         return IMAGE_INIT_FAIL;
884884
885885      /* Store data, address & size */
886886      pet_cbm_cart[0].addr = address;
r8323r8324
888888      test = image.fread(pet_cbm_cart[0].chip, pet_cbm_cart[0].size);
889889
890890      if (test != pet_cbm_cart[0].size)
891         return INIT_FAIL;
891         return IMAGE_INIT_FAIL;
892892   }
893893
894894   /* Finally load the cart */
r8323r8324
897897//      memcpy(pet_memory + pet_cbm_cart[i].addr, pet_cbm_cart[i].chip, pet_cbm_cart[i].size);
898898   memcpy(pet_memory + pet_cbm_cart[0].addr, pet_cbm_cart[0].chip, pet_cbm_cart[0].size);
899899
900   return INIT_PASS;
900   return IMAGE_INIT_PASS;
901901}
902902
903903MACHINE_DRIVER_START(pet_cartslot)
src/mess/machine/c16.c
r8323r8324
663663   test = image.fread( mem + address, size);
664664
665665   if (test != size)
666      return INIT_FAIL;
666      return IMAGE_INIT_FAIL;
667667
668   return INIT_PASS;
668   return IMAGE_INIT_PASS;
669669}
670670
671671MACHINE_DRIVER_START( c16_cartslot )
src/mess/machine/mekd2.c
r8323r8324
571571   if (memcmp(buff, magic, sizeof (buff)))
572572   {
573573      logerror( "mekd2_rom_load: magic '%s' not found\n", magic);
574      return INIT_FAIL;
574      return IMAGE_INIT_FAIL;
575575   }
576576   image.fread( &addr, 2);
577577   addr = LITTLE_ENDIANIZE_INT16(addr);
r8323r8324
582582   while (size-- > 0)
583583      image.fread( &RAM[addr++], 1);
584584
585   return INIT_PASS;
585   return IMAGE_INIT_PASS;
586586}
src/mess/machine/a7800.c
r8323r8324
230230
231231   /* Check the cart */
232232   if( a7800_verify_cart((char *)header) == IMAGE_VERIFY_FAIL)
233      return INIT_FAIL;
233      return IMAGE_INIT_FAIL;
234234
235235   len =(header[49] << 24) |(header[50] << 16) |(header[51] << 8) | header[52];
236236   a7800_cart_size = len;
r8323r8324
325325
326326   memcpy( a7800_cart_bkup, memory + 0xC000, 0x4000 );
327327   memcpy( memory + 0xC000, a7800_bios_bkup, 0x4000 );
328   return INIT_PASS;
328   return IMAGE_INIT_PASS;
329329}
330330
331331
src/mess/machine/nascom1.c
r8323r8324
201201   nascom1_tape_size = image.length();
202202   nascom1_tape_image = (UINT8*)image.ptr();
203203   if (!nascom1_tape_image)
204      return INIT_FAIL;
204      return IMAGE_INIT_FAIL;
205205
206206   nascom1_tape_index = 0;
207   return INIT_PASS;
207   return IMAGE_INIT_PASS;
208208}
209209
210210
r8323r8324
246246      }
247247   }
248248
249   return INIT_PASS;
249   return IMAGE_INIT_PASS;
250250}
251251
252252
src/mess/machine/amstrad.c
r8323r8324
34593459
34603460   /* get file size */
34613461   if (snapshot_size < 8)
3462      return INIT_FAIL;
3462      return IMAGE_INIT_FAIL;
34633463
34643464   snapshot = (UINT8 *)malloc(snapshot_size);
34653465   if (!snapshot)
3466      return INIT_FAIL;
3466      return IMAGE_INIT_FAIL;
34673467
34683468   /* read whole file */
34693469   image.fread(snapshot, snapshot_size);
r8323r8324
34713471   if (memcmp(snapshot, "MV - SNA", 8))
34723472   {
34733473      free(snapshot);
3474      return INIT_FAIL;
3474      return IMAGE_INIT_FAIL;
34753475   }
34763476
34773477   amstrad_handle_snapshot(image.device().machine, snapshot);
34783478   free(snapshot);
3479   return INIT_PASS;
3479   return IMAGE_INIT_PASS;
34803480}
34813481
34823482
r8323r8324
35073507      {
35083508         logerror("IMG: failed to read from cart image\n");
35093509         auto_free(image.device().machine, temp_copy);
3510         return INIT_FAIL;
3510         return IMAGE_INIT_FAIL;
35113511      }
35123512   }
35133513   else
r8323r8324
35363536         {
35373537            logerror("BIN: block %i loaded is smaller than 16kB in size\n", offset / 0x4000);
35383538            auto_free(image.device().machine, temp_copy);
3539            return INIT_FAIL;
3539            return IMAGE_INIT_FAIL;
35403540         }
35413541         offset += 0x4000;
35423542      }
r8323r8324
35483548      {
35493549         logerror("CPR: not an Amstrad CPC cartridge image\n");
35503550         auto_free(image.device().machine, temp_copy);
3551         return INIT_FAIL;
3551         return IMAGE_INIT_FAIL;
35523552      }
35533553
35543554      bytes_to_read = header[4] + (header[5] << 8) + (header[6] << 16)+ (header[7] << 24);
r8323r8324
36063606   {
36073607      logerror("Gamelist cart in RIFF format\n");
36083608      auto_free(image.device().machine, temp_copy);
3609      return INIT_FAIL;
3609      return IMAGE_INIT_FAIL;
36103610   }
36113611
36123612   auto_free(image.device().machine, temp_copy);
3613   return INIT_PASS;
3613   return IMAGE_INIT_PASS;
36143614}
36153615
36163616
36173617#if 0
36183618static DEVICE_IMAGE_LOAD( aleste )
36193619{
3620    if (device_load_basicdsk_floppy(image)==INIT_PASS)
3620    if (device_load_basicdsk_floppy(image)==IMAGE_INIT_PASS)
36213621    {
36223622        basicdsk_set_geometry(image, 80, 2, 9, 512, 0x01, 0, FALSE);
3623        return INIT_PASS;
3623        return IMAGE_INIT_PASS;
36243624    }
3625    return INIT_FAIL;
3625    return IMAGE_INIT_FAIL;
36263626}
36273627#endif
src/mess/machine/sms.c
r8323r8324
12521252   if (!size)
12531253   {
12541254      image.seterror(IMAGE_ERROR_UNSPECIFIED, "Invalid ROM image: ROM image is too small");
1255      return INIT_FAIL;
1255      return IMAGE_INIT_FAIL;
12561256   }
12571257
12581258   /* Create a new memory region to hold the ROM. */
r8323r8324
12671267      image.fseek(offset, SEEK_SET);
12681268
12691269      if (image.fread( sms_state.cartridge[index].ROM, size) != size)
1270         return INIT_FAIL;
1270         return IMAGE_INIT_FAIL;
12711271   }
12721272   else
12731273      memcpy(sms_state.cartridge[index].ROM, image.get_software_region("rom") + offset, size);
r8323r8324
13571357   /* Load battery backed RAM, if available */
13581358   image.battery_load(sms_state.cartridge[index].cartSRAM, sizeof(UINT8) * NVRAM_SIZE, 0x00);
13591359
1360   return INIT_PASS;
1360   return IMAGE_INIT_PASS;
13611361}
13621362
13631363
src/mess/machine/poly88.c
r8323r8324
330330      pos+=recordLen;
331331   }
332332   devtag_get_device(image.device().machine, "uart")->reset();
333   return INIT_PASS;
333   return IMAGE_INIT_PASS;
334334}
src/mess/machine/z1013.c
r8323r8324
8484   startaddr = data[0] + data[1]*256;
8585   endaddr   = data[2] + data[3]*256;
8686   runaddr   = data[4] + data[5]*256;
87   if (data[12]!='C') return INIT_FAIL;
88   if (data[13]!=0xD3 || data[14]!=0xD3 || data[14]!=0xD3) return INIT_FAIL;
87   if (data[12]!='C') return IMAGE_INIT_FAIL;
88   if (data[13]!=0xD3 || data[14]!=0xD3 || data[14]!=0xD3) return IMAGE_INIT_FAIL;
8989
9090   memcpy (memory_get_read_ptr(cputag_get_address_space(image.device().machine, "maincpu", ADDRESS_SPACE_PROGRAM),  startaddr ),
9191       data+0x20, endaddr - startaddr + 1);
9292
9393   cpu_set_reg(devtag_get_device(image.device().machine, "maincpu"), Z80_PC, runaddr);
9494
95   return INIT_PASS;
95   return IMAGE_INIT_PASS;
9696}
9797
src/mess/machine/primo.c
r8323r8324
309309   UINT8 *snapshot_data;
310310
311311   if (!(snapshot_data = (UINT8*) malloc(snapshot_size)))
312      return INIT_FAIL;
312      return IMAGE_INIT_FAIL;
313313
314314   if (image.fread( snapshot_data, snapshot_size) != snapshot_size)
315315   {
316316      free(snapshot_data);
317      return INIT_FAIL;
317      return IMAGE_INIT_FAIL;
318318   }
319319
320320   if (strncmp((char *)snapshot_data, "PS01", 4))
321321   {
322322      free(snapshot_data);
323      return INIT_FAIL;
323      return IMAGE_INIT_FAIL;
324324   }
325325
326326   primo_setup_pss(image.device().machine,snapshot_data, snapshot_size);
327327
328328   free(snapshot_data);
329   return INIT_PASS;
329   return IMAGE_INIT_PASS;
330330}
331331
332332/*******************************************************************************
r8323r8324
359359   UINT8 *quickload_data;
360360
361361   if (!(quickload_data = (UINT8*) malloc(quickload_size)))
362      return INIT_FAIL;
362      return IMAGE_INIT_FAIL;
363363
364364   if (image.fread( quickload_data, quickload_size) != quickload_size)
365365   {
366366      free(quickload_data);
367      return INIT_FAIL;
367      return IMAGE_INIT_FAIL;
368368   }
369369
370370   primo_setup_pp(image.device().machine, quickload_data, quickload_size);
371371
372372   free(quickload_data);
373   return INIT_PASS;
373   return IMAGE_INIT_PASS;
374374}
src/mess/machine/ti85.c
r8323r8324
976976   if (snapshot_size != expected_snapshot_size)
977977   {
978978      logerror ("Incomplete snapshot file\n");
979      return INIT_FAIL;
979      return IMAGE_INIT_FAIL;
980980   }
981981
982982   if (!(ti8x_snapshot_data = (UINT8*)malloc(snapshot_size)))
983      return INIT_FAIL;
983      return IMAGE_INIT_FAIL;
984984
985985   image.fread( ti8x_snapshot_data, snapshot_size);
986986
r8323r8324
990990      case TI_86: ti86_setup_snapshot(image.device().machine, ti8x_snapshot_data); break;
991991   }
992992   free(ti8x_snapshot_data);
993   return INIT_PASS;
993   return IMAGE_INIT_PASS;
994994}
995995
996996
src/mess/machine/svi318.c
r8323r8324
119119
120120   p = (UINT8*)image.image_malloc(size);
121121   if (!p)
122      return INIT_FAIL;
122      return IMAGE_INIT_FAIL;
123123
124124   pcart_rom_size = size;
125125   memset(p, 0xff, size);
r8323r8324
128128   if (image.fread( p, size) != size)
129129   {
130130      logerror ("can't read file %s\n", image.filename() );
131      return INIT_FAIL;
131      return IMAGE_INIT_FAIL;
132132   }
133133
134134   if (svi318_verify_cart(p)==IMAGE_VERIFY_FAIL)
135      return INIT_FAIL;
135      return IMAGE_INIT_FAIL;
136136   pcart = p;
137137
138   return INIT_PASS;
138   return IMAGE_INIT_PASS;
139139}
140140
141141DEVICE_IMAGE_UNLOAD( svi318_cart )
src/mess/machine/galaxy.c
r8323r8324
140140         snapshot_data = auto_alloc_array(image.device().machine, UINT8, snapshot_size);
141141         break;
142142      default:
143         return INIT_FAIL;
143         return IMAGE_INIT_FAIL;
144144   }
145145
146146   image.fread( snapshot_data, snapshot_size);
147147
148148   galaxy_setup_snapshot(image.device().machine, snapshot_data, snapshot_size);
149149
150   return INIT_PASS;
150   return IMAGE_INIT_PASS;
151151}
152152
153153
src/mess/machine/994x_ser.c
r8323r8324
9494   else
9595      pio->pio_handshakein = 1;
9696
97   return INIT_PASS;
97   return IMAGE_INIT_PASS;
9898}
9999
100100/*
r8323r8324
149149      tms9902_set_dsr(tms9902, 0);
150150   }
151151
152   return INIT_PASS;
152   return IMAGE_INIT_PASS;
153153}
154154
155155/*
src/mess/machine/vtech2.c
r8323r8324
351351   if( size > 0xc000 )
352352      laser_bank_mask |= 0x8000;
353353
354   return size > 0 ? INIT_PASS : INIT_FAIL;
354   return size > 0 ? IMAGE_INIT_PASS : IMAGE_INIT_FAIL;
355355}
356356
357357DEVICE_IMAGE_UNLOAD( laser_cart )
src/mess/machine/wswan.c
r8323r8324
13951395            if (image.fread( ROMMap[ii], 0x10000) != 0x10000)
13961396            {
13971397               logerror("Error while reading loading rom!\n");
1398               return INIT_FAIL;
1398               return IMAGE_INIT_FAIL;
13991399            }
14001400         }
14011401         else
r8323r8324
14041404      else
14051405      {
14061406         logerror("Memory allocation failed reading rom!\n");
1407         return INIT_FAIL;
1407         return IMAGE_INIT_FAIL;
14081408      }
14091409   }
14101410
r8323r8324
14521452   }
14531453
14541454   /* All done */
1455   return INIT_PASS;
1455   return IMAGE_INIT_PASS;
14561456}
14571457
14581458static TIMER_CALLBACK(wswan_scanline_interrupt)
src/mess/machine/x68k_hdc.c
r8323r8324
6767   {
6868      ret = image.fwrite(sectordata,256);
6969      if(ret < 256)
70         return INIT_FAIL;
70         return IMAGE_INIT_FAIL;
7171   }
7272
73   return INIT_PASS;
73   return IMAGE_INIT_PASS;
7474}
7575
7676WRITE16_DEVICE_HANDLER( x68k_hdc_w )
src/mess/machine/nc.c
r8323r8324
114114         {
115115            nc_set_card_present_state(1);
116116         }
117         return INIT_PASS;
117         return IMAGE_INIT_PASS;
118118      }
119119   }
120120
121121   /* nc100 can run without a image */
122   return INIT_FAIL;
122   return IMAGE_INIT_FAIL;
123123}
124124
125125DEVICE_IMAGE_UNLOAD( nc_pcmcia_card )
src/mess/machine/990_tap.c
r8323r8324
162162
163163   t->bot = 1;
164164
165   return INIT_PASS;
165   return IMAGE_INIT_PASS;
166166}
167167
168168/*
src/mess/machine/nes.c
r8323r8324
851851         if (size <= 0x20)
852852         {
853853            logerror("%s only contains the UNIF header and no data.\n", image.filename());
854            return INIT_FAIL;
854            return IMAGE_INIT_FAIL;
855855         }
856856
857857         do
r8323r8324
11201120      else
11211121      {
11221122         logerror("%s is NOT a file in either iNES or UNIF format.\n", image.filename());
1123         return INIT_FAIL;
1123         return IMAGE_INIT_FAIL;
11241124      }
11251125   }
11261126   else
r8323r8324
13121312      auto_free(image.device().machine, temp_nvram);
13131313   }
13141314
1315   return INIT_PASS;
1315   return IMAGE_INIT_PASS;
13161316}
13171317
13181318
src/mess/machine/msx.c
r8323r8324
103103
104104   if( id == -1 ) {
105105      //logerror ("error: invalid cart tag '%s'\n", image->tag);
106      return INIT_FAIL;
106      return IMAGE_INIT_FAIL;
107107   }
108108
109109   size = image.length ();
110110   if (size < 0x2000) {
111111      logerror ("cart #%d: error: file is smaller than 2kb, too small "
112112              "to be true!\n", id);
113      return INIT_FAIL;
113      return IMAGE_INIT_FAIL;
114114   }
115115
116116   /* allocate memory and load */
r8323r8324
122122   if (!mem) {
123123      logerror ("cart #%d: error: failed to allocate memory for cartridge\n",
124124                  id);
125      return INIT_FAIL;
125      return IMAGE_INIT_FAIL;
126126   }
127127   if (size < size_aligned) {
128128      memset (mem, 0xff, size_aligned);
r8323r8324
130130   if (image.fread(mem, size) != size) {
131131      logerror ("cart #%d: %s: can't read full %d bytes\n",
132132                  id, image.filename (), size);
133      return INIT_FAIL;
133      return IMAGE_INIT_FAIL;
134134   }
135135
136136   /* see if msx.crc will tell us more */
r8323r8324
169169      mem = (UINT8*)image.image_realloc(mem, 0x10000);
170170      if (!mem) {
171171         logerror ("cart #%d: error: cannot allocate memory\n", id);
172         return INIT_FAIL;
172         return IMAGE_INIT_FAIL;
173173      }
174174
175175      if (size < 0x10000) {
r8323r8324
245245   {
246246      logerror ("cart #%d: error: cannot allocate memory for "
247247              "cartridge state\n", id);
248      return INIT_FAIL;
248      return IMAGE_INIT_FAIL;
249249   }
250250   memset (state, 0, sizeof (slot_state));
251251
r8323r8324
264264   }
265265
266266   if (msx_slot_list[type].init (image.device().machine, state, 0, mem, size_aligned)) {
267      return INIT_FAIL;
267      return IMAGE_INIT_FAIL;
268268   }
269269   if (msx_slot_list[type].loadsram) {
270270      msx_slot_list[type].loadsram (state);
r8323r8324
273273   msx1.cart_state[id] = cart_state[id] = state;
274274   msx_memory_set_carts ();
275275
276   return INIT_PASS;
276   return IMAGE_INIT_PASS;
277277}
278278
279279DEVICE_IMAGE_UNLOAD (msx_cart)
src/mess/machine/vectrex.c
r8323r8324
8484   if (vectrex_verify_cart((char*)mem) == IMAGE_VERIFY_FAIL)
8585   {
8686      logerror("Invalid image!\n");
87      return INIT_FAIL;
87      return IMAGE_INIT_FAIL;
8888   }
8989
9090   /* If VIA T2 starts, reset refresh timer.
r8323r8324
116116      vectrex_reset_refresh = 0;
117117   }
118118
119   return INIT_PASS;
119   return IMAGE_INIT_PASS;
120120}
121121
122122
src/mess/machine/lynx.c
r8323r8324
19631963      if (!mame_stricmp (filetype, "lnx"))
19641964      {
19651965         if (image.fread( header, 0x40) != 0x40)
1966            return INIT_FAIL;
1966            return IMAGE_INIT_FAIL;
19671967
19681968         /* Check the image */
19691969         if (lynx_verify_cart((char*)header, LYNX_CART) == IMAGE_VERIFY_FAIL)
1970            return INIT_FAIL;
1970            return IMAGE_INIT_FAIL;
19711971
19721972         /* 2008-10 FP: According to Handy source these should be page_size_bank0. Are we using
19731973            it correctly in MESS? Moreover, the next two values should be page_size_bank1. We should
r8323r8324
19931993      }
19941994
19951995      if (image.fread( rom, size) != size)
1996         return INIT_FAIL;
1996         return IMAGE_INIT_FAIL;
19971997
19981998      lynx_crc_keyword(image);
19991999   }
r8323r8324
20072007
20082008      /* Check the image */
20092009      if (lynx_verify_cart((char*)header, LYNX_CART) == IMAGE_VERIFY_FAIL)
2010         return INIT_FAIL;
2010         return IMAGE_INIT_FAIL;
20112011
20122012      /* 2008-10 FP: According to Handy source these should be page_size_bank0. Are we using
20132013         it correctly in MESS? Moreover, the next two values should be page_size_bank1. We should
r8323r8324
20212021      memcpy(rom, image.get_software_region("rom") + 0x40, size);
20222022   }
20232023
2024   return INIT_PASS;
2024   return IMAGE_INIT_PASS;
20252025}
20262026
20272027MACHINE_DRIVER_START(lynx_cartslot)
src/mess/machine/kaypro.c
r8323r8324
406406   /* Load image to the TPA (Transient Program Area) */
407407   for (i = 0; i < quickload_size; i++)
408408   {
409      if (image.fread( &data, 1) != 1) return INIT_FAIL;
409      if (image.fread( &data, 1) != 1) return IMAGE_INIT_FAIL;
410410
411411      RAM[i+0x100] = data;
412412   }
r8323r8324
419419      cpu_set_reg(cpu, STATE_GENPC, 0x100);            // start program
420420   }
421421
422   return INIT_PASS;
422   return IMAGE_INIT_PASS;
423423}
424424
425425QUICKLOAD_LOAD( kaypro2x )
r8323r8324
432432
433433   for (i = 0; i < quickload_size; i++)
434434   {
435      if (image.fread( &data, 1) != 1) return INIT_FAIL;
435      if (image.fread( &data, 1) != 1) return IMAGE_INIT_FAIL;
436436
437437      RAM[i+0x100] = data;
438438   }
r8323r8324
445445      cpu_set_reg(cpu, STATE_GENPC, 0x100);
446446   }
447447
448   return INIT_PASS;
448   return IMAGE_INIT_PASS;
449449}
src/mess/machine/lviv.c
r8323r8324
333333   if (!lviv_snapshot_data)
334334   {
335335      logerror ("Unable to load snapshot file\n");
336      return INIT_FAIL;
336      return IMAGE_INIT_FAIL;
337337   }
338338
339339   image.fread( lviv_snapshot_data, LVIV_SNAPSHOT_SIZE);
r8323r8324
341341   if( lviv_verify_snapshot(lviv_snapshot_data, snapshot_size) == IMAGE_VERIFY_FAIL)
342342   {
343343      free(lviv_snapshot_data);
344      return INIT_FAIL;
344      return IMAGE_INIT_FAIL;
345345   }
346346
347347   lviv_setup_snapshot (image.device().machine,lviv_snapshot_data);
r8323r8324
351351   free(lviv_snapshot_data);
352352
353353   logerror("Snapshot file loaded\n");
354   return INIT_PASS;
354   return IMAGE_INIT_PASS;
355355}
356356
src/mess/machine/exidy.c
r8323r8324
410410   {
411411      image.seterror(IMAGE_ERROR_INVALIDIMAGE, "Snapshot must be 65564 bytes");
412412      image.message("Snapshot must be 65564 bytes");
413      return INIT_FAIL;
413      return IMAGE_INIT_FAIL;
414414   }
415415
416416   /* get the header */
r8323r8324
438438   cpu_set_reg(cpu, Z80_IM, header[25]);
439439   cpu_set_reg(cpu, STATE_GENPC, header[26] | (header[27] << 8));
440440
441   return INIT_PASS;
441   return IMAGE_INIT_PASS;
442442}
443443
444444MACHINE_START( exidy )
src/mess/machine/apple1.c
r8323r8324
225225
226226   /* Read the snapshot data into a temporary array */
227227   if (filesize < SNAP_HEADER_LEN)
228      return INIT_FAIL;
228      return IMAGE_INIT_FAIL;
229229   snapbuf = (UINT8*)image.ptr();
230230   if (!snapbuf)
231      return INIT_FAIL;
231      return IMAGE_INIT_FAIL;
232232
233233   /* Verify the snapshot header */
234234   if (apple1_verify_header(snapbuf) == IMAGE_VERIFY_FAIL)
235235   {
236236      logerror("apple1 - Snapshot Header is in incorrect format - needs to be LOAD:xxyyDATA:\n");
237      return INIT_FAIL;
237      return IMAGE_INIT_FAIL;
238238   }
239239
240240   datasize = filesize - SNAP_HEADER_LEN;
r8323r8324
250250   {
251251      logerror("apple1 - Snapshot won't fit in this memory configuration;\n"
252252            "needs memory from $%04X to $%04X.\n", start_addr, end_addr);
253      return INIT_FAIL;
253      return IMAGE_INIT_FAIL;
254254   }
255255
256256   /* Copy the data into memory space. */
r8323r8324
259259       addr++, snapptr++)
260260      memory_write_byte(cputag_get_address_space(image.device().machine, "maincpu", ADDRESS_SPACE_PROGRAM), addr, *snapptr);
261261
262   return INIT_PASS;
262   return IMAGE_INIT_PASS;
263263}
264264
265265
src/mess/machine/mtx.c
r8323r8324
390390      image.fread( ptr, snapshot_size - 599 - 4);
391391   }
392392
393   return INIT_PASS;
393   return IMAGE_INIT_PASS;
394394}
395395
396396/***************************************************************************
src/mess/machine/intv.c
r8323r8324
342342      image.fread( &temp, 1);         /* header */
343343      if (temp != 0xa8)
344344      {
345         return INIT_FAIL;
345         return IMAGE_INIT_FAIL;
346346      }
347347
348348      image.fread( &num_segments, 1);
r8323r8324
350350      image.fread( &temp, 1);
351351      if (temp != (num_segments ^ 0xff))
352352      {
353         return INIT_FAIL;
353         return IMAGE_INIT_FAIL;
354354      }
355355
356356      for (i = 0; i < num_segments; i++)
r8323r8324
380380      {
381381         image.fread( &temp, 1);
382382      }
383      return INIT_PASS;
383      return IMAGE_INIT_PASS;
384384   }
385385   /* otherwise, we load it as a .bin file, using extrainfo from intv.hsi in place of .cfg */
386386   else
r8323r8324
459459         }
460460      }
461461
462      return INIT_PASS;
462      return IMAGE_INIT_PASS;
463463   }
464464}
465465
r8323r8324
572572      image.fread( &memory[0xe000], 0x2000);
573573   }
574574
575   return INIT_PASS;
575   return IMAGE_INIT_PASS;
576576
577577}
src/mess/machine/snescart.c
r8323r8324
879879         {
880880            logerror("This image has been identified as ExHiROM, but it's too small!\n");
881881            logerror("Please verify if it's corrupted. If it's not please report this as a bug.\n");
882            return INIT_FAIL;
882            return IMAGE_INIT_FAIL;
883883         }
884884         /* Scaling down the counter */
885885         read_blocks -= 64;
r8323r8324
943943         {
944944            printf("This is a Sufami Turbo data cart and cannot be loaded for snes/snespal in MESS.\n");
945945            printf("Please use snesst driver to load it, instead.\n");
946            return INIT_FAIL;
946            return IMAGE_INIT_FAIL;
947947         }
948948         else
949949         {
r8323r8324
977977         {
978978            printf("This is a BS-X flash cart and cannot be loaded in snes/snespal.\n");
979979//            printf("Please use snesbsx driver to load it, instead.\n");
980            return INIT_FAIL;
980            return IMAGE_INIT_FAIL;
981981         }
982982#endif
983983         break;
r8323r8324
10071007            {
10081008               logerror("This image has been identified as a SuperFX game, but it's too large!\n");
10091009               logerror("Please verify if it's corrupted. If it's not please report this as a bug.\n");
1010               return INIT_FAIL;
1010               return IMAGE_INIT_FAIL;
10111011            }
10121012         }
10131013         else
r8323r8324
10651065   snes_load_sram(machine);
10661066
10671067   /* All done */
1068   return INIT_PASS;
1068   return IMAGE_INIT_PASS;
10691069}
10701070
10711071static DEVICE_IMAGE_LOAD( sufami_cart )
r8323r8324
11201120   {
11211121      printf("This is not a Sufami Turbo data pack.\n");
11221122      printf("This image cannot be loaded in snesst (Use snes or snespal drivers, instead).\n");
1123      return INIT_FAIL;
1123      return IMAGE_INIT_FAIL;
11241124   }
11251125   
11261126   if (st_bios == 1)
11271127   {
11281128      printf("This is the Sufami Turbo BIOS and not a Sufami Turbo data pack.\n");
11291129      printf("This image cannot be loaded in snesst.\n");
1130      return INIT_FAIL;
1130      return IMAGE_INIT_FAIL;
11311131   }
11321132
11331133   /* FIXME: Insert crc check here? */
r8323r8324
11701170
11711171   auto_free(image.device().machine, ROM);
11721172   
1173   return INIT_PASS;
1173   return IMAGE_INIT_PASS;
11741174}
11751175
11761176static DEVICE_IMAGE_LOAD( bsx_cart )
r8323r8324
12361236   {
12371237      printf("This is not a BS-X compatible cart.\n");
12381238      printf("This image cannot be loaded in the first cartslot of snesbsx.\n");
1239      return INIT_FAIL;
1239      return IMAGE_INIT_FAIL;
12401240   }
12411241   
12421242
r8323r8324
12721272      read_blocks += repeat_blocks;
12731273   }
12741274
1275   return INIT_PASS;
1275   return IMAGE_INIT_PASS;
12761276}
12771277
12781278static DEVICE_IMAGE_LOAD( bsx2slot_cart )
r8323r8324
13221322   {
13231323      printf("This is not a BS-X flash cart.\n");
13241324      printf("This image cannot be loaded in the second cartslot of snesbsx.\n");
1325      return INIT_FAIL;
1325      return IMAGE_INIT_FAIL;
13261326   }
13271327     
13281328   // actually load the cart
1329   return INIT_PASS;
1329   return IMAGE_INIT_PASS;
13301330}
13311331
13321332MACHINE_DRIVER_START( snes_cartslot )
src/mess/machine/c64.c
r8323r8324
10441044      ;
10451045
10461046      if (i >= ARRAY_LENGTH(c64_cbm_cart))
1047         return INIT_FAIL;
1047         return IMAGE_INIT_FAIL;
10481048
10491049      /* Start to parse the .crt header */
10501050      /* 0x16-0x17 is Hardware type */
r8323r8324
11421142         /* Does CHIP contain any data? */
11431143         c64_cbm_cart[i].chip = (UINT8*) image.image_malloc(chip_data_size);
11441144         if (!c64_cbm_cart[i].chip)
1145            return INIT_FAIL;
1145            return IMAGE_INIT_FAIL;
11461146
11471147         /* Store data, address & size of the CHIP block */
11481148         c64_cbm_cart[i].addr = address;
r8323r8324
11561156         new_start += c64_cbm_cart[i].size;
11571157
11581158         if (test != chip_data_size)
1159            return INIT_FAIL;
1159            return IMAGE_INIT_FAIL;
11601160
11611161         /* Advance to the next CHIP block */
11621162         i++;
r8323r8324
11801180      /* Does cart contain any data? */
11811181      c64_cbm_cart[0].chip = (UINT8*) image.image_malloc(size);
11821182      if (!c64_cbm_cart[0].chip)
1183         return INIT_FAIL;
1183         return IMAGE_INIT_FAIL;
11841184
11851185      /* Store data, address & size */
11861186      c64_cbm_cart[0].addr = address;
r8323r8324
11931193      new_start += c64_cbm_cart[0].size;
11941194
11951195      if (test != c64_cbm_cart[0].size)
1196         return INIT_FAIL;
1196         return IMAGE_INIT_FAIL;
11971197   }
11981198
11991199   n_banks = i;
r8323r8324
12291229
12301230   c64_cart_n_banks = n_banks; // this is needed so that we only set mappers if a cart is present!
12311231
1232   return INIT_PASS;
1232   return IMAGE_INIT_PASS;
12331233}
12341234
12351235static DEVICE_IMAGE_LOAD( c64_cart )
r8323r8324
12391239
12401240static DEVICE_IMAGE_LOAD( max_cart )
12411241{
1242   int result = INIT_PASS;
1242   int result = IMAGE_INIT_PASS;
12431243
12441244   if (image.software_entry() == NULL)
12451245   {
src/mess/machine/genesis.c
r8323r8324
10531053      if (!tmpROMnew)
10541054      {
10551055         logerror("Memory allocation failed reading roms!\n");
1056         return INIT_FAIL;
1056         return IMAGE_INIT_FAIL;
10571057      }
10581058
10591059      memcpy(tmpROMnew, ROM + 0x2000, length);
r8323r8324
12821282   if (sram_detected)
12831283      logerror("SRAM detected from header: starting location %X - SRAM Length %X\n", genesis_sram_start, genesis_sram_end - genesis_sram_start + 1);
12841284
1285   return INIT_PASS;
1285   return IMAGE_INIT_PASS;
12861286}
12871287
12881288/******* Image unloading (with SRAM saving) *******/
r8323r8324
13391339
13401340   auto_free(image.device().machine, temp_copy);
13411341
1342   return INIT_PASS;
1342   return IMAGE_INIT_PASS;
13431343}
13441344
13451345/******* Cart getinfo *******/
src/mess/machine/pc.c
r8323r8324
14141414         break;
14151415      default:
14161416         image.seterror(IMAGE_ERROR_UNSUPPORTED, "Invalid rom file size" );
1417         return INIT_FAIL;
1417         return IMAGE_INIT_FAIL;
14181418      }
14191419
14201420      /* Read and verify the header */
14211421      if ( 512 != image.fread( header, 512 ) )
14221422      {
14231423         image.seterror(IMAGE_ERROR_UNSUPPORTED, "Unable to read header" );
1424         return INIT_FAIL;
1424         return IMAGE_INIT_FAIL;
14251425      }
14261426
14271427      /* Read the cartridge contents */
14281428      if ( ( size - 0x200 ) != image.fread(memory_region(image.device().machine, "maincpu") + address, size - 0x200 ) )
14291429      {
14301430         image.seterror(IMAGE_ERROR_UNSUPPORTED, "Unable to read cartridge contents" );
1431         return INIT_FAIL;
1431         return IMAGE_INIT_FAIL;
14321432      }
14331433   }
14341434
1435   return INIT_PASS;
1435   return IMAGE_INIT_PASS;
14361436}
14371437
14381438
src/mess/machine/kc.c
r8323r8324
105105   int i;
106106
107107   if (!kc_load(image, &data))
108      return INIT_FAIL;
108      return IMAGE_INIT_FAIL;
109109
110110   header = (struct kcc_header *) data;
111111   datasize = (header->length_l & 0x0ff) | ((header->length_h & 0x0ff)<<8);
r8323r8324
114114
115115   for (i=0; i<datasize; i++)
116116      messram_get_ptr(devtag_get_device(image.device().machine, "messram"))[(addr+i) & 0x0ffff] = data[i+128];
117   return INIT_PASS;
117   return IMAGE_INIT_PASS;
118118}
119119
120120
src/mess/formats/atom_atm.c
r8323r8324
7272
7373   cpu_set_reg(image.device().machine->firstcpu, STATE_GENPC, run_address);
7474
75   return INIT_PASS;
75   return IMAGE_INIT_PASS;
7676}
src/mess/formats/m65_snqk.c
r8323r8324
115115        logerror("parse_intel_hex: registers (?) at %04X\n", last_addr);
116116        memcpy(&snapshot_buff[8192+64], &snapshot_buff[last_addr], last_size);
117117    }
118    return INIT_PASS;
118    return IMAGE_INIT_PASS;
119119}
120120
121121static int parse_zillion_hex(UINT8 *snapshot_buff, char *src)
r8323r8324
198198        }
199199        src++;
200200    }
201    return INIT_PASS;
201    return IMAGE_INIT_PASS;
202202}
203203
204204static void microtan_set_cpu_regs(running_machine *machine,const UINT8 *snapshot_buff, int base)
r8323r8324
323323
324324    snapshot_buff = (UINT8*)image.ptr();
325325    if (!snapshot_buff)
326        return INIT_FAIL;
326        return IMAGE_INIT_FAIL;
327327
328328    if (microtan_verify_snapshot(snapshot_buff, snapshot_size)==IMAGE_VERIFY_FAIL)
329        return INIT_FAIL;
329        return IMAGE_INIT_FAIL;
330330
331331    microtan_snapshot_copy(image.device().machine, snapshot_buff, snapshot_size);
332    return INIT_PASS;
332    return IMAGE_INIT_PASS;
333333}
334334
335335QUICKLOAD_LOAD( microtan )
r8323r8324
344344    if (!snapshot_buff)
345345    {
346346        logerror("microtan_hexfile_load: could not allocate %d bytes of buffer\n", snapshot_size);
347        return INIT_FAIL;
347        return IMAGE_INIT_FAIL;
348348    }
349349    memset(snapshot_buff, 0, snapshot_size);
350350
r8323r8324
353353    {
354354        free(snapshot_buff);
355355        logerror("microtan_hexfile_load: could not allocate %d bytes of buffer\n", quickload_size);
356        return INIT_FAIL;
356        return IMAGE_INIT_FAIL;
357357    }
358358    image.fread( buff, quickload_size);
359359
r8323r8324
363363        rc = parse_intel_hex(snapshot_buff, buff);
364364    else
365365        rc = parse_zillion_hex(snapshot_buff, buff);
366    if (rc == INIT_PASS)
366    if (rc == IMAGE_INIT_PASS)
367367        microtan_snapshot_copy(image.device().machine, snapshot_buff, snapshot_size);
368368    free(snapshot_buff);
369369    return rc;
src/mess/formats/cbm_snqk.c
r8323r8324
6868
6969   cbm_sethiaddress(image.device().machine, address + snapshot_size);
7070   free(data);
71   return INIT_PASS;
71   return IMAGE_INIT_PASS;
7272
7373error:
7474   if (data)
7575      free(data);
76   return INIT_FAIL;
76   return IMAGE_INIT_FAIL;
7777}
7878
7979static void cbm_quick_sethiaddress( running_machine *machine, UINT16 hiaddress )
src/mess/formats/spec_snqk.c
r8323r8324
203203
204204    free(snapshot_data);
205205
206    return INIT_PASS;
206    return IMAGE_INIT_PASS;
207207
208208error:
209209    if (snapshot_data)
210210        free(snapshot_data);
211    return INIT_FAIL;
211    return IMAGE_INIT_FAIL;
212212}
213213
214214/*******************************************************************
r8323r8324
24672467
24682468    free(quickload_data);
24692469
2470    return INIT_PASS;
2470    return IMAGE_INIT_PASS;
24712471
24722472error:
24732473    if (quickload_data)
24742474        free(quickload_data);
2475    return INIT_FAIL;
2475    return IMAGE_INIT_FAIL;
24762476}
24772477
24782478/*******************************************************************
src/mess/formats/ti85_ser.c
r8323r8324
12991299   UINT8* file_data;
13001300   UINT16 file_size;
13011301
1302   if (ti85serial->status != TI85_SEND_STOP) return INIT_FAIL;
1302   if (ti85serial->status != TI85_SEND_STOP) return IMAGE_INIT_FAIL;
13031303
13041304   file_size = image.length();
13051305
r8323r8324
13111311      if(!ti85_convert_file_data_to_serial_stream(image, file_data, file_size, &ti85serial->stream))
13121312      {
13131313         ti85_free_serial_stream (&ti85serial->stream);
1314         return INIT_FAIL;
1314         return IMAGE_INIT_FAIL;
13151315      }
13161316
13171317      ti85serial->status = TI85_SEND_HEADER;
13181318   }
13191319   else
13201320   {
1321      return INIT_FAIL;
1321      return IMAGE_INIT_FAIL;
13221322   }
1323   return INIT_PASS;
1323   return IMAGE_INIT_PASS;
13241324}
13251325
13261326
src/mess/formats/comx35_comx.c
r8323r8324
5555
5656   if (size > messram_get_size(devtag_get_device(image.device().machine, "messram")))
5757   {
58      return INIT_FAIL;
58      return IMAGE_INIT_FAIL;
5959   }
6060
6161   image.fread( header, 5);
6262
6363   if (header[1] != 'C' || header[2] != 'O' || header[3] != 'M' || header[4] != 'X' )
6464   {
65      return INIT_FAIL;
65      return IMAGE_INIT_FAIL;
6666   }
6767
6868   switch (header[0])
r8323r8324
189189      break;
190190   }
191191
192   return INIT_PASS;
192   return IMAGE_INIT_PASS;
193193}
src/mess/formats/timex_dck.c
r8323r8324
5252//   if (file_size < 0x09)
5353//   {
5454//      logerror ("Bad file size\n");
55//      return INIT_FAIL;
55//      return IMAGE_INIT_FAIL;
5656//   }
5757//
5858//   file_data = (UINT8 *)malloc(file_size);
5959//   if (file_data == NULL)
6060//   {
6161//      logerror ("Memory allocating error\n");
62//      return INIT_FAIL;
62//      return IMAGE_INIT_FAIL;
6363//   }
6464//
6565//   image_fread(image, file_data, file_size);
r8323r8324
7171//   {
7272//      free (file_data);
7373//      logerror ("File corrupted\n");
74//      return INIT_FAIL;
74//      return IMAGE_INIT_FAIL;
7575//   }
7676//
7777//   switch (file_data[0x00])
r8323r8324
8383//            {
8484//               free (file_data);
8585//               logerror ("Memory allocate error\n");
86//               return INIT_FAIL;
86//               return IMAGE_INIT_FAIL;
8787//            }
8888//            chunks_in_file = 0;
8989//            for (i=0; i<8; i++)
r8323r8324
108108//      default:   logerror ("Cart type not supported\n");
109109//            free (file_data);
110110//            timex_cart_type = TIMEX_CART_NONE;
111//            return INIT_FAIL;
111//            return IMAGE_INIT_FAIL;
112112//   }
113113//
114114//   logerror ("Cart loaded\n");
115115//   logerror ("Chunks %02x\n", timex_cart_chunks);
116   return INIT_PASS;
116   return IMAGE_INIT_PASS;
117117}
118118
119119DEVICE_IMAGE_UNLOAD( timex_cart )
src/mess/formats/studio2_st2.c
r8323r8324
5656
5757   if (filesize <= ST2_BLOCK_SIZE) {
5858      logerror("Error loading cartridge: Invalid ROM file: %s.\n", image.filename());
59      return INIT_FAIL;
59      return IMAGE_INIT_FAIL;
6060   }
6161
6262   /* read ST2 header */
6363   if (image.fread( &header, ST2_BLOCK_SIZE) != ST2_BLOCK_SIZE) {
6464      logerror("Error loading cartridge: Unable to read header from file: %s.\n", image.filename());
65      return INIT_FAIL;
65      return IMAGE_INIT_FAIL;
6666   }
6767
6868   if (LOG) logerror("ST2 Catalogue: %s\n", header.catalogue);
r8323r8324
7878
7979      if (image.fread( ptr, ST2_BLOCK_SIZE) != ST2_BLOCK_SIZE) {
8080         logerror("Error loading cartridge: Unable to read contents from file: %s.\n", image.filename());
81         return INIT_FAIL;
81         return IMAGE_INIT_FAIL;
8282      }
8383   }
8484
85   return INIT_PASS;
85   return IMAGE_INIT_PASS;
8686}
src/mess/formats/trs_cmd.c
r8323r8324
8787      }
8888   }
8989
90   return INIT_PASS;
90   return IMAGE_INIT_PASS;
9191}
src/mess/drivers/vip.c
r8323r8324
840840
841841   if ((size + chip8_size) > messram_get_size(devtag_get_device(image.device().machine, "messram")))
842842   {
843      return INIT_FAIL;
843      return IMAGE_INIT_FAIL;
844844   }
845845
846846   if (chip8_size > 0)
r8323r8324
852852   /* load image to RAM */
853853   image.fread( ptr + chip8_size, size);
854854
855   return INIT_PASS;
855   return IMAGE_INIT_PASS;
856856}
857857
858858/* System Drivers */
src/mess/drivers/elf.c
r8323r8324
357357
358358   if (size > messram_get_size(devtag_get_device(image.device().machine, "messram")))
359359   {
360      return INIT_FAIL;
360      return IMAGE_INIT_FAIL;
361361   }
362362
363363   image.fread( messram_get_ptr(devtag_get_device(image.device().machine, "messram")), size);
364364
365   return INIT_PASS;
365   return IMAGE_INIT_PASS;
366366}
367367
368368/* System Drivers */
src/mess/drivers/jaguar.c
r8323r8324
781781   /* Transfer control to image */
782782   cpu_set_reg(devtag_get_device(image.device().machine, "maincpu"), STATE_GENPC, quickload_begin);
783783   jaguar_shared_ram[1]=quickload_begin;
784   return INIT_PASS;
784   return IMAGE_INIT_PASS;
785785}
786786
787787static DEVICE_IMAGE_LOAD( jaguar )
r8323r8324
820820
821821   /* Transfer control to the bios */
822822   cpu_set_reg(devtag_get_device(image.device().machine, "maincpu"), STATE_GENPC, rom_base[1]);
823   return INIT_PASS;
823   return IMAGE_INIT_PASS;
824824}
825825
826826/*************************************
src/mess/drivers/vii.c
r8323r8324
846846   if( image.fread(cart, size ) != size )
847847   {
848848      image.seterror( IMAGE_ERROR_UNSPECIFIED, "Unable to fully read from file" );
849      return INIT_FAIL;
849      return IMAGE_INIT_FAIL;
850850   }
851851
852852   memcpy(state->cart, cart + 0x4000*2, (0x400000 - 0x4000) * 2);
r8323r8324
862862   {
863863      state->centered_coordinates = 0;
864864   }
865   return INIT_PASS;
865   return IMAGE_INIT_PASS;
866866}
867867
868868static DEVICE_IMAGE_LOAD( vsmile_cart )
r8323r8324
874874   if( image.fread( cart, size ) != size )
875875   {
876876      image.seterror( IMAGE_ERROR_UNSPECIFIED, "Unable to fully read from file" );
877      return INIT_FAIL;
877      return IMAGE_INIT_FAIL;
878878   }
879879
880880   memcpy(state->cart, cart + 0x4000*2, (0x400000 - 0x4000) * 2);
881881
882   return INIT_PASS;
882   return IMAGE_INIT_PASS;
883883}
884884
885885static MACHINE_START( vii )
src/mess/drivers/advision.c
r8323r8324
7272      if (size > memory_region_length(image.device().machine, I8048_TAG))
7373      {
7474         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unsupported cartridge size");
75         return INIT_FAIL;
75         return IMAGE_INIT_FAIL;
7676      }
7777
7878      if (image.fread( memory_region(image.device().machine, I8048_TAG), size) != size)
7979      {
8080         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unable to fully read from file");
81         return INIT_FAIL;
81         return IMAGE_INIT_FAIL;
8282      }
8383
8484   }
r8323r8324
8888      memcpy(memory_region(image.device().machine, I8048_TAG), image.get_software_region("rom"), size);
8989   }
9090
91   return INIT_PASS;
91   return IMAGE_INIT_PASS;
9292}
9393
9494/* Machine Driver */
src/mess/drivers/vic20.c
r8323r8324
592592      memory_install_rom(program, address, (address + size) - 1, 0, 0, ptr + address);
593593   }
594594
595   return INIT_PASS;
595   return IMAGE_INIT_PASS;
596596}
597597
598598/* Graphics Definitions and Video Emulation */
src/mess/drivers/tm990189.c
r8323r8324
377377   rs232_input_timer = timer_alloc(image.device().machine, rs232_input_callback, (void*)image);
378378   timer_adjust_periodic(rs232_input_timer, attotime_zero, 0, ATTOTIME_IN_MSEC(10));
379379
380   return INIT_PASS;
380   return IMAGE_INIT_PASS;
381381}
382382
383383/*
src/mess/drivers/arcadia.c
r8323r8324
471471         size = memory_region_length(image.device().machine, "maincpu");
472472
473473      if (image.fread(rom, size) != size)
474         return INIT_FAIL;
474         return IMAGE_INIT_FAIL;
475475   }
476476   else
477477   {
r8323r8324
528528       rom[patch[i].address] = patch[i].new;
529529   }
530530#endif
531   return INIT_PASS;
531   return IMAGE_INIT_PASS;
532532}
533533
534534static MACHINE_DRIVER_START( arcadia )
src/mess/drivers/spectrum.c
r8323r8324
686686      if (filesize != 0x4000 )
687687      {
688688         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Incorrect or not support cartridge size");
689         return INIT_FAIL;
689         return IMAGE_INIT_FAIL;
690690      }
691691
692692      if (image.fread(memory_region(image.device().machine, "maincpu"), filesize) != filesize)
693693      {
694694         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Error loading file");
695         return INIT_FAIL;
695         return IMAGE_INIT_FAIL;
696696      }
697697   }
698698   else
r8323r8324
700700      filesize = image.get_software_region_length("rom");
701701      memcpy(memory_region(image.device().machine, "maincpu"), image.get_software_region("rom"), filesize);
702702   }
703   return INIT_PASS;
703   return IMAGE_INIT_PASS;
704704}
705705
706706MACHINE_DRIVER_START( spectrum_common )
src/mess/drivers/astrocde.c
r8323r8324
154154      if (image.fread( memory_region(image.device().machine, "maincpu") + 0x2000, size) != size)
155155      {
156156         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unable to fully read from file");
157         return INIT_FAIL;
157         return IMAGE_INIT_FAIL;
158158      }
159159
160160   }
r8323r8324
164164      memcpy(memory_region(image.device().machine, "maincpu") + 0x2000, image.get_software_region("rom"), size);
165165   }
166166
167   return INIT_PASS;
167   return IMAGE_INIT_PASS;
168168}
169169
170170static MACHINE_DRIVER_START( astrocde )
src/mess/drivers/atarist.c
r8323r8324
18021802      {
18031803         memory_install_readwrite_bank(cputag_get_address_space(image.device().machine, M68000_TAG, ADDRESS_SPACE_PROGRAM), 0xfa0000, 0xfbffff, 0, 0, "bank3");
18041804
1805         return INIT_PASS;
1805         return IMAGE_INIT_PASS;
18061806      }
18071807   }
18081808
1809   return INIT_FAIL;
1809   return IMAGE_INIT_FAIL;
18101810}
18111811
18121812static const floppy_config atarist_floppy_config =
src/mess/drivers/sg1000.c
r8323r8324
845845   {
846846      size = image.length();
847847      if (image.fread( ptr, size) != size)
848         return INIT_FAIL;
848         return IMAGE_INIT_FAIL;
849849   }
850850   else
851851   {
r8323r8324
859859   /* work RAM banking */
860860   memory_install_readwrite_bank(program, 0xc000, 0xc3ff, 0, 0x3c00, "bank2");
861861
862   return INIT_PASS;
862   return IMAGE_INIT_PASS;
863863}
864864
865865/*-------------------------------------------------
r8323r8324
875875   {
876876      size = image.length();
877877      if (image.fread( ptr, size) != size)
878         return INIT_FAIL;
878         return IMAGE_INIT_FAIL;
879879   }
880880   else
881881   {
r8323r8324
886886   /* cartridge ROM banking */
887887   sg1000_map_cartridge_memory(image.device().machine, ptr, size);
888888
889   return INIT_PASS;
889   return IMAGE_INIT_PASS;
890890}
891891
892892/*-------------------------------------------------
r8323r8324
930930   {
931931      size = image.length();
932932      if (image.fread( ptr, size) != size)
933         return INIT_FAIL;
933         return IMAGE_INIT_FAIL;
934934   }
935935   else
936936   {
r8323r8324
941941   /* cartridge ROM and work RAM banking */
942942   sc3000_map_cartridge_memory(image.device().machine, ptr, size);
943943
944   return INIT_PASS;
944   return IMAGE_INIT_PASS;
945945}
946946
947947/***************************************************************************
src/mess/drivers/ssem.c
r8323r8324
602602        }
603603    }
604604
605    return INIT_PASS;
605    return IMAGE_INIT_PASS;
606606}
607607
608608/****************************************************\
src/mess/drivers/ql.c
r8323r8324
604604//         memory_install_read_bank(cputag_get_address_space(image.device().machine, M68008_TAG, ADDRESS_SPACE_PROGRAM), 0x00c000, 0x00ffff, 0, 0, "bank1");
605605//         memory_unmap_write(cputag_get_address_space(image.device().machine, M68008_TAG, ADDRESS_SPACE_PROGRAM), 0x00c000, 0x00ffff, 0, 0);
606606//
607//         return INIT_PASS;
607//         return IMAGE_INIT_PASS;
608608//      }
609609//   }
610610//
611   return INIT_FAIL;
611   return IMAGE_INIT_FAIL;
612612}
613613
614614
r8323r8324
904904{
905905   image.fread(messram_get_ptr(devtag_get_device(image.device().machine, "messram")), 128*1024);
906906
907   return INIT_PASS;
907   return IMAGE_INIT_PASS;
908908}
909909
910910/* Computer Drivers */
src/mess/drivers/tmc1800.c
r8323r8324
999999
10001000   if (size > messram_get_size(devtag_get_device(image.device().machine, "messram")))
10011001   {
1002      return INIT_FAIL;
1002      return IMAGE_INIT_FAIL;
10031003   }
10041004
10051005   image.fread( ptr, size);
10061006
1007   return INIT_PASS;
1007   return IMAGE_INIT_PASS;
10081008}
10091009
10101010/* Driver Initialization */
src/mess/drivers/crvision.c
r8323r8324
539539
540540   default:
541541      auto_free(machine, temp_copy);
542      return INIT_FAIL;
542      return IMAGE_INIT_FAIL;
543543   }
544544
545545   memory_configure_bank(machine, "bank1", 0, 1, mem + 0x8000, 0);
r8323r8324
550550
551551   auto_free(machine, temp_copy);
552552
553   return INIT_PASS;
553   return IMAGE_INIT_PASS;
554554}
555555
556556/* Machine Driver */
src/mess/drivers/gmaster.c
r8323r8324
228228      if (size > (memory_region_length(image.device().machine, "maincpu") - 0x8000))
229229      {
230230         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unsupported cartridge size");
231         return INIT_FAIL;
231         return IMAGE_INIT_FAIL;
232232      }
233233
234234      if (image.fread( memory_region(image.device().machine, "maincpu") + 0x8000, size) != size)
235235      {
236236         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unable to fully read from file");
237         return INIT_FAIL;
237         return IMAGE_INIT_FAIL;
238238      }
239239
240240   }
r8323r8324
244244      memcpy(memory_region(image.device().machine, "maincpu") + 0x8000, image.get_software_region("rom"), size);
245245   }
246246
247   return INIT_PASS;
247   return IMAGE_INIT_PASS;
248248}
249249
250250static INTERRUPT_GEN( gmaster_interrupt )
src/mess/drivers/newbrain.c
r8323r8324
14951495
14961496static DEVICE_IMAGE_LOAD( newbrain_serial )
14971497{
1498   if (device_load_serial(image)==INIT_PASS)
1498   if (device_load_serial(image)==IMAGE_INIT_PASS)
14991499   {
15001500      serial_device_setup(image, 9600, 8, 1, SERIAL_PARITY_NONE);
15011501
15021502      serial_device_set_transmit_state(image, 1);
15031503
1504      return INIT_PASS;
1504      return IMAGE_INIT_PASS;
15051505   }
15061506
1507   return INIT_FAIL;
1507   return IMAGE_INIT_FAIL;
15081508}
15091509
15101510
src/mess/drivers/vboy.c
r8323r8324
678678   {
679679      size = image.length();
680680      if (image.fread( ptr, size) != size)
681         return INIT_FAIL;
681         return IMAGE_INIT_FAIL;
682682   }
683683   else
684684   {
r8323r8324
686686      memcpy(ptr, image.get_software_region("rom"), size);
687687   }
688688
689   return INIT_PASS;
689   return IMAGE_INIT_PASS;
690690}
691691
692692static MACHINE_DRIVER_START( vboy )
src/mess/drivers/vtech1.c
r8323r8324
214214      snprintf(message, ARRAY_LENGTH(message), "SNAPLOAD: %s\nInsufficient RAM - need %04X",pgmname,size);
215215      image.seterror(IMAGE_ERROR_INVALIDIMAGE, message);
216216      image.message("SNAPLOAD: %s\nInsufficient RAM - need %04X",pgmname,size);
217      return INIT_FAIL;
217      return IMAGE_INIT_FAIL;
218218   }
219219
220220   /* write it to ram */
r8323r8324
245245   default:
246246      image.seterror(IMAGE_ERROR_UNSUPPORTED, "Snapshot format not supported.");
247247      image.message("Snapshot format not supported.");
248      return INIT_FAIL;
248      return IMAGE_INIT_FAIL;
249249   }
250250
251   return INIT_PASS;
251   return IMAGE_INIT_PASS;
252252}
253253
254254static Z80BIN_EXECUTE( vtech1 )
src/mess/drivers/ng_aes.c
r8323r8324
867867//static DEVICE_IMAGE_LOAD(aes_cart)
868868//{
869869//   else
870//      return INIT_FAIL;
870//      return IMAGE_INIT_FAIL;
871871   
872//   return INIT_PASS;
872//   return IMAGE_INIT_PASS;
873873//}
874874
875875/*************************************
src/mess/drivers/psx.c
r8323r8324
420420   if( exe_buffer == NULL )
421421   {
422422      logerror( "psx_exe_load: out of memory\n" );
423      return INIT_FAIL;
423      return IMAGE_INIT_FAIL;
424424   }
425425   if( image.fread( exe_buffer, quickload_size ) != quickload_size )
426426   {
427427      free( exe_buffer );
428      return INIT_FAIL;
428      return IMAGE_INIT_FAIL;
429429   }
430430   exe_size = quickload_size;
431431   memory_set_direct_update_handler( space, psx_setopbase );
432   return INIT_PASS;
432   return IMAGE_INIT_PASS;
433433}
434434
435435/* PAD emulation */
src/mess/drivers/tutor.c
r8323r8324
260260static DEVICE_IMAGE_LOAD( tutor_cart )
261261{
262262   image.fread( memory_region(image.device().machine, "maincpu") + cartridge_base, 0x6000);
263   return INIT_PASS;
263   return IMAGE_INIT_PASS;
264264}
265265
266266static DEVICE_IMAGE_UNLOAD( tutor_cart )
src/mess/drivers/pockstat.c
r8323r8324
929929
930930   if(length != 0x20f40)
931931   {
932      return INIT_FAIL;
932      return IMAGE_INIT_FAIL;
933933   }
934934
935935   for(i = 0; i < strlen(gme_id); i++)
936936   {
937937      if(cart[i] != gme_id[i])
938938      {
939         return INIT_FAIL;
939         return IMAGE_INIT_FAIL;
940940      }
941941   }
942942
943943   memcpy(cart, cart + 0xf40, 0x20000);
944944
945   return INIT_PASS;
945   return IMAGE_INIT_PASS;
946946}
947947
948948static MACHINE_DRIVER_START( pockstat )
src/mess/drivers/gamepock.c
r8323r8324
5252      int size = image.length();
5353      if ( image.fread( cart, size ) != size ) {
5454         image.seterror( IMAGE_ERROR_UNSPECIFIED, "Unable to fully read from file" );
55         return INIT_FAIL;
55         return IMAGE_INIT_FAIL;
5656      }
5757   }
5858   else
r8323r8324
6262
6363   memory_set_bankptr( image.device().machine, "bank1", cart );
6464
65   return INIT_PASS;
65   return IMAGE_INIT_PASS;
6666}
6767
6868static MACHINE_DRIVER_START( gamepock )
src/mess/drivers/vidbrain.c
r8323r8324
460460   {
461461      size = image.length();
462462      if (image.fread(ptr, size) != size)
463         return INIT_FAIL;
463         return IMAGE_INIT_FAIL;
464464   }
465465   else
466466   {
r8323r8324
468468      memcpy(ptr, image.get_software_region("rom"), size);
469469   }
470470
471   return INIT_PASS;
471   return IMAGE_INIT_PASS;
472472}
473473
474474/***************************************************************************
src/mess/drivers/pv1000.c
r8323r8324
188188   if (size != 0x2000 && size != 0x4000)
189189   {
190190      image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unsupported cartridge size");
191      return INIT_FAIL;
191      return IMAGE_INIT_FAIL;
192192   }
193193
194194   if (image.software_entry() == NULL)
r8323r8324
196196      if (image.fread( cart, size) != size)
197197      {
198198         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unable to fully read from file");
199         return INIT_FAIL;
199         return IMAGE_INIT_FAIL;
200200      }
201201   }
202202   else
r8323r8324
207207   if (size == 0x2000)
208208      memcpy(cart + 0x2000, cart, 0x2000);
209209
210   return INIT_PASS;
210   return IMAGE_INIT_PASS;
211211}
212212
213213
src/mess/drivers/nc.c
r8323r8324
16321632   running_device *uart = devtag_get_device(image.device().machine, "uart");
16331633
16341634   /* filename specified */
1635   if (device_load_serial(image)==INIT_PASS)
1635   if (device_load_serial(image)==IMAGE_INIT_PASS)
16361636   {
16371637      /* setup transmit parameters */
16381638      serial_device_setup(&image.device(), 9600, 8, 1, SERIAL_PARITY_NONE);
r8323r8324
16431643      /* and start transmit */
16441644      serial_device_set_transmit_state(&image.device(),1);
16451645
1646      return INIT_PASS;
1646      return IMAGE_INIT_PASS;
16471647   }
16481648
1649   return INIT_FAIL;
1649   return IMAGE_INIT_FAIL;
16501650
16511651}
16521652
src/mess/drivers/ngp.c
r8323r8324
663663      if (filesize != 0x80000 && filesize != 0x100000 && filesize != 0x200000 && filesize != 0x400000)
664664      {
665665         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Incorrect or not support cartridge size");
666         return INIT_FAIL;
666         return IMAGE_INIT_FAIL;
667667      }
668668
669669      if (image.fread( memory_region(image.device().machine, "cart"), filesize) != filesize)
670670      {
671671         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Error loading file");
672         return INIT_FAIL;
672         return IMAGE_INIT_FAIL;
673673      }
674674   }
675675   else
r8323r8324
736736   state->flash_chip[0].present = 1;
737737   state->flash_chip[0].state = F_READ;
738738
739   return INIT_PASS;
739   return IMAGE_INIT_PASS;
740740}
741741
742742
src/mess/drivers/pasogo.c
r8323r8324
515515      if (image.fread( user, size) != size)
516516      {
517517         logerror("%s load error\n", image.filename());
518         return INIT_FAIL;
518         return IMAGE_INIT_FAIL;
519519      }
520520   }
521521   else
r8323r8324
524524      memcpy(user, image.get_software_region("rom"), size);
525525   }
526526
527   return INIT_PASS;
527   return IMAGE_INIT_PASS;
528528}
529529
530530static MACHINE_DRIVER_START( pasogo )
src/mess/drivers/cgenie.c
r8323r8324
673673    short dir_length = 0;
674674
675675    // A Floppy Isnt manditory, so return if none
676    if (device_load_basicdsk_floppy(image) != INIT_PASS)
677        return INIT_FAIL;
676    if (device_load_basicdsk_floppy(image) != IMAGE_INIT_PASS)
677        return IMAGE_INIT_FAIL;
678678
679679    // determine image geometry
680680    image.fseek(0, SEEK_SET);
r8323r8324
749749        }
750750
751751    }
752    return INIT_PASS;
752    return IMAGE_INIT_PASS;
753753}
754754#endif
755755
src/mess/drivers/lynx.c
r8323r8324
148148   int i;
149149
150150   if (image.fread( header, sizeof(header)) != sizeof(header))
151      return INIT_FAIL;
151      return IMAGE_INIT_FAIL;
152152
153153   /* Check the image */
154154   if (lynx_verify_cart((char*)header, LYNX_QUICKLOAD) == IMAGE_VERIFY_FAIL)
155      return INIT_FAIL;
155      return IMAGE_INIT_FAIL;
156156
157157   start = header[3] | (header[2]<<8); //! big endian format in file format for little endian cpu
158158   length = header[5] | (header[4]<<8);
r8323r8324
163163   if (image.fread( data, length) != length)
164164   {
165165      free(data);
166      return INIT_FAIL;
166      return IMAGE_INIT_FAIL;
167167   }
168168
169169   for (i = 0; i < length; i++)
r8323r8324
180180
181181   cpu_set_reg(cpu, STATE_GENPC, start);
182182
183   return INIT_PASS;
183   return IMAGE_INIT_PASS;
184184}
185185
186186/***************************************************************************
src/mess/drivers/apexc.c
r8323r8324
8080   }
8181#endif
8282
83   return INIT_PASS;
83   return IMAGE_INIT_PASS;
8484}
8585
8686/*
src/mess/drivers/super80.c
r8323r8324
611611{
612612   image.fread( memory_region(image.device().machine, "maincpu") + 0xc000, 0x3000);
613613
614   return INIT_PASS;
614   return IMAGE_INIT_PASS;
615615}
616616
617617static const mc6845_interface super80v_crtc = {
src/mess/drivers/n64.c
r8323r8324
146146   }
147147
148148   logerror("cart length = %d\n", length);
149   return INIT_PASS;
149   return IMAGE_INIT_PASS;
150150}
151151
152152static MACHINE_DRIVER_START( n64 )
src/mess/drivers/bw2.c
r8323r8324
781781{
782782   bw2_state *state = (bw2_state *) image.device().machine->driver_data;
783783
784   if (device_load_serial(image) == INIT_PASS)
784   if (device_load_serial(image) == IMAGE_INIT_PASS)
785785   {
786786      serial_device_setup(image, 9600 >> input_port_read(image.device().machine, "BAUD"), 8, 1, SERIAL_PARITY_NONE);
787787
r8323r8324
789789
790790      serial_device_set_transmit_state(image, 1);
791791
792      return INIT_PASS;
792      return IMAGE_INIT_PASS;
793793   }
794794
795   return INIT_FAIL;
795   return IMAGE_INIT_FAIL;
796796}
797797
798798
src/mess/drivers/atom.c
r8323r8324
787787      {
788788         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unsupported cartridge size");
789789         auto_free(image.device().machine, temp_copy);
790         return INIT_FAIL;
790         return IMAGE_INIT_FAIL;
791791      }
792792     
793793      if (image.fread(temp_copy, size) != size)
794794      {
795795         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unable to fully read from file");
796796         auto_free(image.device().machine, temp_copy);
797         return INIT_FAIL;
797         return IMAGE_INIT_FAIL;
798798      }
799799   }
800800   else
r8323r8324
812812   
813813   auto_free(image.device().machine, temp_copy);
814814   
815   return INIT_PASS;
815   return IMAGE_INIT_PASS;
816816}
817817
818818
src/mess/drivers/coleco.c
r8323r8324
563563
564564   if (image.fread( ptr, size ) != size)
565565   {
566      return INIT_FAIL;
566      return IMAGE_INIT_FAIL;
567567   }
568568
569   return INIT_PASS;
569   return IMAGE_INIT_PASS;
570570}
571571
572572/* Machine Drivers */
src/mess/drivers/altair.c
r8323r8324
7070   int read_;
7171   quick_length = image.length();
7272   if (quick_length >= 0xfd00)
73      return INIT_FAIL;
73      return IMAGE_INIT_FAIL;
7474   read_ = image.fread(altair_ram, quick_length);
7575   if (read_ != quick_length)
76      return INIT_FAIL;
76      return IMAGE_INIT_FAIL;
7777
78   return INIT_PASS;
78   return IMAGE_INIT_PASS;
7979}
8080
8181
src/mess/drivers/supracan.c
r8323r8324
11271127      if (size > 0x400000)
11281128      {
11291129         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unsupported cartridge size");
1130         return INIT_FAIL;
1130         return IMAGE_INIT_FAIL;
11311131      }
11321132
11331133      if (image.fread( cart, size) != size)
11341134      {
11351135         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unable to fully read from file");
1136         return INIT_FAIL;
1136         return IMAGE_INIT_FAIL;
11371137      }
11381138   }
11391139   else
r8323r8324
11421142      memcpy(cart, image.get_software_region("rom"), size);
11431143   }
11441144
1145   return INIT_PASS;
1145   return IMAGE_INIT_PASS;
11461146}
11471147
11481148
src/mess/drivers/channelf.c
r8323r8324
245245      if (size > 0xf800)
246246      {
247247         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unsupported cartridge size");
248         return INIT_FAIL;
248         return IMAGE_INIT_FAIL;
249249      }
250250
251251      if (image.fread( memory_region(image.device().machine, "maincpu") + 0x0800, size) != size)
252252      {
253253         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unable to fully read from file");
254         return INIT_FAIL;
254         return IMAGE_INIT_FAIL;
255255      }
256256
257257   }
r8323r8324
261261      memcpy(memory_region(image.device().machine, "maincpu") + 0x0800, image.get_software_region("rom"), size);
262262   }
263263
264   return INIT_PASS;
264   return IMAGE_INIT_PASS;
265265}
266266
267267static MACHINE_DRIVER_START( channelf_cart )
src/mess/drivers/pegasus.c
r8323r8324
296296   image.fread(memory_region(image.device().machine, "maincpu") + 0x0000, 0x1000);
297297   pegasus_decrypt_rom( image.device().machine, 0x0000 );
298298
299   return INIT_PASS;
299   return IMAGE_INIT_PASS;
300300}
301301
302302static DEVICE_IMAGE_LOAD( pegasus_cart_2 )
r8323r8324
304304   image.fread(memory_region(image.device().machine, "maincpu") + 0x1000, 0x1000);
305305   pegasus_decrypt_rom( image.device().machine, 0x1000 );
306306
307   return INIT_PASS;
307   return IMAGE_INIT_PASS;
308308}
309309
310310static DEVICE_IMAGE_LOAD( pegasus_cart_3 )
r8323r8324
312312   image.fread(memory_region(image.device().machine, "maincpu") + 0x2000, 0x1000);
313313   pegasus_decrypt_rom( image.device().machine, 0x2000 );
314314
315   return INIT_PASS;
315   return IMAGE_INIT_PASS;
316316}
317317
318318static DEVICE_IMAGE_LOAD( pegasus_cart_4 )
r8323r8324
320320   image.fread(memory_region(image.device().machine, "maincpu") + 0xc000, 0x1000);
321321   pegasus_decrypt_rom( image.device().machine, 0xc000 );
322322
323   return INIT_PASS;
323   return IMAGE_INIT_PASS;
324324}
325325
326326static DEVICE_IMAGE_LOAD( pegasus_cart_5 )
r8323r8324
328328   image.fread( memory_region(image.device().machine, "maincpu") + 0xd000, 0x1000);
329329   pegasus_decrypt_rom( image.device().machine, 0xd000 );
330330
331   return INIT_PASS;
331   return IMAGE_INIT_PASS;
332332}
333333
334334static MACHINE_START( pegasus )
src/mess/drivers/exelv.c
r8323r8324
107107#ifdef UNUSED_FUNCTION
108108static DEVICE_IMAGE_LOAD(exelv_cart)
109109{
110   return INIT_PASS;
110   return IMAGE_INIT_PASS;
111111}
112112
113113static DEVICE_IMAGE_UNLOAD( exelv_cart )
src/mess/drivers/scv.c
r8323r8324
338338      if ( size > memory_region_length( image.device().machine, "cart" ) )
339339      {
340340         image.seterror( IMAGE_ERROR_UNSPECIFIED, "Unsupported cartridge size" );
341         return INIT_FAIL;
341         return IMAGE_INIT_FAIL;
342342      }
343343
344344      if ( image.fread( cart, size ) != size )
345345      {
346346         image.seterror( IMAGE_ERROR_UNSPECIFIED, "Unable to fully read from file" );
347         return INIT_FAIL;
347         return IMAGE_INIT_FAIL;
348348      }
349349
350350      state->cart_rom = cart;
r8323r8324
362362
363363   scv_set_banks( image.device().machine );
364364
365   return INIT_PASS;
365   return IMAGE_INIT_PASS;
366366}
367367
368368
src/mess/drivers/svision.c
r8323r8324
471471      {
472472         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unsupported cartridge size");
473473         auto_free(image.device().machine, temp_copy);
474         return INIT_FAIL;
474         return IMAGE_INIT_FAIL;
475475      }
476476
477477      if (image.fread( temp_copy, size) != size)
478478      {
479479         image.seterror(IMAGE_ERROR_UNSPECIFIED, "Unable to fully read from file");
480480         auto_free(image.device().machine, temp_copy);
481         return INIT_FAIL;
481         return IMAGE_INIT_FAIL;
482482      }
483483   }
484484   else
r8323r8324
496496
497497   auto_free(image.device().machine, temp_copy);
498498
499   return INIT_PASS;
499   return IMAGE_INIT_PASS;
500500}
501501
502502static MACHINE_RESET( svision )
src/mess/drivers/vc4000.c
r8323r8324
232232      if (image.software_entry() == NULL)
233233      {
234234         if (image.fread( memory_region(machine, "maincpu"), size) != size)
235            return INIT_FAIL;
235            return IMAGE_INIT_FAIL;
236236      }
237237      else
238238         memcpy(memory_region(machine, "maincpu"), image.get_software_region("rom"), size);
239239   }
240240
241   return INIT_PASS;
241   return IMAGE_INIT_PASS;
242242}
243243
244244static MACHINE_DRIVER_START( vc4000 )
r8323r8324
385385   quick_length = image.length();
386386   quick_data = (UINT8*)malloc(quick_length);
387387   if (!quick_data)
388      return INIT_FAIL;
388      return IMAGE_INIT_FAIL;
389389
390390   read_ = image.fread( quick_data, quick_length);
391391   if (read_ != quick_length)
392      return INIT_FAIL;
392      return IMAGE_INIT_FAIL;
393393
394394   if (quick_data[0] != 2)
395      return INIT_FAIL;
395      return IMAGE_INIT_FAIL;
396396
397397   quick_addr = quick_data[1] * 256 + quick_data[2];
398398
399399   //if ((quick_addr + quick_length - 5) > 0x1000)
400   //  return INIT_FAIL;
400   //  return IMAGE_INIT_FAIL;
401401
402402   memory_write_byte(space, 0x08be, quick_data[3]);
403403   memory_write_byte(space, 0x08bf, quick_data[4]);
r8323r8324
408408   }
409409
410410   logerror("quick loading at %.4x size:%.4x\n", quick_addr, (quick_length-5));
411   return INIT_PASS;
411   return IMAGE_INIT_PASS;
412412}
413413
414414
src/mess/drivers/cosmicos.c
r8323r8324
583583   /* load image to RAM */
584584   image.fread(ptr, size);
585585
586   return INIT_PASS;
586   return IMAGE_INIT_PASS;
587587}
588588
589589/* Machine Driver */
src/mess/drivers/gba.c
r8323r8324
24132413         break;
24142414   }
24152415
2416   return INIT_PASS;
2416   return IMAGE_INIT_PASS;
24172417}
24182418
24192419static MACHINE_DRIVER_START( gbadv )
src/mess/drivers/bbcbc.c
r8323r8324
136136      int size = image.length();
137137      if ( image.fread(cart, size ) != size ) {
138138         image.seterror( IMAGE_ERROR_UNSPECIFIED, "Unable to fully read from file" );
139         return INIT_FAIL;
139         return IMAGE_INIT_FAIL;
140140      }
141141   }
142142   else
r8323r8324
147147      memcpy( cart, reg, MIN(reg_len, 0x8000) );
148148   }
149149
150   return INIT_PASS;
150   return IMAGE_INIT_PASS;
151151
152152}
153153

Previous 15994 Revisions Next


© 1998-2018 The MESS Team