[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[PATCH 2/2] Remove PED_ASSERT action argument
|
From: |
Brian C. Lane |
|
Subject: |
[PATCH 2/2] Remove PED_ASSERT action argument |
|
Date: |
Wed, 2 Mar 2011 14:36:33 -0800 |
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.
---
debug/clearfat/clearfat.c | 2 +-
include/parted/debug.h | 6 +-
libparted/arch/beos.c | 8 +-
libparted/arch/gnu.c | 16 +-
libparted/arch/linux.c | 75 ++++----
libparted/cs/constraint.c | 35 ++--
libparted/cs/geom.c | 56 +++---
libparted/cs/natmath.c | 14 +-
libparted/device.c | 56 +++---
libparted/disk.c | 287 +++++++++++++++---------------
libparted/exception.c | 4 +-
libparted/filesys.c | 70 ++++----
libparted/fs/amiga/affs.c | 4 +-
libparted/fs/amiga/amiga.c | 4 +-
libparted/fs/amiga/apfs.c | 4 +-
libparted/fs/amiga/asfs.c | 4 +-
libparted/fs/bfs/bfs.c | 12 +-
libparted/fs/ext2/ext2.h | 4 +-
libparted/fs/ext2/ext2_inode_relocator.c | 2 +-
libparted/fs/ext2/ext2_mkfs.c | 2 +-
libparted/fs/ext2/interface.c | 2 +-
libparted/fs/fat/bootsector.c | 18 +-
libparted/fs/fat/calc.c | 34 ++--
libparted/fs/fat/clstdup.c | 26 ++--
libparted/fs/fat/context.c | 4 +-
libparted/fs/fat/count.c | 5 +-
libparted/fs/fat/fat.c | 3 +-
libparted/fs/fat/fatio.c | 10 +-
libparted/fs/fat/resize.c | 22 ++--
libparted/fs/fat/table.c | 14 +-
libparted/fs/fat/traverse.c | 4 +-
libparted/fs/hfs/cache.c | 8 +-
libparted/fs/hfs/file.c | 2 +-
libparted/fs/hfs/file_plus.c | 2 +-
libparted/fs/hfs/hfs.c | 20 +-
libparted/fs/hfs/probe.c | 14 +-
libparted/fs/hfs/reloc.c | 11 +-
libparted/fs/hfs/reloc_plus.c | 16 +-
libparted/fs/reiserfs/geom_dal.c | 20 +-
libparted/fs/reiserfs/reiserfs.c | 22 ++--
libparted/fs/ufs/ufs.c | 2 +-
libparted/labels/aix.c | 6 +-
libparted/labels/bsd.c | 28 ++--
libparted/labels/dasd.c | 30 ++--
libparted/labels/dos.c | 145 ++++++++--------
libparted/labels/dvh.c | 24 ++--
libparted/labels/gpt.c | 60 +++---
libparted/labels/loop.c | 6 +-
libparted/labels/mac.c | 64 ++++----
libparted/labels/pc98.c | 80 ++++----
libparted/labels/pt-common.h | 4 +-
libparted/labels/pt-tools.c | 6 +-
libparted/labels/rdb.c | 99 +++++-----
libparted/labels/sun.c | 39 ++--
libparted/timer.c | 6 +-
libparted/unit.c | 10 +-
parted/parted.c | 35 ++--
parted/strlist.c | 2 +-
parted/ui.c | 11 +-
59 files changed, 778 insertions(+), 801 deletions(-)
diff --git a/debug/clearfat/clearfat.c b/debug/clearfat/clearfat.c
index 1b16dcf..7b02a34 100644
--- a/debug/clearfat/clearfat.c
+++ b/debug/clearfat/clearfat.c
@@ -170,7 +170,7 @@ _calc_fat_entry_offset (PedFileSystem* fs, FatCluster
cluster)
switch (fs_info->fat_type) {
case FAT_TYPE_FAT12:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
case FAT_TYPE_FAT16:
diff --git a/include/parted/debug.h b/include/parted/debug.h
index 634c759..e7fafb6 100644
--- a/include/parted/debug.h
+++ b/include/parted/debug.h
@@ -41,7 +41,7 @@ ped_assert ( const char* cond_text,
ped_debug ( level, __FILE__, __LINE__, __PRETTY_FUNCTION__, \
__VA_ARGS__ )
-#define PED_ASSERT(cond, action) \
+#define PED_ASSERT(cond) \
do { \
if (!(cond)) { \
ped_assert ( \
@@ -64,7 +64,7 @@ static void PED_DEBUG (int level, ...)
va_end (va_args);
}
-#define PED_ASSERT(cond, action) \
+#define PED_ASSERT(cond) \
do { \
if (!(cond)) { \
ped_assert ( \
@@ -79,7 +79,7 @@ static void PED_DEBUG (int level, ...)
#else /* !DEBUG */
-#define PED_ASSERT(cond, action) do {} while (0)
+#define PED_ASSERT(cond) do {} while (0)
#define PED_DEBUG(level, ...) do {} while (0)
diff --git a/libparted/arch/beos.c b/libparted/arch/beos.c
index 76f79b5..41f67d6 100644
--- a/libparted/arch/beos.c
+++ b/libparted/arch/beos.c
@@ -273,7 +273,7 @@ beos_new (const char* path)
struct stat stat_info;
PedDevice* dev;
- PED_ASSERT(path != NULL, return NULL);
+ PED_ASSERT(path != NULL);
dev = (PedDevice*) ped_malloc (sizeof (PedDevice));
if (!dev)
@@ -404,7 +404,7 @@ beos_read (const PedDevice* dev, void* buffer, PedSector
start, PedSector count)
PedExceptionOption ex_status;
size_t read_length = count * dev->sector_size;
- PED_ASSERT(dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0, return 0);
+ PED_ASSERT(dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0);
/* First, try to seek */
while(1)
@@ -478,7 +478,7 @@ beos_write (PedDevice* dev, const void* buffer, PedSector
start,
PedExceptionOption ex_status;
size_t write_length = count * dev->sector_size;
- PED_ASSERT(dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0, return 0);
+ PED_ASSERT(dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0);
if (dev->read_only)
{
@@ -565,7 +565,7 @@ beos_check (PedDevice* dev, void* buffer, PedSector start,
PedSector count)
PedSector done = 0;
int status;
- PED_ASSERT(dev != NULL, return 0);
+ PED_ASSERT(dev != NULL);
if (lseek(arch_specific->fd, start * dev->sector_size, SEEK_SET)
!= start * dev->sector_size)
diff --git a/libparted/arch/gnu.c b/libparted/arch/gnu.c
index cd5dc7f..1ac0319 100644
--- a/libparted/arch/gnu.c
+++ b/libparted/arch/gnu.c
@@ -240,7 +240,7 @@ gnu_new (const char* path)
error_t ro_err, rw_err;
int ispath;
- PED_ASSERT (path != NULL, return NULL);
+ PED_ASSERT (path != NULL);
dev = _init_device (path);
if (!dev)
@@ -309,7 +309,7 @@ ped_device_new_from_store (struct store *source)
PedDevice* dev;
GNUSpecific* arch_specific;
- PED_ASSERT (source != NULL, return NULL);
+ PED_ASSERT (source != NULL);
dev = _init_device (source->name ?: "(unknown)");
if (!dev)
@@ -671,7 +671,7 @@ doggy_first_block_write:
/* We are now left with (strictly) less then a store block to write
to disk. Thus, we read the block, overlay the buffer and flush. */
PED_ASSERT (count * PED_SECTOR_SIZE_DEFAULT
- < arch_specific->store->block_size, return 0);
+ < arch_specific->store->block_size);
doggy_last_block_read:
/* We do not bother looping as we are only reading a
@@ -753,9 +753,9 @@ gnu_check (PedDevice* dev, void* buffer, PedSector start,
PedSector count)
int status;
int done = 0;
- PED_ASSERT (dev != NULL, return 0);
- PED_ASSERT (!dev->external_mode, return 0);
- PED_ASSERT (buffer != NULL, return 0);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (!dev->external_mode);
+ PED_ASSERT (buffer != NULL);
return count;
}
@@ -768,8 +768,8 @@ gnu_sync (PedDevice* dev)
PedExceptionOption ex_status;
static char *last_failure = NULL;
- PED_ASSERT (dev != NULL, return 0);
- PED_ASSERT (!dev->external_mode, return 0);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (!dev->external_mode);
arch_specific = GNU_SPECIFIC (dev);
diff --git a/libparted/arch/linux.c b/libparted/arch/linux.c
index 8d9ce1a..e77210e 100644
--- a/libparted/arch/linux.c
+++ b/libparted/arch/linux.c
@@ -507,8 +507,8 @@ _probe_dm_devices ()
static int
_device_stat (PedDevice* dev, struct stat * dev_stat)
{
- PED_ASSERT (dev != NULL, return 0);
- PED_ASSERT (!dev->external_mode, return 0);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (!dev->external_mode);
while (1) {
if (!stat (dev->path, dev_stat)) {
@@ -655,7 +655,7 @@ _device_set_sector_size (PedDevice* dev)
dev->sector_size = PED_SECTOR_SIZE_DEFAULT;
dev->phys_sector_size = PED_SECTOR_SIZE_DEFAULT;
- PED_ASSERT (dev->open_count, return);
+ PED_ASSERT (dev->open_count);
if (_get_linux_version() < KERNEL_VERSION (2,3,0)) {
dev->sector_size = PED_SECTOR_SIZE_DEFAULT;
@@ -725,8 +725,8 @@ _device_get_length (PedDevice* dev)
PedSector test_size;
- PED_ASSERT (dev->open_count > 0, return 0);
- PED_ASSERT (dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0, return 0);
+ PED_ASSERT (dev->open_count > 0);
+ PED_ASSERT (dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0);
test_str = getenv ("PARTED_TEST_DEVICE_LENGTH");
if (test_str
@@ -761,7 +761,7 @@ _device_probe_geometry (PedDevice* dev)
if (!_device_stat (dev, &dev_stat))
return 0;
- PED_ASSERT (S_ISBLK (dev_stat.st_mode), return 0);
+ PED_ASSERT (S_ISBLK (dev_stat.st_mode));
_device_set_sector_size (dev);
@@ -841,7 +841,7 @@ init_ide (PedDevice* dev)
dev->model = strdup(_("Generic IDE"));
break;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
} else {
@@ -877,7 +877,7 @@ init_ide (PedDevice* dev)
case PED_EXCEPTION_IGNORE:
break;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
}
@@ -1137,7 +1137,7 @@ init_dasd (PedDevice* dev, const char* model_name)
LinuxSpecific* arch_specific = LINUX_SPECIFIC (dev);
- PED_ASSERT (S_ISBLK (dev_stat.st_mode), return 0);
+ PED_ASSERT (S_ISBLK (dev_stat.st_mode));
_device_set_sector_size (dev);
if (!dev->sector_size)
@@ -1224,7 +1224,7 @@ init_generic (PedDevice* dev, const char* model_name)
case PED_EXCEPTION_IGNORE:
break;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
@@ -1282,7 +1282,7 @@ linux_new (const char* path)
PedDevice* dev;
LinuxSpecific* arch_specific;
- PED_ASSERT (path != NULL, return NULL);
+ PED_ASSERT (path != NULL);
dev = (PedDevice*) ped_malloc (sizeof (PedDevice));
if (!dev)
@@ -1630,9 +1630,9 @@ _device_seek (const PedDevice* dev, PedSector sector)
{
LinuxSpecific* arch_specific;
- PED_ASSERT (dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0, return 0);
- PED_ASSERT (dev != NULL, return 0);
- PED_ASSERT (!dev->external_mode, return 0);
+ PED_ASSERT (dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (!dev->external_mode);
arch_specific = LINUX_SPECIFIC (dev);
@@ -1654,8 +1654,8 @@ _read_lastoddsector (const PedDevice* dev, void* buffer)
LinuxSpecific* arch_specific;
struct blkdev_ioctl_param ioctl_param;
- PED_ASSERT(dev != NULL, return 0);
- PED_ASSERT(buffer != NULL, return 0);
+ PED_ASSERT(dev != NULL);
+ PED_ASSERT(buffer != NULL);
arch_specific = LINUX_SPECIFIC (dev);
@@ -1689,8 +1689,8 @@ linux_read (const PedDevice* dev, void* buffer, PedSector
start,
PedExceptionOption ex_status;
void* diobuf = NULL;
- PED_ASSERT (dev != NULL, return 0);
- PED_ASSERT (dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0, return 0);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0);
if (_get_linux_version() < KERNEL_VERSION (2,6,0)) {
/* Kludge. This is necessary to read/write the last
@@ -1724,7 +1724,7 @@ linux_read (const PedDevice* dev, void* buffer, PedSector
start,
case PED_EXCEPTION_CANCEL:
return 0;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
}
@@ -1768,7 +1768,7 @@ linux_read (const PedDevice* dev, void* buffer, PedSector
start,
free(diobuf);
return 0;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
}
@@ -1784,8 +1784,8 @@ _write_lastoddsector (PedDevice* dev, const void* buffer)
LinuxSpecific* arch_specific;
struct blkdev_ioctl_param ioctl_param;
- PED_ASSERT(dev != NULL, return 0);
- PED_ASSERT(buffer != NULL, return 0);
+ PED_ASSERT(dev != NULL);
+ PED_ASSERT(buffer != NULL);
arch_specific = LINUX_SPECIFIC (dev);
@@ -1820,7 +1820,7 @@ linux_write (PedDevice* dev, const void* buffer,
PedSector start,
void* diobuf;
void* diobuf_start;
- PED_ASSERT(dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0, return 0);
+ PED_ASSERT(dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0);
if (dev->read_only) {
if (ped_exception_throw (
@@ -1866,7 +1866,7 @@ linux_write (PedDevice* dev, const void* buffer,
PedSector start,
case PED_EXCEPTION_CANCEL:
return 0;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
}
@@ -1910,7 +1910,7 @@ linux_write (PedDevice* dev, const void* buffer,
PedSector start,
free(diobuf_start);
return 0;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
}
@@ -1929,7 +1929,7 @@ linux_check (PedDevice* dev, void* buffer, PedSector
start, PedSector count)
int status;
void* diobuf;
- PED_ASSERT(dev != NULL, return 0);
+ PED_ASSERT(dev != NULL);
if (!_device_seek (dev, start))
return 0;
@@ -1980,7 +1980,7 @@ _do_fsync (PedDevice* dev)
case PED_EXCEPTION_CANCEL:
return 0;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
}
@@ -1990,8 +1990,8 @@ _do_fsync (PedDevice* dev)
static int
linux_sync (PedDevice* dev)
{
- PED_ASSERT (dev != NULL, return 0);
- PED_ASSERT (!dev->external_mode, return 0);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (!dev->external_mode);
if (dev->read_only)
return 1;
@@ -2004,8 +2004,8 @@ linux_sync (PedDevice* dev)
static int
linux_sync_fast (PedDevice* dev)
{
- PED_ASSERT (dev != NULL, return 0);
- PED_ASSERT (!dev->external_mode, return 0);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (!dev->external_mode);
if (dev->read_only)
return 1;
@@ -2302,7 +2302,7 @@ _partition_is_mounted (const PedPartition *part)
static int
_has_partitions (const PedDisk* disk)
{
- PED_ASSERT(disk != NULL, return 0);
+ PED_ASSERT(disk != NULL);
/* Some devices can't be partitioned. */
if (!strcmp (disk->type->name, "loop"))
@@ -2316,7 +2316,7 @@ linux_partition_is_busy (const PedPartition* part)
{
PedPartition* walk;
- PED_ASSERT (part != NULL, return 0);
+ PED_ASSERT (part != NULL);
if (_partition_is_mounted (part))
return 1;
@@ -2350,9 +2350,8 @@ _blkpg_add_partition (PedDisk* disk, const PedPartition
*part)
const char* vol_name;
char* dev_name;
- PED_ASSERT(disk != NULL, return 0);
- PED_ASSERT(disk->dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0,
- return 0);
+ PED_ASSERT(disk != NULL);
+ PED_ASSERT(disk->dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0);
if (!_has_partitions (disk))
return 0;
@@ -2460,8 +2459,8 @@ _device_get_partition_range(PedDevice* dev)
static int
_disk_sync_part_table (PedDisk* disk)
{
- PED_ASSERT(disk != NULL, return 0);
- PED_ASSERT(disk->dev != NULL, return 0);
+ PED_ASSERT(disk != NULL);
+ PED_ASSERT(disk->dev != NULL);
int lpn;
/* lpn = largest partition number. */
diff --git a/libparted/cs/constraint.c b/libparted/cs/constraint.c
index 5588f51..f4181c5 100644
--- a/libparted/cs/constraint.c
+++ b/libparted/cs/constraint.c
@@ -63,11 +63,11 @@ ped_constraint_init (
PedSector min_size,
PedSector max_size)
{
- PED_ASSERT (constraint != NULL, return 0);
- PED_ASSERT (start_range != NULL, return 0);
- PED_ASSERT (end_range != NULL, return 0);
- PED_ASSERT (min_size > 0, return 0);
- PED_ASSERT (max_size > 0, return 0);
+ PED_ASSERT (constraint != NULL);
+ PED_ASSERT (start_range != NULL);
+ PED_ASSERT (end_range != NULL);
+ PED_ASSERT (min_size > 0);
+ PED_ASSERT (max_size > 0);
constraint->start_align = ped_alignment_duplicate (start_align);
constraint->end_align = ped_alignment_duplicate (end_align);
@@ -125,9 +125,9 @@ ped_constraint_new_from_min_max (
PedGeometry start_range;
PedGeometry end_range;
- PED_ASSERT (min != NULL, return NULL);
- PED_ASSERT (max != NULL, return NULL);
- PED_ASSERT (ped_geometry_test_inside (max, min), return NULL);
+ PED_ASSERT (min != NULL);
+ PED_ASSERT (max != NULL);
+ PED_ASSERT (ped_geometry_test_inside (max, min));
ped_geometry_init (&start_range, min->dev, max->start,
min->start - max->start + 1);
@@ -150,7 +150,7 @@ ped_constraint_new_from_min (const PedGeometry* min)
{
PedGeometry full_dev;
- PED_ASSERT (min != NULL, return NULL);
+ PED_ASSERT (min != NULL);
ped_geometry_init (&full_dev, min->dev, 0, min->dev->length);
return ped_constraint_new_from_min_max (min, &full_dev);
@@ -165,7 +165,7 @@ ped_constraint_new_from_min (const PedGeometry* min)
PedConstraint*
ped_constraint_new_from_max (const PedGeometry* max)
{
- PED_ASSERT (max != NULL, return NULL);
+ PED_ASSERT (max != NULL);
return ped_constraint_new (
ped_alignment_any, ped_alignment_any,
@@ -180,7 +180,7 @@ ped_constraint_new_from_max (const PedGeometry* max)
PedConstraint*
ped_constraint_duplicate (const PedConstraint* constraint)
{
- PED_ASSERT (constraint != NULL, return NULL);
+ PED_ASSERT (constraint != NULL);
return ped_constraint_new (
constraint->start_align,
@@ -260,7 +260,7 @@ empty:
void
ped_constraint_done (PedConstraint* constraint)
{
- PED_ASSERT (constraint != NULL, return);
+ PED_ASSERT (constraint != NULL);
ped_alignment_destroy (constraint->start_align);
ped_alignment_destroy (constraint->end_align);
@@ -416,8 +416,8 @@ ped_constraint_solve_nearest (
if (constraint == NULL)
return NULL;
- PED_ASSERT (geom != NULL, return NULL);
- PED_ASSERT (constraint->start_range->dev == geom->dev, return NULL);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (constraint->start_range->dev == geom->dev);
start = _constraint_get_nearest_start_soln (constraint, geom->start);
if (start == -1)
@@ -429,8 +429,7 @@ ped_constraint_solve_nearest (
result = ped_geometry_new (geom->dev, start, end - start + 1);
if (!result)
return NULL;
- PED_ASSERT (ped_constraint_is_solution (constraint, result),
- return NULL);
+ PED_ASSERT (ped_constraint_is_solution (constraint, result));
return result;
}
@@ -462,8 +461,8 @@ int
ped_constraint_is_solution (const PedConstraint* constraint,
const PedGeometry* geom)
{
- PED_ASSERT (constraint != NULL, return 0);
- PED_ASSERT (geom != NULL, return 0);
+ PED_ASSERT (constraint != NULL);
+ PED_ASSERT (geom != NULL);
if (!ped_alignment_is_aligned (constraint->start_align, NULL,
geom->start))
diff --git a/libparted/cs/geom.c b/libparted/cs/geom.c
index 6d00b24..c7d92f1 100644
--- a/libparted/cs/geom.c
+++ b/libparted/cs/geom.c
@@ -56,8 +56,8 @@ int
ped_geometry_init (PedGeometry* geom, const PedDevice* dev,
PedSector start, PedSector length)
{
- PED_ASSERT (geom != NULL, return 0);
- PED_ASSERT (dev != NULL, return 0);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (dev != NULL);
geom->dev = (PedDevice*) dev;
return ped_geometry_set (geom, start, length);
@@ -74,7 +74,7 @@ ped_geometry_new (const PedDevice* dev, PedSector start,
PedSector length)
{
PedGeometry* geom;
- PED_ASSERT (dev != NULL, return NULL);
+ PED_ASSERT (dev != NULL);
geom = (PedGeometry*) ped_malloc (sizeof (PedGeometry));
if (!geom)
@@ -102,7 +102,7 @@ error:
PedGeometry*
ped_geometry_duplicate (const PedGeometry* geom)
{
- PED_ASSERT (geom != NULL, return NULL);
+ PED_ASSERT (geom != NULL);
return ped_geometry_new (geom->dev, geom->start, geom->length);
}
@@ -138,7 +138,7 @@ ped_geometry_intersect (const PedGeometry* a, const
PedGeometry* b)
void
ped_geometry_destroy (PedGeometry* geom)
{
- PED_ASSERT (geom != NULL, return);
+ PED_ASSERT (geom != NULL);
free (geom);
}
@@ -151,8 +151,8 @@ ped_geometry_destroy (PedGeometry* geom)
int
ped_geometry_set (PedGeometry* geom, PedSector start, PedSector length)
{
- PED_ASSERT (geom != NULL, return 0);
- PED_ASSERT (geom->dev != NULL, return 0);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (geom->dev != NULL);
if (length < 1) {
ped_exception_throw (
@@ -209,8 +209,8 @@ ped_geometry_set_end (PedGeometry* geom, PedSector end)
int
ped_geometry_test_overlap (const PedGeometry* a, const PedGeometry* b)
{
- PED_ASSERT (a != NULL, return 0);
- PED_ASSERT (b != NULL, return 0);
+ PED_ASSERT (a != NULL);
+ PED_ASSERT (b != NULL);
if (a->dev != b->dev)
return 0;
@@ -231,8 +231,8 @@ ped_geometry_test_overlap (const PedGeometry* a, const
PedGeometry* b)
int
ped_geometry_test_inside (const PedGeometry* a, const PedGeometry* b)
{
- PED_ASSERT (a != NULL, return 0);
- PED_ASSERT (b != NULL, return 0);
+ PED_ASSERT (a != NULL);
+ PED_ASSERT (b != NULL);
if (a->dev != b->dev)
return 0;
@@ -249,8 +249,8 @@ ped_geometry_test_inside (const PedGeometry* a, const
PedGeometry* b)
int
ped_geometry_test_equal (const PedGeometry* a, const PedGeometry* b)
{
- PED_ASSERT (a != NULL, return 0);
- PED_ASSERT (b != NULL, return 0);
+ PED_ASSERT (a != NULL);
+ PED_ASSERT (b != NULL);
return a->dev == b->dev
&& a->start == b->start
@@ -265,7 +265,7 @@ ped_geometry_test_equal (const PedGeometry* a, const
PedGeometry* b)
int
ped_geometry_test_sector_inside (const PedGeometry* geom, PedSector sector)
{
- PED_ASSERT (geom != NULL, return 0);
+ PED_ASSERT (geom != NULL);
return sector >= geom->start && sector <= geom->end;
}
@@ -290,10 +290,10 @@ ped_geometry_read (const PedGeometry* geom, void* buffer,
PedSector offset,
{
PedSector real_start;
- PED_ASSERT (geom != NULL, return 0);
- PED_ASSERT (buffer != NULL, return 0);
- PED_ASSERT (offset >= 0, return 0);
- PED_ASSERT (count >= 0, return 0);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (buffer != NULL);
+ PED_ASSERT (offset >= 0);
+ PED_ASSERT (count >= 0);
real_start = geom->start + offset;
@@ -335,7 +335,7 @@ ped_geometry_read_alloc (const PedGeometry* geom, void**
buffer,
int
ped_geometry_sync (PedGeometry* geom)
{
- PED_ASSERT (geom != NULL, return 0);
+ PED_ASSERT (geom != NULL);
return ped_device_sync (geom->dev);
}
@@ -352,7 +352,7 @@ ped_geometry_sync (PedGeometry* geom)
int
ped_geometry_sync_fast (PedGeometry* geom)
{
- PED_ASSERT (geom != NULL, return 0);
+ PED_ASSERT (geom != NULL);
return ped_device_sync_fast (geom->dev);
}
@@ -370,10 +370,10 @@ ped_geometry_write (PedGeometry* geom, const void*
buffer, PedSector offset,
int exception_status;
PedSector real_start;
- PED_ASSERT (geom != NULL, return 0);
- PED_ASSERT (buffer != NULL, return 0);
- PED_ASSERT (offset >= 0, return 0);
- PED_ASSERT (count >= 0, return 0);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (buffer != NULL);
+ PED_ASSERT (offset >= 0);
+ PED_ASSERT (count >= 0);
real_start = geom->start + offset;
@@ -417,8 +417,8 @@ ped_geometry_check (PedGeometry* geom, void* buffer,
PedSector buffer_size,
PedSector i;
PedSector read_len;
- PED_ASSERT (geom != NULL, return 0);
- PED_ASSERT (buffer != NULL, return 0);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (buffer != NULL);
ped_timer_reset (timer);
ped_timer_set_state_name (timer, _("checking for bad blocks"));
@@ -474,8 +474,8 @@ ped_geometry_map (const PedGeometry* dst, const
PedGeometry* src,
{
PedSector result;
- PED_ASSERT (dst != NULL, return 0);
- PED_ASSERT (src != NULL, return 0);
+ PED_ASSERT (dst != NULL);
+ PED_ASSERT (src != NULL);
if (!ped_geometry_test_sector_inside (src, sector))
return -1;
diff --git a/libparted/cs/natmath.c b/libparted/cs/natmath.c
index 592bce3..0294436 100644
--- a/libparted/cs/natmath.c
+++ b/libparted/cs/natmath.c
@@ -102,8 +102,8 @@ ped_round_to_nearest (PedSector sector, PedSector
grain_size)
PedSector
ped_greatest_common_divisor (PedSector a, PedSector b)
{
- PED_ASSERT (a >= 0, return 0);
- PED_ASSERT (b >= 0, return 0);
+ PED_ASSERT (a >= 0);
+ PED_ASSERT (b >= 0);
/* Put the arguments in the "right" format. (Recursive calls made by
* this function are always in the right format.)
@@ -127,7 +127,7 @@ ped_greatest_common_divisor (PedSector a, PedSector b)
int
ped_alignment_init (PedAlignment* align, PedSector offset, PedSector
grain_size)
{
- PED_ASSERT (align != NULL, return 0);
+ PED_ASSERT (align != NULL);
if (grain_size < 0)
return 0;
@@ -344,7 +344,7 @@ static PedSector
_closest_inside_geometry (const PedAlignment* align, const PedGeometry* geom,
PedSector sector)
{
- PED_ASSERT (align != NULL, return -1);
+ PED_ASSERT (align != NULL);
if (!align->grain_size) {
if (ped_alignment_is_aligned (align, geom, sector)
@@ -381,7 +381,7 @@ ped_alignment_align_up (const PedAlignment* align, const
PedGeometry* geom,
{
PedSector result;
- PED_ASSERT (align != NULL, return -1);
+ PED_ASSERT (align != NULL);
if (!align->grain_size)
result = align->offset;
@@ -409,7 +409,7 @@ ped_alignment_align_down (const PedAlignment* align, const
PedGeometry* geom,
{
PedSector result;
- PED_ASSERT (align != NULL, return -1);
+ PED_ASSERT (align != NULL);
if (!align->grain_size)
result = align->offset;
@@ -448,7 +448,7 @@ PedSector
ped_alignment_align_nearest (const PedAlignment* align, const PedGeometry*
geom,
PedSector sector)
{
- PED_ASSERT (align != NULL, return -1);
+ PED_ASSERT (align != NULL);
return closest (sector, ped_alignment_align_up (align, geom, sector),
ped_alignment_align_down (align, geom, sector));
diff --git a/libparted/device.c b/libparted/device.c
index 6cbfaaf..738b320 100644
--- a/libparted/device.c
+++ b/libparted/device.c
@@ -110,7 +110,7 @@ _ped_device_probe (const char* path)
{
PedDevice* dev;
- PED_ASSERT (path != NULL, return);
+ PED_ASSERT (path != NULL);
ped_exception_fetch_all ();
dev = ped_device_get (path);
@@ -151,7 +151,7 @@ ped_device_get (const char* path)
PedDevice* walk;
char* normal_path = NULL;
- PED_ASSERT (path != NULL, return NULL);
+ PED_ASSERT (path != NULL);
/* Don't canonicalize /dev/mapper paths, see tests/symlink.c */
if (strncmp (path, "/dev/mapper/", 12))
normal_path = canonicalize_file_name (path);
@@ -224,8 +224,8 @@ ped_device_open (PedDevice* dev)
{
int status;
- PED_ASSERT (dev != NULL, return 0);
- PED_ASSERT (!dev->external_mode, return 0);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (!dev->external_mode);
if (dev->open_count)
status = ped_architecture->dev_ops->refresh_open (dev);
@@ -246,9 +246,9 @@ ped_device_open (PedDevice* dev)
int
ped_device_close (PedDevice* dev)
{
- PED_ASSERT (dev != NULL, return 0);
- PED_ASSERT (!dev->external_mode, return 0);
- PED_ASSERT (dev->open_count > 0, return 0);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (!dev->external_mode);
+ PED_ASSERT (dev->open_count > 0);
if (--dev->open_count)
return ped_architecture->dev_ops->refresh_close (dev);
@@ -283,8 +283,8 @@ ped_device_close (PedDevice* dev)
int
ped_device_begin_external_access (PedDevice* dev)
{
- PED_ASSERT (dev != NULL, return 0);
- PED_ASSERT (!dev->external_mode, return 0);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (!dev->external_mode);
dev->external_mode = 1;
if (dev->open_count)
@@ -303,8 +303,8 @@ ped_device_begin_external_access (PedDevice* dev)
int
ped_device_end_external_access (PedDevice* dev)
{
- PED_ASSERT (dev != NULL, return 0);
- PED_ASSERT (dev->external_mode, return 0);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (dev->external_mode);
dev->external_mode = 0;
if (dev->open_count)
@@ -323,10 +323,10 @@ int
ped_device_read (const PedDevice* dev, void* buffer, PedSector start,
PedSector count)
{
- PED_ASSERT (dev != NULL, return 0);
- PED_ASSERT (buffer != NULL, return 0);
- PED_ASSERT (!dev->external_mode, return 0);
- PED_ASSERT (dev->open_count > 0, return 0);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (buffer != NULL);
+ PED_ASSERT (!dev->external_mode);
+ PED_ASSERT (dev->open_count > 0);
return (ped_architecture->dev_ops->read) (dev, buffer, start, count);
}
@@ -344,10 +344,10 @@ int
ped_device_write (PedDevice* dev, const void* buffer, PedSector start,
PedSector count)
{
- PED_ASSERT (dev != NULL, return 0);
- PED_ASSERT (buffer != NULL, return 0);
- PED_ASSERT (!dev->external_mode, return 0);
- PED_ASSERT (dev->open_count > 0, return 0);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (buffer != NULL);
+ PED_ASSERT (!dev->external_mode);
+ PED_ASSERT (dev->open_count > 0);
return (ped_architecture->dev_ops->write) (dev, buffer, start, count);
}
@@ -356,9 +356,9 @@ PedSector
ped_device_check (PedDevice* dev, void* buffer, PedSector start,
PedSector count)
{
- PED_ASSERT (dev != NULL, return 0);
- PED_ASSERT (!dev->external_mode, return 0);
- PED_ASSERT (dev->open_count > 0, return 0);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (!dev->external_mode);
+ PED_ASSERT (dev->open_count > 0);
return (ped_architecture->dev_ops->check) (dev, buffer, start, count);
}
@@ -373,9 +373,9 @@ ped_device_check (PedDevice* dev, void* buffer, PedSector
start,
int
ped_device_sync (PedDevice* dev)
{
- PED_ASSERT (dev != NULL, return 0);
- PED_ASSERT (!dev->external_mode, return 0);
- PED_ASSERT (dev->open_count > 0, return 0);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (!dev->external_mode);
+ PED_ASSERT (dev->open_count > 0);
return ped_architecture->dev_ops->sync (dev);
}
@@ -390,9 +390,9 @@ ped_device_sync (PedDevice* dev)
int
ped_device_sync_fast (PedDevice* dev)
{
- PED_ASSERT (dev != NULL, return 0);
- PED_ASSERT (!dev->external_mode, return 0);
- PED_ASSERT (dev->open_count > 0, return 0);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (!dev->external_mode);
+ PED_ASSERT (dev->open_count > 0);
return ped_architecture->dev_ops->sync_fast (dev);
}
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))
diff --git a/libparted/exception.c b/libparted/exception.c
index 52f56b7..910d25c 100644
--- a/libparted/exception.c
+++ b/libparted/exception.c
@@ -108,7 +108,7 @@ ped_log2 (int n)
{
int x;
- PED_ASSERT (n > 0, return -1);
+ PED_ASSERT (n > 0);
for (x=0; 1 << x <= n; x++);
@@ -304,7 +304,7 @@ ped_exception_fetch_all ()
void
ped_exception_leave_all ()
{
- PED_ASSERT (ex_fetch_count > 0, return);
+ PED_ASSERT (ex_fetch_count > 0);
ex_fetch_count--;
}
diff --git a/libparted/filesys.c b/libparted/filesys.c
index 198e131..c3be2e1 100644
--- a/libparted/filesys.c
+++ b/libparted/filesys.c
@@ -46,9 +46,9 @@ static PedFileSystemAlias* fs_aliases = NULL;
void
ped_file_system_type_register (PedFileSystemType* fs_type)
{
- PED_ASSERT (fs_type != NULL, return);
- PED_ASSERT (fs_type->ops != NULL, return);
- PED_ASSERT (fs_type->name != NULL, return);
+ PED_ASSERT (fs_type != NULL);
+ PED_ASSERT (fs_type->ops != NULL);
+ PED_ASSERT (fs_type->name != NULL);
fs_type->next = fs_types;
fs_types = fs_type;
@@ -60,13 +60,13 @@ ped_file_system_type_unregister (PedFileSystemType* fs_type)
PedFileSystemType* walk;
PedFileSystemType* last = NULL;
- PED_ASSERT (fs_types != NULL, return);
- PED_ASSERT (fs_type != NULL, return);
+ PED_ASSERT (fs_types != NULL);
+ PED_ASSERT (fs_type != NULL);
for (walk = fs_types; walk && walk != fs_type;
last = walk, walk = walk->next);
- PED_ASSERT (walk != NULL, return);
+ PED_ASSERT (walk != NULL);
if (last)
((struct _PedFileSystemType*) last)->next = fs_type->next;
else
@@ -79,8 +79,8 @@ ped_file_system_alias_register (PedFileSystemType* fs_type,
const char* alias,
{
PedFileSystemAlias* fs_alias;
- PED_ASSERT (fs_type != NULL, return);
- PED_ASSERT (alias != NULL, return);
+ PED_ASSERT (fs_type != NULL);
+ PED_ASSERT (alias != NULL);
fs_alias = ped_malloc (sizeof *fs_alias);
if (!fs_alias)
@@ -100,16 +100,16 @@ ped_file_system_alias_unregister (PedFileSystemType*
fs_type,
PedFileSystemAlias* walk;
PedFileSystemAlias* last = NULL;
- PED_ASSERT (fs_aliases != NULL, return);
- PED_ASSERT (fs_type != NULL, return);
- PED_ASSERT (alias != NULL, return);
+ PED_ASSERT (fs_aliases != NULL);
+ PED_ASSERT (fs_type != NULL);
+ PED_ASSERT (alias != NULL);
for (walk = fs_aliases; walk; last = walk, walk = walk->next) {
if (walk->fs_type == fs_type && !strcmp (walk->alias, alias))
break;
}
- PED_ASSERT (walk != NULL, return);
+ PED_ASSERT (walk != NULL);
if (last)
last->next = walk->next;
else
@@ -128,7 +128,7 @@ ped_file_system_type_get (const char* name)
PedFileSystemType* walk;
PedFileSystemAlias* alias_walk;
- PED_ASSERT (name != NULL, return NULL);
+ PED_ASSERT (name != NULL);
for (walk = fs_types; walk != NULL; walk = walk->next) {
if (!strcasecmp (walk->name, name))
@@ -194,9 +194,9 @@ ped_file_system_probe_specific (
{
PedGeometry* result;
- PED_ASSERT (fs_type != NULL, return NULL);
- PED_ASSERT (fs_type->ops->probe != NULL, return NULL);
- PED_ASSERT (geom != NULL, return NULL);
+ PED_ASSERT (fs_type != NULL);
+ PED_ASSERT (fs_type->ops->probe != NULL);
+ PED_ASSERT (geom != NULL);
/* Fail all fs-specific probe-related tests when sector size
is not the default. */
@@ -326,7 +326,7 @@ ped_file_system_probe (PedGeometry* geom)
int detected_count = 0;
PedFileSystemType* walk = NULL;
- PED_ASSERT (geom != NULL, return NULL);
+ PED_ASSERT (geom != NULL);
if (!ped_device_open (geom->dev))
return NULL;
@@ -372,7 +372,7 @@ ped_file_system_clobber (PedGeometry* geom)
{
PedFileSystemType* fs_type = NULL;
- PED_ASSERT (geom != NULL, return 0);
+ PED_ASSERT (geom != NULL);
if (!ped_device_open (geom->dev))
goto error;
@@ -451,7 +451,7 @@ ped_file_system_open (PedGeometry* geom)
PedFileSystem* fs;
PedGeometry* probed_geom;
- PED_ASSERT (geom != NULL, return NULL);
+ PED_ASSERT (geom != NULL);
if (!ped_device_open (geom->dev))
goto error;
@@ -514,8 +514,8 @@ ped_file_system_create (PedGeometry* geom, const
PedFileSystemType* type,
{
PedFileSystem* fs;
- PED_ASSERT (geom != NULL, return NULL);
- PED_ASSERT (type != NULL, return NULL);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (type != NULL);
if (!type->ops->create) {
ped_exception_throw (PED_EXCEPTION_NO_FEATURE,
@@ -552,7 +552,7 @@ ped_file_system_close (PedFileSystem* fs)
{
PedDevice* dev = fs->geom->dev;
- PED_ASSERT (fs != NULL, goto error_close_dev);
+ PED_ASSERT (fs != NULL);
if (!fs->type->ops->close (fs))
goto error_close_dev;
@@ -575,7 +575,7 @@ error_close_dev:
int
ped_file_system_check (PedFileSystem* fs, PedTimer* timer)
{
- PED_ASSERT (fs != NULL, return 0);
+ PED_ASSERT (fs != NULL);
if (!fs->type->ops->check) {
ped_exception_throw (PED_EXCEPTION_NO_FEATURE,
@@ -594,9 +594,9 @@ _raw_copy (const PedGeometry* src, PedGeometry* dest,
PedTimer* timer)
char* buf;
PedSector pos;
- PED_ASSERT (src != NULL, goto error);
- PED_ASSERT (dest != NULL, goto error);
- PED_ASSERT (src->length <= dest->length, goto error);
+ PED_ASSERT (src != NULL);
+ PED_ASSERT (dest != NULL);
+ PED_ASSERT (src->length <= dest->length);
buf = ped_malloc (BUFFER_SIZE * 512); /* FIXME */
if (!buf)
@@ -688,8 +688,8 @@ ped_file_system_copy (PedFileSystem* fs, PedGeometry* geom,
PedTimer* timer)
{
PedFileSystem* new_fs;
- PED_ASSERT (fs != NULL, return 0);
- PED_ASSERT (geom != NULL, return 0);
+ PED_ASSERT (fs != NULL);
+ PED_ASSERT (geom != NULL);
if (!ped_device_open (geom->dev))
goto error;
@@ -765,8 +765,8 @@ error:
int
ped_file_system_resize (PedFileSystem* fs, PedGeometry* geom, PedTimer* timer)
{
- PED_ASSERT (fs != NULL, return 0);
- PED_ASSERT (geom != NULL, return 0);
+ PED_ASSERT (fs != NULL);
+ PED_ASSERT (geom != NULL);
if (!fs->type->ops->resize) {
ped_exception_throw (PED_EXCEPTION_NO_FEATURE,
@@ -798,8 +798,8 @@ PedConstraint*
ped_file_system_get_create_constraint (const PedFileSystemType* fs_type,
const PedDevice* dev)
{
- PED_ASSERT (fs_type != NULL, return NULL);
- PED_ASSERT (dev != NULL, return NULL);
+ PED_ASSERT (fs_type != NULL);
+ PED_ASSERT (dev != NULL);
if (!fs_type->ops->get_create_constraint)
return NULL;
@@ -821,7 +821,7 @@ ped_file_system_get_create_constraint (const
PedFileSystemType* fs_type,
PedConstraint*
ped_file_system_get_resize_constraint (const PedFileSystem* fs)
{
- PED_ASSERT (fs != NULL, return 0);
+ PED_ASSERT (fs != NULL);
if (!fs->type->ops->get_resize_constraint)
return NULL;
@@ -840,8 +840,8 @@ ped_file_system_get_copy_constraint (const PedFileSystem*
fs,
{
PedGeometry full_dev;
- PED_ASSERT (fs != NULL, return NULL);
- PED_ASSERT (dev != NULL, return NULL);
+ PED_ASSERT (fs != NULL);
+ PED_ASSERT (dev != NULL);
if (fs->type->ops->get_copy_constraint)
return fs->type->ops->get_copy_constraint (fs, dev);
diff --git a/libparted/fs/amiga/affs.c b/libparted/fs/amiga/affs.c
index 974c649..11d375c 100644
--- a/libparted/fs/amiga/affs.c
+++ b/libparted/fs/amiga/affs.c
@@ -53,8 +53,8 @@ _generic_affs_probe (PedGeometry* geom, uint32_t kind)
struct PartitionBlock * part;
int blocksize = 1, reserved = 2, prealloc = 0;
- PED_ASSERT (geom != NULL, return NULL);
- PED_ASSERT (geom->dev != NULL, return NULL);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (geom->dev != NULL);
/* Finds the blocksize, prealloc and reserved values of the partition
block */
if (!(part = ped_malloc (PED_SECTOR_SIZE_DEFAULT*blocksize))) {
diff --git a/libparted/fs/amiga/amiga.c b/libparted/fs/amiga/amiga.c
index 415208a..7052bfc 100644
--- a/libparted/fs/amiga/amiga.c
+++ b/libparted/fs/amiga/amiga.c
@@ -268,8 +268,8 @@ amiga_find_part (PedGeometry *geom, struct PartitionBlock
*part)
uint32_t partlist[AMIGA_MAX_PARTITIONS];
int i;
- PED_ASSERT(geom!= NULL, return NULL);
- PED_ASSERT(geom->dev!= NULL, return NULL);
+ PED_ASSERT(geom!= NULL);
+ PED_ASSERT(geom->dev!= NULL);
if (!(rdb = ped_malloc (PED_SECTOR_SIZE_DEFAULT))) {
switch (ped_exception_throw(PED_EXCEPTION_ERROR,
diff --git a/libparted/fs/amiga/apfs.c b/libparted/fs/amiga/apfs.c
index dd948d9..d5ece60 100644
--- a/libparted/fs/amiga/apfs.c
+++ b/libparted/fs/amiga/apfs.c
@@ -46,8 +46,8 @@ _generic_apfs_probe (PedGeometry* geom, uint32_t kind)
struct PartitionBlock * part;
uint32_t blocksize = 1, reserved = 2;
- PED_ASSERT (geom != NULL, return NULL);
- PED_ASSERT (geom->dev != NULL, return NULL);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (geom->dev != NULL);
/* Finds the blocksize and reserved values of the partition block */
if (!(part = ped_malloc (PED_SECTOR_SIZE_DEFAULT*blocksize))) {
diff --git a/libparted/fs/amiga/asfs.c b/libparted/fs/amiga/asfs.c
index 273ab37..2cd8307 100644
--- a/libparted/fs/amiga/asfs.c
+++ b/libparted/fs/amiga/asfs.c
@@ -60,8 +60,8 @@ _asfs_probe (PedGeometry* geom)
PedSector root;
int found = 0;
- PED_ASSERT (geom != NULL, return NULL);
- PED_ASSERT (geom->dev != NULL, return NULL);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (geom->dev != NULL);
/* Finds the blocksize of the partition block */
if (!(part = ped_malloc (PED_SECTOR_SIZE_DEFAULT*blocksize))) {
diff --git a/libparted/fs/bfs/bfs.c b/libparted/fs/bfs/bfs.c
index 1e68b53..d85f331 100644
--- a/libparted/fs/bfs/bfs.c
+++ b/libparted/fs/bfs/bfs.c
@@ -48,8 +48,8 @@ bfs_probe (PedGeometry* geom)
{
uint8_t* buf;
- PED_ASSERT (geom != NULL, return NULL);
- PED_ASSERT (geom->dev != NULL, return NULL);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (geom->dev != NULL);
buf = ped_malloc (geom->dev->sector_size);
@@ -71,8 +71,8 @@ bfs_clobber (PedGeometry* geom)
{
uint8_t* buf;
- PED_ASSERT (geom != NULL, return 0);
- PED_ASSERT (geom->dev != NULL, return 0);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (geom->dev != NULL);
buf = ped_malloc (geom->dev->sector_size);
@@ -132,8 +132,8 @@ bfs_open (PedGeometry *geom)
struct BfsSpecific* bfs;
uint8_t* buf;
- PED_ASSERT (geom != NULL, return NULL);
- PED_ASSERT (geom->dev != NULL, return NULL);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (geom->dev != NULL);
buf = ped_malloc (geom->dev->sector_size);
diff --git a/libparted/fs/ext2/ext2.h b/libparted/fs/ext2/ext2.h
index a259246..eb647b4 100644
--- a/libparted/fs/ext2/ext2.h
+++ b/libparted/fs/ext2/ext2.h
@@ -217,8 +217,8 @@ static __inline__ int ext2_is_data_block(struct ext2_fs
*fs, blk_t block)
blk_t blk;
int group;
- PED_ASSERT (block >= EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb), return 0);
- PED_ASSERT (block < EXT2_SUPER_BLOCKS_COUNT(fs->sb), return 0);
+ PED_ASSERT (block >= EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb));
+ PED_ASSERT (block < EXT2_SUPER_BLOCKS_COUNT(fs->sb));
blk = block - EXT2_SUPER_FIRST_DATA_BLOCK(fs->sb);
diff --git a/libparted/fs/ext2/ext2_inode_relocator.c
b/libparted/fs/ext2/ext2_inode_relocator.c
index dca1982..56b4b5c 100644
--- a/libparted/fs/ext2/ext2_inode_relocator.c
+++ b/libparted/fs/ext2/ext2_inode_relocator.c
@@ -145,7 +145,7 @@ static int doblock(struct ext2_fs *fs, struct
ext2_inode_relocator_state *state,
offset))
return 0;
- PED_ASSERT (ptr->rec_len > 0, return 0);
+ PED_ASSERT (ptr->rec_len > 0);
offset += EXT2_DIRENT_REC_LEN (*ptr);
} while (offset < fs->blocksize);
diff --git a/libparted/fs/ext2/ext2_mkfs.c b/libparted/fs/ext2/ext2_mkfs.c
index 22886d4..c4964b7 100644
--- a/libparted/fs/ext2/ext2_mkfs.c
+++ b/libparted/fs/ext2/ext2_mkfs.c
@@ -420,7 +420,7 @@ static int ext2_mkfs_init_sb (struct ext2_super_block *sb,
blk_t numblocks,
int reserved_block_percentage)
{
/* catch a bug in gcc 2.95.2 */
- PED_ASSERT(numgroups != 0, return 0);
+ PED_ASSERT(numgroups != 0);
memset(sb, 0, 1024);
diff --git a/libparted/fs/ext2/interface.c b/libparted/fs/ext2/interface.c
index 8a720be..222fbe1 100644
--- a/libparted/fs/ext2/interface.c
+++ b/libparted/fs/ext2/interface.c
@@ -234,7 +234,7 @@ _ext2_resize (PedFileSystem* fs, PedGeometry* geom,
PedTimer* timer)
struct ext2_fs* f;
PedSector old_length = fs->geom->length;
- PED_ASSERT (fs->geom->dev == geom->dev, return 0);
+ PED_ASSERT (fs->geom->dev == geom->dev);
if (fs->geom->start != geom->start)
{
diff --git a/libparted/fs/fat/bootsector.c b/libparted/fs/fat/bootsector.c
index 3c87bde..a5d69c3 100644
--- a/libparted/fs/fat/bootsector.c
+++ b/libparted/fs/fat/bootsector.c
@@ -38,8 +38,8 @@
int
fat_boot_sector_read (FatBootSector* bs, const PedGeometry *geom)
{
- PED_ASSERT (bs != NULL, return 0);
- PED_ASSERT (geom != NULL, return 0);
+ PED_ASSERT (bs != NULL);
+ PED_ASSERT (geom != NULL);
if (!ped_geometry_read (geom, bs, 0, 1))
return 0;
@@ -130,7 +130,7 @@ fat_boot_sector_analyse (FatBootSector* bs, PedFileSystem*
fs)
FatSpecific* fs_info = FAT_SPECIFIC (fs);
int fat_entry_size;
- PED_ASSERT (bs != NULL, return 0);
+ PED_ASSERT (bs != NULL);
if (PED_LE16_TO_CPU (bs->sector_size) != 512) {
if (ped_exception_throw (
@@ -290,7 +290,7 @@ fat_boot_sector_analyse (FatBootSector* bs, PedFileSystem*
fs)
int
fat_boot_sector_set_boot_code (FatBootSector* bs)
{
- PED_ASSERT (bs != NULL, return 0);
+ PED_ASSERT (bs != NULL);
memset (bs, 0, 512);
memcpy (bs->boot_jump, FAT_BOOT_JUMP, 3);
@@ -303,7 +303,7 @@ fat_boot_sector_generate (FatBootSector* bs, const
PedFileSystem* fs)
{
FatSpecific* fs_info = FAT_SPECIFIC (fs);
- PED_ASSERT (bs != NULL, return 0);
+ PED_ASSERT (bs != NULL);
memcpy (bs->system_id, "MSWIN4.1", 8);
bs->sector_size = PED_CPU_TO_LE16 (fs_info->logical_sector_size * 512);
@@ -382,7 +382,7 @@ fat_boot_sector_write (const FatBootSector* bs,
PedFileSystem* fs)
{
FatSpecific* fs_info = FAT_SPECIFIC (fs);
- PED_ASSERT (bs != NULL, return 0);
+ PED_ASSERT (bs != NULL);
if (!ped_geometry_write (fs->geom, bs, 0, 1))
return 0;
@@ -400,7 +400,7 @@ fat_info_sector_read (FatInfoSector* is, const
PedFileSystem* fs)
FatSpecific* fs_info = FAT_SPECIFIC (fs);
int status;
- PED_ASSERT (is != NULL, return 0);
+ PED_ASSERT (is != NULL);
if (!ped_geometry_read (fs->geom, is, fs_info->info_sector_offset, 1))
return 0;
@@ -423,7 +423,7 @@ fat_info_sector_generate (FatInfoSector* is, const
PedFileSystem* fs)
{
FatSpecific* fs_info = FAT_SPECIFIC (fs);
- PED_ASSERT (is != NULL, return 0);
+ PED_ASSERT (is != NULL);
fat_table_count_stats (fs_info->fat);
@@ -443,7 +443,7 @@ fat_info_sector_write (const FatInfoSector* is,
PedFileSystem *fs)
{
FatSpecific* fs_info = FAT_SPECIFIC (fs);
- PED_ASSERT (is != NULL, return 0);
+ PED_ASSERT (is != NULL);
if (!ped_geometry_write (fs->geom, is, fs_info->info_sector_offset, 1))
return 0;
diff --git a/libparted/fs/fat/calc.c b/libparted/fs/fat/calc.c
index 75eff57..4193dcd 100644
--- a/libparted/fs/fat/calc.c
+++ b/libparted/fs/fat/calc.c
@@ -113,7 +113,7 @@ fat_check_resize_geometry (const PedFileSystem* fs,
PedSector new_total_space;
PedSector dir_space;
- PED_ASSERT (geom != NULL, return 0);
+ PED_ASSERT (geom != NULL);
dir_space = fs_info->total_dir_clusters * fs_info->cluster_sectors;
free_space = fs_info->fat->free_cluster_count
@@ -182,8 +182,8 @@ calc_sizes (PedSector size, PedSector align, FatType
fat_type,
FatCluster cluster_count;
int i;
- PED_ASSERT (out_cluster_count != NULL, return 0);
- PED_ASSERT (out_fat_size != NULL, return 0);
+ PED_ASSERT (out_cluster_count != NULL);
+ PED_ASSERT (out_fat_size != NULL);
data_fat_space = size - fat_min_reserved_sector_count (fat_type)
- align;
@@ -234,9 +234,9 @@ fat_calc_sizes (PedSector size, PedSector align, FatType
fat_type,
{
PedSector cluster_sectors;
- PED_ASSERT (out_cluster_sectors != NULL, return 0);
- PED_ASSERT (out_cluster_count != NULL, return 0);
- PED_ASSERT (out_fat_size != NULL, return 0);
+ PED_ASSERT (out_cluster_sectors != NULL);
+ PED_ASSERT (out_cluster_count != NULL);
+ PED_ASSERT (out_fat_size != NULL);
for (cluster_sectors = fat_recommend_min_cluster_size (fat_type, size);
cluster_sectors <= fat_max_cluster_size (fat_type);
@@ -291,10 +291,10 @@ fat_calc_resize_sizes (
FatCluster* out_cluster_count,
PedSector* out_fat_size)
{
- PED_ASSERT (geom != NULL, return 0);
- PED_ASSERT (out_cluster_sectors != NULL, return 0);
- PED_ASSERT (out_cluster_count != NULL, return 0);
- PED_ASSERT (out_fat_size != NULL, return 0);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (out_cluster_sectors != NULL);
+ PED_ASSERT (out_cluster_count != NULL);
+ PED_ASSERT (out_fat_size != NULL);
/* libparted can only reduce the cluster size at this point */
for (*out_cluster_sectors = cluster_sectors;
@@ -375,8 +375,7 @@ fat_cluster_to_frag (const PedFileSystem* fs, FatCluster
cluster)
{
FatSpecific* fs_info = FAT_SPECIFIC (fs);
- PED_ASSERT (cluster >= 2 && cluster < fs_info->cluster_count + 2,
- return 0);
+ PED_ASSERT (cluster >= 2 && cluster < fs_info->cluster_count + 2);
return (cluster - 2) * fs_info->cluster_frags;
}
@@ -386,7 +385,7 @@ fat_frag_to_cluster (const PedFileSystem* fs, FatFragment
frag)
{
FatSpecific* fs_info = FAT_SPECIFIC (fs);
- PED_ASSERT (frag >= 0 && frag < fs_info->frag_count, return 0);
+ PED_ASSERT (frag >= 0 && frag < fs_info->frag_count);
return frag / fs_info->cluster_frags + 2;
}
@@ -396,7 +395,7 @@ fat_frag_to_sector (const PedFileSystem* fs, FatFragment
frag)
{
FatSpecific* fs_info = FAT_SPECIFIC (fs);
- PED_ASSERT (frag >= 0 && frag < fs_info->frag_count, return 0);
+ PED_ASSERT (frag >= 0 && frag < fs_info->frag_count);
return frag * fs_info->frag_sectors + fs_info->cluster_offset;
}
@@ -406,7 +405,7 @@ fat_sector_to_frag (const PedFileSystem* fs, PedSector
sector)
{
FatSpecific* fs_info = FAT_SPECIFIC (fs);
- PED_ASSERT (sector >= fs_info->cluster_offset, return 0);
+ PED_ASSERT (sector >= fs_info->cluster_offset);
return (sector - fs_info->cluster_offset) / fs_info->frag_sectors;
}
@@ -416,8 +415,7 @@ fat_cluster_to_sector (const PedFileSystem* fs, FatCluster
cluster)
{
FatSpecific* fs_info = FAT_SPECIFIC (fs);
- PED_ASSERT (cluster >= 2 && cluster < fs_info->cluster_count + 2,
- return 0);
+ PED_ASSERT (cluster >= 2 && cluster < fs_info->cluster_count + 2);
return (cluster - 2) * fs_info->cluster_sectors
+ fs_info->cluster_offset;
@@ -428,7 +426,7 @@ fat_sector_to_cluster (const PedFileSystem* fs, PedSector
sector)
{
FatSpecific* fs_info = FAT_SPECIFIC (fs);
- PED_ASSERT (sector >= fs_info->cluster_offset, return 0);
+ PED_ASSERT (sector >= fs_info->cluster_offset);
return (sector - fs_info->cluster_offset) / fs_info->cluster_sectors
+ 2;
diff --git a/libparted/fs/fat/clstdup.c b/libparted/fs/fat/clstdup.c
index 0d2a625..3b8549e 100644
--- a/libparted/fs/fat/clstdup.c
+++ b/libparted/fs/fat/clstdup.c
@@ -30,8 +30,7 @@ needs_duplicating (const FatOpContext* ctx, FatFragment frag)
FatCluster cluster = fat_frag_to_cluster (ctx->old_fs, frag);
FatClusterFlag flag;
- PED_ASSERT (cluster >= 2 && cluster < old_fs_info->cluster_count + 2,
- return 0);
+ PED_ASSERT (cluster >= 2 && cluster < old_fs_info->cluster_count + 2);
flag = fat_get_fragment_flag (ctx->old_fs, frag);
switch (flag) {
@@ -132,7 +131,7 @@ get_first_underlay (const FatOpContext* ctx, int first, int
last)
int old;
FatFragment new;
- PED_ASSERT (first <= last, return 0);
+ PED_ASSERT (first <= last);
new = ctx->buffer_map [first];
for (old = first + 1; old <= last; old++) {
@@ -153,7 +152,7 @@ get_last_underlay (const FatOpContext* ctx, int first, int
last)
int old;
FatFragment new;
- PED_ASSERT (first <= last, return 0);
+ PED_ASSERT (first <= last);
new = ctx->buffer_map [last];
for (old = last - 1; old >= first; old--) {
@@ -178,14 +177,14 @@ quick_group_write_read_underlay (FatOpContext* ctx, int
first, int last)
FatFragment last_underlay;
FatFragment underlay_length;
- PED_ASSERT (first <= last, return 0);
+ PED_ASSERT (first <= last);
first_underlay = get_first_underlay (ctx, first, last);
if (first_underlay == -1)
return 1;
last_underlay = get_last_underlay (ctx, first, last);
- PED_ASSERT (first_underlay <= last_underlay, return 0);
+ PED_ASSERT (first_underlay <= last_underlay);
underlay_length = last_underlay - first_underlay + 1;
if (!fat_read_fragments (ctx->new_fs,
@@ -214,7 +213,7 @@ quick_group_write (FatOpContext* ctx, int first, int last)
int i;
int offset;
- PED_ASSERT (first <= last, return 0);
+ PED_ASSERT (first <= last);
ped_exception_fetch_all ();
if (!quick_group_write_read_underlay (ctx, first, last))
@@ -256,7 +255,7 @@ slow_group_write (FatOpContext* ctx, int first, int last)
FatSpecific* new_fs_info = FAT_SPECIFIC (ctx->new_fs);
int i;
- PED_ASSERT (first <= last, return 0);
+ PED_ASSERT (first <= last);
for (i = first; i <= last; i++) {
if (ctx->buffer_map [i] == -1)
@@ -281,7 +280,7 @@ update_remap (FatOpContext* ctx, int first, int last)
{
int i;
- PED_ASSERT (first <= last, return 0);
+ PED_ASSERT (first <= last);
for (i = first; i <= last; i++) {
if (ctx->buffer_map [i] == -1)
@@ -295,7 +294,7 @@ update_remap (FatOpContext* ctx, int first, int last)
static int
group_write (FatOpContext* ctx, int first, int last)
{
- PED_ASSERT (first <= last, return 0);
+ PED_ASSERT (first <= last);
if (!quick_group_write (ctx, first, last)) {
if (!slow_group_write (ctx, first, last))
@@ -318,7 +317,7 @@ write_fragments (FatOpContext* ctx)
FatFragment i;
FatCluster new_cluster;
- PED_ASSERT (ctx->buffer_offset < old_fs_info->frag_count, return 0);
+ PED_ASSERT (ctx->buffer_offset < old_fs_info->frag_count);
group_start = -1;
for (i = 0; i < ctx->buffer_frags; i++) {
@@ -338,8 +337,7 @@ write_fragments (FatOpContext* ctx)
group_start = group_end = i;
PED_ASSERT (ctx->buffer_map [i]
- >= ctx->buffer_map [group_start],
- return 0);
+ >= ctx->buffer_map [group_start]);
mapped_length = ctx->buffer_map [i]
- ctx->buffer_map [group_start] + 1;
@@ -355,7 +353,7 @@ write_fragments (FatOpContext* ctx)
}
}
- PED_ASSERT (group_start != -1, return 0);
+ PED_ASSERT (group_start != -1);
if (!group_write (ctx, group_start, group_end))
return 0;
diff --git a/libparted/fs/fat/context.c b/libparted/fs/fat/context.c
index 40f3ad1..4176b17 100644
--- a/libparted/fs/fat/context.c
+++ b/libparted/fs/fat/context.c
@@ -228,7 +228,7 @@ fat_op_context_create_initial_fat (FatOpContext* ctx)
continue;
new_clst = fat_frag_to_cluster (ctx->new_fs, new_frag);
- PED_ASSERT (new_clst != 0, return 0);
+ PED_ASSERT (new_clst != 0);
if (frag_flag == FAT_FLAG_BAD) {
if (!fat_table_set_bad (new_fs_info->fat, new_clst))
@@ -248,7 +248,7 @@ fat_op_context_create_initial_fat (FatOpContext* ctx)
continue;
clst = fat_sector_to_cluster (ctx->new_fs, new_sect);
- PED_ASSERT (clst != 0, return 0);
+ PED_ASSERT (clst != 0);
if (!fat_table_set_eof (new_fs_info->fat, clst))
return 0;
diff --git a/libparted/fs/fat/count.c b/libparted/fs/fat/count.c
index 2c91178..97ed2ab 100644
--- a/libparted/fs/fat/count.c
+++ b/libparted/fs/fat/count.c
@@ -224,7 +224,7 @@ flag_traverse_dir (FatTraverseInfo* trav_info) {
FatCluster first_cluster;
PedSector size;
- PED_ASSERT (trav_info != NULL, return 0);
+ PED_ASSERT (trav_info != NULL);
strcpy (file_name, trav_info->dir_name);
file_name_start = file_name + strlen (file_name);
@@ -370,8 +370,7 @@ fat_get_fragment_flag (PedFileSystem* fs, FatFragment frag)
FatFragment last_frag_used;
FatClusterFlag flag;
- PED_ASSERT (cluster >= 2 && cluster < fs_info->cluster_count + 2,
- return 0);
+ PED_ASSERT (cluster >= 2 && cluster < fs_info->cluster_count + 2);
flag = fat_get_cluster_flag (fs, cluster);
if (flag != FAT_FLAG_FILE && flag != FAT_FLAG_DIRECTORY)
diff --git a/libparted/fs/fat/fat.c b/libparted/fs/fat/fat.c
index 9742954..72e568e 100644
--- a/libparted/fs/fat/fat.c
+++ b/libparted/fs/fat/fat.c
@@ -97,8 +97,7 @@ fat_set_frag_sectors (PedFileSystem* fs, PedSector
frag_sectors)
FatSpecific* fs_info = FAT_SPECIFIC (fs);
PED_ASSERT (fs_info->cluster_sectors % frag_sectors == 0
- && frag_sectors <= fs_info->cluster_sectors,
- return 0);
+ && frag_sectors <= fs_info->cluster_sectors);
fs_info->frag_size = frag_sectors * 512;
fs_info->frag_sectors = frag_sectors;
diff --git a/libparted/fs/fat/fatio.c b/libparted/fs/fat/fatio.c
index 7769e10..ecc2cd8 100644
--- a/libparted/fs/fat/fatio.c
+++ b/libparted/fs/fat/fatio.c
@@ -38,7 +38,7 @@ fat_read_fragments (PedFileSystem* fs, char* buf, FatFragment
frag,
PedSector sector = fat_frag_to_sector (fs, frag);
PedSector sector_count = count * fs_info->frag_sectors;
- PED_ASSERT (frag >= 0 && frag < fs_info->frag_count, return 0);
+ PED_ASSERT (frag >= 0 && frag < fs_info->frag_count);
return ped_geometry_read (fs->geom, buf, sector, sector_count);
}
@@ -57,7 +57,7 @@ fat_write_fragments (PedFileSystem* fs, char* buf,
FatFragment frag,
PedSector sector = fat_frag_to_sector (fs, frag);
PedSector sector_count = count * fs_info->frag_sectors;
- PED_ASSERT (frag >= 0 && frag < fs_info->frag_count, return 0);
+ PED_ASSERT (frag >= 0 && frag < fs_info->frag_count);
return ped_geometry_write (fs->geom, buf, sector, sector_count);
}
@@ -94,8 +94,7 @@ fat_read_clusters (PedFileSystem* fs, char *buf, FatCluster
cluster,
PedSector sector_count = count * fs_info->cluster_sectors;
PED_ASSERT (cluster >= 2
- && cluster + count - 1 < fs_info->cluster_count + 2,
- return 0);
+ && cluster + count - 1 < fs_info->cluster_count + 2);
return ped_geometry_read (fs->geom, buf, sector, sector_count);
}
@@ -115,8 +114,7 @@ fat_write_clusters (PedFileSystem* fs, char *buf,
FatCluster cluster,
PedSector sector_count = count * fs_info->cluster_sectors;
PED_ASSERT (cluster >= 2
- && cluster + count - 1 < fs_info->cluster_count + 2,
- return 0);
+ && cluster + count - 1 < fs_info->cluster_count + 2);
return ped_geometry_write (fs->geom, buf, sector, sector_count);
}
diff --git a/libparted/fs/fat/resize.c b/libparted/fs/fat/resize.c
index ffe59c7..2c0097a 100644
--- a/libparted/fs/fat/resize.c
+++ b/libparted/fs/fat/resize.c
@@ -84,7 +84,7 @@ duplicate_legacy_root_dir (FatOpContext* ctx)
FatSpecific* new_fs_info = FAT_SPECIFIC (ctx->new_fs);
PED_ASSERT (old_fs_info->root_dir_sector_count
- == new_fs_info->root_dir_sector_count, return 0);
+ == new_fs_info->root_dir_sector_count);
if (!ped_geometry_read (ctx->old_fs->geom, old_fs_info->buffer,
old_fs_info->root_dir_offset,
@@ -224,7 +224,7 @@ alloc_root_dir (FatOpContext* ctx)
FatCluster cluster;
FatCluster cluster_count;
- PED_ASSERT (new_fs_info->fat_type == FAT_TYPE_FAT32, return 0);
+ PED_ASSERT (new_fs_info->fat_type == FAT_TYPE_FAT32);
cluster_count = ped_div_round_up (
PED_MAX (16, old_fs_info->root_dir_sector_count),
@@ -258,8 +258,8 @@ free_root_dir (FatOpContext* ctx)
FatCluster old_cluster;
FatFragment i;
- PED_ASSERT (old_fs_info->fat_type == FAT_TYPE_FAT32, return 0);
- PED_ASSERT (new_fs_info->fat_type == FAT_TYPE_FAT16, return 0);
+ PED_ASSERT (old_fs_info->fat_type == FAT_TYPE_FAT32);
+ PED_ASSERT (new_fs_info->fat_type == FAT_TYPE_FAT16);
for (old_cluster = old_fs_info->root_cluster;
!fat_table_is_eof (old_fs_info->fat, old_cluster);
@@ -286,8 +286,8 @@ fat_clear_root_dir (PedFileSystem* fs)
FatSpecific* fs_info = FAT_SPECIFIC (fs);
int i;
- PED_ASSERT (fs_info->fat_type == FAT_TYPE_FAT16, return 0);
- PED_ASSERT (fs_info->root_dir_sector_count, return 0);
+ PED_ASSERT (fs_info->fat_type == FAT_TYPE_FAT16);
+ PED_ASSERT (fs_info->root_dir_sector_count);
memset (fs_info->buffer, 0, 512);
@@ -343,7 +343,7 @@ fat_construct_dir_tree (FatOpContext* ctx)
if (new_fs_info->fat_type == old_fs_info->fat_type) {
switch (old_fs_info->fat_type) {
case FAT_TYPE_FAT12:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
case FAT_TYPE_FAT16:
@@ -430,11 +430,11 @@ fat_construct_new_fat (FatOpContext* ctx)
new_next_frag = fat_op_context_map_fragment (ctx,
old_next_frag);
- PED_ASSERT (new_next_frag != -1, return 0);
+ PED_ASSERT (new_next_frag != -1);
new_next_cluster = fat_frag_to_cluster (ctx->new_fs,
new_next_frag);
- PED_ASSERT (new_next_cluster != new_cluster, return 0);
+ PED_ASSERT (new_next_cluster != new_cluster);
fat_table_set (new_fs_info->fat, new_cluster, new_next_cluster);
}
@@ -536,7 +536,7 @@ ask_type (PedFileSystem* fs, int fat16_ok, int fat32_ok,
FatType* out_fat_type)
return 0;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
}
@@ -811,7 +811,7 @@ _copy_hidden_sectors (FatOpContext* ctx)
last = PED_MIN (old_fs_info->fat_offset, new_fs_info->fat_offset) - 1;
count = last - first + 1;
- PED_ASSERT (count < BUFFER_SIZE, return 0);
+ PED_ASSERT (count < BUFFER_SIZE);
if (!ped_geometry_read (ctx->old_fs->geom, old_fs_info->buffer,
first, count))
diff --git a/libparted/fs/fat/table.c b/libparted/fs/fat/table.c
index 68697b3..b77e372 100644
--- a/libparted/fs/fat/table.c
+++ b/libparted/fs/fat/table.c
@@ -89,7 +89,7 @@ fat_table_clear (FatTable* ft)
int
fat_table_set_cluster_count (FatTable* ft, FatCluster new_cluster_count)
{
- PED_ASSERT (new_cluster_count + 2 <= ft->size, return 0);
+ PED_ASSERT (new_cluster_count + 2 <= ft->size);
ft->cluster_count = new_cluster_count;
return fat_table_count_stats (ft);
@@ -100,7 +100,7 @@ fat_table_count_stats (FatTable* ft)
{
FatCluster i;
- PED_ASSERT (ft->cluster_count + 2 <= ft->size, return 0);
+ PED_ASSERT (ft->cluster_count + 2 <= ft->size);
ft->free_cluster_count = 0;
ft->bad_cluster_count = 0;
@@ -119,7 +119,7 @@ fat_table_read (FatTable* ft, const PedFileSystem* fs, int
table_num)
{
FatSpecific* fs_info = FAT_SPECIFIC (fs);
- PED_ASSERT (ft->raw_size >= fs_info->fat_sectors * 512, return 0);
+ PED_ASSERT (ft->raw_size >= fs_info->fat_sectors * 512);
memset (ft->table, 0, ft->raw_size);
@@ -154,7 +154,7 @@ fat_table_write (const FatTable* ft, PedFileSystem* fs, int
table_num)
{
FatSpecific* fs_info = FAT_SPECIFIC (fs);
- PED_ASSERT (ft->raw_size >= fs_info->fat_sectors * 512, return 0);
+ PED_ASSERT (ft->raw_size >= fs_info->fat_sectors * 512);
if (!ped_geometry_write (fs->geom, (void *) ft->table,
fs_info->fat_offset
@@ -275,7 +275,7 @@ fat_table_set (FatTable* ft, FatCluster cluster, FatCluster
value)
switch (ft->fat_type) {
case FAT_TYPE_FAT12:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
case FAT_TYPE_FAT16:
@@ -305,7 +305,7 @@ fat_table_get (const FatTable* ft, FatCluster cluster)
switch (ft->fat_type) {
case FAT_TYPE_FAT12:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
case FAT_TYPE_FAT16:
@@ -415,7 +415,7 @@ fat_table_set_eof (FatTable* ft, FatCluster cluster)
switch (ft->fat_type) {
case FAT_TYPE_FAT12:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
case FAT_TYPE_FAT16:
diff --git a/libparted/fs/fat/traverse.c b/libparted/fs/fat/traverse.c
index 424c877..7cecfe3 100644
--- a/libparted/fs/fat/traverse.c
+++ b/libparted/fs/fat/traverse.c
@@ -89,7 +89,7 @@ read_next_dir_buffer (FatTraverseInfo* trav_info)
{
FatSpecific* fs_info = FAT_SPECIFIC (trav_info->fs);
- PED_ASSERT (!trav_info->is_legacy_root_dir, return 0);
+ PED_ASSERT (!trav_info->is_legacy_root_dir);
trav_info->this_buffer = trav_info->next_buffer;
@@ -252,7 +252,7 @@ fat_dir_entry_set_first_cluster (FatDirEntry* dir_entry,
PedFileSystem* fs,
switch (fs_info->fat_type) {
case FAT_TYPE_FAT12:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
case FAT_TYPE_FAT16:
diff --git a/libparted/fs/hfs/cache.c b/libparted/fs/hfs/cache.c
index 63e9fa0..97dcca7 100644
--- a/libparted/fs/hfs/cache.c
+++ b/libparted/fs/hfs/cache.c
@@ -123,7 +123,7 @@ hfsc_cache_add_extent(HfsCPrivateCache* cache, uint32_t
start, uint32_t length,
HfsCPrivateExtent* ext;
unsigned int idx = start >> CR_SHIFT;
- PED_ASSERT(idx < cache->linked_ref_size, return NULL);
+ PED_ASSERT(idx < cache->linked_ref_size);
for (ext = cache->linked_ref[idx];
ext && start != ext->ext_start;
@@ -178,7 +178,7 @@ hfsc_cache_search_extent(HfsCPrivateCache* cache, uint32_t
start)
HfsCPrivateExtent* ret;
unsigned int idx = start >> CR_SHIFT;
- PED_ASSERT(idx < cache->linked_ref_size, return NULL);
+ PED_ASSERT(idx < cache->linked_ref_size);
for (ret = cache->linked_ref[idx];
ret && start != ret->ext_start;
@@ -199,8 +199,8 @@ hfsc_cache_move_extent(HfsCPrivateCache* cache, uint32_t
old_start,
unsigned int idx1 = old_start >> CR_SHIFT;
unsigned int idx2 = new_start >> CR_SHIFT;
- PED_ASSERT(idx1 < cache->linked_ref_size, return NULL);
- PED_ASSERT(idx2 < cache->linked_ref_size, return NULL);
+ PED_ASSERT(idx1 < cache->linked_ref_size);
+ PED_ASSERT(idx2 < cache->linked_ref_size);
for (pext = cache->linked_ref[idx2];
pext && new_start != pext->ext_start;
diff --git a/libparted/fs/hfs/file.c b/libparted/fs/hfs/file.c
index e291ea6..9fc501b 100644
--- a/libparted/fs/hfs/file.c
+++ b/libparted/fs/hfs/file.c
@@ -146,7 +146,7 @@ hfs_file_find_sector (HfsPrivateFile* file, PedSector
sector)
}
/* in the three cached extent */
- PED_ASSERT(file->start_cache && block >= file->start_cache, return 0);
+ PED_ASSERT(file->start_cache && block >= file->start_cache);
for (s = file->start_cache, i = 0; i < HFS_EXT_NB; i++) {
if ((block >= s) && (block < s + PED_BE16_TO_CPU (
file->cache[i].block_count))) {
diff --git a/libparted/fs/hfs/file_plus.c b/libparted/fs/hfs/file_plus.c
index 94bd0e3..acacc93 100644
--- a/libparted/fs/hfs/file_plus.c
+++ b/libparted/fs/hfs/file_plus.c
@@ -160,7 +160,7 @@ hfsplus_file_find_extent (HfsPPrivateFile* file, PedSector
sector,
}
/* ret == {0,0} */
- PED_ASSERT(file->start_cache && block >= file->start_cache, return ret);
+ PED_ASSERT(file->start_cache && block >= file->start_cache);
for (s = file->start_cache, i = 0; i < HFSP_EXT_NB; i++) {
if ((block >= s) && (block < s + PED_BE32_TO_CPU (
diff --git a/libparted/fs/hfs/hfs.c b/libparted/fs/hfs/hfs.c
index 87b4daa..51aec12 100644
--- a/libparted/fs/hfs/hfs.c
+++ b/libparted/fs/hfs/hfs.c
@@ -203,17 +203,17 @@ hfs_resize (PedFileSystem* fs, PedGeometry* geom,
PedTimer* timer)
PedSector hgee;
/* check preconditions */
- PED_ASSERT (fs != NULL, return 0);
- PED_ASSERT (fs->geom != NULL, return 0);
- PED_ASSERT (geom != NULL, return 0);
+ PED_ASSERT (fs != NULL);
+ PED_ASSERT (fs->geom != NULL);
+ PED_ASSERT (geom != NULL);
#ifdef DEBUG
- PED_ASSERT ((hgee = hfs_get_empty_end(fs)) != 0, return 0);
+ PED_ASSERT ((hgee = hfs_get_empty_end(fs)) != 0);
#else
if ((hgee = hfs_get_empty_end(fs)) == 0)
return 0;
#endif
- PED_ASSERT ((hgee = hfs_get_empty_end(fs)) != 0, return 0);
+ PED_ASSERT ((hgee = hfs_get_empty_end(fs)) != 0);
if (ped_geometry_test_equal(fs->geom, geom))
return 1;
@@ -915,12 +915,12 @@ hfsplus_resize (PedFileSystem* fs, PedGeometry* geom,
PedTimer* timer)
PedSector hgms;
/* check preconditions */
- PED_ASSERT (fs != NULL, return 0);
- PED_ASSERT (fs->geom != NULL, return 0);
- PED_ASSERT (geom != NULL, return 0);
- PED_ASSERT (fs->geom->dev == geom->dev, return 0);
+ PED_ASSERT (fs != NULL);
+ PED_ASSERT (fs->geom != NULL);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (fs->geom->dev == geom->dev);
#ifdef DEBUG
- PED_ASSERT ((hgms = hfsplus_get_min_size (fs)) != 0, return 0);
+ PED_ASSERT ((hgms = hfsplus_get_min_size (fs)) != 0);
#else
if ((hgms = hfsplus_get_min_size (fs)) == 0)
return 0;
diff --git a/libparted/fs/hfs/probe.c b/libparted/fs/hfs/probe.c
index 1d83a32..8c656cf 100644
--- a/libparted/fs/hfs/probe.c
+++ b/libparted/fs/hfs/probe.c
@@ -40,8 +40,8 @@ hfsc_can_use_geom (PedGeometry* geom)
PedDevice* dev;
dev = geom->dev;
- PED_ASSERT (geom != NULL, return 0);
- PED_ASSERT (dev != NULL, return 0);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (dev != NULL);
if (dev->sector_size != PED_SECTOR_SIZE_DEFAULT) {
ped_exception_throw (
@@ -67,8 +67,8 @@ hfs_and_wrapper_probe (PedGeometry* geom)
PedGeometry* geom_ret;
PedSector search, max;
- PED_ASSERT (geom != NULL, return NULL);
- PED_ASSERT (hfsc_can_use_geom (geom), return NULL);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (hfsc_can_use_geom (geom));
mdb = (HfsMasterDirectoryBlock *) buf;
@@ -103,7 +103,7 @@ hfsplus_probe (PedGeometry* geom)
PedGeometry* geom_ret;
uint8_t buf[PED_SECTOR_SIZE_DEFAULT];
- PED_ASSERT (geom != NULL, return NULL);
+ PED_ASSERT (geom != NULL);
if (!hfsc_can_use_geom (geom))
return NULL;
@@ -173,7 +173,7 @@ hfs_probe (PedGeometry* geom)
PedGeometry* geom_base;
PedGeometry* geom_plus = NULL;
- PED_ASSERT (geom != NULL, return NULL);
+ PED_ASSERT (geom != NULL);
if (!hfsc_can_use_geom (geom))
return NULL;
@@ -196,7 +196,7 @@ hfsx_probe (PedGeometry* geom)
PedSector search, max;
HfsPVolumeHeader *vh = (HfsPVolumeHeader *) buf;
- PED_ASSERT (geom != NULL, return NULL);
+ PED_ASSERT (geom != NULL);
if (!hfsc_can_use_geom (geom))
return NULL;
diff --git a/libparted/fs/hfs/reloc.c b/libparted/fs/hfs/reloc.c
index 5666d7c..81d1057 100644
--- a/libparted/fs/hfs/reloc.c
+++ b/libparted/fs/hfs/reloc.c
@@ -52,8 +52,8 @@ hfs_effect_move_extent (PedFileSystem *fs, unsigned int
*ptr_fblock,
unsigned int next_to_fblock;
unsigned int start, stop;
- PED_ASSERT (hfs_block != NULL, return -1);
- PED_ASSERT (*ptr_to_fblock <= *ptr_fblock, return -1);
+ PED_ASSERT (hfs_block != NULL);
+ PED_ASSERT (*ptr_to_fblock <= *ptr_fblock);
/* quiet gcc */
start = stop = 0;
@@ -230,8 +230,7 @@ hfs_do_move (PedFileSystem* fs, unsigned int *ptr_src,
file = priv_data->catalog_file;
CR_BTREE:
PED_ASSERT(ref->sect_by_block == 1
- && ref->ref_offset < PED_SECTOR_SIZE_DEFAULT,
- return -1);
+ && ref->ref_offset <
PED_SECTOR_SIZE_DEFAULT);
if (!hfs_file_read_sector(file, node, ref->ref_block))
return -1;
extent = ( HfsExtDescriptor* ) (node + ref->ref_offset);
@@ -257,7 +256,7 @@ hfs_do_move (PedFileSystem* fs, unsigned int *ptr_src,
/* Update the cache */
move = hfsc_cache_move_extent(cache, ref->ext_start, new_start);
if (!move) return -1; /* "cleanly" fail */
- PED_ASSERT(move == ref, return -1); /* generate a bug */
+ PED_ASSERT(move == ref); /* generate a bug */
}
return new_start;
@@ -596,7 +595,7 @@ hfs_pack_free_space_from_block (PedFileSystem *fs, unsigned
int fblock,
+ 1 - start - to_free;
int ret;
- PED_ASSERT (!hfs_block, return 0);
+ PED_ASSERT (!hfs_block);
cache = hfs_cache_extents (fs, timer);
if (!cache)
diff --git a/libparted/fs/hfs/reloc_plus.c b/libparted/fs/hfs/reloc_plus.c
index 6dc3f34..750927f 100644
--- a/libparted/fs/hfs/reloc_plus.c
+++ b/libparted/fs/hfs/reloc_plus.c
@@ -56,8 +56,8 @@ hfsplus_effect_move_extent (PedFileSystem *fs, unsigned int
*ptr_fblock,
unsigned int next_to_fblock;
unsigned int start, stop;
- PED_ASSERT (hfsp_block != NULL, return -1);
- PED_ASSERT (*ptr_to_fblock <= *ptr_fblock, return -1);
+ PED_ASSERT (hfsp_block != NULL);
+ PED_ASSERT (*ptr_to_fblock <= *ptr_fblock);
/* quiet GCC */
start = stop = 0;
@@ -282,7 +282,7 @@ hfsplus_do_move (PedFileSystem* fs, unsigned int *ptr_src,
CR_BTREE :
PED_ASSERT(PED_SECTOR_SIZE_DEFAULT * ref->sect_by_block
- > ref->ref_offset, return -1 );
+ > ref->ref_offset);
if (!hfsplus_file_read(file, hfsp_block,
(PedSector)ref->ref_block * ref->sect_by_block,
ref->sect_by_block))
@@ -312,7 +312,7 @@ hfsplus_do_move (PedFileSystem* fs, unsigned int *ptr_src,
move = hfsc_cache_move_extent(cache, ref->ext_start, new_start);
if (!move) return -1;
- PED_ASSERT(move == ref, return -1);
+ PED_ASSERT(move == ref);
}
return new_start;
@@ -502,7 +502,7 @@ hfsplus_cache_from_catalog(HfsCPrivateCache* cache,
PedFileSystem* fs,
leaf_node = PED_BE32_TO_CPU (header->first_leaf_node);
bsize = PED_BE16_TO_CPU (header->node_size);
size = bsize / PED_SECTOR_SIZE_DEFAULT;
- PED_ASSERT(size < 256, return 0);
+ PED_ASSERT(size < 256);
node = (uint8_t*) ped_malloc(bsize);
if (!node) return 0;
@@ -624,7 +624,7 @@ hfsplus_cache_from_extent(HfsCPrivateCache* cache,
PedFileSystem* fs,
leaf_node = PED_BE32_TO_CPU (header->first_leaf_node);
bsize = PED_BE16_TO_CPU (header->node_size);
size = bsize / PED_SECTOR_SIZE_DEFAULT;
- PED_ASSERT(size < 256, return 0);
+ PED_ASSERT(size < 256);
node = (uint8_t*) ped_malloc (bsize);
if (!node) return -1;
@@ -735,7 +735,7 @@ hfsplus_cache_from_attributes(HfsCPrivateCache* cache,
PedFileSystem* fs,
leaf_node = PED_BE32_TO_CPU (header->first_leaf_node);
bsize = PED_BE16_TO_CPU (header->node_size);
size = bsize / PED_SECTOR_SIZE_DEFAULT;
- PED_ASSERT(size < 256, return 0);
+ PED_ASSERT(size < 256);
node = (uint8_t*) ped_malloc(bsize);
if (!node) return 0;
@@ -866,7 +866,7 @@ hfsplus_pack_free_space_from_block (PedFileSystem *fs,
unsigned int fblock,
+ 1 - start - to_free;
int ret;
- PED_ASSERT (!hfsp_block, return 0);
+ PED_ASSERT (!hfsp_block);
cache = hfsplus_cache_extents (fs, timer);
if (!cache)
diff --git a/libparted/fs/reiserfs/geom_dal.c b/libparted/fs/reiserfs/geom_dal.c
index c718fd6..17bb685 100644
--- a/libparted/fs/reiserfs/geom_dal.c
+++ b/libparted/fs/reiserfs/geom_dal.c
@@ -26,7 +26,7 @@
#include <parted/debug.h>
static blk_t __len(dal_t *dal) {
- PED_ASSERT(dal != NULL, return 0);
+ PED_ASSERT(dal != NULL);
return ((PedGeometry *)dal->dev)->length /
(dal->block_size / PED_SECTOR_SIZE_DEFAULT);
@@ -37,7 +37,7 @@ static int __read(dal_t *dal, void *buff, blk_t block, blk_t
count) {
PedSector block_pos;
PedSector block_count;
- PED_ASSERT(dal != NULL, return 0);
+ PED_ASSERT(dal != NULL);
k = dal->block_size / PED_SECTOR_SIZE_DEFAULT;
block_pos = (PedSector)(block * k);
@@ -51,7 +51,7 @@ static int __write(dal_t *dal, void *buff, blk_t block, blk_t
count) {
PedSector block_pos;
PedSector block_count;
- PED_ASSERT(dal != NULL, return 0);
+ PED_ASSERT(dal != NULL);
k = dal->block_size / PED_SECTOR_SIZE_DEFAULT;
block_pos = (PedSector)(block * k);
@@ -62,18 +62,18 @@ static int __write(dal_t *dal, void *buff, blk_t block,
blk_t count) {
}
static int __sync(dal_t *dal) {
- PED_ASSERT(dal != NULL, return 0);
+ PED_ASSERT(dal != NULL);
return ped_geometry_sync((PedGeometry *)dal->dev);
}
static int __flags(dal_t *dal) {
- PED_ASSERT(dal != NULL, return 0);
+ PED_ASSERT(dal != NULL);
return dal->flags;
}
static int __equals(dal_t *dal1, dal_t *dal2) {
- PED_ASSERT(dal1 != NULL, return 0);
- PED_ASSERT(dal2 != NULL, return 0);
+ PED_ASSERT(dal1 != NULL);
+ PED_ASSERT(dal2 != NULL);
return ped_geometry_test_equal((PedGeometry *)dal1->dev,
(PedGeometry *)dal2->dev);
@@ -81,8 +81,8 @@ static int __equals(dal_t *dal1, dal_t *dal2) {
static int __stat(dal_t *dal, struct stat *st) {
- PED_ASSERT(dal != NULL, return 0);
- PED_ASSERT(st != NULL, return 0);
+ PED_ASSERT(dal != NULL);
+ PED_ASSERT(st != NULL);
if (stat(((PedGeometry *)dal->dev)->dev->path, st))
return 0;
@@ -131,7 +131,7 @@ int geom_dal_reopen(dal_t *dal, int flags) {
}
void geom_dal_free(dal_t *dal) {
- PED_ASSERT(dal != NULL, return);
+ PED_ASSERT(dal != NULL);
free(dal);
}
diff --git a/libparted/fs/reiserfs/reiserfs.c b/libparted/fs/reiserfs/reiserfs.c
index 1cdcbd1..cb8071d 100644
--- a/libparted/fs/reiserfs/reiserfs.c
+++ b/libparted/fs/reiserfs/reiserfs.c
@@ -199,7 +199,7 @@ static PedGeometry *reiserfs_probe(PedGeometry *geom)
int i;
reiserfs_super_block_t sb;
- PED_ASSERT(geom != NULL, return NULL);
+ PED_ASSERT(geom != NULL);
for (i = 0; reiserfs_super_offset[i] != -1; i++) {
if (reiserfs_super_offset[i] >= geom->length)
@@ -233,7 +233,7 @@ static int reiserfs_clobber(PedGeometry *geom)
int i;
char buf[512];
- PED_ASSERT(geom != NULL, return 0);
+ PED_ASSERT(geom != NULL);
memset(buf, 0, 512);
for (i = 0; reiserfs_super_offset[i] != -1; i++) {
@@ -256,7 +256,7 @@ static PedFileSystem *reiserfs_open(PedGeometry *geom)
dal_t *dal;
reiserfs_fs_t *fs_info;
- PED_ASSERT(geom != NULL, return NULL);
+ PED_ASSERT(geom != NULL);
if (!(fs_geom = ped_geometry_duplicate(geom)))
goto error;
@@ -300,7 +300,7 @@ static PedFileSystem *reiserfs_create(PedGeometry *geom,
PedTimer *timer)
reiserfs_fs_t *fs_info;
reiserfs_gauge_t *gauge = NULL;
- PED_ASSERT(geom != NULL, return NULL);
+ PED_ASSERT(geom != NULL);
fs_geom = ped_geometry_duplicate(geom);
@@ -357,7 +357,7 @@ static int reiserfs_close(PedFileSystem *fs)
{
dal_t *dal;
- PED_ASSERT(fs != NULL, return 0);
+ PED_ASSERT(fs != NULL);
dal = reiserfs_fs_host_dal(fs->type_specific);
reiserfs_fs_close(fs->type_specific);
@@ -391,7 +391,7 @@ static int reiserfs_check(PedFileSystem *fs, PedTimer
*timer)
reiserfs_gauge_t *gauge = NULL;
#endif
- PED_ASSERT(fs != NULL, return 0);
+ PED_ASSERT(fs != NULL);
fs_info = fs->type_specific;
@@ -461,11 +461,11 @@ static int reiserfs_resize(PedFileSystem *fs, PedGeometry
*geom,
reiserfs_fs_t *fs_info;
reiserfs_gauge_t *gauge = NULL;
- PED_ASSERT(fs != NULL, return 0);
+ PED_ASSERT(fs != NULL);
old_length = fs->geom->length;
- PED_ASSERT (fs->geom->dev == geom->dev, return 0);
+ PED_ASSERT (fs->geom->dev == geom->dev);
if (fs->geom->start != geom->start) {
ped_exception_throw(PED_EXCEPTION_ERROR,
@@ -547,7 +547,7 @@ static PedConstraint *reiserfs_get_resize_constraint(const
PedFileSystem *
PedAlignment start_align;
PedGeometry start_sector;
- PED_ASSERT(fs != NULL, return NULL);
+ PED_ASSERT(fs != NULL);
fs_info = fs->type_specific;
dev = fs->geom->dev;
@@ -651,8 +651,8 @@ static PedConstraint *reiserfs_get_copy_constraint(const
PedFileSystem *fs,
{
PedGeometry full_dev;
- PED_ASSERT(fs != NULL, return NULL);
- PED_ASSERT(dev != NULL, return NULL);
+ PED_ASSERT(fs != NULL);
+ PED_ASSERT(dev != NULL);
if (!ped_geometry_init(&full_dev, dev, 0, dev->length - 1))
return NULL;
diff --git a/libparted/fs/ufs/ufs.c b/libparted/fs/ufs/ufs.c
index 62a1f01..d4309a8 100644
--- a/libparted/fs/ufs/ufs.c
+++ b/libparted/fs/ufs/ufs.c
@@ -310,7 +310,7 @@ static PedFileSystemType ufs_type_hp = {
void
ped_file_system_ufs_init ()
{
- PED_ASSERT (sizeof (struct ufs_super_block) == 1380, return);
+ PED_ASSERT (sizeof (struct ufs_super_block) == 1380);
ped_file_system_type_register (&ufs_type_sun);
ped_file_system_type_register (&ufs_type_hp);
diff --git a/libparted/labels/aix.c b/libparted/labels/aix.c
index ebef296..18d0f54 100644
--- a/libparted/labels/aix.c
+++ b/libparted/labels/aix.c
@@ -54,7 +54,7 @@ aix_label_magic_set (char *label, int magic_val)
static int
aix_probe (const PedDevice *dev)
{
- PED_ASSERT (dev != NULL, return 0);
+ PED_ASSERT (dev != NULL);
void *label;
if (!ptt_read_sector (dev, 0, &label))
@@ -142,7 +142,7 @@ aix_partition_duplicate (const PedPartition* part)
static void
aix_partition_destroy (PedPartition* part)
{
- PED_ASSERT (part != NULL, return);
+ PED_ASSERT (part != NULL);
_ped_partition_free (part);
}
@@ -198,7 +198,7 @@ aix_get_max_supported_partition_count (const PedDisk* disk,
int *max_n)
static int
aix_partition_align (PedPartition* part, const PedConstraint* constraint)
{
- PED_ASSERT (part != NULL, return 0);
+ PED_ASSERT (part != NULL);
return 1;
}
diff --git a/libparted/labels/bsd.c b/libparted/labels/bsd.c
index 6b5956c..f3dd9d4 100644
--- a/libparted/labels/bsd.c
+++ b/libparted/labels/bsd.c
@@ -153,7 +153,7 @@ bsd_probe (const PedDevice *dev)
{
BSDRawLabel *partition;
- PED_ASSERT (dev != NULL, return 0);
+ PED_ASSERT (dev != NULL);
if (dev->sector_size < 512)
return 0;
@@ -179,7 +179,7 @@ bsd_alloc (const PedDevice* dev)
BSDDiskData* bsd_specific;
BSDRawLabel* label;
- PED_ASSERT(dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0, return 0);
+ PED_ASSERT(dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0);
disk = _ped_disk_alloc ((PedDevice*)dev, &bsd_disk_type);
if (!disk)
@@ -336,8 +336,8 @@ bsd_write (const PedDisk* disk)
int i;
int max_part = 0;
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (disk->dev != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
bsd_specific = (BSDDiskData*) disk->disk_specific;
label = (BSDRawLabel *) (bsd_specific->boot_code + BSD_LABEL_OFFSET);
@@ -434,7 +434,7 @@ bsd_partition_duplicate (const PedPartition* part)
static void
bsd_partition_destroy (PedPartition* part)
{
- PED_ASSERT (part != NULL, return);
+ PED_ASSERT (part != NULL);
if (ped_partition_is_active (part))
free (part->disk_specific);
@@ -464,9 +464,9 @@ bsd_partition_set_flag (PedPartition* part,
PedPartitionFlag flag, int state)
// PedPartition* walk; // since -Werror, this unused variable
would break build
BSDPartitionData* bsd_data;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
- PED_ASSERT (part->disk != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
+ PED_ASSERT (part->disk != NULL);
bsd_data = part->disk_specific;
@@ -496,8 +496,8 @@ bsd_partition_get_flag (const PedPartition* part,
PedPartitionFlag flag)
{
BSDPartitionData* bsd_data;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
bsd_data = part->disk_specific;
switch (flag) {
@@ -601,8 +601,8 @@ bsd_alloc_metadata (PedDisk* disk)
PedPartition* new_part;
PedConstraint* constraint_any = NULL;
- PED_ASSERT (disk != NULL, goto error);
- PED_ASSERT (disk->dev != NULL, goto error);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
constraint_any = ped_constraint_any (disk->dev);
@@ -646,8 +646,8 @@ static PedDiskType bsd_disk_type = {
void
ped_disk_bsd_init ()
{
- PED_ASSERT (sizeof (BSDRawPartition) == 16, return);
- PED_ASSERT (sizeof (BSDRawLabel) == 276, return);
+ PED_ASSERT (sizeof (BSDRawPartition) == 16);
+ PED_ASSERT (sizeof (BSDRawLabel) == 276);
ped_disk_type_register (&bsd_disk_type);
}
diff --git a/libparted/labels/dasd.c b/libparted/labels/dasd.c
index 37cf155..d40119f 100644
--- a/libparted/labels/dasd.c
+++ b/libparted/labels/dasd.c
@@ -136,7 +136,7 @@ dasd_alloc (const PedDevice* dev)
DasdDiskSpecific *disk_specific;
char volser[7];
- PED_ASSERT (dev != NULL, return NULL);
+ PED_ASSERT (dev != NULL);
arch_specific = LINUX_SPECIFIC (dev);
disk = _ped_disk_alloc (dev, &dasd_disk_type);
@@ -183,7 +183,7 @@ dasd_duplicate (const PedDisk* disk)
static void
dasd_free (PedDisk* disk)
{
- PED_ASSERT(disk != NULL, return);
+ PED_ASSERT(disk != NULL);
/* Don't free disk->disk_specific first, in case _ped_disk_free
or one of its eventual callees ever accesses it. */
void *p = disk->disk_specific;
@@ -210,7 +210,7 @@ dasd_probe (const PedDevice *dev)
LinuxSpecific* arch_specific;
struct fdasd_anchor anchor;
- PED_ASSERT(dev != NULL, return 0);
+ PED_ASSERT(dev != NULL);
if (!(dev->type == PED_DEVICE_DASD
|| dev->type == PED_DEVICE_VIODASD
@@ -258,9 +258,9 @@ dasd_read (PedDisk* disk)
PDEBUG;
- PED_ASSERT (disk != NULL, return 0);
+ PED_ASSERT (disk != NULL);
PDEBUG;
- PED_ASSERT (disk->dev != NULL, return 0);
+ PED_ASSERT (disk->dev != NULL);
PDEBUG;
dev = disk->dev;
@@ -576,8 +576,8 @@ dasd_write (const PedDisk* disk)
struct fdasd_anchor anchor;
partition_info_t *part_info[USABLE_PARTITIONS];
- PED_ASSERT(disk != NULL, return 0);
- PED_ASSERT(disk->dev != NULL, return 0);
+ PED_ASSERT(disk != NULL);
+ PED_ASSERT(disk->dev != NULL);
arch_specific = LINUX_SPECIFIC (disk->dev);
disk_specific = disk->disk_specific;
@@ -685,7 +685,7 @@ dasd_partition_duplicate (const PedPartition *part)
static void
dasd_partition_destroy (PedPartition* part)
{
- PED_ASSERT(part != NULL, return);
+ PED_ASSERT(part != NULL);
if (ped_partition_is_active(part))
free(part->disk_specific);
@@ -697,8 +697,8 @@ dasd_partition_set_flag (PedPartition* part,
PedPartitionFlag flag, int state)
{
DasdPartitionData* dasd_data;
- PED_ASSERT(part != NULL, return 0);
- PED_ASSERT(part->disk_specific != NULL, return 0);
+ PED_ASSERT(part != NULL);
+ PED_ASSERT(part->disk_specific != NULL);
dasd_data = part->disk_specific;
switch (flag) {
@@ -722,8 +722,8 @@ dasd_partition_get_flag (const PedPartition* part,
PedPartitionFlag flag)
{
DasdPartitionData* dasd_data;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
dasd_data = part->disk_specific;
switch (flag) {
@@ -815,7 +815,7 @@ dasd_partition_align (PedPartition* part, const
PedConstraint* constraint)
{
DasdDiskSpecific* disk_specific;
- PED_ASSERT (part != NULL, return 0);
+ PED_ASSERT (part != NULL);
disk_specific = part->disk->disk_specific;
/* If formated in LDL, ignore metadata partition */
@@ -911,8 +911,8 @@ dasd_alloc_metadata (PedDisk* disk)
PedSector trailing_meta_start, trailing_meta_end;
struct fdasd_anchor anchor;
- PED_ASSERT (disk != NULL, goto error);
- PED_ASSERT (disk->dev != NULL, goto error);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
arch_specific = LINUX_SPECIFIC (disk->dev);
disk_specific = disk->disk_specific;
diff --git a/libparted/labels/dos.c b/libparted/labels/dos.c
index ba80896..3d2dbd7 100644
--- a/libparted/labels/dos.c
+++ b/libparted/labels/dos.c
@@ -238,7 +238,7 @@ msdos_probe (const PedDevice *dev)
DosRawTable* part_table;
int i;
- PED_ASSERT (dev != NULL, return 0);
+ PED_ASSERT (dev != NULL);
if (dev->sector_size < sizeof *part_table)
return 0;
@@ -307,7 +307,7 @@ static PedDisk*
msdos_alloc (const PedDevice* dev)
{
PedDisk* disk;
- PED_ASSERT (dev != NULL, return NULL);
+ PED_ASSERT (dev != NULL);
disk = _ped_disk_alloc ((PedDevice*)dev, &msdos_disk_type);
if (disk) {
@@ -341,7 +341,7 @@ msdos_duplicate (const PedDisk* disk)
static void
msdos_free (PedDisk* disk)
{
- PED_ASSERT (disk != NULL, return);
+ PED_ASSERT (disk != NULL);
DosDiskData *disk_specific = disk->disk_specific;
_ped_disk_free (disk);
@@ -411,8 +411,8 @@ chs_to_sector (const PedDevice* dev, const PedCHSGeometry
*bios_geom,
PedSector h; /* lots of bits */
PedSector s;
- PED_ASSERT (bios_geom != NULL, return 0);
- PED_ASSERT (chs != NULL, return 0);
+ PED_ASSERT (bios_geom != NULL);
+ PED_ASSERT (chs != NULL);
c = chs_get_cylinder (chs);
h = chs_get_head (chs);
@@ -431,8 +431,8 @@ sector_to_chs (const PedDevice* dev, const PedCHSGeometry*
bios_geom,
{
PedSector real_c, real_h, real_s;
- PED_ASSERT (dev != NULL, return);
- PED_ASSERT (chs != NULL, return);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (chs != NULL);
if (!bios_geom)
bios_geom = &dev->bios_geom;
@@ -456,8 +456,8 @@ static PedSector
legacy_start (const PedDisk* disk, const PedCHSGeometry* bios_geom,
const DosRawPartition* raw_part)
{
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (raw_part != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (raw_part != NULL);
return chs_to_sector (disk->dev, bios_geom, &raw_part->chs_start);
}
@@ -466,8 +466,8 @@ static PedSector
legacy_end (const PedDisk* disk, const PedCHSGeometry* bios_geom,
const DosRawPartition* raw_part)
{
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (raw_part != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (raw_part != NULL);
return chs_to_sector (disk->dev, bios_geom, &raw_part->chs_end);
}
@@ -476,8 +476,8 @@ static PedSector
linear_start (const PedDisk* disk, const DosRawPartition* raw_part,
PedSector offset)
{
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (raw_part != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (raw_part != NULL);
return offset + PED_LE32_TO_CPU (raw_part->start);
}
@@ -486,8 +486,8 @@ static PedSector
linear_end (const PedDisk* disk, const DosRawPartition* raw_part,
PedSector offset)
{
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (raw_part != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (raw_part != NULL);
return (linear_start (disk, raw_part, offset)
+ (PED_LE32_TO_CPU (raw_part->length) - 1));
@@ -501,9 +501,9 @@ partition_check_bios_geometry (PedPartition* part,
PedCHSGeometry* bios_geom)
DosPartitionData* dos_data;
PedDisk* disk;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
dos_data = part->disk_specific;
if (!dos_data->orig)
@@ -525,7 +525,7 @@ disk_check_bios_geometry (const PedDisk* disk,
PedCHSGeometry* bios_geom)
{
PedPartition* part = NULL;
- PED_ASSERT (disk != NULL, return 0);
+ PED_ASSERT (disk != NULL);
while ((part = ped_disk_next_partition (disk, part))) {
if (ped_partition_is_active (part)) {
@@ -548,12 +548,11 @@ probe_filesystem_for_geom (const PedPartition* part,
PedCHSGeometry* bios_geom)
int heads;
int res = 0;
- PED_ASSERT (bios_geom != NULL, return 0);
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk != NULL, return 0);
- PED_ASSERT (part->disk->dev != NULL, return 0);
- PED_ASSERT (part->disk->dev->sector_size % PED_SECTOR_SIZE_DEFAULT ==
0,
- return 0);
+ PED_ASSERT (bios_geom != NULL);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk != NULL);
+ PED_ASSERT (part->disk->dev != NULL);
+ PED_ASSERT (part->disk->dev->sector_size % PED_SECTOR_SIZE_DEFAULT ==
0);
buf = ped_malloc (part->disk->dev->sector_size);
@@ -639,9 +638,9 @@ probe_partition_for_geom (const PedPartition* part,
PedCHSGeometry* bios_geom)
PedSector cyl_size, head_size;
PedSector cylinders, heads, sectors;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
- PED_ASSERT (bios_geom != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
+ PED_ASSERT (bios_geom != NULL);
dos_data = part->disk_specific;
@@ -731,7 +730,7 @@ probe_partition_for_geom (const PedPartition* part,
PedCHSGeometry* bios_geom)
head_size = ( A_ - C * cyl_size ) / H;
else {
/* should not happen because denum != 0 */
- PED_ASSERT (0, return 0);
+ PED_ASSERT (0);
}
if (!(head_size > 0))
@@ -776,9 +775,9 @@ static void
partition_probe_bios_geometry (const PedPartition* part,
PedCHSGeometry* bios_geom)
{
- PED_ASSERT (part != NULL, return);
- PED_ASSERT (part->disk != NULL, return);
- PED_ASSERT (bios_geom != NULL, return);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk != NULL);
+ PED_ASSERT (bios_geom != NULL);
if (ped_partition_is_active (part)) {
if (probe_partition_for_geom (part, bios_geom))
@@ -791,7 +790,7 @@ partition_probe_bios_geometry (const PedPartition* part,
if (part->type & PED_PARTITION_LOGICAL) {
PedPartition* ext_part;
ext_part = ped_disk_extended_partition (part->disk);
- PED_ASSERT (ext_part != NULL, return);
+ PED_ASSERT (ext_part != NULL);
partition_probe_bios_geometry (ext_part, bios_geom);
} else {
*bios_geom = part->disk->dev->bios_geom;
@@ -839,7 +838,7 @@ disk_probe_bios_geometry (const PedDisk* disk,
PedCHSGeometry* bios_geom)
static int
raw_part_is_extended (const DosRawPartition* raw_part)
{
- PED_ASSERT (raw_part != NULL, return 0);
+ PED_ASSERT (raw_part != NULL);
switch (raw_part->type) {
case PARTITION_DOS_EXT:
@@ -857,7 +856,7 @@ raw_part_is_extended (const DosRawPartition* raw_part)
static int
raw_part_is_hidden (const DosRawPartition* raw_part)
{
- PED_ASSERT (raw_part != NULL, return 0);
+ PED_ASSERT (raw_part != NULL);
switch (raw_part->type) {
case PARTITION_FAT12_H:
@@ -879,7 +878,7 @@ raw_part_is_hidden (const DosRawPartition* raw_part)
static int
raw_part_is_lba (const DosRawPartition* raw_part)
{
- PED_ASSERT (raw_part != NULL, return 0);
+ PED_ASSERT (raw_part != NULL);
switch (raw_part->type) {
case PARTITION_FAT32_LBA:
@@ -903,8 +902,8 @@ raw_part_parse (const PedDisk* disk, const DosRawPartition*
raw_part,
PedPartition* part;
DosPartitionData* dos_data;
- PED_ASSERT (disk != NULL, return NULL);
- PED_ASSERT (raw_part != NULL, return NULL);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (raw_part != NULL);
part = ped_partition_new (
disk, type, NULL,
@@ -946,8 +945,8 @@ read_table (PedDisk* disk, PedSector sector, int
is_extended_table)
PedPartitionType type;
PedSector lba_offset;
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (disk->dev != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
void *label = NULL;
if (!ptt_read_sector (disk->dev, sector, &label))
@@ -1065,8 +1064,8 @@ error:
static int
msdos_read (PedDisk* disk)
{
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (disk->dev != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
ped_disk_delete_all (disk);
if (!read_table (disk, 0, 0))
@@ -1101,8 +1100,8 @@ fill_raw_part (DosRawPartition* raw_part,
DosPartitionData* dos_data;
PedCHSGeometry bios_geom;
- PED_ASSERT (raw_part != NULL, return 0);
- PED_ASSERT (part != NULL, return 0);
+ PED_ASSERT (raw_part != NULL);
+ PED_ASSERT (part != NULL);
partition_probe_bios_geometry (part, &bios_geom);
@@ -1134,9 +1133,9 @@ fill_ext_raw_part_geom (DosRawPartition* raw_part,
const PedCHSGeometry* bios_geom,
const PedGeometry* geom, PedSector offset)
{
- PED_ASSERT (raw_part != NULL, return 0);
- PED_ASSERT (geom != NULL, return 0);
- PED_ASSERT (geom->dev != NULL, return 0);
+ PED_ASSERT (raw_part != NULL);
+ PED_ASSERT (geom != NULL);
+ PED_ASSERT (geom->dev != NULL);
raw_part->boot_ind = 0;
raw_part->type = PARTITION_DOS_EXT;
@@ -1157,9 +1156,9 @@ write_ext_table (const PedDisk* disk,
PedPartition* part;
PedSector lba_offset;
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (ped_disk_extended_partition (disk) != NULL, return 0);
- PED_ASSERT (logical != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (ped_disk_extended_partition (disk) != NULL);
+ PED_ASSERT (logical != NULL);
lba_offset = ped_disk_extended_partition (disk)->geom.start;
@@ -1205,7 +1204,7 @@ write_empty_table (const PedDisk* disk, PedSector sector)
DosRawTable table;
void* table_sector;
- PED_ASSERT (disk != NULL, return 0);
+ PED_ASSERT (disk != NULL);
if (ptt_read_sector (disk->dev, sector, &table_sector)) {
memcpy (&table, table_sector, sizeof (table));
@@ -1226,7 +1225,7 @@ write_extended_partitions (const PedDisk* disk)
PedPartition* part;
PedCHSGeometry bios_geom;
- PED_ASSERT (disk != NULL, return 0);
+ PED_ASSERT (disk != NULL);
ext_part = ped_disk_extended_partition (disk);
partition_probe_bios_geometry (ext_part, &bios_geom);
@@ -1253,8 +1252,8 @@ msdos_write (const PedDisk* disk)
PedPartition* part;
int i;
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (disk->dev != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
void *s0;
if (!ptt_read_sector (disk->dev, 0, &s0))
@@ -1379,7 +1378,7 @@ msdos_partition_duplicate (const PedPartition* part)
static void
msdos_partition_destroy (PedPartition* part)
{
- PED_ASSERT (part != NULL, return);
+ PED_ASSERT (part != NULL);
if (ped_partition_is_active (part)) {
DosPartitionData* dos_data;
@@ -1489,9 +1488,9 @@ msdos_partition_set_flag (PedPartition* part,
PedPartition* walk;
DosPartitionData* dos_data;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
- PED_ASSERT (part->disk != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
+ PED_ASSERT (part->disk != NULL);
dos_data = part->disk_specific;
disk = part->disk;
@@ -1566,8 +1565,8 @@ msdos_partition_get_flag (const PedPartition* part,
PedPartitionFlag flag)
{
DosPartitionData* dos_data;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
dos_data = part->disk_specific;
switch (flag) {
@@ -1810,7 +1809,7 @@ _logical_constraint (const PedDisk* disk, const
PedCHSGeometry* bios_geom,
PedAlignment end_align;
PedGeometry max_geom;
- PED_ASSERT (ext_part != NULL, return NULL);
+ PED_ASSERT (ext_part != NULL);
if (!ped_alignment_init (&start_align, start_offset, cylinder_size))
return NULL;
@@ -1959,7 +1958,7 @@ _log_meta_overlap_constraint (PedPartition* part, const
PedGeometry* geom)
PedPartition* walk;
int not_5 = (part->num != 5);
- PED_ASSERT (ext_part != NULL, return NULL);
+ PED_ASSERT (ext_part != NULL);
walk = ext_part->part_list;
@@ -2001,7 +2000,7 @@ _align_logical (PedPartition* part, const PedCHSGeometry*
bios_geom,
PedGeometry* solution = NULL;
PedConstraint *intersect, *log_meta_overlap;
- PED_ASSERT (ext_part != NULL, return 0);
+ PED_ASSERT (ext_part != NULL);
log_meta_overlap = _log_meta_overlap_constraint(part, &part->geom);
intersect = ped_constraint_intersect (constraint, log_meta_overlap);
@@ -2139,8 +2138,8 @@ msdos_partition_align (PedPartition* part, const
PedConstraint* constraint)
PedCHSGeometry bios_geom;
DosPartitionData* dos_data;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
dos_data = part->disk_specific;
@@ -2185,7 +2184,7 @@ add_metadata_part (PedDisk* disk, PedPartitionType type,
PedSector start,
{
PedPartition* new_part;
- PED_ASSERT (disk != NULL, return 0);
+ PED_ASSERT (disk != NULL);
new_part = ped_partition_new (disk, type | PED_PARTITION_METADATA, NULL,
start, end);
@@ -2242,7 +2241,7 @@ add_logical_part_metadata (PedDisk* disk, const
PedPartition* log_part)
if (log_part->num == 5 && metadata_length < bios_geom.sectors)
return 1;
- PED_ASSERT (metadata_length > 0, return 0);
+ PED_ASSERT (metadata_length > 0);
return add_metadata_part (disk, PED_PARTITION_LOGICAL,
metadata_start, metadata_end);
@@ -2356,8 +2355,8 @@ msdos_alloc_metadata (PedDisk* disk)
{
PedPartition* ext_part;
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (disk->dev != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
if (!add_startend_metadata (disk))
return 0;
@@ -2415,8 +2414,8 @@ next_logical (const PedDisk* disk)
static int
msdos_partition_enumerate (PedPartition* part)
{
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk != NULL);
/* don't re-number a primary partition */
if (part->num != -1 && part->num <= DOS_N_PRI_PARTITIONS)
@@ -2472,8 +2471,8 @@ static PedDiskType msdos_disk_type = {
void
ped_disk_msdos_init ()
{
- PED_ASSERT (sizeof (DosRawPartition) == 16, return);
- PED_ASSERT (sizeof (DosRawTable) == 512, return);
+ PED_ASSERT (sizeof (DosRawPartition) == 16);
+ PED_ASSERT (sizeof (DosRawTable) == 512);
ped_disk_type_register (&msdos_disk_type);
}
diff --git a/libparted/labels/dvh.c b/libparted/labels/dvh.c
index d31f2d4..6378c04 100644
--- a/libparted/labels/dvh.c
+++ b/libparted/labels/dvh.c
@@ -69,7 +69,7 @@ static int
read_sector (const PedDevice *dev, PedSector sector_num, char **buf)
{
char *b = ped_malloc (dev->sector_size);
- PED_ASSERT (b != NULL, return 0);
+ PED_ASSERT (b != NULL);
if (!ped_device_read (dev, b, sector_num, 1)) {
free (b);
return 0;
@@ -146,7 +146,7 @@ dvh_duplicate (const PedDisk* disk)
DVHDiskData* new_dvh_disk_data;
DVHDiskData* old_dvh_disk_data = disk->disk_specific;
- PED_ASSERT (old_dvh_disk_data != NULL, goto error);
+ PED_ASSERT (old_dvh_disk_data != NULL);
new_disk = ped_disk_new_fresh (disk->dev, &dvh_disk_type);
if (!new_disk)
@@ -309,7 +309,7 @@ dvh_read (PedDisk* disk)
int write_back = 0;
#endif
- PED_ASSERT (dvh_disk_data != NULL, return 0);
+ PED_ASSERT (dvh_disk_data != NULL);
ped_disk_delete_all (disk);
@@ -329,7 +329,7 @@ dvh_read (PedDisk* disk)
return 0;
}
- PED_ASSERT (PED_BE32_TO_CPU (vh.vh_magic) == VHMAGIC, return 0);
+ PED_ASSERT (PED_BE32_TO_CPU (vh.vh_magic) == VHMAGIC);
dvh_disk_data->dev_params = vh.vh_dp;
strncpy (boot_name, vh.vh_bootfile, BFNAMESIZE);
@@ -429,7 +429,7 @@ _generate_partition (PedPartition* part, struct
partition_table* pt)
DVHPartData* dvh_part_data = part->disk_specific;
/* Assert not a bootfile */
- PED_ASSERT ((part->type & PED_PARTITION_LOGICAL) == 0, return);
+ PED_ASSERT ((part->type & PED_PARTITION_LOGICAL) == 0);
pt->pt_nblks = PED_CPU_TO_BE32 (part->geom.length);
pt->pt_firstlbn = PED_CPU_TO_BE32 (part->geom.start);
@@ -442,7 +442,7 @@ _generate_boot_file (PedPartition* part, struct
volume_directory* vd)
DVHPartData* dvh_part_data = part->disk_specific;
/* Assert it's a bootfile */
- PED_ASSERT ((part->type & PED_PARTITION_LOGICAL) != 0, return);
+ PED_ASSERT ((part->type & PED_PARTITION_LOGICAL) != 0);
vd->vd_nbytes = PED_CPU_TO_BE32 (dvh_part_data->real_file_size);
vd->vd_lbn = PED_CPU_TO_BE32 (part->geom.start);
@@ -458,7 +458,7 @@ dvh_write (const PedDisk* disk)
struct volume_header vh;
int i;
- PED_ASSERT (dvh_disk_data != NULL, return 0);
+ PED_ASSERT (dvh_disk_data != NULL);
_flush_stale_flags (disk);
@@ -587,7 +587,7 @@ static void
dvh_partition_destroy (PedPartition* part)
{
if (ped_partition_is_active (part)) {
- PED_ASSERT (part->disk_specific != NULL, return);
+ PED_ASSERT (part->disk_specific != NULL);
free (part->disk_specific);
}
_ped_partition_free (part);
@@ -771,7 +771,7 @@ _get_primary_constraint (PedDisk* disk)
static int
dvh_partition_align (PedPartition* part, const PedConstraint* constraint)
{
- PED_ASSERT (part != NULL, return 0);
+ PED_ASSERT (part != NULL);
if (_ped_partition_attempt_align (
part, constraint,
@@ -808,7 +808,7 @@ dvh_partition_enumerate (PedPartition* part)
return 1;
}
}
- PED_ASSERT (0, return 0);
+ PED_ASSERT (0);
} else if (part->type & PED_PARTITION_EXTENDED) {
/* Volheader */
part->num = PNUM_VOLHDR + 1;
@@ -852,7 +852,7 @@ dvh_alloc_metadata (PedDisk* disk)
PedPartition* part;
PedPartition* extended_part;
PedPartitionType metadata_type;
- PED_ASSERT(disk != NULL, return 0);
+ PED_ASSERT(disk != NULL);
/* We don't need to "protect" the start of the disk from the volume
* header.
@@ -901,7 +901,7 @@ static PedDiskType dvh_disk_type = {
void
ped_disk_dvh_init ()
{
- PED_ASSERT (sizeof (struct volume_header) == 512, return);
+ PED_ASSERT (sizeof (struct volume_header) == 512);
ped_disk_type_register (&dvh_disk_type);
}
diff --git a/libparted/labels/gpt.c b/libparted/labels/gpt.c
index 1b9fcfa..54f0785 100644
--- a/libparted/labels/gpt.c
+++ b/libparted/labels/gpt.c
@@ -331,7 +331,7 @@ pth_new_from_raw (const PedDevice *dev, const uint8_t
*pth_raw)
{
GuidPartitionTableHeader_t *pth = pth_new (dev);
- PED_ASSERT (pth_raw != NULL, return 0);
+ PED_ASSERT (pth_raw != NULL);
memcpy (pth, pth_raw, pth_get_size_static (dev));
memcpy (pth->Reserved2, pth_raw + pth_get_size_static (dev),
@@ -345,7 +345,7 @@ pth_free (GuidPartitionTableHeader_t *pth)
{
if (pth == NULL)
return;
- PED_ASSERT (pth->Reserved2 != NULL, return);
+ PED_ASSERT (pth->Reserved2 != NULL);
free (pth->Reserved2);
free (pth);
@@ -354,8 +354,8 @@ pth_free (GuidPartitionTableHeader_t *pth)
static uint8_t *
pth_get_raw (const PedDevice *dev, const GuidPartitionTableHeader_t *pth)
{
- PED_ASSERT (pth != NULL, return 0);
- PED_ASSERT (pth->Reserved2 != NULL, return 0);
+ PED_ASSERT (pth != NULL);
+ PED_ASSERT (pth->Reserved2 != NULL);
int size_static = pth_get_size_static (dev);
uint8_t *pth_raw = ped_malloc (pth_get_size (dev));
@@ -393,7 +393,7 @@ swap_uuid_and_efi_guid (uuid_t uuid)
{
efi_guid_t *guid = (efi_guid_t *) uuid;
- PED_ASSERT (uuid != NULL, return);
+ PED_ASSERT (uuid != NULL);
guid->time_low = PED_SWAP32 (guid->time_low);
guid->time_mid = PED_SWAP16 (guid->time_mid);
guid->time_hi_and_version = PED_SWAP16 (guid->time_hi_and_version);
@@ -416,8 +416,8 @@ static int
pth_crc32 (const PedDevice *dev, const GuidPartitionTableHeader_t *pth,
uint32_t *crc32)
{
- PED_ASSERT (dev != NULL, return 0);
- PED_ASSERT (pth != NULL, return 0);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (pth != NULL);
uint8_t *pth_raw = pth_get_raw (dev, pth);
if (pth_raw == NULL)
@@ -441,7 +441,7 @@ _pmbr_is_valid (const LegacyMBR_t *mbr)
{
int i;
- PED_ASSERT (mbr != NULL, return 0);
+ PED_ASSERT (mbr != NULL);
if (mbr->Signature != PED_CPU_TO_LE16 (MSDOS_MBR_SIGNATURE))
return 0;
@@ -459,7 +459,7 @@ gpt_probe (const PedDevice *dev)
GuidPartitionTableHeader_t *gpt = NULL;
int gpt_sig_found = 0;
- PED_ASSERT (dev != NULL, return 0);
+ PED_ASSERT (dev != NULL);
if (dev->length <= 1)
return 0;
@@ -718,11 +718,11 @@ _parse_header (PedDisk *disk, const
GuidPartitionTableHeader_t *gpt,
last_usable_if_grown = last_usable_min_default;
}
- PED_ASSERT (last_usable > first_usable, return 0);
- PED_ASSERT (last_usable <= disk->dev->length, return 0);
+ PED_ASSERT (last_usable > first_usable);
+ PED_ASSERT (last_usable <= disk->dev->length);
- PED_ASSERT (last_usable_if_grown > first_usable, return 0);
- PED_ASSERT (last_usable_if_grown <= disk->dev->length, return 0);
+ PED_ASSERT (last_usable_if_grown > first_usable);
+ PED_ASSERT (last_usable_if_grown <= disk->dev->length);
if (!asked_already && last_usable < last_usable_if_grown)
{
@@ -754,8 +754,8 @@ _parse_header (PedDisk *disk, const
GuidPartitionTableHeader_t *gpt,
gpt_disk_data->entry_count
= PED_LE32_TO_CPU (gpt->NumberOfPartitionEntries);
- PED_ASSERT (gpt_disk_data->entry_count > 0, return 0);
- PED_ASSERT (gpt_disk_data->entry_count <= 8192, return 0);
+ PED_ASSERT (gpt_disk_data->entry_count > 0);
+ PED_ASSERT (gpt_disk_data->entry_count <= 8192);
gpt_disk_data->uuid = gpt->DiskGUID;
@@ -1160,7 +1160,7 @@ _partition_generate_part_entry (PedPartition *part,
GuidPartitionEntry_t *pte)
GPTPartitionData *gpt_part_data = part->disk_specific;
unsigned int i;
- PED_ASSERT (gpt_part_data != NULL, return);
+ PED_ASSERT (gpt_part_data != NULL);
pte->PartitionTypeGuid = gpt_part_data->type;
pte->UniquePartitionGuid = gpt_part_data->uuid;
@@ -1189,9 +1189,9 @@ gpt_write (const PedDisk *disk)
PedPartition *part;
int ptes_size;
- PED_ASSERT (disk != NULL, goto error);
- PED_ASSERT (disk->dev != NULL, goto error);
- PED_ASSERT (disk->disk_specific != NULL, goto error);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
+ PED_ASSERT (disk->disk_specific != NULL);
gpt_disk_data = disk->disk_specific;
@@ -1263,7 +1263,7 @@ add_metadata_part (PedDisk *disk, PedSector start,
PedSector length)
{
PedPartition *part;
PedConstraint *constraint_exact;
- PED_ASSERT (disk != NULL, return 0);
+ PED_ASSERT (disk != NULL);
part = ped_partition_new (disk, PED_PARTITION_METADATA, NULL,
start, start + length - 1);
@@ -1363,7 +1363,7 @@ gpt_partition_destroy (PedPartition *part)
{
if (part->type == 0)
{
- PED_ASSERT (part->disk_specific != NULL, return);
+ PED_ASSERT (part->disk_specific != NULL);
free (part->disk_specific);
}
@@ -1376,7 +1376,7 @@ gpt_partition_set_system (PedPartition *part,
{
GPTPartitionData *gpt_part_data = part->disk_specific;
- PED_ASSERT (gpt_part_data != NULL, return 0);
+ PED_ASSERT (gpt_part_data != NULL);
part->fs_type = fs_type;
@@ -1452,9 +1452,9 @@ gpt_alloc_metadata (PedDisk *disk)
PedSector gptlength, pteslength = 0;
GPTDiskData *gpt_disk_data;
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (disk->dev != NULL, return 0);
- PED_ASSERT (disk->disk_specific != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
+ PED_ASSERT (disk->disk_specific != NULL);
gpt_disk_data = disk->disk_specific;
gptlength = ped_div_round_up (sizeof (GuidPartitionTableHeader_t),
@@ -1496,7 +1496,7 @@ gpt_partition_enumerate (PedPartition *part)
}
}
- PED_ASSERT (0, return 0);
+ PED_ASSERT (0);
return 0; /* used if debug is disabled */
}
@@ -1505,8 +1505,8 @@ static int
gpt_partition_set_flag (PedPartition *part, PedPartitionFlag flag, int state)
{
GPTPartitionData *gpt_part_data;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
gpt_part_data = part->disk_specific;
switch (flag)
@@ -1618,7 +1618,7 @@ static int
gpt_partition_get_flag (const PedPartition *part, PedPartitionFlag flag)
{
GPTPartitionData *gpt_part_data;
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part->disk_specific != NULL);
gpt_part_data = part->disk_specific;
switch (flag)
@@ -1758,7 +1758,7 @@ _non_metadata_constraint (const PedDisk *disk)
static int
gpt_partition_align (PedPartition *part, const PedConstraint *constraint)
{
- PED_ASSERT (part != NULL, return 0);
+ PED_ASSERT (part != NULL);
if (_ped_partition_attempt_align (part, constraint,
_non_metadata_constraint (part->disk)))
diff --git a/libparted/labels/loop.c b/libparted/labels/loop.c
index c99f3fb..c0f0979 100644
--- a/libparted/labels/loop.c
+++ b/libparted/labels/loop.c
@@ -76,7 +76,7 @@ error:
static PedDisk*
loop_alloc (const PedDevice* dev)
{
- PED_ASSERT (dev != NULL, return 0);
+ PED_ASSERT (dev != NULL);
if (dev->length < 256)
return NULL;
@@ -92,7 +92,7 @@ loop_duplicate (const PedDisk* disk)
static void
loop_free (PedDisk* disk)
{
- PED_ASSERT (disk != NULL, return);
+ PED_ASSERT (disk != NULL);
_ped_disk_free (disk);
}
@@ -106,7 +106,7 @@ loop_read (PedDisk* disk)
PedPartition* part;
PedConstraint* constraint_any;
- PED_ASSERT (disk != NULL, return 0);
+ PED_ASSERT (disk != NULL);
dev = disk->dev;
constraint_any = ped_constraint_any (dev);
diff --git a/libparted/labels/mac.c b/libparted/labels/mac.c
index f49fcab..f63f48a 100644
--- a/libparted/labels/mac.c
+++ b/libparted/labels/mac.c
@@ -200,7 +200,7 @@ _rawpart_check_signature (MacRawPartition* raw_part)
static int
mac_probe (const PedDevice * dev)
{
- PED_ASSERT (dev != NULL, return 0);
+ PED_ASSERT (dev != NULL);
if (dev->sector_size < sizeof (MacRawDisk))
return 0;
@@ -269,7 +269,7 @@ mac_alloc (const PedDevice* dev)
PedDisk* disk;
MacDiskData* mac_disk_data;
- PED_ASSERT (dev != NULL, return NULL);
+ PED_ASSERT (dev != NULL);
#ifndef DISCOVER_ONLY
if (dev->length < 256) {
@@ -327,7 +327,7 @@ mac_duplicate (const PedDisk* disk)
PedSector first_part_map_sector = old_mac_data->ghost_size;
PedPartition *partition_map
= ped_disk_get_partition_by_sector (new_disk, first_part_map_sector);
- PED_ASSERT (partition_map != NULL, return 0);
+ PED_ASSERT (partition_map != NULL);
/* ped_disk_remove_partition may be used only to delete a "normal"
partition. Trying to delete at least "freespace" or "metadata"
@@ -335,7 +335,7 @@ mac_duplicate (const PedDisk* disk)
ped_disk_remove_partition, since it calls _disk_push_update_mode,
which destroys all "freespace" and "metadata" partitions, and
depends on that destruction not freeing its PART parameter. */
- PED_ASSERT (partition_map->type == PED_PARTITION_NORMAL, return 0);
+ PED_ASSERT (partition_map->type == PED_PARTITION_NORMAL);
ped_disk_remove_partition (new_disk, partition_map);
/* ugly, but C is ugly :p */
@@ -704,7 +704,7 @@ _disk_analyse_ghost_size (PedDisk* disk)
if (_rawpart_check_signature (buf)
&& !_rawpart_is_void (buf)) {
mac_disk_data->ghost_size = i;
- PED_ASSERT (i <= disk->dev->sector_size / 512, break);
+ PED_ASSERT (i <= disk->dev->sector_size / 512);
found = 1;
break;
}
@@ -731,7 +731,7 @@ mac_read (PedDisk* disk)
PedConstraint* constraint_exact;
int last_part_entry_num = 0;
- PED_ASSERT (disk != NULL, return 0);
+ PED_ASSERT (disk != NULL);
mac_disk_data = disk->disk_specific;
mac_disk_data->part_map_entry_num = 0; /* 0 == none */
@@ -909,7 +909,7 @@ _generate_raw_part (PedDisk* disk, PedPartition* part,
MacPartitionData* mac_part_data;
PedSector block_size = disk->dev->sector_size / 512;
- PED_ASSERT (part->num > 0, goto error);
+ PED_ASSERT (part->num > 0);
mac_disk_data = disk->disk_specific;
mac_part_data = part->disk_specific;
@@ -967,7 +967,7 @@ _generate_raw_freespace_part (PedDisk* disk, PedGeometry*
geom, int num,
MacDiskData* mac_disk_data = disk->disk_specific;
PedSector block_size = disk->dev->sector_size / 512;
- PED_ASSERT (num > 0, goto error);
+ PED_ASSERT (num > 0);
MacRawPartition *part_map_entry = get_pme (part_map, num, disk);
@@ -999,7 +999,7 @@ _generate_empty_part (PedDisk* disk, int num,
MacRawPartition* part_map)
{
MacDiskData* mac_disk_data = disk->disk_specific;
- PED_ASSERT (num > 0, return 0);
+ PED_ASSERT (num > 0);
MacRawPartition *part_map_entry = get_pme (part_map, num, disk);
part_map_entry->signature = PED_CPU_TO_BE16 (MAC_PARTITION_MAGIC_2);
@@ -1058,10 +1058,10 @@ mac_write (PedDisk* disk)
PedPartition* part;
int num;
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (disk->disk_specific != NULL, return 0);
- PED_ASSERT (disk->dev != NULL, return 0);
- PED_ASSERT (!disk->update_mode, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->disk_specific != NULL);
+ PED_ASSERT (disk->dev != NULL);
+ PED_ASSERT (!disk->update_mode);
mac_disk_data = disk->disk_specific;
@@ -1181,7 +1181,7 @@ mac_partition_duplicate (const PedPartition* part)
static void
mac_partition_destroy (PedPartition* part)
{
- PED_ASSERT (part != NULL, return);
+ PED_ASSERT (part != NULL);
if (ped_partition_is_active (part))
free (part->disk_specific);
@@ -1224,8 +1224,8 @@ mac_partition_set_flag (PedPartition* part,
PedPartitionFlag flag, int state)
{
MacPartitionData* mac_data;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
mac_data = part->disk_specific;
@@ -1294,8 +1294,8 @@ mac_partition_get_flag (const PedPartition* part,
PedPartitionFlag flag)
{
MacPartitionData* mac_data;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
mac_data = part->disk_specific;
switch (flag) {
@@ -1342,8 +1342,8 @@ mac_partition_set_name (PedPartition* part, const char*
name)
MacPartitionData* mac_data;
int i;
- PED_ASSERT (part != NULL, return);
- PED_ASSERT (part->disk_specific != NULL, return);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
mac_data = part->disk_specific;
#ifndef DISCOVER_ONLY
@@ -1371,8 +1371,8 @@ mac_partition_get_name (const PedPartition* part)
{
MacPartitionData* mac_data;
- PED_ASSERT (part != NULL, return NULL);
- PED_ASSERT (part->disk_specific != NULL, return NULL);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
mac_data = part->disk_specific;
return mac_data->volume_name;
@@ -1410,7 +1410,7 @@ _primary_constraint (PedDisk* disk)
static int
mac_partition_align (PedPartition* part, const PedConstraint* constraint)
{
- PED_ASSERT (part != NULL, return 0);
+ PED_ASSERT (part != NULL);
if (_ped_partition_attempt_align (part, constraint,
_primary_constraint (part->disk)))
@@ -1433,8 +1433,8 @@ mac_partition_enumerate (PedPartition* part)
int i;
int max_part_count;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk != NULL);
disk = part->disk;
mac_disk_data = (MacDiskData*) disk->disk_specific;
@@ -1469,7 +1469,7 @@ _disk_count_partitions (PedDisk* disk)
PedPartition* part = NULL;
PedPartition* last = NULL;
- PED_ASSERT (disk->update_mode, return 0);
+ PED_ASSERT (disk->update_mode);
mac_disk_data->active_part_entry_count = 0;
mac_disk_data->free_part_entry_count = 0;
@@ -1508,7 +1508,7 @@ add_metadata_part (PedDisk* disk, PedSector start,
PedSector end)
PedPartition* new_part;
PedConstraint* constraint_any = ped_constraint_any (disk->dev);
- PED_ASSERT (disk != NULL, return 0);
+ PED_ASSERT (disk != NULL);
new_part = ped_partition_new (disk, PED_PARTITION_METADATA, NULL,
start, end);
@@ -1530,9 +1530,9 @@ error:
static int
mac_alloc_metadata (PedDisk* disk)
{
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (disk->disk_specific != NULL, return 0);
- PED_ASSERT (disk->dev != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->disk_specific != NULL);
+ PED_ASSERT (disk->dev != NULL);
if (!add_metadata_part (disk, 0, disk->dev->sector_size / 512 - 1))
return 0;
@@ -1605,8 +1605,8 @@ static PedDiskType mac_disk_type = {
void
ped_disk_mac_init ()
{
- PED_ASSERT (sizeof (MacRawPartition) == 512, return);
- PED_ASSERT (sizeof (MacRawDisk) == 512, return);
+ PED_ASSERT (sizeof (MacRawPartition) == 512);
+ PED_ASSERT (sizeof (MacRawDisk) == 512);
ped_disk_type_register (&mac_disk_type);
}
diff --git a/libparted/labels/pc98.c b/libparted/labels/pc98.c
index 958d97c..5a720db 100644
--- a/libparted/labels/pc98.c
+++ b/libparted/labels/pc98.c
@@ -180,7 +180,7 @@ pc98_probe (const PedDevice *dev)
int empty;
const PC98RawPartition* p;
- PED_ASSERT (dev != NULL, return 0);
+ PED_ASSERT (dev != NULL);
if (dev->sector_size != 512)
return 0;
@@ -221,7 +221,7 @@ pc98_probe (const PedDevice *dev)
static PedDisk*
pc98_alloc (const PedDevice* dev)
{
- PED_ASSERT (dev != NULL, return 0);
+ PED_ASSERT (dev != NULL);
return _ped_disk_alloc (dev, &pc98_disk_type);
}
@@ -235,7 +235,7 @@ pc98_duplicate (const PedDisk* disk)
static void
pc98_free (PedDisk* disk)
{
- PED_ASSERT (disk != NULL, return);
+ PED_ASSERT (disk != NULL);
_ped_disk_free (disk);
}
@@ -243,7 +243,7 @@ pc98_free (PedDisk* disk)
static PedSector
chs_to_sector (const PedDevice* dev, int c, int h, int s)
{
- PED_ASSERT (dev != NULL, return 0);
+ PED_ASSERT (dev != NULL);
return (c * dev->hw_geom.heads + h) * dev->hw_geom.sectors + s;
}
@@ -252,10 +252,10 @@ sector_to_chs (const PedDevice* dev, PedSector sector,
int* c, int* h, int* s)
{
PedSector cyl_size;
- PED_ASSERT (dev != NULL, return);
- PED_ASSERT (c != NULL, return);
- PED_ASSERT (h != NULL, return);
- PED_ASSERT (s != NULL, return);
+ PED_ASSERT (dev != NULL);
+ PED_ASSERT (c != NULL);
+ PED_ASSERT (h != NULL);
+ PED_ASSERT (s != NULL);
cyl_size = dev->hw_geom.heads * dev->hw_geom.sectors;
@@ -267,8 +267,8 @@ sector_to_chs (const PedDevice* dev, PedSector sector, int*
c, int* h, int* s)
static PedSector
legacy_start (const PedDisk* disk, const PC98RawPartition* raw_part)
{
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (raw_part != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (raw_part != NULL);
return chs_to_sector (disk->dev, PED_LE16_TO_CPU(raw_part->cyl),
raw_part->head, raw_part->sector);
@@ -277,8 +277,8 @@ legacy_start (const PedDisk* disk, const PC98RawPartition*
raw_part)
static PedSector
legacy_end (const PedDisk* disk, const PC98RawPartition* raw_part)
{
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (raw_part != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (raw_part != NULL);
if (raw_part->end_head == 0 && raw_part->end_sector == 0) {
return chs_to_sector (disk->dev,
@@ -317,8 +317,8 @@ read_table (PedDisk* disk)
PC98RawTable table;
PedConstraint* constraint_any;
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (disk->dev != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
constraint_any = ped_constraint_any (disk->dev);
@@ -353,7 +353,7 @@ read_table (PedDisk* disk)
if (!part)
goto error;
pc98_data = part->disk_specific;
- PED_ASSERT (pc98_data != NULL, goto error);
+ PED_ASSERT (pc98_data != NULL);
pc98_data->system = (raw_part->mid << 8) | raw_part->sid;
pc98_data->boot = GET_BIT(raw_part->mid, 7);
@@ -402,8 +402,8 @@ error:
static int
pc98_read (PedDisk* disk)
{
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (disk->dev != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
ped_disk_delete_all (disk);
return read_table (disk);
@@ -417,9 +417,9 @@ fill_raw_part (PC98RawPartition* raw_part, const
PedPartition* part)
int c, h, s;
const char* name;
- PED_ASSERT (raw_part != NULL, return 0);
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (raw_part != NULL);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
pc98_data = part->disk_specific;
raw_part->mid = (pc98_data->system >> 8) & 0xFF;
@@ -430,8 +430,8 @@ fill_raw_part (PC98RawPartition* raw_part, const
PedPartition* part)
memset (raw_part->name, ' ', sizeof(raw_part->name));
name = ped_partition_get_name (part);
- PED_ASSERT (name != NULL, return 0);
- PED_ASSERT (strlen (name) <= 16, return 0);
+ PED_ASSERT (name != NULL);
+ PED_ASSERT (strlen (name) <= 16);
if (!strlen (name) && part->fs_type)
name = part->fs_type->name;
memcpy (raw_part->name, name, strlen (name));
@@ -482,8 +482,8 @@ pc98_write (const PedDisk* disk)
PedPartition* part;
int i;
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (disk->dev != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
void *s0;
if (!ptt_read_sectors (disk->dev, 0, 2, &s0))
@@ -573,7 +573,7 @@ pc98_partition_duplicate (const PedPartition* part)
static void
pc98_partition_destroy (PedPartition* part)
{
- PED_ASSERT (part != NULL, return);
+ PED_ASSERT (part != NULL);
if (ped_partition_is_active (part))
free (part->disk_specific);
@@ -619,8 +619,8 @@ pc98_partition_set_flag (PedPartition* part,
PedPartitionFlag flag, int state)
{
PC98PartitionData* pc98_data;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
pc98_data = part->disk_specific;
@@ -643,8 +643,8 @@ pc98_partition_get_flag (const PedPartition* part,
PedPartitionFlag flag)
{
PC98PartitionData* pc98_data;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
pc98_data = part->disk_specific;
switch (flag) {
@@ -679,8 +679,8 @@ pc98_partition_set_name (PedPartition* part, const char*
name)
PC98PartitionData* pc98_data;
int i;
- PED_ASSERT (part != NULL, return);
- PED_ASSERT (part->disk_specific != NULL, return);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
pc98_data = part->disk_specific;
strncpy (pc98_data->name, name, 16);
@@ -694,8 +694,8 @@ pc98_partition_get_name (const PedPartition* part)
{
PC98PartitionData* pc98_data;
- PED_ASSERT (part != NULL, return NULL);
- PED_ASSERT (part->disk_specific != NULL, return NULL);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
pc98_data = part->disk_specific;
return pc98_data->name;
@@ -736,7 +736,7 @@ _primary_constraint (PedDisk* disk)
static int
pc98_partition_align (PedPartition* part, const PedConstraint* constraint)
{
- PED_ASSERT (part != NULL, return 0);
+ PED_ASSERT (part != NULL);
if (_ped_partition_attempt_align (part, constraint,
_primary_constraint (part->disk)))
@@ -765,14 +765,14 @@ next_primary (PedDisk* disk)
static int
pc98_partition_enumerate (PedPartition* part)
{
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk != NULL);
/* don't re-number a partition */
if (part->num != -1)
return 1;
- PED_ASSERT (ped_partition_is_active (part), return 0);
+ PED_ASSERT (ped_partition_is_active (part));
part->num = next_primary (part->disk);
if (!part->num) {
@@ -792,8 +792,8 @@ pc98_alloc_metadata (PedDisk* disk)
PedConstraint* constraint_any = NULL;
PedSector cyl_size;
- PED_ASSERT (disk != NULL, goto error);
- PED_ASSERT (disk->dev != NULL, goto error);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
constraint_any = ped_constraint_any (disk->dev);
@@ -854,7 +854,7 @@ static PedDiskType pc98_disk_type = {
void
ped_disk_pc98_init ()
{
- PED_ASSERT (sizeof (PC98RawTable) == 512 * 2, return);
+ PED_ASSERT (sizeof (PC98RawTable) == 512 * 2);
ped_disk_type_register (&pc98_disk_type);
}
diff --git a/libparted/labels/pt-common.h b/libparted/labels/pt-common.h
index 97eee0a..76f06e3 100644
--- a/libparted/labels/pt-common.h
+++ b/libparted/labels/pt-common.h
@@ -19,7 +19,7 @@ PT_type##_partition_max_start_sector (void)
\
{ \
PedSector max; \
int err = ptt_partition_max_start_sector (#PT_type, &max); \
- PED_ASSERT (err == 0, return 0); \
+ PED_ASSERT (err == 0); \
return max; \
} \
\
@@ -28,7 +28,7 @@ PT_type##_partition_max_length (void)
\
{ \
PedSector max; \
int err = ptt_partition_max_length (#PT_type, &max); \
- PED_ASSERT (err == 0, return 0); \
+ PED_ASSERT (err == 0); \
return max; \
}
diff --git a/libparted/labels/pt-tools.c b/libparted/labels/pt-tools.c
index 19d530c..19eac19 100644
--- a/libparted/labels/pt-tools.c
+++ b/libparted/labels/pt-tools.c
@@ -40,7 +40,7 @@ static char zero[16 * 1024];
int
ptt_write_sector (PedDisk const *disk, void const *buf, size_t buflen)
{
- PED_ASSERT (buflen <= disk->dev->sector_size, return 0);
+ PED_ASSERT (buflen <= disk->dev->sector_size);
/* Allocate a big enough buffer for ped_device_write. */
char *s0 = ped_malloc (disk->dev->sector_size);
if (s0 == NULL)
@@ -65,7 +65,7 @@ ptt_read_sectors (PedDevice const *dev, PedSector
start_sector,
PedSector n_sectors, void **buf)
{
char *b = ped_malloc (n_sectors * dev->sector_size);
- PED_ASSERT (b != NULL, return 0);
+ PED_ASSERT (b != NULL);
if (!ped_device_read (dev, b, start_sector, n_sectors)) {
free (b);
return 0;
@@ -88,7 +88,7 @@ ptt_read_sector (PedDevice const *dev, PedSector sector_num,
void **buf)
int
ptt_clear_sectors (PedDevice *dev, PedSector start, PedSector n)
{
- PED_ASSERT (dev->sector_size <= sizeof zero, return 0);
+ PED_ASSERT (dev->sector_size <= sizeof zero);
PedSector n_z_sectors = sizeof zero / dev->sector_size;
PedSector n_full = n / n_z_sectors;
PedSector i;
diff --git a/libparted/labels/rdb.c b/libparted/labels/rdb.c
index 734d678..98c8fb6 100644
--- a/libparted/labels/rdb.c
+++ b/libparted/labels/rdb.c
@@ -332,7 +332,7 @@ amiga_probe (const PedDevice *dev)
{
struct RigidDiskBlock *rdb;
uint32_t found;
- PED_ASSERT(dev != NULL, return 0);
+ PED_ASSERT(dev != NULL);
if ((rdb=RDSK(ped_malloc(dev->sector_size)))==NULL)
return 0;
@@ -350,7 +350,7 @@ amiga_alloc (const PedDevice* dev)
PedSector cyl_size;
int highest_cylinder, highest_block;
- PED_ASSERT(dev != NULL, return NULL);
+ PED_ASSERT(dev != NULL);
cyl_size = dev->hw_geom.sectors * dev->hw_geom.heads;
if (!(disk = _ped_disk_alloc (dev, &amiga_disk_type)))
@@ -364,7 +364,7 @@ amiga_alloc (const PedDevice* dev)
/* Upon failed assertion this does leak. That's fine, because
if the assertion fails, you have bigger problems than this leak. */
- PED_ASSERT(sizeof(*rdb) <= disk->dev->sector_size, return NULL);
+ PED_ASSERT(sizeof(*rdb) <= disk->dev->sector_size);
memset(rdb, 0, disk->dev->sector_size);
@@ -424,9 +424,9 @@ amiga_duplicate (const PedDisk* disk)
PedDisk* new_disk;
struct RigidDiskBlock * new_rdb;
struct RigidDiskBlock * old_rdb;
- PED_ASSERT(disk != NULL, return NULL);
- PED_ASSERT(disk->dev != NULL, return NULL);
- PED_ASSERT(disk->disk_specific != NULL, return NULL);
+ PED_ASSERT(disk != NULL);
+ PED_ASSERT(disk->dev != NULL);
+ PED_ASSERT(disk->disk_specific != NULL);
old_rdb = (struct RigidDiskBlock *) disk->disk_specific;
@@ -441,8 +441,8 @@ amiga_duplicate (const PedDisk* disk)
static void
amiga_free (PedDisk* disk)
{
- PED_ASSERT(disk != NULL, return);
- PED_ASSERT(disk->disk_specific != NULL, return);
+ PED_ASSERT(disk != NULL);
+ PED_ASSERT(disk->disk_specific != NULL);
free (disk->disk_specific);
_ped_disk_free (disk);
@@ -473,11 +473,10 @@ amiga_read (PedDisk* disk)
PedSector cylblocks;
int i;
- PED_ASSERT(disk != NULL, return 0);
- PED_ASSERT(disk->dev != NULL, return 0);
- PED_ASSERT(disk->dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0,
- return 0);
- PED_ASSERT(disk->disk_specific != NULL, return 0);
+ PED_ASSERT(disk != NULL);
+ PED_ASSERT(disk->dev != NULL);
+ PED_ASSERT(disk->dev->sector_size % PED_SECTOR_SIZE_DEFAULT == 0);
+ PED_ASSERT(disk->disk_specific != NULL);
rdb = RDSK(disk->disk_specific);
if (_amiga_find_rdb (disk->dev, rdb) == AMIGA_RDB_NOT_FOUND) {
@@ -561,8 +560,8 @@ _amiga_find_free_blocks(const PedDisk *disk, uint32_t
*table,
{
PedSector next;
- PED_ASSERT(disk != NULL, return 0);
- PED_ASSERT(disk->dev != NULL, return 0);
+ PED_ASSERT(disk != NULL);
+ PED_ASSERT(disk->dev != NULL);
for (next = first; next != LINK_END; next =
PED_BE32_TO_CPU(block->lk_Next)) {
if (table[next] != IDNAME_FREE) {
@@ -635,9 +634,9 @@ amiga_write (const PedDisk* disk)
uint32_t i;
uint32_t rdb_num, part_num, block_num, next_num;
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (disk->dev != NULL, return 0);
- PED_ASSERT (disk->disk_specific != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
+ PED_ASSERT (disk->disk_specific != NULL);
if (!(rdb = ped_malloc (disk->dev->sector_size)))
return 0;
@@ -719,9 +718,9 @@ amiga_write (const PedDisk* disk)
part = _amiga_next_real_partition(disk, NULL);
rdb->rdb_PartitionList = PED_CPU_TO_BE32(part ? part_num : LINK_END);
for (; part != NULL; part = next_part, block_num = next_num) {
- PED_ASSERT(part->disk_specific != NULL, return 0);
- PED_ASSERT(part->geom.start % cylblocks == 0, return 0);
- PED_ASSERT((part->geom.end + 1) % cylblocks == 0, return 0);
+ PED_ASSERT(part->disk_specific != NULL);
+ PED_ASSERT(part->geom.start % cylblocks == 0);
+ PED_ASSERT((part->geom.end + 1) % cylblocks == 0);
next_part = _amiga_next_real_partition(disk, part);
next_num = _amiga_next_free_block(table, block_num+1,
IDNAME_PARTITION);
@@ -778,9 +777,9 @@ amiga_partition_new (const PedDisk* disk, PedPartitionType
part_type,
struct PartitionBlock *partition;
struct RigidDiskBlock *rdb;
- PED_ASSERT(disk != NULL, return NULL);
- PED_ASSERT(disk->dev != NULL, return NULL);
- PED_ASSERT(disk->disk_specific != NULL, return NULL);
+ PED_ASSERT(disk != NULL);
+ PED_ASSERT(disk->dev != NULL);
+ PED_ASSERT(disk->disk_specific != NULL);
dev = disk->dev;
cyl = (PedSector) (dev->hw_geom.sectors * dev->hw_geom.heads);
rdb = RDSK(disk->disk_specific);
@@ -839,9 +838,9 @@ amiga_partition_duplicate (const PedPartition* part)
struct PartitionBlock *new_amiga_part;
struct PartitionBlock *old_amiga_part;
- PED_ASSERT(part != NULL, return NULL);
- PED_ASSERT(part->disk != NULL, return NULL);
- PED_ASSERT(part->disk_specific != NULL, return NULL);
+ PED_ASSERT(part != NULL);
+ PED_ASSERT(part->disk != NULL);
+ PED_ASSERT(part->disk_specific != NULL);
old_amiga_part = (struct PartitionBlock *) part->disk_specific;
new_part = ped_partition_new (part->disk, part->type,
@@ -859,10 +858,10 @@ amiga_partition_duplicate (const PedPartition* part)
static void
amiga_partition_destroy (PedPartition* part)
{
- PED_ASSERT (part != NULL, return);
+ PED_ASSERT (part != NULL);
if (ped_partition_is_active (part)) {
- PED_ASSERT (part->disk_specific != NULL, return);
+ PED_ASSERT (part->disk_specific != NULL);
free (part->disk_specific);
}
_ped_partition_free (part);
@@ -874,8 +873,8 @@ amiga_partition_set_system (PedPartition* part,
{
struct PartitionBlock *partition;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
partition = PART(part->disk_specific);
part->fs_type = fs_type;
@@ -916,8 +915,8 @@ amiga_partition_set_flag (PedPartition* part,
PedPartitionFlag flag, int state)
{
struct PartitionBlock *partition;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
partition = PART(part->disk_specific);
@@ -948,8 +947,8 @@ amiga_partition_get_flag (const PedPartition* part,
PedPartitionFlag flag)
{
struct PartitionBlock *partition;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
partition = PART(part->disk_specific);
@@ -987,8 +986,8 @@ amiga_partition_set_name (PedPartition* part, const char*
name)
{
struct PartitionBlock *partition;
- PED_ASSERT (part != NULL, return);
- PED_ASSERT (part->disk_specific != NULL, return);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
partition = PART(part->disk_specific);
_amiga_set_bstr(name, partition->pb_DriveName, 32);
@@ -998,8 +997,8 @@ amiga_partition_get_name (const PedPartition* part)
{
struct PartitionBlock *partition;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
partition = PART(part->disk_specific);
@@ -1038,8 +1037,8 @@ _amiga_get_constraint (const PedDisk *disk)
static int
amiga_partition_align (PedPartition* part, const PedConstraint* constraint)
{
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk != NULL);
if (_ped_partition_attempt_align (part, constraint,
_amiga_get_constraint (part->disk)))
@@ -1058,8 +1057,8 @@ amiga_partition_enumerate (PedPartition* part)
int i;
PedPartition* p;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk != NULL);
/* never change the partition numbers */
if (part->num != -1)
@@ -1086,8 +1085,8 @@ amiga_alloc_metadata (PedDisk* disk)
PedPartition* new_part;
PedConstraint* constraint_any = NULL;
- PED_ASSERT (disk != NULL, goto error);
- PED_ASSERT (disk->dev != NULL, goto error);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
constraint_any = ped_constraint_any (disk->dev);
@@ -1147,11 +1146,11 @@ static PedDiskType amiga_disk_type = {
void
ped_disk_amiga_init ()
{
- PED_ASSERT (sizeof (struct AmigaBlock) != 3, return);
- PED_ASSERT (sizeof (struct RigidDiskBlock) != 64, return);
- PED_ASSERT (sizeof (struct PartitionBlock) != 64, return);
- PED_ASSERT (sizeof (struct LinkedBlock) != 5, return);
- PED_ASSERT (sizeof (struct Linked2Block) != 18, return);
+ PED_ASSERT (sizeof (struct AmigaBlock) != 3);
+ PED_ASSERT (sizeof (struct RigidDiskBlock) != 64);
+ PED_ASSERT (sizeof (struct PartitionBlock) != 64);
+ PED_ASSERT (sizeof (struct LinkedBlock) != 5);
+ PED_ASSERT (sizeof (struct Linked2Block) != 18);
ped_disk_type_register (&amiga_disk_type);
}
diff --git a/libparted/labels/sun.c b/libparted/labels/sun.c
index afe2d84..e674bb6 100644
--- a/libparted/labels/sun.c
+++ b/libparted/labels/sun.c
@@ -140,7 +140,7 @@ sun_verify_checksum (SunRawLabel const *label)
static int
sun_probe (const PedDevice *dev)
{
- PED_ASSERT (dev != NULL, return 0);
+ PED_ASSERT (dev != NULL);
void *s0;
if (!ptt_read_sector (dev, 0, &s0))
@@ -175,7 +175,7 @@ sun_alloc (const PedDevice* dev)
SunDiskData* sun_specific;
const PedCHSGeometry* bios_geom = &dev->bios_geom;
PedSector cyl_size = bios_geom->sectors * bios_geom->heads;
- PED_ASSERT (cyl_size != 0, return NULL);
+ PED_ASSERT (cyl_size != 0);
disk = _ped_disk_alloc (dev, &sun_disk_type);
if (!disk)
@@ -186,8 +186,7 @@ sun_alloc (const PedDevice* dev)
goto error_free_disk;
sun_specific = (SunDiskData*) disk->disk_specific;
- PED_ASSERT (bios_geom->cylinders == (PedSector) (dev->length /
cyl_size),
- return NULL);
+ PED_ASSERT (bios_geom->cylinders == (PedSector) (dev->length /
cyl_size));
sun_specific->length = ped_round_down_to (dev->length, cyl_size);
label = &sun_specific->raw_label;
@@ -316,9 +315,9 @@ sun_read (PedDisk* disk)
PedSector end, start, block;
PedConstraint* constraint_exact;
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (disk->dev != NULL, return 0);
- PED_ASSERT (disk->disk_specific != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
+ PED_ASSERT (disk->disk_specific != NULL);
disk_data = (SunDiskData*) disk->disk_specific;
@@ -405,8 +404,8 @@ sun_write (const PedDisk* disk)
PedPartition* part;
int i;
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (disk->dev != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->dev != NULL);
void *s0;
if (!ptt_read_sector (disk->dev, 0, &s0))
@@ -553,7 +552,7 @@ sun_partition_duplicate (const PedPartition* part)
static void
sun_partition_destroy (PedPartition* part)
{
- PED_ASSERT (part != NULL, return);
+ PED_ASSERT (part != NULL);
if (ped_partition_is_active (part))
free (part->disk_specific);
@@ -600,9 +599,9 @@ sun_partition_set_flag (PedPartition* part,
PedPartitionFlag flag, int state)
{
SunPartitionData* sun_data;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
- PED_ASSERT (ped_partition_is_flag_available (part, flag), return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
+ PED_ASSERT (ped_partition_is_flag_available (part, flag));
sun_data = part->disk_specific;
@@ -654,8 +653,8 @@ sun_partition_get_flag (const PedPartition* part,
PedPartitionFlag flag)
{
SunPartitionData* sun_data;
- PED_ASSERT (part != NULL, return 0);
- PED_ASSERT (part->disk_specific != NULL, return 0);
+ PED_ASSERT (part != NULL);
+ PED_ASSERT (part->disk_specific != NULL);
sun_data = part->disk_specific;
@@ -763,7 +762,7 @@ _get_lax_constraint (PedDisk* disk)
static int
sun_partition_align (PedPartition* part, const PedConstraint* constraint)
{
- PED_ASSERT (part != NULL, return 0);
+ PED_ASSERT (part != NULL);
if (_ped_partition_attempt_align (part, constraint,
_get_strict_constraint (part->disk)))
@@ -835,9 +834,9 @@ sun_alloc_metadata (PedDisk* disk)
SunDiskData* disk_data;
PedConstraint* constraint_any;
- PED_ASSERT (disk != NULL, return 0);
- PED_ASSERT (disk->disk_specific != NULL, return 0);
- PED_ASSERT (disk->dev != NULL, return 0);
+ PED_ASSERT (disk != NULL);
+ PED_ASSERT (disk->disk_specific != NULL);
+ PED_ASSERT (disk->dev != NULL);
constraint_any = ped_constraint_any (disk->dev);
@@ -897,7 +896,7 @@ static PedDiskType sun_disk_type = {
void
ped_disk_sun_init ()
{
- PED_ASSERT (sizeof (SunRawLabel) == 512, return);
+ PED_ASSERT (sizeof (SunRawLabel) == 512);
ped_disk_type_register (&sun_disk_type);
}
diff --git a/libparted/timer.c b/libparted/timer.c
index c00938f..d12b801 100644
--- a/libparted/timer.c
+++ b/libparted/timer.c
@@ -66,7 +66,7 @@ ped_timer_new (PedTimerHandler* handler, void* context)
{
PedTimer* timer;
- PED_ASSERT (handler != NULL, return NULL);
+ PED_ASSERT (handler != NULL);
timer = (PedTimer*) ped_malloc (sizeof (PedTimer));
if (!timer)
@@ -127,8 +127,8 @@ ped_timer_new_nested (PedTimer* parent, float nest_frac)
if (!parent)
return NULL;
- PED_ASSERT (nest_frac >= 0.0, return NULL);
- PED_ASSERT (nest_frac <= 1.0, return NULL);
+ PED_ASSERT (nest_frac >= 0.0);
+ PED_ASSERT (nest_frac <= 1.0);
context = (NestedContext*) ped_malloc (sizeof (NestedContext));
if (!context)
diff --git a/libparted/unit.c b/libparted/unit.c
index 2670c38..5885d83 100644
--- a/libparted/unit.c
+++ b/libparted/unit.c
@@ -141,7 +141,7 @@ ped_unit_get_size (const PedDevice* dev, PedUnit unit)
}
/* never reached */
- PED_ASSERT(0, return 0);
+ PED_ASSERT(0);
return 0;
}
@@ -198,7 +198,7 @@ ped_unit_format_custom_byte (const PedDevice* dev,
PedSector byte, PedUnit unit)
double d, w;
int p;
- PED_ASSERT (dev != NULL, return NULL);
+ PED_ASSERT (dev != NULL);
/* CHS has a special comma-separated format. */
if (unit == PED_UNIT_CHS) {
@@ -266,7 +266,7 @@ ped_unit_format_custom_byte (const PedDevice* dev,
PedSector byte, PedUnit unit)
char*
ped_unit_format_byte (const PedDevice* dev, PedSector byte)
{
- PED_ASSERT (dev != NULL, return NULL);
+ PED_ASSERT (dev != NULL);
return ped_unit_format_custom_byte (dev, byte, default_unit);
}
@@ -279,7 +279,7 @@ ped_unit_format_byte (const PedDevice* dev, PedSector byte)
char*
ped_unit_format_custom (const PedDevice* dev, PedSector sector, PedUnit unit)
{
- PED_ASSERT (dev != NULL, return NULL);
+ PED_ASSERT (dev != NULL);
return ped_unit_format_custom_byte(dev, sector*dev->sector_size, unit);
}
@@ -293,7 +293,7 @@ ped_unit_format_custom (const PedDevice* dev, PedSector
sector, PedUnit unit)
char*
ped_unit_format (const PedDevice* dev, PedSector sector)
{
- PED_ASSERT (dev != NULL, return NULL);
+ PED_ASSERT (dev != NULL);
return ped_unit_format_custom_byte (dev, sector * dev->sector_size,
default_unit);
}
diff --git a/parted/parted.c b/parted/parted.c
index a62884f..9b4c1f2 100644
--- a/parted/parted.c
+++ b/parted/parted.c
@@ -278,7 +278,7 @@ _disk_warn_loss (PedDisk* disk)
static int
snap (PedSector* sector, PedSector new_sector, PedGeometry* range)
{
- PED_ASSERT (ped_geometry_test_sector_inside (range, *sector), return
0);
+ PED_ASSERT (ped_geometry_test_sector_inside (range, *sector));
if (!ped_geometry_test_sector_inside (range, new_sector))
return 0;
*sector = new_sector;
@@ -314,7 +314,7 @@ prefer_snap (PedSector s, int what, PedGeometry* range,
EMoves* allow,
PedSector new_sect;
EMoves move;
- PED_ASSERT (what == SECT_START || what == SECT_END, return 0);
+ PED_ASSERT (what == SECT_START || what == SECT_END);
if (!(*allow & (MOVE_UP | MOVE_DOWN))) {
*dist = 0;
@@ -346,7 +346,7 @@ prefer_snap (PedSector s, int what, PedGeometry* range,
EMoves* allow,
&& what == SECT_END) )
move = MOVE_UP;
else
- PED_ASSERT (0, return 0);
+ PED_ASSERT (0);
} else if (*allow & MOVE_UP)
move = MOVE_UP;
else if (*allow & MOVE_DOWN)
@@ -407,7 +407,7 @@ snap_to_boundaries (PedGeometry* new_geom, PedGeometry*
old_geom,
end_want = prefer_snap (end, SECT_END, end_range, &end_allow,
end_part, &end_dist );
- PED_ASSERT (start_dist >= 0 && end_dist >= 0, return);
+ PED_ASSERT (start_dist >= 0 && end_dist >= 0);
/* If start and end are on adjacent partitions, */
/* and if they would prefer crossing, then refrain */
@@ -418,13 +418,13 @@ snap_to_boundaries (PedGeometry* new_geom, PedGeometry*
old_geom,
start_want = prefer_snap (start, SECT_START,
start_range, &start_allow,
start_part, &start_dist );
- PED_ASSERT (start_dist >= 0, return);
+ PED_ASSERT (start_dist >= 0);
} else {
end_allow &= ~MOVE_DOWN;
end_want = prefer_snap (end, SECT_END,
end_range, &end_allow,
end_part, &end_dist );
- PED_ASSERT (end_dist >= 0, return);
+ PED_ASSERT (end_dist >= 0);
}
}
@@ -435,10 +435,9 @@ snap_to_boundaries (PedGeometry* new_geom, PedGeometry*
old_geom,
end = ( end_want == MOVE_DOWN ? end_part->geom.start - 1 :
( end_want == MOVE_UP ? end_part->geom.end :
end ) );
- PED_ASSERT (ped_geometry_test_sector_inside(start_range,start),
return);
- PED_ASSERT (ped_geometry_test_sector_inside (end_range, end), return);
- PED_ASSERT (start <= end,
- PED_DEBUG (0, "start = %d, end = %d\n", start, end));
+ PED_ASSERT (ped_geometry_test_sector_inside(start_range,start));
+ PED_ASSERT (ped_geometry_test_sector_inside (end_range, end));
+ PED_ASSERT (start <= end);
ped_geometry_set (new_geom, start, end - start + 1);
}
@@ -806,7 +805,7 @@ do_mkpart (PedDevice** dev)
/* create constraints */
user_constraint = constraint_from_start_end (*dev, range_start,
range_end);
- PED_ASSERT (user_constraint != NULL, return 0);
+ PED_ASSERT (user_constraint != NULL);
if (alignment == ALIGNMENT_OPTIMAL)
dev_constraint =
@@ -816,7 +815,7 @@ do_mkpart (PedDevice** dev)
ped_device_get_minimal_aligned_constraint(*dev);
else
dev_constraint = ped_device_get_constraint(*dev);
- PED_ASSERT (dev_constraint != NULL, return 0);
+ PED_ASSERT (dev_constraint != NULL);
final_constraint = ped_constraint_intersect (user_constraint,
dev_constraint);
@@ -900,7 +899,7 @@ do_mkpart (PedDevice** dev)
/* set minor attributes */
if (part_name)
- PED_ASSERT (ped_partition_set_name (part, part_name), return
0);
+ PED_ASSERT (ped_partition_set_name (part, part_name));
free (part_name); /* avoid double-free upon failure */
part_name = NULL;
if (!ped_partition_set_system (part, fs_type))
@@ -1015,7 +1014,7 @@ do_mkpartfs (PedDevice** dev)
/* create constraints */
user_constraint = constraint_from_start_end (*dev, range_start,
range_end);
- PED_ASSERT (user_constraint != NULL, return 0);
+ PED_ASSERT (user_constraint != NULL);
if (alignment == ALIGNMENT_OPTIMAL)
dev_constraint =
@@ -1025,7 +1024,7 @@ do_mkpartfs (PedDevice** dev)
ped_device_get_minimal_aligned_constraint(*dev);
else
dev_constraint = ped_device_get_constraint(*dev);
- PED_ASSERT (dev_constraint != NULL, return 0);
+ PED_ASSERT (dev_constraint != NULL);
final_constraint = ped_constraint_intersect (user_constraint,
dev_constraint);
@@ -1113,7 +1112,7 @@ do_mkpartfs (PedDevice** dev)
ped_file_system_close (fs);
if (part_name)
- PED_ASSERT (ped_partition_set_name (part, part_name), return
0);
+ PED_ASSERT (ped_partition_set_name (part, part_name));
if (!ped_partition_set_system (part, fs_type))
goto error_destroy_disk;
@@ -2058,7 +2057,7 @@ static bool
partition_align_check (PedDisk const *disk, PedPartition const *part,
enum AlignmentType a_type)
{
- PED_ASSERT (part->disk == disk, return false);
+ PED_ASSERT (part->disk == disk);
PedDevice const *dev = disk->dev;
PedAlignment *pa = (a_type == PA_MINIMUM
@@ -2067,7 +2066,7 @@ partition_align_check (PedDisk const *disk, PedPartition
const *part,
if (pa == NULL)
return true;
- PED_ASSERT (pa->grain_size != 0, return false);
+ PED_ASSERT (pa->grain_size != 0);
bool ok = (part->geom.start % pa->grain_size == pa->offset);
free (pa);
return ok;
diff --git a/parted/strlist.c b/parted/strlist.c
index df5afff..798d5ae 100644
--- a/parted/strlist.c
+++ b/parted/strlist.c
@@ -441,7 +441,7 @@ str_list_print_wrap (const StrList* list, int line_length,
int offset,
int search_result;
int line_break;
- PED_ASSERT (line_length - indent > 10, return);
+ PED_ASSERT (line_length - indent > 10);
line_left = line_length - offset;
diff --git a/parted/ui.c b/parted/ui.c
index fa0ab29..5255538 100644
--- a/parted/ui.c
+++ b/parted/ui.c
@@ -353,7 +353,7 @@ sa_sigsegv_handler (int signum, siginfo_t* info, void*
ucontext)
case SEGV_MAPERR:
fputs(_("\nError: SEGV_MAPERR (Address not mapped "
"to object)\n"), stdout);
- PED_ASSERT(0, break); /* Force a backtrace */
+ PED_ASSERT(0); /* Force a backtrace */
break;
case SEGV_ACCERR:
@@ -364,7 +364,7 @@ sa_sigsegv_handler (int signum, siginfo_t* info, void*
ucontext)
default:
fputs(_("\nError: A general SIGSEGV signal was "
"encountered.\n"), stdout);
- PED_ASSERT(0, break); /* Force a backtrace */
+ PED_ASSERT(0); /* Force a backtrace */
break;
}
@@ -672,7 +672,7 @@ command_line_pop_word ()
char* result;
StrList* next;
- PED_ASSERT (command_line != NULL, return NULL);
+ PED_ASSERT (command_line != NULL);
result = str_list_convert_node (command_line);
next = command_line->next;
@@ -785,8 +785,7 @@ _construct_prompt (const char* head, const char* def,
char* prompt = strdup (head);
if (def && possibilities)
- PED_ASSERT (str_list_match_any (possibilities, def),
- return NULL);
+ PED_ASSERT (str_list_match_any (possibilities, def));
if (possibilities && str_list_length (possibilities) < 8) {
const StrList* walk;
@@ -1107,7 +1106,7 @@ command_line_get_disk_type (const char* prompt, const
PedDiskType*(* value))
*value = ped_disk_type_get (disk_type_name);
free (disk_type_name);
- PED_ASSERT (*value != NULL, return 0);
+ PED_ASSERT (*value != NULL);
return 1;
}
--
1.7.4