trivial: C99ify more for-loops

libfwupd/fwupd-device.c

@@ -216,11 +216,10 @@ gboolean
 fwupd_device_has_guid (FwupdDevice *device, const gchar *guid)
 {
 	FwupdDevicePrivate *priv = GET_PRIVATE (device);
-	guint i;
 
 	g_return_val_if_fail (FWUPD_IS_DEVICE (device), FALSE);
 
-	for (i = 0; i < priv->guids->len; i++) {
+	for (guint i = 0; i < priv->guids->len; i++) {
 		const gchar *guid_tmp = g_ptr_array_index (priv->guids, i);
 		if (g_strcmp0 (guid, guid_tmp) == 0)
 			return TRUE;
@@ -1016,10 +1015,9 @@ fwupd_device_from_key_value (FwupdDevice *device, const gchar *key, GVariant *va
 		return;
 	}
 	if (g_strcmp0 (key, FWUPD_RESULT_KEY_CHECKSUM) == 0) {
-		guint i;
 		const gchar *checksums = g_variant_get_string (value, NULL);
 		g_auto(GStrv) split = g_strsplit (checksums, ",", -1);
-		for (i = 0; split[i] != NULL; i++)
+		for (guint i = 0; split[i] != NULL; i++)
 			fwupd_device_add_checksum (device, split[i]);
 		return;
 	}
@@ -1083,11 +1081,8 @@ fwupd_pad_kv_unx (GString *str, const gchar *key, guint64 value)
 static void
 fwupd_pad_kv_dfl (GString *str, const gchar *key, guint64 device_flags)
 {
-	guint i;
+	g_autoptr(GString) tmp = g_string_new ("");
-	g_autoptr(GString) tmp = NULL;
+	for (guint i = 0; i < 64; i++) {
-
-	tmp = g_string_new ("");
-	for (i = 0; i < 64; i++) {
 		if ((device_flags & ((guint64) 1 << i)) == 0)
 			continue;
 		g_string_append_printf (tmp, "%s|",

libfwupd/fwupd-release.c

@@ -622,9 +622,8 @@ fwupd_release_to_data (FwupdRelease *release, const gchar *type_string)
 				       g_variant_new_string (priv->description));
 	}
 	if (priv->checksums->len > 0) {
-		guint i;
 		g_autoptr(GString) str = g_string_new ("");
-		for (i = 0; i < priv->checksums->len; i++) {
+		for (guint i = 0; i < priv->checksums->len; i++) {
 			const gchar *checksum = g_ptr_array_index (priv->checksums, i);
 			g_string_append_printf (str, "%s,", checksum);
 		}
@@ -759,11 +758,8 @@ fwupd_pad_kv_siz (GString *str, const gchar *key, guint64 value)
 static void
 fwupd_pad_kv_tfl (GString *str, const gchar *key, FwupdTrustFlags trust_flags)
 {
-	guint i;
+	g_autoptr(GString) tmp = g_string_new ("");
-	g_autoptr(GString) tmp = NULL;
+	for (guint i = 1; i < FWUPD_TRUST_FLAG_LAST; i *= 2) {
-
-	tmp = g_string_new ("");
-	for (i = 1; i < FWUPD_TRUST_FLAG_LAST; i *= 2) {
 		if ((trust_flags & i) == 0)
 			continue;
 		g_string_append_printf (tmp, "%s|",

libfwupd/fwupd-self-test.c

@@ -59,34 +59,31 @@ as_test_compare_lines (const gchar *txt1, const gchar *txt2, GError **error)
 static void
 fwupd_enums_func (void)
 {
-	const gchar *tmp;
-	guint64 i;
-
 	/* enums */
-	for (i = 0; i < FWUPD_ERROR_LAST; i++) {
+	for (guint i = 0; i < FWUPD_ERROR_LAST; i++) {
-		tmp = fwupd_error_to_string (i);
+		const gchar *tmp = fwupd_error_to_string (i);
 		g_assert_cmpstr (tmp, !=, NULL);
 		g_assert_cmpint (fwupd_error_from_string (tmp), ==, i);
 	}
-	for (i = 0; i < FWUPD_STATUS_LAST; i++) {
+	for (guint i = 0; i < FWUPD_STATUS_LAST; i++) {
-		tmp = fwupd_status_to_string (i);
+		const gchar *tmp = fwupd_status_to_string (i);
 		g_assert_cmpstr (tmp, !=, NULL);
 		g_assert_cmpint (fwupd_status_from_string (tmp), ==, i);
 	}
-	for (i = 0; i < FWUPD_UPDATE_STATE_LAST; i++) {
+	for (guint i = 0; i < FWUPD_UPDATE_STATE_LAST; i++) {
-		tmp = fwupd_update_state_to_string (i);
+		const gchar *tmp = fwupd_update_state_to_string (i);
 		g_assert_cmpstr (tmp, !=, NULL);
 		g_assert_cmpint (fwupd_update_state_from_string (tmp), ==, i);
 	}
-	for (i = 0; i < FWUPD_TRUST_FLAG_LAST; i++) {
+	for (guint i = 0; i < FWUPD_TRUST_FLAG_LAST; i++) {
-		tmp = fwupd_trust_flag_to_string (i);
+		const gchar *tmp = fwupd_trust_flag_to_string (i);
 		g_assert_cmpstr (tmp, !=, NULL);
 		g_assert_cmpint (fwupd_trust_flag_from_string (tmp), ==, i);
 	}
 
 	/* bitfield */
-	for (i = 1; i < FWUPD_DEVICE_FLAG_UNKNOWN; i *= 2) {
+	for (guint64 i = 1; i < FWUPD_DEVICE_FLAG_UNKNOWN; i *= 2) {
-		tmp = fwupd_device_flag_to_string (i);
+		const gchar *tmp = fwupd_device_flag_to_string (i);
 		if (tmp == NULL)
 			break;
 		g_assert_cmpint (fwupd_device_flag_from_string (tmp), ==, i);

plugins/altos/fu-altos-tool.c

@@ -36,9 +36,7 @@ fu_altos_tool_write_progress_cb (goffset current, goffset total, gpointer user_d
 int
 main (int argc, char **argv)
 {
-
 	gsize len;
-	guint i;
 	g_autofree guint8 *data = NULL;
 	g_autoptr(FuDeviceAltos) dev = NULL;
 	g_autoptr(GBytes) fw = NULL;
@@ -62,7 +60,7 @@ main (int argc, char **argv)
 	}
 	g_usb_context_enumerate (usb_ctx);
 	devices = g_usb_context_get_devices (usb_ctx);
-	for (i = 0; i < devices->len; i++) {
+	for (guint i = 0; i < devices->len; i++) {
 		GUsbDevice *usb_dev_tmp = g_ptr_array_index (devices, i);
 		g_autoptr(FuDeviceAltos) dev_tmp = fu_device_altos_new (usb_dev_tmp);
 		if (dev_tmp == NULL)

plugins/dfu/dfu-cipher-xtea.c

@@ -53,7 +53,6 @@ dfu_cipher_uint32_to_buf (guint8 *buf, guint buflen, const guint32 *array)
 static gboolean
 dfu_tool_parse_xtea_key (const gchar *key, guint32 *keys, GError **error)
 {
-	guint i;
 	gsize key_len;
 
 	/* too long */
@@ -69,7 +68,7 @@ dfu_tool_parse_xtea_key (const gchar *key, guint32 *keys, GError **error)
 
 	/* parse 4x32b values or generate a hash */
 	if (key_len == 32) {
-		for (i = 0; i < 4; i++) {
+		for (guint8 i = 0; i < 4; i++) {
 			gchar buf[] = "xxxxxxxx";
 			gchar *endptr;
 			guint64 tmp;
@@ -123,8 +122,6 @@ dfu_cipher_decrypt_xtea (const gchar *key,
 	guint32 sum;
 	guint32 v0;
 	guint32 v1;
-	guint8 i;
-	guint j;
 	guint32 chunks = length / 4;
 	guint32 keys[4];
 	g_autofree guint32 *tmp = NULL;
@@ -156,11 +153,11 @@ dfu_cipher_decrypt_xtea (const gchar *key,
 	dfu_cipher_buf_to_uint32 (data, length, tmp);
 
 	/* process buffer using XTEA keys */
-	for (j = 0; j < chunks; j += 2) {
+	for (guint j = 0; j < chunks; j += 2) {
 		v0 = tmp[j];
 		v1 = tmp[j+1];
 		sum = XTEA_DELTA * XTEA_NUM_ROUNDS;
-		for (i = 0; i < XTEA_NUM_ROUNDS; i++) {
+		for (guint8 i = 0; i < XTEA_NUM_ROUNDS; i++) {
 			v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + keys[(sum >> 11) & 3]);
 			sum -= XTEA_DELTA;
 			v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + keys[sum & 3]);
@@ -194,8 +191,6 @@ dfu_cipher_encrypt_xtea (const gchar *key,
 	guint32 sum;
 	guint32 v0;
 	guint32 v1;
-	guint8 i;
-	guint j;
 	guint32 chunks = length / 4;
 	guint32 keys[4];
 	g_autofree guint32 *tmp = NULL;
@@ -227,11 +222,11 @@ dfu_cipher_encrypt_xtea (const gchar *key,
 	dfu_cipher_buf_to_uint32 (data, length, tmp);
 
 	/* process buffer using XTEA keys */
-	for (j = 0; j < chunks; j += 2) {
+	for (guint j = 0; j < chunks; j += 2) {
 		sum = 0;
 		v0 = tmp[j];
 		v1 = tmp[j+1];
-		for (i = 0; i < XTEA_NUM_ROUNDS; i++) {
+		for (guint8 i = 0; i < XTEA_NUM_ROUNDS; i++) {
 			v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + keys[sum & 3]);
 			sum += XTEA_DELTA;
 			v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + keys[(sum >> 11) & 3]);

plugins/dfu/dfu-context.c

@@ -151,12 +151,10 @@ static DfuContextItem *
 dfu_context_find_item_by_platform_id (DfuContext *context, const gchar *platform_id)
 {
 	DfuContextPrivate *priv = GET_PRIVATE (context);
-	DfuContextItem *item;
-	guint i;
 
 	/* do we have this device */
-	for (i = 0; i < priv->devices->len; i++) {
+	for (guint i = 0; i < priv->devices->len; i++) {
-		item = g_ptr_array_index (priv->devices, i);
+		DfuContextItem *item = g_ptr_array_index (priv->devices, i);
 		if (g_strcmp0 (dfu_device_get_platform_id (item->device), platform_id) == 0)
 			return item;
 	}
@@ -413,15 +411,13 @@ GPtrArray *
 dfu_context_get_devices (DfuContext *context)
 {
 	DfuContextPrivate *priv = GET_PRIVATE (context);
-	DfuContextItem *item;
 	GPtrArray *devices;
-	guint i;
 
 	g_return_val_if_fail (DFU_IS_CONTEXT (context), NULL);
 
 	devices = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
-	for (i = 0; i < priv->devices->len; i++) {
+	for (guint i = 0; i < priv->devices->len; i++) {
-		item = g_ptr_array_index (priv->devices, i);
+		DfuContextItem *item = g_ptr_array_index (priv->devices, i);
 		g_ptr_array_add (devices, g_object_ref (item->device));
 	}
 	return devices;
@@ -445,20 +441,17 @@ dfu_context_get_device_by_vid_pid (DfuContext *context,
 				   GError **error)
 {
 	DfuContextPrivate *priv = GET_PRIVATE (context);
-	DfuContextItem *item;
 	DfuDevice *device = NULL;
-	GUsbDevice *dev;
-	guint i;
 
 	g_return_val_if_fail (DFU_IS_CONTEXT (context), NULL);
 	g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 
 	/* search all devices */
-	for (i = 0; i < priv->devices->len; i++) {
+	for (guint i = 0; i < priv->devices->len; i++) {
 
 		/* match */
-		item = g_ptr_array_index (priv->devices, i);
+		DfuContextItem *item = g_ptr_array_index (priv->devices, i);
-		dev = dfu_device_get_usb_dev (item->device);
+		GUsbDevice *dev = dfu_device_get_usb_dev (item->device);
 		if (g_usb_device_get_vid (dev) == vid &&
 		    g_usb_device_get_pid (dev) == pid) {
 			if (device != NULL) {
@@ -500,15 +493,13 @@ dfu_context_get_device_by_platform_id (DfuContext *context,
 				       GError **error)
 {
 	DfuContextPrivate *priv = GET_PRIVATE (context);
-	DfuContextItem *item;
-	guint i;
 
 	g_return_val_if_fail (DFU_IS_CONTEXT (context), NULL);
 	g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 
 	/* search all devices */
-	for (i = 0; i < priv->devices->len; i++) {
+	for (guint i = 0; i < priv->devices->len; i++) {
-		item = g_ptr_array_index (priv->devices, i);
+		DfuContextItem *item = g_ptr_array_index (priv->devices, i);
 		if (g_strcmp0 (dfu_device_get_platform_id (item->device),
 			       platform_id) == 0) {
 			return g_object_ref (item->device);

plugins/dfu/dfu-device.c

@@ -373,8 +373,6 @@ static gboolean
 dfu_device_add_targets (DfuDevice *device)
 {
 	DfuDevicePrivate *priv = GET_PRIVATE (device);
-	guint i;
-	GUsbInterface *iface;
 	g_autoptr(GPtrArray) ifaces = NULL;
 
 	/* add all DFU-capable targets */
@@ -382,10 +380,10 @@ dfu_device_add_targets (DfuDevice *device)
 	if (ifaces == NULL)
 		return FALSE;
 	g_ptr_array_set_size (priv->targets, 0);
-	for (i = 0; i < ifaces->len; i++) {
+	for (guint i = 0; i < ifaces->len; i++) {
 		GBytes *iface_data = NULL;
 		DfuTarget *target;
-		iface = g_ptr_array_index (ifaces, i);
+		GUsbInterface *iface = g_ptr_array_index (ifaces, i);
 		if (g_usb_interface_get_class (iface) != G_USB_DEVICE_CLASS_APPLICATION_SPECIFIC)
 			continue;
 		if (g_usb_interface_get_subclass (iface) != 0x01)
@@ -725,15 +723,13 @@ dfu_device_get_target_by_alt_setting (DfuDevice *device,
 				      GError **error)
 {
 	DfuDevicePrivate *priv = GET_PRIVATE (device);
-	DfuTarget *target;
-	guint i;
 
 	g_return_val_if_fail (DFU_IS_DEVICE (device), NULL);
 	g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 
 	/* find by ID */
-	for (i = 0; i < priv->targets->len; i++) {
+	for (guint i = 0; i < priv->targets->len; i++) {
-		target = g_ptr_array_index (priv->targets, i);
+		DfuTarget *target = g_ptr_array_index (priv->targets, i);
 		if (dfu_target_get_alt_setting (target) == alt_setting)
 			return g_object_ref (target);
 	}
@@ -763,15 +759,13 @@ dfu_device_get_target_by_alt_name (DfuDevice *device,
 				   GError **error)
 {
 	DfuDevicePrivate *priv = GET_PRIVATE (device);
-	DfuTarget *target;
-	guint i;
 
 	g_return_val_if_fail (DFU_IS_DEVICE (device), NULL);
 	g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 
 	/* find by ID */
-	for (i = 0; i < priv->targets->len; i++) {
+	for (guint i = 0; i < priv->targets->len; i++) {
-		target = g_ptr_array_index (priv->targets, i);
+		DfuTarget *target = g_ptr_array_index (priv->targets, i);
 		if (g_strcmp0 (dfu_target_get_alt_name (target, NULL), alt_name) == 0)
 			return g_object_ref (target);
 	}
@@ -1747,7 +1741,6 @@ dfu_device_upload (DfuDevice *device,
 		   GError **error)
 {
 	DfuDevicePrivate *priv = GET_PRIVATE (device);
-	guint i;
 	g_autoptr(DfuFirmware) firmware = NULL;
 
 	/* no backing USB device */
@@ -1792,7 +1785,7 @@ dfu_device_upload (DfuDevice *device,
 	}
 
 	/* upload from each target */
-	for (i = 0; i < priv->targets->len; i++) {
+	for (guint i = 0; i < priv->targets->len; i++) {
 		DfuTarget *target;
 		const gchar *alt_name;
 		gulong id1;
@@ -1899,7 +1892,6 @@ dfu_device_download (DfuDevice *device,
 	DfuDevicePrivate *priv = GET_PRIVATE (device);
 	GPtrArray *images;
 	gboolean ret;
-	guint i;
 
 	/* no backing USB device */
 	if (priv->dev == NULL) {
@@ -1999,7 +1991,7 @@ dfu_device_download (DfuDevice *device,
 				     "no images in firmware file");
 		return FALSE;
 	}
-	for (i = 0; i < images->len; i++) {
+	for (guint i = 0; i < images->len; i++) {
 		DfuCipherKind cipher_fw;
 		DfuCipherKind cipher_target;
 		DfuImage *image;

plugins/dfu/dfu-firmware.c

@@ -120,14 +120,12 @@ DfuImage *
 dfu_firmware_get_image (DfuFirmware *firmware, guint8 alt_setting)
 {
 	DfuFirmwarePrivate *priv = GET_PRIVATE (firmware);
-	DfuImage *im;
-	guint i;
 
 	g_return_val_if_fail (DFU_IS_FIRMWARE (firmware), NULL);
 
 	/* find correct image */
-	for (i = 0; i < priv->images->len; i++) {
+	for (guint i = 0; i < priv->images->len; i++) {
-		im = g_ptr_array_index (priv->images, i);
+		DfuImage *im = g_ptr_array_index (priv->images, i);
 		if (dfu_image_get_alt_setting (im) == alt_setting)
 			return im;
 	}
@@ -147,14 +145,12 @@ DfuImage *
 dfu_firmware_get_image_by_name (DfuFirmware *firmware, const gchar *name)
 {
 	DfuFirmwarePrivate *priv = GET_PRIVATE (firmware);
-	DfuImage *im;
-	guint i;
 
 	g_return_val_if_fail (DFU_IS_FIRMWARE (firmware), NULL);
 
 	/* find correct image */
-	for (i = 0; i < priv->images->len; i++) {
+	for (guint i = 0; i < priv->images->len; i++) {
-		im = g_ptr_array_index (priv->images, i);
+		DfuImage *im = g_ptr_array_index (priv->images, i);
 		if (g_strcmp0 (dfu_image_get_name (im), name) == 0)
 			return im;
 	}
@@ -211,9 +207,8 @@ dfu_firmware_get_size (DfuFirmware *firmware)
 {
 	DfuFirmwarePrivate *priv = GET_PRIVATE (firmware);
 	guint32 length = 0;
-	guint i;
 	g_return_val_if_fail (DFU_IS_FIRMWARE (firmware), 0);
-	for (i = 0; i < priv->images->len; i++) {
+	for (guint i = 0; i < priv->images->len; i++) {
 		DfuImage *image = g_ptr_array_index (priv->images, i);
 		length += dfu_image_get_size (image);
 	}
@@ -649,9 +644,7 @@ dfu_firmware_to_string (DfuFirmware *firmware)
 {
 	DfuFirmwarePrivate *priv = GET_PRIVATE (firmware);
 	DfuImage *image;
-	GList *l;
 	GString *str;
-	guint i;
 	g_autofree gchar *release_str = NULL;
 	g_autoptr(GList) keys = NULL;
 
@@ -672,16 +665,15 @@ dfu_firmware_to_string (DfuFirmware *firmware)
 
 	/* print metadata */
 	keys = g_hash_table_get_keys (priv->metadata);
-	for (l = keys; l != NULL; l = l->next) {
+	for (GList *l = keys; l != NULL; l = l->next) {
-		const gchar *key;
+		const gchar *key = l->data;
 		const gchar *value;
-		key = l->data;
 		value = g_hash_table_lookup (priv->metadata, key);
 		g_string_append_printf (str, "metadata:    %s=%s\n", key, value);
 	}
 
 	/* print images */
-	for (i = 0; i < priv->images->len; i++) {
+	for (guint i = 0; i < priv->images->len; i++) {
 		g_autofree gchar *tmp = NULL;
 		image = g_ptr_array_index (priv->images, i);
 		tmp = dfu_image_to_string (image);

plugins/dfu/dfu-format-dfu.c

@@ -128,9 +128,8 @@ static guint32 _crctbl[] = {
 static guint32
 dfu_firmware_generate_crc32 (const guint8 *data, gsize length)
 {
-	guint i;
 	guint32 accum = 0xffffffff;
-	for (i = 0; i < length; i++)
+	for (guint i = 0; i < length; i++)
 		accum = _crctbl[(accum^data[i]) & 0xff] ^ (accum >> 8);
 	return accum;
 }

plugins/dfu/dfu-format-dfuse.c

@@ -150,7 +150,6 @@ dfu_image_from_dfuse (const guint8 *data,
 	DfuSeImagePrefix *im;
 	guint32 elements;
 	guint32 offset = sizeof(DfuSeImagePrefix);
-	guint j;
 	g_autoptr(DfuImage) image = NULL;
 
 	g_assert_cmpint(sizeof(DfuSeImagePrefix), ==, 274);
@@ -184,7 +183,7 @@ dfu_image_from_dfuse (const guint8 *data,
 	/* parse elements */
 	length -= offset;
 	elements = GUINT32_FROM_LE (im->elements);
-	for (j = 0; j < elements; j++) {
+	for (guint j = 0; j < elements; j++) {
 		guint32 consumed_local;
 		g_autoptr(DfuElement) element = NULL;
 		element = dfu_element_from_dfuse (data + offset, length,
@@ -214,22 +213,19 @@ dfu_image_from_dfuse (const guint8 *data,
 static GBytes *
 dfu_image_to_dfuse (DfuImage *image)
 {
-	DfuElement *element;
 	DfuSeImagePrefix *im;
-	GBytes *bytes;
 	GPtrArray *elements;
 	guint32 length_total = 0;
 	guint32 offset = sizeof (DfuSeImagePrefix);
 	guint8 *buf;
-	guint i;
 	g_autoptr(GPtrArray) element_array = NULL;
 
 	/* get total size */
 	element_array = g_ptr_array_new_with_free_func ((GDestroyNotify) g_bytes_unref);
 	elements = dfu_image_get_elements (image);
-	for (i = 0; i < elements->len; i++) {
+	for (guint i = 0; i < elements->len; i++) {
-		element = g_ptr_array_index (elements, i);
+		DfuElement *element = g_ptr_array_index (elements, i);
-		bytes = dfu_element_to_dfuse (element);
+		GBytes *bytes = dfu_element_to_dfuse (element);
 		g_ptr_array_add (element_array, bytes);
 		length_total += (guint32) g_bytes_get_size (bytes);
 	}
@@ -247,11 +243,10 @@ dfu_image_to_dfuse (DfuImage *image)
 	im->elements = GUINT32_TO_LE (elements->len);
 
 	/* copy data */
-	for (i = 0; i < element_array->len; i++) {
+	for (guint i = 0; i < element_array->len; i++) {
-		const guint8 *data;
 		gsize length;
-		bytes = g_ptr_array_index (element_array, i);
+		GBytes *bytes = g_ptr_array_index (element_array, i);
-		data = g_bytes_get_data (bytes, &length);
+		const guint8 *data = g_bytes_get_data (bytes, &length);
 		memcpy (buf + offset, data, length);
 		offset += (guint32) length;
 	}
@@ -280,7 +275,6 @@ dfu_firmware_to_dfuse (DfuFirmware *firmware, GError **error)
 {
 	DfuSePrefix *prefix;
 	GPtrArray *images;
-	guint i;
 	guint32 image_size_total = 0;
 	guint32 offset = sizeof (DfuSePrefix);
 	g_autofree guint8 *buf = NULL;
@@ -289,7 +283,7 @@ dfu_firmware_to_dfuse (DfuFirmware *firmware, GError **error)
 	/* get all the image data */
 	dfuse_images = g_ptr_array_new_with_free_func ((GDestroyNotify) g_bytes_unref);
 	images = dfu_firmware_get_images (firmware);
-	for (i = 0; i < images->len; i++) {
+	for (guint i = 0; i < images->len; i++) {
 		DfuImage *im = g_ptr_array_index (images, i);
 		GBytes *contents;
 		contents = dfu_image_to_dfuse (im);
@@ -316,7 +310,7 @@ dfu_firmware_to_dfuse (DfuFirmware *firmware, GError **error)
 	prefix->targets = (guint8) images->len;
 
 	/* copy images */
-	for (i = 0; i < dfuse_images->len; i++) {
+	for (guint i = 0; i < dfuse_images->len; i++) {
 		GBytes *contents = g_ptr_array_index (dfuse_images, i);
 		gsize length;
 		const guint8 *data;
@@ -350,7 +344,6 @@ dfu_firmware_from_dfuse (DfuFirmware *firmware,
 	gsize len;
 	guint32 offset = sizeof(DfuSePrefix);
 	guint8 *data;
-	guint i;
 
 	/* check the prefix (BE) */
 	data = (guint8 *) g_bytes_get_data (bytes, &len);
@@ -388,7 +381,7 @@ dfu_firmware_from_dfuse (DfuFirmware *firmware,
 
 	/* parse the image targets */
 	len -= sizeof(DfuSePrefix);
-	for (i = 0; i < prefix->targets; i++) {
+	for (guint i = 0; i < prefix->targets; i++) {
 		guint consumed;
 		g_autoptr(DfuImage) image = NULL;
 		image = dfu_image_from_dfuse (data + offset, (guint32) len,

plugins/dfu/dfu-format-ihex.c

@@ -104,8 +104,6 @@ dfu_firmware_from_ihex (DfuFirmware *firmware,
 	guint8 len_tmp;
 	guint8 type;
 	guint end;
-	guint i;
-	guint j;
 	guint offset = 0;
 	g_autoptr(DfuElement) element = NULL;
 	g_autoptr(DfuImage) image = NULL;
@@ -164,7 +162,7 @@ dfu_firmware_from_ihex (DfuFirmware *firmware,
 		/* verify checksum */
 		if ((flags & DFU_FIRMWARE_PARSE_FLAG_NO_CRC_TEST) == 0) {
 			checksum = 0;
-			for (i = offset + 1; i < end + 2; i += 2) {
+			for (guint i = offset + 1; i < end + 2; i += 2) {
 				data_tmp = dfu_firmware_ihex_parse_uint8 (in_buffer, i);
 				checksum += data_tmp;
 			}
@@ -204,11 +202,11 @@ dfu_firmware_from_ihex (DfuFirmware *firmware,
 
 			/* parse bytes from line */
 			g_debug ("writing data 0x%08x", (guint32) addr32);
-			for (i = offset + 9; i < end; i += 2) {
+			for (guint i = offset + 9; i < end; i += 2) {
 				/* any holes in the hex record */
 				guint32 len_hole = addr32 - addr32_last;
 				if (addr32_last > 0x0 && len_hole > 1) {
-					for (j = 1; j < len_hole; j++) {
+					for (guint j = 1; j < len_hole; j++) {
 						g_debug ("filling address 0x%08x",
 							 addr32_last + j);
 						/* although 0xff might be clearer,
@@ -238,7 +236,7 @@ dfu_firmware_from_ihex (DfuFirmware *firmware,
 			addr32 = ((guint32) addr_high << 16) + addr_low;
 			break;
 		case DFU_INHX32_RECORD_TYPE_SIGNATURE:
-			for (i = offset + 9; i < end; i += 2) {
+			for (guint i = offset + 9; i < end; i += 2) {
 				guint8 tmp_c = dfu_firmware_ihex_parse_uint8 (in_buffer, i);
 				g_string_append_c (signature, tmp_c);
 			}

plugins/dfu/dfu-format-metadata.c

@@ -59,7 +59,6 @@ dfu_firmware_from_metadata (DfuFirmware *firmware,
 {
 	const guint8 *data;
 	gsize data_length;
-	guint i;
 	guint idx = 2;
 	guint kvlen;
 	guint number_keys;
@@ -75,7 +74,7 @@ dfu_firmware_from_metadata (DfuFirmware *firmware,
 
 	/* parse key=value store */
 	number_keys = data[idx++];
-	for (i = 0; i < number_keys; i++) {
+	for (guint i = 0; i < number_keys; i++) {
 		g_autofree gchar *key = NULL;
 		g_autofree gchar *value = NULL;
 
@@ -137,7 +136,6 @@ dfu_firmware_from_metadata (DfuFirmware *firmware,
 GBytes *
 dfu_firmware_to_metadata (DfuFirmware *firmware, GError **error)
 {
-	GList *l;
 	GHashTable *metadata;
 	guint8 mdbuf[239];
 	guint idx = 0;
@@ -165,7 +163,7 @@ dfu_firmware_to_metadata (DfuFirmware *firmware, GError **error)
 	mdbuf[idx++] = 'M';
 	mdbuf[idx++] = 'D';
 	mdbuf[idx++] = (guint8) number_keys;
-	for (l = keys; l != NULL; l = l->next) {
+	for (GList *l = keys; l != NULL; l = l->next) {
 		const gchar *key;
 		const gchar *value;
 		guint key_len;

plugins/dfu/dfu-image.c

@@ -191,9 +191,8 @@ dfu_image_get_size (DfuImage *image)
 {
 	DfuImagePrivate *priv = GET_PRIVATE (image);
 	guint32 length = 0;
-	guint i;
 	g_return_val_if_fail (DFU_IS_IMAGE (image), 0);
-	for (i = 0; i < priv->elements->len; i++) {
+	for (guint i = 0; i < priv->elements->len; i++) {
 		DfuElement *element = g_ptr_array_index (priv->elements, i);
 		length += (guint32) g_bytes_get_size (dfu_element_get_contents (element));
 	}
@@ -270,7 +269,6 @@ dfu_image_to_string (DfuImage *image)
 {
 	DfuImagePrivate *priv = GET_PRIVATE (image);
 	GString *str;
-	guint i;
 
 	g_return_val_if_fail (DFU_IS_IMAGE (image), NULL);
 
@@ -282,7 +280,7 @@ dfu_image_to_string (DfuImage *image)
 				priv->elements->len);
 
 	/* add elements */
-	for (i = 0; i < priv->elements->len; i++) {
+	for (guint i = 0; i < priv->elements->len; i++) {
 		DfuElement *element = g_ptr_array_index (priv->elements, i);
 		g_autofree gchar *tmp = NULL;
 		tmp = dfu_element_to_string (element);

plugins/dfu/dfu-progress-bar.c

@@ -83,7 +83,6 @@ static gboolean
 dfu_progress_bar_draw (DfuProgressBar *self, gint percentage)
 {
 	guint section;
-	guint i;
 	GString *str;
 
 	/* no value yet */
@@ -96,9 +95,9 @@ dfu_progress_bar_draw (DfuProgressBar *self, gint percentage)
 
 	section = (guint) ((gfloat) self->size / (gfloat) 100.0 * (gfloat) percentage);
 	g_string_append (str, "[");
-	for (i = 0; i < section; i++)
+	for (guint i = 0; i < section; i++)
 		g_string_append (str, "=");
-	for (i = 0; i < self->size - section; i++)
+	for (guint i = 0; i < self->size - section; i++)
 		g_string_append (str, " ");
 	g_string_append (str, "] ");
 	if (percentage >= 0 && percentage < 100)

plugins/dfu/dfu-self-test.c

@@ -84,7 +84,6 @@ _g_bytes_compare_verbose (GBytes *bytes1, GBytes *bytes2)
 	const guint8 *data2;
 	gsize length1;
 	gsize length2;
-	guint i;
 
 	data1 = g_bytes_get_data (bytes1, &length1);
 	data2 = g_bytes_get_data (bytes2, &length2);
@@ -97,7 +96,7 @@ _g_bytes_compare_verbose (GBytes *bytes1, GBytes *bytes2)
 	}
 
 	/* return 00 01 02 03 */
-	for (i = 0; i < length1; i++) {
+	for (guint i = 0; i < length1; i++) {
 		if (data1[i] != data2[i]) {
 			return g_strdup_printf ("got 0x%02x, expected 0x%02x @ 0x%04x",
 						data1[i], data2[i], i);
@@ -164,10 +163,9 @@ dfu_firmware_xdfu_func (void)
 static void
 dfu_enums_func (void)
 {
-	guint i;
+	for (guint i = 0; i < DFU_STATE_LAST; i++)
-	for (i = 0; i < DFU_STATE_LAST; i++)
 		g_assert_cmpstr (dfu_state_to_string (i), !=, NULL);
-	for (i = 0; i < DFU_STATUS_LAST; i++)
+	for (guint i = 0; i < DFU_STATUS_LAST; i++)
 		g_assert_cmpstr (dfu_status_to_string (i), !=, NULL);
 }
 
@@ -188,7 +186,6 @@ dfu_firmware_raw_func (void)
 	DfuImage *image_tmp;
 	GBytes *no_suffix_contents;
 	gchar buf[256];
-	guint i;
 	gboolean ret;
 	g_autoptr(DfuFirmware) firmware = NULL;
 	g_autoptr(GBytes) fw = NULL;
@@ -196,7 +193,7 @@ dfu_firmware_raw_func (void)
 	g_autoptr(GError) error = NULL;
 
 	/* set up some dummy data */
-	for (i = 0; i < 256; i++)
+	for (guint i = 0; i < 256; i++)
 		buf[i] = (gchar) i;
 	fw = g_bytes_new_static (buf, 256);
 
@@ -232,7 +229,6 @@ static void
 dfu_firmware_dfu_func (void)
 {
 	gchar buf[256];
-	guint i;
 	gboolean ret;
 	g_autofree gchar *filename = NULL;
 	g_autoptr(DfuFirmware) firmware = NULL;
@@ -246,7 +242,7 @@ dfu_firmware_dfu_func (void)
 	g_autoptr(GFile) file = NULL;
 
 	/* set up some dummy data */
-	for (i = 0; i < 256; i++)
+	for (guint i = 0; i < 256; i++)
 		buf[i] = (gchar) i;
 	fw = g_bytes_new_static (buf, 256);
 
@@ -674,17 +670,14 @@ dfu_colorhug_plus_func (void)
 static gchar *
 dfu_target_sectors_to_string (DfuTarget *target)
 {
-	DfuSector *sector;
 	GPtrArray *sectors;
 	GString *str;
-	guint i;
 
 	str = g_string_new ("");
 	sectors = dfu_target_get_sectors (target);
-	for (i = 0; i < sectors->len; i++) {
+	for (guint i = 0; i < sectors->len; i++) {
-		g_autofree gchar *tmp = NULL;
+		DfuSector *sector = g_ptr_array_index (sectors, i);
-		sector = g_ptr_array_index (sectors, i);
+		g_autofree gchar *tmp = dfu_sector_to_string (sector);
-		tmp = dfu_sector_to_string (sector);
 		g_string_append_printf (str, "%s\n", tmp);
 	}
 	if (str->len > 0)

plugins/dfu/dfu-target.c

@@ -147,15 +147,10 @@ static gchar *
 dfu_target_sectors_to_string (DfuTarget *target)
 {
 	DfuTargetPrivate *priv = GET_PRIVATE (target);
-	DfuSector *sector;
+	GString *str = g_string_new ("");
-	GString *str;
+	for (guint i = 0; i < priv->sectors->len; i++) {
-	guint i;
+		DfuSector *sector = g_ptr_array_index (priv->sectors, i);
-
+		g_autofree gchar *tmp = dfu_sector_to_string (sector);
-	str = g_string_new ("");
-	for (i = 0; i < priv->sectors->len; i++) {
-		g_autofree gchar *tmp = NULL;
-		sector = g_ptr_array_index (priv->sectors, i);
-		tmp = dfu_sector_to_string (sector);
 		g_string_append_printf (str, "%s\n", tmp);
 	}
 	if (str->len > 0)
@@ -167,11 +162,9 @@ static DfuSector *
 dfu_target_get_sector_for_addr (DfuTarget *target, guint32 addr)
 {
 	DfuTargetPrivate *priv = GET_PRIVATE (target);
-	DfuSector *sector;
-	guint i;
 
-	for (i = 0; i < priv->sectors->len; i++) {
+	for (guint i = 0; i < priv->sectors->len; i++) {
-		sector = g_ptr_array_index (priv->sectors, i);
+		DfuSector *sector = g_ptr_array_index (priv->sectors, i);
 		if (addr < dfu_sector_get_address (sector))
 			continue;
 		if (addr > dfu_sector_get_address (sector) +
@@ -196,7 +189,6 @@ dfu_target_parse_sector (DfuTarget *target,
 	guint32 addr_offset = 0;
 	guint64 nr_sectors;
 	guint64 sector_size;
-	guint i;
 
 	/* parse # of sectors */
 	nr_sectors = g_ascii_strtoull (dfuse_sector_id, &tmp, 10);
@@ -288,7 +280,7 @@ dfu_target_parse_sector (DfuTarget *target,
 	}
 
 	/* add all the sectors */
-	for (i = 0; i < nr_sectors; i++) {
+	for (guint i = 0; i < nr_sectors; i++) {
 		DfuSector *sector;
 		sector = dfu_sector_new (*addr + addr_offset,
 					 (guint32) sector_size,
@@ -960,17 +952,16 @@ _g_bytes_array_join (GPtrArray *chunks)
 	gsize total_size = 0;
 	guint32 offset = 0;
 	guint8 *buffer;
-	guint i;
 
 	/* get the size of all the chunks */
-	for (i = 0; i < chunks->len; i++) {
+	for (guint i = 0; i < chunks->len; i++) {
 		GBytes *chunk_tmp = g_ptr_array_index (chunks, i);
 		total_size += g_bytes_get_size (chunk_tmp);
 	}
 
 	/* copy them into a buffer */
 	buffer = g_malloc0 (total_size);
-	for (i = 0; i < chunks->len; i++) {
+	for (guint i = 0; i < chunks->len; i++) {
 		const guint8 *chunk_data;
 		gsize chunk_size = 0;
 		GBytes *chunk_tmp = g_ptr_array_index (chunks, i);
@@ -999,7 +990,6 @@ dfu_target_upload_element_dfuse (DfuTarget *target,
 	guint percentage_size = expected_size > 0 ? expected_size : maximum_size;
 	gsize total_size = 0;
 	guint16 transfer_size = dfu_device_get_transfer_size (priv->device);
-	guint idx;
 	g_autoptr(GBytes) contents = NULL;
 	g_autoptr(GBytes) contents_truncated = NULL;
 	g_autoptr(GPtrArray) chunks = NULL;
@@ -1043,7 +1033,7 @@ dfu_target_upload_element_dfuse (DfuTarget *target,
 
 	/* get all the chunks from the hardware */
 	chunks = g_ptr_array_new_with_free_func ((GDestroyNotify) g_bytes_unref);
-	for (idx = 0; idx < G_MAXUINT16; idx++) {
+	for (guint idx = 0; idx < G_MAXUINT16; idx++) {
 		guint32 chunk_size;
 
 		/* read chunk of data -- ST uses wBlockNum=0 for DfuSe commands
@@ -1126,7 +1116,6 @@ dfu_target_upload_element_dfu (DfuTarget *target,
 	guint percentage_size = expected_size > 0 ? expected_size : maximum_size;
 	gsize total_size = 0;
 	guint16 transfer_size = dfu_device_get_transfer_size (priv->device);
-	guint idx;
 	g_autoptr(GBytes) contents = NULL;
 	g_autoptr(GPtrArray) chunks = NULL;
 
@@ -1135,7 +1124,7 @@ dfu_target_upload_element_dfu (DfuTarget *target,
 
 	/* get all the chunks from the hardware */
 	chunks = g_ptr_array_new_with_free_func ((GDestroyNotify) g_bytes_unref);
-	for (idx = 0; idx < G_MAXUINT16; idx++) {
+	for (guint idx = 0; idx < G_MAXUINT16; idx++) {
 		guint32 chunk_size;
 
 		/* read chunk of data */
@@ -1218,9 +1207,8 @@ static guint32
 dfu_target_get_size_of_zone (DfuTarget *target, guint16 zone)
 {
 	DfuTargetPrivate *priv = GET_PRIVATE (target);
-	guint i;
 	guint32 len = 0;
-	for (i = 0; i < priv->sectors->len; i++) {
+	for (guint i = 0; i < priv->sectors->len; i++) {
 		DfuSector *sector = g_ptr_array_index (priv->sectors, i);
 		if (dfu_sector_get_zone (sector) != zone)
 			continue;
@@ -1248,7 +1236,6 @@ dfu_target_upload (DfuTarget *target,
 {
 	DfuTargetPrivate *priv = GET_PRIVATE (target);
 	DfuSector *sector;
-	guint i;
 	guint16 zone_cur;
 	guint32 zone_size = 0;
 	guint32 zone_last = G_MAXUINT;
@@ -1289,7 +1276,7 @@ dfu_target_upload (DfuTarget *target,
 	dfu_image_set_alt_setting (image, priv->alt_setting);
 
 	/* get all the sectors for the device */
-	for (i = 0; i < priv->sectors->len; i++) {
+	for (guint i = 0; i < priv->sectors->len; i++) {
 		g_autoptr(DfuElement) element = NULL;
 
 		/* only upload to the start of any zone:sector */
@@ -1347,7 +1334,6 @@ _g_bytes_compare_verbose (GBytes *bytes1, GBytes *bytes2)
 	const guint8 *data2;
 	gsize length1;
 	gsize length2;
-	guint i;
 
 	data1 = g_bytes_get_data (bytes1, &length1);
 	data2 = g_bytes_get_data (bytes2, &length2);
@@ -1360,7 +1346,7 @@ _g_bytes_compare_verbose (GBytes *bytes1, GBytes *bytes2)
 	}
 
 	/* return 00 01 02 03 */
-	for (i = 0; i < length1; i++) {
+	for (guint i = 0; i < length1; i++) {
 		if (data1[i] != data2[i]) {
 			return g_strdup_printf ("got 0x%02x, expected 0x%02x @ 0x%04x",
 						data1[i], data2[i], i);
@@ -1378,7 +1364,6 @@ dfu_target_download_element_dfu (DfuTarget *target,
 {
 	DfuTargetPrivate *priv = GET_PRIVATE (target);
 	GBytes *bytes;
-	guint i;
 	guint nr_chunks;
 	guint16 transfer_size = dfu_device_get_transfer_size (priv->device);
 
@@ -1394,7 +1379,7 @@ dfu_target_download_element_dfu (DfuTarget *target,
 		return FALSE;
 	}
 	dfu_target_set_action (target, DFU_ACTION_WRITE);
-	for (i = 0; i < nr_chunks + 1; i++) {
+	for (guint i = 0; i < nr_chunks + 1; i++) {
 		gsize length;
 		guint32 offset;
 		g_autoptr(GBytes) bytes_tmp = NULL;
@@ -1442,7 +1427,6 @@ dfu_target_download_element_dfuse (DfuTarget *target,
 	DfuTargetPrivate *priv = GET_PRIVATE (target);
 	DfuSector *sector;
 	GBytes *bytes;
-	guint i;
 	guint nr_chunks;
 	guint zone_last = G_MAXUINT;
 	guint16 transfer_size = dfu_device_get_transfer_size (priv->device);
@@ -1464,7 +1448,7 @@ dfu_target_download_element_dfuse (DfuTarget *target,
 	/* 1st pass: work out which sectors need erasing */
 	sectors_array = g_ptr_array_new ();
 	sectors_hash = g_hash_table_new (g_direct_hash, g_direct_equal);
-	for (i = 0; i < nr_chunks; i++) {
+	for (guint i = 0; i < nr_chunks; i++) {
 		guint32 offset_dev;
 
 		/* for DfuSe devices we need to handle the erase and setting
@@ -1503,7 +1487,7 @@ dfu_target_download_element_dfuse (DfuTarget *target,
 
 	/* 2nd pass: actually erase sectors */
 	dfu_target_set_action (target, DFU_ACTION_ERASE);
-	for (i = 0; i < sectors_array->len; i++) {
+	for (guint i = 0; i < sectors_array->len; i++) {
 		sector = g_ptr_array_index (sectors_array, i);
 		g_debug ("erasing sector at 0x%04x",
 			 dfu_sector_get_address (sector));
@@ -1519,7 +1503,7 @@ dfu_target_download_element_dfuse (DfuTarget *target,
 
 	/* 3rd pass: write data */
 	dfu_target_set_action (target, DFU_ACTION_WRITE);
-	for (i = 0; i < nr_chunks; i++) {
+	for (guint i = 0; i < nr_chunks; i++) {
 		gsize length;
 		guint32 offset;
 		guint32 offset_dev;
@@ -1655,10 +1639,8 @@ dfu_target_download (DfuTarget *target, DfuImage *image,
 		     GError **error)
 {
 	DfuTargetPrivate *priv = GET_PRIVATE (target);
-	DfuElement *element;
 	GPtrArray *elements;
 	gboolean ret;
-	guint i;
 
 	g_return_val_if_fail (DFU_IS_TARGET (target), FALSE);
 	g_return_val_if_fail (DFU_IS_IMAGE (image), FALSE);
@@ -1690,8 +1672,8 @@ dfu_target_download (DfuTarget *target, DfuImage *image,
 				     "no image elements");
 		return FALSE;
 	}
-	for (i = 0; i < elements->len; i++) {
+	for (guint i = 0; i < elements->len; i++) {
-		element = dfu_image_get_element (image, (guint8) i);
+		DfuElement *element = dfu_image_get_element (image, (guint8) i);
 		g_debug ("downloading element at 0x%04x",
 			 dfu_element_get_address (element));
 

plugins/dfu/dfu-tool.c

@@ -51,11 +51,10 @@ typedef struct {
 static void
 dfu_tool_print_indent (const gchar *title, const gchar *message, guint indent)
 {
-	gsize i;
+	for (gsize i = 0; i < indent; i++)
-	for (i = 0; i < indent; i++)
 		g_print (" ");
 	g_print ("%s:", title);
-	for (i = strlen (title) + indent; i < 15; i++)
+	for (gsize i = strlen (title) + indent; i < 15; i++)
 		g_print (" ");
 	g_print ("%s\n", message);
 }
@@ -106,8 +105,6 @@ dfu_tool_add (GPtrArray *array,
 	      const gchar *description,
 	      FuUtilPrivateCb callback)
 {
-	guint i;
-	FuUtilItem *item;
 	g_auto(GStrv) names = NULL;
 
 	g_return_if_fail (name != NULL);
@@ -116,8 +113,8 @@ dfu_tool_add (GPtrArray *array,
 
 	/* add each one */
 	names = g_strsplit (name, ",", -1);
-	for (i = 0; names[i] != NULL; i++) {
+	for (guint i = 0; names[i] != NULL; i++) {
-		item = g_new0 (FuUtilItem, 1);
+		FuUtilItem *item = g_new0 (FuUtilItem, 1);
 		item->name = g_strdup (names[i]);
 		if (i == 0) {
 			item->description = g_strdup (description);
@@ -135,8 +132,6 @@ dfu_tool_add (GPtrArray *array,
 static gchar *
 dfu_tool_get_descriptions (GPtrArray *array)
 {
-	guint i;
-	gsize j;
 	gsize len;
 	const gsize max_len = 31;
 	FuUtilItem *item;
@@ -144,7 +139,7 @@ dfu_tool_get_descriptions (GPtrArray *array)
 
 	/* print each command */
 	string = g_string_new ("");
-	for (i = 0; i < array->len; i++) {
+	for (guint i = 0; i < array->len; i++) {
 		item = g_ptr_array_index (array, i);
 		g_string_append (string, "  ");
 		g_string_append (string, item->name);
@@ -155,13 +150,13 @@ dfu_tool_get_descriptions (GPtrArray *array)
 			len += strlen (item->arguments) + 1;
 		}
 		if (len < max_len) {
-			for (j = len; j < max_len + 1; j++)
+			for (guint j = len; j < max_len + 1; j++)
 				g_string_append_c (string, ' ');
 			g_string_append (string, item->description);
 			g_string_append_c (string, '\n');
 		} else {
 			g_string_append_c (string, '\n');
-			for (j = 0; j < max_len + 1; j++)
+			for (guint j = 0; j < max_len + 1; j++)
 				g_string_append_c (string, ' ');
 			g_string_append (string, item->description);
 			g_string_append_c (string, '\n');
@@ -181,12 +176,9 @@ dfu_tool_run (DfuToolPrivate *priv,
 	      gchar **values,
 	      GError **error)
 {
-	guint i;
-	FuUtilItem *item;
-
 	/* find command */
-	for (i = 0; i < priv->cmd_array->len; i++) {
+	for (guint i = 0; i < priv->cmd_array->len; i++) {
-		item = g_ptr_array_index (priv->cmd_array, i);
+		FuUtilItem *item = g_ptr_array_index (priv->cmd_array, i);
 		if (g_strcmp0 (item->name, command) == 0)
 			return item->callback (priv, values, error);
 	}
@@ -439,7 +431,6 @@ static GBytes *
 dfu_tool_parse_hex_string (const gchar *val, GError **error)
 {
 	gsize result_size;
-	guint i;
 	g_autofree guint8 *result = NULL;
 
 	/* sanity check */
@@ -454,7 +445,7 @@ dfu_tool_parse_hex_string (const gchar *val, GError **error)
 	/* parse each hex byte */
 	result_size = strlen (val) / 2;
 	result = g_malloc (result_size);
-	for (i = 0; i < result_size; i++) {
+	for (guint i = 0; i < result_size; i++) {
 		gchar buf[3] = { "xx" };
 		gchar *endptr = NULL;
 		guint64 tmp;
@@ -478,7 +469,6 @@ static guint
 dfu_tool_bytes_replace (GBytes *data, GBytes *search, GBytes *replace)
 {
 	gsize data_sz;
-	gsize i;
 	gsize replace_sz;
 	gsize search_sz;
 	guint8 *data_buf;
@@ -493,7 +483,7 @@ dfu_tool_bytes_replace (GBytes *data, GBytes *search, GBytes *replace)
 	g_return_val_if_fail (search_sz == replace_sz, FALSE);
 
 	/* find and replace each one */
-	for (i = 0; i < data_sz - search_sz; i++) {
+	for (gsize i = 0; i < data_sz - search_sz; i++) {
 		if (memcmp (data_buf + i, search_buf, search_sz) == 0) {
 			g_print ("Replacing %" G_GSIZE_FORMAT " bytes @0x%04x\n",
 				 replace_sz, (guint) i);
@@ -630,8 +620,6 @@ static gboolean
 dfu_tool_replace_data (DfuToolPrivate *priv, gchar **values, GError **error)
 {
 	GPtrArray *images;
-	guint i;
-	guint j;
 	guint cnt = 0;
 	g_autoptr(DfuFirmware) firmware = NULL;
 	g_autoptr(GFile) file = NULL;
@@ -675,10 +663,10 @@ dfu_tool_replace_data (DfuToolPrivate *priv, gchar **values, GError **error)
 
 	/* get each data segment */
 	images = dfu_firmware_get_images (firmware);
-	for (i = 0; i < images->len; i++) {
+	for (guint i = 0; i < images->len; i++) {
 		DfuImage *image = g_ptr_array_index (images, i);
 		GPtrArray *elements = dfu_image_get_elements (image);
-		for (j = 0; j < elements->len; j++) {
+		for (guint j = 0; j < elements->len; j++) {
 			DfuElement *element = g_ptr_array_index (elements, j);
 			GBytes *contents = dfu_element_get_contents (element);
 			if (contents == NULL)
@@ -1020,7 +1008,6 @@ dfu_tool_merge (DfuToolPrivate *priv, gchar **values, GError **error)
 	guint16 pid = 0xffff;
 	guint16 rel = 0xffff;
 	guint16 vid = 0xffff;
-	guint i;
 	g_autofree gchar *str_debug = NULL;
 	g_autoptr(DfuFirmware) firmware = NULL;
 	g_autoptr(GFile) file = NULL;
@@ -1039,9 +1026,8 @@ dfu_tool_merge (DfuToolPrivate *priv, gchar **values, GError **error)
 	/* parse source files */
 	firmware = dfu_firmware_new ();
 	dfu_firmware_set_format (firmware, DFU_FIRMWARE_FORMAT_DFUSE);
-	for (i = 1; values[i] != NULL; i++) {
+	for (guint i = 1; values[i] != NULL; i++) {
 		GPtrArray *images;
-		guint j;
 		g_autoptr(GFile) file_tmp = NULL;
 		g_autoptr(DfuFirmware) firmware_tmp = NULL;
 
@@ -1092,7 +1078,7 @@ dfu_tool_merge (DfuToolPrivate *priv, gchar **values, GError **error)
 
 		/* add all images to destination */
 		images = dfu_firmware_get_images (firmware_tmp);
-		for (j = 0; j < images->len; j++) {
+		for (guint j = 0; j < images->len; j++) {
 			DfuImage *image;
 			guint8 alt_id;
 
@@ -1720,8 +1706,6 @@ dfu_tool_decrypt (DfuToolPrivate *priv, gchar **values, GError **error)
 static gboolean
 dfu_tool_watch (DfuToolPrivate *priv, gchar **values, GError **error)
 {
-	guint i;
-	DfuDevice *device;
 	g_autoptr(DfuContext) dfu_context = NULL;
 	g_autoptr(GMainLoop) loop = NULL;
 	g_autoptr(GPtrArray) devices = NULL;
@@ -1732,8 +1716,8 @@ dfu_tool_watch (DfuToolPrivate *priv, gchar **values, GError **error)
 
 	/* print what's already attached */
 	devices = dfu_context_get_devices (dfu_context);
-	for (i = 0; i < devices->len; i++) {
+	for (guint i = 0; i < devices->len; i++) {
-		device = g_ptr_array_index (devices, i);
+		DfuDevice *device = g_ptr_array_index (devices, i);
 		dfu_tool_device_added_cb (dfu_context, device, priv);
 	}
 
@@ -1755,7 +1739,6 @@ static gboolean
 dfu_tool_dump (DfuToolPrivate *priv, gchar **values, GError **error)
 {
 	DfuFirmwareParseFlags flags = DFU_FIRMWARE_PARSE_FLAG_NONE;
-	guint i;
 
 	/* check args */
 	if (g_strv_length (values) < 1) {
@@ -1773,7 +1756,7 @@ dfu_tool_dump (DfuToolPrivate *priv, gchar **values, GError **error)
 	}
 
 	/* open files */
-	for (i = 0; values[i] != NULL; i++) {
+	for (guint i = 0; values[i] != NULL; i++) {
 		g_autoptr(DfuFirmware) firmware = NULL;
 		g_autoptr(GFile) file = NULL;
 		g_autoptr(GError) error_local = NULL;
@@ -2018,7 +2001,6 @@ dfu_tool_list_target (DfuTarget *target)
 	DfuCipherKind cipher_kind;
 	GPtrArray *sectors;
 	const gchar *tmp;
-	guint i;
 	g_autofree gchar *alt_id = NULL;
 	g_autoptr(GError) error_local = NULL;
 
@@ -2050,7 +2032,7 @@ dfu_tool_list_target (DfuTarget *target)
 
 	/* print sector information */
 	sectors = dfu_target_get_sectors (target);
-	for (i = 0; i < sectors->len; i++) {
+	for (guint i = 0; i < sectors->len; i++) {
 		DfuSector *sector;
 		g_autofree gchar *msg = NULL;
 		g_autofree gchar *title = NULL;
@@ -2065,7 +2047,6 @@ dfu_tool_list_target (DfuTarget *target)
 static gboolean
 dfu_tool_list (DfuToolPrivate *priv, gchar **values, GError **error)
 {
-	guint i;
 	g_autoptr(DfuContext) dfu_context = NULL;
 	g_autoptr(GPtrArray) devices = NULL;
 
@@ -2073,13 +2054,12 @@ dfu_tool_list (DfuToolPrivate *priv, gchar **values, GError **error)
 	dfu_context = dfu_context_new ();
 	dfu_context_enumerate (dfu_context, NULL);
 	devices = dfu_context_get_devices (dfu_context);
-	for (i = 0; i < devices->len; i++) {
+	for (guint i = 0; i < devices->len; i++) {
 		DfuDevice *device = NULL;
 		DfuTarget *target;
 		GUsbDevice *dev;
 		GPtrArray *dfu_targets;
 		const gchar *tmp;
-		guint j;
 		guint16 transfer_size;
 		g_autofree gchar *quirks = NULL;
 		g_autofree gchar *version = NULL;
@@ -2165,7 +2145,7 @@ dfu_tool_list (DfuToolPrivate *priv, gchar **values, GError **error)
 
 		/* list targets */
 		dfu_targets = dfu_device_get_targets (device);
-		for (j = 0; j < dfu_targets->len; j++) {
+		for (guint j = 0; j < dfu_targets->len; j++) {
 			target = g_ptr_array_index (dfu_targets, j);
 			dfu_tool_list_target (target);
 		}

plugins/ebitdo/fu-device-ebitdo.c

@@ -346,7 +346,6 @@ fu_device_ebitdo_open (FuDeviceEbitdo *device, GError **error)
 	gdouble tmp;
 	guint32 version_tmp = 0;
 	guint32 serial_tmp[9];
-	guint i;
 	g_autoptr(FuDeviceLocker) locker = NULL;
 
 	/* already open */
@@ -417,7 +416,7 @@ fu_device_ebitdo_open (FuDeviceEbitdo *device, GError **error)
 				    error)) {
 		return FALSE;
 	}
-	for (i = 0; i < 9; i++)
+	for (guint i = 0; i < 9; i++)
 		priv->serial[i] = GUINT32_FROM_LE (serial_tmp[i]);
 
 	/* success */
@@ -450,10 +449,8 @@ fu_device_ebitdo_write_firmware (FuDeviceEbitdo *device, GBytes *fw,
 	FuEbitdoFirmwareHeader *hdr;
 	const guint8 *payload_data;
 	const guint chunk_sz = 32;
-	guint32 offset;
 	guint32 payload_len;
 	guint32 serial_new[3];
-	guint i;
 	g_autoptr(GError) error_local = NULL;
 	const guint32 app_key_index[16] = {
 		0x186976e5, 0xcac67acd, 0x38f27fee, 0x0a4948f1,
@@ -488,7 +485,7 @@ fu_device_ebitdo_write_firmware (FuDeviceEbitdo *device, GBytes *fw,
 	}
 
 	/* check if this is firmware */
-	for (i = 0; i < 4; i++) {
+	for (guint i = 0; i < 4; i++) {
 		if (hdr->reserved[i] != 0x0) {
 			g_set_error (error,
 				     G_IO_ERROR,
@@ -525,7 +522,7 @@ fu_device_ebitdo_write_firmware (FuDeviceEbitdo *device, GBytes *fw,
 	/* flash the firmware in 32 byte blocks */
 	payload_data = g_bytes_get_data (fw, NULL);
 	payload_data += sizeof(FuEbitdoFirmwareHeader);
-	for (offset = 0; offset < payload_len; offset += chunk_sz) {
+	for (guint32 offset = 0; offset < payload_len; offset += chunk_sz) {
 		if (g_getenv ("FU_EBITDO_DEBUG") != NULL) {
 			g_debug ("writing %u bytes to 0x%04x of 0x%04x",
 				 chunk_sz, offset, payload_len);
@@ -666,7 +663,6 @@ fu_device_ebitdo_new (GUsbDevice *usb_device)
 {
 	FuDeviceEbitdo *device;
 	FuDeviceEbitdoPrivate *priv;
-	guint j;
 	const FuEbitdoVidPid vidpids[] = {
 		/* legacy VIDs */
 		{ 0x0483, 0x5750, FU_DEVICE_EBITDO_KIND_BOOTLOADER },
@@ -690,7 +686,7 @@ fu_device_ebitdo_new (GUsbDevice *usb_device)
 	};
 
 	/* set kind */
-	for (j = 0; vidpids[j].vid != 0x0000; j++) {
+	for (guint j = 0; vidpids[j].vid != 0x0000; j++) {
 		if (g_usb_device_get_vid (usb_device) != vidpids[j].vid)
 			continue;
 		if (g_usb_device_get_pid (usb_device) != vidpids[j].pid)

plugins/ebitdo/fu-ebitdo-tool.c

@@ -40,7 +40,6 @@ int
 main (int argc, char **argv)
 {
 	gsize len;
-	guint i;
 	g_autofree guint8 *data = NULL;
 	g_autoptr(FuDeviceEbitdo) dev = NULL;
 	g_autoptr(FuDeviceLocker) locker = NULL;
@@ -65,7 +64,7 @@ main (int argc, char **argv)
 	}
 	g_usb_context_enumerate (usb_ctx);
 	devices = g_usb_context_get_devices (usb_ctx);
-	for (i = 0; i < devices->len; i++) {
+	for (guint i = 0; i < devices->len; i++) {
 		GUsbDevice *usb_dev_tmp = g_ptr_array_index (devices, i);
 		g_autoptr(FuDeviceEbitdo) dev_tmp = fu_device_ebitdo_new (usb_dev_tmp);
 		if (dev_tmp != NULL) {
@@ -92,7 +91,7 @@ main (int argc, char **argv)
 	g_print ("Device Firmware Ver: %s\n",
 		 fu_device_get_version (FU_DEVICE (dev)));
 	g_print ("Device Verification ID:\n");
-	for (i = 0; i < 9; i++)
+	for (guint i = 0; i < 9; i++)
 		g_print ("\t%u = 0x%08x\n", i, fu_device_ebitdo_get_serial(dev)[i]);
 
 	/* not in bootloader mode, so print what to do */

plugins/synapticsmst/fu-plugin-synapticsmst.c

@@ -137,9 +137,6 @@ fu_plugin_synaptics_scan_cascade (FuPlugin *plugin,
 	g_autofree gchar *dev_id_str = NULL;
 	FuDevice *fu_dev = NULL;
 	const gchar *aux_node;
-	guint8 layer = 0;
-	guint16 rad = 0;
-	guint8 j;
 
 	aux_node = synapticsmst_device_get_aux_node (device);
 	if (!synapticsmst_device_open (device, error)) {
@@ -149,9 +146,9 @@ fu_plugin_synaptics_scan_cascade (FuPlugin *plugin,
 		return FALSE;
 	}
 
-	for (j = 0; j < 2; j++) {
+	for (guint8 j = 0; j < 2; j++) {
-		layer = synapticsmst_device_get_layer (device) + 1;
+		guint8 layer = synapticsmst_device_get_layer (device) + 1;
-		rad = synapticsmst_device_get_rad (device) | (j << (2 * (layer - 1)));
+		guint16 rad = synapticsmst_device_get_rad (device) | (j << (2 * (layer - 1)));
 		dev_id_str = g_strdup_printf ("MST-REMOTE-%s-%u-%u",
 					      aux_node, layer, rad);
 		fu_dev = fu_plugin_cache_lookup (plugin, dev_id_str);

plugins/synapticsmst/synapticsmst-tool.c

@@ -95,9 +95,7 @@ synapticsmst_tool_add (GPtrArray *array,
 		       const gchar *description,
 		       FuUtilPrivateCb callback)
 {
-	guint i;
+	g_auto(GStrv) names = NULL;
-	FuUtilItem *item;
-	g_auto (GStrv) names = NULL;
 
 	g_return_if_fail (name != NULL);
 	g_return_if_fail (description != NULL);
@@ -105,8 +103,8 @@ synapticsmst_tool_add (GPtrArray *array,
 
 	/* add each one */
 	names = g_strsplit (name, ",", -1);
-	for (i = 0; names[i] != NULL; i++) {
+	for (guint i = 0; names[i] != NULL; i++) {
-		item = g_new0 (FuUtilItem, 1);
+		FuUtilItem *item = g_new0 (FuUtilItem, 1);
 		item->name = g_strdup (names[i]);
 		if (i == 0) {
 			item->description = g_strdup (description);
@@ -124,44 +122,41 @@ synapticsmst_tool_add (GPtrArray *array,
 static gchar *
 synapticsmst_tool_get_descriptions (GPtrArray *array)
 {
-	guint i;
-	gsize j;
 	gsize len;
 	const gsize max_len = 31;
-	FuUtilItem *item;
+	GString *str;
-	GString *string;
 
 	/* print each command */
-	string = g_string_new ("");
+	str = g_string_new ("");
-	for (i = 0; i < array->len; i++) {
+	for (guint i = 0; i < array->len; i++) {
-		item = g_ptr_array_index (array, i);
+		FuUtilItem *item = g_ptr_array_index (array, i);
-		g_string_append (string, "  ");
+		g_string_append (str, "  ");
-		g_string_append (string, item->name);
+		g_string_append (str, item->name);
 		len = strlen (item->name) + 2;
 		if (item->arguments != NULL) {
-			g_string_append (string, " ");
+			g_string_append (str, " ");
-			g_string_append (string, item->arguments);
+			g_string_append (str, item->arguments);
 			len += strlen (item->arguments) + 1;
 		}
 		if (len < max_len) {
-			for (j = len; j < max_len + 1; j++)
+			for (gsize j = len; j < max_len + 1; j++)
-				g_string_append_c (string, ' ');
+				g_string_append_c (str, ' ');
-			g_string_append (string, item->description);
+			g_string_append (str, item->description);
-			g_string_append_c (string, '\n');
+			g_string_append_c (str, '\n');
 		} else {
-			g_string_append_c (string, '\n');
+			g_string_append_c (str, '\n');
-			for (j = 0; j < max_len + 1; j++)
+			for (gsize j = 0; j < max_len + 1; j++)
-				g_string_append_c (string, ' ');
+				g_string_append_c (str, ' ');
-			g_string_append (string, item->description);
+			g_string_append (str, item->description);
-			g_string_append_c (string, '\n');
+			g_string_append_c (str, '\n');
 		}
 	}
 
 	/* remove trailing newline */
-	if (string->len > 0)
+	if (str->len > 0)
-		g_string_set_size (string, string->len - 1);
+		g_string_set_size (str, str->len - 1);
 
-	return g_string_free (string, FALSE);
+	return g_string_free (str, FALSE);
 }
 
 static gboolean
@@ -344,12 +339,9 @@ synapticsmst_tool_run (SynapticsMSTToolPrivate *priv,
 		       guint8 device_index,
 		       GError **error)
 {
-	guint i;
-	FuUtilItem *item;
-
 	/* find command */
-	for (i = 0; i < priv->cmd_array->len; i++) {
+	for (guint i = 0; i < priv->cmd_array->len; i++) {
-		item = g_ptr_array_index (priv->cmd_array, i);
+		FuUtilItem *item = g_ptr_array_index (priv->cmd_array, i);
 		if (g_strcmp0 (item->name, command) == 0)
 			return item->callback (priv, values, device_index, error);
 	}

plugins/thunderbolt/fu-self-test.c

@@ -221,7 +221,6 @@ mock_tree_init (MockDevice *device)
 static void
 mock_tree_dump (const MockTree *node, int level)
 {
-	guint i;
 	if (node->path) {
 		g_debug ("%*s * %s [%s] at %s", level, " ",
 			 node->device->name, node->uuid, node->path);
@@ -234,7 +233,7 @@ mock_tree_dump (const MockTree *node, int level)
 			 node->device->name, node->uuid, node->sysfs_id);
 	}
 
-	for (i = 0; i < node->children->len; i++) {
+	for (guint i = 0; i < node->children->len; i++) {
 		const MockTree *child = g_ptr_array_index (node->children, i);
 		mock_tree_dump (child, level + 2);
 	}
@@ -291,12 +290,10 @@ mock_tree_contains (const MockTree    *node,
 		    MockTreePredicate  predicate,
 		    gpointer           data)
 {
-	guint i;
-
 	if (predicate (node, data))
 		return node;
 
-	for (i = 0; i < node->children->len; i++) {
+	for (guint i = 0; i < node->children->len; i++) {
 		const MockTree *child;
 		const MockTree *match;
 
@@ -630,12 +627,11 @@ static void
 mock_tree_detach (MockTree *node)
 {
 	UMockdevTestbed *bed;
-	guint i;
 
 	if (mock_tree_node_is_detached (node, NULL))
 		return;
 
-	for (i = 0; i < node->children->len; i++) {
+	for (guint i = 0; i < node->children->len; i++) {
 		MockTree *child = g_ptr_array_index (node->children, i);
 		mock_tree_detach (child);
 		g_free (child->sysfs_parent);

plugins/udev/fu-rom-tool.c

@@ -59,11 +59,10 @@ fu_fuzzer_rom_parse (const gchar *fn, GError **error)
 static gboolean
 fu_fuzzer_write_files (GHashTable *hash, GError **error)
 {
-	GList *l;
 	GString *str;
 	g_autoptr(GList) keys = g_hash_table_get_keys (hash);
 
-	for (l = keys; l != NULL; l = l->next) {
+	for (GList *l = keys; l != NULL; l = l->next) {
 		g_autofree gchar *filename = NULL;
 		const gchar *fn = l->data;
 		filename = g_build_filename ("fuzzing", fn, NULL);
@@ -164,7 +163,6 @@ fu_fuzzer_rom_create (GError **error)
 int
 main (int argc, char *argv[])
 {
-	guint i;
 	gboolean verbose = FALSE;
 	g_autoptr(GError) error_parse = NULL;
 	g_autoptr(GOptionContext) context = NULL;
@@ -190,7 +188,7 @@ main (int argc, char *argv[])
 		g_setenv ("G_MESSAGES_DEBUG", "all", TRUE);
 	if (g_strcmp0 (argv[1], "rom") == 0) {
 		gboolean all_successful = TRUE;
-		for (i = 2; i < (guint) argc; i++) {
+		for (guint i = 2; i < (guint) argc; i++) {
 			g_autoptr(GError) error = NULL;
 			if (!fu_fuzzer_rom_parse (argv[i], &error)) {
 				g_print ("Failed to parse %s: %s\n",

plugins/unifying/lu-tool.c

@@ -82,8 +82,6 @@ lu_tool_add (GPtrArray *array,
 	     const gchar *description,
 	     FuLuToolPrivateCb callback)
 {
-	guint i;
-	FuLuToolItem *item;
 	g_auto(GStrv) names = NULL;
 
 	g_return_if_fail (name != NULL);
@@ -92,8 +90,8 @@ lu_tool_add (GPtrArray *array,
 
 	/* add each one */
 	names = g_strsplit (name, ",", -1);
-	for (i = 0; names[i] != NULL; i++) {
+	for (guint i = 0; names[i] != NULL; i++) {
-		item = g_new0 (FuLuToolItem, 1);
+		FuLuToolItem *item = g_new0 (FuLuToolItem, 1);
 		item->name = g_strdup (names[i]);
 		if (i == 0) {
 			item->description = g_strdup (description);
@@ -109,44 +107,41 @@ lu_tool_add (GPtrArray *array,
 static gchar *
 lu_tool_get_descriptions (GPtrArray *array)
 {
-	guint i;
-	gsize j;
-	gsize len;
 	const gsize max_len = 31;
-	FuLuToolItem *item;
+	GString *str;
-	GString *string;
 
 	/* print each command */
-	string = g_string_new ("");
+	str = g_string_new ("");
-	for (i = 0; i < array->len; i++) {
+	for (guint i = 0; i < array->len; i++) {
-		item = g_ptr_array_index (array, i);
+		FuLuToolItem *item = g_ptr_array_index (array, i);
-		g_string_append (string, "  ");
+		gsize len;
-		g_string_append (string, item->name);
+		g_string_append (str, "  ");
+		g_string_append (str, item->name);
 		len = strlen (item->name) + 2;
 		if (item->arguments != NULL) {
-			g_string_append (string, " ");
+			g_string_append (str, " ");
-			g_string_append (string, item->arguments);
+			g_string_append (str, item->arguments);
 			len += strlen (item->arguments) + 1;
 		}
 		if (len < max_len) {
-			for (j = len; j < max_len + 1; j++)
+			for (guint j = len; j < max_len + 1; j++)
-				g_string_append_c (string, ' ');
+				g_string_append_c (str, ' ');
-			g_string_append (string, item->description);
+			g_string_append (str, item->description);
-			g_string_append_c (string, '\n');
+			g_string_append_c (str, '\n');
 		} else {
-			g_string_append_c (string, '\n');
+			g_string_append_c (str, '\n');
-			for (j = 0; j < max_len + 1; j++)
+			for (guint j = 0; j < max_len + 1; j++)
-				g_string_append_c (string, ' ');
+				g_string_append_c (str, ' ');
-			g_string_append (string, item->description);
+			g_string_append (str, item->description);
-			g_string_append_c (string, '\n');
+			g_string_append_c (str, '\n');
 		}
 	}
 
 	/* remove trailing newline */
-	if (string->len > 0)
+	if (str->len > 0)
-		g_string_set_size (string, string->len - 1);
+		g_string_set_size (str, str->len - 1);
 
-	return g_string_free (string, FALSE);
+	return g_string_free (str, FALSE);
 }
 
 static gboolean
@@ -155,12 +150,9 @@ lu_tool_run (FuLuToolPrivate *priv,
 	     gchar **values,
 	     GError **error)
 {
-	guint i;
-	FuLuToolItem *item;
-
 	/* find command */
-	for (i = 0; i < priv->cmd_array->len; i++) {
+	for (guint i = 0; i < priv->cmd_array->len; i++) {
-		item = g_ptr_array_index (priv->cmd_array, i);
+		FuLuToolItem *item = g_ptr_array_index (priv->cmd_array, i);
 		if (g_strcmp0 (item->name, command) == 0)
 			return item->callback (priv, values, error);
 	}