php-src/ext/sablot/sablot.c

/*
   +----------------------------------------------------------------------+
   | PHP version 4.0                                                      |
   +----------------------------------------------------------------------+
   | Copyright (c) 1997, 1998, 1999, 2000 The PHP Group                   |
   +----------------------------------------------------------------------+
   | This source file is subject to version 2.02 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
   | available at through the world-wide-web at                           |
   | http://www.php.net/license/2_02.txt.                                 |
   | If you did not receive a copy of the PHP license and are unable to   |
   | obtain it through the world-wide-web, please send a note to          |
   | license@php.net so we can mail you a copy immediately.               |
   +----------------------------------------------------------------------+
   | Authors: Sterling Hughes <sterling@php.net>                          |
   +----------------------------------------------------------------------+
 */

#include "php.h"

#if HAVE_SABLOT

#include <sablot.h>
#include <string.h>
#include <stdarg.h>
#include "ext/standard/php_output.h"
#include "php_sablot.h"

/* Functions related to PHP's list handling */
static void _php_sablot_free_processor(php_sablot *handle);

/* SAX Handlers */
static void _php_sablot_handler_pair(php_sablot *handle, zval **first_func, zval **second_func, zval **indiv_handlers);
static void _php_sablot_call_handler_function(zval *handlerName, int argc, zval **args, char *function_name);
static SAX_RETURN _php_sablot_sax_startDoc(void *userData);
static SAX_RETURN _php_sablot_sax_startElement(void *userData, const char *name, const char **attributes);
static SAX_RETURN _php_sablot_sax_endElement(void *userData, const char *name);
static SAX_RETURN _php_sablot_sax_startNamespace(void *userData, const char *prefix, const char *uri);
static SAX_RETURN _php_sablot_sax_endNamespace(void *userData, const char *prefix);
static SAX_RETURN _php_sablot_sax_comment(void *userData, const char *contents);
static SAX_RETURN _php_sablot_sax_PI(void *userData, const char *target, const char *contents);
static SAX_RETURN _php_sablot_sax_characters(void *userData, const char *contents, int length);
static SAX_RETURN _php_sablot_sax_endDoc(void *userData);

/* Error Handling Functions */
#ifdef SABLOT_ERRORS
static MH_ERROR _php_sablot_make_code(void *userData, SablotHandle p, int severity, unsigned short facility, unsigned short code);
static MH_ERROR _php_sablot_error(void *userData, SablotHandle p, MH_ERROR code, MH_LEVEL level, char **fields);
#endif

/* PHP Utility Functions */
static void m_convert_to_string_ex(int argc, ...);
static zval *_php_xslt_string_zval(const char *str);
static zval *_php_xslt_resource_zval(long value);

/* Free macros */
#define S_FREE(var) if (var) efree(var);
#define FUNCH_FREE(var) if (var) zval_del_ref(&(var));


static SAXHandler sax = {
       _php_sablot_sax_startDoc,
       _php_sablot_sax_startElement,
       _php_sablot_sax_endElement,
       _php_sablot_sax_startNamespace,
       _php_sablot_sax_endNamespace,
       _php_sablot_sax_comment,
       _php_sablot_sax_PI,
       _php_sablot_sax_characters,
       _php_sablot_sax_endDoc
};

#ifdef SABLOT_ERRORS
static MessageHandler mh = {
	_php_sablot_make_code,
	_php_sablot_error,
	_php_sablot_error
};
#endif

/* {{{ Begin PHP Extension code */

#ifdef ZTS
int sablot_globals_id;
#else
php_sablot_globals sablot_globals;
#endif


static unsigned char sixth_arg_force_ref[] = { 6, BYREF_NONE, BYREF_NONE, BYREF_NONE, BYREF_NONE, BYREF_NONE, BYREF_FORCE };
static unsigned char third_arg_force_ref[] = { 4, BYREF_NONE, BYREF_NONE, BYREF_FORCE, BYREF_NONE };

function_entry sablot_functions[] = {
	PHP_FE(xslt_output_begintransform,    NULL)
	PHP_FE(xslt_output_endtransform,      NULL)
	PHP_FE(xslt_transform,                sixth_arg_force_ref)
	PHP_FE(xslt_process,                  third_arg_force_ref)
	PHP_FE(xslt_create,                   NULL)
	PHP_FE(xslt_run,                      NULL)
	PHP_FE(xslt_fetch_result,             NULL)
	PHP_FE(xslt_openlog,                  NULL)
	PHP_FE(xslt_closelog,                 NULL)
	PHP_FE(xslt_set_sax_handler,          NULL)
	PHP_FE(xslt_free,                     NULL)
	PHP_FE(xslt_error,                    NULL)
	PHP_FE(xslt_errno,                    NULL)
	{NULL, NULL, NULL}
};

zend_module_entry sablot_module_entry = {
	"sablot",
	sablot_functions,
	PHP_MINIT(sablot),
	NULL,
	NULL,
	NULL,
	PHP_MINFO(sablot),
	STANDARD_MODULE_PROPERTIES
};

