Pre-beta mechanical code beautification.

Run pgindent, pgperltidy, and reformat-dat-files.

This set of diffs is a bit larger than typical.  We've updated to
pg_bsd_indent 2.1.2, which properly indents variable declarations that
have multi-line initialization expressions (the continuation lines are
now indented one tab stop).  We've also updated to perltidy version
20230309 and changed some of its settings, which reduces its desire to
add whitespace to lines to make assignments etc. line up.  Going
forward, that should make for fewer random-seeming changes to existing
code.

Discussion: https://postgr.es/m/20230428092545.qfb3y5wcu4cm75ur@alvherre.pgsql

src/backend/storage/buffer/bufmgr.c

@@ -2667,7 +2667,7 @@ BufferSync(int flags)
 	{
 		BufferDesc *bufHdr = NULL;
 		CkptTsStatus *ts_stat = (CkptTsStatus *)
-		DatumGetPointer(binaryheap_first(ts_heap));
+			DatumGetPointer(binaryheap_first(ts_heap));
 
 		buf_id = CkptBufferIds[ts_stat->index].buf_id;
 		Assert(buf_id != -1);

src/backend/storage/file/buffile.c

@@ -98,8 +98,7 @@ struct BufFile
 
 	/*
 	 * XXX Should ideally us PGIOAlignedBlock, but might need a way to avoid
-	 * wasting per-file alignment padding when some users create many
-	 * files.
+	 * wasting per-file alignment padding when some users create many files.
 	 */
 	PGAlignedBlock buffer;
 };

src/backend/storage/ipc/dsm_impl.c

@@ -357,14 +357,15 @@ dsm_impl_posix_resize(int fd, off_t size)
 	/*
 	 * Block all blockable signals, except SIGQUIT.  posix_fallocate() can run
 	 * for quite a long time, and is an all-or-nothing operation.  If we
-	 * allowed SIGUSR1 to interrupt us repeatedly (for example, due to recovery
-	 * conflicts), the retry loop might never succeed.
+	 * allowed SIGUSR1 to interrupt us repeatedly (for example, due to
+	 * recovery conflicts), the retry loop might never succeed.
 	 */
 	if (IsUnderPostmaster)
 		sigprocmask(SIG_SETMASK, &BlockSig, &save_sigmask);
 
 	pgstat_report_wait_start(WAIT_EVENT_DSM_ALLOCATE);
 #if defined(HAVE_POSIX_FALLOCATE) && defined(__linux__)
+
 	/*
 	 * On Linux, a shm_open fd is backed by a tmpfs file.  If we were to use
 	 * ftruncate, the file would contain a hole.  Accessing memory backed by a
@@ -374,8 +375,8 @@ dsm_impl_posix_resize(int fd, off_t size)
 	 * SIGBUS later.
 	 *
 	 * We still use a traditional EINTR retry loop to handle SIGCONT.
-	 * posix_fallocate() doesn't restart automatically, and we don't want
-	 * this to fail if you attach a debugger.
+	 * posix_fallocate() doesn't restart automatically, and we don't want this
+	 * to fail if you attach a debugger.
 	 */
 	do
 	{
@@ -383,9 +384,9 @@ dsm_impl_posix_resize(int fd, off_t size)
 	} while (rc == EINTR);
 
 	/*
-	 * The caller expects errno to be set, but posix_fallocate() doesn't
-	 * set it.  Instead it returns error numbers directly.  So set errno,
-	 * even though we'll also return rc to indicate success or failure.
+	 * The caller expects errno to be set, but posix_fallocate() doesn't set
+	 * it.  Instead it returns error numbers directly.  So set errno, even
+	 * though we'll also return rc to indicate success or failure.
 	 */
 	errno = rc;
 #else

src/backend/storage/lmgr/generate-lwlocknames.pl

@@ -10,10 +10,9 @@ use Getopt::Long;
 my $output_path = '.';
 
 my $lastlockidx = -1;
