Fix many typos and inconsistencies

michaelpq · michaelpq · commit c74d49d41c9e · 2019-07-01T10:00:23.000+09:00
Author: Alexander Lakhin Discussion: https://postgr.es/m/af27d1b3-a128-9d62-46e0-88f424397f44@gmail.com
diff --git a/contrib/bloom/blutils.c b/contrib/bloom/blutils.c
@@ -341,7 +341,7 @@ BloomPageAddItem(BloomState *state, Page page, BloomTuple *tuple)
 /*
  * Allocate a new page (either by recycling, or by extending the index file)
  * The returned buffer is already pinned and exclusive-locked
- * Caller is responsible for initializing the page by calling BloomInitBuffer
+ * Caller is responsible for initializing the page by calling BloomInitPage
  */
 Buffer
 BloomNewBuffer(Relation index)
diff --git a/contrib/intarray/_int_selfuncs.c b/contrib/intarray/_int_selfuncs.c
@@ -43,7 +43,7 @@ static int	compare_val_int4(const void *a, const void *b);
  *
  * The default array selectivity operators for the @>, && and @< operators
  * work fine for integer arrays. However, if we tried to just use arraycontsel
- * and arracontjoinsel directly as the cost estimator functions for our
+ * and arraycontjoinsel directly as the cost estimator functions for our
  * operators, they would not work as intended, because they look at the
  * operator's OID. Our operators behave exactly like the built-in anyarray
  * versions, but we must tell the cost estimator functions which built-in
