Verify spelling fixes pass check-spelling

Author: jsoref

CODING_STANDARDS.md

@@ -3,7 +3,7 @@
 This file lists several standards that any programmer adding or changing code in
 PHP should follow. Since this file was added at a very late stage of the
 development of PHP v3.0, the code base does not fully follow it, but new
-features are going in that general direction. Many sections have been recoded to
+features are going in that general direction. Many sections have been rewritten to
 use these rules.
 
 ## Code implementation

NEWS

@@ -41,7 +41,7 @@ PHP                                                                        NEWS
 - MySQLnd:
   . Fixed bug #80761 (PDO uses too much memory). (Nikita)
 
-- Opcache:
+- OPcache:
   . Added inheritance cache. (Dmitry)
 
 - OpenSSL:

TSRM/tsrm_win32.c

@@ -254,7 +254,7 @@ TSRM_API int tsrm_win32_access(const char *pathname, int mode)
 		goto Finished;
 	}
 
-	/* Different identity, we need a new impersontated token as well */
+	/* Different identity, we need a new impersonated token as well */
 	if (!TWG(impersonation_token_sid) || !EqualSid(token_sid, TWG(impersonation_token_sid))) {
 		if (TWG(impersonation_token_sid)) {
 			free(TWG(impersonation_token_sid));

UPGRADING

@@ -113,12 +113,12 @@ PHP 8.1 UPGRADE NOTES
 - PDO SQLite:
   . Integers and floats in results sets will now be returned using native PHP
     types. You can restore the previous behavior by enabling the
-    PDO::ATTR_STRINGFIY_FETCHES option.
+    PDO::ATTR_STRINGIFY_FETCHES option.
 
 - Standard:
   . version_compare() no longer accepts undocumented operator abbreviations.
   . htmlspecialchars(), htmlentities(), htmlspecialchars_decode(),
-    html_entitity_decode() and get_html_translation_table() now use
+    html_entity_decode() and get_html_translation_table() now use
     ENT_QUOTES | ENT_SUBSTITUTE rather than ENT_COMPAT by default. This means
     that ' is escaped to ' while previously it was left alone.
     Additionally, malformed UTF-8 will be replaced by a Unicode substitution
@@ -187,7 +187,7 @@ PHP 8.1 UPGRADE NOTES
     echo $h, "\n";
     ```
 
-    A valid seed value is within the range from 0 to the plaform defined UINT_MAX, usually 4294967295.
+    A valid seed value is within the range from 0 to the platform defined UINT_MAX, usually 4294967295.
 
   . Added xxHash. The implementation brings in the following arguments
 
@@ -262,7 +262,7 @@ PHP 8.1 UPGRADE NOTES
     etc. was changed. Now properties are naturally ordered according to their
     declaration and inheritance. Properties declared in a base class are going
     to be before the child properties. This order is consistent with internal
-    layout of properies in zend_objct structure and repeats the order in
+    layout of properties in zend_object structure and repeats the order in
     default_properties_table[] and properties_info_table[]. The old order was
     not documented and was caused by class inheritance implementation details.
 

Zend/Optimizer/block_pass.c

@@ -1458,7 +1458,7 @@ static void zend_jmp_optimization(zend_basic_block *block, zend_op_array *op_arr
 					/*       is not used on the following path and             */
 					/*       should be used once on the branch path.           */
 					/*                                                         */
-					/*       The pattern works well only if jums processed in  */
+					/*       The pattern works well only if jumps processed in  */
 					/*       direct order, otherwise it breaks JMPZ_EX         */
 					/*       sequences too early.                              */
 					last_op->result.var = target->result.var;

Zend/Optimizer/dce.c

@@ -527,7 +527,7 @@ int dce_optimize_op_array(zend_op_array *op_array, zend_ssa *ssa, bool reorder_d
 	ctx.phi_dead = alloca(sizeof(zend_ulong) * ctx.phi_worklist_len);
 	memset(ctx.phi_dead, 0xff, sizeof(zend_ulong) * ctx.phi_worklist_len);
 
-	/* Mark reacable instruction without side effects as dead */
+	/* Mark reachable instruction without side effects as dead */
 	int b = ssa->cfg.blocks_count;
 	while (b > 0) {
 		int	op_data = -1;

Zend/Optimizer/pass1.c

@@ -111,7 +111,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx)
 				 || opline->extended_value == ZEND_DIV
 				 || opline->extended_value == ZEND_POW) {
 					if (Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) {
-						/* don't optimise if it should produce a runtime numeric string error */
+						/* don't optimize if it should produce a runtime numeric string error */
 						if (is_numeric_string(Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)), NULL, NULL, 0)) {
 							convert_scalar_to_number(&ZEND_OP2_LITERAL(opline));
 						}
@@ -120,7 +120,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx)
 				 || opline->extended_value == ZEND_SL
 				 || opline->extended_value == ZEND_SR) {
 					if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_LONG) {
-						/* don't optimise if it should produce a runtime numeric string error */
+						/* don't optimize if it should produce a runtime numeric string error */
 						if (!(Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING
 							&& !is_numeric_string(Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)), NULL, NULL, 0))) {
 							convert_to_long(&ZEND_OP2_LITERAL(opline));
@@ -312,7 +312,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx)
 			}
 			if (send1_opline->opcode != ZEND_SEND_VAL ||
 			    send1_opline->op1_type != IS_CONST) {
-				/* don't colllect constants after unknown function call */
+				/* don't collect constants after unknown function call */
 				collect_constants = 0;
 				break;
 			}
@@ -324,7 +324,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx)
 				}
 				if (send1_opline->opcode != ZEND_SEND_VAL ||
 				    send1_opline->op1_type != IS_CONST) {
-					/* don't colllect constants after unknown function call */
+					/* don't collect constants after unknown function call */
 					collect_constants = 0;
 					break;
 				}
@@ -336,7 +336,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx)
 			if (init_opline->opcode != ZEND_INIT_FCALL ||
 			    init_opline->op2_type != IS_CONST ||
 			    Z_TYPE(ZEND_OP2_LITERAL(init_opline)) != IS_STRING) {
-				/* don't colllect constants after unknown function call */
+				/* don't collect constants after unknown function call */
 				collect_constants = 0;
 				break;
 			}
@@ -505,7 +505,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx)
 					break;
 				}
 			}
-			/* don't colllect constants after any other function call */
+			/* don't collect constants after any other function call */
 			collect_constants = 0;
 			break;
 		}

Zend/Optimizer/pass3.c

@@ -261,7 +261,7 @@ void zend_optimizer_pass3(zend_op_array *op_array, zend_optimizer_ctx *ctx)
 						/*       is not used on the following path and             */
 						/*       should be used once on the branch path.           */
 						/*                                                         */
-						/*       The pattern works well only if jums processed in  */
+						/*       The pattern works well only if jumps processed in  */
 						/*       direct order, otherwise it breaks JMPZ_EX         */
 						/*       sequences too early.                              */
 						opline->result.var = target->result.var;

Zend/Optimizer/zend_call_graph.h

@@ -45,7 +45,7 @@ struct _zend_call_info {
 struct _zend_func_info {
 	int                     num;
 	uint32_t                flags;
-	zend_ssa                ssa;          /* Static Single Assignmnt Form  */
+	zend_ssa                ssa;          /* Static Single Assignment Form  */
 	zend_call_info         *caller_info;  /* where this function is called from */
 	zend_call_info         *callee_info;  /* which functions are called from this one */
 	zend_call_info        **call_map;     /* Call info associated with init/call/send opnum */

Zend/Optimizer/zend_dump.c

@@ -926,7 +926,7 @@ ZEND_API void zend_dump_op_array(const zend_op_array *op_array, uint32_t dump_fl
 		}
 	}
 	if (func_flags & ZEND_FUNC_IRREDUCIBLE) {
-		fprintf(stderr, ", irreducable");
+		fprintf(stderr, ", irreducible");
 	}
 	if (func_flags & ZEND_FUNC_NO_LOOPS) {
 		fprintf(stderr, ", no_loops");

Zend/Optimizer/zend_inference.c

@@ -3778,7 +3778,7 @@ static bool is_effective_op2_double_cast(zend_op *opline, zval *op1) {
  *    E.g. 0+$i and 0.0+$i only differ by that cast. If then the consuming instruction of this
  *    result will perform a double cast anyway, the conversion is safe.
  *
- * The checks happens recursively, while keeping track of which variables are already visisted to
+ * The checks happens recursively, while keeping track of which variables are already visited to
  * avoid infinite loops. An iterative, worklist driven approach would be possible, but the state
  * management more cumbersome to implement, so we don't bother for now.
  */

Zend/Optimizer/zend_optimizer_internal.h

@@ -113,7 +113,7 @@ zend_function *zend_optimizer_get_called_func(
 uint32_t zend_optimizer_classify_function(zend_string *name, uint32_t num_args);
 void zend_optimizer_migrate_jump(zend_op_array *op_array, zend_op *new_opline, zend_op *opline);
 void zend_optimizer_shift_jump(zend_op_array *op_array, zend_op *opline, uint32_t *shiftlist);
-int sccp_optimize_op_array(zend_optimizer_ctx *ctx, zend_op_array *op_arrya, zend_ssa *ssa, zend_call_info **call_map);
+int sccp_optimize_op_array(zend_optimizer_ctx *ctx, zend_op_array *op_array, zend_ssa *ssa, zend_call_info **call_map);
 int dce_optimize_op_array(zend_op_array *op_array, zend_ssa *ssa, bool reorder_dtor_effects);
 int zend_ssa_escape_analysis(const zend_script *script, zend_op_array *op_array, zend_ssa *ssa);
 

Zend/zend.c

@@ -931,7 +931,7 @@ void zend_startup(zend_utility_functions *utility_functions) /* {{{ */
 #endif
 # if ZEND_MAP_PTR_KIND == ZEND_MAP_PTR_KIND_PTR
 		/* Create a map region, used for indirect pointers from shared to
-		 * process memory. It's allocatred once and never resized.
+		 * process memory. It's allocated once and never resized.
 		 * All processes must map it into the same address space.
 		 */
 		CG(map_ptr_size) = 1024 * 1024; // TODO: initial size ???
@@ -1374,8 +1374,8 @@ static ZEND_COLD void zend_error_impl(
 			ZVAL_COPY_VALUE(&orig_user_error_handler, &EG(user_error_handler));
 			ZVAL_UNDEF(&EG(user_error_handler));
 
-			/* User error handler may include() additinal PHP files.
-			 * If an error was generated during comilation PHP will compile
+			/* User error handler may include() additional PHP files.
+			 * If an error was generated during compilation PHP will compile
 			 * such scripts recursively, but some CG() variables may be
 			 * inconsistent. */
 

Zend/zend_API.c

@@ -2899,7 +2899,7 @@ void module_destructor(zend_module_entry *module) /* {{{ */
 		zend_unregister_ini_entries(module->module_number);
 	}
 
-	/* Deinitilaise module globals */
+	/* Deinitialize module globals */
 	if (module->globals_size) {
 #ifdef ZTS
 		if (*module->globals_id_ptr) {

Zend/zend_API.h

@@ -590,7 +590,7 @@ ZEND_API void zend_fcall_info_args_clear(zend_fcall_info *fci, bool free_mem);
  */
 ZEND_API void zend_fcall_info_args_save(zend_fcall_info *fci, uint32_t *param_count, zval **params);
 
-/** Free arguments connected with zend_fcall_info *fci andset back saved ones.
+/** Free arguments connected with zend_fcall_info *fci and set back saved ones.
  */
 ZEND_API void zend_fcall_info_args_restore(zend_fcall_info *fci, uint32_t param_count, zval *params);
 

Zend/zend_alloc.c

@@ -210,7 +210,7 @@ int zend_mm_use_huge_pages = 0;
  * free_tail  - number of continuous free pages at the end of chunk
  *
  * free_map   - bitset (a bit for each page). The bit is set if the corresponding
- *              page is allocated. Allocator for "lage sizes" may easily find a
+ *              page is allocated. Allocator for "large sizes" may easily find a
  *              free page (or a continuous number of pages) searching for zero
  *              bits.
  *

Zend/zend_builtin_functions.c

@@ -1922,7 +1922,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int
 			zend_hash_add_new(Z_ARRVAL(stack_frame), ZSTR_KNOWN(ZEND_STR_LINE), &tmp);
 
 			/* try to fetch args only if an FCALL was just made - elsewise we're in the middle of a function
-			 * and debug_baktrace() might have been called by the error_handler. in this case we don't
+			 * and debug_backtrace() might have been called by the error_handler. in this case we don't
 			 * want to pop anything of the argument-stack */
 		} else {
 			zend_execute_data *prev_call = skip;

Zend/zend_compile.c

@@ -586,7 +586,7 @@ static int zend_add_ns_func_name_literal(zend_string *name) /* {{{ */
 	zend_string *lc_name = zend_string_tolower(name);
 	zend_add_literal_string(&lc_name);
 
-	/* Lowercased unqualfied name */
+	/* Lowercased unqualified name */
 	if (zend_get_unqualified_name(name, &unqualified_name, &unqualified_name_len)) {
 		lc_name = zend_string_alloc(unqualified_name_len, 0);
 		zend_str_tolower_copy(ZSTR_VAL(lc_name), unqualified_name, unqualified_name_len);
@@ -715,7 +715,7 @@ void zend_do_free(znode *op1) /* {{{ */
 			switch (opline->opcode) {
 				case ZEND_BOOL:
 				case ZEND_BOOL_NOT:
-					/* boolean resuls don't have to be freed */
+					/* boolean results don't have to be freed */
 					return;
 				case ZEND_POST_INC_STATIC_PROP:
 				case ZEND_POST_DEC_STATIC_PROP:
@@ -3230,7 +3230,7 @@ void zend_compile_assign(znode *result, zend_ast *ast) /* {{{ */
 			if (zend_propagate_list_refs(var_ast)) {
 				if (!zend_is_variable_or_call(expr_ast)) {
 					zend_error_noreturn(E_COMPILE_ERROR,
-						"Cannot assign reference to non referencable value");
+						"Cannot assign reference to non referenceable value");
 				}
 
 				zend_compile_var(&expr_node, expr_ast, BP_VAR_W, 1);

Zend/zend_compile.h

@@ -233,7 +233,7 @@ typedef struct _zend_oparray_context {
 /* op_array or class is preloaded                         |     |     |     */
 #define ZEND_ACC_PRELOADED               (1 << 10) /*  X  |  X  |     |     */
 /*                                                        |     |     |     */
-/* Flag to differenciate cases from constants.            |     |     |     */
+/* Flag to differentiate cases from constants.            |     |     |     */
 /* Stored in Z_ACCESS_FLAGS, must not conflict with       |     |     |     */
 /* ZEND_ACC_ visibility flags or IS_CONSTANT_VISITED_MARK |     |     |     */
 #define ZEND_CLASS_CONST_IS_CASE         (1 << 6)  /*     |     |     |  X  */
@@ -1103,15 +1103,15 @@ END_EXTERN_C()
 #define ZEND_COMPILE_EXTENDED_FCALL             (1<<1)
 #define ZEND_COMPILE_EXTENDED_INFO              (ZEND_COMPILE_EXTENDED_STMT|ZEND_COMPILE_EXTENDED_FCALL)
 
-/* call op_array handler of extendions */
+/* call op_array handler of extensions */
 #define ZEND_COMPILE_HANDLE_OP_ARRAY            (1<<2)
 
 /* generate ZEND_INIT_FCALL_BY_NAME for internal functions instead of ZEND_INIT_FCALL */
 #define ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS  (1<<3)
 
 /* don't perform early binding for classes inherited form internal ones;
  * in namespaces assume that internal class that doesn't exist at compile-time
- * may apper in run-time */
+ * may appear in run-time */
 #define ZEND_COMPILE_IGNORE_INTERNAL_CLASSES    (1<<4)
 
 /* generate ZEND_DECLARE_CLASS_DELAYED opcode to delay early binding */

Zend/zend_constants.h

@@ -84,7 +84,7 @@ ZEND_API void zend_register_string_constant(const char *name, size_t name_len, c
 ZEND_API void zend_register_stringl_constant(const char *name, size_t name_len, const char *strval, size_t strlen, int flags, int module_number);
 ZEND_API zend_result zend_register_constant(zend_constant *c);
 #ifdef ZTS
-void zend_copy_constants(HashTable *target, HashTable *sourc);
+void zend_copy_constants(HashTable *target, HashTable *source);
 #endif
 
 ZEND_API zend_constant *_zend_get_special_const(const char *name, size_t name_len);

Zend/zend_exceptions.c

@@ -53,7 +53,7 @@ static zend_object_handlers default_exception_handlers;
 /* {{{ zend_implement_throwable */
 static int zend_implement_throwable(zend_class_entry *interface, zend_class_entry *class_type)
 {
-	/* zend_ce_exception and zend_ce_error may not be initialized yet when this is caleld (e.g when
+	/* zend_ce_exception and zend_ce_error may not be initialized yet when this is called (e.g when
 	 * implementing Throwable for Exception itself). Perform a manual inheritance check. */
 	zend_class_entry *root = class_type;
 	while (root->parent) {

Zend/zend_execute.h

@@ -174,7 +174,7 @@ struct _zend_vm_stack {
 /*
  * In general in RELEASE build ZEND_ASSERT() must be zero-cost, but for some
  * reason, GCC generated worse code, performing CSE on assertion code and the
- * following "slow path" and moving memory read operatins from slow path into
+ * following "slow path" and moving memory read operations from slow path into
  * common header. This made a degradation for the fast path.
  * The following "#if ZEND_DEBUG" eliminates it.
  */

Zend/zend_generators.c

@@ -708,7 +708,7 @@ ZEND_API void zend_generator_resume(zend_generator *orig_generator) /* {{{ */
 			orig_generator->flags &= ~ZEND_GENERATOR_DO_INIT;
 			return;
 		}
-		/* If there are no more deletegated values, resume the generator
+		/* If there are no more delegated values, resume the generator
 		 * after the "yield from" expression. */
 	}
 

Zend/zend_globals.h

@@ -229,7 +229,7 @@ struct _zend_executor_globals {
 
 	zend_long assertions;
 
-	uint32_t           ht_iterators_count;     /* number of allocatd slots */
+	uint32_t           ht_iterators_count;     /* number of allocated slots */
 	uint32_t           ht_iterators_used;      /* number of used slots */
 	HashTableIterator *ht_iterators;
 	HashTableIterator  ht_iterators_slots[16];

Zend/zend_hash.c

@@ -1842,7 +1842,7 @@ ZEND_API void ZEND_FASTCALL zend_hash_graceful_reverse_destroy(HashTable *ht)
  * return codes are possible:
  * ZEND_HASH_APPLY_KEEP   - continue
  * ZEND_HASH_APPLY_STOP   - stop iteration
- * ZEND_HASH_APPLY_REMOVE - delete the element, combineable with the former
+ * ZEND_HASH_APPLY_REMOVE - delete the element, combinable with the former
  */
 
 ZEND_API void ZEND_FASTCALL zend_hash_apply(HashTable *ht, apply_func_t apply_func)