-my $continue    = "\n";
+my $continue = "\n";
 
-GetOptions(
-	'outdir:s'       => \$output_path);
+GetOptions('outdir:s' => \$output_path);
 
 open my $lwlocknames, '<', $ARGV[0] or die;
 
@@ -48,7 +47,7 @@ while (<$lwlocknames>)
 	$trimmedlockname =~ s/Lock$//;
 	die "lock names must end with 'Lock'" if $trimmedlockname eq $lockname;
 
-	die "lwlocknames.txt not in order"   if $lockidx < $lastlockidx;
+	die "lwlocknames.txt not in order" if $lockidx < $lastlockidx;
 	die "lwlocknames.txt has duplicates" if $lockidx == $lastlockidx;
 
 	while ($lastlockidx < $lockidx - 1)
@@ -59,7 +58,7 @@ while (<$lwlocknames>)
 	}
 	printf $c "%s	\"%s\"", $continue, $trimmedlockname;
 	$lastlockidx = $lockidx;
-	$continue    = ",\n";
+	$continue = ",\n";
 
 	print $h "#define $lockname (&MainLWLockArray[$lockidx].lock)\n";
 }
@@ -71,7 +70,8 @@ printf $h "#define NUM_INDIVIDUAL_LWLOCKS		%s\n", $lastlockidx + 1;
 close $h;
 close $c;
 
-rename($htmp, "$output_path/lwlocknames.h") || die "rename: $htmp to $output_path/lwlocknames.h: $!";
+rename($htmp, "$output_path/lwlocknames.h")
+  || die "rename: $htmp to $output_path/lwlocknames.h: $!";
 rename($ctmp, "$output_path/lwlocknames.c") || die "rename: $ctmp: $!";
 
 close $lwlocknames;

src/backend/storage/lmgr/lock.c