diff --git a/contrib/pg_trgm/trgm_regexp.c b/contrib/pg_trgm/trgm_regexp.c
@@ -441,9 +441,9 @@ typedef struct
 struct TrgmPackedGraph
 {
 	/*
-	 * colorTrigramsCount and colorTrigramsGroups contain information about
-	 * how trigrams are grouped into color trigrams.  "colorTrigramsCount" is
-	 * the count of color trigrams and "colorTrigramGroups" contains number of
+	 * colorTrigramsCount and colorTrigramGroups contain information about how
+	 * trigrams are grouped into color trigrams.  "colorTrigramsCount" is the
+	 * count of color trigrams and "colorTrigramGroups" contains number of
 	 * simple trigrams for each color trigram.  The array of simple trigrams
 	 * (stored separately from this struct) is ordered so that the simple
 	 * trigrams for each color trigram are consecutive, and they're in order
diff --git a/contrib/pgcrypto/crypt-des.c b/contrib/pgcrypto/crypt-des.c
@@ -11,7 +11,7 @@
  *	binaries of libcrypt exportable from the USA
  *
  * Adapted for FreeBSD-4.0 by Mark R V Murray
- *	this file should now *only* export crypt_des(), in order to make
+ *	this file should now *only* export px_crypt_des(), in order to make
  *	a module that can be optionally included in libcrypt.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/contrib/postgres_fdw/expected/postgres_fdw.out b/contrib/postgres_fdw/expected/postgres_fdw.out
@@ -665,7 +665,7 @@ EXPLAIN (VERBOSE, COSTS OFF) SELECT * FROM ft1 t1 WHERE c1 = ANY(ARRAY[c2, 1, c1
    Remote SQL: SELECT "C 1", c2, c3, c4, c5, c6, c7, c8 FROM "S 1"."T 1" WHERE (("C 1" = ANY (ARRAY[c2, 1, ("C 1" + 0)])))
 (3 rows)
 
-EXPLAIN (VERBOSE, COSTS OFF) SELECT * FROM ft1 t1 WHERE c1 = (ARRAY[c1,c2,3])[1]; -- ArrayRef
+EXPLAIN (VERBOSE, COSTS OFF) SELECT * FROM ft1 t1 WHERE c1 = (ARRAY[c1,c2,3])[1]; -- SubscriptingRef
                                                       QUERY PLAN                                                      
 ----------------------------------------------------------------------------------------------------------------------
  Foreign Scan on public.ft1 t1
diff --git a/contrib/postgres_fdw/sql/postgres_fdw.sql b/contrib/postgres_fdw/sql/postgres_fdw.sql
@@ -297,7 +297,7 @@ EXPLAIN (VERBOSE, COSTS OFF) SELECT * FROM ft1 t1 WHERE c1 = -c1;          -- Op
 EXPLAIN (VERBOSE, COSTS OFF) SELECT * FROM ft1 t1 WHERE 1 = c1!;           -- OpExpr(r)
 EXPLAIN (VERBOSE, COSTS OFF) SELECT * FROM ft1 t1 WHERE (c1 IS NOT NULL) IS DISTINCT FROM (c1 IS NOT NULL); -- DistinctExpr
 EXPLAIN (VERBOSE, COSTS OFF) SELECT * FROM ft1 t1 WHERE c1 = ANY(ARRAY[c2, 1, c1 + 0]); -- ScalarArrayOpExpr
-EXPLAIN (VERBOSE, COSTS OFF) SELECT * FROM ft1 t1 WHERE c1 = (ARRAY[c1,c2,3])[1]; -- ArrayRef
+EXPLAIN (VERBOSE, COSTS OFF) SELECT * FROM ft1 t1 WHERE c1 = (ARRAY[c1,c2,3])[1]; -- SubscriptingRef
 EXPLAIN (VERBOSE, COSTS OFF) SELECT * FROM ft1 t1 WHERE c6 = E'foo''s\\bar';  -- check special chars
 EXPLAIN (VERBOSE, COSTS OFF) SELECT * FROM ft1 t1 WHERE c8 = 'foo';  -- can't be sent to remote
 -- parameterized remote path for foreign table
diff --git a/doc/src/sgml/diskusage.sgml b/doc/src/sgml/diskusage.sgml
@@ -87,9 +87,9 @@ WHERE c.relname = 'customer' AND
       c2.oid = i.indexrelid
 ORDER BY c2.relname;
 
-       relname        | relpages
-----------------------+----------
- customer_id_indexdex |       26
+      relname      | relpages
+-------------------+----------
+ customer_id_index |       26
 </programlisting>
   </para>
 
diff --git a/src/backend/access/brin/brin_tuple.c b/src/backend/access/brin/brin_tuple.c
@@ -1,5 +1,5 @@
 /*
- * brin_tuples.c
+ * brin_tuple.c
  *		Method implementations for tuples in BRIN indexes.
  *
  * Intended usage is that code outside this file only deals with
@@ -207,7 +207,7 @@ brin_form_tuple(BrinDesc *brdesc, BlockNumber blkno, BrinMemTuple *tuple,
 		/*
 		 * Note that we reverse the sense of null bits in this module: we
 		 * store a 1 for a null attribute rather than a 0.  So we must reverse
-		 * the sense of the att_isnull test in br_deconstruct_tuple as well.
+		 * the sense of the att_isnull test in brin_deconstruct_tuple as well.
 		 */
 		bitP = ((bits8 *) ((char *) rettuple + SizeOfBrinTuple)) - 1;
 		bitmask = HIGHBIT;
diff --git a/src/backend/access/nbtree/nbtree.c b/src/backend/access/nbtree/nbtree.c
@@ -621,8 +621,8 @@ btparallelrescan(IndexScanDesc scan)
 
 /*
  * _bt_parallel_seize() -- Begin the process of advancing the scan to a new
- *		page.  Other scans must wait until we call bt_parallel_release() or
- *		bt_parallel_done().
+ *		page.  Other scans must wait until we call _bt_parallel_release()
+ *		or _bt_parallel_done().
  *
  * The return value is true if we successfully seized the scan and false
  * if we did not.  The latter case occurs if no pages remain for the current
diff --git a/src/backend/access/nbtree/nbtxlog.c b/src/backend/access/nbtree/nbtxlog.c
@@ -181,7 +181,7 @@ btree_xlog_insert(bool isleaf, bool ismeta, XLogReaderState *record)
 
 		if (PageAddItem(page, (Item) datapos, datalen, xlrec->offnum,
 						false, false) == InvalidOffsetNumber)
-			elog(PANIC, "btree_insert_redo: failed to add item");
+			elog(PANIC, "btree_xlog_insert: failed to add item");
 
 		PageSetLSN(page, lsn);
 		MarkBufferDirty(buffer);
diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
@@ -1588,9 +1588,8 @@ RemoveAttributeById(Oid relid, AttrNumber attnum)
 	/*
 	 * Grab an exclusive lock on the target table, which we will NOT release
 	 * until end of transaction.  (In the simple case where we are directly
-	 * dropping this column, AlterTableDropColumn already did this ... but
-	 * when cascading from a drop of some other object, we may not have any
-	 * lock.)
+	 * dropping this column, ATExecDropColumn already did this ... but when
+	 * cascading from a drop of some other object, we may not have any lock.)
 	 */
 	rel = relation_open(relid, AccessExclusiveLock);
 
diff --git a/src/backend/executor/execExpr.c b/src/backend/executor/execExpr.c
@@ -1200,12 +1200,12 @@ ExecInitExprRec(Expr *node, ExprState *state,
 					 * field's values[]/nulls[] entries as both the caseval
 					 * source and the result address for this subexpression.
 					 * That's okay only because (1) both FieldStore and
-					 * ArrayRef evaluate their arg or refexpr inputs first,
-					 * and (2) any such CaseTestExpr is directly the arg or
-					 * refexpr input.  So any read of the caseval will occur
-					 * before there's a chance to overwrite it.  Also, if
-					 * multiple entries in the newvals/fieldnums lists target
-					 * the same field, they'll effectively be applied
+					 * SubscriptingRef evaluate their arg or refexpr inputs
+					 * first, and (2) any such CaseTestExpr is directly the
+					 * arg or refexpr input.  So any read of the caseval will
+					 * occur before there's a chance to overwrite it.  Also,
+					 * if multiple entries in the newvals/fieldnums lists
+					 * target the same field, they'll effectively be applied
 					 * left-to-right which is what we want.
 					 */
 					save_innermost_caseval = state->innermost_caseval;
diff --git a/src/backend/libpq/be-fsstubs.c b/src/backend/libpq/be-fsstubs.c
@@ -62,7 +62,7 @@
  * A non-null entry is a pointer to a LargeObjectDesc allocated in the
  * LO private memory context "fscxt".  The cookies array itself is also
  * dynamically allocated in that context.  Its current allocated size is
- * cookies_len entries, of which any unused entries will be NULL.
+ * cookies_size entries, of which any unused entries will be NULL.
  */
 static LargeObjectDesc **cookies = NULL;
 static int	cookies_size = 0;
diff --git a/src/backend/nodes/tidbitmap.c b/src/backend/nodes/tidbitmap.c
@@ -934,7 +934,7 @@ tbm_extract_page_tuple(PagetableEntry *page, TBMIterateResult *output)
 }
 
 /*
- *	tbm_advance_schunkbit - Advance the chunkbit
+ *	tbm_advance_schunkbit - Advance the schunkbit
  */
 static inline void
 tbm_advance_schunkbit(PagetableEntry *chunk, int *schunkbitp)
diff --git a/src/backend/optimizer/path/equivclass.c b/src/backend/optimizer/path/equivclass.c
@@ -929,11 +929,10 @@ generate_base_implied_equalities_no_const(PlannerInfo *root,
 	/*
 	 * We scan the EC members once and track the last-seen member for each
 	 * base relation.  When we see another member of the same base relation,
-	 * we generate "prev_mem = cur_mem".  This results in the minimum number
-	 * of derived clauses, but it's possible that it will fail when a
-	 * different ordering would succeed.  XXX FIXME: use a UNION-FIND
-	 * algorithm similar to the way we build merged ECs.  (Use a list-of-lists
-	 * for each rel.)
+	 * we generate "prev_em = cur_em".  This results in the minimum number of
+	 * derived clauses, but it's possible that it will fail when a different
+	 * ordering would succeed.  XXX FIXME: use a UNION-FIND algorithm similar
+	 * to the way we build merged ECs.  (Use a list-of-lists for each rel.)
 	 */
 	prev_ems = (EquivalenceMember **)
 		palloc0(root->simple_rel_array_size * sizeof(EquivalenceMember *));
diff --git a/src/backend/optimizer/plan/createplan.c b/src/backend/optimizer/plan/createplan.c
@@ -3911,7 +3911,7 @@ create_foreignscan_plan(PlannerInfo *root, ForeignPath *best_path,
 }
 
 /*
- * create_custom_plan
+ * create_customscan_plan
  *
  * Transform a CustomPath into a Plan.
  */
diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c
@@ -3409,10 +3409,10 @@ eval_const_expressions_mutator(Node *node,
 			{
 				/*
 				 * This case could be folded into the generic handling used
-				 * for ArrayRef etc.  But because the simplification logic is
-				 * so trivial, applying evaluate_expr() to perform it would be
-				 * a heavy overhead.  BooleanTest is probably common enough to
-				 * justify keeping this bespoke implementation.
+				 * for SubscriptingRef etc.  But because the simplification
+				 * logic is so trivial, applying evaluate_expr() to perform it
+				 * would be a heavy overhead.  BooleanTest is probably common
+				 * enough to justify keeping this bespoke implementation.
 				 */
 				BooleanTest *btest = (BooleanTest *) node;
 				BooleanTest *newbtest;
diff --git a/src/backend/parser/analyze.c b/src/backend/parser/analyze.c
@@ -2082,7 +2082,7 @@ transformSetOperationTree(ParseState *pstate, SelectStmt *stmt,
 			 * Select common collation.  A common collation is required for
 			 * all set operators except UNION ALL; see SQL:2008 7.13 <query
 			 * expression> Syntax Rule 15c.  (If we fail to identify a common
-			 * collation for a UNION ALL column, the curCollations element
+			 * collation for a UNION ALL column, the colCollations element
 			 * will be set to InvalidOid, which may result in a runtime error
 			 * if something at a higher query level wants to use the column's
 			 * collation.)
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
@@ -12542,7 +12542,7 @@ SimpleTypename:
  * Note that ConstInterval is not included here since it must
  * be pushed up higher in the rules to accommodate the postfix
  * options (e.g. INTERVAL '1' YEAR). Likewise, we have to handle
- * the generic-type-name case in AExprConst to avoid premature
+ * the generic-type-name case in AexprConst to avoid premature
  * reduce/reduce conflicts against function names.
  */
 ConstTypename:
diff --git a/src/backend/parser/parse_target.c b/src/backend/parser/parse_target.c
@@ -695,9 +695,9 @@ transformAssignmentIndirection(ParseState *pstate,
 		/*
 		 * Set up a substitution.  We abuse CaseTestExpr for this.  It's safe
 		 * to do so because the only nodes that will be above the CaseTestExpr
-		 * in the finished expression will be FieldStore and ArrayRef nodes.
-		 * (There could be other stuff in the tree, but it will be within
-		 * other child fields of those node types.)
+		 * in the finished expression will be FieldStore and SubscriptingRef
+		 * nodes. (There could be other stuff in the tree, but it will be
+		 * within other child fields of those node types.)
 		 */
 		CaseTestExpr *ctest = makeNode(CaseTestExpr);
 
diff --git a/src/backend/postmaster/bgworker.c b/src/backend/postmaster/bgworker.c
@@ -525,7 +525,7 @@ ResetBackgroundWorkerCrashTimes(void)
 		if (rw->rw_worker.bgw_restart_time == BGW_NEVER_RESTART)
 		{
 			/*
-			 * Workers marked BGW_NVER_RESTART shouldn't get relaunched after
+			 * Workers marked BGW_NEVER_RESTART shouldn't get relaunched after
 			 * the crash, so forget about them.  (If we wait until after the
 			 * crash to forget about them, and they are parallel workers,
 			 * parallel_terminate_count will get incremented after we've
diff --git a/src/backend/replication/logical/logical.c b/src/backend/replication/logical/logical.c
@@ -114,7 +114,7 @@ CheckLogicalDecodingRequirements(void)
 }
 
 /*
- * Helper function for CreateInitialDecodingContext() and
+ * Helper function for CreateInitDecodingContext() and
  * CreateDecodingContext() performing common tasks.
  */
 static LogicalDecodingContext *
diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c
@@ -1334,7 +1334,9 @@ SaveSlotToPath(ReplicationSlot *slot, const char *dir, int elevel)
 		return;
 	}
 
-	/* Check CreateSlot() for the reasoning of using a crit. section. */
+	/*
+	 * Check CreateSlotOnDisk() for the reasoning of using a critical section.
+	 */
 	START_CRIT_SECTION();
 
 	fsync_fname(path, false);
diff --git a/src/backend/rewrite/rewriteHandler.c b/src/backend/rewrite/rewriteHandler.c
@@ -980,11 +980,11 @@ process_matched_tle(TargetEntry *src_tle,
 	 *
 	 * As a further complication, the destination column might be a domain,
 	 * resulting in each assignment containing a CoerceToDomain node over a
-	 * FieldStore or ArrayRef.  These should have matching target domains,
-	 * so we strip them and reconstitute a single CoerceToDomain over the
-	 * combined FieldStore/ArrayRef nodes.  (Notice that this has the result
-	 * that the domain's checks are applied only after we do all the field or
-	 * element updates, not after each one.  This is arguably desirable.)
+	 * FieldStore or SubscriptingRef.  These should have matching target
+	 * domains, so we strip them and reconstitute a single CoerceToDomain over
+	 * the combined FieldStore/SubscriptingRef nodes.  (Notice that this has the
+	 * result that the domain's checks are applied only after we do all the
+	 * field or element updates, not after each one.  This is arguably desirable.)
 	 *----------
 	 */
 	src_expr = (Node *) src_tle->expr;
diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c
@@ -220,7 +220,7 @@ StrategyGetBuffer(BufferAccessStrategy strategy, uint32 *buf_state)
 	 * If asked, we need to waken the bgwriter. Since we don't want to rely on
 	 * a spinlock for this we force a read from shared memory once, and then
 	 * set the latch based on that value. We need to go through that length
-	 * because otherwise bgprocno might be reset while/after we check because
+	 * because otherwise bgwprocno might be reset while/after we check because
 	 * the compiler might just reread from memory.
 	 *
 	 * This can possibly set the latch of the wrong process if the bgwriter
diff --git a/src/backend/storage/buffer/localbuf.c b/src/backend/storage/buffer/localbuf.c
@@ -537,7 +537,7 @@ GetLocalBufferStorage(void)
 /*
  * CheckForLocalBufferLeaks - ensure this backend holds no local buffer pins
  *
- * This is just like CheckBufferLeaks(), but for local buffers.
+ * This is just like CheckForBufferLeaks(), but for local buffers.
  */
 static void
 CheckForLocalBufferLeaks(void)
diff --git a/src/backend/storage/ipc/barrier.c b/src/backend/storage/ipc/barrier.c
@@ -226,9 +226,9 @@ BarrierAttach(Barrier *barrier)
 }
 
 /*
- * Detach from a barrier.  This may release other waiters from BarrierWait and
- * advance the phase if they were only waiting for this backend.  Return true
- * if this participant was the last to detach.
+ * Detach from a barrier.  This may release other waiters from
+ * BarrierArriveAndWait() and advance the phase if they were only waiting for
+ * this backend.  Return true if this participant was the last to detach.
  */
 bool
 BarrierDetach(Barrier *barrier)
diff --git a/src/backend/utils/Gen_dummy_probes.pl b/src/backend/utils/Gen_dummy_probes.pl
@@ -14,7 +14,7 @@
 #
 #-------------------------------------------------------------------------
 
-# turn off perlcritic for autogened code
+# turn off perlcritic for autogenerated code
 ## no critic
 
 $0 =~ s/^.*?(\w+)[\.\w+]*$/$1/;
diff --git a/src/backend/utils/adt/arrayfuncs.c b/src/backend/utils/adt/arrayfuncs.c
@@ -1322,7 +1322,7 @@ array_recv(PG_FUNCTION_ARGS)
 		lBound[i] = pq_getmsgint(buf, 4);
 
 		/*
-		 * Check overflow of upper bound. (ArrayNItems() below checks that
+		 * Check overflow of upper bound. (ArrayGetNItems() below checks that
 		 * dim[i] >= 0)
 		 */
 		if (dim[i] != 0)
diff --git a/src/backend/utils/adt/date.c b/src/backend/utils/adt/date.c
@@ -1374,7 +1374,7 @@ time_scale(PG_FUNCTION_ARGS)
 
 /* AdjustTimeForTypmod()
  * Force the precision of the time value to a specified value.
- * Uses *exactly* the same code as in AdjustTimestampForTypemod()
+ * Uses *exactly* the same code as in AdjustTimestampForTypmod()
  * but we make a separate copy because those types do not
  * have a fundamental tie together but rather a coincidence of
  * implementation. - thomas
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
@@ -3029,7 +3029,7 @@ DecodeSpecial(int field, char *lowtoken, int *val)
 }
 
 
-/* ClearPgTM
+/* ClearPgTm
  *
  * Zero out a pg_tm and associated fsec_t
  */
diff --git a/src/backend/utils/adt/oracle_compat.c b/src/backend/utils/adt/oracle_compat.c
@@ -527,7 +527,7 @@ dotrim(const char *string, int stringlen,
  *
  * Syntax:
  *
- *	 bytea byteatrim(byta string, bytea set)
+ *	 bytea byteatrim(bytea string, bytea set)
  *
  * Purpose:
  *
diff --git a/src/backend/utils/cache/plancache.c b/src/backend/utils/cache/plancache.c
@@ -504,7 +504,7 @@ DropCachedPlan(CachedPlanSource *plansource)
 		plansource->is_saved = false;
 	}
 
-	/* Decrement generic CachePlan's refcount and drop if no longer needed */
+	/* Decrement generic CachedPlan's refcount and drop if no longer needed */
 	ReleaseGenericPlan(plansource);
 
 	/* Mark it no longer valid */
diff --git a/src/backend/utils/mmgr/dsa.c b/src/backend/utils/mmgr/dsa.c
@@ -2258,7 +2258,7 @@ check_for_freed_segments(dsa_area *area)
 }
 
 /*
- * Workhorse for check_for_free_segments(), and also used directly in path
+ * Workhorse for check_for_freed_segments(), and also used directly in path
  * where the area lock is already held.  This should be called after acquiring
  * the lock but before looking up any segment by index number, to make sure we
  * unmap any stale segments that might have previously had the same index as a
diff --git a/src/backend/utils/mmgr/freepage.c b/src/backend/utils/mmgr/freepage.c
@@ -231,7 +231,7 @@ FreePageManagerGet(FreePageManager *fpm, Size npages, Size *first_page)
 
 	/*
 	 * FreePageManagerGetInternal may have set contiguous_pages_dirty.
-	 * Recompute contigous_pages if so.
+	 * Recompute contiguous_pages if so.
 	 */
 	FreePageManagerUpdateLargest(fpm);
 
diff --git a/src/include/access/attnum.h b/src/include/access/attnum.h
@@ -55,7 +55,7 @@ typedef int16 AttrNumber;
 )
 
 /*
- * AttributeOffsetGetAttributeNumber
+ * AttrOffsetGetAttrNumber
  *		Returns the attribute number for an attribute offset.
  */
 #define AttrOffsetGetAttrNumber(attributeOffset) \
diff --git a/src/include/access/hash.h b/src/include/access/hash.h
@@ -457,7 +457,7 @@ extern void hashbucketcleanup(Relation rel, Bucket cur_bucket,
 							  BufferAccessStrategy bstrategy,
 							  uint32 maxbucket, uint32 highmask, uint32 lowmask,
 							  double *tuples_removed, double *num_index_tuples,
-							  bool bucket_has_garbage,
+							  bool split_cleanup,
 							  IndexBulkDeleteCallback callback, void *callback_state);
 
 #endif							/* HASH_H */
diff --git a/src/include/commands/event_trigger.h b/src/include/commands/event_trigger.h
diff --git a/src/include/commands/extension.h b/src/include/commands/extension.h
diff --git a/src/include/executor/nodeCustom.h b/src/include/executor/nodeCustom.h
diff --git a/src/include/funcapi.h b/src/include/funcapi.h
diff --git a/src/include/nodes/primnodes.h b/src/include/nodes/primnodes.h
diff --git a/src/include/optimizer/cost.h b/src/include/optimizer/cost.h
diff --git a/src/include/optimizer/pathnode.h b/src/include/optimizer/pathnode.h
diff --git a/src/include/storage/fd.h b/src/include/storage/fd.h
diff --git a/src/include/storage/proc.h b/src/include/storage/proc.h
diff --git a/src/include/tcop/tcopprot.h b/src/include/tcop/tcopprot.h
diff --git a/src/include/utils/inval.h b/src/include/utils/inval.h
diff --git a/src/include/utils/sortsupport.h b/src/include/utils/sortsupport.h
diff --git a/src/interfaces/libpq/fe-auth.c b/src/interfaces/libpq/fe-auth.c

Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ static int compare_val_int4(const void a, const void b);`
`43`	`43`	`*`
`44`	`44`	`* The default array selectivity operators for the @>, && and @< operators`
`45`	`45`	`* work fine for integer arrays. However, if we tried to just use arraycontsel`
`46`		`- * and arracontjoinsel directly as the cost estimator functions for our`
	`46`	`+ * and arraycontjoinsel directly as the cost estimator functions for our`
`47`	`47`	`* operators, they would not work as intended, because they look at the`
`48`	`48`	`* operator's OID. Our operators behave exactly like the built-in anyarray`
`49`	`49`	`* versions, but we must tell the cost estimator functions which built-in`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@`
`11`	`11`	`* binaries of libcrypt exportable from the USA`
`12`	`12`	`*`
`13`	`13`	`* Adapted for FreeBSD-4.0 by Mark R V Murray`
`14`		`- * this file should now only export crypt_des(), in order to make`
	`14`	`+ * this file should now only export px_crypt_des(), in order to make`
`15`	`15`	`* a module that can be optionally included in libcrypt.`
`16`	`16`	`*`
`17`	`17`	`* Redistribution and use in source and binary forms, with or without`
Original file line number	Diff line number	Diff line change
`@@ -934,7 +934,7 @@ tbm_extract_page_tuple(PagetableEntry page, TBMIterateResult output)`
`934`	`934`	`}`
`935`	`935`
`936`	`936`	`/*`
`937`		`- * tbm_advance_schunkbit - Advance the chunkbit`
	`937`	`+ * tbm_advance_schunkbit - Advance the schunkbit`
`938`	`938`	`*/`
`939`	`939`	`static inline void`
`940`	`940`	`tbm_advance_schunkbit(PagetableEntry chunk, int schunkbitp)`
Original file line number	Diff line number	Diff line change
`@@ -3911,7 +3911,7 @@ create_foreignscan_plan(PlannerInfo root, ForeignPath best_path,`
`3911`	`3911`	`}`
`3912`	`3912`
`3913`	`3913`	`/*`
`3914`		`- * create_custom_plan`
	`3914`	`+ * create_customscan_plan`
`3915`	`3915`	`*`
`3916`	`3916`	`* Transform a CustomPath into a Plan.`
`3917`	`3917`	`*/`
Original file line number	Diff line number	Diff line change
`@@ -525,7 +525,7 @@ ResetBackgroundWorkerCrashTimes(void)`
`525`	`525`	`if (rw->rw_worker.bgw_restart_time == BGW_NEVER_RESTART)`
`526`	`526`	`{`
`527`	`527`	`/*`
`528`		`- * Workers marked BGW_NVER_RESTART shouldn't get relaunched after`
	`528`	`+ * Workers marked BGW_NEVER_RESTART shouldn't get relaunched after`
`529`	`529`	`* the crash, so forget about them. (If we wait until after the`
`530`	`530`	`* crash to forget about them, and they are parallel workers,`
`531`	`531`	`* parallel_terminate_count will get incremented after we've`
Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ CheckLogicalDecodingRequirements(void)`
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`/*`
`117`		`- * Helper function for CreateInitialDecodingContext() and`
	`117`	`+ * Helper function for CreateInitDecodingContext() and`
`118`	`118`	`* CreateDecodingContext() performing common tasks.`
`119`	`119`	`*/`
`120`	`120`	`static LogicalDecodingContext *`
Original file line number	Diff line number	Diff line change
`@@ -1334,7 +1334,9 @@ SaveSlotToPath(ReplicationSlot slot, const char dir, int elevel)`
`1334`	`1334`	`return;`
`1335`	`1335`	`}`
`1336`	`1336`
`1337`		`- /* Check CreateSlot() for the reasoning of using a crit. section. */`
	`1337`	`+ /*`
	`1338`	`+ * Check CreateSlotOnDisk() for the reasoning of using a critical section.`
	`1339`	`+ */`
`1338`	`1340`	`START_CRIT_SECTION();`
`1339`	`1341`
`1340`	`1342`	`fsync_fname(path, false);`
Original file line number	Diff line number	Diff line change
`@@ -220,7 +220,7 @@ StrategyGetBuffer(BufferAccessStrategy strategy, uint32 *buf_state)`
`220`	`220`	`* If asked, we need to waken the bgwriter. Since we don't want to rely on`
`221`	`221`	`* a spinlock for this we force a read from shared memory once, and then`
`222`	`222`	`* set the latch based on that value. We need to go through that length`
`223`		`- * because otherwise bgprocno might be reset while/after we check because`
	`223`	`+ * because otherwise bgwprocno might be reset while/after we check because`
`224`	`224`	`* the compiler might just reread from memory.`
`225`	`225`	`*`
`226`	`226`	`* This can possibly set the latch of the wrong process if the bgwriter`
Original file line number	Diff line number	Diff line change
`@@ -537,7 +537,7 @@ GetLocalBufferStorage(void)`
`537`	`537`	`/*`
`538`	`538`	`* CheckForLocalBufferLeaks - ensure this backend holds no local buffer pins`
`539`	`539`	`*`
`540`		`- * This is just like CheckBufferLeaks(), but for local buffers.`
	`540`	`+ * This is just like CheckForBufferLeaks(), but for local buffers.`
`541`	`541`	`*/`
`542`	`542`	`static void`
`543`	`543`	`CheckForLocalBufferLeaks(void)`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@`
`14`	`14`	`#`
`15`	`15`	`#-------------------------------------------------------------------------`
`16`	`16`
`17`		`-# turn off perlcritic for autogened code`
	`17`	`+# turn off perlcritic for autogenerated code`
`18`	`18`	`## no critic`
`19`	`19`
`20`	`20`	`$0 =~ s/^.?(\w+)[\.\w+]$/$1/;`