#ifdef COMPILE_DL_SABLOT
ZEND_GET_MODULE(sablot)
#endif

/* }}} */


/* {{{ MINIT and MINFO Functions */
PHP_MINIT_FUNCTION(sablot)
{
	SABLOTLS_FETCH();
	SABLOTG(le_sablot) = register_list_destructors(_php_sablot_free_processor, NULL);
	return SUCCESS;
}

PHP_MINFO_FUNCTION(sablot)
{
	php_info_print_table_start();
	php_info_print_table_header(2, "Sablotron support", "enabled");
	php_info_print_table_end();

}
/* }}} */

/* }}} */

/* {{{ Begin Extension function */

/* {{{ Begin Output Transformation functions */

/* {{{ void xslt_output_begintransform(string file)
   Begin filtering of all data that is being printed out through the XSL file given by the file parameter. */
PHP_FUNCTION(xslt_output_begintransform)
{
	zval **file;
	SABLOTLS_FETCH();
	
	if (ZEND_NUM_ARGS() != 1 ||
	    zend_get_parameters_ex(1, &file) == FAILURE) {
		WRONG_PARAM_COUNT;
	}
	convert_to_string_ex(file);
	
	S_FREE(SABLOTG(output_transform_file));
		
	SABLOTG(output_transform_file) = estrndup(Z_STRVAL_PP(file), Z_STRLEN_PP(file));
	php_start_ob_buffer();
}
/* }}} */

/* {{{ void xslt_output_endtranform(void)
   End filtering that data through the XSL file set by xslt_output_transform() and output the data */
PHP_FUNCTION(xslt_output_endtransform)
{
	zval **buffer;
	int ret = 0;
	char *tRes = NULL;
	OLS_FETCH();

	if (OG(nesting_level) == 0) {
		return;
	}
	ZVAL_STRINGL(*buffer, OG(active_ob_buffer).buffer, OG(active_ob_buffer).text_length, 1);
	
	if (Z_STRVAL_PP(buffer)) {
		char *args[] = {"/_xmlinput", Z_STRVAL_PP(buffer),
		                "/_output",   NULL};
		
		ret = SablotProcess(SABLOTG(output_transform_file), "arg:/_xmlinput", "arg:/_output", NULL, args, &tRes);
		
		if (ret) {
			php_error(E_WARNING, "Error [%d]: %s", ret, SablotGetMsgText(ret));
			SABLOTG(last_errno) = ret;
			S_FREE(SABLOTG(output_transform_file));
			return;
		}
		
		php_end_ob_buffer(0);
		
		PUTS(tRes);
		S_FREE(SABLOTG(output_transform_file));
		
		if (tRes)
			SablotFree(tRes);
	} else {
		php_end_ob_buffer(0);
	}
}
/* }}} */

/* }}} */

/* {{{ Begin Simple API */

/* {{{ bool xslt_transform(string xslt_uri, string transform_uri, string result_uri[, array xslt_params[, array xslt_args[, string &result]]])
   Transform an XML document, transform_uri, with an XSL stylesheet, xslt_uri with parameters, xslt_params, into the Result buffer, result_uri, xslt_args defines the variables in xslt_uri, transform_uri and result_uri. */
PHP_FUNCTION(xslt_transform)
{
	zval **xslt_uri, **transform_uri, **result_uri,
	     **xslt_params, **xslt_args, **result, **value;
	
	char **args   = NULL,
	     **params = NULL,
	     *tResult = NULL,
	     *string_key;
	
	int argc = ZEND_NUM_ARGS(), ret = 0;
	ulong num_key;
	SABLOTLS_FETCH();
	
	if (argc < 3 || argc > 6 ||
	    zend_get_parameters_ex(argc, &xslt_uri, &transform_uri, &result_uri, &xslt_params, &xslt_args, &result) == FAILURE) {
		WRONG_PARAM_COUNT;
	}
	m_convert_to_string_ex(3, xslt_uri, transform_uri, result_uri);
	
	if (argc > 3) {
		if (Z_TYPE_PP(xslt_params) != IS_LONG || Z_LVAL_PP(xslt_params) != 0) {
			int numelems, size, i=0;
			HashTable *ar = HASH_OF(*xslt_params);

			numelems = zend_hash_num_elements(ar);
			size = (numelems * 2 + 1) * sizeof(char *);
			
			params = (char **)emalloc(size+1);
			memset((char *)params, 0, size);
			
			for (zend_hash_internal_pointer_reset(ar);
			     zend_hash_get_current_data(ar, (void **)&value) == SUCCESS;
			     zend_hash_move_forward(ar)) {
				SEPARATE_ZVAL(value);
				convert_to_string_ex(value);
				
				if (zend_hash_get_current_key(ar, &string_key, &num_key) == HASH_KEY_IS_LONG) {
					params[i++] = Z_STRVAL_PP(value);
					continue;
				}
				
				params[i++] = string_key;
				params[i++] = Z_STRVAL_PP(value);
			}
			params[i] = NULL;
		}
	}
	
	if (argc > 4) {
		if (Z_TYPE_PP(xslt_args) != IS_LONG || Z_LVAL_PP(xslt_args) != 0) {
			int numelems, size, i=0;
			HashTable *ar = HASH_OF(*xslt_args);

			numelems = zend_hash_num_elements(ar);
			size = (numelems * 2 + 1) * sizeof(char *);
			
			args = (char **)emalloc(size+1);
			memset((char *)args, 0, size);
			
			for (zend_hash_internal_pointer_reset(ar);
			     zend_hash_get_current_data(ar, (void **)&value) == SUCCESS;
			     zend_hash_move_forward(ar)) {
				SEPARATE_ZVAL(value);
				convert_to_string_ex(value);
				
				if (zend_hash_get_current_key(ar, &string_key, &num_key) == HASH_KEY_IS_LONG) {
					args[i++] = Z_STRVAL_PP(value);
					continue;
				}
				
				args[i++] = string_key;
				args[i++] = Z_STRVAL_PP(value);
			}
			args[i] = NULL;
		}
	}
	
	ret = SablotProcess(Z_STRVAL_PP(xslt_uri), Z_STRVAL_PP(transform_uri),
	                    Z_STRVAL_PP(result_uri), params, args, &tResult);
	
	if (ret) {
		SABLOTG(last_errno) = ret;
		
		S_FREE(params);
		S_FREE(args);
		if (tResult)
			SablotFree(tResult);
		
		RETURN_FALSE;
	} else { RETVAL_TRUE; }


	if (tResult &&
	    argc == 6) {
		ZVAL_STRING(*result, tResult, 1);
	}
	
	S_FREE(params);
	S_FREE(args);
	
	if (tResult)
		SablotFree(tResult);
}
/* }}} */