@@ -3936,6 +3936,7 @@ GetSingleProcBlockerStatusData(PGPROC *blocked_proc, BlockedProcsData *data)
 	dclist_foreach(proc_iter, waitQueue)
 	{
 		PGPROC	   *queued_proc = dlist_container(PGPROC, links, proc_iter.cur);
+
 		if (queued_proc == blocked_proc)
 			break;
 		data->waiter_pids[data->npids++] = queued_proc->pid;

src/backend/storage/lmgr/lwlock.c

@@ -1118,9 +1118,9 @@ LWLockDequeueSelf(LWLock *lock)
 	LWLockWaitListLock(lock);
 
 	/*
-	 * Remove ourselves from the waitlist, unless we've already been
-	 * removed. The removal happens with the wait list lock held, so there's
-	 * no race in this check.
+	 * Remove ourselves from the waitlist, unless we've already been removed.
+	 * The removal happens with the wait list lock held, so there's no race in
+	 * this check.
 	 */
 	on_waitlist = MyProc->lwWaiting == LW_WS_WAITING;
 	if (on_waitlist)

src/backend/storage/lmgr/predicate.c

@@ -625,7 +625,7 @@ RWConflictExists(const SERIALIZABLEXACT *reader, const SERIALIZABLEXACT *writer)
 	dlist_foreach(iter, &unconstify(SERIALIZABLEXACT *, reader)->outConflicts)
 	{
 		RWConflict	conflict =
-		dlist_container(RWConflictData, outLink, iter.cur);
+			dlist_container(RWConflictData, outLink, iter.cur);
 
 		if (conflict->sxactIn == writer)
 			return true;
@@ -708,7 +708,7 @@ FlagSxactUnsafe(SERIALIZABLEXACT *sxact)
 	dlist_foreach_modify(iter, &sxact->possibleUnsafeConflicts)
 	{
 		RWConflict	conflict =
-		dlist_container(RWConflictData, inLink, iter.cur);
+			dlist_container(RWConflictData, inLink, iter.cur);
 
 		Assert(!SxactIsReadOnly(conflict->sxactOut));
 		Assert(sxact == conflict->sxactIn);
@@ -1587,7 +1587,7 @@ GetSafeSnapshotBlockingPids(int blocked_pid, int *output, int output_size)
 		dlist_foreach(iter, &blocking_sxact->possibleUnsafeConflicts)
 		{
 			RWConflict	possibleUnsafeConflict =
-			dlist_container(RWConflictData, inLink, iter.cur);
+				dlist_container(RWConflictData, inLink, iter.cur);
 
 			output[num_written++] = possibleUnsafeConflict->sxactOut->pid;
 
@@ -1825,8 +1825,8 @@ GetSerializableTransactionSnapshotInt(Snapshot snapshot,
 		/*
 		 * If we didn't find any possibly unsafe conflicts because every
 		 * uncommitted writable transaction turned out to be doomed, then we
-		 * can "opt out" immediately.  See comments above the earlier check for
-		 * PredXact->WritableSxactCount == 0.
+		 * can "opt out" immediately.  See comments above the earlier check
+		 * for PredXact->WritableSxactCount == 0.
 		 */
 		if (dlist_is_empty(&sxact->possibleUnsafeConflicts))
 		{
@@ -2613,7 +2613,7 @@ DeleteLockTarget(PREDICATELOCKTARGET *target, uint32 targettaghash)
 	dlist_foreach_modify(iter, &target->predicateLocks)
 	{
 		PREDICATELOCK *predlock =
-		dlist_container(PREDICATELOCK, targetLink, iter.cur);
+			dlist_container(PREDICATELOCK, targetLink, iter.cur);
 		bool		found;
 
 		dlist_delete(&(predlock->xactLink));
@@ -2754,7 +2754,7 @@ TransferPredicateLocksToNewTarget(PREDICATELOCKTARGETTAG oldtargettag,
 		dlist_foreach_modify(iter, &oldtarget->predicateLocks)
 		{
 			PREDICATELOCK *oldpredlock =
-			dlist_container(PREDICATELOCK, targetLink, iter.cur);
+				dlist_container(PREDICATELOCK, targetLink, iter.cur);
 			PREDICATELOCK *newpredlock;
 			SerCommitSeqNo oldCommitSeqNo = oldpredlock->commitSeqNo;
 
@@ -2976,7 +2976,7 @@ DropAllPredicateLocksFromTable(Relation relation, bool transfer)
 		dlist_foreach_modify(iter, &oldtarget->predicateLocks)
 		{
 			PREDICATELOCK *oldpredlock =
-			dlist_container(PREDICATELOCK, targetLink, iter.cur);
+				dlist_container(PREDICATELOCK, targetLink, iter.cur);
 			PREDICATELOCK *newpredlock;
 			SerCommitSeqNo oldCommitSeqNo;
 			SERIALIZABLEXACT *oldXact;
@@ -3194,7 +3194,7 @@ SetNewSxactGlobalXmin(void)
 	dlist_foreach(iter, &PredXact->activeList)
 	{
 		SERIALIZABLEXACT *sxact =
-		dlist_container(SERIALIZABLEXACT, xactLink, iter.cur);
+			dlist_container(SERIALIZABLEXACT, xactLink, iter.cur);
 
 		if (!SxactIsRolledBack(sxact)
 			&& !SxactIsCommitted(sxact)
@@ -3440,7 +3440,7 @@ ReleasePredicateLocks(bool isCommit, bool isReadOnlySafe)
 		dlist_foreach_modify(iter, &MySerializableXact->possibleUnsafeConflicts)
 		{
 			RWConflict	possibleUnsafeConflict =
-			dlist_container(RWConflictData, inLink, iter.cur);
+				dlist_container(RWConflictData, inLink, iter.cur);
 
 			Assert(!SxactIsReadOnly(possibleUnsafeConflict->sxactOut));
 			Assert(MySerializableXact == possibleUnsafeConflict->sxactIn);
@@ -3471,7 +3471,7 @@ ReleasePredicateLocks(bool isCommit, bool isReadOnlySafe)
 	dlist_foreach_modify(iter, &MySerializableXact->outConflicts)
 	{
 		RWConflict	conflict =
-		dlist_container(RWConflictData, outLink, iter.cur);
+			dlist_container(RWConflictData, outLink, iter.cur);
 
 		if (isCommit
 			&& !SxactIsReadOnly(MySerializableXact)
@@ -3496,7 +3496,7 @@ ReleasePredicateLocks(bool isCommit, bool isReadOnlySafe)
 	dlist_foreach_modify(iter, &MySerializableXact->inConflicts)
 	{
 		RWConflict	conflict =
-		dlist_container(RWConflictData, inLink, iter.cur);
+			dlist_container(RWConflictData, inLink, iter.cur);
 
 		if (!isCommit
 			|| SxactIsCommitted(conflict->sxactOut)
@@ -3515,7 +3515,7 @@ ReleasePredicateLocks(bool isCommit, bool isReadOnlySafe)
 		dlist_foreach_modify(iter, &MySerializableXact->possibleUnsafeConflicts)
 		{
 			RWConflict	possibleUnsafeConflict =
-			dlist_container(RWConflictData, outLink, iter.cur);
+				dlist_container(RWConflictData, outLink, iter.cur);
 
 			roXact = possibleUnsafeConflict->sxactIn;
 			Assert(MySerializableXact == possibleUnsafeConflict->sxactOut);
@@ -3564,8 +3564,8 @@ ReleasePredicateLocks(bool isCommit, bool isReadOnlySafe)
 	 * xmin and purge any transactions which finished before this transaction
 	 * was launched.
 	 *
-	 * For parallel queries in read-only transactions, it might run twice.
-	 * We only release the reference on the first call.
+	 * For parallel queries in read-only transactions, it might run twice. We
+	 * only release the reference on the first call.
 	 */
 	needToClear = false;
 	if ((partiallyReleasing ||
@@ -3641,7 +3641,7 @@ ClearOldPredicateLocks(void)
 	dlist_foreach_modify(iter, FinishedSerializableTransactions)
 	{
 		SERIALIZABLEXACT *finishedSxact =
-		dlist_container(SERIALIZABLEXACT, finishedLink, iter.cur);
+			dlist_container(SERIALIZABLEXACT, finishedLink, iter.cur);
 
 		if (!TransactionIdIsValid(PredXact->SxactGlobalXmin)
 			|| TransactionIdPrecedesOrEquals(finishedSxact->finishedBefore,
@@ -3700,7 +3700,7 @@ ClearOldPredicateLocks(void)
 	dlist_foreach_modify(iter, &OldCommittedSxact->predicateLocks)
 	{
 		PREDICATELOCK *predlock =
-		dlist_container(PREDICATELOCK, xactLink, iter.cur);
+			dlist_container(PREDICATELOCK, xactLink, iter.cur);
 		bool		canDoPartialCleanup;
 
 		LWLockAcquire(SerializableXactHashLock, LW_SHARED);
@@ -3787,7 +3787,7 @@ ReleaseOneSerializableXact(SERIALIZABLEXACT *sxact, bool partial,
 	dlist_foreach_modify(iter, &sxact->predicateLocks)
 	{
 		PREDICATELOCK *predlock =
-		dlist_container(PREDICATELOCK, xactLink, iter.cur);
+			dlist_container(PREDICATELOCK, xactLink, iter.cur);
 		PREDICATELOCKTAG tag;
 		PREDICATELOCKTARGET *target;
 		PREDICATELOCKTARGETTAG targettag;
@@ -3864,7 +3864,7 @@ ReleaseOneSerializableXact(SERIALIZABLEXACT *sxact, bool partial,
 		dlist_foreach_modify(iter, &sxact->outConflicts)
 		{
 			RWConflict	conflict =
-			dlist_container(RWConflictData, outLink, iter.cur);
+				dlist_container(RWConflictData, outLink, iter.cur);
 
 			if (summarize)
 				conflict->sxactIn->flags |= SXACT_FLAG_SUMMARY_CONFLICT_IN;
@@ -3876,7 +3876,7 @@ ReleaseOneSerializableXact(SERIALIZABLEXACT *sxact, bool partial,
 	dlist_foreach_modify(iter, &sxact->inConflicts)
 	{
 		RWConflict	conflict =
-		dlist_container(RWConflictData, inLink, iter.cur);
+			dlist_container(RWConflictData, inLink, iter.cur);
 
 		if (summarize)
 			conflict->sxactOut->flags |= SXACT_FLAG_SUMMARY_CONFLICT_OUT;
@@ -4134,7 +4134,7 @@ CheckTargetForConflictsIn(PREDICATELOCKTARGETTAG *targettag)
 	dlist_foreach_modify(iter, &target->predicateLocks)
 	{
 		PREDICATELOCK *predlock =
-		dlist_container(PREDICATELOCK, targetLink, iter.cur);
+			dlist_container(PREDICATELOCK, targetLink, iter.cur);
 		SERIALIZABLEXACT *sxact = predlock->tag.myXact;
 
 		if (sxact == MySerializableXact)
@@ -4407,7 +4407,7 @@ CheckTableForSerializableConflictIn(Relation relation)
 		dlist_foreach_modify(iter, &target->predicateLocks)
 		{
 			PREDICATELOCK *predlock =
-			dlist_container(PREDICATELOCK, targetLink, iter.cur);
+				dlist_container(PREDICATELOCK, targetLink, iter.cur);
 
 			if (predlock->tag.myXact != MySerializableXact
 				&& !RWConflictExists(predlock->tag.myXact, MySerializableXact))
@@ -4519,7 +4519,7 @@ OnConflict_CheckForSerializationFailure(const SERIALIZABLEXACT *reader,
 		dlist_foreach(iter, &writer->outConflicts)
 		{
 			RWConflict	conflict =
-			dlist_container(RWConflictData, outLink, iter.cur);
+				dlist_container(RWConflictData, outLink, iter.cur);
 			SERIALIZABLEXACT *t2 = conflict->sxactIn;
 
 			if (SxactIsPrepared(t2)
@@ -4566,7 +4566,7 @@ OnConflict_CheckForSerializationFailure(const SERIALIZABLEXACT *reader,
 			dlist_foreach(iter, &unconstify(SERIALIZABLEXACT *, reader)->inConflicts)
 			{
 				const RWConflict conflict =
-				dlist_container(RWConflictData, inLink, iter.cur);
+					dlist_container(RWConflictData, inLink, iter.cur);
 				const SERIALIZABLEXACT *t0 = conflict->sxactOut;
 
 				if (!SxactIsDoomed(t0)
@@ -4664,7 +4664,7 @@ PreCommit_CheckForSerializationFailure(void)
 	dlist_foreach(near_iter, &MySerializableXact->inConflicts)
 	{
 		RWConflict	nearConflict =
-		dlist_container(RWConflictData, inLink, near_iter.cur);
+			dlist_container(RWConflictData, inLink, near_iter.cur);
 
 		if (!SxactIsCommitted(nearConflict->sxactOut)
 			&& !SxactIsDoomed(nearConflict->sxactOut))
@@ -4674,7 +4674,7 @@ PreCommit_CheckForSerializationFailure(void)
 			dlist_foreach(far_iter, &nearConflict->sxactOut->inConflicts)
 			{
 				RWConflict	farConflict =
-				dlist_container(RWConflictData, inLink, far_iter.cur);
+					dlist_container(RWConflictData, inLink, far_iter.cur);
 
 				if (farConflict->sxactOut == MySerializableXact
 					|| (!SxactIsCommitted(farConflict->sxactOut)
@@ -4770,7 +4770,7 @@ AtPrepare_PredicateLocks(void)
 	dlist_foreach(iter, &sxact->predicateLocks)
 	{
 		PREDICATELOCK *predlock =
-		dlist_container(PREDICATELOCK, xactLink, iter.cur);
+			dlist_container(PREDICATELOCK, xactLink, iter.cur);
 
 		record.type = TWOPHASEPREDICATERECORD_LOCK;
 		lockRecord->target = predlock->tag.myTarget->tag;

src/backend/storage/lmgr/proc.c

@@ -101,7 +101,7 @@ ProcGlobalShmemSize(void)
 {
 	Size		size = 0;
 	Size		TotalProcs =
-	add_size(MaxBackends, add_size(NUM_AUXILIARY_PROCS, max_prepared_xacts));
+		add_size(MaxBackends, add_size(NUM_AUXILIARY_PROCS, max_prepared_xacts));
 
 	/* ProcGlobal */
 	size = add_size(size, sizeof(PROC_HDR));
@@ -331,7 +331,7 @@ InitProcess(void)
 
 	if (!dlist_is_empty(procgloballist))
 	{
-		MyProc = (PGPROC*) dlist_pop_head_node(procgloballist);
+		MyProc = (PGPROC *) dlist_pop_head_node(procgloballist);
 		SpinLockRelease(ProcStructLock);
 	}
 	else
@@ -1009,7 +1009,7 @@ ProcSleep(LOCALLOCK *locallock, LockMethod lockMethodTable)
 	uint32		hashcode = locallock->hashcode;
 	LWLock	   *partitionLock = LockHashPartitionLock(hashcode);
 	dclist_head *waitQueue = &lock->waitProcs;
-	PGPROC     *insert_before = NULL;
+	PGPROC	   *insert_before = NULL;
 	LOCKMASK	myHeldLocks = MyProc->heldLocks;
 	TimestampTz standbyWaitStart = 0;
 	bool		early_deadlock = false;
@@ -1244,7 +1244,7 @@ ProcSleep(LOCALLOCK *locallock, LockMethod lockMethodTable)
 		if (InHotStandby)
 		{
 			bool		maybe_log_conflict =
-			(standbyWaitStart != 0 && !logged_recovery_conflict);
+				(standbyWaitStart != 0 && !logged_recovery_conflict);
 
 			/* Set a timer and wait for that or for the lock to be granted */
 			ResolveRecoveryConflictWithLock(locallock->tag.lock,

src/backend/storage/smgr/md.c

@@ -549,7 +549,7 @@ mdzeroextend(SMgrRelation reln, ForkNumber forknum,
 
 	while (remblocks > 0)
 	{
-		BlockNumber	segstartblock = curblocknum % ((BlockNumber) RELSEG_SIZE);
+		BlockNumber segstartblock = curblocknum % ((BlockNumber) RELSEG_SIZE);
 		off_t		seekpos = (off_t) BLCKSZ * segstartblock;
 		int			numblocks;
 
@@ -597,9 +597,9 @@ mdzeroextend(SMgrRelation reln, ForkNumber forknum,
 			/*
 			 * Even if we don't want to use fallocate, we can still extend a
 			 * bit more efficiently than writing each 8kB block individually.
-			 * pg_pwrite_zeros() (via FileZero()) uses
-			 * pg_pwritev_with_retry() to avoid multiple writes or needing a
-			 * zeroed buffer for the whole length of the extension.
+			 * pg_pwrite_zeros() (via FileZero()) uses pg_pwritev_with_retry()
+			 * to avoid multiple writes or needing a zeroed buffer for the
+			 * whole length of the extension.
 			 */
 			ret = FileZero(v->mdfd_vfd,
 						   seekpos, (off_t) BLCKSZ * numblocks,