switch (fs_info->fat_type) {
case FAT_TYPE_FAT12:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
case FAT_TYPE_FAT16:
ped_debug ( level, __FILE__, __LINE__, __PRETTY_FUNCTION__, \
__VA_ARGS__ )
-#define PED_ASSERT(cond, action) \
+#define PED_ASSERT(cond) \
do { \
if (!(cond)) { \
ped_assert ( \
va_end (va_args);
}
-#define PED_ASSERT(cond, action) \
+#define PED_ASSERT(cond) \
do { \
if (!(cond)) { \
ped_assert ( \
#else /* !DEBUG */
-#define PED_ASSERT(cond, action) do {} while (0)
+#define PED_ASSERT(cond) do {} while (0)
#define PED_DEBUG(level, ...) do {} while (0)
struct stat stat_info;
PedDevice* dev;
- PED_ASSERT(path != NULL, return NULL);
+ PED_ASSERT(path != NULL);
dev = (PedDevice*) ped_malloc (sizeof (PedDevice));
if (!dev)
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)
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)
{
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)
error_t ro_err, rw_err;
int ispath;
- PED_ASSERT (path != NULL, return NULL);
+ PED_ASSERT (path != NULL);
dev = _init_device (path);
if (!dev)
PedDevice* dev;
GNUSpecific* arch_specific;
- PED_ASSERT (source != NULL, return NULL);
+ PED_ASSERT (source != NULL);
dev = _init_device (source->name ?: "(unknown)");
if (!dev)
/* 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
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;
}
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);
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)) {
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;
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
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);
dev->model = strdup(_("Generic IDE"));
break;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
} else {
case PED_EXCEPTION_IGNORE:
break;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
}
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)
case PED_EXCEPTION_IGNORE:
break;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
PedDevice* dev;
LinuxSpecific* arch_specific;
- PED_ASSERT (path != NULL, return NULL);
+ PED_ASSERT (path != NULL);
dev = (PedDevice*) ped_malloc (sizeof (PedDevice));
if (!dev)
{
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);
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);
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
case PED_EXCEPTION_CANCEL:
return 0;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
}
free(diobuf);
return 0;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
}
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);
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 (
case PED_EXCEPTION_CANCEL:
return 0;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
}
free(diobuf_start);
return 0;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
}
int status;
void* diobuf;
- PED_ASSERT(dev != NULL, return 0);
+ PED_ASSERT(dev != NULL);
if (!_device_seek (dev, start))
return 0;
case PED_EXCEPTION_CANCEL:
return 0;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
}
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;
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;
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"))
{
PedPartition* walk;
- PED_ASSERT (part != NULL, return 0);
+ PED_ASSERT (part != NULL);
if (_partition_is_mounted (part))
return 1;
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;
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. */
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);
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);
{
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);
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,
PedConstraint*
ped_constraint_duplicate (const PedConstraint* constraint)
{
- PED_ASSERT (constraint != NULL, return NULL);
+ PED_ASSERT (constraint != NULL);
return ped_constraint_new (
constraint->start_align,
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);
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)
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;
}
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))
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);
{
PedGeometry* geom;
- PED_ASSERT (dev != NULL, return NULL);
+ PED_ASSERT (dev != NULL);
geom = (PedGeometry*) ped_malloc (sizeof (PedGeometry));
if (!geom)
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);
}
void
ped_geometry_destroy (PedGeometry* geom)
{
- PED_ASSERT (geom != NULL, return);
+ PED_ASSERT (geom != NULL);
free (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 (
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;
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;
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
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;
}
{
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;
int
ped_geometry_sync (PedGeometry* geom)
{
- PED_ASSERT (geom != NULL, return 0);
+ PED_ASSERT (geom != NULL);
return ped_device_sync (geom->dev);
}
int
ped_geometry_sync_fast (PedGeometry* geom)
{
- PED_ASSERT (geom != NULL, return 0);
+ PED_ASSERT (geom != NULL);
return ped_device_sync_fast (geom->dev);
}
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;
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"));
{
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;
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.)
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;
_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)
{
PedSector result;
- PED_ASSERT (align != NULL, return -1);
+ PED_ASSERT (align != NULL);
if (!align->grain_size)
result = align->offset;
{
PedSector result;
- PED_ASSERT (align != NULL, return -1);
+ PED_ASSERT (align != NULL);
if (!align->grain_size)
result = align->offset;
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));
{
PedDevice* dev;
- PED_ASSERT (path != NULL, return);
+ PED_ASSERT (path != NULL);
ped_exception_fetch_all ();
dev = ped_device_get (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);
{
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);
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);
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)
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)
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);
}
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);
}
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);
}
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);
}
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);
}
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;
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
{
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))
{
PedDiskType* walk = NULL;
- PED_ASSERT (dev != NULL, return NULL);
+ PED_ASSERT (dev != NULL);
if (!ped_device_open (dev))
return NULL;
PedDiskType* type;
PedDisk* disk;
- PED_ASSERT (dev != NULL, return NULL);
+ PED_ASSERT (dev != NULL);
if (!ped_device_open (dev))
goto error;
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)
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);
{
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;
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);
}
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;
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 (
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);
}
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);
}
{
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)) {
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)) {
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)) {
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);
}
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);
}
{
int ret;
- PED_ASSERT (disk != NULL, return 0);
+ PED_ASSERT (disk != NULL);
PedDiskOps *ops = disk->type->ops;
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;
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;
{
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);
}
{
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);
}
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
PedPartition* walk = NULL;
PedPartition* next;
- PED_ASSERT (disk != NULL, return 0);
+ PED_ASSERT (disk != NULL);
next = ped_disk_next_partition (disk, walk);
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);
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
{
PedPartition* part;
- PED_ASSERT (disk != NULL, return 0);
+ PED_ASSERT (disk != NULL);
part = (PedPartition*) ped_malloc (sizeof (PedPartition));
if (!part)
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);
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);
}
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);
{
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 (
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);
}
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);
}
{
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);
}
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;
}
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);
}
{
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)
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;
{
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))
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;
}
{
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)) {
{
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)) {
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;
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;
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;
PedPartition* last;
PedPartition* ext_part;
- PED_ASSERT (disk->update_mode, return 0);
+ PED_ASSERT (disk->update_mode);
ext_part = ped_disk_extended_partition (disk);
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;
{
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)) {
{
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
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 (
{
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))
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;
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;
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;
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;
PedPartition* walk;
PedPartition* next;
- PED_ASSERT (disk != NULL, return 0);
+ PED_ASSERT (disk != NULL);
if (!_disk_push_update_mode (disk))
return 0;
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);
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 {
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))
/* 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;
}
PedConstraint* constraint;
int status;
- PED_ASSERT (disk != NULL, return 0);
+ PED_ASSERT (disk != NULL);
ext_part = ped_disk_extended_partition (disk);
if (!ext_part)
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),
{
PedPartition* part;
- PED_ASSERT (disk != NULL, return);
+ PED_ASSERT (disk != NULL);
for (part = disk->part_list; part;
part = ped_disk_next_partition (disk, part))
{
int x;
- PED_ASSERT (n > 0, return -1);
+ PED_ASSERT (n > 0);
for (x=0; 1 << x <= n; x++);
void
ped_exception_leave_all ()
{
- PED_ASSERT (ex_fetch_count > 0, return);
+ PED_ASSERT (ex_fetch_count > 0);
ex_fetch_count--;
}
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;
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
{
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)
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
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))
{
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. */
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;
{
PedFileSystemType* fs_type = NULL;
- PED_ASSERT (geom != NULL, return 0);
+ PED_ASSERT (geom != NULL);
if (!ped_device_open (geom->dev))
goto error;
PedFileSystem* fs;
PedGeometry* probed_geom;
- PED_ASSERT (geom != NULL, return NULL);
+ PED_ASSERT (geom != NULL);
if (!ped_device_open (geom->dev))
goto error;
{
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,
{
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;
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,
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)
{
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;
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,
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;
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;
{
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);
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))) {
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,
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))) {
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))) {
{
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);
{
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);
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);
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);
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);
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);
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)
{
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;
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 (
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);
{
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);
{
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;
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;
{
FatSpecific* fs_info = FAT_SPECIFIC (fs);
- PED_ASSERT (is != NULL, return 0);
+ PED_ASSERT (is != NULL);
fat_table_count_stats (fs_info->fat);
{
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;
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
min_free_space = total_space - new_total_space + dir_space;
PED_ASSERT (new_cluster_count
- <= fat_max_cluster_count (FAT_TYPE_FAT32),
- return 0);
+ <= fat_max_cluster_count (FAT_TYPE_FAT32));
if (free_space < min_free_space) {
char* needed = ped_unit_format (geom->dev, min_free_space);
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;
{
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);
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;
{
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;
}
{
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;
}
{
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;
}
{
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;
}
{
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;
{
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;
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) {
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++) {
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--) {
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,
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))
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)
{
int i;
- PED_ASSERT (first <= last, return 0);
+ PED_ASSERT (first <= last);
for (i = first; i <= last; i++) {
if (ctx->buffer_map [i] == -1)
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))
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++) {
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;
}
}
- PED_ASSERT (group_start != -1, return 0);
+ PED_ASSERT (group_start != -1);
if (!group_write (ctx, group_start, group_end))
return 0;
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))
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;
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);
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)
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;
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);
}
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);
}
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);
}
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);
}
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,
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),
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);
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);
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:
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);
}
return 0;
default:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
}
}
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))
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);
{
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;
{
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);
{
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
switch (ft->fat_type) {
case FAT_TYPE_FAT12:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
case FAT_TYPE_FAT16:
switch (ft->fat_type) {
case FAT_TYPE_FAT12:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
case FAT_TYPE_FAT16:
switch (ft->fat_type) {
case FAT_TYPE_FAT12:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
case FAT_TYPE_FAT16:
{
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;
switch (fs_info->fat_type) {
case FAT_TYPE_FAT12:
- PED_ASSERT (0, (void) 0);
+ PED_ASSERT (0);
break;
case FAT_TYPE_FAT16:
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;
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;
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;
}
/* 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))) {
}
/* 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 (
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;
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;
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 (
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;
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;
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;
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;
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;
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);
/* 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;
+ 1 - start - to_free;
int ret;
- PED_ASSERT (!hfs_block, return 0);
+ PED_ASSERT (!hfs_block);
cache = hfs_cache_extents (fs, timer);
if (!cache)
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;
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))
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;
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;
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;
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;
+ 1 - start - to_free;
int ret;
- PED_ASSERT (!hfsp_block, return 0);
+ PED_ASSERT (!hfsp_block);
cache = hfsplus_cache_extents (fs, timer);
if (!cache)
#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);
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);
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);
}
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);
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;
}
void geom_dal_free(dal_t *dal) {
- PED_ASSERT(dal != NULL, return);
+ PED_ASSERT(dal != NULL);
free(dal);
}
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)
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++) {
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;
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);
{
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);
reiserfs_gauge_t *gauge = NULL;
#endif
- PED_ASSERT(fs != NULL, return 0);
+ PED_ASSERT(fs != NULL);
fs_info = fs->type_specific;
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,
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;
{
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;
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);
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))
static void
aix_partition_destroy (PedPartition* part)
{
- PED_ASSERT (part != NULL, return);
+ PED_ASSERT (part != NULL);
_ped_partition_free (part);
}
static int
aix_partition_align (PedPartition* part, const PedConstraint* constraint)
{
- PED_ASSERT (part != NULL, return 0);
+ PED_ASSERT (part != NULL);
return 1;
}
{
BSDRawLabel *partition;
- PED_ASSERT (dev != NULL, return 0);
+ PED_ASSERT (dev != NULL);
if (dev->sector_size < 512)
return 0;
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)
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);
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);
// 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;
{
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) {
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);
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);
}
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);
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;
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
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;
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;
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);
{
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) {
{
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) {
{
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 */
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;
DosRawTable* part_table;
int i;
- PED_ASSERT (dev != NULL, return 0);
+ PED_ASSERT (dev != NULL);
if (dev->sector_size < sizeof *part_table)
return 0;
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) {
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);
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);
{
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;
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);
}
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);
}
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);
}
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));
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)
{
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)) {
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);
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;
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))
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))
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;
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:
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:
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:
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,
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))
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))
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);
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;
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;
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));
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);
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))
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;
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;
{
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) {
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;
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;
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);
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;
{
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);
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);
{
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;
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)
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);
}
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;
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)
int write_back = 0;
#endif
- PED_ASSERT (dvh_disk_data != NULL, return 0);
+ PED_ASSERT (dvh_disk_data != NULL);
ped_disk_delete_all (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);
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);
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);
struct volume_header vh;
int i;
- PED_ASSERT (dvh_disk_data != NULL, return 0);
+ PED_ASSERT (dvh_disk_data != NULL);
_flush_stale_flags (disk);
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);
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,
return 1;
}
}
- PED_ASSERT (0, return 0);
+ PED_ASSERT (0);
} else if (part->type & PED_PARTITION_EXTENDED) {
/* Volheader */
part->num = PNUM_VOLHDR + 1;
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.
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);
}
{
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),
{
if (pth == NULL)
return;
- PED_ASSERT (pth->Reserved2 != NULL, return);
+ PED_ASSERT (pth->Reserved2 != NULL);
free (pth->Reserved2);
free (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));
{
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);
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)
{
int i;
- PED_ASSERT (mbr != NULL, return 0);
+ PED_ASSERT (mbr != NULL);
if (mbr->Signature != PED_CPU_TO_LE16 (MSDOS_MBR_SIGNATURE))
return 0;
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;
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)
{
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;
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;
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;
{
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);
{
if (part->type == 0)
{
- PED_ASSERT (part->disk_specific != NULL, return);
+ PED_ASSERT (part->disk_specific != NULL);
free (part->disk_specific);
}
{
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;
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),
}
}
- PED_ASSERT (0, return 0);
+ PED_ASSERT (0);
return 0; /* used if debug is disabled */
}
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)
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)
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)))
static PedDisk*
loop_alloc (const PedDevice* dev)
{
- PED_ASSERT (dev != NULL, return 0);
+ PED_ASSERT (dev != NULL);
if (dev->length < 256)
return NULL;
static void
loop_free (PedDisk* disk)
{
- PED_ASSERT (disk != NULL, return);
+ PED_ASSERT (disk != NULL);
_ped_disk_free (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);
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;
PedDisk* disk;
MacDiskData* mac_disk_data;
- PED_ASSERT (dev != NULL, return NULL);
+ PED_ASSERT (dev != NULL);
#ifndef DISCOVER_ONLY
if (dev->length < 256) {
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"
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 */
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;
}
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 */
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;
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);
{
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);
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;
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);
{
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;
{
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) {
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
{
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;
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)))
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;
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;
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);
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;
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);
}
int empty;
const PC98RawPartition* p;
- PED_ASSERT (dev != NULL, return 0);
+ PED_ASSERT (dev != NULL);
if (dev->sector_size != 512)
return 0;
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);
}
static void
pc98_free (PedDisk* disk)
{
- PED_ASSERT (disk != NULL, return);
+ PED_ASSERT (disk != NULL);
_ped_disk_free (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;
}
{
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;
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);
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,
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);
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);
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);
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;
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));
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))
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);
{
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;
{
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) {
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);
{
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;
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)))
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) {
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);
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);
}
{ \
PedSector max; \
int err = ptt_partition_max_start_sector (#PT_type, &max); \
- PED_ASSERT (err == 0, return 0); \
+ PED_ASSERT (err == 0); \
return max; \
} \
\
{ \
PedSector max; \
int err = ptt_partition_max_length (#PT_type, &max); \
- PED_ASSERT (err == 0, return 0); \
+ PED_ASSERT (err == 0); \
return max; \
}
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)
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;
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;
{
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;
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)))
/* 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);
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;
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);
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) {
{
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) {
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;
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);
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);
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,
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);
{
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;
{
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);
{
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);
{
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);
{
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);
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)))
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)
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);
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);
}
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))
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)
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;
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;
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))
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);
{
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;
{
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;
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)))
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);
void
ped_disk_sun_init ()
{
- PED_ASSERT (sizeof (SunRawLabel) == 512, return);
+ PED_ASSERT (sizeof (SunRawLabel) == 512);
ped_disk_type_register (&sun_disk_type);
}
{
PedTimer* timer;
- PED_ASSERT (handler != NULL, return NULL);
+ PED_ASSERT (handler != NULL);
timer = (PedTimer*) ped_malloc (sizeof (PedTimer));
if (!timer)
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)
}
/* never reached */
- PED_ASSERT(0, return 0);
+ PED_ASSERT(0);
return 0;
}
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) {
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);
}
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);
}
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);
}
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;
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;
&& 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)
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 */
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);
}
}
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);
}
/* 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 =
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);
/* 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))
/* 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 =
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);
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;
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
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;
int search_result;
int line_break;
- PED_ASSERT (line_length - indent > 10, return);
+ PED_ASSERT (line_length - indent > 10);
line_left = line_length - offset;
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:
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;
}
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;
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;
*value = ped_disk_type_get (disk_type_name);
free (disk_type_name);
- PED_ASSERT (*value != NULL, return 0);
+ PED_ASSERT (*value != NULL);
return 1;
}