/* {{{ bool xslt_process(string xslt, string input_str, string &result[, string base])
   Process data given by input_str through xslt and place the results in the string result.  If base is supplied, it will be used as the base URI. */
PHP_FUNCTION(xslt_process)
{
	zval **xslt, **input, **result, **base;
	char *tRes = NULL;
	int ret = 0, argc = ZEND_NUM_ARGS();
	SABLOTLS_FETCH();
	
	if (argc < 3 || argc > 4 ||
	    zend_get_parameters_ex(argc, &xslt, &input, &result, &base) == FAILURE) {
		WRONG_PARAM_COUNT;
	}
	m_convert_to_string_ex(2, xslt, input);
	
	if (argc > 3) {
		convert_to_string_ex(base);
		ret = SablotProcessStringsWithBase(Z_STRVAL_PP(xslt), Z_STRVAL_PP(input), &tRes, Z_STRVAL_PP(base));
	} else {
		ret = SablotProcessStrings(Z_STRVAL_PP(xslt), Z_STRVAL_PP(input), &tRes);
	}
	
	if (ret) {
		SABLOTG(last_errno) = ret;
		if (tRes)
			SablotFree(tRes);
		RETURN_FALSE;
	}

	if (tRes) {
		ZVAL_STRING(*result, tRes, 1);
		SablotFree(tRes);
	}
	RETURN_TRUE;
}
/* }}} */

/* }}} */

/* {{{ Begin Advanced Resource API */

/* {{{ proto resource xslt_create(void)
   Create a new XSL processor and return a resource identifier. */
PHP_FUNCTION(xslt_create)
{
	php_sablot *handle;
	SablotHandle p;
	int ret;
	SABLOTLS_FETCH();

	ret = SablotCreateProcessor(&p);
	
	if (ret) {
		SABLOTG(last_errno) = ret;
		RETURN_FALSE;
	}
	
	handle = (php_sablot *)emalloc(sizeof(php_sablot));
	if (!handle) {
		php_error(E_WARNING, "Couldn't allocate PHP-Sablotron Handle");
		RETURN_FALSE;
	}
	memset(handle, 0, sizeof(php_sablot));
	
	handle->p = p;
	ret = SablotRegHandler(handle->p, HLR_SAX, (void *)&sax, (void *)handle);
	
	if (ret) {
		SABLOTG(last_errno) = ret;
		RETURN_FALSE;
	}

#ifdef SABLOT_ERRORS	
	ret = SablotRegHandler(handle->p, HLR_MESSAGE, (void *)&mh, (void *)handle);
	
	if (ret) {
		SABLOTG(last_errno) = ret;
		RETURN_FALSE;
	}
#endif
	
	ZEND_REGISTER_RESOURCE(return_value, handle, SABLOTG(le_sablot));
	handle->index = Z_LVAL_P(return_value);
}
/* }}} */

/* {{{ proto bool xslt_run(resource xh, string xslt_file, string data_file[, string result[, array xslt_params[, array xslt_args]]])
   Process the file data_file with the XSL stylesheet xslt_file and parameters xslt_parameters place the results in the buffer pointed to by the result parameter (defaults to "/_result"), args contains the values of the variables in the other parameters.  */
