Fix typos in code comments in Zend/ [skip ci]

Zend/zend.c

@@ -1399,7 +1399,7 @@ static ZEND_COLD void zend_error_va_list(int type, const char *format, va_list a
 
 			/* User error handler may include() additinal PHP files.
 			 * If an error was generated during comilation PHP will compile
-			 * such scripts recursivly, but some CG() variables may be
+			 * such scripts recursively, but some CG() variables may be
 			 * inconsistent. */
 
 			in_compilation = CG(in_compilation);

Zend/zend_alloc.c

@@ -196,7 +196,7 @@ int zend_mm_use_huge_pages = 0;
  * Memory is retrieved from OS by chunks of fixed size 2MB.
  * Inside chunk it's managed by pages of fixed size 4096B.
  * So each chunk consists from 512 pages.
- * The first page of each chunk is reseved for chunk header.
+ * The first page of each chunk is reserved for chunk header.
  * It contains service information about all pages.
  *
  * free_pages - current number of free pages in this chunk
@@ -2012,7 +2012,7 @@ ZEND_API size_t zend_mm_gc(zend_mm_heap *heap)
 					int pages_count = bin_pages[bin_num];
 
 					if (ZEND_MM_SRUN_FREE_COUNTER(info) == bin_elements[bin_num]) {
-						/* all elemens are free */
+						/* all elements are free */
 						zend_mm_free_pages_ex(heap, chunk, i, pages_count, 0);
 						collected += pages_count;
 					} else {

Zend/zend_compile.c

@@ -2153,7 +2153,7 @@ static inline void zend_handle_numeric_dim(zend_op *opline, znode *dim_node) /*
 		zend_ulong index;
 
 		if (ZEND_HANDLE_NUMERIC(Z_STR(dim_node->u.constant), index)) {
-			/* For numeric indexs we also keep the original value to use by ArrayAccess
+			/* For numeric indexes we also keep the original value to use by ArrayAccess
 			 * See bug #63217
 			 */
 			int c = zend_add_literal(&dim_node->u.constant);

Zend/zend_cpuinfo.h

@@ -112,8 +112,8 @@ ZEND_API int zend_cpu_supports(zend_cpu_feature feature);
 #if PHP_HAVE_BUILTIN_CPU_SUPPORTS
 /* NOTE: you should use following inline function in
  * resolver functions (ifunc), as it could be called
- * before all PLT symbols are resloved. in other words,
- * resolver functions should not depends any external
+ * before all PLT symbols are resolved. in other words,
+ * resolver functions should not depend on any external
  * functions */
 ZEND_NO_SANITIZE_ADDRESS
 static zend_always_inline int zend_cpu_supports_sse2() {

Zend/zend_execute.c

@@ -3526,7 +3526,7 @@ static zend_execute_data *zend_vm_stack_copy_call_frame(zend_execute_data *call,
 	/* delete old call_frame from previous stack segment */
 	EG(vm_stack)->prev->top = (zval*)call;
 
-	/* delete previous stack segment if it becames empty */
+	/* delete previous stack segment if it became empty */
 	if (UNEXPECTED(EG(vm_stack)->prev->top == ZEND_VM_STACK_ELEMENTS(EG(vm_stack)->prev))) {
 		zend_vm_stack r = EG(vm_stack)->prev;
 

Zend/zend_float.h

@@ -66,7 +66,7 @@ END_EXTERN_C()
     on how to do that?
 
  MS Visual C:
-  - Since MSVC users tipically don't use autoconf or CMake, we will detect
+  - Since MSVC users typically don't use autoconf or CMake, we will detect
     MSVC via compile time define. Floating point precision change isn't
     supported on 64 bit platforms, so it's NOP. See
     http://msdn.microsoft.com/en-us/library/c9676k6h(v=vs.110).aspx

Zend/zend_gc.c

@@ -48,7 +48,7 @@
  * gc_scan_roots will be called, and each root will be called with
  * gc_scan(root->ref)
  *
- * gc_scan checkes the colors of possible members.
+ * gc_scan checks the colors of possible members.
  *
  * If the node is marked as grey and the refcount > 0
  *    gc_scan_black will be called on that node to scan it's subgraph.

Zend/zend_hash.h

@@ -168,7 +168,7 @@ ZEND_API int ZEND_FASTCALL zend_hash_str_del_ind(HashTable *ht, const char *key,
 ZEND_API int ZEND_FASTCALL zend_hash_index_del(HashTable *ht, zend_ulong h);
 ZEND_API void ZEND_FASTCALL zend_hash_del_bucket(HashTable *ht, Bucket *p);
 
-/* Data retreival */
+/* Data retrieval */
 ZEND_API zval* ZEND_FASTCALL zend_hash_find(const HashTable *ht, zend_string *key);
 ZEND_API zval* ZEND_FASTCALL zend_hash_str_find(const HashTable *ht, const char *key, size_t len);
 ZEND_API zval* ZEND_FASTCALL zend_hash_index_find(const HashTable *ht, zend_ulong h);
@@ -1063,7 +1063,7 @@ static zend_always_inline void *zend_hash_get_current_data_ptr_ex(HashTable *ht,
 	_val = _z;
 
 /* The following macros are useful to insert a sequence of new elements
- * of packed array. They may be use insted of series of
+ * of packed array. They may be used instead of series of
  * zend_hash_next_index_insert_new()
  * (HashTable must have enough free buckets).
  */

Zend/zend_inheritance.c

@@ -1869,7 +1869,7 @@ static void zend_do_check_for_inconsistent_traits_aliasing(zend_class_entry *ce,
 							   ZSTR_VAL(cur_alias->trait_method.method_name));
 				} else {
 					/** Here are two possible cases:
-						1) this is an attempt to modifiy the visibility
+						1) this is an attempt to modify the visibility
 						   of a method introduce as part of another alias.
 						   Since that seems to violate the DRY principle,
 						   we check against it and abort.

Zend/zend_object_handlers.c

@@ -1223,7 +1223,7 @@ ZEND_API zend_function *zend_get_call_trampoline_func(zend_class_entry *ce, zend
 	func->opcodes = &EG(call_trampoline_op);
 	ZEND_MAP_PTR_INIT(func->run_time_cache, (void***)&dummy);
 	func->scope = fbc->common.scope;
-	/* reserve space for arguments, local and temorary variables */
+	/* reserve space for arguments, local and temporary variables */
 	func->T = (fbc->type == ZEND_USER_FUNCTION)? MAX(fbc->op_array.last_var + fbc->op_array.T, 2) : 2;
 	func->filename = (fbc->type == ZEND_USER_FUNCTION)? fbc->op_array.filename : ZSTR_EMPTY_ALLOC();
 	func->line_start = (fbc->type == ZEND_USER_FUNCTION)? fbc->op_array.line_start : 0;

Zend/zend_object_handlers.h

@@ -134,7 +134,7 @@ typedef zend_object* (*zend_object_clone_obj_t)(zval *object);
 typedef zend_string *(*zend_object_get_class_name_t)(const zend_object *object);
 
 typedef int (*zend_object_compare_t)(zval *object1, zval *object2);
-typedef int (*zend_object_compare_zvals_t)(zval *resul, zval *op1, zval *op2);
+typedef int (*zend_object_compare_zvals_t)(zval *result, zval *op1, zval *op2);
 
 /* Cast an object to some other type.
  * readobj and retval must point to distinct zvals.

Zend/zend_string.h

@@ -336,7 +336,7 @@ static zend_always_inline zend_bool zend_string_equals(zend_string *s1, zend_str
  * constants, prime or not, has never been adequately explained by
  * anyone. So I try an explanation: if one experimentally tests all
  * multipliers between 1 and 256 (as RSE did now) one detects that even
- * numbers are not useable at all. The remaining 128 odd numbers
+ * numbers are not usable at all. The remaining 128 odd numbers
  * (except for the number 1) work more or less all equally well. They
  * all distribute in an acceptable way and this way fill a hash table
  * with an average percent of approx. 86%.

Zend/zend_ts_hash.h

@@ -64,7 +64,7 @@ ZEND_API void zend_ts_hash_reverse_apply(TsHashTable *ht, apply_func_t apply_fun
 ZEND_API int zend_ts_hash_del(TsHashTable *ht, zend_string *key);
 ZEND_API int zend_ts_hash_index_del(TsHashTable *ht, zend_ulong h);
 
-/* Data retreival */
+/* Data retrieval */
 ZEND_API zval *zend_ts_hash_find(TsHashTable *ht, zend_string *key);
 ZEND_API zval *zend_ts_hash_index_find(TsHashTable *ht, zend_ulong);