malloc to calloc

src/device/cartridge.c

@@ -113,8 +113,7 @@ cart_image_load(int drive, char *fn)
         (void) !fread(&base, 1, 2, fp);
         base <<= 4;
         fseek(fp, 0x00000200, SEEK_SET);
-        carts[drive].buf = (uint8_t *) malloc(size);
-        memset(carts[drive].buf, 0x00, size);
+        carts[drive].buf = (uint8_t *) calloc(1, size);
         (void) !fread(carts[drive].buf, 1, size, fp);
         fclose(fp);
     } else {
@@ -122,8 +121,7 @@ cart_image_load(int drive, char *fn)
         if (size == 32768)
             base += 0x8000;
         fseek(fp, 0x00000000, SEEK_SET);
-        carts[drive].buf = (uint8_t *) malloc(size);
-        memset(carts[drive].buf, 0x00, size);
+        carts[drive].buf = (uint8_t *) calloc(1, size);
         (void) !fread(carts[drive].buf, 1, size, fp);
         fclose(fp);
     }

src/device/cassette.c

@@ -131,9 +131,7 @@ pc_cas_free(pc_cassette_t *cas)
 pc_cassette_t *
 pc_cas_new(void)
 {
-    pc_cassette_t *cas;
-
-    cas = malloc(sizeof(pc_cassette_t));
+    pc_cassette_t *cas = calloc(1, sizeof( pc_cassette_t));
 
     if (cas == NULL) {
         return (NULL);

src/device/clock_ics9xxx.c

@@ -1181,8 +1181,7 @@ ics9xxx_find_bus_match(ics9xxx_t *dev, uint32_t bus, uint8_t preset_mask, uint8_
 static void *
 ics9xxx_init(const device_t *info)
 {
-    ics9xxx_t *dev = (ics9xxx_t *) malloc(sizeof(ics9xxx_t));
-    memset(dev, 0, sizeof(ics9xxx_t));
+    ics9xxx_t *dev = (ics9xxx_t *) calloc(1, sizeof(ics9xxx_t));
 
     dev->model_idx  = info->local;
     dev->model      = (ics9xxx_model_t *) &ics9xxx_models[dev->model_idx];
@@ -1267,8 +1266,7 @@ ics9xxx_close(void *priv)
 device_t *
 ics9xxx_get(uint8_t model)
 {
-    device_t *dev = (device_t *) malloc(sizeof(device_t));
-    memset(dev, 0, sizeof(device_t));
+    device_t *dev = (device_t *) calloc(1, sizeof(device_t));
 
     dev->name  = "ICS9xxx-xx Clock Generator";
     dev->local = model;

src/device/hasp.c

@@ -305,8 +305,7 @@ hasp_read_status(void *priv)
 static void *
 hasp_init(void *lpt, int type)
 {
-    hasp_t *dev = malloc(sizeof(hasp_t));
-    memset(dev, 0, sizeof(hasp_t));
+    hasp_t *dev = calloc(1, sizeof(hasp_t));
 
     hasp_log("HASP: init(%d)\n", type);
 

src/device/hwm_gl518sm.c

@@ -282,8 +282,7 @@ gl518sm_close(void *priv)
 static void *
 gl518sm_init(const device_t *info)
 {
-    gl518sm_t *dev = (gl518sm_t *) malloc(sizeof(gl518sm_t));
-    memset(dev, 0, sizeof(gl518sm_t));
+    gl518sm_t *dev = (gl518sm_t *) calloc(1, sizeof(gl518sm_t));
 
     dev->local = info->local;
 

src/device/hwm_lm75.c

@@ -216,8 +216,7 @@ lm75_close(void *priv)
 static void *
 lm75_init(const device_t *info)
 {
-    lm75_t *dev = (lm75_t *) malloc(sizeof(lm75_t));
-    memset(dev, 0, sizeof(lm75_t));
+    lm75_t *dev = (lm75_t *) calloc(1, sizeof(lm75_t));
 
     dev->local = info->local;
 

src/device/hwm_lm78.c

@@ -771,8 +771,7 @@ lm78_close(void *priv)
 static void *
 lm78_init(const device_t *info)
 {
-    lm78_t *dev = (lm78_t *) malloc(sizeof(lm78_t));
-    memset(dev, 0, sizeof(lm78_t));
+    lm78_t *dev = (lm78_t *) calloc(1, sizeof(lm78_t));
 
     dev->local = info->local;
 

src/device/hwm_vt82c686.c

@@ -183,8 +183,7 @@ vt82c686_close(void *priv)
 static void *
 vt82c686_init(UNUSED(const device_t *info))
 {
-    vt82c686_t *dev = (vt82c686_t *) malloc(sizeof(vt82c686_t));
-    memset(dev, 0, sizeof(vt82c686_t));
+    vt82c686_t *dev = (vt82c686_t *) calloc(1, sizeof(vt82c686_t));
 
     /* Set default values. Since this hardware monitor has a complex voltage factor system,
        the values struct contains voltage values *before* applying their respective factors. */

src/device/i2c.c

@@ -67,8 +67,7 @@ i2c_log(const char *fmt, ...)
 void *
 i2c_addbus(char *name)
 {
-    i2c_bus_t *bus = (i2c_bus_t *) malloc(sizeof(i2c_bus_t));
-    memset(bus, 0, sizeof(i2c_bus_t));
+    i2c_bus_t *bus = (i2c_bus_t *) calloc(1, sizeof(i2c_bus_t));
 
     bus->name = name;
 
@@ -127,8 +126,7 @@ i2c_sethandler(void *bus_handle, uint8_t base, int size,
 
     for (int c = 0; c < size; c++) {
         p = bus->last[base + c];
-        q = (i2c_t *) malloc(sizeof(i2c_t));
-        memset(q, 0, sizeof(i2c_t));
+        q = (i2c_t *) calloc(1, sizeof(i2c_t));
         if (p) {
             p->next = q;
             q->prev = p;

src/device/i2c_gpio.c

@@ -59,8 +59,7 @@ i2c_gpio_log(int level, const char *fmt, ...)
 void *
 i2c_gpio_init(char *bus_name)
 {
-    i2c_gpio_t *dev = (i2c_gpio_t *) malloc(sizeof(i2c_gpio_t));
-    memset(dev, 0, sizeof(i2c_gpio_t));
+    i2c_gpio_t *dev = (i2c_gpio_t *) calloc(1, sizeof(i2c_gpio_t));
 
     i2c_gpio_log(1, "I2C GPIO %s: init()\n", bus_name);
 

src/device/isamem.c

@@ -483,8 +483,7 @@ isamem_init(const device_t *info)
     uint8_t  *ptr;
 
     /* Find our device and create an instance. */
-    dev = (memdev_t *) malloc(sizeof(memdev_t));
-    memset(dev, 0x00, sizeof(memdev_t));
+    dev = (memdev_t *) calloc(1, sizeof(memdev_t));
     dev->name  = info->name;
     dev->board = info->local;
 

src/device/isapnp.c

@@ -679,7 +679,7 @@ isapnp_write_data(UNUSED(uint16_t addr), uint8_t val, void *priv)
 static void *
 isapnp_init(UNUSED(const device_t *info))
 {
-    isapnp_t *dev = (isapnp_t *) malloc(sizeof(isapnp_t));
+    isapnp_t *dev = (isapnp_t *) calloc(1, sizeof(isapnp_t));
     memset(dev, 0, sizeof(isapnp_t));
 
     io_sethandler(0x279, 1, NULL, NULL, NULL, isapnp_write_addr, NULL, NULL, dev);
@@ -728,8 +728,7 @@ isapnp_add_card(uint8_t *rom, uint16_t rom_size,
     if (!dev)
         dev = (isapnp_t *) device_add(&isapnp_device);
 
-    isapnp_card_t *card = (isapnp_card_t *) malloc(sizeof(isapnp_card_t));
-    memset(card, 0, sizeof(isapnp_card_t));
+    isapnp_card_t *card = (isapnp_card_t *) calloc(1, sizeof(isapnp_card_t));
 
     card->enable           = 1;
     card->priv             = priv;

src/device/isartc.c

@@ -520,8 +520,7 @@ isartc_init(const device_t *info)
     is_at           = is_at || !strcmp(machine_get_internal_name(), "xi8088");
 
     /* Create a device instance. */
-    dev = (rtcdev_t *) malloc(sizeof(rtcdev_t));
-    memset(dev, 0x00, sizeof(rtcdev_t));
+    dev = (rtcdev_t *) calloc(1, sizeof(rtcdev_t));
     dev->name     = info->name;
     dev->board    = info->local;
     dev->irq      = -1;

src/device/kbc_at.c

@@ -2282,8 +2282,7 @@ kbc_at_init(const device_t *info)
     atkbc_t *dev;
     int max_ports;
 
-    dev = (atkbc_t *) malloc(sizeof(atkbc_t));
-    memset(dev, 0x00, sizeof(atkbc_t));
+    dev = (atkbc_t *) calloc(1, sizeof(atkbc_t));
 
     dev->flags = info->local;
 
@@ -2393,8 +2392,7 @@ kbc_at_init(const device_t *info)
 #endif
 
     for (int i = 0; i < max_ports; i++) {
-        kbc_at_ports[i] = (kbc_at_port_t *) malloc(sizeof(kbc_at_port_t));
-        memset(kbc_at_ports[i], 0x00, sizeof(kbc_at_port_t));
+        kbc_at_ports[i] = (kbc_at_port_t *) calloc(1, sizeof(kbc_at_port_t));
         kbc_at_ports[i]->out_new = -1;
     }
 

src/device/keyboard_xt.c

@@ -1000,8 +1000,7 @@ kbd_init(const device_t *info)
 {
     xtkbd_t *kbd;
 
-    kbd = (xtkbd_t *) malloc(sizeof(xtkbd_t));
-    memset(kbd, 0x00, sizeof(xtkbd_t));
+    kbd = (xtkbd_t *) calloc(1, sizeof(xtkbd_t));
 
     io_sethandler(0x0060, 4,
                   kbd_read, NULL, NULL, kbd_write, NULL, NULL, kbd);

src/device/mouse_bus.c

@@ -614,8 +614,7 @@ bm_init(const device_t *info)
     mouse_t *dev;
     int      hz;
 
-    dev = (mouse_t *) malloc(sizeof(mouse_t));
-    memset(dev, 0x00, sizeof(mouse_t));
+    dev = (mouse_t *) calloc(1, sizeof(mouse_t));
 
     if ((info->local & ~MOUSE_TYPE_ONBOARD) == MOUSE_TYPE_INPORT)
         dev->flags = FLAG_INPORT;

src/device/mouse_microtouch_touchscreen.c

@@ -128,8 +128,7 @@ mtouch_initnvr(void *priv)
     FILE *fp;
 
     /* Allocate and initialize the EEPROM. */
-    dev->nvr = (uint8_t *) malloc(NVR_SIZE);
-    memset(dev->nvr, 0x00, NVR_SIZE);
+    dev->nvr = (uint8_t *) calloc(1, NVR_SIZE);
 
     fp = nvr_fopen(dev->nvr_path, "rb");
     if (fp) {

src/device/mouse_serial.c

@@ -845,8 +845,7 @@ sermouse_init(const device_t *info)
     void (*dev_write)(struct serial_s *serial, void *priv, uint8_t data);
     void (*transmit_period_callback)(struct serial_s *serial, void *priv, double transmit_period);
 
-    dev = (mouse_t *) malloc(sizeof(mouse_t));
-    memset(dev, 0x00, sizeof(mouse_t));
+    dev = (mouse_t *) calloc(1, sizeof(mouse_t));
     dev->name = info->name;
     dev->but  = device_get_config_int("buttons");
     dev->rev  = device_get_config_int("revision");

src/device/pci_bridge.c

@@ -491,8 +491,7 @@ pci_bridge_init(const device_t *info)
     uint8_t interrupt_mask;
     uint8_t slot_count;
 
-    pci_bridge_t *dev = (pci_bridge_t *) malloc(sizeof(pci_bridge_t));
-    memset(dev, 0, sizeof(pci_bridge_t));
+    pci_bridge_t *dev = (pci_bridge_t *) calloc(1, sizeof(pci_bridge_t));
 
     dev->local     = info->local;
     dev->bus_index = pci_register_bus();

src/device/phoenix_486_jumper.c

@@ -110,8 +110,7 @@ phoenix_486_jumper_close(void *priv)
 static void *
 phoenix_486_jumper_init(const device_t *info)
 {
-    phoenix_486_jumper_t *dev = (phoenix_486_jumper_t *) malloc(sizeof(phoenix_486_jumper_t));
-    memset(dev, 0, sizeof(phoenix_486_jumper_t));
+    phoenix_486_jumper_t *dev = (phoenix_486_jumper_t *) calloc(1, sizeof(phoenix_486_jumper_t));
 
     dev->type = info->local;
 

src/device/serial.c

@@ -914,8 +914,7 @@ serial_reset(void *priv)
 static void *
 serial_init(const device_t *info)
 {
-    serial_t *dev = (serial_t *) malloc(sizeof(serial_t));
-    memset(dev, 0, sizeof(serial_t));
+    serial_t *dev = (serial_t *) calloc(1, sizeof(serial_t));
 
     dev->inst = next_inst;
 

src/device/serial_passthrough.c

@@ -178,8 +178,7 @@ serial_passthrough_dev_init(const device_t *info)
 {
     serial_passthrough_t *dev;
 
-    dev = (serial_passthrough_t *) malloc(sizeof(serial_passthrough_t));
-    memset(dev, 0, sizeof(serial_passthrough_t));
+    dev = (serial_passthrough_t *) calloc(1, sizeof(serial_passthrough_t));
     dev->mode = device_get_config_int("mode");
 
     dev->port      = device_get_instance() - 1;

src/device/smbus_ali7101.c

@@ -273,7 +273,7 @@ smbus_ali7101_reset(void *priv)
 static void *
 smbus_ali7101_init(const device_t *info)
 {
-    smbus_ali7101_t *dev = (smbus_ali7101_t *) malloc(sizeof(smbus_ali7101_t));
+    smbus_ali7101_t *dev = (smbus_ali7101_t *) calloc(1, sizeof(smbus_ali7101_t));
     memset(dev, 0, sizeof(smbus_ali7101_t));
 
     dev->local = info->local;

src/device/smbus_piix4.c

@@ -357,8 +357,7 @@ smbus_piix4_setclock(smbus_piix4_t *dev, int clock)
 static void *
 smbus_piix4_init(const device_t *info)
 {
-    smbus_piix4_t *dev = (smbus_piix4_t *) malloc(sizeof(smbus_piix4_t));
-    memset(dev, 0, sizeof(smbus_piix4_t));
+    smbus_piix4_t *dev = (smbus_piix4_t *) calloc(1, sizeof(smbus_piix4_t));
 
     dev->local = info->local;
     /* We save the I2C bus handle on dev but use i2c_smbus for all operations because

src/device/smbus_sis5595.c

@@ -343,8 +343,7 @@ smbus_sis5595_reset(void *priv)
 static void *
 smbus_sis5595_init(const device_t *info)
 {
-    smbus_sis5595_t *dev = (smbus_sis5595_t *) malloc(sizeof(smbus_sis5595_t));
-    memset(dev, 0, sizeof(smbus_sis5595_t));
+    smbus_sis5595_t *dev = (smbus_sis5595_t *) calloc(1, sizeof(smbus_sis5595_t));
 
     dev->local        = info->local;