PHP_FUNCTION(xslt_run)
{
	zval **xh, **xslt_file, **data_file, 
	     **xslt_result, **xslt_params, **xslt_args, **value;

	php_sablot *handle;
	char **args   = NULL,
	     **params = NULL,
	     *result  = NULL,
	     *string_key;
	
	int argc = ZEND_NUM_ARGS(),
	    ret  = 0;
	ulong num_key;

	SABLOTLS_FETCH();
	
	if (argc < 3 || argc > 6 ||
	    zend_get_parameters_ex(argc, &xh, &xslt_file, &data_file, &xslt_result, &xslt_params, &xslt_args) == FAILURE) {
		WRONG_PARAM_COUNT;
	}
	ZEND_FETCH_RESOURCE(handle, php_sablot *, xh, -1, "PHP-Sablotron handle", SABLOTG(le_sablot));
	m_convert_to_string_ex(2, xslt_file, data_file);
	
	if (argc == 3)
		result = estrdup("arg:/_result");
	
	if (argc > 3) {
		convert_to_string_ex(xslt_result);
		result = estrndup(Z_STRVAL_PP(xslt_result), Z_STRLEN_PP(xslt_result));
	}
	
	if (argc > 4) {
		if (Z_TYPE_PP(xslt_params) != IS_LONG || Z_LVAL_PP(xslt_params) != 0) { 
			int numelems, size, i=0;
			HashTable *ar = HASH_OF(*xslt_params);

			numelems = zend_hash_num_elements(ar);
			size = (numelems * 2 + 1) * sizeof(char *);
			
			params = (char **)emalloc(size+1);
			memset((char *)params, 0, size);
			
			for (zend_hash_internal_pointer_reset(ar);
			     zend_hash_get_current_data(ar, (void **)&value) == SUCCESS;
			     zend_hash_move_forward(ar)) {
				SEPARATE_ZVAL(value);
				convert_to_string_ex(value);
				
				if (zend_hash_get_current_key(ar, &string_key, &num_key) == HASH_KEY_IS_LONG) {
					params[i++] = Z_STRVAL_PP(value);
					continue;
				}
				
				params[i++] = string_key;
				params[i++] = Z_STRVAL_PP(value);
			}
			params[i] = NULL;
		}
	}
	
	if (argc > 5) {
		if (Z_TYPE_PP(xslt_args) != IS_LONG || Z_LVAL_PP(xslt_args) != 0) {
			int numelems, size, i=0;
			HashTable *ar = HASH_OF(*xslt_args);

			numelems = zend_hash_num_elements(ar);
			size = (numelems * 2 + 1) * sizeof(char *);
			
			args = (char **)emalloc(size+1);
			memset((char *)args, 0, size);
			
			for (zend_hash_internal_pointer_reset(ar);
			     zend_hash_get_current_data(ar, (void **)&value) == SUCCESS;
			     zend_hash_move_forward(ar)) {
				SEPARATE_ZVAL(value);
				convert_to_string_ex(value);
				
				if (zend_hash_get_current_key(ar, &string_key, &num_key) == HASH_KEY_IS_LONG) {
					args[i++] = Z_STRVAL_PP(value);
					continue;
				}
				
				args[i++] = string_key;
				args[i++] = Z_STRVAL_PP(value);
			}
			args[i] = NULL;
		}
	}
	
	ret = SablotRunProcessor(handle->p, Z_STRVAL_PP(xslt_file), Z_STRVAL_PP(data_file), result, params, args);
	
	if (ret) {
		handle->last_errno = ret;
		SABLOTG(last_errno) = ret;
		S_FREE(params);
		S_FREE(args);
		S_FREE(result);
		RETURN_FALSE;
	}
	
	S_FREE(params);
	S_FREE(args);
	S_FREE(result);
	
	RETURN_TRUE;
}
/* }}} */

/* {{{ proto bool xslt_openlog(resource xh, string logfile[, int loglevel])
   Sets a logfile for Sablotron to place all of its error messages */
PHP_FUNCTION(xslt_openlog)
{
	zval **xh, **logfile, **opt_loglevel;
	php_sablot *handle;
	int ret = 0, loglevel = 0, argc = ZEND_NUM_ARGS();
	
	if (argc < 2 || argc > 3 ||
	    zend_get_parameters_ex(argc, &xh, &logfile, &opt_loglevel) == FAILURE) {
		WRONG_PARAM_COUNT;
	}
	ZEND_FETCH_RESOURCE(handle, php_sablot *, xh, -1, "PHP-Sablotron", SABLOTG(le_sablot));
	convert_to_string_ex(logfile);
	
	if (argc > 2) {
		convert_to_long_ex(opt_loglevel);
		loglevel = Z_LVAL_PP(opt_loglevel);
	}
	
	ret = SablotSetLog(handle->p, (const char *)Z_STRVAL_PP(logfile), loglevel);
	
	if (ret) {
		handle->last_errno  = ret;
		SABLOTG(last_errno) = ret;
		RETURN_FALSE;
	} else {
		RETURN_TRUE;
	}
}
/* }}} */

