Mirrors
/
gparted
mirror of https://gitlab.gnome.org/GNOME/gparted.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

C++11: Convert NULL to nullptr (!117) 

In C++11, nullptr [1] is the strongly typed value to use instead of the
macro NULL [2].  Use everywhere [3][4].

[1] nullptr, the pointer literal (since C++11)
    https://en.cppreference.com/w/cpp/language/nullptr
[2] NULL
    https://en.cppreference.com/w/cpp/types/NULL
[3] Bjarne Stroustrup's C++ Style and Technique FAQ, Should I use NULL
    or 0?
    https://www.stroustrup.com/bs_faq2.html#null
        "In C++, the definition of NULL is 0, so there is only an
        aesthetic difference.  I prefer to avoid macros, so I use 0.
        Another problem with NULL is that people sometimes mistakenly
        believe that it is different from 0 and/or not an integer.  In
        pre-standard code, NULL was/is sometimes defined to something
        unsuitable and therefore had/has to be avoided.  That's less
        common these days.

        If you have to name the null pointer, call it nullptr; that's
        what it's called in C++11.  Then, "nullptr" will be a keyword.
        "
[4] What is nullptr in C++? Advantages, Use Cases & Examples
    https://favtutor.com/blogs/nullptr-cpp
        "Advantages of nullptr
        ...
        Compatible: Null pointers are compatible with null pointer
        constants in the C style (such as NULL and 0).  This implies
        that old C code that uses these constants and null pointers can
        communicate with each other in C++.
        "

Closes !117 - Require C++11 compilation
This commit is contained in:
Mike Fleetwood 2023-08-31 21:08:59 +01:00 committed by Curtis Gedak
parent 6bf7668f8e
commit 40665913bf
29 changed files with 296 additions and 294 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/Win_GParted.h
View File

@ -212,7 +212,7 @@ private:
// operations applied to partitions for displaying in the UI. // operations applied to partitions for displaying in the UI.
const Partition * selected_partition_ptr; // Pointer to the selected partition. (Alias to element const Partition * selected_partition_ptr; // Pointer to the selected partition. (Alias to element
// in Win_GParted::m_display_device.partitions[] vector). // in Win_GParted::m_display_device.partitions[] vector).
const Partition * copied_partition; // NULL or copy of source partition object. const Partition* copied_partition; // nullptr or copy of source partition object.
std::vector<Operation *> operations; std::vector<Operation *> operations;
//gui stuff //gui stuff

8
src/DMRaid.cc
View File

