file_systems/udf: Reduce indent

Reduce indent in walk_volume_descriptor_sequence() for readability.

Change-Id: Ie4d46fc69ebee3b74f0410639f06010351e71894
Reviewed-on: https://review.haiku-os.org/c/haiku/+/3294
Reviewed-by: waddlesplash <[email protected]>

src/add-ons/kernel/file_systems/udf/Recognition.cpp

@@ -239,6 +239,87 @@ walk_anchor_volume_descriptor_sequences(int device, off_t offset, off_t length,
 	RETURN(error);
 }
 
+static status_t
+walk_tagid_partition_descriptor(descriptor_tag  *tag, off_t block,
+	uint8& uniquePartitions, partition_descriptor* partitionDescriptors)
+{
+	DEBUG_INIT(NULL);
+
+	status_t error = B_OK;
+	partition_descriptor *partition =
+		reinterpret_cast<partition_descriptor*>(tag);
+	PDUMP(partition);
+	if (partition->tag().init_check(block) == B_OK) {
+		// Check for a previously discovered partition descriptor with
+		// the same number as this partition. If found, keep the one with
+		// the higher vds number.
+		bool foundDuplicate = false;
+		int num;
+		for (num = 0; num < uniquePartitions; num++) {
+			if (partitionDescriptors[num].partition_number()
+				== partition->partition_number()) {
+				foundDuplicate = true;
+				if (partitionDescriptors[num].vds_number()
+					< partition->vds_number()) {
+					partitionDescriptors[num] = *partition;
+					PRINT(("Replacing previous partition #%d "
+						"(vds_number: %" B_PRIu32 ") with new partition #%d "
+						"(vds_number: %" B_PRIu32 ")\n",
+						partitionDescriptors[num].partition_number(),
+						partitionDescriptors[num].vds_number(),
+						partition->partition_number(),
+						partition->vds_number()));
+				}
+				break;
+			}
+		}
+		// If we didn't find a duplicate, see if we have any open descriptor
+		// spaces left.
+		if (!foundDuplicate) {
+			if (num < kMaxPartitionDescriptors) {
+			// At least one more partition descriptor allowed
+				partitionDescriptors[num] = *partition;
+				uniquePartitions++;
+				PRINT(("Adding partition #%d (vds_number: %" B_PRIu32 ")\n",
+					partition->partition_number(),
+					partition->vds_number()));
+			} else {
+				// We've found more than kMaxPartitionDescriptor uniquely-
+				// numbered partitions. So, search through the partitions
+				// we already have again, this time just looking for a
+				// partition with a lower vds number. If we find one,
+				// replace it with this one. If we don't, scream bloody
+				// murder.
+				bool foundReplacement = false;
+				for (int j = 0; j < uniquePartitions; j++) {
+					if (partitionDescriptors[j].vds_number()
+						< partition->vds_number()) {
+						foundReplacement = true;
+						partitionDescriptors[j] = *partition;
+						PRINT(("Replacing partition #%d "
+							"(vds_number: %" B_PRIu32 ") "
+							"with partition #%d "
+							"(vds_number: %" B_PRIu32 ")\n",
+							partitionDescriptors[j].partition_number(),
+							partitionDescriptors[j].vds_number(),
+							partition->partition_number(),
+							partition->vds_number()));
+							break;
+					}
+				}
+				if (!foundReplacement) {
+					PRINT(("Found more than kMaxPartitionDescriptors == %d "
+					"unique partition descriptors!\n",
+					kMaxPartitionDescriptors));
+						error = B_BAD_VALUE;
+				}
+			}
+		}
+	}
+
+	RETURN(error);
+}
+
 static
 status_t
 walk_volume_descriptor_sequence(extent_address descriptorSequence,
@@ -269,7 +350,8 @@ walk_volume_descriptor_sequence(extent_address descriptorSequence,
 
 		status_t loopError = chunk.InitCheck();
 		if (!loopError) {
-			ssize_t bytesRead = read_pos(device, address, chunk.Data(), blockSize);
+			ssize_t bytesRead = read_pos(device, address, chunk.Data(),
+				blockSize);
 			loopError = bytesRead == (ssize_t)blockSize ? B_OK : B_IO_ERROR;
 			if (loopError) {
 				PRINT(("block %" B_PRIdOFF ": read_pos(pos:%" B_PRIdOFF ", "
@@ -289,7 +371,8 @@ walk_volume_descriptor_sequence(extent_address descriptorSequence,
 
 				case TAGID_PRIMARY_VOLUME_DESCRIPTOR:
 				{
-					primary_volume_descriptor *primary = reinterpret_cast<primary_volume_descriptor*>(tag);
+					primary_volume_descriptor *primary =
+						reinterpret_cast<primary_volume_descriptor*>(tag);
 					PDUMP(primary);
 					primaryVolumeDescriptor = *primary;
 					break;
@@ -303,102 +386,37 @@ walk_volume_descriptor_sequence(extent_address descriptorSequence,
 
 				case TAGID_IMPLEMENTATION_USE_VOLUME_DESCRIPTOR:
 				{
-					implementation_use_descriptor *impUse = reinterpret_cast<implementation_use_descriptor*>(tag);
+					implementation_use_descriptor *impUse =
+						reinterpret_cast<implementation_use_descriptor*>(tag);
 					PDUMP(impUse);
-					// Check for a matching implementation id string (note that the
+					// Check for a matching implementation id string
-					// revision version is not checked)
+					//  (note that the revision version is not checked)
 					if (impUse->tag().init_check(block) == B_OK
-					    && impUse->implementation_id().matches(kLogicalVolumeInfoId201)) {
+						&& impUse->implementation_id().matches(
-							foundUdfImplementationUseDescriptor = true;
+						kLogicalVolumeInfoId201)) {
+								foundUdfImplementationUseDescriptor = true;
 					}
 					break;
 				}
 
 				case TAGID_PARTITION_DESCRIPTOR:
 				{
-					partition_descriptor *partition = reinterpret_cast<partition_descriptor*>(tag);
+					error = walk_tagid_partition_descriptor(
-					PDUMP(partition);
+						tag, block, uniquePartitions, partitionDescriptors);
-					if (partition->tag().init_check(block) == B_OK) {
-						// Check for a previously discovered partition descriptor with
-						// the same number as this partition. If found, keep the one with
-						// the higher vds number.
-						bool foundDuplicate = false;
-						int num;
-						for (num = 0; num < uniquePartitions; num++) {
-							if (partitionDescriptors[num].partition_number()
-							    == partition->partition_number()) {
-								foundDuplicate = true;
-								if (partitionDescriptors[num].vds_number()
-								    < partition->vds_number()) {
-									partitionDescriptors[num] = *partition;		
-									PRINT(("Replacing previous partition #%d "
-												"(vds_number: %" B_PRIu32 ") "
-												"with new partition #%d "
-												"(vds_number: %" B_PRIu32 ")\n",
-									       partitionDescriptors[num].partition_number(),
-									       partitionDescriptors[num].vds_number(),
-									       partition->partition_number(),
-									       partition->vds_number()));
-								}
-								break;
-							}							    
-						}
-						// If we didn't find a duplicate, see if we have any open descriptor
-						// spaces left.
-						if (!foundDuplicate) {
-							if (num < kMaxPartitionDescriptors) {
-								// At least one more partition descriptor allowed
-								partitionDescriptors[num] = *partition;
-								uniquePartitions++;
-								PRINT(("Adding partition #%d (vds_number: %" B_PRIu32
-								       ")\n",
-								       partition->partition_number(),
-								       partition->vds_number()));
-							} else {
-								// We've found more than kMaxPartitionDescriptor uniquely-
-								// numbered partitions. So, search through the partitions
-								// we already have again, this time just looking for a
-								// partition with a lower vds number. If we find one,
-								// replace it with this one. If we don't, scream bloody
-								// murder.
-								bool foundReplacement = false;
-								for (int j = 0; j < uniquePartitions; j++) {
-									if (partitionDescriptors[j].vds_number()
-									    < partition->vds_number()) {
-										foundReplacement = true;
-										partitionDescriptors[j] = *partition;
-										PRINT(("Replacing partition #%d "
-													"(vds_number: %" B_PRIu32 ") "
-													"with partition #%d "
-													"(vds_number: %" B_PRIu32 ")\n",
-										       partitionDescriptors[j].partition_number(),
-										       partitionDescriptors[j].vds_number(),
-										       partition->partition_number(),
-										       partition->vds_number()));
-										break;
-									}
-								}
-								if (!foundReplacement) {
-									PRINT(("Found more than kMaxPartitionDescriptors == %d "
-									       "unique partition descriptors!\n",
-									       kMaxPartitionDescriptors));
-									error = B_BAD_VALUE;
-									break;
-								}
-							}									
-						} 
-					}
 					break;
 				}
 
 				case TAGID_LOGICAL_VOLUME_DESCRIPTOR:
 				{
-					logical_volume_descriptor *logical = reinterpret_cast<logical_volume_descriptor*>(tag);
+					logical_volume_descriptor *logical =
+						reinterpret_cast<logical_volume_descriptor*>(tag);
 					PDUMP(logical);
 					if (foundLogicalVolumeDescriptor) {
 						// Keep the vd with the highest vds_number
-						if (logicalVolumeDescriptor.vds_number() < logical->vds_number())
+						if (logicalVolumeDescriptor.vds_number()
-							logicalVolumeDescriptor = *logical;
+							< logical->vds_number()) {
+								logicalVolumeDescriptor = *logical;
+						}
 					} else {
 						logicalVolumeDescriptor = *logical;
 						foundLogicalVolumeDescriptor = true;
@@ -408,7 +426,8 @@ walk_volume_descriptor_sequence(extent_address descriptorSequence,
 
 				case TAGID_UNALLOCATED_SPACE_DESCRIPTOR:
 				{
-					unallocated_space_descriptor *unallocated = reinterpret_cast<unallocated_space_descriptor*>(tag);
+					unallocated_space_descriptor *unallocated =
+						reinterpret_cast<unallocated_space_descriptor*>(tag);
 					PDUMP(unallocated);
 					foundUnallocatedSpaceDescriptor = true;
 					(void)unallocated;	// kill the warning
@@ -417,7 +436,8 @@ walk_volume_descriptor_sequence(extent_address descriptorSequence,
 
 				case TAGID_TERMINATING_DESCRIPTOR:
 				{
-					terminating_descriptor *terminating = reinterpret_cast<terminating_descriptor*>(tag);
+					terminating_descriptor *terminating =
+						reinterpret_cast<terminating_descriptor*>(tag);
 					PDUMP(terminating);
 					(void)terminating;	// kill the warning
 					break;
@@ -435,15 +455,15 @@ walk_volume_descriptor_sequence(extent_address descriptorSequence,
 	}
 
 	PRINT(("found %d unique partition%s\n", uniquePartitions,
-	       (uniquePartitions == 1 ? "" : "s")));
+		(uniquePartitions == 1 ? "" : "s")));
 
 	if (!error && !foundUdfImplementationUseDescriptor) {
 		INFORM(("WARNING: no valid udf implementation use descriptor found\n"));
 	}
 	if (!error)
 		error = foundLogicalVolumeDescriptor
-		        && foundUnallocatedSpaceDescriptor
+			&& foundUnallocatedSpaceDescriptor
-		        ? B_OK : B_ERROR;
+			? B_OK : B_ERROR;
 	if (!error)
 		error = uniquePartitions >= 1 ? B_OK : B_ERROR;
 	if (!error)
@@ -456,7 +476,7 @@ walk_volume_descriptor_sequence(extent_address descriptorSequence,
 
 	\return
 	- \c B_OK: Success. the sequence was terminated by a valid, closed
-	           integrity descriptor.
+		integrity descriptor.
 	- \c B_ENTRY_NOT_FOUND: The sequence was empty.
 	- (other error code): The sequence was non-empty and did not end in a valid,
                           closed integrity descriptor.
@@ -466,9 +486,9 @@ walk_integrity_sequence(int device, uint32 blockSize, uint32 blockShift,
                         extent_address descriptorSequence, uint32 sequenceNumber)
 {
 	DEBUG_INIT_ETC(NULL,
-	           ("descriptorSequence.loc:%" B_PRIu32 ", "
+		("descriptorSequence.loc:%" B_PRIu32 ", "
-	           "descriptorSequence.len:%" B_PRIu32 ,
+		"descriptorSequence.len:%" B_PRIu32 ,
-	           descriptorSequence.location(), descriptorSequence.length()));
+		descriptorSequence.location(), descriptorSequence.length()));
 	uint32 count = descriptorSequence.length() >> blockShift;
 
 	bool lastDescriptorWasClosed = false;
@@ -490,8 +510,8 @@ walk_integrity_sequence(int device, uint32 blockSize, uint32 blockShift,
 			loopError = check_size_error(bytesRead, blockSize);
 			if (loopError) {
 				PRINT(("block %" B_PRIdOFF": read_pos(pos:%" B_PRIdOFF
-				       ", len:%" B_PRIu32 ") failed with error 0x%lx\n",
+					", len:%" B_PRIu32 ") failed with error 0x%lx\n",
-				       block, address, blockSize, bytesRead));
+					block, address, blockSize, bytesRead));
 			}
 		}
 		if (!loopError) {
@@ -501,7 +521,7 @@ walk_integrity_sequence(int device, uint32 blockSize, uint32 blockShift,
 		if (!loopError) {
 			// Check the descriptor type and see if it's closed.
 			loopError = tag->id() == TAGID_LOGICAL_VOLUME_INTEGRITY_DESCRIPTOR
-			            ? B_OK : B_BAD_DATA;
+				? B_OK : B_BAD_DATA;
 			if (!loopError) {
 				logical_volume_integrity_descriptor *descriptor =
 					reinterpret_cast<logical_volume_integrity_descriptor*>(chunk.Data());
@@ -513,8 +533,8 @@ walk_integrity_sequence(int device, uint32 blockSize, uint32 blockShift,
 						highestMinimumUDFReadRevision = minimumRevision;
 					} else if (minimumRevision < highestMinimumUDFReadRevision) {
 						INFORM(("WARNING: found decreasing minimum udf read revision in integrity "
-						        "sequence (last highest: 0x%04x, current: 0x%04x); using higher "
+							"sequence (last highest: 0x%04x, current: 0x%04x); using higher "
-						        "revision.\n", highestMinimumUDFReadRevision, minimumRevision));
+							"revision.\n", highestMinimumUDFReadRevision, minimumRevision));
 					}
 				}
 
@@ -523,7 +543,7 @@ walk_integrity_sequence(int device, uint32 blockSize, uint32 blockShift,
 				extent_address &next = descriptor->next_integrity_extent();
 				if (next.length() > 0) {
 					status_t nextError = walk_integrity_sequence(device, blockSize, blockShift,
-					                                             next, sequenceNumber+1);
+						next, sequenceNumber+1);
 					if (nextError && nextError != B_ENTRY_NOT_FOUND) {
 						// Continuation proved invalid
 						error = nextError;