/* {{{ proto bool xslt_closelog(resource xh)
   Clear the logfile for a given instance Sablotron */
PHP_FUNCTION(xslt_closelog)
{
	zval **xh;
	php_sablot *handle;
	int ret;
	SABLOTLS_FETCH();
	
	if (ZEND_NUM_ARGS() != 1 ||
	    zend_get_parameters_ex(1, &xh) == FAILURE) {
		WRONG_PARAM_COUNT;
	}
	ZEND_FETCH_RESOURCE(handle, php_sablot *, xh, -1, "PHP-Sablotron", SABLOTG(le_sablot));
	
	ret = SablotSetLog(handle->p, (const char *)NULL, 1);
	
	if (ret) {
		RETURN_FALSE;
	}
	RETURN_TRUE; 
}
/* }}} */

/* {{{ proto string xslt_fetch_result(resource xh[, string result_name])
   Fetch a result buffer on process handle, xh, with name, result_name, if name is not given than the "/_result" buffer is fetched. */
PHP_FUNCTION(xslt_fetch_result)
{
	zval **xh, **result_name;
	php_sablot *handle;
	char *rname, *value=NULL;
	int argc = ZEND_NUM_ARGS(), ret = 0;
	SABLOTLS_FETCH();

	if (argc < 1 || argc > 2 ||
	    zend_get_parameters_ex(argc, &xh, &result_name) == FAILURE) {
		WRONG_PARAM_COUNT;
	}
	ZEND_FETCH_RESOURCE(handle, php_sablot *, xh, -1, "PHP-Sablotron Handle", SABLOTG(le_sablot));
	
	if (argc > 1) {
		convert_to_string_ex(result_name);
		rname = Z_STRVAL_PP(result_name);
	} else {
		rname = "/_result";
	}
	
	ret = SablotGetResultArg(handle->p, rname, &value);
	
	if (ret) {
		handle->last_errno  = ret;
		SABLOTG(last_errno) = ret;
		PUTS((char *)SablotGetMsgText(ret));
		if (value)
			SablotFree(value);
		RETURN_FALSE;
	}
	
	if (value) {
		RETVAL_STRING(value, 1);
		SablotFree(value);
	}
}
/* }}} */

/* {{{ proto void xslt_free(resource xh)
   Free resources associated with a xslt handle. */
PHP_FUNCTION(xslt_free)
{
	zval **xh;
	php_sablot *handle;
	SABLOTLS_FETCH();
	
	if (ZEND_NUM_ARGS() != 1 ||
	    zend_get_parameters_ex(1, &xh) == FAILURE) {
		WRONG_PARAM_COUNT;
	}
	
	ZEND_FETCH_RESOURCE(handle, php_sablot *, xh, -1, "PHP-Sablotron Handle", SABLOTG(le_sablot));
	zend_list_delete(Z_LVAL_PP(xh));
}
/* }}} */

/* {{{ proto void xslt_set_sax_handler(resource xh, array handlers)
   Set SAX Handlers on the resource handle given by xh. */
PHP_FUNCTION(xslt_set_sax_handler)
{
	zval **xh, **handlers, **indiv_handlers, **handler;
	php_sablot *handle;
	HashTable *handlers_list;
	char *string_key = NULL;
	ulong num_key;
	SABLOTLS_FETCH();
	
	if (ZEND_NUM_ARGS() != 2 ||
	    zend_get_parameters_ex(2, &xh, &handlers) == FAILURE) {
		WRONG_PARAM_COUNT;
	}
	ZEND_FETCH_RESOURCE(handle, php_sablot *, xh, -1, "PHP-Sablotron Handle", SABLOTG(le_sablot));
	
	handlers_list = HASH_OF(*handlers);
	
	for (zend_hash_internal_pointer_reset(handlers_list);
	     zend_hash_get_current_data(handlers_list, (void **)&indiv_handlers) == SUCCESS;
	     zend_hash_move_forward(handlers_list)) {
		
		SEPARATE_ZVAL(indiv_handlers);
		
		if (zend_hash_get_current_key(handlers_list, &string_key, &num_key) == HASH_KEY_IS_LONG) {
			php_error(E_WARNING, "The Keys of the first dimension of your array must be strings");
			RETURN_FALSE;
		}
		
		
		if (!strcasecmp("document", string_key)) {
			_php_sablot_handler_pair(handle, 
			                         &handle->startDocHandler, &handle->endDocHandler,
			                         indiv_handlers);
		} else if (!strcasecmp("element", string_key)) {
			_php_sablot_handler_pair(handle, 
			                         &handle->startElementHandler, &handle->endElementHandler, 
			                         indiv_handlers);
		} else if (!strcasecmp("namespace", string_key)) {
			_php_sablot_handler_pair(handle,
			                         &handle->startNamespaceHandler, &handle->endNamespaceHandler, 
			                         indiv_handlers);
		} else if (!strcasecmp("comment", string_key)) {
			zval_add_ref(indiv_handlers);
			handle->commentHandler = *indiv_handlers;
		} else if (!strcasecmp("pi", string_key)) {
			zval_add_ref(indiv_handlers);
			handle->PIHandler = *indiv_handlers;
		} else if (!strcasecmp("characters", string_key)) {
			zval_add_ref(indiv_handlers);
			handle->charactersHandler = *indiv_handlers;
		} else {		
			php_error(E_WARNING, "Invalid option: %s", string_key);
		}
		
		S_FREE(string_key);
	}
}
/* }}} */

