Zend: Use true / false instead of 1 / 0 when assigning to bool

Changes done with Coccinelle: @@ bool b; @@ - b = 0 + b = false @@ bool b; @@ - b = 1 + b = true
2026-03-24 00:02:20 +01:00 · 2025-09-23 22:58:39 +02:00
parent d8db34138e
commit c32fbca874
15 changed files with 128 additions and 128 deletions
--- a/Zend/zend.c
+++ b/Zend/zend.c
@@ -641,7 +641,7 @@ static FILE *zend_fopen_wrapper(zend_string *filename, zend_string **opened_path
 /* }}} */

 #ifdef ZTS
-static bool short_tags_default      = 1;
+static bool short_tags_default = true;
 static uint32_t compiler_options_default = ZEND_COMPILE_DEFAULT;
 #else
 # define short_tags_default			1
@@ -817,7 +817,7 @@ static void executor_globals_ctor(zend_executor_globals *executor_globals) /* {{
 	executor_globals->saved_fpu_cw = 0;
 #endif
 	executor_globals->saved_fpu_cw_ptr = NULL;
-	executor_globals->active = 0;
+	executor_globals->active = false;
 	executor_globals->bailout = NULL;
 	executor_globals->error_handling  = EH_NORMAL;
 	executor_globals->exception_class = NULL;
@@ -1026,7 +1026,7 @@ void zend_startup(zend_utility_functions *utility_functions) /* {{{ */
 	executor_globals = ts_resource(executor_globals_id);

 	compiler_globals_dtor(compiler_globals);
-	compiler_globals->in_compilation = 0;
+	compiler_globals->in_compilation = false;
 	compiler_globals->function_table = (HashTable *) malloc(sizeof(HashTable));
 	compiler_globals->class_table = (HashTable *) malloc(sizeof(HashTable));

--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -818,8 +818,8 @@ static const char *zend_parse_arg_impl(zval *arg, va_list *va, const char **spec
 {
 	const char *spec_walk = *spec;
 	char c = *spec_walk++;
-	bool check_null = 0;
-	bool separate = 0;
+	bool check_null = false;
+	bool separate = false;
 	zval *real_arg = arg;

 	/* scan through modifiers */
@@ -828,9 +828,9 @@ static const char *zend_parse_arg_impl(zval *arg, va_list *va, const char **spec
 		if (*spec_walk == '/') {
 			SEPARATE_ZVAL_NOREF(arg);
 			real_arg = arg;
-			separate = 1;
+			separate = true;
 		} else if (*spec_walk == '!') {
-			check_null = 1;
+			check_null = true;
 		} else {
 			break;
 		}
@@ -1157,8 +1157,8 @@ static zend_result zend_parse_va_args(uint32_t num_args, const char *type_spec,
 	uint32_t max_num_args = 0;
 	uint32_t post_varargs = 0;
 	zval *arg;
-	bool have_varargs = 0;
-	bool have_optional_args = 0;
+	bool have_varargs = false;
+	bool have_optional_args = false;
 	zval **varargs = NULL;
 	uint32_t *n_varargs = NULL;

@@ -1180,7 +1180,7 @@ static zend_result zend_parse_va_args(uint32_t num_args, const char *type_spec,

 			case '|':
 				min_num_args = max_num_args;
-				have_optional_args = 1;
+				have_optional_args = true;
 				break;

 			case '/':
@@ -1195,7 +1195,7 @@ static zend_result zend_parse_va_args(uint32_t num_args, const char *type_spec,
 						"only one varargs specifier (* or +) is permitted");
 					return FAILURE;
 				}
-				have_varargs = 1;
+				have_varargs = true;
 				/* we expect at least one parameter in varargs */
 				if (c == '+') {
 					max_num_args++;
@@ -3596,7 +3596,7 @@ ZEND_API zend_result zend_register_class_alias_ex(const char *name, size_t name_

 	/* TODO: Move this out of here in 7.4. */
 	if (persistent && EG(current_module) && EG(current_module)->type == MODULE_TEMPORARY) {
-		persistent = 0;
+		persistent = false;
 	}

 	if (name[0] == '\\') {
@@ -3719,7 +3719,7 @@ static bool zend_is_callable_check_class(zend_string *name, zend_class_entry *sc
 	ZSTR_ALLOCA_ALLOC(lcname, name_len, use_heap);
 	zend_str_tolower_copy(ZSTR_VAL(lcname), ZSTR_VAL(name), name_len);

-	*strict_class = 0;
+	*strict_class = false;
 	if (zend_string_equals(lcname, ZSTR_KNOWN(ZEND_STR_SELF))) {
 		if (!scope) {
 			if (error) *error = estrdup("cannot access \"self\" when no class scope is active");
@@ -3754,7 +3754,7 @@ static bool zend_is_callable_check_class(zend_string *name, zend_class_entry *sc
 			if (!fcc->object) {
 				fcc->object = zend_get_this_object(frame);
 			}
-			*strict_class = 1;
+			*strict_class = true;
 			ret = true;
 		}
 	} else if (zend_string_equals(lcname, ZSTR_KNOWN(ZEND_STR_STATIC))) {
@@ -3771,7 +3771,7 @@ static bool zend_is_callable_check_class(zend_string *name, zend_class_entry *sc
 			if (!fcc->object) {
 				fcc->object = zend_get_this_object(frame);
 			}
-			*strict_class = 1;
+			*strict_class = true;
 			ret = true;
 		}
 	} else if ((ce = zend_lookup_class(name)) != NULL) {
@@ -3791,7 +3791,7 @@ static bool zend_is_callable_check_class(zend_string *name, zend_class_entry *sc
 		} else {
 			fcc->called_scope = fcc->object ? fcc->object->ce : ce;
 		}
-		*strict_class = 1;
+		*strict_class = true;
 		ret = true;
 	} else {
 		if (error) zend_spprintf(error, 0, "class \"%.*s\" not found", (int)name_len, ZSTR_VAL(name));
@@ -3815,7 +3815,7 @@ ZEND_API void zend_release_fcall_info_cache(zend_fcall_info_cache *fcc) {
 static zend_always_inline bool zend_is_callable_check_func(zval *callable, zend_execute_data *frame, zend_fcall_info_cache *fcc, bool strict_class, char **error, bool suppress_deprecation) /* {{{ */
 {
 	zend_class_entry *ce_org = fcc->calling_scope;
-	bool retval = 0;
+	bool retval = false;
 	zend_string *mname, *cname;
 	zend_string *lmname;
 	const char *colon;
@@ -3897,7 +3897,7 @@ static zend_always_inline bool zend_is_callable_check_func(zval *callable, zend_
 			} else {
 				fcc->called_scope = fcc->object ? fcc->object->ce : fcc->calling_scope;
 			}
-			strict_class = 1;
+			strict_class = true;
 		} else if (!zend_is_callable_check_class(cname, scope, frame, fcc, &strict_class, error, suppress_deprecation || ce_org != NULL)) {
 			zend_string_release_ex(cname, 0);
 			return 0;
@@ -3935,11 +3935,11 @@ static zend_always_inline bool zend_is_callable_check_func(zval *callable, zend_
 		zend_string_equals_literal(lmname, ZEND_CONSTRUCTOR_FUNC_NAME)) {
 		fcc->function_handler = fcc->calling_scope->constructor;
 		if (fcc->function_handler) {
-			retval = 1;
+			retval = true;
 		}
 	} else if ((zv = zend_hash_find(ftable, lmname)) != NULL) {
 		fcc->function_handler = Z_PTR_P(zv);
-		retval = 1;
+		retval = true;
 		if ((fcc->function_handler->op_array.fn_flags & ZEND_ACC_CHANGED) &&
 		    !strict_class) {
 			scope = get_scope(frame);
@@ -3964,7 +3964,7 @@ static zend_always_inline bool zend_is_callable_check_func(zval *callable, zend_
 			scope = get_scope(frame);
 			ZEND_ASSERT(!(fcc->function_handler->common.fn_flags & ZEND_ACC_PUBLIC));
 			if (!zend_check_method_accessible(fcc->function_handler, scope)) {
-				retval = 0;
+				retval = false;
 				fcc->function_handler = NULL;
 				goto get_function_via_handler;
 			}
@@ -3975,7 +3975,7 @@ get_function_via_handler:
 			if (strict_class && ce_org->__call) {
 				fcc->function_handler = zend_get_call_trampoline_func(ce_org, mname, 0);
 				call_via_handler = 1;
-				retval = 1;
+				retval = true;
 			} else {
 				fcc->function_handler = fcc->object->handlers->get_method(&fcc->object, mname, NULL);
 				if (fcc->function_handler) {
@@ -3984,7 +3984,7 @@ get_function_via_handler:
 					     !instanceof_function(ce_org, fcc->function_handler->common.scope))) {
 						zend_release_fcall_info_cache(fcc);
 					} else {
-						retval = 1;
+						retval = true;
 						call_via_handler = (fcc->function_handler->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) != 0;
 					}
 				}
@@ -3996,7 +3996,7 @@ get_function_via_handler:
 				fcc->function_handler = zend_std_get_static_method(fcc->calling_scope, mname, NULL);
 			}
 			if (fcc->function_handler) {
-				retval = 1;
+				retval = true;
 				call_via_handler = (fcc->function_handler->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) != 0;
 				if (call_via_handler && !fcc->object) {
 					zend_object *object = zend_get_this_object(frame);
@@ -4012,12 +4012,12 @@ get_function_via_handler:
 	if (retval) {
 		if (fcc->calling_scope && !call_via_handler) {
 			if (fcc->function_handler->common.fn_flags & ZEND_ACC_ABSTRACT) {
-				retval = 0;
+				retval = false;
 				if (error) {
 					zend_spprintf(error, 0, "cannot call abstract method %s::%s()", ZSTR_VAL(fcc->calling_scope->name), ZSTR_VAL(fcc->function_handler->common.function_name));
 				}
 			} else if (!fcc->object && !(fcc->function_handler->common.fn_flags & ZEND_ACC_STATIC)) {
-				retval = 0;
+				retval = false;
 				if (error) {
 					zend_spprintf(error, 0, "non-static method %s::%s() cannot be called statically", ZSTR_VAL(fcc->calling_scope->name), ZSTR_VAL(fcc->function_handler->common.function_name));
 				}
@@ -4033,7 +4033,7 @@ get_function_via_handler:
 						}
 						zend_spprintf(error, 0, "cannot access %s method %s::%s()", zend_visibility_string(fcc->function_handler->common.fn_flags), ZSTR_VAL(fcc->calling_scope->name), ZSTR_VAL(fcc->function_handler->common.function_name));
 					}
-					retval = 0;
+					retval = false;
 				}
 			}
 		}
@@ -4128,7 +4128,7 @@ ZEND_API bool zend_is_callable_at_frame(
 {
 	bool ret;
 	zend_fcall_info_cache fcc_local;
-	bool strict_class = 0;
+	bool strict_class = false;

 	if (fcc == NULL) {
 		fcc = &fcc_local;
--- a/Zend/zend_builtin_functions.c
+++ b/Zend/zend_builtin_functions.c
@@ -503,7 +503,7 @@ ZEND_FUNCTION(error_reporting)

 static bool validate_constant_array_argument(HashTable *ht, int argument_number) /* {{{ */
 {
-	bool ret = 1;
+	bool ret = true;
 	zval *val;

 	GC_PROTECT_RECURSION(ht);
@@ -512,10 +512,10 @@ static bool validate_constant_array_argument(HashTable *ht, int argument_number)
 		if (Z_TYPE_P(val) == IS_ARRAY && Z_REFCOUNTED_P(val)) {
 			if (Z_IS_RECURSIVE_P(val)) {
 				zend_argument_value_error(argument_number, "cannot be a recursive array");
-				ret = 0;
+				ret = false;
 				break;
 			} else if (!validate_constant_array_argument(Z_ARRVAL_P(val), argument_number)) {
-				ret = 0;
+				ret = false;
 				break;
 			}
 		}
@@ -1631,7 +1631,7 @@ static void add_zendext_info(zend_extension *ext, void *arg) /* {{{ */
 /* {{{ Return an array containing names of loaded extensions */
 ZEND_FUNCTION(get_loaded_extensions)
 {
-	bool zendext = 0;
+	bool zendext = false;

 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &zendext) == FAILURE) {
 		RETURN_THROWS();
@@ -1654,7 +1654,7 @@ ZEND_FUNCTION(get_loaded_extensions)
 /* {{{ Return an array containing the names and values of all defined constants */
 ZEND_FUNCTION(get_defined_constants)
 {
-	bool categorize = 0;
+	bool categorize = false;

 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &categorize) == FAILURE) {
 		RETURN_THROWS();
@@ -1892,7 +1892,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int
 {
 	zend_execute_data *call, *last_call = NULL;
 	zend_object *object;
-	bool fake_frame = 0;
+	bool fake_frame = false;
 	int lineno, frameno = 0;
 	zend_function *func;
 	zend_string *filename;
@@ -2128,7 +2128,7 @@ not_frameless_call:
 			}
 		} else {
 			/* i know this is kinda ugly, but i'm trying to avoid extra cycles in the main execution loop */
-			bool build_filename_arg = 1;
+			bool build_filename_arg = true;
 			zend_string *pseudo_function_name;
 			uint32_t include_kind = 0;
 			if (prev && prev->func && ZEND_USER_CODE(prev->func->common.type) && prev->opline->opcode == ZEND_INCLUDE_OR_EVAL) {
@@ -2138,7 +2138,7 @@ not_frameless_call:
 			switch (include_kind) {
 				case ZEND_EVAL:
 					pseudo_function_name = ZSTR_KNOWN(ZEND_STR_EVAL);
-					build_filename_arg = 0;
+					build_filename_arg = false;
 					break;
 				case ZEND_INCLUDE:
 					pseudo_function_name = ZSTR_KNOWN(ZEND_STR_INCLUDE);
@@ -2160,7 +2160,7 @@ not_frameless_call:
 					}

 					pseudo_function_name = ZSTR_KNOWN(ZEND_STR_UNKNOWN);
-					build_filename_arg = 0;
+					build_filename_arg = false;
 					break;
 			}

@@ -2194,9 +2194,9 @@ skip_frame:
 		 && prev->func
 		 && ZEND_USER_CODE(prev->func->common.type)
 		 && prev->opline->opcode == ZEND_INCLUDE_OR_EVAL) {
-			fake_frame = 1;
+			fake_frame = true;
 		} else {
-			fake_frame = 0;
+			fake_frame = false;
 			include_filename = filename;
 			last_call = call;
 			call = prev;
@@ -2266,9 +2266,9 @@ ZEND_FUNCTION(get_extension_funcs)
 	if (module->functions) {
 		/* avoid BC break, if functions list is empty, will return an empty array */
 		array_init(return_value);
-		array = 1;
+		array = true;
 	} else {
-		array = 0;
+		array = false;
 	}

 	ZEND_HASH_MAP_FOREACH_PTR(CG(function_table), zif) {
@@ -2276,7 +2276,7 @@ ZEND_FUNCTION(get_extension_funcs)
 			&& zif->internal_function.module == module) {
 			if (!array) {
 				array_init(return_value);
-				array = 1;
+				array = true;
 			}
 			add_next_index_str(return_value, zend_string_copy(zif->common.function_name));
 		}
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -1075,21 +1075,21 @@ static zend_string *zend_resolve_non_class_name(
 	bool case_sensitive, HashTable *current_import_sub
 ) {
 	char *compound;
-	*is_fully_qualified = 0;
+	*is_fully_qualified = false;

 	if (ZSTR_VAL(name)[0] == '\\') {
 		/* Remove \ prefix (only relevant if this is a string rather than a label) */
-		*is_fully_qualified = 1;
+		*is_fully_qualified = true;
 		return zend_string_init(ZSTR_VAL(name) + 1, ZSTR_LEN(name) - 1, 0);
 	}

 	if (type == ZEND_NAME_FQ) {
-		*is_fully_qualified = 1;
+		*is_fully_qualified = true;
 		return zend_string_copy(name);
 	}

 	if (type == ZEND_NAME_RELATIVE) {
-		*is_fully_qualified = 1;
+		*is_fully_qualified = true;
 		return zend_prefix_with_ns(name);
 	}

@@ -1103,14 +1103,14 @@ static zend_string *zend_resolve_non_class_name(
 		}

 		if (import_name) {
-			*is_fully_qualified = 1;
+			*is_fully_qualified = true;
 			return zend_string_copy(import_name);
 		}
 	}

 	compound = memchr(ZSTR_VAL(name), '\\', ZSTR_LEN(name));
 	if (compound) {
-		*is_fully_qualified = 1;
+		*is_fully_qualified = true;
 	}

 	if (compound && FC(imports)) {
@@ -1542,7 +1542,7 @@ static void zend_mark_function_as_generator(void) /* {{{ */
 			ZEND_TYPE_FOREACH(return_type, single_type) {
 				if (ZEND_TYPE_HAS_NAME(*single_type)
 						&& is_generator_compatible_class_type(ZEND_TYPE_NAME(*single_type))) {
-					valid_type = 1;
+					valid_type = true;
 					break;
 				}
 			} ZEND_TYPE_FOREACH_END();
@@ -3262,7 +3262,7 @@ static inline void zend_emit_assign_ref_znode(zend_ast *var_ast, znode *value_no
 /* Propagate refs used on leaf elements to the surrounding list() structures. */
 static bool zend_propagate_list_refs(zend_ast *ast) { /* {{{ */
 	zend_ast_list *list = zend_ast_get_list(ast);
-	bool has_refs = 0;
+	bool has_refs = false;
 	uint32_t i;

 	for (i = 0; i < list->children; ++i) {
@@ -3297,7 +3297,7 @@ static void zend_compile_list_assign(
 {
 	zend_ast_list *list = zend_ast_get_list(ast);
 	uint32_t i;
-	bool has_elems = 0;
+	bool has_elems = false;
 	bool is_keyed = list_is_keyed(list);

 	if (list->children && expr_node->op_type == IS_CONST && Z_TYPE(expr_node->u.constant) == IS_STRING) {
@@ -3326,7 +3326,7 @@ static void zend_compile_list_assign(

 		var_ast = elem_ast->child[0];
 		key_ast = elem_ast->child[1];
-		has_elems = 1;
+		has_elems = true;

 		if (is_keyed) {
 			if (key_ast == NULL) {
@@ -3716,16 +3716,16 @@ static uint32_t zend_compile_args(
 {
 	zend_ast_list *args = zend_ast_get_list(ast);
 	uint32_t i;
-	bool uses_arg_unpack = 0;
+	bool uses_arg_unpack = false;
 	uint32_t arg_count = 0; /* number of arguments not including unpacks */

 	/* Whether named arguments are used syntactically, to enforce language level limitations.
 	 * May not actually use named argument passing. */
-	bool uses_named_args = 0;
+	bool uses_named_args = false;
 	/* Whether there may be any undef arguments due to the use of named arguments. */
-	bool may_have_undef = 0;
+	bool may_have_undef = false;
 	/* Whether there may be any extra named arguments collected into a variadic. */
-	*may_have_extra_named_args = 0;
+	*may_have_extra_named_args = false;

 	for (i = 0; i < args->children; ++i) {
 		zend_ast *arg = args->child[i];
@@ -3743,12 +3743,12 @@ static uint32_t zend_compile_args(
 			}

 			/* Unpack may contain named arguments. */
-			may_have_undef = 1;
+			may_have_undef = true;
 			if (!fbc || (fbc->common.fn_flags & ZEND_ACC_VARIADIC)) {
-				*may_have_extra_named_args = 1;
+				*may_have_extra_named_args = true;
 			}

-			uses_arg_unpack = 1;
+			uses_arg_unpack = true;
 			fbc = NULL;

 			zend_compile_expr(&arg_node, arg->child[0]);
@@ -3760,7 +3760,7 @@ static uint32_t zend_compile_args(
 		}

 		if (arg->kind == ZEND_AST_NAMED_ARG) {
-			uses_named_args = 1;
+			uses_named_args = true;
 			arg_name = zval_make_interned_string(zend_ast_get_zval(arg->child[0]));
 			arg = arg->child[1];

@@ -3772,15 +3772,15 @@ static uint32_t zend_compile_args(
 					arg_count++;
 				} else {
 					// TODO: We could track which arguments were passed, even if out of order.
-					may_have_undef = 1;
+					may_have_undef = true;
 					if (arg_num == (uint32_t) -1 && (fbc->common.fn_flags & ZEND_ACC_VARIADIC)) {
-						*may_have_extra_named_args = 1;
+						*may_have_extra_named_args = true;
 					}
 				}
 			} else {
 				arg_num = (uint32_t) -1;
-				may_have_undef = 1;
-				*may_have_extra_named_args = 1;
+				may_have_undef = true;
+				*may_have_extra_named_args = true;
 			}
 		} else {
 			if (uses_arg_unpack) {
@@ -4415,7 +4415,7 @@ static void zend_compile_assert(znode *result, zend_ast_list *args, zend_string

 static zend_result zend_compile_func_in_array(znode *result, zend_ast_list *args) /* {{{ */
 {
-	bool strict = 0;
+	bool strict = false;
 	znode array, needly;
 	zend_op *opline;

@@ -4450,7 +4450,7 @@ static zend_result zend_compile_func_in_array(znode *result, zend_ast_list *args
 	}

 	if (zend_hash_num_elements(Z_ARRVAL(array.u.constant)) > 0) {
-		bool ok = 1;
+		bool ok = true;
 		zval *val, tmp;
 		HashTable *src = Z_ARRVAL(array.u.constant);
 		HashTable *dst = zend_new_array(zend_hash_num_elements(src));
@@ -4465,7 +4465,7 @@ static zend_result zend_compile_func_in_array(znode *result, zend_ast_list *args
 					zend_hash_index_add(dst, Z_LVAL_P(val), &tmp);
 				} else {
 					zend_array_destroy(dst);
-					ok = 0;
+					ok = false;
 					break;
 				}
 			} ZEND_HASH_FOREACH_END();
@@ -4474,7 +4474,7 @@ static zend_result zend_compile_func_in_array(znode *result, zend_ast_list *args
 				if (Z_TYPE_P(val) != IS_STRING
 				 || is_numeric_string(Z_STRVAL_P(val), Z_STRLEN_P(val), NULL, NULL, 0)) {
 					zend_array_destroy(dst);
-					ok = 0;
+					ok = false;
 					break;
 				}
 				zend_hash_add(dst, Z_STR_P(val), &tmp);
@@ -5699,7 +5699,7 @@ static void zend_compile_return(zend_ast *ast) /* {{{ */

 	if (is_generator) {
 		/* For generators the by-ref flag refers to yields, not returns */
-		by_ref = 0;
+		by_ref = false;
 	}

 	if (!expr_ast) {
@@ -6115,7 +6115,7 @@ static void zend_compile_foreach(zend_ast *ast) /* {{{ */
 	}

 	if (value_ast->kind == ZEND_AST_ARRAY && zend_propagate_list_refs(value_ast)) {
-		by_ref = 1;
+		by_ref = true;
 	}

 	if (by_ref && is_variable) {
@@ -6294,7 +6294,7 @@ static void zend_compile_switch(zend_ast *ast) /* {{{ */
 	zend_ast_list *cases = zend_ast_get_list(ast->child[1]);

 	uint32_t i;
-	bool has_default_case = 0;
+	bool has_default_case = false;

 	znode expr_node, case_node;
 	zend_op *opline;
@@ -6339,7 +6339,7 @@ static void zend_compile_switch(zend_ast *ast) /* {{{ */
 				zend_error_noreturn(E_COMPILE_ERROR,
 					"Switch statements may only contain one default clause");
 			}
-			has_default_case = 1;
+			has_default_case = true;
 			continue;
 		}

@@ -6547,7 +6547,7 @@ static void zend_compile_match(znode *result, zend_ast *ast)
 {
 	zend_ast *expr_ast = ast->child[0];
 	zend_ast_list *arms = zend_ast_get_list(ast->child[1]);
-	bool has_default_arm = 0;
+	bool has_default_arm = false;
 	uint32_t opnum_match = (uint32_t)-1;

 	znode expr_node;
@@ -6572,7 +6572,7 @@ static void zend_compile_match(znode *result, zend_ast *ast)
 				zend_error_noreturn(E_COMPILE_ERROR,
 					"Match expressions may only contain one default arm");
 			}
-			has_default_arm = 1;
+			has_default_arm = true;
 		}
 	}

@@ -6625,7 +6625,7 @@ static void zend_compile_match(znode *result, zend_ast *ast)
 		opnum_default_jmp = zend_emit_jump(0);
 	}

-	bool is_first_case = 1;
+	bool is_first_case = true;
 	uint32_t cond_count = 0;
 	uint32_t *jmp_end_opnums = safe_emalloc(sizeof(uint32_t), arms->children, 0);

@@ -6697,7 +6697,7 @@ static void zend_compile_match(znode *result, zend_ast *ast)

 		if (is_first_case) {
 			zend_emit_op_tmp(result, ZEND_QM_ASSIGN, &body_node, NULL);
-			is_first_case = 0;
+			is_first_case = false;
 		} else {
 			zend_op *opline_qm_assign = zend_emit_op(NULL, ZEND_QM_ASSIGN, &body_node, NULL);
 			SET_NODE(opline_qm_assign->result, result);
@@ -7553,7 +7553,7 @@ static void zend_compile_attributes(
 			if (args) {
 				ZEND_ASSERT(args->kind == ZEND_AST_ARG_LIST);

-				bool uses_named_args = 0;
+				bool uses_named_args = false;
 				for (j = 0; j < args->children; j++) {
 					zend_ast **arg_ast_ptr = &args->child[j];
 					zend_ast *arg_ast = *arg_ast_ptr;
@@ -7566,7 +7566,7 @@ static void zend_compile_attributes(
 					if (arg_ast->kind == ZEND_AST_NAMED_ARG) {
 						attr->args[j].name = zend_string_copy(zend_ast_get_str(arg_ast->child[0]));
 						arg_ast_ptr = &arg_ast->child[1];
-						uses_named_args = 1;
+						uses_named_args = true;

 						for (uint32_t k = 0; k < j; k++) {
 							if (attr->args[k].name &&
@@ -8103,7 +8103,7 @@ static void find_implicit_binds_recursively(closure_info *info, zend_ast *ast) {

 			zend_hash_add_empty_element(&info->uses, name);
 		} else {
-			info->varvars_used = 1;
+			info->varvars_used = true;
 			find_implicit_binds_recursively(info, name_ast);
 		}
 	} else if (zend_ast_is_list(ast)) {
@@ -10088,7 +10088,7 @@ static bool zend_try_ct_eval_array(zval *result, zend_ast *ast) /* {{{ */
 	zend_ast_list *list = zend_ast_get_list(ast);
 	zend_ast *last_elem_ast = NULL;
 	uint32_t i;
-	bool is_constant = 1;
+	bool is_constant = true;

 	if (ast->attr == ZEND_ARRAY_SYNTAX_LIST) {
 		zend_error(E_COMPILE_ERROR, "Cannot use list() as standalone expression");
@@ -10113,13 +10113,13 @@ static bool zend_try_ct_eval_array(zval *result, zend_ast *ast) /* {{{ */
 			if (elem_ast->attr /* by_ref */ || elem_ast->child[0]->kind != ZEND_AST_ZVAL
 				|| (elem_ast->child[1] && elem_ast->child[1]->kind != ZEND_AST_ZVAL)
 			) {
-				is_constant = 0;
+				is_constant = false;
 			}
 		} else {
 			zend_eval_const_expr(&elem_ast->child[0]);

 			if (elem_ast->child[0]->kind != ZEND_AST_ZVAL) {
-				is_constant = 0;
+				is_constant = false;
 			}
 		}

@@ -10604,7 +10604,7 @@ static void zend_compile_assign_coalesce(znode *result, zend_ast *ast) /* {{{ */
 	znode var_node_is, var_node_w, default_node, assign_node, *node;
 	zend_op *opline;
 	uint32_t coalesce_opnum;
-	bool need_frees = 0;
+	bool need_frees = false;

 	/* Remember expressions compiled during the initial BP_VAR_IS lookup,
 	 * to avoid double-evaluation when we compile again with BP_VAR_W. */
@@ -10673,7 +10673,7 @@ static void zend_compile_assign_coalesce(znode *result, zend_ast *ast) /* {{{ */

 	ZEND_HASH_FOREACH_PTR(CG(memoized_exprs), node) {
 		if (node->op_type == IS_TMP_VAR || node->op_type == IS_VAR) {
-			need_frees = 1;
+			need_frees = true;
 			break;
 		}
 	} ZEND_HASH_FOREACH_END();
@@ -10939,7 +10939,7 @@ static void zend_compile_array(znode *result, zend_ast *ast) /* {{{ */
 	zend_ast_list *list = zend_ast_get_list(ast);
 	zend_op *opline;
 	uint32_t i, opnum_init = -1;
-	bool packed = 1;
+	bool packed = true;

 	if (zend_try_ct_eval_array(&result->u.constant, ast)) {
 		result->op_type = IS_CONST;
@@ -11000,7 +11000,7 @@ static void zend_compile_array(znode *result, zend_ast *ast) /* {{{ */
 		opline->extended_value |= by_ref;

 		if (key_ast && key_node.op_type == IS_CONST && Z_TYPE(key_node.u.constant) == IS_STRING) {
-			packed = 0;
+			packed = false;
 		}
 	}

--- a/Zend/zend_exceptions.c
+++ b/Zend/zend_exceptions.c
@@ -401,7 +401,7 @@ ZEND_METHOD(ErrorException, __construct)
 {
 	zend_string *message = NULL, *filename = NULL;
 	zend_long   code = 0, severity = E_ERROR, lineno;
-	bool lineno_is_null = 1;
+	bool lineno_is_null = true;
 	zval   tmp, *object, *previous = NULL;

 	if (zend_parse_parameters(ZEND_NUM_ARGS(), "|SllS!l!O!", &message, &code, &severity, &filename, &lineno, &lineno_is_null, &previous, zend_ce_throwable) == FAILURE) {
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -874,7 +874,7 @@ zend_result zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_
 	for (i=0; i<fci->param_count; i++) {
 		zval *param = ZEND_CALL_ARG(call, i+1);
 		zval *arg = &fci->params[i];
-		bool must_wrap = 0;
+		bool must_wrap = false;
 		if (UNEXPECTED(Z_ISUNDEF_P(arg))) {
 			/* Allow forwarding undef slots. This is only used by Closure::__invoke(). */
 			ZVAL_UNDEF(param);
@@ -888,7 +888,7 @@ zend_result zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_
 					/* By-value send is not allowed -- emit a warning,
 					 * and perform the call with the value wrapped in a reference. */
 					zend_param_must_be_ref(func, i + 1);
-					must_wrap = 1;
+					must_wrap = true;
 					if (UNEXPECTED(EG(exception))) {
 						ZEND_CALL_NUM_ARGS(call) = i;
 cleanup_args:
@@ -922,13 +922,13 @@ cleanup_args:
 		zend_string *name;
 		zval *arg;
 		uint32_t arg_num = ZEND_CALL_NUM_ARGS(call) + 1;
-		bool have_named_params = 0;
+		bool have_named_params = false;
 		ZEND_HASH_FOREACH_STR_KEY_VAL(fci->named_params, name, arg) {
-			bool must_wrap = 0;
+			bool must_wrap = false;
 			zval *target;
 			if (name) {
 				void *cache_slot[2] = {NULL, NULL};
-				have_named_params = 1;
+				have_named_params = true;
 				target = zend_handle_named_arg(&call, name, &arg_num, cache_slot);
 				if (!target) {
 					goto cleanup_args;
@@ -950,7 +950,7 @@ cleanup_args:
 						/* By-value send is not allowed -- emit a warning,
 						 * and perform the call with the value wrapped in a reference. */
 						zend_param_must_be_ref(func, arg_num);
-						must_wrap = 1;
+						must_wrap = true;
 						if (UNEXPECTED(EG(exception))) {
 							goto cleanup_args;
 						}
--- a/Zend/zend_gc.c
+++ b/Zend/zend_gc.c
@@ -512,10 +512,10 @@ static void root_buffer_dtor(zend_gc_globals *gc_globals)

 static void gc_globals_ctor_ex(zend_gc_globals *gc_globals)
 {
-	gc_globals->gc_enabled = 0;
-	gc_globals->gc_active = 0;
-	gc_globals->gc_protected = 1;
-	gc_globals->gc_full = 0;
+	gc_globals->gc_enabled = false;
+	gc_globals->gc_active = false;
+	gc_globals->gc_protected = true;
+	gc_globals->gc_full = false;

 	gc_globals->buf = NULL;
 	gc_globals->unused = GC_INVALID;
@@ -1974,8 +1974,8 @@ static zend_never_inline void gc_call_destructors_in_fiber(uint32_t end)
 ZEND_API int zend_gc_collect_cycles(void)
 {
 	int total_count = 0;
-	bool should_rerun_gc = 0;
-	bool did_rerun_gc = 0;
+	bool should_rerun_gc = false;
+	bool did_rerun_gc = false;

 	zend_hrtime_t start_time = zend_hrtime();
 	if (GC_G(num_roots) && !GC_G(gc_active)) {
@@ -2029,7 +2029,7 @@ rerun_gc:
 			 * modify any refcounts, so we have no real way to detect this situation
 			 * short of rerunning full GC tracing. What we do instead is to only run
 			 * destructors at this point and automatically re-run GC afterwards. */
-			should_rerun_gc = 1;
+			should_rerun_gc = true;

 			/* Mark all roots for which a dtor will be invoked as DTOR_GARBAGE. Additionally
 			 * color them purple. This serves a double purpose: First, they should be
@@ -2155,7 +2155,7 @@ rerun_gc:
 	 * up. We do this only once: If we encounter more destructors on the second run, we'll not
 	 * run GC another time. */
 	if (should_rerun_gc && !did_rerun_gc) {
-		did_rerun_gc = 1;
+		did_rerun_gc = true;
 		goto rerun_gc;
 	}

--- a/Zend/zend_gdb.c
+++ b/Zend/zend_gdb.c
@@ -109,7 +109,7 @@ ZEND_API void zend_gdb_unregister_all(void)

 ZEND_API bool zend_gdb_present(void)
 {
-	bool ret = 0;
+	bool ret = false;
 #if defined(__linux__) /* netbsd while having this procfs part, does not hold the tracer pid */
 	int fd = open("/proc/self/status", O_RDONLY);

@@ -133,7 +133,7 @@ ZEND_API bool zend_gdb_present(void)
 					snprintf(buf, sizeof(buf), "/proc/%d/exe", (int)pid);
 					if (readlink(buf, out, sizeof(out) - 1) > 0) {
 						if (strstr(out, "gdb")) {
-							ret = 1;
+							ret = true;
 						}
 					}
 				}
--- a/Zend/zend_inheritance.c
+++ b/Zend/zend_inheritance.c
@@ -475,7 +475,7 @@ static inheritance_status zend_is_class_subtype_of_type(
 		zend_class_entry *fe_scope, zend_string *fe_class_name,
 		zend_class_entry *proto_scope, const zend_type proto_type) {
 	zend_class_entry *fe_ce = NULL;
-	bool have_unresolved = 0;
+	bool have_unresolved = false;

 	/* If the parent has 'object' as a return type, any class satisfies the co-variant check */
 	if (ZEND_TYPE_FULL_MASK(proto_type) & MAY_BE_OBJECT) {
@@ -484,7 +484,7 @@ static inheritance_status zend_is_class_subtype_of_type(
 		 * are not classes (such as typedefs). */
 		if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name);
 		if (!fe_ce) {
-			have_unresolved = 1;
+			have_unresolved = true;
 		} else {
 			track_class_dependency(fe_ce, fe_class_name);
 			return INHERITANCE_SUCCESS;
@@ -495,7 +495,7 @@ static inheritance_status zend_is_class_subtype_of_type(
 	if (ZEND_TYPE_FULL_MASK(proto_type) & MAY_BE_CALLABLE) {
 		if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name);
 		if (!fe_ce) {
-			have_unresolved = 1;
+			have_unresolved = true;
 		} else if (fe_ce == zend_ce_closure) {
 			track_class_dependency(fe_ce, fe_class_name);
 			return INHERITANCE_SUCCESS;
@@ -506,7 +506,7 @@ static inheritance_status zend_is_class_subtype_of_type(
 	if ((ZEND_TYPE_FULL_MASK(proto_type) & MAY_BE_STATIC) && (fe_scope->ce_flags & ZEND_ACC_FINAL)) {
 		if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name);
 		if (!fe_ce) {
-			have_unresolved = 1;
+			have_unresolved = true;
 		} else if (fe_ce == fe_scope) {
 			track_class_dependency(fe_ce, fe_class_name);
 			return INHERITANCE_SUCCESS;
@@ -530,7 +530,7 @@ static inheritance_status zend_is_class_subtype_of_type(
 					}
 					continue;
 				case INHERITANCE_UNRESOLVED:
-					have_unresolved = 1;
+					have_unresolved = true;
 					continue;
 				case INHERITANCE_SUCCESS:
 					if (!is_intersection) {
@@ -562,7 +562,7 @@ static inheritance_status zend_is_class_subtype_of_type(
 		}

 		if (!fe_ce || !proto_ce) {
-			have_unresolved = 1;
+			have_unresolved = true;
 			continue;
 		}
 		if (unlinked_instanceof(fe_ce, proto_ce)) {
--- a/Zend/zend_ini.c
+++ b/Zend/zend_ini.c
@@ -515,7 +515,7 @@ ZEND_API zend_string *zend_ini_str_ex(const char *name, size_t name_length, bool
 	ini_entry = zend_hash_str_find_ptr(EG(ini_directives), name, name_length);
 	if (ini_entry) {
 		if (exists) {
-			*exists = 1;
+			*exists = true;
 		}

 		if (orig && ini_entry->modified) {
@@ -525,7 +525,7 @@ ZEND_API zend_string *zend_ini_str_ex(const char *name, size_t name_length, bool
 		}
 	} else {
 		if (exists) {
-			*exists = 0;
+			*exists = false;
 		}
 		return NULL;
 	}
@@ -534,7 +534,7 @@ ZEND_API zend_string *zend_ini_str_ex(const char *name, size_t name_length, bool

 ZEND_API zend_string *zend_ini_str(const char *name, size_t name_length, bool orig) /* {{{ */
 {
-	bool exists = 1;
+	bool exists = true;
 	zend_string *return_value;

 	return_value = zend_ini_str_ex(name, name_length, orig, &exists);
--- a/Zend/zend_interfaces.c
+++ b/Zend/zend_interfaces.c
@@ -496,7 +496,7 @@ static zend_object *zend_internal_iterator_create(zend_class_entry *ce) {
 	zend_internal_iterator *intern = emalloc(sizeof(zend_internal_iterator));
 	zend_object_std_init(&intern->std, ce);
 	intern->iter = NULL;
-	intern->rewind_called = 0;
+	intern->rewind_called = false;
 	return &intern->std;
 }

@@ -537,7 +537,7 @@ static zend_internal_iterator *zend_internal_iterator_fetch(zval *This) {
 static zend_result zend_internal_iterator_ensure_rewound(zend_internal_iterator *intern) {
 	if (!intern->rewind_called) {
 		zend_object_iterator *iter = intern->iter;
-		intern->rewind_called = 1;
+		intern->rewind_called = true;
 		if (iter->funcs->rewind) {
 			iter->funcs->rewind(iter);
 			if (UNEXPECTED(EG(exception))) {
@@ -630,7 +630,7 @@ ZEND_METHOD(InternalIterator, rewind) {
 		RETURN_THROWS();
 	}

-	intern->rewind_called = 1;
+	intern->rewind_called = true;
 	if (!intern->iter->funcs->rewind) {
 		/* Allow calling rewind() if no iteration has happened yet,
 		 * even if the iterator does not support rewinding. */
--- a/Zend/zend_object_handlers.c
+++ b/Zend/zend_object_handlers.c
@@ -2418,7 +2418,7 @@ lazy_init:
 		if (!value || (Z_PROP_FLAG_P(value) & IS_PROP_LAZY)) {
 			zobj = zend_lazy_object_init(zobj);
 			if (!zobj) {
-				result = 0;
+				result = false;
 				goto exit;
 			}

@@ -2436,7 +2436,7 @@ lazy_init:
 		}
 	}

-	result = 0;
+	result = false;
 	goto exit;
 }
 /* }}} */
--- a/Zend/zend_operators.c
+++ b/Zend/zend_operators.c
@@ -377,7 +377,7 @@ static zend_always_inline zend_result zendi_try_convert_scalar_to_number(zval *o

 static zend_never_inline zend_long ZEND_FASTCALL zendi_try_get_long(const zval *op, bool *failed) /* {{{ */
 {
-	*failed = 0;
+	*failed = false;
 try_again:
 	switch (Z_TYPE_P(op)) {
 		case IS_NULL:
@@ -389,7 +389,7 @@ try_again:
 			double dval = Z_DVAL_P(op);
 			zend_long lval = zend_dval_to_lval_safe(dval);
 			if (UNEXPECTED(EG(exception))) {
-				*failed = 1;
+				*failed = true;
 			}
 			return lval;
 		}
@@ -405,7 +405,7 @@ try_again:
 				type = is_numeric_string_ex(Z_STRVAL_P(op), Z_STRLEN_P(op), &lval, &dval,
 					/* allow errors */ true, NULL, &trailing_data);
 				if (type == 0) {
-					*failed = 1;
+					*failed = true;
 					return 0;
 				}
 				if (UNEXPECTED(trailing_data)) {
@@ -414,7 +414,7 @@ try_again:
 					}
 					zend_error(E_WARNING, "A non-numeric value encountered");
 					if (UNEXPECTED(EG(exception))) {
-						*failed = 1;
+						*failed = true;
 						zend_tmp_string_release(op_str);
 						return 0;
 					}
@@ -435,7 +435,7 @@ try_again:
 					if (!zend_is_long_compatible(dval, lval)) {
 						zend_incompatible_string_to_long_error(op_str);
 						if (UNEXPECTED(EG(exception))) {
-							*failed = 1;
+							*failed = true;
 						}
 					}
 					zend_string_release(op_str);
@@ -447,7 +447,7 @@ try_again:
 				zval dst;
 				if (Z_OBJ_HT_P(op)->cast_object(Z_OBJ_P(op), &dst, IS_LONG) == FAILURE
 						|| EG(exception)) {
-					*failed = 1;
+					*failed = true;
 					return 0;
 				}
 				ZEND_ASSERT(Z_TYPE(dst) == IS_LONG);
@@ -455,7 +455,7 @@ try_again:
 			}
 		case IS_RESOURCE:
 		case IS_ARRAY:
-			*failed = 1;
+			*failed = true;
 			return 0;
 		case IS_REFERENCE:
 			op = Z_REFVAL_P(op);
--- a/Zend/zend_strtod.c
+++ b/Zend/zend_strtod.c
@@ -4535,10 +4535,10 @@ ZEND_API char *zend_gcvt(double value, int ndigit, char dec_point, char exponent
 	if ((decpt >= 0 && decpt > ndigit) || decpt < -3) { /* use E-style */
 		/* exponential format (e.g. 1.2345e+13) */
 		if (--decpt < 0) {
-			sign = 1;
+			sign = true;
 			decpt = -decpt;
 		} else {
-			sign = 0;
+			sign = false;
 		}
 		src = digits;
 		*dst++ = *src++;
--- a/Zend/zend_virtual_cwd.c
+++ b/Zend/zend_virtual_cwd.c
@@ -524,11 +524,11 @@ static size_t tsrm_realpath_r(char *path, size_t start, size_t len, int *ll, tim
 			(i + 1 == len && path[i] == '.')) {
 			/* remove double slashes and '.' */
 			len = EXPECTED(i > 0) ? i - 1 : 0;
-			is_dir = 1;
+			is_dir = true;
 			continue;
 		} else if (i + 2 == len && path[i] == '.' && path[i+1] == '.') {
 			/* remove '..' and previous directory */
-			is_dir = 1;
+			is_dir = true;
 			if (link_is_dir) {
 				*link_is_dir = 1;
 			}