Remove PED_ASSERT action argument

The action argument was a leftover from when the PED_ASSERT macro was
last changed. This removes that argument from the macro and from all
occurrences of it.

1 files changed, 140 insertions, 147 deletions

diff --git a/libparted/disk.c b/libparted/disk.c
index f6f795f..1057aa8 100644
--- a/libparted/disk.c
+++ b/libparted/disk.c
@@ -67,9 +67,9 @@ static PedDiskType*	disk_types = NULL;
 void
 ped_disk_type_register (PedDiskType* disk_type)
 {
-	PED_ASSERT (disk_type != NULL, return);
-	PED_ASSERT (disk_type->ops != NULL, return);
-	PED_ASSERT (disk_type->name != NULL, return);
+	PED_ASSERT (disk_type != NULL);
+	PED_ASSERT (disk_type->ops != NULL);
+	PED_ASSERT (disk_type->name != NULL);
 
         disk_type->next = disk_types;
         disk_types =  disk_type;
@@ -81,13 +81,13 @@ ped_disk_type_unregister (PedDiskType* disk_type)
 	PedDiskType*	walk;
 	PedDiskType*	last = NULL;
 
-	PED_ASSERT (disk_types != NULL, return);
-	PED_ASSERT (disk_type != NULL, return);
+	PED_ASSERT (disk_types != NULL);
+	PED_ASSERT (disk_type != NULL);
 
 	for (walk = disk_types; walk && walk != disk_type;
                 last = walk, walk = walk->next);
 
-	PED_ASSERT (walk != NULL, return);
+	PED_ASSERT (walk != NULL);
 	if (last)
 		((struct _PedDiskType*) last)->next = disk_type->next;
 	else
@@ -119,7 +119,7 @@ ped_disk_type_get (const char* name)
 {
 	PedDiskType*	walk = NULL;
 
-	PED_ASSERT (name != NULL, return NULL);
+	PED_ASSERT (name != NULL);
 
 	for (walk = ped_disk_type_get_next (NULL); walk;
 	     walk = ped_disk_type_get_next (walk))
@@ -139,7 +139,7 @@ ped_disk_probe (PedDevice* dev)
 {
         PedDiskType* walk = NULL;
 
-        PED_ASSERT (dev != NULL, return NULL);
+        PED_ASSERT (dev != NULL);
 
         if (!ped_device_open (dev))
                 return NULL;
@@ -181,7 +181,7 @@ ped_disk_new (PedDevice* dev)
 	PedDiskType*	type;
 	PedDisk*	disk;
 
-	PED_ASSERT (dev != NULL, return NULL);
+	PED_ASSERT (dev != NULL);
 
 	if (!ped_device_open (dev))
 		goto error;
@@ -251,11 +251,10 @@ ped_disk_duplicate (const PedDisk* old_disk)
 	PedDisk*	new_disk;
 	PedPartition*	old_part;
 
-	PED_ASSERT (old_disk != NULL, return NULL);
-	PED_ASSERT (!old_disk->update_mode, return NULL);
-	PED_ASSERT (old_disk->type->ops->duplicate != NULL, return NULL);
-	PED_ASSERT (old_disk->type->ops->partition_duplicate != NULL,
-		    return NULL);
+	PED_ASSERT (old_disk != NULL);
+	PED_ASSERT (!old_disk->update_mode);
+	PED_ASSERT (old_disk->type->ops->duplicate != NULL);
+	PED_ASSERT (old_disk->type->ops->partition_duplicate != NULL);
 
 	new_disk = old_disk->type->ops->duplicate (old_disk);
 	if (!new_disk)
@@ -309,13 +308,13 @@ find_disk_type (char const *name)
 int
 ped_disk_clobber (PedDevice* dev)
 {
-	PED_ASSERT (dev != NULL, goto error);
+	PED_ASSERT (dev != NULL);
 
 	if (!ped_device_open (dev))
 		goto error;
 
         PedDiskType const *gpt = find_disk_type ("gpt");
-	PED_ASSERT (gpt != NULL, goto error);
+	PED_ASSERT (gpt != NULL);
 
         /* If there is a GPT table, don't clobber the protective MBR.  */
         bool is_gpt = gpt->ops->probe (dev);
@@ -369,19 +368,19 @@ ped_disk_new_fresh (PedDevice* dev, const PedDiskType* type)
 {
 	PedDisk*	disk;
 
-	PED_ASSERT (dev != NULL, return NULL);
-	PED_ASSERT (type != NULL, return NULL);
-	PED_ASSERT (type->ops->alloc != NULL, return NULL);
+	PED_ASSERT (dev != NULL);
+	PED_ASSERT (type != NULL);
+	PED_ASSERT (type->ops->alloc != NULL);
 	PedCHSGeometry*	bios_geom = &dev->bios_geom;
-	PED_ASSERT (bios_geom->sectors != 0, return NULL);
-	PED_ASSERT (bios_geom->heads != 0, return NULL);
+	PED_ASSERT (bios_geom->sectors != 0);
+	PED_ASSERT (bios_geom->heads != 0);
 
 	disk = type->ops->alloc (dev);
 	if (!disk)
        		goto error;
         if (!_disk_pop_update_mode (disk))
                 goto error_destroy_disk;
-	PED_ASSERT (disk->update_mode == 0, ignored);
+	PED_ASSERT (disk->update_mode == 0);
 
 	disk->needs_clobber = 1;
 	return disk;
@@ -429,8 +428,8 @@ _ped_disk_free (PedDisk* disk)
 void
 ped_disk_destroy (PedDisk* disk)
 {
-	PED_ASSERT (disk != NULL, return);
-	PED_ASSERT (!disk->update_mode, return);
+	PED_ASSERT (disk != NULL);
+	PED_ASSERT (!disk->update_mode);
 
 	disk->type->ops->free (disk);
 }
@@ -451,7 +450,7 @@ ped_disk_destroy (PedDisk* disk)
 int
 ped_disk_commit_to_os (PedDisk* disk)
 {
-	PED_ASSERT (disk != NULL, return 0);
+	PED_ASSERT (disk != NULL);
 
 	if (!ped_device_open (disk->dev))
 		goto error;
@@ -475,8 +474,8 @@ error:
 int
 ped_disk_commit_to_dev (PedDisk* disk)
 {
-	PED_ASSERT (disk != NULL, goto error);
-	PED_ASSERT (!disk->update_mode, goto error);
+	PED_ASSERT (disk != NULL);
+	PED_ASSERT (!disk->update_mode);
 
 	if (!disk->type->ops->write) {
 		ped_exception_throw (
@@ -557,7 +556,7 @@ error:
 int
 ped_partition_is_busy (const PedPartition* part)
 {
-	PED_ASSERT (part != NULL, return 1);
+	PED_ASSERT (part != NULL);
 
 	return ped_architecture->disk_ops->partition_is_busy (part);
 }
@@ -569,7 +568,7 @@ ped_partition_is_busy (const PedPartition* part)
 char*
 ped_partition_get_path (const PedPartition* part)
 {
-	PED_ASSERT (part != NULL, return NULL);
+	PED_ASSERT (part != NULL);
 
 	return ped_architecture->disk_ops->partition_get_path (part);
 }
@@ -598,7 +597,7 @@ ped_disk_check (const PedDisk* disk)
 {
 	PedPartition*	walk;
 
-	PED_ASSERT (disk != NULL, return 0);
+	PED_ASSERT (disk != NULL);
 
 	for (walk = disk->part_list; walk;
 	     walk = ped_disk_next_partition (disk, walk)) {
@@ -667,7 +666,7 @@ ped_disk_get_primary_partition_count (const PedDisk* disk)
 	PedPartition*	walk;
 	int		count = 0;
 
-	PED_ASSERT (disk != NULL, return 0);
+	PED_ASSERT (disk != NULL);
 
 	for (walk = disk->part_list; walk;
 	     walk = ped_disk_next_partition (disk, walk)) {
@@ -688,7 +687,7 @@ ped_disk_get_last_partition_num (const PedDisk* disk)
 	PedPartition*	walk;
 	int		highest = -1;
 
-	PED_ASSERT (disk != NULL, return 0);
+	PED_ASSERT (disk != NULL);
 
 	for (walk = disk->part_list; walk;
 	     walk = ped_disk_next_partition (disk, walk)) {
@@ -707,8 +706,8 @@ ped_disk_get_last_partition_num (const PedDisk* disk)
 bool
 ped_disk_get_max_supported_partition_count(const PedDisk* disk, int* supported)
 {
-	PED_ASSERT(disk != NULL, return -1);
-	PED_ASSERT(disk->type->ops->get_max_supported_partition_count != NULL, return -1);
+	PED_ASSERT(disk != NULL);
+	PED_ASSERT(disk->type->ops->get_max_supported_partition_count != NULL);
 
 	return disk->type->ops->get_max_supported_partition_count(disk, supported);
 }
@@ -742,9 +741,8 @@ ped_disk_get_partition_alignment(const PedDisk *disk)
 int
 ped_disk_get_max_primary_partition_count (const PedDisk* disk)
 {
-	PED_ASSERT (disk->type != NULL, return 0);
-	PED_ASSERT (disk->type->ops->get_max_primary_partition_count != NULL,
-		    return 0);
+	PED_ASSERT (disk->type != NULL);
+	PED_ASSERT (disk->type->ops->get_max_primary_partition_count != NULL);
 
 	return disk->type->ops->get_max_primary_partition_count (disk);
 }
@@ -764,7 +762,7 @@ ped_disk_set_flag(PedDisk *disk, PedDiskFlag flag, int state)
 {
         int ret;
 
-        PED_ASSERT (disk != NULL, return 0);
+        PED_ASSERT (disk != NULL);
 
         PedDiskOps *ops = disk->type->ops;
 
@@ -796,7 +794,7 @@ ped_disk_set_flag(PedDisk *disk, PedDiskFlag flag, int state)
 int
 ped_disk_get_flag(const PedDisk *disk, PedDiskFlag flag)
 {
-        PED_ASSERT (disk != NULL, return 0);
+        PED_ASSERT (disk != NULL);
 
         PedDiskOps *ops = disk->type->ops;
 
@@ -814,7 +812,7 @@ ped_disk_get_flag(const PedDisk *disk, PedDiskFlag flag)
 int
 ped_disk_is_flag_available(const PedDisk *disk, PedDiskFlag flag)
 {
-        PED_ASSERT (disk != NULL, return 0);
+        PED_ASSERT (disk != NULL);
 
         PedDiskOps *ops = disk->type->ops;
 
@@ -910,13 +908,13 @@ _partition_align (PedPartition* part, const PedConstraint* constraint)
 {
 	const PedDiskType*	disk_type;
 
-	PED_ASSERT (part != NULL, return 0);
-	PED_ASSERT (part->num != -1, return 0);
-	PED_ASSERT (part->disk != NULL, return 0);
+	PED_ASSERT (part != NULL);
+	PED_ASSERT (part->num != -1);
+	PED_ASSERT (part->disk != NULL);
 	disk_type = part->disk->type;
-	PED_ASSERT (disk_type != NULL, return 0);
-	PED_ASSERT (disk_type->ops->partition_align != NULL, return 0);
-	PED_ASSERT (part->disk->update_mode, return 0);
+	PED_ASSERT (disk_type != NULL);
+	PED_ASSERT (disk_type->ops->partition_align != NULL);
+	PED_ASSERT (part->disk->update_mode);
 
 	return disk_type->ops->partition_align (part, constraint);
 }
@@ -926,11 +924,11 @@ _partition_enumerate (PedPartition* part)
 {
 	const PedDiskType*	disk_type;
 
-	PED_ASSERT (part != NULL, return 0);
-	PED_ASSERT (part->disk != NULL, return 0);
+	PED_ASSERT (part != NULL);
+	PED_ASSERT (part->disk != NULL);
 	disk_type = part->disk->type;
-	PED_ASSERT (disk_type != NULL, return 0);
-	PED_ASSERT (disk_type->ops->partition_enumerate != NULL, return 0);
+	PED_ASSERT (disk_type != NULL);
+	PED_ASSERT (disk_type->ops->partition_enumerate != NULL);
 
 	return disk_type->ops->partition_enumerate (part);
 }
@@ -946,7 +944,7 @@ ped_disk_enumerate_partitions (PedDisk* disk)
 	int		i;
 	int		end;
 
-	PED_ASSERT (disk != NULL, return 0);
+	PED_ASSERT (disk != NULL);
 
 /* first "sort" already-numbered partitions.  (e.g. if a logical partition
  * is removed, then all logical partitions that were number higher MUST be
@@ -979,7 +977,7 @@ _disk_remove_metadata (PedDisk* disk)
 	PedPartition*	walk = NULL;
 	PedPartition*	next;
 
-	PED_ASSERT (disk != NULL, return 0);
+	PED_ASSERT (disk != NULL);
 
 	next = ped_disk_next_partition (disk, walk);
 
@@ -999,7 +997,7 @@ _disk_remove_metadata (PedDisk* disk)
 static int
 _disk_alloc_metadata (PedDisk* disk)
 {
-	PED_ASSERT (disk != NULL, return 0);
+	PED_ASSERT (disk != NULL);
 
 	if (!disk->update_mode)
 		_disk_remove_metadata (disk);
@@ -1146,7 +1144,7 @@ _disk_push_update_mode (PedDisk* disk)
 static int
 _disk_pop_update_mode (PedDisk* disk)
 {
-	PED_ASSERT (disk->update_mode, return 0);
+	PED_ASSERT (disk->update_mode);
 
 	if (disk->update_mode == 1) {
 	/* re-allocate metadata BEFORE leaving update mode, to prevent infinite
@@ -1188,7 +1186,7 @@ _ped_partition_alloc (const PedDisk* disk, PedPartitionType type,
 {
 	PedPartition*	part;
 
-	PED_ASSERT (disk != NULL, return 0);
+	PED_ASSERT (disk != NULL);
 
 	part = (PedPartition*) ped_malloc (sizeof (PedPartition));
 	if (!part)
@@ -1270,8 +1268,8 @@ ped_partition_new (const PedDisk* disk, PedPartitionType type,
 	int		supports_extended;
 	PedPartition*	part;
 
-	PED_ASSERT (disk != NULL, return NULL);
-	PED_ASSERT (disk->type->ops->partition_new != NULL, return NULL);
+	PED_ASSERT (disk != NULL);
+	PED_ASSERT (disk->type->ops->partition_new != NULL);
 
 	supports_extended = ped_disk_type_check_feature (disk->type,
 			    	PED_DISK_TYPE_EXTENDED);
@@ -1313,9 +1311,9 @@ error:
 void
 ped_partition_destroy (PedPartition* part)
 {
-	PED_ASSERT (part != NULL, return);
-	PED_ASSERT (part->disk != NULL, return);
-	PED_ASSERT (part->disk->type->ops->partition_new != NULL, return);
+	PED_ASSERT (part != NULL);
+	PED_ASSERT (part->disk != NULL);
+	PED_ASSERT (part->disk->type->ops->partition_new != NULL);
 
 	part->disk->type->ops->partition_destroy (part);
 }
@@ -1330,7 +1328,7 @@ ped_partition_destroy (PedPartition* part)
 int
 ped_partition_is_active (const PedPartition* part)
 {
-	PED_ASSERT (part != NULL, return 0);
+	PED_ASSERT (part != NULL);
 
 	return !(part->type & PED_PARTITION_FREESPACE
 		 || part->type & PED_PARTITION_METADATA);
@@ -1359,13 +1357,13 @@ ped_partition_set_flag (PedPartition* part, PedPartitionFlag flag, int state)
 {
 	PedDiskOps*	ops;
 
-	PED_ASSERT (part != NULL, return 0);
-	PED_ASSERT (part->disk != NULL, return 0);
-	PED_ASSERT (ped_partition_is_active (part), return 0);
+	PED_ASSERT (part != NULL);
+	PED_ASSERT (part->disk != NULL);
+	PED_ASSERT (ped_partition_is_active (part));
 
 	ops = part->disk->type->ops;
-	PED_ASSERT (ops->partition_set_flag != NULL, return 0);
-	PED_ASSERT (ops->partition_is_flag_available != NULL, return 0);
+	PED_ASSERT (ops->partition_set_flag != NULL);
+	PED_ASSERT (ops->partition_is_flag_available != NULL);
 
 	if (!ops->partition_is_flag_available (part, flag)) {
 		ped_exception_throw (
@@ -1390,11 +1388,10 @@ ped_partition_set_flag (PedPartition* part, PedPartitionFlag flag, int state)
 int
 ped_partition_get_flag (const PedPartition* part, PedPartitionFlag flag)
 {
-	PED_ASSERT (part != NULL, return 0);
-	PED_ASSERT (part->disk != NULL, return 0);
-	PED_ASSERT (part->disk->type->ops->partition_get_flag != NULL,
-		    return 0);
-	PED_ASSERT (ped_partition_is_active (part), return 0);
+	PED_ASSERT (part != NULL);
+	PED_ASSERT (part->disk != NULL);
+	PED_ASSERT (part->disk->type->ops->partition_get_flag != NULL);
+	PED_ASSERT (ped_partition_is_active (part));
 
 	return part->disk->type->ops->partition_get_flag (part, flag);
 }
@@ -1408,11 +1405,10 @@ int
 ped_partition_is_flag_available (const PedPartition* part,
 	       			 PedPartitionFlag flag)
 {
-	PED_ASSERT (part != NULL, return 0);
-	PED_ASSERT (part->disk != NULL, return 0);
-	PED_ASSERT (part->disk->type->ops->partition_is_flag_available != NULL,
-		    return 0);
-	PED_ASSERT (ped_partition_is_active (part), return 0);
+	PED_ASSERT (part != NULL);
+	PED_ASSERT (part->disk != NULL);
+	PED_ASSERT (part->disk->type->ops->partition_is_flag_available != NULL);
+	PED_ASSERT (ped_partition_is_active (part));
 
 	return part->disk->type->ops->partition_is_flag_available (part, flag);
 }
@@ -1430,13 +1426,13 @@ ped_partition_set_system (PedPartition* part, const PedFileSystemType* fs_type)
 {
 	const PedDiskType*	disk_type;
 
-	PED_ASSERT (part != NULL, return 0);
-	PED_ASSERT (ped_partition_is_active (part), return 0);
-	PED_ASSERT (part->disk != NULL, return 0);
+	PED_ASSERT (part != NULL);
+	PED_ASSERT (ped_partition_is_active (part));
+	PED_ASSERT (part->disk != NULL);
 	disk_type = part->disk->type;
-	PED_ASSERT (disk_type != NULL, return 0);
-	PED_ASSERT (disk_type->ops != NULL, return 0);
-	PED_ASSERT (disk_type->ops->partition_set_system != NULL, return 0);
+	PED_ASSERT (disk_type != NULL);
+	PED_ASSERT (disk_type->ops != NULL);
+	PED_ASSERT (disk_type->ops->partition_set_system != NULL);
 
 	return disk_type->ops->partition_set_system (part, fs_type);
 }
@@ -1474,16 +1470,15 @@ _assert_partition_name_feature (const PedDiskType* disk_type)
 int
 ped_partition_set_name (PedPartition* part, const char* name)
 {
-	PED_ASSERT (part != NULL, return 0);
-	PED_ASSERT (part->disk != NULL, return 0);
-	PED_ASSERT (ped_partition_is_active (part), return 0);
-	PED_ASSERT (name != NULL, return 0);
+	PED_ASSERT (part != NULL);
+	PED_ASSERT (part->disk != NULL);
+	PED_ASSERT (ped_partition_is_active (part));
+	PED_ASSERT (name != NULL);
 
 	if (!_assert_partition_name_feature (part->disk->type))
 		return 0;
 
-	PED_ASSERT (part->disk->type->ops->partition_set_name != NULL,
-		    return 0);
+	PED_ASSERT (part->disk->type->ops->partition_set_name != NULL);
 	part->disk->type->ops->partition_set_name (part, name);
 	return 1;
 }
@@ -1498,15 +1493,14 @@ ped_partition_set_name (PedPartition* part, const char* name)
 const char*
 ped_partition_get_name (const PedPartition* part)
 {
-	PED_ASSERT (part != NULL, return NULL);
-	PED_ASSERT (part->disk != NULL, return 0);
-	PED_ASSERT (ped_partition_is_active (part), return 0);
+	PED_ASSERT (part != NULL);
+	PED_ASSERT (part->disk != NULL);
+	PED_ASSERT (ped_partition_is_active (part));
 
 	if (!_assert_partition_name_feature (part->disk->type))
 		return NULL;
 
-	PED_ASSERT (part->disk->type->ops->partition_get_name != NULL,
-		    return NULL);
+	PED_ASSERT (part->disk->type->ops->partition_get_name != NULL);
 	return part->disk->type->ops->partition_get_name (part);
 }
 
@@ -1523,7 +1517,7 @@ ped_disk_extended_partition (const PedDisk* disk)
 {
 	PedPartition*		walk;
 
-	PED_ASSERT (disk != NULL, return 0);
+	PED_ASSERT (disk != NULL);
 
 	for (walk = disk->part_list; walk; walk = walk->next) {
 		if (walk->type == PED_PARTITION_EXTENDED)
@@ -1544,7 +1538,7 @@ ped_disk_extended_partition (const PedDisk* disk)
 PedPartition*
 ped_disk_next_partition (const PedDisk* disk, const PedPartition* part)
 {
-	PED_ASSERT (disk != NULL, return 0);
+	PED_ASSERT (disk != NULL);
 
 	if (!part)
 		return disk->part_list;
@@ -1565,11 +1559,11 @@ _disk_check_sanity (PedDisk* disk)
 {
 	PedPartition*	walk;
 
-	PED_ASSERT (disk != NULL, return 0);
+	PED_ASSERT (disk != NULL);
 
 	for (walk = disk->part_list; walk; walk = walk->next) {
-		PED_ASSERT (!(walk->type & PED_PARTITION_LOGICAL), return 0);
-		PED_ASSERT (!walk->prev || walk->prev->next == walk, return 0);
+		PED_ASSERT (!(walk->type & PED_PARTITION_LOGICAL));
+		PED_ASSERT (!walk->prev || walk->prev->next == walk);
 	}
 
 	if (!ped_disk_extended_partition (disk))
@@ -1577,9 +1571,9 @@ _disk_check_sanity (PedDisk* disk)
 
 	for (walk = ped_disk_extended_partition (disk)->part_list; walk;
 	     walk = walk->next) {
-		PED_ASSERT (walk->type & PED_PARTITION_LOGICAL, return 0);
+		PED_ASSERT (walk->type & PED_PARTITION_LOGICAL);
 		if (walk->prev)
-			PED_ASSERT (walk->prev->next == walk, return 0);
+			PED_ASSERT (walk->prev->next == walk);
 	}
 	return 1;
 }
@@ -1595,7 +1589,7 @@ ped_disk_get_partition (const PedDisk* disk, int num)
 {
 	PedPartition*	walk;
 
-	PED_ASSERT (disk != NULL, return 0);
+	PED_ASSERT (disk != NULL);
 
 	for (walk = disk->part_list; walk;
 	     walk = ped_disk_next_partition (disk, walk)) {
@@ -1616,7 +1610,7 @@ ped_disk_get_partition_by_sector (const PedDisk* disk, PedSector sect)
 {
 	PedPartition*	walk;
 
-	PED_ASSERT (disk != NULL, return 0);
+	PED_ASSERT (disk != NULL);
 
 	for (walk = disk->part_list; walk;
 	     walk = ped_disk_next_partition (disk, walk)) {
@@ -1656,9 +1650,9 @@ ped_disk_max_partition_start_sector (const PedDisk* disk)
 static int
 _disk_raw_insert_before (PedDisk* disk, PedPartition* loc, PedPartition* part)
 {
-	PED_ASSERT (disk != NULL, return 0);
-	PED_ASSERT (loc != NULL, return 0);
-	PED_ASSERT (part != NULL, return 0);
+	PED_ASSERT (disk != NULL);
+	PED_ASSERT (loc != NULL);
+	PED_ASSERT (part != NULL);
 
 	part->prev = loc->prev;
 	part->next = loc;
@@ -1678,9 +1672,9 @@ _disk_raw_insert_before (PedDisk* disk, PedPartition* loc, PedPartition* part)
 static int
 _disk_raw_insert_after (PedDisk* disk, PedPartition* loc, PedPartition* part)
 {
-	PED_ASSERT (disk != NULL, return 0);
-	PED_ASSERT (loc != NULL, return 0);
-	PED_ASSERT (part != NULL, return 0);
+	PED_ASSERT (disk != NULL);
+	PED_ASSERT (loc != NULL);
+	PED_ASSERT (part != NULL);
 
 	part->prev = loc;
 	part->next = loc->next;
@@ -1694,8 +1688,8 @@ _disk_raw_insert_after (PedDisk* disk, PedPartition* loc, PedPartition* part)
 static int
 _disk_raw_remove (PedDisk* disk, PedPartition* part)
 {
-	PED_ASSERT (disk != NULL, return 0);
-	PED_ASSERT (part != NULL, return 0);
+	PED_ASSERT (disk != NULL);
+	PED_ASSERT (part != NULL);
 
 	if (part->prev) {
 		part->prev->next = part->next;
@@ -1725,7 +1719,7 @@ _disk_raw_add (PedDisk* disk, PedPartition* part)
 	PedPartition*	last;
 	PedPartition*	ext_part;
 
-	PED_ASSERT (disk->update_mode, return 0);
+	PED_ASSERT (disk->update_mode);
 
 	ext_part = ped_disk_extended_partition (disk);
 
@@ -1762,14 +1756,14 @@ _partition_get_overlap_constraint (PedPartition* part, PedGeometry* geom)
 	PedPartition*	walk;
 	PedGeometry	free_space;
 
-	PED_ASSERT (part->disk->update_mode, return NULL);
-	PED_ASSERT (part->geom.dev == geom->dev, return NULL);
+	PED_ASSERT (part->disk->update_mode);
+	PED_ASSERT (part->geom.dev == geom->dev);
 
 	if (part->type & PED_PARTITION_LOGICAL) {
 		PedPartition* ext_part;
 
 		ext_part = ped_disk_extended_partition (part->disk);
-		PED_ASSERT (ext_part != NULL, return NULL);
+		PED_ASSERT (ext_part != NULL);
 
 		min_start = ext_part->geom.start;
 		max_end = ext_part->geom.end;
@@ -1818,8 +1812,8 @@ _disk_check_part_overlaps (PedDisk* disk, PedPartition* part)
 {
 	PedPartition*	walk;
 
-	PED_ASSERT (disk != NULL, return 0);
-	PED_ASSERT (part != NULL, return 0);
+	PED_ASSERT (disk != NULL);
+	PED_ASSERT (part != NULL);
 
 	for (walk = ped_disk_next_partition (disk, NULL); walk;
 	     walk = ped_disk_next_partition (disk, walk)) {
@@ -1849,11 +1843,11 @@ _partition_check_basic_sanity (PedDisk* disk, PedPartition* part)
 {
 	PedPartition*	ext_part = ped_disk_extended_partition (disk);
 
-	PED_ASSERT (part->disk == disk, return 0);
+	PED_ASSERT (part->disk == disk);
 
-	PED_ASSERT (part->geom.start >= 0, return 0);
-	PED_ASSERT (part->geom.end < disk->dev->length, return 0);
-	PED_ASSERT (part->geom.start <= part->geom.end, return 0);
+	PED_ASSERT (part->geom.start >= 0);
+	PED_ASSERT (part->geom.end < disk->dev->length);
+	PED_ASSERT (part->geom.start <= part->geom.end);
 
 	if (!ped_disk_type_check_feature (disk->type, PED_DISK_TYPE_EXTENDED)
 	    && (part->type == PED_PARTITION_EXTENDED
@@ -1898,10 +1892,10 @@ _check_extended_partition (PedDisk* disk, PedPartition* part)
 	PedPartition*		walk;
 	PedPartition*		ext_part;
 
-	PED_ASSERT (disk != NULL, return 0);
+	PED_ASSERT (disk != NULL);
 	ext_part = ped_disk_extended_partition (disk);
 	if (!ext_part) ext_part = part;
-	PED_ASSERT (ext_part != NULL, return 0);
+	PED_ASSERT (ext_part != NULL);
 
 	if (part != ext_part) {
 		ped_exception_throw (
@@ -1930,7 +1924,7 @@ _check_partition (PedDisk* disk, PedPartition* part)
 {
 	PedPartition*	ext_part = ped_disk_extended_partition (disk);
 
-	PED_ASSERT (part->geom.start <= part->geom.end, return 0);
+	PED_ASSERT (part->geom.start <= part->geom.end);
 
 	if (part->type == PED_PARTITION_EXTENDED) {
 		if (!_check_extended_partition (disk, part))
@@ -1992,8 +1986,8 @@ ped_disk_add_partition (PedDisk* disk, PedPartition* part,
 	PedConstraint*	overlap_constraint = NULL;
 	PedConstraint*	constraints = NULL;
 
-	PED_ASSERT (disk != NULL, return 0);
-	PED_ASSERT (part != NULL, return 0);
+	PED_ASSERT (disk != NULL);
+	PED_ASSERT (part != NULL);
 
 	if (!_partition_check_basic_sanity (disk, part))
 		return 0;
@@ -2060,12 +2054,12 @@ error:
 int
 ped_disk_remove_partition (PedDisk* disk, PedPartition* part)
 {
-	PED_ASSERT (disk != NULL, return 0);
-	PED_ASSERT (part != NULL, return 0);
+	PED_ASSERT (disk != NULL);
+	PED_ASSERT (part != NULL);
 
 	if (!_disk_push_update_mode (disk))
 		return 0;
-	PED_ASSERT (part->part_list == NULL, ignored);
+	PED_ASSERT (part->part_list == NULL);
 	_disk_raw_remove (disk, part);
 	if (!_disk_pop_update_mode (disk))
 		return 0;
@@ -2084,8 +2078,8 @@ ped_disk_delete_all_logical (PedDisk* disk);
 int
 ped_disk_delete_partition (PedDisk* disk, PedPartition* part)
 {
-	PED_ASSERT (disk != NULL, return 0);
-	PED_ASSERT (part != NULL, return 0);
+	PED_ASSERT (disk != NULL);
+	PED_ASSERT (part != NULL);
 
 	if (!_disk_push_update_mode (disk))
 		return 0;
@@ -2106,9 +2100,9 @@ ped_disk_delete_all_logical (PedDisk* disk)
 	PedPartition*		next;
 	PedPartition*		ext_part;
 
-	PED_ASSERT (disk != NULL, return 0);
+	PED_ASSERT (disk != NULL);
 	ext_part = ped_disk_extended_partition (disk);
-	PED_ASSERT (ext_part != NULL, return 0);
+	PED_ASSERT (ext_part != NULL);
 
 	for (walk = ext_part->part_list; walk; walk = next) {
 		next = walk->next;
@@ -2130,7 +2124,7 @@ ped_disk_delete_all (PedDisk* disk)
 	PedPartition*		walk;
 	PedPartition*		next;
 
-	PED_ASSERT (disk != NULL, return 0);
+	PED_ASSERT (disk != NULL);
 
 	if (!_disk_push_update_mode (disk))
 		return 0;
@@ -2172,9 +2166,9 @@ ped_disk_set_partition_geom (PedDisk* disk, PedPartition* part,
 	PedGeometry	old_geom;
 	PedGeometry	new_geom;
 
-	PED_ASSERT (disk != NULL, return 0);
-	PED_ASSERT (part != NULL, return 0);
-	PED_ASSERT (part->disk == disk, return 0);
+	PED_ASSERT (disk != NULL);
+	PED_ASSERT (part != NULL);
+	PED_ASSERT (part->disk == disk);
 
 	old_geom = part->geom;
 	ped_geometry_init (&new_geom, part->geom.dev, start, end - start + 1);
@@ -2237,11 +2231,11 @@ ped_disk_maximize_partition (PedDisk* disk, PedPartition* part,
 	PedPartition*	ext_part = ped_disk_extended_partition (disk);
 	PedConstraint*	constraint_any;
 
-	PED_ASSERT (disk != NULL, return 0);
-	PED_ASSERT (part != NULL, return 0);
+	PED_ASSERT (disk != NULL);
+	PED_ASSERT (part != NULL);
 
 	if (part->type & PED_PARTITION_LOGICAL) {
-		PED_ASSERT (ext_part != NULL, return 0);
+		PED_ASSERT (ext_part != NULL);
 		global_min_start = ext_part->geom.start;
 		global_max_end = ext_part->geom.end;
 	} else {
@@ -2295,9 +2289,9 @@ ped_disk_get_max_partition_geometry (PedDisk* disk, PedPartition* part,
 	PedGeometry*	max_geom;
 	PedConstraint*	constraint_exact;
 
-	PED_ASSERT(disk != NULL, return NULL);
-	PED_ASSERT(part != NULL, return NULL);
-	PED_ASSERT(ped_partition_is_active (part), return NULL);
+	PED_ASSERT(disk != NULL);
+	PED_ASSERT(part != NULL);
+	PED_ASSERT(ped_partition_is_active (part));
 
 	old_geom = part->geom;
 	if (!ped_disk_maximize_partition (disk, part, constraint))
@@ -2312,8 +2306,7 @@ ped_disk_get_max_partition_geometry (PedDisk* disk, PedPartition* part,
 	/* this assertion should never fail, because the old
 	 * geometry was valid
 	 */
-	PED_ASSERT (ped_geometry_test_equal (&part->geom, &old_geom),
-		    return NULL);
+	PED_ASSERT (ped_geometry_test_equal (&part->geom, &old_geom));
 
 	return max_geom;
 }
@@ -2335,7 +2328,7 @@ ped_disk_minimize_extended_partition (PedDisk* disk)
 	PedConstraint*		constraint;
 	int			status;
 
-	PED_ASSERT (disk != NULL, return 0);
+	PED_ASSERT (disk != NULL);
 
 	ext_part = ped_disk_extended_partition (disk);
 	if (!ext_part)
@@ -2494,7 +2487,7 @@ ped_partition_flag_get_by_name (const char* name)
 static void
 ped_partition_print (const PedPartition* part)
 {
-	PED_ASSERT (part != NULL, return);
+	PED_ASSERT (part != NULL);
 
 	printf ("  %-10s %02d  (%d->%d)\n",
 		ped_partition_type_get_name (part->type),
@@ -2518,7 +2511,7 @@ ped_disk_print (const PedDisk* disk)
 {
 	PedPartition*	part;
 
-	PED_ASSERT (disk != NULL, return);
+	PED_ASSERT (disk != NULL);
 
 	for (part = disk->part_list; part;
 	     part = ped_disk_next_partition (disk, part))