/* }}} */

/* {{{ Begin Error Handling functions */

/* {{{ proto mixed xslt_error([int xh])
   Return the error string related to a given error handle.  If no handle is given the last error that occurred anywhere is returned. */
PHP_FUNCTION(xslt_error)
{
	zval **xh;
	int errno;
	php_sablot *handle;
	int argc = ZEND_NUM_ARGS();
	
	if (argc < 0 || argc > 1 ||
	    zend_get_parameters_ex(argc, &xh) == FAILURE) {
		WRONG_PARAM_COUNT;
	}
	
	if (argc) {
		ZEND_FETCH_RESOURCE(handle, php_sablot *, xh, -1, "PHP-Sablotron Handle", SABLOTG(le_sablot));

#ifdef SABLOT_ERRORS		
		if (handle->errors) {
			if (array_init(return_value) == FAILURE) {
				php_error(E_WARNING, "Cannot initialize return array from xslt_error");
				RETURN_FALSE;
			}
		
			handle->errors = handle->errors_start.next;
			while (handle->errors) {
				add_assoc_string(return_value, handle->errors->key, handle->errors->value, 0);
				handle->errors = handle->errors->next;
			}
			add_assoc_string(return_value, "errstr", (char *)SablotGetMsgText(handle->last_errno), 1);
			add_assoc_long(return_value, "errno", handle->last_errno);
			return;
		}
#endif
		
		errno = handle->last_errno;
	} else {
		errno = SABLOTG(last_errno);
	}

	RETURN_STRING((char *)SablotGetMsgText(errno), 1);
}
/* }}} */

/* {{{ proto int xslt_errno([int xh])
   Return the error number related to a given error handle.  If no handle is given the last error number that occurred anywhere is returned. */
PHP_FUNCTION(xslt_errno)
{
	zval **xh;
	int errno;
	php_sablot *handle;
	int argc = ZEND_NUM_ARGS();
	
	if (argc < 0 || argc > 1 ||
	    zend_get_parameters_ex(argc, &xh) == FAILURE) {
		WRONG_PARAM_COUNT;
	}
	
	if (argc) {
		ZEND_FETCH_RESOURCE(handle, php_sablot *, xh, -1, "PHP-Sablotron Handle", SABLOTG(le_sablot));
		RETURN_LONG(handle->last_errno);
	} else {
		RETURN_LONG(SABLOTG(last_errno));
	}
}
/* }}} */

/* }}} */

/* }}} */

/* {{{ BEGIN HANDLER FUNCTIONS */

/* {{{ Begin SAX Handler functions */

/* {{{ _php_sablot_handler_pair()
   Set the handler functions from a two item array */
static void _php_sablot_handler_pair(php_sablot *handle, zval **first_func, zval **second_func, zval **indiv_handlers)
{
	HashTable *second_level = HASH_OF(*indiv_handlers);
	zval **handler;
	int item = 0;
		
	for (zend_hash_internal_pointer_reset(second_level);
	     zend_hash_get_current_data(second_level, (void **)&handler) == SUCCESS;
	     zend_hash_move_forward(second_level)) {
		
		SEPARATE_ZVAL(handler);
		zval_add_ref(handler);
	
		switch (item)
		{
			case 0:
				*first_func  = *handler;
				break;
			case 1:
				*second_func = *handler;
				break;
			default:
				convert_to_string_ex(handler);
				php_error(E_WARNING, "Sorry, too many elements, %s discarded", Z_STRVAL_PP(handler));
				zval_del_ref(handler);
				break;
		}
		item++;
	}
}
/* }}} */

/* {{{ _php_sablot_call_handler_function()
   Call a sablot call handler function, wrapper for call_user_function() */
static void _php_sablot_call_handler_function(zval *handlerName, int argc, zval **args, char *function_name)
{
	zval *retval;
	int result, i;
	ELS_FETCH();
	
	MAKE_STD_ZVAL(retval);
	
	if (call_user_function(EG(function_table), NULL, handlerName, retval, argc, args) == FAILURE) {
		php_error(E_WARNING, "Sorry, couldn't call %s handler", function_name);
	}
	
	zval_dtor(retval);
	efree(retval);
	
	for (i=0; i<argc; i++) {
		zval_del_ref(&(args[i]));
	}
}
/* }}} */

/* {{{ _php_sablot_startDoc() */
static SAX_RETURN _php_sablot_sax_startDoc(void *userData)
{
	php_sablot *handle = (php_sablot *)userData;

	if (handle->startDocHandler) {
		zval *args[1];
		args[0] = _php_xslt_resource_zval(handle->index);

		_php_sablot_call_handler_function(handle->startDocHandler, 1, args, "start document");
	}
}
/* }}} */