@ -163,8 +163,8 @@ bool DMRaid::is_dmraid_device( const Glib::ustring & dev_path )
if ( ! device_found && file_test( dev_path, Glib::FILE_TEST_IS_SYMLINK ) ) if ( ! device_found && file_test( dev_path, Glib::FILE_TEST_IS_SYMLINK ) )
{ {
//Path is a symbolic link so find real path //Path is a symbolic link so find real path
char * rpath = realpath( dev_path.c_str(), NULL ); char* rpath = realpath(dev_path.c_str(), nullptr);
if ( rpath != NULL ) if (rpath != nullptr)
{ {
Glib::ustring tmp_path = rpath; Glib::ustring tmp_path = rpath;
free( rpath ); free( rpath );
@ -233,8 +233,8 @@ Glib::ustring DMRaid::get_dmraid_name( const Glib::ustring & dev_path )
if ( dmraid_name .empty() && file_test( dev_path, Glib::FILE_TEST_IS_SYMLINK ) ) if ( dmraid_name .empty() && file_test( dev_path, Glib::FILE_TEST_IS_SYMLINK ) )
{ {
//Path is a symbolic link so find real path //Path is a symbolic link so find real path
char * rpath = realpath( dev_path.c_str(), NULL ); char* rpath = realpath(dev_path.c_str(), nullptr);
if ( rpath != NULL ) if (rpath != nullptr)
{ {
Glib::ustring tmp_path = rpath; Glib::ustring tmp_path = rpath;
free( rpath ); free( rpath );

6
src/Dialog_Base_Partition.cc
View File

@ -31,7 +31,7 @@ namespace GParted
Dialog_Base_Partition::Dialog_Base_Partition(const Device& device) Dialog_Base_Partition::Dialog_Base_Partition(const Device& device)
: m_device(device) : m_device(device)
{ {
frame_resizer_base = NULL; frame_resizer_base = nullptr;
GRIP = false ; GRIP = false ;
this ->fixed_start = false ; this ->fixed_start = false ;
this ->set_resizable( false ); this ->set_resizable( false );
@ -165,7 +165,7 @@ void Dialog_Base_Partition::Set_Resizer( bool extended )
const Partition & Dialog_Base_Partition::Get_New_Partition() const Partition & Dialog_Base_Partition::Get_New_Partition()
{ {
g_assert( new_partition != NULL ); // Bug: Not initialised by derived Dialog_Partition_*() constructor calling set_data() g_assert(new_partition != nullptr); // Bug: Not initialised by derived Dialog_Partition_*() constructor calling set_data()
prepare_new_partition(); prepare_new_partition();
return *new_partition; return *new_partition;
@ -173,7 +173,7 @@ const Partition & Dialog_Base_Partition::Get_New_Partition()
void Dialog_Base_Partition::prepare_new_partition() void Dialog_Base_Partition::prepare_new_partition()
{ {
g_assert( new_partition != NULL ); // Bug: Not initialised by derived Dialog_Partition_*() constructor calling set_data() g_assert(new_partition != nullptr); // Bug: Not initialised by derived Dialog_Partition_*() constructor calling set_data()
Sector old_size = new_partition->get_sector_length(); Sector old_size = new_partition->get_sector_length();

4
src/Dialog_Partition_Copy.cc
View File

@ -43,7 +43,7 @@ Dialog_Partition_Copy::Dialog_Partition_Copy(const Device& device, const FS& fs,
Dialog_Partition_Copy::~Dialog_Partition_Copy() Dialog_Partition_Copy::~Dialog_Partition_Copy()
{ {
delete new_partition; delete new_partition;
new_partition = NULL; new_partition = nullptr;
} }
void Dialog_Partition_Copy::set_data( const Partition & selected_partition, const Partition & copied_partition ) void Dialog_Partition_Copy::set_data( const Partition & selected_partition, const Partition & copied_partition )
@ -145,7 +145,7 @@ void Dialog_Partition_Copy::set_data( const Partition & selected_partition, cons
const Partition & Dialog_Partition_Copy::Get_New_Partition() const Partition & Dialog_Partition_Copy::Get_New_Partition()
{ {
g_assert( new_partition != NULL ); // Bug: Not initialised by constructor calling set_data() g_assert(new_partition != nullptr); // Bug: Not initialised by constructor calling set_data()
//first call baseclass to get the correct new partition //first call baseclass to get the correct new partition
Dialog_Base_Partition::prepare_new_partition(); Dialog_Base_Partition::prepare_new_partition();

9
src/Dialog_Partition_New.cc
View File

@ -51,7 +51,7 @@ Dialog_Partition_New::Dialog_Partition_New( const Device & device,
Dialog_Partition_New::~Dialog_Partition_New() Dialog_Partition_New::~Dialog_Partition_New()
{ {
delete new_partition; delete new_partition;
new_partition = NULL; new_partition = nullptr;
// Work around a Gtk issue fixed in 3.24.0. // Work around a Gtk issue fixed in 3.24.0.
// https://gitlab.gnome.org/GNOME/gtk/issues/125 // https://gitlab.gnome.org/GNOME/gtk/issues/125
@ -212,7 +212,7 @@ void Dialog_Partition_New::set_data( const Device & device,
const Partition & Dialog_Partition_New::Get_New_Partition() const Partition & Dialog_Partition_New::Get_New_Partition()
{ {
g_assert( new_partition != NULL ); // Bug: Not initialised by constructor calling set_data() g_assert(new_partition != nullptr); // Bug: Not initialised by constructor calling set_data()
PartitionType part_type ; PartitionType part_type ;
Sector new_start, new_end; Sector new_start, new_end;
@ -339,7 +339,7 @@ const Partition & Dialog_Partition_New::Get_New_Partition()
void Dialog_Partition_New::combobox_changed(bool combo_type_changed) void Dialog_Partition_New::combobox_changed(bool combo_type_changed)
{ {
g_assert( new_partition != NULL ); // Bug: Not initialised by constructor calling set_data() g_assert(new_partition != nullptr); // Bug: Not initialised by constructor calling set_data()
// combo_type // combo_type
if (combo_type_changed) if (combo_type_changed)
@ -414,7 +414,8 @@ void Dialog_Partition_New::combobox_changed(bool combo_type_changed)
void Dialog_Partition_New::build_filesystems_combo(bool only_unformatted) void Dialog_Partition_New::build_filesystems_combo(bool only_unformatted)
{ {
g_assert( new_partition != NULL ); // Bug: Not initialised by constructor calling set_data() g_assert(new_partition != nullptr); // Bug: Not initialised by constructor calling set_data()
combo_filesystem.items().clear(); combo_filesystem.items().clear();
// Fill the file system combobox // Fill the file system combobox

14
src/Dialog_Partition_Resize_Move.cc
View File

@ -40,7 +40,7 @@ Dialog_Partition_Resize_Move::Dialog_Partition_Resize_Move(const Device& device,
Dialog_Partition_Resize_Move::~Dialog_Partition_Resize_Move() Dialog_Partition_Resize_Move::~Dialog_Partition_Resize_Move()
{ {
delete new_partition; delete new_partition;
new_partition = NULL; new_partition = nullptr;
} }
void Dialog_Partition_Resize_Move::set_data( const Partition & selected_partition, void Dialog_Partition_Resize_Move::set_data( const Partition & selected_partition,
@ -78,7 +78,7 @@ void Dialog_Partition_Resize_Move::set_data( const Partition & selected_partitio
void Dialog_Partition_Resize_Move::Resize_Move_Normal( const PartitionVector & partitions ) void Dialog_Partition_Resize_Move::Resize_Move_Normal( const PartitionVector & partitions )
{ {
g_assert( new_partition != NULL ); // Bug: Not initialised by constructor calling set_data() g_assert(new_partition != nullptr); // Bug: Not initialised by constructor calling set_data()
// Don't permit shrinking an existing file system (other than linux-swap) when the // Don't permit shrinking an existing file system (other than linux-swap) when the
// usage is unknown as that sets the minimum resize. // usage is unknown as that sets the minimum resize.
@ -118,7 +118,7 @@ void Dialog_Partition_Resize_Move::Resize_Move_Normal( const PartitionVector & p
Sector previous, next ; Sector previous, next ;
previous = next = 0 ; previous = next = 0 ;
const Partition* prev_unalloc_partition = NULL; const Partition* prev_unalloc_partition = nullptr;
//also check the partitions file system ( if this is a 'resize-only' then previous should be 0 ) //also check the partitions file system ( if this is a 'resize-only' then previous should be 0 )
if (t >= 1 && partitions[t-1].type == TYPE_UNALLOCATED && ! this->fixed_start) if (t >= 1 && partitions[t-1].type == TYPE_UNALLOCATED && ! this->fixed_start)
{ {
@ -157,7 +157,7 @@ void Dialog_Partition_Resize_Move::Resize_Move_Normal( const PartitionVector & p
// Only need to use MIN_SPACE_BEFORE_MB to reserve 1 MiB to protect the partition // Only need to use MIN_SPACE_BEFORE_MB to reserve 1 MiB to protect the partition
// table or EBR if there is a previous unallocated partition allowing the start of // table or EBR if there is a previous unallocated partition allowing the start of
// this selected partition to be resize/moved to the left. // this selected partition to be resize/moved to the left.
if (prev_unalloc_partition == NULL) if (prev_unalloc_partition == nullptr)
MIN_SPACE_BEFORE_MB = 0 ; MIN_SPACE_BEFORE_MB = 0 ;
else else
MIN_SPACE_BEFORE_MB = Dialog_Base_Partition::MB_Needed_for_Boot_Record(*prev_unalloc_partition); MIN_SPACE_BEFORE_MB = Dialog_Base_Partition::MB_Needed_for_Boot_Record(*prev_unalloc_partition);
@ -231,7 +231,7 @@ void Dialog_Partition_Resize_Move::Resize_Move_Normal( const PartitionVector & p
void Dialog_Partition_Resize_Move::Resize_Move_Extended( const PartitionVector & partitions ) void Dialog_Partition_Resize_Move::Resize_Move_Extended( const PartitionVector & partitions )
{ {
g_assert( new_partition != NULL ); // Bug: Not initialised by constructor calling set_data() g_assert(new_partition != nullptr); // Bug: Not initialised by constructor calling set_data()
set_title(Glib::ustring::compose(_("Resize/Move %1"), new_partition->get_path())); set_title(Glib::ustring::compose(_("Resize/Move %1"), new_partition->get_path()));
@ -243,7 +243,7 @@ void Dialog_Partition_Resize_Move::Resize_Move_Extended( const PartitionVector &
Sector previous, next ; Sector previous, next ;
previous = next = 0 ; previous = next = 0 ;
const Partition* prev_unalloc_partition = NULL; const Partition* prev_unalloc_partition = nullptr;
//calculate length and start of previous //calculate length and start of previous
if (t > 0 && partitions[t-1].type == TYPE_UNALLOCATED) if (t > 0 && partitions[t-1].type == TYPE_UNALLOCATED)
{ {
@ -263,7 +263,7 @@ void Dialog_Partition_Resize_Move::Resize_Move_Extended( const PartitionVector &
// Only need to use MIN_SPACE_BEFORE_MB to reserve 1 MiB to protect the partition // Only need to use MIN_SPACE_BEFORE_MB to reserve 1 MiB to protect the partition
// table or EBR if there is a previous unallocated partition allowing the start of // table or EBR if there is a previous unallocated partition allowing the start of
// this selected partition to be resize/moved to the left. // this selected partition to be resize/moved to the left.
if (prev_unalloc_partition == NULL) if (prev_unalloc_partition == nullptr)
MIN_SPACE_BEFORE_MB = 0 ; MIN_SPACE_BEFORE_MB = 0 ;
else else
MIN_SPACE_BEFORE_MB = Dialog_Base_Partition::MB_Needed_for_Boot_Record(*prev_unalloc_partition); MIN_SPACE_BEFORE_MB = Dialog_Base_Partition::MB_Needed_for_Boot_Record(*prev_unalloc_partition);

8
src/Dialog_Rescue_Data.cc
View File

@ -164,7 +164,7 @@ void Dialog_Rescue_Data::on_view_clicked(int nPart)
char tmpDir[32]=tmp_prefix; char tmpDir[32]=tmp_prefix;
char * tmpDirResult = mkdtemp(tmpDir); char * tmpDirResult = mkdtemp(tmpDir);
if ( tmpDirResult == NULL ) if (tmpDirResult == nullptr)
{ {
Glib::ustring error_txt = _("An error occurred while creating a temporary directory for use as a mount point."); Glib::ustring error_txt = _("An error occurred while creating a temporary directory for use as a mount point.");
error_txt += "\n"; error_txt += "\n";
@ -212,8 +212,8 @@ void Dialog_Rescue_Data::on_view_clicked(int nPart)
/* Opens the default browser in a directory */ /* Opens the default browser in a directory */
void Dialog_Rescue_Data::open_ro_view(Glib::ustring mountPoint) void Dialog_Rescue_Data::open_ro_view(Glib::ustring mountPoint)
{ {
GError *error = NULL ; GError* error = nullptr;
GdkScreen *gscreen = NULL ; GdkScreen* gscreen = nullptr;
Glib::ustring uri = "file:" + mountPoint ; Glib::ustring uri = "file:" + mountPoint ;
@ -221,7 +221,7 @@ void Dialog_Rescue_Data::open_ro_view(Glib::ustring mountPoint)
gtk_show_uri( gscreen, uri .c_str(), gtk_get_current_event_time(), &error ) ; gtk_show_uri( gscreen, uri .c_str(), gtk_get_current_event_time(), &error ) ;
if ( error != NULL ) if (error != nullptr)
{ {
Glib::ustring sec_text(_("Error:")); Glib::ustring sec_text(_("Error:"));
sec_text.append("\n"); sec_text.append("\n");

12
src/DrawingAreaVisualDisk.cc
View File

@ -33,7 +33,7 @@ namespace GParted
DrawingAreaVisualDisk::DrawingAreaVisualDisk() DrawingAreaVisualDisk::DrawingAreaVisualDisk()
{ {
selected_vp = NULL ; selected_vp = nullptr;
// Set some standard colors // Set some standard colors
color_used .set( Utils::get_color( GParted::FS_USED ) ); color_used .set( Utils::get_color( GParted::FS_USED ) );
@ -57,17 +57,17 @@ void DrawingAreaVisualDisk::load_partitions( const PartitionVector & partitions,
void DrawingAreaVisualDisk::set_selected( const Partition * partition_ptr ) void DrawingAreaVisualDisk::set_selected( const Partition * partition_ptr )
{ {
selected_vp = NULL ; selected_vp = nullptr;
set_selected( visual_partitions, partition_ptr ); set_selected( visual_partitions, partition_ptr );
queue_draw() ; queue_draw() ;
} }
void DrawingAreaVisualDisk::clear() void DrawingAreaVisualDisk::clear()
{ {
visual_partitions .clear() ; visual_partitions .clear() ;
selected_vp = NULL ; selected_vp = nullptr;
queue_resize() ; queue_resize() ;
} }
@ -343,7 +343,7 @@ bool DrawingAreaVisualDisk::on_button_press_event( GdkEventButton * event )
{ {
bool ret_val = Gtk::DrawingArea::on_button_press_event( event ) ; bool ret_val = Gtk::DrawingArea::on_button_press_event( event ) ;
selected_vp = NULL ; selected_vp = nullptr;
set_selected( visual_partitions, static_cast<int>( event ->x ), static_cast<int>( event ->y ) ) ; set_selected( visual_partitions, static_cast<int>( event ->x ), static_cast<int>( event ->y ) ) ;
queue_draw() ; queue_draw() ;

12
src/FileSystem.cc
View File

@ -91,7 +91,7 @@ int FileSystem::execute_command( const Glib::ustring & command, OperationDetail
{ {
StreamSlot empty_stream_slot; StreamSlot empty_stream_slot;
TimedSlot empty_timed_slot; TimedSlot empty_timed_slot;
return execute_command_internal(command, NULL, operationdetail, flags, empty_stream_slot, empty_timed_slot); return execute_command_internal(command, nullptr, operationdetail, flags, empty_stream_slot, empty_timed_slot);
} }
@ -114,7 +114,7 @@ int FileSystem::execute_command( const Glib::ustring & command, OperationDetail
StreamSlot stream_progress_slot ) StreamSlot stream_progress_slot )
{ {
TimedSlot empty_timed_slot; TimedSlot empty_timed_slot;
return execute_command_internal(command, NULL, operationdetail, flags, stream_progress_slot, empty_timed_slot); return execute_command_internal(command, nullptr, operationdetail, flags, stream_progress_slot, empty_timed_slot);
} }
@ -125,7 +125,7 @@ int FileSystem::execute_command( const Glib::ustring & command, OperationDetail
TimedSlot timed_progress_slot ) TimedSlot timed_progress_slot )
{ {
StreamSlot empty_stream_slot; StreamSlot empty_stream_slot;
return execute_command_internal(command, NULL, operationdetail, flags, empty_stream_slot, timed_progress_slot); return execute_command_internal(command, nullptr, operationdetail, flags, empty_stream_slot, timed_progress_slot);
} }
@ -150,7 +150,7 @@ int FileSystem::execute_command_internal(const Glib::ustring& command, const cha
Glib::SPAWN_DO_NOT_REAP_CHILD | Glib::SPAWN_SEARCH_PATH, Glib::SPAWN_DO_NOT_REAP_CHILD | Glib::SPAWN_SEARCH_PATH,
sigc::ptr_fun(setup_child), sigc::ptr_fun(setup_child),
&pid, &pid,
(input != NULL) ? &in : 0, (input != nullptr) ? &in : 0,
&out, &out,
&err ); &err );
} catch (Glib::SpawnError &e) { } catch (Glib::SpawnError &e) {
@ -194,7 +194,7 @@ int FileSystem::execute_command_internal(const Glib::ustring& command, const cha
pid, pid,
flags & EXEC_CANCEL_SAFE ) ); flags & EXEC_CANCEL_SAFE ) );
if (input != NULL && in != -1) if (input != nullptr && in != -1)
{ {
// Write small amount of input to pipe to the child process. Linux will // Write small amount of input to pipe to the child process. Linux will
// always accept up to 4096 bytes without blocking. See pipe(7). // always accept up to 4096 bytes without blocking. See pipe(7).
@ -252,7 +252,7 @@ Glib::ustring FileSystem::mk_temp_dir( const Glib::ustring & infix, OperationDet
operationdetail .add_child( OperationDetail( operationdetail .add_child( OperationDetail(
Glib::ustring( "mkdir -v " ) + dir_buf, STATUS_EXECUTE, FONT_BOLD_ITALIC ) ) ; Glib::ustring( "mkdir -v " ) + dir_buf, STATUS_EXECUTE, FONT_BOLD_ITALIC ) ) ;
const char * dir_name = mkdtemp( dir_buf ) ; const char * dir_name = mkdtemp( dir_buf ) ;
if ( NULL == dir_name ) if (nullptr == dir_name)
{ {
int e = errno ; int e = errno ;
operationdetail .get_last_child() .add_child( OperationDetail( operationdetail .get_last_child() .add_child( OperationDetail(

236
src/GParted_Core.cc
View File

@ -201,7 +201,7 @@ void GParted_Core::set_devices_thread( std::vector<Device> * pdevices )
ped_device_probe_all(); ped_device_probe_all();
} }
PedDevice* lp_device = ped_device_get_next( NULL ) ; PedDevice* lp_device = ped_device_get_next(nullptr);
while ( lp_device ) while ( lp_device )
{ {
/* TO TRANSLATORS: looks like Confirming /dev/sda */ /* TO TRANSLATORS: looks like Confirming /dev/sda */
@ -243,7 +243,7 @@ void GParted_Core::set_devices_thread( std::vector<Device> * pdevices )
#endif #endif
PedDevice* lp_device = ped_device_get( device_paths[t].c_str() ); PedDevice* lp_device = ped_device_get( device_paths[t].c_str() );
if ( lp_device == NULL || ! useable_device( lp_device ) ) if (lp_device == nullptr || ! useable_device(lp_device))
{ {
// Remove this disk device which isn't useable // Remove this disk device which isn't useable
device_paths.erase( device_paths.begin() + t-- ); device_paths.erase( device_paths.begin() + t-- );
@ -272,7 +272,7 @@ void GParted_Core::set_devices_thread( std::vector<Device> * pdevices )
} }
set_thread_status_message("") ; set_thread_status_message("") ;
g_idle_add( (GSourceFunc)_mainquit, NULL ); g_idle_add((GSourceFunc)_mainquit, nullptr);
} }
// runs gpart on the specified parameter // runs gpart on the specified parameter
@ -516,11 +516,11 @@ bool GParted_Core::new_disklabel( const Glib::ustring & device_path, const Glib:
{ {
bool return_value = false ; bool return_value = false ;
PedDevice* lp_device = NULL ; PedDevice* lp_device = nullptr;
PedDisk* lp_disk = NULL ; PedDisk* lp_disk = nullptr;
if ( get_device( device_path, lp_device ) ) if ( get_device( device_path, lp_device ) )
{ {
PedDiskType *type = NULL ; PedDiskType* type = nullptr;
type = ped_disk_type_get( disklabel .c_str() ) ; type = ped_disk_type_get( disklabel .c_str() ) ;
if ( type ) if ( type )
@ -549,8 +549,8 @@ bool GParted_Core::new_disklabel( const Glib::ustring & device_path, const Glib:
bool GParted_Core::toggle_flag( const Partition & partition, const Glib::ustring & flag, bool state ) bool GParted_Core::toggle_flag( const Partition & partition, const Glib::ustring & flag, bool state )
{ {
bool succes = false ; bool succes = false ;
PedDevice* lp_device = NULL ; PedDevice* lp_device = nullptr;
PedDisk* lp_disk = NULL ; PedDisk* lp_disk = nullptr;
if ( get_device_and_disk( partition .device_path, lp_device, lp_disk ) ) if ( get_device_and_disk( partition .device_path, lp_device, lp_disk ) )
{ {
PedPartition* lp_partition = get_lp_partition( lp_disk, partition ); PedPartition* lp_partition = get_lp_partition( lp_disk, partition );
@ -590,7 +590,7 @@ std::vector<Glib::ustring> GParted_Core::get_disklabeltypes()
std::vector<Glib::ustring> disklabeltypes ; std::vector<Glib::ustring> disklabeltypes ;
PedDiskType *disk_type ; PedDiskType *disk_type ;
for ( disk_type = ped_disk_type_get_next( NULL ) ; disk_type ; disk_type = ped_disk_type_get_next( disk_type ) ) for (disk_type = ped_disk_type_get_next(nullptr); disk_type; disk_type = ped_disk_type_get_next(disk_type))
disklabeltypes .push_back( disk_type->name ) ; disklabeltypes .push_back( disk_type->name ) ;
return disklabeltypes ; return disklabeltypes ;
@ -600,8 +600,8 @@ std::map<Glib::ustring, bool> GParted_Core::get_available_flags( const Partition
{ {
std::map<Glib::ustring, bool> flag_info ; std::map<Glib::ustring, bool> flag_info ;
PedDevice* lp_device = NULL ; PedDevice* lp_device = nullptr;
PedDisk* lp_disk = NULL ; PedDisk* lp_disk = nullptr;
if ( get_device_and_disk( partition .device_path, lp_device, lp_disk ) ) if ( get_device_and_disk( partition .device_path, lp_device, lp_disk ) )
{ {
PedPartition* lp_partition = get_lp_partition( lp_disk, partition ); PedPartition* lp_partition = get_lp_partition( lp_disk, partition );
@ -624,13 +624,13 @@ std::map<Glib::ustring, bool> GParted_Core::get_available_flags( const Partition
Glib::ustring GParted_Core::get_partition_path(const PedPartition *lp_partition) Glib::ustring GParted_Core::get_partition_path(const PedPartition *lp_partition)
{ {
g_assert(lp_partition != NULL); // Bug: Not initialised by suitable ped_disk_*partition*() call g_assert(lp_partition != nullptr); // Bug: Not initialised by suitable ped_disk_*partition*() call
char * lp_path; //we have to free the result of ped_partition_get_path() char * lp_path; //we have to free the result of ped_partition_get_path()
Glib::ustring partition_path = "Partition path not found"; Glib::ustring partition_path = "Partition path not found";
lp_path = ped_partition_get_path(lp_partition); lp_path = ped_partition_get_path(lp_partition);
if ( lp_path != NULL ) if (lp_path != nullptr)
{ {
partition_path = lp_path; partition_path = lp_path;
free(lp_path); free(lp_path);
@ -653,8 +653,8 @@ Glib::ustring GParted_Core::get_partition_path(const PedPartition *lp_partition)
void GParted_Core::set_device_from_disk( Device & device, const Glib::ustring & device_path ) void GParted_Core::set_device_from_disk( Device & device, const Glib::ustring & device_path )
{ {
PedDevice* lp_device = NULL; PedDevice* lp_device = nullptr;
PedDisk* lp_disk = NULL; PedDisk* lp_disk = nullptr;
if (! get_device(device_path, lp_device, true)) if (! get_device(device_path, lp_device, true))
return; return;
@ -677,7 +677,7 @@ void GParted_Core::set_device_from_disk( Device & device, const Glib::ustring &
device.cylsize = MEBIBYTE / device.sector_size; device.cylsize = MEBIBYTE / device.sector_size;
std::vector<Glib::ustring> messages; std::vector<Glib::ustring> messages;
FSType fstype = detect_filesystem(lp_device, NULL, messages); FSType fstype = detect_filesystem(lp_device, nullptr, messages);
if (fstype != FS_UNKNOWN) if (fstype != FS_UNKNOWN)
{ {
@ -826,11 +826,11 @@ void GParted_Core::set_device_partitions( Device & device, PedDevice* lp_device,
//clear partitions //clear partitions
device .partitions .clear() ; device .partitions .clear() ;
PedPartition* lp_partition = ped_disk_next_partition( lp_disk, NULL ) ; PedPartition* lp_partition = ped_disk_next_partition(lp_disk, nullptr);
while ( lp_partition ) while ( lp_partition )
{ {
libparted_messages .clear() ; libparted_messages .clear() ;
Partition * partition_temp = NULL; Partition* partition_temp = nullptr;
bool partition_is_busy = false ; bool partition_is_busy = false ;
FSType fstype; FSType fstype;
std::vector<Glib::ustring> detect_messages; std::vector<Glib::ustring> detect_messages;
@ -930,7 +930,7 @@ void GParted_Core::set_device_partitions( Device & device, PedDevice* lp_device,
// Only for libparted reported partition types that we care about: NORMAL, // Only for libparted reported partition types that we care about: NORMAL,
// LOGICAL, EXTENDED // LOGICAL, EXTENDED
if ( partition_temp != NULL ) if (partition_temp != nullptr)
{ {
set_partition_label_and_uuid( *partition_temp ); set_partition_label_and_uuid( *partition_temp );
set_mountpoints( *partition_temp ); set_mountpoints( *partition_temp );
@ -986,7 +986,7 @@ void GParted_Core::set_device_one_partition( Device & device, PedDevice * lp_dev
Glib::ustring path = lp_device->path; Glib::ustring path = lp_device->path;
bool partition_is_busy = is_busy(device.get_path(), fstype, path); bool partition_is_busy = is_busy(device.get_path(), fstype, path);
Partition * partition_temp = NULL; Partition* partition_temp = nullptr;
if ( fstype == FS_LUKS ) if ( fstype == FS_LUKS )
partition_temp = new PartitionLUKS(); partition_temp = new PartitionLUKS();
else else
@ -1008,7 +1008,7 @@ void GParted_Core::set_device_one_partition( Device & device, PedDevice * lp_dev
set_partition_label_and_uuid( *partition_temp ); set_partition_label_and_uuid( *partition_temp );
set_mountpoints( *partition_temp ); set_mountpoints( *partition_temp );
set_used_sectors( *partition_temp, NULL ); set_used_sectors(*partition_temp, nullptr);
device.partitions.push_back_adopt( partition_temp ); device.partitions.push_back_adopt( partition_temp );
} }
@ -1039,7 +1039,7 @@ void GParted_Core::set_luks_partition( PartitionLUKS & partition )
set_partition_label_and_uuid( encrypted ); set_partition_label_and_uuid( encrypted );
set_mountpoints( encrypted ); set_mountpoints( encrypted );
set_used_sectors( encrypted, NULL ); set_used_sectors(encrypted, nullptr);
} }
void GParted_Core::set_partition_label_and_uuid( Partition & partition ) void GParted_Core::set_partition_label_and_uuid( Partition & partition )
@ -1095,18 +1095,18 @@ FSType GParted_Core::detect_filesystem_in_encryption_mapping(const Glib::ustring
FSType fstype = FS_UNKNOWN; FSType fstype = FS_UNKNOWN;
PedDevice *lp_device = NULL; PedDevice* lp_device = nullptr;
if (get_device(path, lp_device)) if (get_device(path, lp_device))
{ {
// Run libparted partition table and file system identification. Only use // Run libparted partition table and file system identification. Only use
// (get the first partition) if it's a "loop" table; because GParted only // (get the first partition) if it's a "loop" table; because GParted only
// supports one block device to one encryption mapping to one file system. // supports one block device to one encryption mapping to one file system.
PedDisk *lp_disk = NULL; PedDisk* lp_disk = nullptr;
PedPartition *lp_partition = NULL; PedPartition* lp_partition = nullptr;
if (get_disk(lp_device, lp_disk) && lp_disk && lp_disk->type && if (get_disk(lp_device, lp_disk) && lp_disk && lp_disk->type &&
lp_disk->type->name && strcmp(lp_disk->type->name, "loop") == 0 ) lp_disk->type->name && strcmp(lp_disk->type->name, "loop") == 0 )
{ {
lp_partition = ped_disk_next_partition(lp_disk, NULL); lp_partition = ped_disk_next_partition(lp_disk, nullptr);
} }
// Clear the "unrecognised disk label" message reported when libparted // Clear the "unrecognised disk label" message reported when libparted
// fails to detect anything. // fails to detect anything.
@ -1147,20 +1147,20 @@ FSType GParted_Core::detect_filesystem_internal(const Glib::ustring& path, Byte_
const char * sig2; const char * sig2;
FSType fstype; FSType fstype;
} signatures[] = { } signatures[] = {
//offset1, sig1 , offset2, sig2 , fstype //offset1, sig1 , offset2, sig2 , fstype
{ 0LL, "LUKS\xBA\xBE" , 0LL, NULL , FS_LUKS }, { 0LL, "LUKS\xBA\xBE" , 0LL, nullptr, FS_LUKS },
{ 3LL, "-FVE-FS-" , 0LL, NULL , FS_BITLOCKER }, { 3LL, "-FVE-FS-" , 0LL, nullptr, FS_BITLOCKER },
{ 0LL, "\x52\x56\xBE\x1B", 0LL, NULL , FS_GRUB2_CORE_IMG }, { 0LL, "\x52\x56\xBE\x1B", 0LL, nullptr, FS_GRUB2_CORE_IMG },
{ 0LL, "\x52\x56\xBE\x6F", 0LL, NULL , FS_GRUB2_CORE_IMG }, { 0LL, "\x52\x56\xBE\x6F", 0LL, nullptr, FS_GRUB2_CORE_IMG },
{ 0LL, "\x52\xE8\x28\x01", 0LL, NULL , FS_GRUB2_CORE_IMG }, { 0LL, "\x52\xE8\x28\x01", 0LL, nullptr, FS_GRUB2_CORE_IMG },
{ 0LL, "\x52\xBF\xF4\x81", 0LL, NULL , FS_GRUB2_CORE_IMG }, { 0LL, "\x52\xBF\xF4\x81", 0LL, nullptr, FS_GRUB2_CORE_IMG },
{ 0LL, "\x52\x56\xBE\x63", 0LL, NULL , FS_GRUB2_CORE_IMG }, { 0LL, "\x52\x56\xBE\x63", 0LL, nullptr, FS_GRUB2_CORE_IMG },
{ 0LL, "\x52\x56\xBE\x56", 0LL, NULL , FS_GRUB2_CORE_IMG }, { 0LL, "\x52\x56\xBE\x56", 0LL, nullptr, FS_GRUB2_CORE_IMG },
{ 24LL, "\x01\x00" , 32LL, "NXSB", FS_APFS }, { 24LL, "\x01\x00" , 32LL, "NXSB" , FS_APFS },
{ 512LL, "LABELONE" , 536LL, "LVM2", FS_LVM2_PV }, { 512LL, "LABELONE" , 536LL, "LVM2" , FS_LVM2_PV },
{ 1030LL, "\x34\x34" , 0LL, NULL , FS_NILFS2 }, { 1030LL, "\x34\x34" , 0LL, nullptr, FS_NILFS2 },
{ 65536LL, "ReIsEr4" , 0LL, NULL , FS_REISER4 }, { 65536LL, "ReIsEr4" , 0LL, nullptr, FS_REISER4 },
{ 65600LL, "_BHRfS_M" , 0LL, NULL , FS_BTRFS } { 65600LL, "_BHRfS_M" , 0LL, nullptr, FS_BTRFS }
}; };
// For simple BitLocker recognition consider validation of BIOS Parameter block // For simple BitLocker recognition consider validation of BIOS Parameter block
// fields unnecessary. // fields unnecessary.
@ -1189,14 +1189,14 @@ FSType GParted_Core::detect_filesystem_internal(const Glib::ustring& path, Byte_
for ( unsigned int i = 0 ; i < sizeof( signatures ) / sizeof( signatures[0] ) ; i ++ ) for ( unsigned int i = 0 ; i < sizeof( signatures ) / sizeof( signatures[0] ) ; i ++ )
{ {
const size_t len1 = std::min( ( signatures[i].sig1 == NULL ) ? 0U : strlen( signatures[i].sig1 ), const size_t len1 = std::min((signatures[i].sig1 == nullptr) ? 0U : strlen(signatures[i].sig1),
sizeof( magic1 ) ); sizeof(magic1));
const size_t len2 = std::min( ( signatures[i].sig2 == NULL ) ? 0U : strlen( signatures[i].sig2 ), const size_t len2 = std::min((signatures[i].sig2 == nullptr) ? 0U : strlen(signatures[i].sig2),
sizeof( magic2 ) ); sizeof(magic2));
// NOTE: From this point onwards signatures[].sig1 and .sig2 are treated // NOTE: From this point onwards signatures[].sig1 and .sig2 are treated
// as character buffers of known lengths len1 and len2, not NUL terminated // as character buffers of known lengths len1 and len2, not NUL terminated
// strings. // strings.
if ( len1 == 0UL || ( signatures[i].sig2 != NULL && len2 == 0UL ) ) if (len1 == 0UL || (signatures[i].sig2 != nullptr && len2 == 0UL))
continue; // Don't allow 0 length signatures to match continue; // Don't allow 0 length signatures to match
Byte_Value read_offset = signatures[i].offset1 / sector_size * sector_size; Byte_Value read_offset = signatures[i].offset1 / sector_size * sector_size;
@ -1220,11 +1220,11 @@ FSType GParted_Core::detect_filesystem_internal(const Glib::ustring& path, Byte_
memcpy(magic1, buf + signatures[i].offset1 % sector_size, len1); memcpy(magic1, buf + signatures[i].offset1 % sector_size, len1);
// WARNING: This assumes offset2 is in the same sector as offset1 // WARNING: This assumes offset2 is in the same sector as offset1
if (signatures[i].sig2 != NULL) if (signatures[i].sig2 != nullptr)
memcpy(magic2, buf + signatures[i].offset2 % sector_size, len2); memcpy(magic2, buf + signatures[i].offset2 % sector_size, len2);
if (memcmp(magic1, signatures[i].sig1, len1) == 0 && if (memcmp(magic1, signatures[i].sig1, len1) == 0 &&
(signatures[i].sig2 == NULL || memcmp(magic2, signatures[i].sig2, len2) == 0) ) (signatures[i].sig2 == nullptr || memcmp(magic2, signatures[i].sig2, len2) == 0) )
{ {
fstype = signatures[i].fstype; fstype = signatures[i].fstype;
break; break;
@ -1241,7 +1241,7 @@ FSType GParted_Core::detect_filesystem_internal(const Glib::ustring& path, Byte_
FSType GParted_Core::detect_filesystem(const PedDevice *lp_device, const PedPartition *lp_partition, FSType GParted_Core::detect_filesystem(const PedDevice *lp_device, const PedPartition *lp_partition,
std::vector<Glib::ustring> &messages) std::vector<Glib::ustring> &messages)
{ {
g_assert(lp_device != NULL); // Bug: Not initialised by call to ped_device_get() or ped_device_get_next() g_assert(lp_device != nullptr); // Bug: Not initialised by call to ped_device_get() or ped_device_get_next()
Glib::ustring fsname = ""; Glib::ustring fsname = "";
Glib::ustring path; Glib::ustring path;
@ -1382,7 +1382,7 @@ FSType GParted_Core::detect_filesystem(const PedDevice *lp_device, const PedPart
void GParted_Core::read_label( Partition & partition ) void GParted_Core::read_label( Partition & partition )
{ {
FileSystem* p_filesystem = NULL; FileSystem* p_filesystem = nullptr;
switch (get_fs(partition.fstype).read_label) switch (get_fs(partition.fstype).read_label)
{ {
case FS::EXTERNAL: case FS::EXTERNAL:
@ -1398,7 +1398,7 @@ void GParted_Core::read_label( Partition & partition )
void GParted_Core::read_uuid( Partition & partition ) void GParted_Core::read_uuid( Partition & partition )
{ {
FileSystem* p_filesystem = NULL; FileSystem* p_filesystem = nullptr;
switch (get_fs(partition.fstype).read_uuid) switch (get_fs(partition.fstype).read_uuid)
{ {
case FS::EXTERNAL: case FS::EXTERNAL:
@ -1574,7 +1574,7 @@ bool GParted_Core::set_mountpoints_helper( Partition & partition, const Glib::us
// Report whether the partition is busy (mounted/active) // Report whether the partition is busy (mounted/active)
bool GParted_Core::is_busy(const Glib::ustring& device_path, FSType fstype, const Glib::ustring& partition_path) bool GParted_Core::is_busy(const Glib::ustring& device_path, FSType fstype, const Glib::ustring& partition_path)
{ {
FileSystem * p_filesystem = NULL ; FileSystem* p_filesystem = nullptr;
bool busy = false ; bool busy = false ;
if ( supported_filesystem( fstype ) ) if ( supported_filesystem( fstype ) )
@ -1620,7 +1620,7 @@ void GParted_Core::set_used_sectors( Partition & partition, PedDisk* lp_disk )
{ {
if (supported_filesystem(partition.fstype)) if (supported_filesystem(partition.fstype))
{ {
FileSystem* p_filesystem = NULL; FileSystem* p_filesystem = nullptr;
if ( partition.busy ) if ( partition.busy )
{ {
switch(get_fs(partition.fstype).online_read) switch(get_fs(partition.fstype).online_read)
@ -1738,8 +1738,8 @@ void GParted_Core::mounted_fs_set_used_sectors( Partition & partition )
#ifdef HAVE_LIBPARTED_FS_RESIZE #ifdef HAVE_LIBPARTED_FS_RESIZE
void GParted_Core::LP_set_used_sectors( Partition & partition, PedDisk* lp_disk ) void GParted_Core::LP_set_used_sectors( Partition & partition, PedDisk* lp_disk )
{ {
PedFileSystem *fs = NULL; PedFileSystem* fs = nullptr;
PedConstraint *constraint = NULL; PedConstraint* constraint = nullptr;
if ( lp_disk ) if ( lp_disk )
{ {
@ -1815,14 +1815,14 @@ bool GParted_Core::create_partition( Partition & new_partition, OperationDetail
operationdetail .add_child( OperationDetail( _("create empty partition") ) ) ; operationdetail .add_child( OperationDetail( _("create empty partition") ) ) ;
new_partition .partition_number = 0 ; new_partition .partition_number = 0 ;
PedDevice* lp_device = NULL ; PedDevice* lp_device = nullptr;
PedDisk* lp_disk = NULL ; PedDisk* lp_disk = nullptr;
if ( get_device_and_disk( new_partition .device_path, lp_device, lp_disk ) ) if ( get_device_and_disk( new_partition .device_path, lp_device, lp_disk ) )
{ {
PedPartitionType type; PedPartitionType type;
PedConstraint *constraint = NULL ; PedConstraint* constraint = nullptr;
PedFileSystemType* fs_type = NULL ; PedFileSystemType* fs_type = nullptr;
//create new partition //create new partition
switch ( new_partition .type ) switch ( new_partition .type )
{ {
@ -1935,7 +1935,7 @@ bool GParted_Core::create_filesystem( const Partition & partition, OperationDeta
Utils::get_filesystem_string(partition.fstype)))); Utils::get_filesystem_string(partition.fstype))));
bool succes = false ; bool succes = false ;
FileSystem* p_filesystem = NULL ; FileSystem* p_filesystem = nullptr;
switch (get_fs(partition.fstype).create) switch (get_fs(partition.fstype).create)
{ {
case FS::NONE: case FS::NONE:
@ -1982,8 +1982,8 @@ bool GParted_Core::delete_partition( const Partition & partition, OperationDetai
operationdetail .add_child( OperationDetail( _("delete partition") ) ) ; operationdetail .add_child( OperationDetail( _("delete partition") ) ) ;
bool succes = false ; bool succes = false ;
PedDevice* lp_device = NULL ; PedDevice* lp_device = nullptr;
PedDisk* lp_disk = NULL ; PedDisk* lp_disk = nullptr;
if ( get_device_and_disk( partition .device_path, lp_device, lp_disk ) ) if ( get_device_and_disk( partition .device_path, lp_device, lp_disk ) )
{ {
PedPartition* lp_partition = get_lp_partition( lp_disk, partition ); PedPartition* lp_partition = get_lp_partition( lp_disk, partition );
@ -1998,8 +1998,8 @@ bool GParted_Core::delete_partition( const Partition & partition, OperationDetai
DMRaid dmraid ; DMRaid dmraid ;
if ( succes && dmraid .is_dmraid_device( partition .device_path ) ) if ( succes && dmraid .is_dmraid_device( partition .device_path ) )
{ {
PedDevice* lp_device = NULL ; PedDevice* lp_device = nullptr;
PedDisk* lp_disk = NULL ; PedDisk* lp_disk = nullptr;
//Open disk handle before and close after to prevent application crash. //Open disk handle before and close after to prevent application crash.
if ( get_device_and_disk( partition .device_path, lp_device, lp_disk ) ) if ( get_device_and_disk( partition .device_path, lp_device, lp_disk ) )
{ {
@ -2029,7 +2029,7 @@ bool GParted_Core::remove_filesystem( const Partition & partition, OperationDeta
} }
bool success = true ; bool success = true ;
FileSystem* p_filesystem = NULL ; FileSystem* p_filesystem = nullptr;
switch (get_fs(partition.fstype ).remove) switch (get_fs(partition.fstype ).remove)
{ {
@ -2071,7 +2071,7 @@ bool GParted_Core::label_filesystem( const Partition & partition, OperationDetai
} }
bool succes = false ; bool succes = false ;
FileSystem* p_filesystem = NULL ; FileSystem* p_filesystem = nullptr;
const FS& fs_cap = get_fs(partition.fstype); const FS& fs_cap = get_fs(partition.fstype);
FS::Support support = (partition.busy) ? fs_cap.online_write_label : fs_cap.write_label; FS::Support support = (partition.busy) ? fs_cap.online_write_label : fs_cap.write_label;
switch (support) switch (support)
@ -2100,8 +2100,8 @@ bool GParted_Core::name_partition( const Partition & partition, OperationDetail
partition.name, partition.get_path() ) ) ); partition.name, partition.get_path() ) ) );
bool success = false; bool success = false;
PedDevice *lp_device = NULL; PedDevice* lp_device = nullptr;
PedDisk *lp_disk = NULL; PedDisk* lp_disk = nullptr;
if ( get_device_and_disk( partition.device_path, lp_device, lp_disk ) ) if ( get_device_and_disk( partition.device_path, lp_device, lp_disk ) )
{ {
PedPartition *lp_partition = ped_disk_get_partition_by_sector( lp_disk, partition.get_sector() ); PedPartition *lp_partition = ped_disk_get_partition_by_sector( lp_disk, partition.get_sector() );
@ -2139,7 +2139,7 @@ bool GParted_Core::change_filesystem_uuid( const Partition & partition, Operatio
} }
bool succes = false ; bool succes = false ;
FileSystem* p_filesystem = NULL ; FileSystem* p_filesystem = nullptr;
switch (get_fs(partition.fstype).write_uuid) switch (get_fs(partition.fstype).write_uuid)
{ {
case FS::EXTERNAL: case FS::EXTERNAL:
@ -2175,7 +2175,7 @@ bool GParted_Core::resize_move( const Partition & partition_old,
{ {
return move( partition_old, partition_new, operationdetail ); return move( partition_old, partition_new, operationdetail );
} }
Partition * temp = NULL; Partition* temp = nullptr;
if ( partition_new .get_sector_length() > partition_old .get_sector_length() ) if ( partition_new .get_sector_length() > partition_old .get_sector_length() )
{ {
//first move, then grow. Since old.length < new.length and new.start is valid, temp is valid. //first move, then grow. Since old.length < new.length and new.start is valid, temp is valid.
@ -2197,7 +2197,7 @@ bool GParted_Core::resize_move( const Partition & partition_old,
success = resize_move( *temp, partition_new, operationdetail ); success = resize_move( *temp, partition_new, operationdetail );
delete temp; delete temp;
temp = NULL; temp = nullptr;
return success; return success;
} }
@ -2264,7 +2264,7 @@ bool GParted_Core::move( const Partition & partition_old,
} }
delete partition_restore; delete partition_restore;
partition_restore = NULL; partition_restore = nullptr;
} }
else else
{ {
@ -2280,7 +2280,7 @@ bool GParted_Core::move( const Partition & partition_old,
} }
delete partition_all_space; delete partition_all_space;
partition_all_space = NULL; partition_all_space = nullptr;
if ( ! success ) if ( ! success )
return false; return false;
@ -2313,7 +2313,7 @@ bool GParted_Core::move_filesystem( const Partition & partition_old,
} }
bool succes = false ; bool succes = false ;
FileSystem* p_filesystem = NULL ; FileSystem* p_filesystem = nullptr;
Sector total_done = 0; Sector total_done = 0;
switch (get_fs(partition_old.fstype).move) switch (get_fs(partition_old.fstype).move)
{ {
@ -2373,13 +2373,13 @@ bool GParted_Core::resize_move_filesystem_using_libparted( const Partition & par
operationdetail .add_child( OperationDetail( _("using libparted"), STATUS_NONE ) ) ; operationdetail .add_child( OperationDetail( _("using libparted"), STATUS_NONE ) ) ;
bool return_value = false ; bool return_value = false ;
PedDevice* lp_device = NULL ; PedDevice* lp_device = nullptr;
PedDisk* lp_disk = NULL ; PedDisk* lp_disk = nullptr;
if ( get_device_and_disk( partition_old .device_path, lp_device, lp_disk ) ) if ( get_device_and_disk( partition_old .device_path, lp_device, lp_disk ) )
{ {
PedFileSystem * fs = NULL ; PedFileSystem* fs = nullptr;
PedGeometry * lp_geom = NULL ; PedGeometry* lp_geom = nullptr;
lp_geom = ped_geometry_new( lp_device, lp_geom = ped_geometry_new( lp_device,
partition_old .sector_start, partition_old .sector_start,
partition_old .get_sector_length() ) ; partition_old .get_sector_length() ) ;
@ -2388,7 +2388,7 @@ bool GParted_Core::resize_move_filesystem_using_libparted( const Partition & par
fs = ped_file_system_open( lp_geom ); fs = ped_file_system_open( lp_geom );
ped_geometry_destroy( lp_geom ); ped_geometry_destroy( lp_geom );
lp_geom = NULL; lp_geom = nullptr;
if ( fs ) if ( fs )
{ {
@ -2426,8 +2426,8 @@ void GParted_Core::thread_lp_ped_file_system_resize( PedFileSystem * fs,
PedGeometry * lp_geom, PedGeometry * lp_geom,
bool * return_value ) bool * return_value )
{ {
*return_value = ped_file_system_resize( fs, lp_geom, NULL ); *return_value = ped_file_system_resize(fs, lp_geom, nullptr);
g_idle_add( (GSourceFunc)_mainquit, NULL ); g_idle_add((GSourceFunc)_mainquit, nullptr);
} }
#endif #endif
@ -2729,9 +2729,9 @@ bool GParted_Core::resize_move_partition( const Partition & partition_old,
rollback_success = rollback_success && update_dmraid_entry( *partition_restore, operationdetail ); rollback_success = rollback_success && update_dmraid_entry( *partition_restore, operationdetail );
delete partition_restore; delete partition_restore;
partition_restore = NULL; partition_restore = nullptr;
delete partition_intersection; delete partition_intersection;
partition_intersection = NULL; partition_intersection = nullptr;
operationdetail.get_last_child().set_success_and_capture_errors( rollback_success ); operationdetail.get_last_child().set_success_and_capture_errors( rollback_success );
} }
@ -2745,14 +2745,14 @@ bool GParted_Core::resize_move_partition_implement( const Partition & partition_
Sector & new_end ) Sector & new_end )
{ {
bool success = false; bool success = false;
PedDevice *lp_device = NULL; PedDevice* lp_device = nullptr;
PedDisk *lp_disk = NULL; PedDisk* lp_disk = nullptr;
if ( get_device_and_disk( partition_old.device_path, lp_device, lp_disk ) ) if ( get_device_and_disk( partition_old.device_path, lp_device, lp_disk ) )
{ {
PedPartition *lp_partition = get_lp_partition( lp_disk, partition_old ); PedPartition *lp_partition = get_lp_partition( lp_disk, partition_old );
if ( lp_partition ) if ( lp_partition )
{ {
PedConstraint *constraint = NULL; PedConstraint* constraint = nullptr;
if ( partition_new.alignment == ALIGN_STRICT || if ( partition_new.alignment == ALIGN_STRICT ||
partition_new.alignment == ALIGN_MEBIBYTE || partition_new.alignment == ALIGN_MEBIBYTE ||
partition_new.strict_start ) partition_new.strict_start )
@ -2969,7 +2969,7 @@ bool GParted_Core::resize_filesystem_implement( const Partition & partition_old,
action = ( partition_old.busy ) ? fs_cap.online_shrink : fs_cap.shrink; action = ( partition_old.busy ) ? fs_cap.online_shrink : fs_cap.shrink;
} }
bool success = false; bool success = false;
FileSystem* p_filesystem = NULL; FileSystem* p_filesystem = nullptr;
switch ( action ) switch ( action )
{ {
case FS::NONE: case FS::NONE:
@ -3078,7 +3078,7 @@ bool GParted_Core::copy_filesystem( const Partition & partition_src,
partition_dst.get_path() ) ) ); partition_dst.get_path() ) ) );
bool success = false; bool success = false;
FileSystem* p_filesystem = NULL; FileSystem* p_filesystem = nullptr;
switch (get_fs(partition_dst.fstype).copy) switch (get_fs(partition_dst.fstype).copy)
{ {
case FS::GPARTED: case FS::GPARTED:
@ -3306,8 +3306,8 @@ void GParted_Core::rollback_move_filesystem( const Partition & partition_src,
delete temp_src; delete temp_src;
delete temp_dst; delete temp_dst;
temp_src = NULL; temp_src = nullptr;
temp_dst = NULL; temp_dst = nullptr;
} }
} }
@ -3332,7 +3332,7 @@ bool GParted_Core::check_repair_filesystem( const Partition & partition, Operati
partition .get_path() ) ) ) ; partition .get_path() ) ) ) ;
bool succes = false ; bool succes = false ;
FileSystem* p_filesystem = NULL ; FileSystem* p_filesystem = nullptr;
switch (get_fs(partition.fstype).check) switch (get_fs(partition.fstype).check)
{ {
case FS::NONE: case FS::NONE:
@ -3380,7 +3380,7 @@ bool GParted_Core::check_repair_maximize( const Partition & partition,
temp_offline->busy = false; temp_offline->busy = false;
bool success = maximize_encryption( *temp_offline, operationdetail ); bool success = maximize_encryption( *temp_offline, operationdetail );
delete temp_offline; delete temp_offline;
temp_offline = NULL; temp_offline = nullptr;
if ( ! success ) if ( ! success )
return false; return false;
@ -3408,8 +3408,8 @@ bool GParted_Core::set_partition_type( const Partition & partition, OperationDet
bool return_value = false ; bool return_value = false ;
PedDevice* lp_device = NULL ; PedDevice* lp_device = nullptr;
PedDisk* lp_disk = NULL ; PedDisk* lp_disk = nullptr;
if ( get_device_and_disk( partition .device_path, lp_device, lp_disk ) ) if ( get_device_and_disk( partition .device_path, lp_device, lp_disk ) )
{ {
PedPartition* lp_partition = ped_disk_get_partition_by_sector( lp_disk, partition.get_sector() ); PedPartition* lp_partition = ped_disk_get_partition_by_sector( lp_disk, partition.get_sector() );
@ -3420,7 +3420,7 @@ bool GParted_Core::set_partition_type( const Partition & partition, OperationDet
// Lookup libparted file system type using GParted's name, as most // Lookup libparted file system type using GParted's name, as most
// match. Exclude cleared as the name won't be recognised by // match. Exclude cleared as the name won't be recognised by
// libparted and get_filesystem_string() has also translated it. // libparted and get_filesystem_string() has also translated it.
PedFileSystemType *lp_fs_type = NULL; PedFileSystemType* lp_fs_type = nullptr;
if (partition.fstype != FS_CLEARED) if (partition.fstype != FS_CLEARED)
lp_fs_type = ped_file_system_type_get(fs_type.c_str()); lp_fs_type = ped_file_system_type_get(fs_type.c_str());
@ -3503,8 +3503,8 @@ bool GParted_Core::calibrate_partition( Partition & partition, OperationDetail &
operationdetail.add_child( OperationDetail( Glib::ustring::compose( _("calibrate %1"), curr_path ) ) ); operationdetail.add_child( OperationDetail( Glib::ustring::compose( _("calibrate %1"), curr_path ) ) );
bool success = false; bool success = false;
PedDevice* lp_device = NULL ; PedDevice* lp_device = nullptr;
PedDisk* lp_disk = NULL ; PedDisk* lp_disk = nullptr;
if ( get_device( partition.device_path, lp_device ) ) if ( get_device( partition.device_path, lp_device ) )
{ {
if ( partition.type == TYPE_UNPARTITIONED ) if ( partition.type == TYPE_UNPARTITIONED )
@ -3612,14 +3612,14 @@ bool GParted_Core::calculate_exact_geom( const Partition & partition_old,
FONT_ITALIC ) ) ; FONT_ITALIC ) ) ;
bool succes = false ; bool succes = false ;
PedDevice* lp_device = NULL ; PedDevice* lp_device = nullptr;
PedDisk* lp_disk = NULL ; PedDisk* lp_disk = nullptr;
if ( get_device_and_disk( partition_old .device_path, lp_device, lp_disk ) ) if ( get_device_and_disk( partition_old .device_path, lp_device, lp_disk ) )
{ {
PedPartition* lp_partition = get_lp_partition( lp_disk, partition_old ); PedPartition* lp_partition = get_lp_partition( lp_disk, partition_old );
if ( lp_partition ) if ( lp_partition )
{ {
PedConstraint *constraint = NULL ; PedConstraint* constraint = nullptr;
constraint = ped_constraint_any( lp_device ) ; constraint = ped_constraint_any( lp_device ) ;
if ( constraint ) if ( constraint )
@ -3673,7 +3673,7 @@ bool GParted_Core::update_dmraid_entry( const Partition & partition, OperationDe
DMRaid dmraid; DMRaid dmraid;
if ( dmraid.is_dmraid_device( partition.device_path ) ) if ( dmraid.is_dmraid_device( partition.device_path ) )
{ {
PedDevice *lp_device = NULL; PedDevice* lp_device = nullptr;
PedDisk *lp_disk; PedDisk *lp_disk;
// Open disk handle before and close after to prevent application crash. // Open disk handle before and close after to prevent application crash.
if ( get_device_and_disk( partition.device_path, lp_device, lp_disk ) ) if ( get_device_and_disk( partition.device_path, lp_device, lp_disk ) )
@ -3696,7 +3696,7 @@ FileSystem * GParted_Core::get_filesystem_object( FSType fstype )
// Return true for file systems with an implementation class, false otherwise // Return true for file systems with an implementation class, false otherwise
bool GParted_Core::supported_filesystem( FSType fstype ) bool GParted_Core::supported_filesystem( FSType fstype )
{ {
return supported_filesystems->get_fs_object(fstype) != NULL; return supported_filesystems->get_fs_object(fstype) != nullptr;
} }
@ -3704,7 +3704,7 @@ FS_Limits GParted_Core::get_filesystem_limits( FSType fstype, const Partition &
{ {
FileSystem* p_filesystem = supported_filesystems->get_fs_object(fstype); FileSystem* p_filesystem = supported_filesystems->get_fs_object(fstype);
FS_Limits fs_limits; FS_Limits fs_limits;
if ( p_filesystem != NULL ) if (p_filesystem != nullptr)
fs_limits = p_filesystem->get_filesystem_limits( partition ); fs_limits = p_filesystem->get_filesystem_limits( partition );
return fs_limits; return fs_limits;
} }
@ -3739,13 +3739,13 @@ bool GParted_Core::erase_filesystem_signatures( const Partition & partition, Ope
//Get device, disk & partition and open the device. Allocate buffer and fill with //Get device, disk & partition and open the device. Allocate buffer and fill with
// zeros. Buffer size is the greater of 4 KiB and the sector size. // zeros. Buffer size is the greater of 4 KiB and the sector size.
PedDevice* lp_device = NULL ; PedDevice* lp_device = nullptr;
PedDisk* lp_disk = NULL ; PedDisk* lp_disk = nullptr;
PedPartition* lp_partition = NULL ; PedPartition* lp_partition = nullptr;
PedGeometry *lp_geom = NULL; PedGeometry* lp_geom = nullptr;
bool device_is_open = false ; bool device_is_open = false ;
Byte_Value bufsize = 4LL * KIBIBYTE ; Byte_Value bufsize = 4LL * KIBIBYTE ;
char * buf = NULL ; char* buf = nullptr;
if ( get_device( partition.device_path, lp_device ) ) if ( get_device( partition.device_path, lp_device ) )
{ {
if ( partition.type == TYPE_UNPARTITIONED ) if ( partition.type == TYPE_UNPARTITIONED )
@ -3763,7 +3763,7 @@ bool GParted_Core::erase_filesystem_signatures( const Partition & partition, Ope
lp_geom = ped_geometry_duplicate(&lp_partition->geom); lp_geom = ped_geometry_duplicate(&lp_partition->geom);
} }
if (lp_geom != NULL && ped_device_open(lp_device)) if (lp_geom != nullptr && ped_device_open(lp_device))
{ {
device_is_open = true ; device_is_open = true ;
@ -3901,7 +3901,7 @@ bool GParted_Core::erase_filesystem_signatures( const Partition & partition, Ope
} }
if ( buf ) if ( buf )
free( buf ) ; free( buf ) ;
if (lp_geom != NULL) if (lp_geom != nullptr)
ped_geometry_destroy(lp_geom); ped_geometry_destroy(lp_geom);
//Linux kernel doesn't maintain buffer cache coherency between the whole disk //Linux kernel doesn't maintain buffer cache coherency between the whole disk
@ -4047,7 +4047,7 @@ void GParted_Core::capture_libparted_messages( OperationDetail & operationdetail
bool GParted_Core::useable_device(const PedDevice* lp_device) bool GParted_Core::useable_device(const PedDevice* lp_device)
{ {
g_assert( lp_device != NULL ); // Bug: Not initialised by call to ped_device_get() or ped_device_get_next() g_assert(lp_device != nullptr); // Bug: Not initialised by call to ped_device_get() or ped_device_get_next()
char * buf = static_cast<char *>( malloc( lp_device->sector_size ) ); char * buf = static_cast<char *>( malloc( lp_device->sector_size ) );
if ( ! buf ) if ( ! buf )
@ -4119,7 +4119,7 @@ bool GParted_Core::get_device( const Glib::ustring & device_path, PedDevice *& l
bool GParted_Core::get_disk(PedDevice *lp_device, PedDisk*& lp_disk) bool GParted_Core::get_disk(PedDevice *lp_device, PedDisk*& lp_disk)
{ {
g_assert(lp_device != NULL); // Bug: Not initialised by call to ped_device_get() or ped_device_get_next() g_assert(lp_device != nullptr); // Bug: Not initialised by call to ped_device_get() or ped_device_get_next()
lp_disk = ped_disk_new(lp_device); lp_disk = ped_disk_new(lp_device);
@ -4129,7 +4129,7 @@ bool GParted_Core::get_disk(PedDevice *lp_device, PedDisk*& lp_disk)
// /dev/PTN entries don't exist. // /dev/PTN entries don't exist.
settle_device(SETTLE_DEVICE_PROBE_MAX_WAIT_SECONDS); settle_device(SETTLE_DEVICE_PROBE_MAX_WAIT_SECONDS);
return (lp_disk != NULL); return (lp_disk != nullptr);
} }
@ -4152,11 +4152,11 @@ void GParted_Core::destroy_device_and_disk( PedDevice*& lp_device, PedDisk*& lp_
{ {
if ( lp_disk ) if ( lp_disk )
ped_disk_destroy( lp_disk ) ; ped_disk_destroy( lp_disk ) ;
lp_disk = NULL ; lp_disk = nullptr;
if ( lp_device ) if ( lp_device )
ped_device_destroy( lp_device ) ; ped_device_destroy( lp_device ) ;
lp_device = NULL ; lp_device = nullptr;
} }
bool GParted_Core::commit( PedDisk* lp_disk ) bool GParted_Core::commit( PedDisk* lp_disk )
@ -4324,7 +4324,7 @@ PedExceptionOption GParted_Core::ped_exception_handler( PedException * e )
GParted_Core::~GParted_Core() GParted_Core::~GParted_Core()
{ {
delete supported_filesystems; delete supported_filesystems;
supported_filesystems = NULL; supported_filesystems = nullptr;
} }

6
src/Mount_Info.cc
View File

@ -153,11 +153,11 @@ bool Mount_Info::is_dev_mounted_at(const Glib::ustring& path, const Glib::ustrin
void Mount_Info::read_mountpoints_from_file( const Glib::ustring & filename, MountMapping & map ) void Mount_Info::read_mountpoints_from_file( const Glib::ustring & filename, MountMapping & map )
{ {
FILE* fp = setmntent( filename .c_str(), "r" ); FILE* fp = setmntent( filename .c_str(), "r" );
if ( fp == NULL ) if (fp == nullptr)
return; return;
struct mntent* p = NULL; struct mntent* p = nullptr;
while ( ( p = getmntent( fp ) ) != NULL ) while ((p = getmntent(fp)) != nullptr)
{ {
Glib::ustring node = lookup_uuid_or_label(p->mnt_fsname); Glib::ustring node = lookup_uuid_or_label(p->mnt_fsname);
if (node.empty()) if (node.empty())

18
src/Operation.cc
View File

@ -29,35 +29,35 @@ Operation::Operation()
Partition & Operation::get_partition_original() Partition & Operation::get_partition_original()
{ {
g_assert( partition_original != NULL ); // Bug: Not initialised by derived Operation*() constructor or reset later g_assert(partition_original != nullptr); // Bug: Not initialised by derived Operation*() constructor or reset later
return *partition_original; return *partition_original;
} }
const Partition & Operation::get_partition_original() const const Partition & Operation::get_partition_original() const
{ {
g_assert( partition_original != NULL ); // Bug: Not initialised by derived Operation*() constructor or reset later g_assert(partition_original != nullptr); // Bug: Not initialised by derived Operation*() constructor or reset later
return *partition_original; return *partition_original;
} }
Partition & Operation::get_partition_new() Partition & Operation::get_partition_new()
{ {
g_assert( partition_new != NULL ); // Bug: Not initialised by derived Operation*() constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by derived Operation*() constructor or reset later
return *partition_new; return *partition_new;
} }
const Partition & Operation::get_partition_new() const const Partition & Operation::get_partition_new() const
{ {
g_assert( partition_new != NULL ); // Bug: Not initialised by derived Operation*() constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by derived Operation*() constructor or reset later
return *partition_new; return *partition_new;
} }
int Operation::find_index_original( const PartitionVector & partitions ) int Operation::find_index_original( const PartitionVector & partitions )
{ {
g_assert( partition_original != NULL ); // Bug: Not initialised by derived Operation*() constructor or reset later g_assert(partition_original != nullptr); // Bug: Not initialised by derived Operation*() constructor or reset later
for ( unsigned int t = 0 ; t < partitions .size() ; t++ ) for ( unsigned int t = 0 ; t < partitions .size() ; t++ )
if ( partition_original->sector_start >= partitions[t].sector_start && if ( partition_original->sector_start >= partitions[t].sector_start &&
@ -71,7 +71,7 @@ int Operation::find_index_original( const PartitionVector & partitions )
// this->partition_new. Return vector index or -1 when no match found. // this->partition_new. Return vector index or -1 when no match found.
int Operation::find_index_new( const PartitionVector & partitions ) int Operation::find_index_new( const PartitionVector & partitions )
{ {
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
for ( unsigned int i = 0 ; i < partitions.size() ; i ++ ) for ( unsigned int i = 0 ; i < partitions.size() ; i ++ )
if ( partition_new->sector_start >= partitions[i].sector_start && if ( partition_new->sector_start >= partitions[i].sector_start &&
@ -93,8 +93,8 @@ void Operation::insert_unallocated( PartitionVector & partitions,
// it with this operation's new partition. // it with this operation's new partition.
void Operation::substitute_new( PartitionVector & partitions ) void Operation::substitute_new( PartitionVector & partitions )
{ {
g_assert( partition_original != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_original != nullptr); // Bug: Not initialised by constructor or reset later
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
int index_extended; int index_extended;
int index; int index;
@ -130,7 +130,7 @@ void Operation::insert_new( PartitionVector & partitions )
// their operations to the disk graphic. Hence their use of, // their operations to the disk graphic. Hence their use of,
// find_index_original(). // find_index_original().
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
int index_extended; int index_extended;
int index; int index;

8
src/OperationChangeUUID.cc
View File

@ -37,8 +37,8 @@ OperationChangeUUID::~OperationChangeUUID()
{ {
delete partition_original; delete partition_original;
delete partition_new; delete partition_new;
partition_original = NULL; partition_original = nullptr;
partition_new = NULL; partition_new = nullptr;
} }
void OperationChangeUUID::apply_to_visual( PartitionVector & partitions ) void OperationChangeUUID::apply_to_visual( PartitionVector & partitions )
@ -48,7 +48,7 @@ void OperationChangeUUID::apply_to_visual( PartitionVector & partitions )
void OperationChangeUUID::create_description() void OperationChangeUUID::create_description()
{ {
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
if ( partition_new->get_filesystem_partition().uuid == UUID_RANDOM_NTFS_HALF ) if ( partition_new->get_filesystem_partition().uuid == UUID_RANDOM_NTFS_HALF )
{ {
@ -68,7 +68,7 @@ void OperationChangeUUID::create_description()
bool OperationChangeUUID::merge_operations( const Operation & candidate ) bool OperationChangeUUID::merge_operations( const Operation & candidate )
{ {
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
if ( candidate.type == OPERATION_CHANGE_UUID && if ( candidate.type == OPERATION_CHANGE_UUID &&
*partition_new == candidate.get_partition_original() ) *partition_new == candidate.get_partition_original() )

8
src/OperationCheck.cc
View File

@ -34,8 +34,8 @@ OperationCheck::~OperationCheck()
{ {
delete partition_original; delete partition_original;
delete partition_new; delete partition_new;
partition_original = NULL; partition_original = nullptr;
partition_new = NULL; partition_new = nullptr;
} }
void OperationCheck::apply_to_visual( PartitionVector & partitions ) void OperationCheck::apply_to_visual( PartitionVector & partitions )
@ -44,7 +44,7 @@ void OperationCheck::apply_to_visual( PartitionVector & partitions )
void OperationCheck::create_description() void OperationCheck::create_description()
{ {
g_assert( partition_original != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_original != nullptr); // Bug: Not initialised by constructor or reset later
/*TO TRANSLATORS: looks like Check and repair file system (ext3) on /dev/hda4 */ /*TO TRANSLATORS: looks like Check and repair file system (ext3) on /dev/hda4 */
description = Glib::ustring::compose( _("Check and repair file system (%1) on %2"), description = Glib::ustring::compose( _("Check and repair file system (%1) on %2"),
@ -54,7 +54,7 @@ void OperationCheck::create_description()
bool OperationCheck::merge_operations( const Operation & candidate ) bool OperationCheck::merge_operations( const Operation & candidate )
{ {
g_assert( partition_original != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_original != nullptr); // Bug: Not initialised by constructor or reset later
if ( candidate.type == OPERATION_CHECK && if ( candidate.type == OPERATION_CHECK &&
*partition_original == candidate.get_partition_original() ) *partition_original == candidate.get_partition_original() )

18
src/OperationCopy.cc
View File

@ -40,28 +40,28 @@ OperationCopy::~OperationCopy()
delete partition_original; delete partition_original;
delete partition_new; delete partition_new;
delete partition_copied; delete partition_copied;
partition_original = NULL; partition_original = nullptr;
partition_new = NULL; partition_new = nullptr;
partition_copied = NULL; partition_copied = nullptr;
} }
Partition & OperationCopy::get_partition_copied() Partition & OperationCopy::get_partition_copied()
{ {
g_assert( partition_copied != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_copied != nullptr); // Bug: Not initialised by constructor or reset later
return *partition_copied; return *partition_copied;
} }
const Partition & OperationCopy::get_partition_copied() const const Partition & OperationCopy::get_partition_copied() const
{ {
g_assert( partition_copied != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_copied != nullptr); // Bug: Not initialised by constructor or reset later
return *partition_copied; return *partition_copied;
} }
void OperationCopy::apply_to_visual( PartitionVector & partitions ) void OperationCopy::apply_to_visual( PartitionVector & partitions )
{ {
g_assert( partition_original != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_original != nullptr); // Bug: Not initialised by constructor or reset later
if ( partition_original->type == TYPE_UNALLOCATED ) if ( partition_original->type == TYPE_UNALLOCATED )
// Paste into unallocated space creating new partition // Paste into unallocated space creating new partition
@ -73,9 +73,9 @@ void OperationCopy::apply_to_visual( PartitionVector & partitions )
void OperationCopy::create_description() void OperationCopy::create_description()
{ {
g_assert( partition_original != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_original != nullptr); // Bug: Not initialised by constructor or reset later
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
g_assert( partition_copied != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_copied != nullptr); // Bug: Not initialised by constructor or reset later
if ( partition_original->type == TYPE_UNALLOCATED ) if ( partition_original->type == TYPE_UNALLOCATED )
{ {

8
src/OperationCreate.cc
View File

@ -39,8 +39,8 @@ OperationCreate::~OperationCreate()
{ {
delete partition_original; delete partition_original;
delete partition_new; delete partition_new;
partition_original = NULL; partition_original = nullptr;
partition_new = NULL; partition_new = nullptr;
} }
void OperationCreate::apply_to_visual( PartitionVector & partitions ) void OperationCreate::apply_to_visual( PartitionVector & partitions )
@ -50,7 +50,7 @@ void OperationCreate::apply_to_visual( PartitionVector & partitions )
void OperationCreate::create_description() void OperationCreate::create_description()
{ {
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
switch( partition_new->type ) switch( partition_new->type )
{ {
@ -79,7 +79,7 @@ void OperationCreate::create_description()
bool OperationCreate::merge_operations( const Operation & candidate ) bool OperationCreate::merge_operations( const Operation & candidate )
{ {
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
if ( candidate.type == OPERATION_FORMAT && if ( candidate.type == OPERATION_FORMAT &&
candidate.get_partition_original().status == STAT_NEW && candidate.get_partition_original().status == STAT_NEW &&

6
src/OperationDelete.cc
View File

@ -33,7 +33,7 @@ OperationDelete::OperationDelete( const Device & device, const Partition & parti
OperationDelete::~OperationDelete() OperationDelete::~OperationDelete()
{ {
delete partition_original; delete partition_original;
partition_original = NULL; partition_original = nullptr;
} }
Partition & OperationDelete::get_partition_new() Partition & OperationDelete::get_partition_new()
@ -54,7 +54,7 @@ const Partition & OperationDelete::get_partition_new() const
void OperationDelete::apply_to_visual( PartitionVector & partitions ) void OperationDelete::apply_to_visual( PartitionVector & partitions )
{ {
g_assert( partition_original != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_original != nullptr); // Bug: Not initialised by constructor or reset later
int index_extended; int index_extended;
int index; int index;
@ -103,7 +103,7 @@ void OperationDelete::apply_to_visual( PartitionVector & partitions )
void OperationDelete::create_description() void OperationDelete::create_description()
{ {
g_assert( partition_original != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_original != nullptr); // Bug: Not initialised by constructor or reset later
if ( partition_original->type == TYPE_LOGICAL ) if ( partition_original->type == TYPE_LOGICAL )
description = _("Logical Partition") ; description = _("Logical Partition") ;

4
src/OperationDetail.cc
View File

@ -90,13 +90,13 @@ void OperationDetail::set_status( OperationDetailStatus status )
{ {
case STATUS_EXECUTE: case STATUS_EXECUTE:
time_elapsed = -1 ; time_elapsed = -1 ;
time_start = std::time( NULL ) ; time_start = std::time(nullptr);
break ; break ;
case STATUS_ERROR: case STATUS_ERROR:
case STATUS_WARNING: case STATUS_WARNING:
case STATUS_SUCCESS: case STATUS_SUCCESS:
if( time_start != -1 ) if( time_start != -1 )
time_elapsed = std::time( NULL ) - time_start ; time_elapsed = std::time(nullptr) - time_start;
break ; break ;
default: default:

14
src/OperationFormat.cc
View File

@ -36,14 +36,14 @@ OperationFormat::~OperationFormat()
{ {
delete partition_original; delete partition_original;
delete partition_new; delete partition_new;
partition_original = NULL; partition_original = nullptr;
partition_new = NULL; partition_new = nullptr;
} }
void OperationFormat::apply_to_visual( PartitionVector & partitions ) void OperationFormat::apply_to_visual( PartitionVector & partitions )
{ {
g_assert( partition_original != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_original != nullptr); // Bug: Not initialised by constructor or reset later
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
if (partition_original->type == TYPE_UNPARTITIONED && partition_new->fstype == FS_CLEARED) if (partition_original->type == TYPE_UNPARTITIONED && partition_new->fstype == FS_CLEARED)
{ {
@ -68,8 +68,8 @@ void OperationFormat::apply_to_visual( PartitionVector & partitions )
void OperationFormat::create_description() void OperationFormat::create_description()
{ {
g_assert( partition_original != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_original != nullptr); // Bug: Not initialised by constructor or reset later
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
/*TO TRANSLATORS: looks like Format /dev/hda4 as linux-swap */ /*TO TRANSLATORS: looks like Format /dev/hda4 as linux-swap */
description = Glib::ustring::compose( _("Format %1 as %2"), description = Glib::ustring::compose( _("Format %1 as %2"),
@ -79,7 +79,7 @@ void OperationFormat::create_description()
bool OperationFormat::merge_operations( const Operation & candidate ) bool OperationFormat::merge_operations( const Operation & candidate )
{ {
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
if ( candidate.type == OPERATION_FORMAT && if ( candidate.type == OPERATION_FORMAT &&
*partition_new == candidate.get_partition_original() ) *partition_new == candidate.get_partition_original() )

8
src/OperationLabelFileSystem.cc
View File

@ -36,8 +36,8 @@ OperationLabelFileSystem::~OperationLabelFileSystem()
{ {
delete partition_original; delete partition_original;
delete partition_new; delete partition_new;
partition_original = NULL; partition_original = nullptr;
partition_new = NULL; partition_new = nullptr;
} }
void OperationLabelFileSystem::apply_to_visual( PartitionVector & partitions ) void OperationLabelFileSystem::apply_to_visual( PartitionVector & partitions )
@ -47,7 +47,7 @@ void OperationLabelFileSystem::apply_to_visual( PartitionVector & partitions )
void OperationLabelFileSystem::create_description() void OperationLabelFileSystem::create_description()
{ {
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
if( partition_new->get_filesystem_partition().get_filesystem_label().empty() ) if( partition_new->get_filesystem_partition().get_filesystem_label().empty() )
{ {
@ -66,7 +66,7 @@ void OperationLabelFileSystem::create_description()
bool OperationLabelFileSystem::merge_operations( const Operation & candidate ) bool OperationLabelFileSystem::merge_operations( const Operation & candidate )
{ {
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
if ( candidate.type == OPERATION_LABEL_FILESYSTEM && if ( candidate.type == OPERATION_LABEL_FILESYSTEM &&
*partition_new == candidate.get_partition_original() ) *partition_new == candidate.get_partition_original() )

8
src/OperationNamePartition.cc
View File

@ -36,8 +36,8 @@ OperationNamePartition::~OperationNamePartition()
{ {
delete partition_original; delete partition_original;
delete partition_new; delete partition_new;
partition_original = NULL; partition_original = nullptr;
partition_new = NULL; partition_new = nullptr;
} }
void OperationNamePartition::apply_to_visual( PartitionVector & partitions ) void OperationNamePartition::apply_to_visual( PartitionVector & partitions )
@ -47,7 +47,7 @@ void OperationNamePartition::apply_to_visual( PartitionVector & partitions )
void OperationNamePartition::create_description() void OperationNamePartition::create_description()
{ {
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
if( partition_new->name.empty() ) if( partition_new->name.empty() )
{ {
@ -66,7 +66,7 @@ void OperationNamePartition::create_description()
bool OperationNamePartition::merge_operations( const Operation & candidate ) bool OperationNamePartition::merge_operations( const Operation & candidate )
{ {
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
if ( candidate.type == OPERATION_NAME_PARTITION && if ( candidate.type == OPERATION_NAME_PARTITION &&
*partition_new == candidate.get_partition_original() ) *partition_new == candidate.get_partition_original() )

18
src/OperationResizeMove.cc
View File

@ -37,13 +37,13 @@ OperationResizeMove::~OperationResizeMove()
{ {
delete partition_original; delete partition_original;
delete partition_new; delete partition_new;
partition_original = NULL; partition_original = nullptr;
partition_new = NULL; partition_new = nullptr;
} }
void OperationResizeMove::apply_to_visual( PartitionVector & partitions ) void OperationResizeMove::apply_to_visual( PartitionVector & partitions )
{ {
g_assert( partition_original != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_original != nullptr); // Bug: Not initialised by constructor or reset later
if ( partition_original->type == TYPE_EXTENDED ) if ( partition_original->type == TYPE_EXTENDED )
apply_extended_to_visual( partitions ) ; apply_extended_to_visual( partitions ) ;
@ -53,8 +53,8 @@ void OperationResizeMove::apply_to_visual( PartitionVector & partitions )
void OperationResizeMove::create_description() void OperationResizeMove::create_description()
{ {
g_assert( partition_original != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_original != nullptr); // Bug: Not initialised by constructor or reset later
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
//i'm not too happy with this, but i think it is the correct way from a i18n POV //i'm not too happy with this, but i think it is the correct way from a i18n POV
enum Action enum Action
@ -143,8 +143,8 @@ void OperationResizeMove::create_description()
void OperationResizeMove::apply_normal_to_visual( PartitionVector & partitions ) void OperationResizeMove::apply_normal_to_visual( PartitionVector & partitions )
{ {
g_assert( partition_original != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_original != nullptr); // Bug: Not initialised by constructor or reset later
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
int index_extended; int index_extended;
int index; int index;
@ -185,7 +185,7 @@ void OperationResizeMove::apply_normal_to_visual( PartitionVector & partitions )
void OperationResizeMove::apply_extended_to_visual( PartitionVector & partitions ) void OperationResizeMove::apply_extended_to_visual( PartitionVector & partitions )
{ {
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
int index_extended; int index_extended;
@ -239,7 +239,7 @@ void OperationResizeMove::remove_adjacent_unallocated( PartitionVector & partiti
bool OperationResizeMove::merge_operations( const Operation & candidate ) bool OperationResizeMove::merge_operations( const Operation & candidate )
{ {
g_assert( partition_new != NULL ); // Bug: Not initialised by constructor or reset later g_assert(partition_new != nullptr); // Bug: Not initialised by constructor or reset later
if ( candidate.type == OPERATION_RESIZE_MOVE && if ( candidate.type == OPERATION_RESIZE_MOVE &&
*partition_new == candidate.get_partition_original() ) *partition_new == candidate.get_partition_original() )

2
src/OptionComboBox.cc
View File

@ -27,7 +27,7 @@ namespace GParted
// NOTE: As stated in Gtkmm3 documentation, slots can be shared for all model instances. // NOTE: As stated in Gtkmm3 documentation, slots can be shared for all model instances.
// See: Class Reference for Gtk::TreeModelColumn and Gtk::TreeModelColumnRecord. // See: Class Reference for Gtk::TreeModelColumn and Gtk::TreeModelColumnRecord.
// https://developer.gnome.org/gtkmm/3.22/classGtk_1_1TreeModelColumnRecord.html#details // https://developer.gnome.org/gtkmm/3.22/classGtk_1_1TreeModelColumnRecord.html#details
OptionStore::Slots *OptionStore::m_slots = NULL; OptionStore::Slots* OptionStore::m_slots = nullptr;
OptionStore_Item::OptionStore_Item(const Glib::RefPtr<OptionStore>& ref_model, OptionStore_Item::OptionStore_Item(const Glib::RefPtr<OptionStore>& ref_model,

16
src/PasswordRAMStore.cc
View File

@ -85,11 +85,11 @@ const size_t ProtectedMemSize = 4096;
PWStore::PWStore() PWStore::PWStore()
{ {
// MAP_ANONYMOUS also ensures RAM is zero initialised. // MAP_ANONYMOUS also ensures RAM is zero initialised.
protected_mem = (char *) mmap( NULL, ProtectedMemSize, PROT_READ|PROT_WRITE, protected_mem = (char*) mmap(nullptr, ProtectedMemSize, PROT_READ|PROT_WRITE,
MAP_PRIVATE|MAP_ANONYMOUS|MAP_LOCKED, -1, 0 ); MAP_PRIVATE|MAP_ANONYMOUS|MAP_LOCKED, -1, 0);
if ( protected_mem == MAP_FAILED ) if ( protected_mem == MAP_FAILED )
{ {
protected_mem = NULL; protected_mem = nullptr;
std::cerr << "No locked virtual memory for password RAM store" << std::endl; std::cerr << "No locked virtual memory for password RAM store" << std::endl;
} }
} }
@ -97,13 +97,13 @@ PWStore::PWStore()
PWStore::~PWStore() PWStore::~PWStore()
{ {
erase_all(); erase_all();
if ( protected_mem != NULL ) if (protected_mem != nullptr)
munmap( protected_mem, ProtectedMemSize ); munmap( protected_mem, ProtectedMemSize );
} }
bool PWStore::insert( const Glib::ustring & key, const char * password ) bool PWStore::insert( const Glib::ustring & key, const char * password )
{ {
if ( protected_mem == NULL ) if (protected_mem == nullptr)
// No locked memory for passwords // No locked memory for passwords
return false; return false;
@ -157,7 +157,7 @@ const char * PWStore::lookup( const Glib::ustring & key )
} }
// No such key // No such key
return NULL; return nullptr;
} }
PWStore::iterator PWStore::find_key( const Glib::ustring & key ) PWStore::iterator PWStore::find_key( const Glib::ustring & key )
@ -174,7 +174,7 @@ PWStore::iterator PWStore::find_key( const Glib::ustring & key )
void PWStore::erase_all() void PWStore::erase_all()
{ {
pw_entries.clear(); pw_entries.clear();
if ( protected_mem != NULL ) if (protected_mem != nullptr)
// WARNING: // WARNING:
// memset() can be optimised away if the compiler knows the memory is not // memset() can be optimised away if the compiler knows the memory is not
// accessed again. In this case this memset() is in a separate method // accessed again. In this case this memset() is in a separate method
@ -206,7 +206,7 @@ static PWStore single_pwstore;
bool PasswordRAMStore::store( const Glib::ustring & key, const char * password ) bool PasswordRAMStore::store( const Glib::ustring & key, const char * password )
{ {
const char * looked_up_pw = single_pwstore.lookup( key ); const char * looked_up_pw = single_pwstore.lookup( key );
if ( looked_up_pw == NULL ) if (looked_up_pw == nullptr)
return single_pwstore.insert( key, password ); return single_pwstore.insert( key, password );
if ( strcmp( looked_up_pw, password ) == 0 ) if ( strcmp( looked_up_pw, password ) == 0 )

2
src/PipeCapture.cc
View File

@ -156,7 +156,7 @@ bool PipeCapture::OnReadable( Glib::IOCondition condition )
// delimited by an end pointer. // delimited by an end pointer.
new_ptr ++; new_ptr ++;
read_ptr = new_ptr; read_ptr = new_ptr;
if ( read_ptr == NULL ) if (read_ptr == nullptr)
read_ptr = end_ptr; read_ptr = end_ptr;
} }

32
src/SupportedFileSystems.cc
View File

@ -52,13 +52,13 @@ SupportedFileSystems::SupportedFileSystems()
// their derived FileSystem object, which determines and implements their // their derived FileSystem object, which determines and implements their
// supported actions. // supported actions.
// supported_filesystem() -> true // supported_filesystem() -> true
// 2) Basic supported file systems have a NULL pointer entry, with // 2) Basic supported file systems have a nullptr pointer entry, with
// find_supported_filesystems() creating a basic set of supported actions. // find_supported_filesystems() creating a basic set of supported actions.
// supported_filesystem() -> false // supported_filesystem() -> false
// 3) Unsupported file systems have no entry, and no supported actions. // 3) Unsupported file systems have no entry, and no supported actions.
// supported_filesystem() -> false // supported_filesystem() -> false
m_fs_objects[FS_UNKNOWN] = NULL; m_fs_objects[FS_UNKNOWN] = nullptr;
m_fs_objects[FS_OTHER] = NULL; m_fs_objects[FS_OTHER] = nullptr;
m_fs_objects[FS_BTRFS] = new btrfs(); m_fs_objects[FS_BTRFS] = new btrfs();
m_fs_objects[FS_EXFAT] = new exfat(); m_fs_objects[FS_EXFAT] = new exfat();
m_fs_objects[FS_EXT2] = new ext2(FS_EXT2); m_fs_objects[FS_EXT2] = new ext2(FS_EXT2);
@ -80,16 +80,16 @@ SupportedFileSystems::SupportedFileSystems()
m_fs_objects[FS_REISERFS] = new reiserfs(); m_fs_objects[FS_REISERFS] = new reiserfs();
m_fs_objects[FS_UDF] = new udf(); m_fs_objects[FS_UDF] = new udf();
m_fs_objects[FS_XFS] = new xfs(); m_fs_objects[FS_XFS] = new xfs();
m_fs_objects[FS_APFS] = NULL; m_fs_objects[FS_APFS] = nullptr;
m_fs_objects[FS_ATARAID] = NULL; m_fs_objects[FS_ATARAID] = nullptr;
m_fs_objects[FS_BITLOCKER] = NULL; m_fs_objects[FS_BITLOCKER] = nullptr;
m_fs_objects[FS_GRUB2_CORE_IMG] = NULL; m_fs_objects[FS_GRUB2_CORE_IMG] = nullptr;
m_fs_objects[FS_ISO9660] = NULL; m_fs_objects[FS_ISO9660] = nullptr;
m_fs_objects[FS_LINUX_SWRAID] = NULL; m_fs_objects[FS_LINUX_SWRAID] = nullptr;
m_fs_objects[FS_LINUX_SWSUSPEND] = NULL; m_fs_objects[FS_LINUX_SWSUSPEND] = nullptr;
m_fs_objects[FS_REFS] = NULL; m_fs_objects[FS_REFS] = nullptr;
m_fs_objects[FS_UFS] = NULL; m_fs_objects[FS_UFS] = nullptr;
m_fs_objects[FS_ZFS] = NULL; m_fs_objects[FS_ZFS] = nullptr;
} }
@ -99,7 +99,7 @@ SupportedFileSystems::~SupportedFileSystems()
for (iter = m_fs_objects.begin(); iter != m_fs_objects.end(); iter++) for (iter = m_fs_objects.begin(); iter != m_fs_objects.end(); iter++)
{ {
delete iter->second; delete iter->second;
iter->second = NULL; iter->second = nullptr;
} }
} }
@ -137,7 +137,7 @@ FileSystem* SupportedFileSystems::get_fs_object(FSType fstype) const
{ {
FSObjectsMap::const_iterator iter = m_fs_objects.find(fstype); FSObjectsMap::const_iterator iter = m_fs_objects.find(fstype);
if (iter == m_fs_objects.end()) if (iter == m_fs_objects.end())
return NULL; return nullptr;
else else
return iter->second; return iter->second;
} }
@ -167,7 +167,7 @@ const std::vector<FS>& SupportedFileSystems::get_all_fs_support() const
// Return true for file systems with an implementation class, false otherwise. // Return true for file systems with an implementation class, false otherwise.
bool SupportedFileSystems::supported_filesystem(FSType fstype) const bool SupportedFileSystems::supported_filesystem(FSType fstype) const
{ {
return get_fs_object(fstype) != NULL; return get_fs_object(fstype) != nullptr;
} }

10
src/Utils.cc
View File

@ -614,7 +614,7 @@ double Utils::sector_to_unit( Sector sectors, Byte_Value sector_size, SIZE_UNIT
int Utils::execute_command( const Glib::ustring & command ) int Utils::execute_command( const Glib::ustring & command )
{ {
Glib::ustring dummy ; Glib::ustring dummy ;
return execute_command( command, NULL, dummy, dummy ); return execute_command(command, nullptr, dummy, dummy);
} }
class CommandStatus class CommandStatus
@ -679,7 +679,7 @@ int Utils::execute_command( const Glib::ustring & command,
Glib::ustring & error, Glib::ustring & error,
bool use_C_locale ) bool use_C_locale )
{ {
return execute_command( command, NULL, output, error, use_C_locale ); return execute_command(command, nullptr, output, error, use_C_locale);
} }
int Utils::execute_command( const Glib::ustring & command, int Utils::execute_command( const Glib::ustring & command,
@ -704,7 +704,7 @@ int Utils::execute_command( const Glib::ustring & command,
Glib::SPAWN_DO_NOT_REAP_CHILD | Glib::SPAWN_SEARCH_PATH, Glib::SPAWN_DO_NOT_REAP_CHILD | Glib::SPAWN_SEARCH_PATH,
use_C_locale ? sigc::ptr_fun( set_locale ) : sigc::slot< void >(), use_C_locale ? sigc::ptr_fun( set_locale ) : sigc::slot< void >(),
&pid, &pid,
( input != NULL ) ? &in : 0, (input != nullptr) ? &in : 0,
&out, &out,
&err ); &err );
} catch (Glib::SpawnError &e) { } catch (Glib::SpawnError &e) {
@ -725,7 +725,7 @@ int Utils::execute_command( const Glib::ustring & command,
outputcapture.connect_signal(); outputcapture.connect_signal();
errorcapture.connect_signal(); errorcapture.connect_signal();
if ( input != NULL && in != -1 ) if (input != nullptr && in != -1)
{ {
// Write small amount of input to pipe to the child process. Linux will // Write small amount of input to pipe to the child process. Linux will
// always accept up 4096 bytes without blocking. See pipe(7). // always accept up 4096 bytes without blocking. See pipe(7).
@ -830,7 +830,7 @@ Glib::ustring Utils::get_lang()
{ {
//Extract base language from string that may look like "en_CA.UTF-8" //Extract base language from string that may look like "en_CA.UTF-8"
// and return in the form "en-CA" // and return in the form "en-CA"
Glib::ustring lang = setlocale( LC_CTYPE, NULL ) ; Glib::ustring lang = setlocale(LC_CTYPE, nullptr);
//Strip off anything after the period "." or at sign "@" //Strip off anything after the period "." or at sign "@"
lang = Utils::regexp_label( lang .c_str(), "^([^.@]*)") ; lang = Utils::regexp_label( lang .c_str(), "^([^.@]*)") ;

91
src/Win_GParted.cc
View File

@ -71,8 +71,8 @@ namespace GParted
Win_GParted::Win_GParted( const std::vector<Glib::ustring> & user_devices ) Win_GParted::Win_GParted( const std::vector<Glib::ustring> & user_devices )
{ {
copied_partition = NULL; copied_partition = nullptr;
selected_partition_ptr = NULL; selected_partition_ptr = nullptr;
new_count = 1; new_count = 1;
current_device = 0 ; current_device = 0 ;
OPERATIONSLIST_OPEN = true ; OPERATIONSLIST_OPEN = true ;
@ -156,7 +156,7 @@ Win_GParted::Win_GParted( const std::vector<Glib::ustring> & user_devices )
Win_GParted::~Win_GParted() Win_GParted::~Win_GParted()
{ {
delete copied_partition; delete copied_partition;
copied_partition = NULL; copied_partition = nullptr;
} }
void Win_GParted::init_menubar() void Win_GParted::init_menubar()
@ -1070,13 +1070,13 @@ void Win_GParted::Refresh_Visual()
// Refresh copy partition source as necessary and select the largest unallocated // Refresh copy partition source as necessary and select the largest unallocated
// partition if there is one. // partition if there is one.
selected_partition_ptr = NULL; selected_partition_ptr = nullptr;
Sector largest_unalloc_size = -1 ; Sector largest_unalloc_size = -1 ;
Sector current_size ; Sector current_size ;
for (unsigned int i = 0; i < m_display_device.partitions.size(); i++) for (unsigned int i = 0; i < m_display_device.partitions.size(); i++)
{ {
if (copied_partition != NULL && m_display_device.partitions[i].get_path() == copied_partition->get_path()) if (copied_partition != nullptr && m_display_device.partitions[i].get_path() == copied_partition->get_path())
{ {
delete copied_partition; delete copied_partition;
copied_partition = m_display_device.partitions[i].clone(); copied_partition = m_display_device.partitions[i].clone();
@ -1096,7 +1096,7 @@ void Win_GParted::Refresh_Visual()
{ {
for (unsigned int j = 0; j < m_display_device.partitions[i].logicals.size(); j++) for (unsigned int j = 0; j < m_display_device.partitions[i].logicals.size(); j++)
{ {
if (copied_partition != NULL && if (copied_partition != nullptr &&
m_display_device.partitions[i].logicals[j].get_path() == copied_partition->get_path()) m_display_device.partitions[i].logicals[j].get_path() == copied_partition->get_path())
{ {
delete copied_partition; delete copied_partition;
@ -1199,7 +1199,7 @@ void Win_GParted::set_valid_operations()
// Set default name for the open/close crypt menu item. // Set default name for the open/close crypt menu item.
const FileSystem * luks_filesystem_object = gparted_core.get_filesystem_object( FS_LUKS ); const FileSystem * luks_filesystem_object = gparted_core.get_filesystem_object( FS_LUKS );
g_assert( luks_filesystem_object != NULL ); // Bug: LUKS FileSystem object not found g_assert(luks_filesystem_object != nullptr); // Bug: LUKS FileSystem object not found
dynamic_cast<Gtk::Label *>(partitionmenu_items[MENU_TOGGLE_CRYPT_BUSY]->get_child()) dynamic_cast<Gtk::Label *>(partitionmenu_items[MENU_TOGGLE_CRYPT_BUSY]->get_child())
->set_label( luks_filesystem_object->get_custom_text( CTEXT_ACTIVATE_FILESYSTEM ) ); ->set_label( luks_filesystem_object->get_custom_text( CTEXT_ACTIVATE_FILESYSTEM ) );
// Set default name for the file system active/deactivate menu item. // Set default name for the file system active/deactivate menu item.
@ -1345,7 +1345,7 @@ void Win_GParted::set_valid_operations()
// Temporarily disable copying of encrypted content into new partitions // Temporarily disable copying of encrypted content into new partitions
// which can't yet be encrypted, until full LUKS read-write support is // which can't yet be encrypted, until full LUKS read-write support is
// implemented. // implemented.
if ( copied_partition != NULL && if ( copied_partition != nullptr &&
! devices[current_device].readonly && ! devices[current_device].readonly &&
copied_partition->fstype != FS_LUKS ) copied_partition->fstype != FS_LUKS )
{ {
@ -1490,7 +1490,7 @@ void Win_GParted::set_valid_operations()
} }
// See if there is a partition to be copied and it fits inside this selected partition // See if there is a partition to be copied and it fits inside this selected partition
if ( copied_partition != NULL && if ( copied_partition != nullptr &&
( copied_partition->get_filesystem_partition().get_byte_length() <= ( copied_partition->get_filesystem_partition().get_byte_length() <=
selected_filesystem.get_byte_length() ) && selected_filesystem.get_byte_length() ) &&
selected_partition_ptr->status == STAT_REAL && selected_partition_ptr->status == STAT_REAL &&
@ -1828,19 +1828,19 @@ void Win_GParted::show_help(const Glib::ustring & filename /* E.g., "gparted" */
return; return;
} }
GError *error = NULL; GError* error = nullptr;
// Display help window // Display help window
#if HAVE_GTK_SHOW_URI_ON_WINDOW #if HAVE_GTK_SHOW_URI_ON_WINDOW
// NULL is provided for the gtk_show_uri_on_window() parent window // nullptr is provided for the gtk_show_uri_on_window() parent window
// so that failures to launch yelp are reported. // so that failures to launch yelp are reported.
// https://gitlab.gnome.org/GNOME/gparted/-/merge_requests/82#note_1106114 // https://gitlab.gnome.org/GNOME/gparted/-/merge_requests/82#note_1106114
gtk_show_uri_on_window(NULL, uri.c_str(), gtk_get_current_event_time(), &error); gtk_show_uri_on_window(nullptr, uri.c_str(), gtk_get_current_event_time(), &error);
#else #else
GdkScreen *gscreen = gdk_screen_get_default(); GdkScreen *gscreen = gdk_screen_get_default();
gtk_show_uri(gscreen, uri.c_str(), gtk_get_current_event_time(), &error); gtk_show_uri(gscreen, uri.c_str(), gtk_get_current_event_time(), &error);
#endif #endif
if (error != NULL) if (error != nullptr)
{ {
Gtk::MessageDialog errorDialog(*this, Gtk::MessageDialog errorDialog(*this,
_("Failed to open GParted Manual help file"), _("Failed to open GParted Manual help file"),
@ -1998,7 +1998,7 @@ bool Win_GParted::max_amount_prim_reached()
void Win_GParted::activate_resize() void Win_GParted::activate_resize()
{ {
g_assert( selected_partition_ptr != NULL ); // Bug: Partition callback without a selected partition g_assert(selected_partition_ptr != nullptr); // Bug: Partition callback without a selected partition
g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object
const Partition & selected_filesystem_ptn = selected_partition_ptr->get_filesystem_partition(); const Partition & selected_filesystem_ptn = selected_partition_ptr->get_filesystem_partition();
@ -2067,7 +2067,7 @@ void Win_GParted::activate_resize()
dialog .set_transient_for( *this ) ; dialog .set_transient_for( *this ) ;
delete working_ptn; delete working_ptn;
working_ptn = NULL; working_ptn = nullptr;
if (dialog.run() == Gtk::RESPONSE_OK && if (dialog.run() == Gtk::RESPONSE_OK &&
ask_for_password_for_encrypted_resize_as_required(*selected_partition_ptr) ) ask_for_password_for_encrypted_resize_as_required(*selected_partition_ptr) )
@ -2102,7 +2102,7 @@ void Win_GParted::activate_resize()
operation->icon = Utils::mk_pixbuf(*this, Gtk::Stock::GOTO_LAST, Gtk::ICON_SIZE_MENU); operation->icon = Utils::mk_pixbuf(*this, Gtk::Stock::GOTO_LAST, Gtk::ICON_SIZE_MENU);
delete resized_ptn; delete resized_ptn;
resized_ptn = NULL; resized_ptn = nullptr;
// Display warning if moving a non-extended partition which already exists // Display warning if moving a non-extended partition which already exists
// on the disk. // on the disk.
@ -2153,7 +2153,7 @@ bool Win_GParted::ask_for_password_for_encrypted_resize_as_required(const Partit
return true; return true;
const char *pw = PasswordRAMStore::lookup(partition.uuid); const char *pw = PasswordRAMStore::lookup(partition.uuid);
if (pw != NULL) if (pw != nullptr)
// GParted already has a password for this encryption mapping which was // GParted already has a password for this encryption mapping which was
// previously used successfully or tested for correctness. // previously used successfully or tested for correctness.
// //
@ -2214,7 +2214,7 @@ bool Win_GParted::ask_for_password_for_encrypted_resize_as_required(const Partit
void Win_GParted::activate_copy() void Win_GParted::activate_copy()
{ {
g_assert( selected_partition_ptr != NULL ); // Bug: Partition callback without a selected partition g_assert(selected_partition_ptr != nullptr); // Bug: Partition callback without a selected partition
g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object
delete copied_partition; delete copied_partition;
@ -2223,8 +2223,8 @@ void Win_GParted::activate_copy()
void Win_GParted::activate_paste() void Win_GParted::activate_paste()
{ {
g_assert( copied_partition != NULL ); // Bug: Paste called without partition to copy g_assert(copied_partition != nullptr); // Bug: Paste called without partition to copy
g_assert( selected_partition_ptr != NULL ); // Bug: Partition callback without a selected partition g_assert(selected_partition_ptr != nullptr); // Bug: Partition callback without a selected partition
g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object
// Unrecognised whole disk device (See GParted_Core::set_device_from_disk(), "unrecognized") // Unrecognised whole disk device (See GParted_Core::set_device_from_disk(), "unrecognized")
@ -2258,7 +2258,7 @@ void Win_GParted::activate_paste()
*selected_partition_ptr, *selected_partition_ptr,
*part_temp); *part_temp);
delete part_temp; delete part_temp;
part_temp = NULL; part_temp = nullptr;
dialog .set_transient_for( *this ); dialog .set_transient_for( *this );
if ( dialog .run() == Gtk::RESPONSE_OK ) if ( dialog .run() == Gtk::RESPONSE_OK )
@ -2368,7 +2368,7 @@ void Win_GParted::activate_paste()
operation->icon = Utils::mk_pixbuf(*this, Gtk::Stock::COPY, Gtk::ICON_SIZE_MENU); operation->icon = Utils::mk_pixbuf(*this, Gtk::Stock::COPY, Gtk::ICON_SIZE_MENU);
delete partition_new; delete partition_new;
partition_new = NULL; partition_new = nullptr;
Add_Operation( devices[current_device], operation ); Add_Operation( devices[current_device], operation );
@ -2396,7 +2396,7 @@ void Win_GParted::activate_paste()
void Win_GParted::activate_new() void Win_GParted::activate_new()
{ {
g_assert( selected_partition_ptr != NULL ); // Bug: Partition callback without a selected partition g_assert(selected_partition_ptr != nullptr); // Bug: Partition callback without a selected partition
g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object
// Unrecognised whole disk device (See GParted_Core::set_device_from_disk(), "unrecognized") // Unrecognised whole disk device (See GParted_Core::set_device_from_disk(), "unrecognized")
@ -2437,7 +2437,7 @@ void Win_GParted::activate_new()
void Win_GParted::activate_delete() void Win_GParted::activate_delete()
{ {
g_assert( selected_partition_ptr != NULL ); // Bug: Partition callback without a selected partition g_assert(selected_partition_ptr != nullptr); // Bug: Partition callback without a selected partition
g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object
// VGNAME from mount mount // VGNAME from mount mount
@ -2474,7 +2474,7 @@ void Win_GParted::activate_delete()
} }
//if partition is on the clipboard...(NOTE: we can't use Partition::== here..) //if partition is on the clipboard...(NOTE: we can't use Partition::== here..)
if ( copied_partition != NULL && selected_partition_ptr->get_path() == copied_partition->get_path() ) if (copied_partition != nullptr && selected_partition_ptr->get_path() == copied_partition->get_path())
{ {
Gtk::MessageDialog dialog( *this, Gtk::MessageDialog dialog( *this,
Glib::ustring::compose( _("Are you sure you want to delete %1?"), Glib::ustring::compose( _("Are you sure you want to delete %1?"),
@ -2501,7 +2501,7 @@ void Win_GParted::activate_delete()
// Deleting partition on the clipboard. Clear clipboard. // Deleting partition on the clipboard. Clear clipboard.
delete copied_partition; delete copied_partition;
copied_partition = NULL; copied_partition = nullptr;
} }
// If deleted one is NEW, it doesn't make sense to add it to the operationslist, // If deleted one is NEW, it doesn't make sense to add it to the operationslist,
@ -2550,7 +2550,7 @@ void Win_GParted::activate_delete()
void Win_GParted::activate_info() void Win_GParted::activate_info()
{ {
g_assert( selected_partition_ptr != NULL ); // Bug: Partition callback without a selected partition g_assert(selected_partition_ptr != nullptr); // Bug: Partition callback without a selected partition
g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object
Dialog_Partition_Info dialog( *selected_partition_ptr ); Dialog_Partition_Info dialog( *selected_partition_ptr );
@ -2560,7 +2560,7 @@ void Win_GParted::activate_info()
void Win_GParted::activate_format( FSType new_fs ) void Win_GParted::activate_format( FSType new_fs )
{ {
g_assert( selected_partition_ptr != NULL ); // Bug: Partition callback without a selected partition g_assert(selected_partition_ptr != nullptr); // Bug: Partition callback without a selected partition
g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object
const Partition & filesystem_ptn = selected_partition_ptr->get_filesystem_partition(); const Partition & filesystem_ptn = selected_partition_ptr->get_filesystem_partition();
@ -2700,18 +2700,19 @@ void Win_GParted::activate_format( FSType new_fs )
} }
delete temp_ptn; delete temp_ptn;
temp_ptn = NULL; temp_ptn = nullptr;
} }
bool Win_GParted::open_encrypted_partition( const Partition & partition, bool Win_GParted::open_encrypted_partition( const Partition & partition,
const char * entered_password, const char * entered_password,
Glib::ustring & message ) Glib::ustring & message )
{ {
const char * pw = NULL; const char* pw = nullptr;
if ( entered_password == NULL ) if (entered_password == nullptr)
{ {
pw = PasswordRAMStore::lookup( partition.uuid ); pw = PasswordRAMStore::lookup( partition.uuid );
if ( pw == NULL ) if (pw == nullptr)
{ {
// Internal documentation message never shown to user. // Internal documentation message never shown to user.
message = "No stored password available"; message = "No stored password available";
@ -2739,7 +2740,7 @@ bool Win_GParted::open_encrypted_partition( const Partition & partition,
Glib::ustring error; Glib::ustring error;
bool success = ! Utils::execute_command( cmd, pw, output, error ); bool success = ! Utils::execute_command( cmd, pw, output, error );
hide_pulsebar(); hide_pulsebar();
if ( success && pw != NULL ) if (success && pw != nullptr)
// Save the password just entered and successfully used to open the LUKS // Save the password just entered and successfully used to open the LUKS
// mapping. // mapping.
PasswordRAMStore::store( partition.uuid, pw ); PasswordRAMStore::store( partition.uuid, pw );
@ -2754,7 +2755,7 @@ bool Win_GParted::open_encrypted_partition( const Partition & partition,
void Win_GParted::toggle_crypt_busy_state() void Win_GParted::toggle_crypt_busy_state()
{ {
g_assert( selected_partition_ptr != NULL ); // Bug: Partition callback without a selected partition g_assert(selected_partition_ptr != nullptr); // Bug: Partition callback without a selected partition
g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object
enum Action enum Action
@ -2808,7 +2809,7 @@ void Win_GParted::toggle_crypt_busy_state()
case LUKSOPEN: case LUKSOPEN:
{ {
// Attempt to unlock LUKS using stored passphrase first. // Attempt to unlock LUKS using stored passphrase first.
success = open_encrypted_partition( *selected_partition_ptr, NULL, error_msg ); success = open_encrypted_partition(*selected_partition_ptr, nullptr, error_msg);
if ( success ) if ( success )
break; break;
@ -2941,7 +2942,7 @@ void Win_GParted::show_toggle_failure_dialog( const Glib::ustring & failure_summ
void Win_GParted::toggle_fs_busy_state() void Win_GParted::toggle_fs_busy_state()
{ {
g_assert( selected_partition_ptr != NULL ); // Bug: Partition callback without a selected partition g_assert(selected_partition_ptr != nullptr); // Bug: Partition callback without a selected partition
g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object
enum Action enum Action
@ -3054,7 +3055,7 @@ void Win_GParted::toggle_fs_busy_state()
void Win_GParted::activate_mount_partition( unsigned int index ) void Win_GParted::activate_mount_partition( unsigned int index )
{ {
g_assert( selected_partition_ptr != NULL ); // Bug: Partition callback without a selected partition g_assert(selected_partition_ptr != nullptr); // Bug: Partition callback without a selected partition
g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object
Glib::ustring disallowed_msg = _("The mount action cannot be performed when an operation is pending for the partition."); Glib::ustring disallowed_msg = _("The mount action cannot be performed when an operation is pending for the partition.");
@ -3261,7 +3262,7 @@ void Win_GParted::activate_attempt_rescue_data()
void Win_GParted::activate_manage_flags() void Win_GParted::activate_manage_flags()
{ {
g_assert( selected_partition_ptr != NULL ); // Bug: Partition callback without a selected partition g_assert(selected_partition_ptr != nullptr); // Bug: Partition callback without a selected partition
g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object
get_window()->set_cursor(Gdk::Cursor::create(Gdk::WATCH)); get_window()->set_cursor(Gdk::Cursor::create(Gdk::WATCH));
@ -3287,7 +3288,7 @@ void Win_GParted::activate_manage_flags()
void Win_GParted::activate_check() void Win_GParted::activate_check()
{ {
g_assert( selected_partition_ptr != NULL ); // Bug: Partition callback without a selected partition g_assert(selected_partition_ptr != nullptr); // Bug: Partition callback without a selected partition
g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object
if (! ask_for_password_for_encrypted_resize_as_required(*selected_partition_ptr)) if (! ask_for_password_for_encrypted_resize_as_required(*selected_partition_ptr))
@ -3311,7 +3312,7 @@ void Win_GParted::activate_check()
void Win_GParted::activate_label_filesystem() void Win_GParted::activate_label_filesystem()
{ {
g_assert( selected_partition_ptr != NULL ); // Bug: Partition callback without a selected partition g_assert(selected_partition_ptr != nullptr); // Bug: Partition callback without a selected partition
g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object
const Partition & filesystem_ptn = selected_partition_ptr->get_filesystem_partition(); const Partition & filesystem_ptn = selected_partition_ptr->get_filesystem_partition();
@ -3332,7 +3333,7 @@ void Win_GParted::activate_label_filesystem()
operation->icon = Utils::mk_pixbuf(*this, Gtk::Stock::EXECUTE, Gtk::ICON_SIZE_MENU); operation->icon = Utils::mk_pixbuf(*this, Gtk::Stock::EXECUTE, Gtk::ICON_SIZE_MENU);
delete part_temp; delete part_temp;
part_temp = NULL; part_temp = nullptr;
Add_Operation( devices[current_device], operation ); Add_Operation( devices[current_device], operation );
// Try to merge this label file system operation with all previous // Try to merge this label file system operation with all previous
@ -3345,7 +3346,7 @@ void Win_GParted::activate_label_filesystem()
void Win_GParted::activate_name_partition() void Win_GParted::activate_name_partition()
{ {
g_assert( selected_partition_ptr != NULL ); // Bug: Partition callback without a selected partition g_assert(selected_partition_ptr != nullptr); // Bug: Partition callback without a selected partition
g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object
Dialog_Partition_Name dialog( *selected_partition_ptr, Dialog_Partition_Name dialog( *selected_partition_ptr,
@ -3366,7 +3367,7 @@ void Win_GParted::activate_name_partition()
operation->icon = Utils::mk_pixbuf(*this, Gtk::Stock::EXECUTE, Gtk::ICON_SIZE_MENU); operation->icon = Utils::mk_pixbuf(*this, Gtk::Stock::EXECUTE, Gtk::ICON_SIZE_MENU);
delete part_temp; delete part_temp;
part_temp = NULL; part_temp = nullptr;
Add_Operation( devices[current_device], operation ); Add_Operation( devices[current_device], operation );
// Try to merge this name partition operation with all previous // Try to merge this name partition operation with all previous
@ -3379,7 +3380,7 @@ void Win_GParted::activate_name_partition()
void Win_GParted::activate_change_uuid() void Win_GParted::activate_change_uuid()
{ {
g_assert( selected_partition_ptr != NULL ); // Bug: Partition callback without a selected partition g_assert(selected_partition_ptr != nullptr); // Bug: Partition callback without a selected partition
g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object g_assert( valid_display_partition_ptr( selected_partition_ptr ) ); // Bug: Not pointing at a valid display partition object
const Partition & filesystem_ptn = selected_partition_ptr->get_filesystem_partition(); const Partition & filesystem_ptn = selected_partition_ptr->get_filesystem_partition();
@ -3424,7 +3425,7 @@ void Win_GParted::activate_change_uuid()
operation->icon = Utils::mk_pixbuf(*this, Gtk::Stock::EXECUTE, Gtk::ICON_SIZE_MENU); operation->icon = Utils::mk_pixbuf(*this, Gtk::Stock::EXECUTE, Gtk::ICON_SIZE_MENU);
delete temp_ptn; delete temp_ptn;
temp_ptn = NULL; temp_ptn = nullptr;
Add_Operation( devices[current_device], operation ); Add_Operation( devices[current_device], operation );
// Try to merge this change UUID operation with all previous operations. // Try to merge this change UUID operation with all previous operations.

2
src/luks.cc
View File

@ -159,7 +159,7 @@ bool luks::resize( const Partition & partition_new, OperationDetail & operationd
// device sector size. // device sector size.
size = "--size " + Utils::num_to_str( ( partition_new.get_byte_length() - mapping.offset ) / 512LL ) + " "; size = "--size " + Utils::num_to_str( ( partition_new.get_byte_length() - mapping.offset ) / 512LL ) + " ";
const char *pw = NULL; const char* pw = nullptr;
if (mapping.key_loc == KEYLOC_KeyRing) if (mapping.key_loc == KEYLOC_KeyRing)
pw = PasswordRAMStore::lookup(partition_new.uuid); pw = PasswordRAMStore::lookup(partition_new.uuid);