/*
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
   | Copyright (c) Zend Technologies Ltd. (http://www.zend.com)           |
   +----------------------------------------------------------------------+
   | This source file is subject to version 2.00 of the Zend license,     |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | http://www.zend.com/license/2_00.txt.                                |
   | If you did not receive a copy of the Zend license and are unable to  |
   | obtain it through the world-wide-web, please send a note to          |
   | license@zend.com so we can mail you a copy immediately.              |
   +----------------------------------------------------------------------+
   | Authors: Gina Peter Banyard <girgias@php.net>                        |
   +----------------------------------------------------------------------+
*/

#include "zend.h"
#include "zend_API.h"
#include "zend_autoload.h"
#include "zend_hash.h"
#include "zend_types.h"
#include "zend_exceptions.h"
#include "zend_string.h"

ZEND_TLS HashTable *zend_class_autoload_functions;

static void zend_autoload_callback_zval_destroy(zval *element)
{
	zend_fcall_info_cache *fcc = Z_PTR_P(element);
	zend_fcc_dtor(fcc);
	efree(fcc);
}

static Bucket *autoload_find_registered_function(const HashTable *autoloader_table, const zend_fcall_info_cache *function_entry)
{
	zend_fcall_info_cache *current_function_entry;
	ZEND_HASH_MAP_FOREACH_PTR(autoloader_table, current_function_entry) {
		if (zend_fcc_equals(current_function_entry, function_entry)) {
			return _p;
		}
	} ZEND_HASH_FOREACH_END();
	return NULL;
}

ZEND_API zend_class_entry *zend_perform_class_autoload(zend_string *class_name, zend_string *lc_name)
{
	if (!zend_class_autoload_functions) {
		return NULL;
	}

	zval zname;
	ZVAL_STR(&zname, class_name);

	const HashTable *class_autoload_functions = zend_class_autoload_functions;

	/* Cannot use ZEND_HASH_MAP_FOREACH_PTR here as autoloaders may be
	 * added/removed during autoloading. */
	HashPosition pos;
	zend_hash_internal_pointer_reset_ex(class_autoload_functions, &pos);
	while (true) {
		zend_fcall_info_cache *func_info = zend_hash_get_current_data_ptr_ex(class_autoload_functions, &pos);
		if (!func_info) {
			break;
		}
		zend_call_known_fcc(func_info, /* retval */ NULL, /* param_count */ 1, /* params */ &zname, /* named_params */ NULL);

		if (EG(exception)) {
			return NULL;
		}
		if (ZSTR_HAS_CE_CACHE(class_name) && ZSTR_GET_CE_CACHE(class_name)) {
			return (zend_class_entry*)ZSTR_GET_CE_CACHE(class_name);
		}

		zend_class_entry *ce = zend_hash_find_ptr(EG(class_table), lc_name);
		if (ce) {
			return ce;
		}

		zend_hash_move_forward_ex(class_autoload_functions, &pos);
	}
	return NULL;
}

/* Needed for compatibility with spl_register_autoload() */
ZEND_API void zend_autoload_register_class_loader(zend_fcall_info_cache *fcc, bool prepend)
{
	ZEND_ASSERT(ZEND_FCC_INITIALIZED(*fcc));

	if (!zend_class_autoload_functions) {
		ALLOC_HASHTABLE(zend_class_autoload_functions);
		zend_hash_init(zend_class_autoload_functions, 1, NULL, zend_autoload_callback_zval_destroy, false);
		/* Initialize as non-packed hash table for prepend functionality. */
		zend_hash_real_init_mixed(zend_class_autoload_functions);
	}

	ZEND_ASSERT(
		fcc->function_handler->type != ZEND_INTERNAL_FUNCTION
		|| !zend_string_equals_literal(fcc->function_handler->common.function_name, "spl_autoload_call")
	);

	/* If function is already registered, don't do anything */
	if (autoload_find_registered_function(zend_class_autoload_functions, fcc)) {
		/* Release potential call trampoline */
		zend_release_fcall_info_cache(fcc);
		return;
	}

	zend_fcc_addref(fcc);
	zend_hash_next_index_insert_mem(zend_class_autoload_functions, fcc, sizeof(zend_fcall_info_cache));
	if (prepend && zend_hash_num_elements(zend_class_autoload_functions) > 1) {
		/* Move the newly created element to the head of the hashtable */
		ZEND_ASSERT(!HT_IS_PACKED(zend_class_autoload_functions));
		Bucket tmp = zend_class_autoload_functions->arData[zend_class_autoload_functions->nNumUsed-1];
		memmove(zend_class_autoload_functions->arData + 1, zend_class_autoload_functions->arData, sizeof(Bucket) * (zend_class_autoload_functions->nNumUsed - 1));
		zend_class_autoload_functions->arData[0] = tmp;
		zend_hash_rehash(zend_class_autoload_functions);
	}
}

ZEND_API bool zend_autoload_unregister_class_loader(const zend_fcall_info_cache *fcc) {
	if (zend_class_autoload_functions) {
		Bucket *p = autoload_find_registered_function(zend_class_autoload_functions, fcc);
		if (p) {
			zend_hash_del_bucket(zend_class_autoload_functions, p);
			return true;
		}
	}
	return false;
}

/* We do not return a HashTable* because zend_empty_array is not collectable,
 * therefore the zval holding this value must do so. Something that ZVAL_EMPTY_ARRAY(); does. */
ZEND_API void zend_autoload_fcc_map_to_callable_zval_map(zval *return_value) {
	if (zend_class_autoload_functions) {
		zend_fcall_info_cache *fcc;

		zend_array *map = zend_new_array(zend_hash_num_elements(zend_class_autoload_functions));
		ZEND_HASH_MAP_FOREACH_PTR(zend_class_autoload_functions, fcc) {
			zval tmp;
			zend_get_callable_zval_from_fcc(fcc, &tmp);
			zend_hash_next_index_insert(map, &tmp);
		} ZEND_HASH_FOREACH_END();
		RETURN_ARR(map);
	}
	RETURN_EMPTY_ARRAY();
}

/* Only for deprecated strange behaviour of spl_autoload_unregister() */
ZEND_API void zend_autoload_clean_class_loaders(void)
{
	if (zend_class_autoload_functions) {
		/* Don't destroy the hash table, as we might be iterating over it right now. */
		zend_hash_clean(zend_class_autoload_functions);
	}
}

void zend_autoload_shutdown(void)
{
	if (zend_class_autoload_functions) {
		zend_hash_destroy(zend_class_autoload_functions);
		FREE_HASHTABLE(zend_class_autoload_functions);
		zend_class_autoload_functions = NULL;
	}
}