/* {{{ _php_sablot_sax_startElement() */
static SAX_RETURN _php_sablot_sax_startElement(void *userData, const char *name, const char **attributes)
{
	php_sablot *handle = (php_sablot *)userData;
	
	if (handle->startElementHandler) {
		zval *args[3];
		
		args[0] = _php_xslt_resource_zval(handle->index);
		args[1] = _php_xslt_string_zval(name);

		MAKE_STD_ZVAL(args[2]);
		if (array_init(args[2]) == FAILURE) {
			php_error(E_WARNING, "Couldn't initialize array to be passed to start element handler");
			return;
		}

		while (attributes && *attributes) {
			char *key = (char *)attributes[0];
			zval *value = _php_xslt_string_zval(attributes[1]);
			
			add_assoc_string(args[2], key, Z_STRVAL_P(value), 0);
			attributes += 2;
		}
	
		_php_sablot_call_handler_function(handle->startElementHandler, 3, args, "start element");
	}
}
/* }}} */

/* {{{ _php_sablot_sax_endElement() */
static SAX_RETURN _php_sablot_sax_endElement(void *userData, const char *name)
{
	php_sablot *handle = (php_sablot *)userData;

	if (handle->endElementHandler) {
		zval *args[2];
		
		args[0] = _php_xslt_resource_zval(handle->index);
		args[1] = _php_xslt_string_zval(name);
		
		_php_sablot_call_handler_function(handle->endElementHandler, 2, args, "end element");
	}
}
/* }}} */

/* {{{ _php_sablot_sax_startNamespace() */
static SAX_RETURN _php_sablot_sax_startNamespace(void *userData, const char *prefix, const char *uri)
{
	php_sablot *handle = (php_sablot *)userData;
	
	if (handle->startNamespaceHandler) {
		zval *args[3];
		
		args[0] = _php_xslt_resource_zval(handle->index);
		args[1] = _php_xslt_string_zval(prefix);
		args[2] = _php_xslt_string_zval(uri);
		
		_php_sablot_call_handler_function(handle->startNamespaceHandler, 3, args, "start namespace");
	}
}
/* }}} */

/* {{{ _php_sablot_sax_endNamespace() */
static SAX_RETURN _php_sablot_sax_endNamespace(void *userData, const char *prefix)
{
	php_sablot *handle = (php_sablot *)userData;
	
	if (handle->endNamespaceHandler) {
		zval *args[2];
		
		args[0] = _php_xslt_resource_zval(handle->index);
		args[1] = _php_xslt_string_zval(prefix);
		
		_php_sablot_call_handler_function(handle->endNamespaceHandler, 2, args, "end namespace");
	}
}
/* }}} */

/* {{{ _php_sablot_sax_comment() */
static SAX_RETURN _php_sablot_sax_comment(void *userData, const char *contents)
{
	php_sablot *handle = (php_sablot *)userData;
	
	if (handle->commentHandler) {
		zval *args[2];
		
		args[0] = _php_xslt_resource_zval(handle->index);
		args[1] = _php_xslt_string_zval(contents);
		
		_php_sablot_call_handler_function(handle->commentHandler, 2, args, "comment");
	}
}
/* }}} */

/* {{{ _php_sablot_sax_PI() */
static SAX_RETURN _php_sablot_sax_PI(void *userData, const char *target, const char *contents)
{
	php_sablot *handle = (php_sablot *)userData;
	
	if (handle->PIHandler) {
		zval *args[3];
		
		args[0] = _php_xslt_resource_zval(handle->index);
		args[1] = _php_xslt_string_zval(target);
		args[2] = _php_xslt_string_zval(contents);
		
		_php_sablot_call_handler_function(handle->PIHandler, 3, args, "PI Handler");
	}
}
/* }}} */

/* {{{ _php_sablot_sax_characters() */
static SAX_RETURN _php_sablot_sax_characters(void *userData, const char *contents, int length)
{
	php_sablot *handle = (php_sablot *)userData;
	
	if (handle->charactersHandler) {
		zval *args[2];
		
		args[0] = _php_xslt_resource_zval(handle->index);
		args[1] = _php_xslt_string_zval(contents);
		
		_php_sablot_call_handler_function(handle->charactersHandler, 2, args, "characters");
	}
}
/* }}} */

/* {{{ _php_sablot_sax_endDoc() */
static SAX_RETURN _php_sablot_sax_endDoc(void *userData)
{
	php_sablot *handle = (php_sablot *)userData;
	
	if (handle->endDocHandler) {
		zval *args[1];
		
		args[0] = _php_xslt_resource_zval(handle->index);
		
		_php_sablot_call_handler_function(handle->endDocHandler, 1, args, "end document");
	}
}
/* }}} */


/* }}} */

/* {{{ Sablotron Error Handling */

