void *
_gda_xslt_extension_init (xsltTransformContextPtr ctxt, const xmlChar * URI)
{
int res;
GdaXsltIntCont *data;
#ifdef GDA_DEBUG_NO
g_print ("_gda_xslt_extension_init");
#endif
if (!URI || strcmp ((gchar*) URI, GDA_XSLT_EXTENSION_URI)) {
#ifdef GDA_DEBUG_NO
g_print ("called for another URI, exit");
#endif
return NULL;
}
data = calloc (1, sizeof (GdaXsltIntCont));
if (data == NULL) {
#ifdef GDA_DEBUG_NO
g_print ("no memory");
#endif
return NULL;
}
#ifdef GDA_DEBUG_NO
g_print ("initialize result_sets hash");
#endif
data->result_sets =
g_hash_table_new_full (g_str_hash, g_str_equal,
g_free,
NULL);
res = xsltRegisterExtFunction (ctxt,
(const xmlChar *)
GDA_XSLT_FUNC_GETVALUE, URI,
gda_xslt_getvalue_function);
res = xsltRegisterExtFunction (ctxt,
(const xmlChar *)
GDA_XSLT_FUNC_GETXMLVALUE, URI,
gda_xslt_getxmlvalue_function);
res |= xsltRegisterExtFunction (ctxt,
(const xmlChar *)
GDA_XSLT_FUNC_CHECKIF, URI,
gda_xslt_checkif_function);
res |= xsltRegisterExtFunction (ctxt,
(const xmlChar *)
GDA_XSLT_FUNC_GETNODESET, URI,
gda_xslt_getnodeset_function);
if (res != 0) {
g_error ("failed to xsltRegisterExtFunction = [%d]", res);
}
res = xsltRegisterExtElement (ctxt,
(const xmlChar *) GDA_XSLT_ELEM_SECTION,
URI,
(xsltTransformFunction)
gda_xslt_section_element);
if (res != 0) {
g_error ("failed to xsltRegisterExtElement = [%d]", res);
}
return data;
}
/*
* exsltFuncRegisterImportFunc
* @data: the exsltFuncFunctionData for the function
* @ch: structure containing context and hash table
* @URI: the function namespace URI
* @name: the function name
*
* Checks if imported function is already registered in top-level
* stylesheet. If not, copies function data and registers function
*/
static void
exsltFuncRegisterImportFunc (exsltFuncFunctionData *data,
exsltFuncImportRegData *ch,
const xmlChar *URI, const xmlChar *name,
ATTRIBUTE_UNUSED const xmlChar *ignored) {
exsltFuncFunctionData *func=NULL;
if ((data == NULL) || (ch == NULL) || (URI == NULL) || (name == NULL))
return;
if (ch->ctxt == NULL || ch->hash == NULL)
return;
/* Check if already present */
func = (exsltFuncFunctionData*)xmlHashLookup2(ch->hash, URI, name);
if (func == NULL) { /* Not yet present - copy it in */
func = exsltFuncNewFunctionData();
memcpy(func, data, sizeof(exsltFuncFunctionData));
if (xmlHashAddEntry2(ch->hash, URI, name, func) < 0) {
xsltGenericError(xsltGenericErrorContext,
"Failed to register function {%s}%s\n",
URI, name);
} else { /* Do the registration */
xsltGenericDebug(xsltGenericDebugContext,
"exsltFuncRegisterImportFunc: register {%s}%s\n",
URI, name);
xsltRegisterExtFunction(ch->ctxt, name, URI,
exsltFuncFunctionFunction);
}
}
}
/**
* exsltFuncRegisterFunc:
* @func: the #exsltFuncFunctionData for the function
* @ctxt: an XSLT transformation context
* @URI: the function namespace URI
* @name: the function name
*
* Registers a function declared by a func:function element
*/
static void
exsltFuncRegisterFunc (exsltFuncFunctionData *data,
xsltTransformContextPtr ctxt,
const xmlChar *URI, const xmlChar *name,
ATTRIBUTE_UNUSED const xmlChar *ignored) {
if ((data == NULL) || (ctxt == NULL) || (URI == NULL) || (name == NULL))
return;
xsltGenericDebug(xsltGenericDebugContext,
"exsltFuncRegisterFunc: register {%s}%s\n",
URI, name);
xsltRegisterExtFunction(ctxt, name, URI,
exsltFuncFunctionFunction);
}
int
registerBasicFunctions(xsltTransformContextPtr ctxt, const xmlChar *URI, int fromR)
{
struct Entries {
const char *name;
xmlXPathEvalFunc fun;
};
struct Entries entries[] = {
{"init", RXSLT_init},
{"call", RXSLT_call},
{"callI", RXSLT_callI},
{"eval", RXSLT_eval},
{"source", RXSLT_source},
{"register", RXSLT_register},
{"exists", RXSLT_exists},
{"library", RXSLT_library},
{"nullEval", RXSLT_nullEval},
{"evalWithOutput", RXSLT_evalWithOutput},
{"length", RXSLT_length},
{"as", RXSLT_as},
{"class", RXSLT_class}
};
int n = sizeof(entries)/sizeof(entries[0]), i;
if(fromR || R_alreadyInitialized)
entries[0].fun = RXSLT_noop;
#ifdef XSLT_DEBUG
fprintf(stderr, "registering %d functions for %s\n", (fromR ? n-1 : n), R_URI);fflush(stderr);
#endif
for(i = 0 ; i < n; i++) {
#ifdef XSLT_DEBUG
fprintf(stderr, "registering %s\n", entries[i].name);fflush(stderr);
#endif
if(ctxt)
xsltRegisterExtFunction(ctxt, entries[i].name, R_URI, entries[i].fun);
else
xsltRegisterExtModuleFunction((const xmlChar *) entries[i].name,
(const xmlChar *) R_URI, entries[i].fun);
}
xsltRegisterExtElement(ctxt, "eval", R_URI, REvalFunctionDefn);
return(n);
}
void
RXSLT_init(xmlXPathParserContextPtr ctxt, int nargs)
{
const char *defaultArgs[] = {"Rxsltproc", "--silent"};
char **args;
int argc, i;
int mustFree;
if(R_alreadyInitialized)
return;
#ifdef XSLT_DEBUG
fprintf(stderr, "in RXSLT_init %d\n", nargs);fflush(stderr);
#endif
if(nargs == 0) {
argc = sizeof(defaultArgs)/sizeof(defaultArgs[0]);
args = (char **)defaultArgs;
} else {
args = (char **) malloc((nargs+1) * sizeof(char*));
args[0] = strdup("Rxsltproc");
argc = nargs+1;
for(i = 0; i < nargs; i++) {
xmlXPathObjectPtr obj = valuePop(ctxt);
if(obj->type) {
args[i+1] = strdup(xmlXPathCastToString(obj));
}
}
mustFree = TRUE;
}
Rf_initEmbeddedR(argc, args);
loadXSLPackage();
valuePush(ctxt, xmlXPathNewBoolean(1));
if(mustFree) {
for(i = 0; i < nargs+1; i++) {
free(args[i]);
}
free(args);
}
#if DEBUG_REGISTRATION
xsltRegisterExtFunction(getTransformCtxt(), "foo", R_URI, RXSLT_genericFunctionCall);
RXSLT_addFunction("foo", NULL_USER_OBJECT);
#endif
R_alreadyInitialized = 1;
return;
}
static void * initFunc(xsltTransformContextPtr ctxt, const xmlChar *uri)
{
VALUE modules = rb_iv_get(xslt, "@modules");
VALUE obj = rb_hash_aref(modules, rb_str_new2((const char *)uri));
VALUE args = { Qfalse };
VALUE methods = rb_funcall(obj, rb_intern("instance_methods"), 1, args);
int i;
for(i = 0; i < RARRAY_LEN(methods); i++) {
xsltRegisterExtFunction(ctxt,
(unsigned char *)StringValuePtr(RARRAY_PTR(methods)[i]), uri, method_caller);
}
return (void *)rb_class_new_instance(0, NULL, obj);
}
void
yelp_transform_start (YelpTransform *transform,
xmlDocPtr document,
gchar **params)
{
transform->inputDoc = document;
transform->context = xsltNewTransformContext (transform->stylesheet,
transform->inputDoc);
if (!transform->context) {
YelpError *error =
yelp_error_new (_("Broken Transformation"),
_("An unknown error occurred while attempting to "
"transform the document."));
transform_set_error (transform, error);
return;
}
transform->params = g_strdupv (params);
transform->context->_private = transform;
if (!exslt_registered) {
exsltRegisterAll ();
exslt_registered = TRUE;
}
xsltRegisterExtElement (transform->context,
BAD_CAST "document",
BAD_CAST YELP_NAMESPACE,
(xsltTransformFunction) xslt_yelp_document);
xsltRegisterExtElement (transform->context,
BAD_CAST "cache",
BAD_CAST YELP_NAMESPACE,
(xsltTransformFunction) xslt_yelp_cache);
xsltRegisterExtFunction (transform->context,
BAD_CAST "input",
BAD_CAST YELP_NAMESPACE,
(xmlXPathFunction) xslt_yelp_input);
transform->mutex = g_mutex_new ();
g_mutex_lock (transform->mutex);
transform->running = TRUE;
transform->thread = g_thread_create ((GThreadFunc) transform_run,
transform, FALSE, NULL);
g_mutex_unlock (transform->mutex);
}
USER_OBJECT_
RXSLT_registerFunction(USER_OBJECT_ name, USER_OBJECT_ fun, USER_OBJECT_ uri, USER_OBJECT_ symbol,
USER_OBJECT_ context)
{
xsltTransformContextPtr ctxt = NULL;
xmlXPathEvalFunc sym;
if(GET_LENGTH(context)) {
ctxt = (xsltTransformContextPtr) R_ExternalPtrAddr(context);
}
if(!ctxt)
ctxt = getTransformCtxt();
if(!ctxt) {
PROBLEM "NULL value for xslTransformContext. One cannot register an R function with XSLT when not applying an XSL style sheet."
ERROR;
}
if(GET_LENGTH(symbol) < 1) {
sym = RXSLT_genericFunctionCall;
} else {
sym = (xmlXPathEvalFunc) R_ExternalPtrAddr(symbol);
}
RXSLT_addFunction(CHAR_DEREF(STRING_ELT(name, 0)), fun); /* XXX check for memory leaks */
/* Register the S function in a hashtable with this name and function. */
#ifdef XSLT_DEBUG
fprintf(stderr, "Registering function (%s) %s with context %p\n",
CHAR_DEREF(STRING_ELT(uri, 0)), CHAR_DEREF(STRING_ELT(name, 0)), ctxt);fflush(stderr);
#endif
if(ctxt)
xsltRegisterExtFunction(ctxt, CHAR_DEREF(STRING_ELT(name, 0)),
CHAR_DEREF(STRING_ELT(uri, 0)),
sym);
else
xsltRegisterExtModuleFunction((const xmlChar *) CHAR_DEREF(STRING_ELT(name, 0)),
(const xmlChar *) CHAR_DEREF(STRING_ELT(uri, 0)), sym);
return(NULL_USER_OBJECT);
}
static void * initFunc(xsltTransformContextPtr ctxt, const xmlChar *uri)
{
VALUE modules = rb_iv_get(xslt, "@modules");
VALUE obj = rb_hash_aref(modules, rb_str_new2((const char *)uri));
VALUE args = { Qfalse };
VALUE methods = rb_funcall(obj, rb_intern("instance_methods"), 1, args);
VALUE inst;
nokogiriXsltStylesheetTuple *wrapper;
int i;
for(i = 0; i < RARRAY_LEN(methods); i++) {
VALUE method_name = rb_obj_as_string(RARRAY_PTR(methods)[i]);
xsltRegisterExtFunction(ctxt,
(unsigned char *)StringValuePtr(method_name), uri, method_caller);
}
Data_Get_Struct(ctxt->style->_private, nokogiriXsltStylesheetTuple,
wrapper);
inst = rb_class_new_instance(0, NULL, obj);
rb_ary_push(wrapper->func_instances, inst);
return (void *)inst;
}
void registerXSLTExtensions(xsltTransformContextPtr ctxt)
{
ASSERT(RuntimeEnabledFeatures::xsltEnabled());
xsltRegisterExtFunction(ctxt, (const xmlChar*)"node-set", (const xmlChar*)"http://exslt.org/common", exsltNodeSetFunction);
}
void registerXSLTExtensions(xsltTransformContextPtr ctxt)
{
xsltRegisterExtFunction(ctxt, (const xmlChar*)"node-set", (const xmlChar*)"http://exslt.org/common", exsltNodeSetFunction);
}
xmlDocPtr c_XSLTProcessor::apply_stylesheet() {
SYNC_VM_REGS_SCOPED();
if (m_stylesheet == nullptr || m_doc == nullptr) {
raise_error("Unable to apply stylesheet");
return nullptr;
}
xsltTransformContextPtr ctxt = xsltNewTransformContext (m_stylesheet, m_doc);
if (ctxt == nullptr) {
raise_error("Unable to apply stylesheet");
return nullptr;
}
ctxt->_private = this;
xsltSecurityPrefsPtr prefs = nullptr;
if (m_secprefs != k_XSL_SECPREF_NONE) {
prefs = xsltNewSecurityPrefs();
int error = 0;
if (m_secprefs & k_XSL_SECPREF_READ_FILE) {
if (xsltSetSecurityPrefs(prefs,
XSLT_SECPREF_READ_FILE,
xsltSecurityForbid) != 0) {
error = 1;
}
}
if (m_secprefs & k_XSL_SECPREF_WRITE_FILE) {
if (xsltSetSecurityPrefs(prefs,
XSLT_SECPREF_WRITE_FILE,
xsltSecurityForbid) != 0) {
error = 1;
}
}
if (m_secprefs & k_XSL_SECPREF_CREATE_DIRECTORY) {
if (xsltSetSecurityPrefs(prefs,
XSLT_SECPREF_CREATE_DIRECTORY,
xsltSecurityForbid) != 0) {
error = 1;
}
}
if (m_secprefs & k_XSL_SECPREF_READ_NETWORK) {
if (xsltSetSecurityPrefs(prefs,
XSLT_SECPREF_READ_NETWORK,
xsltSecurityForbid) != 0) {
error = 1;
}
}
if (m_secprefs & k_XSL_SECPREF_WRITE_NETWORK) {
if (xsltSetSecurityPrefs(prefs,
XSLT_SECPREF_WRITE_NETWORK,
xsltSecurityForbid) != 0) {
error = 1;
}
}
if (xsltSetCtxtSecurityPrefs(prefs, ctxt) != 0) {
error = 1;
}
if (error == 1) {
raise_error("Can't set libxslt security properties, not doing "
"transformation for security reasons");
return nullptr;
}
}
xsltRegisterExtFunction(ctxt,
(const xmlChar*) "functionString",
(const xmlChar*) "http://php.net/xsl",
xslt_ext_function_string_php
);
xsltRegisterExtFunction(ctxt,
(const xmlChar*) "function",
(const xmlChar*) "http://php.net/xsl",
xslt_ext_function_object_php
);
for (ArrayIter iter(m_params); iter; ++iter) {
assert(iter.first().isString());
assert(iter.second().isString());
xmlChar *value = xslt_string_to_xpathexpr(iter.second().toString().c_str());
if (value) {
xsltEvalOneUserParam(ctxt,
(const xmlChar*)iter.first().toString().c_str(),
(const xmlChar*)value
);
xmlFree(value);
}
}
FILE *profile = nullptr;
if (m_profile) {
profile = fopen(m_profile.data(), "w");
}
xmlDocPtr res = xsltApplyStylesheetUser(m_stylesheet,
m_doc,
nullptr,
nullptr,
profile,
ctxt);
if (profile) {
fclose(profile);
}
xsltFreeTransformContext(ctxt);
if (prefs) {
xsltFreeSecurityPrefs(prefs);
}
return res;
}
static void
transform_run (YelpTransform *transform)
{
YelpTransformPrivate *priv = GET_PRIV (transform);
debug_print (DB_FUNCTION, "entering\n");
priv->stylesheet = xsltParseStylesheetFile (BAD_CAST (priv->stylesheet_file));
if (priv->stylesheet == NULL) {
g_mutex_lock (&priv->mutex);
if (priv->error)
g_error_free (priv->error);
priv->error = g_error_new (YELP_ERROR, YELP_ERROR_PROCESSING,
_("The XSLT stylesheet ‘%s’ is either missing or not valid."),
priv->stylesheet_file);
g_object_ref (transform);
g_idle_add ((GSourceFunc) transform_error, transform);
g_mutex_unlock (&priv->mutex);
return;
}
priv->context = xsltNewTransformContext (priv->stylesheet,
priv->input);
if (priv->context == NULL) {
g_mutex_lock (&priv->mutex);
if (priv->error)
g_error_free (priv->error);
priv->error = g_error_new (YELP_ERROR, YELP_ERROR_PROCESSING,
_("The XSLT stylesheet ‘%s’ is either missing or not valid."),
priv->stylesheet_file);
g_object_ref (transform);
g_idle_add ((GSourceFunc) transform_error, transform);
g_mutex_unlock (&priv->mutex);
return;
}
priv->context->_private = transform;
xsltRegisterExtElement (priv->context,
BAD_CAST "document",
BAD_CAST YELP_NAMESPACE,
(xsltTransformFunction) xslt_yelp_document);
xsltRegisterExtElement (priv->context,
BAD_CAST "cache",
BAD_CAST YELP_NAMESPACE,
(xsltTransformFunction) xslt_yelp_cache);
xsltRegisterExtFunction (priv->context,
BAD_CAST "input",
BAD_CAST YELP_NAMESPACE,
(xmlXPathFunction) xslt_yelp_aux);
priv->output = xsltApplyStylesheetUser (priv->stylesheet,
priv->input,
(const char **) priv->params,
NULL, NULL,
priv->context);
g_mutex_lock (&priv->mutex);
priv->running = FALSE;
if (!priv->cancelled) {
g_idle_add ((GSourceFunc) transform_final, transform);
g_mutex_unlock (&priv->mutex);
}
else {
g_mutex_unlock (&priv->mutex);
g_object_unref (transform);
}
}