#ifdef SABLOT_ERRORS
/* {{{ _php_sablot_make_code() */
static MH_ERROR _php_sablot_make_code(void *userData, SablotHandle p, int severity, unsigned short facility, unsigned short code)
{
	return(code);
}
/* }}} */

/* {{{ _php_sablot_error()
   Handle Sablotron errors */
static MH_ERROR _php_sablot_error(void *userData, SablotHandle p, MH_ERROR code, MH_LEVEL level, char **fields)
{
	php_sablot *handle = (php_sablot *)userData;
	int idx, len;
	char *sep;

	if (!fields) {
		if (code) {
			handle->last_errno = (int)code;
		}
		return(0);
	}
	
	switch (code)
	{
		case MH_LEVEL_CRITICAL:
			php_error(E_CORE, "Critical Error with Sablotron XSL Processor, must abort");
			return (0);
		case MH_LEVEL_ERROR:
			php_error(E_ERROR, "Error with Sablotron XSL Processor, must abort");
			return (0);
		case MH_LEVEL_WARN:
			php_error(E_WARNING, "Error occured with Sablotron XSL Processor");
			break;
	}	
	
	if (handle->errors) {
		handle->errors = handle->errors_start.next;
		while (handle->errors) {
			S_FREE(handle->errors->key);
			S_FREE(handle->errors->value);
			handle->errors = handle->errors->next;
		}
		S_FREE(handle->errors);
	}

	handle->errors_start.next = NULL;
	handle->errors = &(handle->errors_start);

	while (fields && *fields) {
		handle->errors->next = (php_sablot_error *)emalloc(sizeof(php_sablot_error));
		handle->errors = handle->errors->next;
	
		sep = strchr(fields[0], ':');
		
		idx = sep - fields[0];
		len = strlen(fields[0]);
		
		handle->errors->key   = emalloc(idx+1);
		handle->errors->value = emalloc((len - idx) + 1);
		memcpy(handle->errors->key, fields[0], idx);
		memcpy(handle->errors->value, fields[0] + idx + 1, len - idx - 1);
		
		handle->errors->next = NULL;
		fields++;
	}
	handle->last_errno = (int)code;

	return(0);
}
/* }}} */
#endif

/* }}} */

/* {{{ List Handling functions */

/* {{{ _php_sablot_free_processor()
   Free a Sablot handle */
static void _php_sablot_free_processor(php_sablot *handle)
{
	if (handle->p) {
#ifdef SABLOT_ERRORS
		SablotUnregHandler(handle->p, HLR_MESSAGE, NULL, NULL);
#endif
		SablotUnregHandler(handle->p, HLR_SAX, NULL, NULL);
		SablotDestroyProcessor(handle->p);
	}
	FUNCH_FREE(handle->startDocHandler);
	FUNCH_FREE(handle->startElementHandler);
	FUNCH_FREE(handle->endElementHandler);
	FUNCH_FREE(handle->startNamespaceHandler);
	FUNCH_FREE(handle->endNamespaceHandler);
	FUNCH_FREE(handle->commentHandler);
	FUNCH_FREE(handle->PIHandler);
	FUNCH_FREE(handle->charactersHandler);
	FUNCH_FREE(handle->endDocHandler);

#ifdef SABLOT_ERRORS
	if (handle->errors) {
		handle->errors = handle->errors_start.next;
		while (handle->errors) {
			S_FREE(handle->errors->key);
			S_FREE(handle->errors->value);
			handle->errors = handle->errors->next;
		}
		S_FREE(handle->errors);
	}
	S_FREE(handle);
#endif
}
/* }}} */

/* }}} */

/* {{{ Conversion Helper functions */

/* {{{ m_convert_to_string_ex()
   A little wrapper function to convert a bunch o' function arguments to strings */
static void m_convert_to_string_ex(int argc, ...)
{
	zval **arg;
	va_list ap;
	int i;
	
	va_start(ap, argc);
	
	for (i = 0; i < argc; i++) {
		arg = va_arg(ap, zval **);
		convert_to_string_ex(arg);
	}
	
	va_end(ap);
}
/* }}} */

/* {{{ _php_xslt_string_zval()
   Converts a Sablotron string to a zval */
static zval *_php_xslt_string_zval(const char *str)
{
	zval *ret;
	int len = strlen(str);
	MAKE_STD_ZVAL(ret);
	
	Z_TYPE_P(ret)   = IS_STRING;
	Z_STRLEN_P(ret) = len;
	Z_STRVAL_P(ret) = estrndup(str, len);
	return(ret);
}
/* }}} */

/* {{{ _php_xslt_resource_zval()
   Converts a long identifier to a resource id */
static zval *_php_xslt_resource_zval(long value)
{
	zval *ret;
	MAKE_STD_ZVAL(ret);
	
	Z_TYPE_P(ret) = IS_RESOURCE;
	Z_LVAL_P(ret) = value;
	
	zend_list_addref(value);
	return(ret);
}
/* }}} */

/* }}} */

/* }}} */
#endif


/*
 * Local variables:
 * tab-width: 4
 * c-basic-offset: 4
 * End:
 */