void schemasInit(void)
{
xmlChar* buf;
if (!(datatypes_rsrc = FindResourceA(MSXML_hInstance, "DATATYPES", "XML")))
{
FIXME("failed to find resource for %s\n", DT_nsURI);
return;
}
if (!(datatypes_handle = LoadResource(MSXML_hInstance, datatypes_rsrc)))
{
FIXME("failed to load resource for %s\n", DT_nsURI);
return;
}
buf = LockResource(datatypes_handle);
datatypes_len = SizeofResource(MSXML_hInstance, datatypes_rsrc);
/* Resource is loaded as raw data,
* need a null-terminated string */
while (buf[datatypes_len - 1] != '>') datatypes_len--;
datatypes_src = HeapAlloc(GetProcessHeap(), 0, datatypes_len + 1);
memcpy(datatypes_src, buf, datatypes_len);
datatypes_src[datatypes_len] = 0;
if (xmlGetExternalEntityLoader() != external_entity_loader)
{
_external_entity_loader = xmlGetExternalEntityLoader();
xmlSetExternalEntityLoader(external_entity_loader);
}
}
void schemasInit(void)
{
int len;
char* buf;
if (!(datatypes_rsrc = FindResourceA(MSXML_hInstance, "DATATYPES", "XML")))
{
FIXME("failed to find resource for %s\n", DT_nsURI);
return;
}
if (!(datatypes_handle = LoadResource(MSXML_hInstance, datatypes_rsrc)))
{
FIXME("failed to load resource for %s\n", DT_nsURI);
return;
}
buf = LockResource(datatypes_handle);
len = SizeofResource(MSXML_hInstance, datatypes_rsrc) - 1;
/* Resource is loaded as raw data,
* need a null-terminated string */
while (buf[len] != '>')
buf[len--] = 0;
datatypes_src = BAD_CAST buf;
datatypes_len = len + 1;
if (xmlGetExternalEntityLoader() != external_entity_loader)
{
_external_entity_loader = xmlGetExternalEntityLoader();
xmlSetExternalEntityLoader(external_entity_loader);
}
}
static BOOL link_datatypes(xmlDocPtr schema)
{
xmlNodePtr root, next, child;
xmlNsPtr ns;
assert(xmlGetExternalEntityLoader() == external_entity_loader);
root = xmlDocGetRootElement(schema);
if (!root)
return FALSE;
for (ns = root->nsDef; ns != NULL; ns = ns->next)
{
if (xmlStrEqual(ns->href, DT_nsURI))
break;
}
if (!ns)
return FALSE;
next = xmlFirstElementChild(root);
child = xmlNewChild(root, NULL, BAD_CAST "import", NULL);
if (next) child = xmlAddPrevSibling(next, child);
xmlSetProp(child, BAD_CAST "namespace", DT_nsURI);
xmlSetProp(child, BAD_CAST "schemaLocation", DT_nsURI);
return TRUE;
}
static
CPLXMLSchemaPtr CPLLoadXMLSchema(const char* pszXSDFilename)
{
char* pszStr = CPLLoadSchemaStr(pszXSDFilename);
if (pszStr == NULL)
return NULL;
xmlExternalEntityLoader pfnLibXMLOldExtranerEntityLoaderLocal = NULL;
pfnLibXMLOldExtranerEntityLoaderLocal = xmlGetExternalEntityLoader();
pfnLibXMLOldExtranerEntityLoader = pfnLibXMLOldExtranerEntityLoaderLocal;
xmlSetExternalEntityLoader(CPLExternalEntityLoader);
xmlSchemaParserCtxtPtr pSchemaParserCtxt =
xmlSchemaNewMemParserCtxt(pszStr, static_cast<int>(strlen(pszStr)));
xmlSchemaSetParserErrors(pSchemaParserCtxt,
CPLLibXMLWarningErrorCallback,
CPLLibXMLWarningErrorCallback,
NULL);
xmlSchemaPtr pSchema = xmlSchemaParse(pSchemaParserCtxt);
xmlSchemaFreeParserCtxt(pSchemaParserCtxt);
xmlSetExternalEntityLoader(pfnLibXMLOldExtranerEntityLoaderLocal);
CPLFree(pszStr);
return (CPLXMLSchemaPtr) pSchema;
}
void _CFSetupXMLInterface(void) {
static dispatch_once_t xmlInitGuard;
dispatch_once(&xmlInitGuard, ^{
xmlInitParser();
// set up the external entity loader
__originalLoader = xmlGetExternalEntityLoader();
xmlSetExternalEntityLoader(_xmlExternalEntityLoader);
});
void registerDTDEntityLoader(const string& sID, const string& sDTD)
{
g_DTDMap[sID] = sDTD;
if (!DefaultLoaderProc) {
DefaultLoaderProc = xmlGetExternalEntityLoader();
}
xmlSetExternalEntityLoader(DTDExternalEntityLoader);
}
Global()
{
/* Check the parser version. The docs say it will kill the app if
* there is a serious version mismatch, but I couldn't find it in the
* source code (it only prints the error/warning message to the console) so
* let's leave it as is for informational purposes. */
LIBXML_TEST_VERSION
/* Init libxml */
xmlInitParser();
/* Save the default entity resolver before someone has replaced it */
sxml.defaultEntityLoader = xmlGetExternalEntityLoader();
}
void moduleInit() override {
cnsInt(s_LIBXML_VERSION, LIBXML_VERSION);
cnsStr(s_LIBXML_DOTTED_VERSION, LIBXML_DOTTED_VERSION);
cnsStr(s_LIBXML_LOADED_VERSION, xmlParserVersion);
// For use with loading xml
cnsInt(s_LIBXML_NOENT, XML_PARSE_NOENT);
cnsInt(s_LIBXML_DTDLOAD, XML_PARSE_DTDLOAD);
cnsInt(s_LIBXML_DTDATTR, XML_PARSE_DTDATTR);
cnsInt(s_LIBXML_DTDVALID, XML_PARSE_DTDVALID);
cnsInt(s_LIBXML_NOERROR, XML_PARSE_NOERROR);
cnsInt(s_LIBXML_NOWARNING, XML_PARSE_NOWARNING);
cnsInt(s_LIBXML_NOBLANKS, XML_PARSE_NOBLANKS);
cnsInt(s_LIBXML_XINCLUDE, XML_PARSE_XINCLUDE);
cnsInt(s_LIBXML_NSCLEAN, XML_PARSE_NSCLEAN);
cnsInt(s_LIBXML_NOCDATA, XML_PARSE_NOCDATA);
cnsInt(s_LIBXML_NONET, XML_PARSE_NONET);
cnsInt(s_LIBXML_PEDANTIC, XML_PARSE_PEDANTIC);
cnsInt(s_LIBXML_COMPACT, XML_PARSE_COMPACT);
cnsInt(s_LIBXML_NOXMLDECL, XML_SAVE_NO_DECL);
cnsInt(s_LIBXML_PARSEHUGE, XML_PARSE_HUGE);
cnsInt(s_LIBXML_NOEMPTYTAG, LIBXML_SAVE_NOEMPTYTAG);
// Schema validation options
#if defined(LIBXML_SCHEMAS_ENABLED)
cnsInt(s_LIBXML_SCHEMA_CREATE, XML_SCHEMA_VAL_VC_I_CREATE);
#endif
// Additional constants for use with loading html
#if LIBXML_VERSION >= 20707
cnsInt(s_LIBXML_HTML_NOIMPLIED, HTML_PARSE_NOIMPLIED);
#endif
#if LIBXML_VERSION >= 20708
cnsInt(s_LIBXML_HTML_NODEFDTD, HTML_PARSE_NODEFDTD);
#endif
// Error levels
cnsInt(s_LIBXML_ERR_NONE, XML_ERR_NONE);
cnsInt(s_LIBXML_ERR_WARNING, XML_ERR_WARNING);
cnsInt(s_LIBXML_ERR_ERROR, XML_ERR_ERROR);
cnsInt(s_LIBXML_ERR_FATAL, XML_ERR_FATAL);
HHVM_FE(libxml_get_errors);
HHVM_FE(libxml_get_last_error);
HHVM_FE(libxml_clear_errors);
HHVM_FE(libxml_use_internal_errors);
HHVM_FE(libxml_suppress_errors);
HHVM_FE(libxml_disable_entity_loader);
HHVM_FE(libxml_set_streams_context);
loadSystemlib();
s_LibXMLError_class = Unit::lookupClass(s_LibXMLError.get());
// Set up callbacks to support stream wrappers for reading and writing
// xml files and loading external entities.
xmlParserInputBufferCreateFilenameDefault(libxml_create_input_buffer);
xmlOutputBufferCreateFilenameDefault(libxml_create_output_buffer);
s_default_entity_loader = xmlGetExternalEntityLoader();
xmlSetExternalEntityLoader(libxml_ext_entity_loader);
}
void GlobalLock::setExternalEntityLoader(PFNEXTERNALENTITYLOADER pLoader)
{
m->pOldLoader = xmlGetExternalEntityLoader();
xmlSetExternalEntityLoader(pLoader);
}
/* A _configure function will be executed by the webserver
* at the moment of 'first' initialisation. Here you do the
* start of memory management. The processing of the configuration
* parameters.
*/
ret_t
cherokee_handler_xslt_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props)
{
cherokee_list_t *i;
cherokee_handler_xslt_props_t *props;
ret_t ret;
if (*_props == NULL) {
CHEROKEE_NEW_STRUCT (n, handler_xslt_props);
cherokee_module_props_init_base (MODULE_PROPS(n),
MODULE_PROPS_FREE(props_free));
/* Look at handler_xslt.h
* This is an xslt of configuration.
*/
xmlInitMemory();
LIBXML_TEST_VERSION
/*
* Register the EXSLT extensions and the test module
*/
exsltRegisterAll();
xsltRegisterTestModule();
cherokee_buffer_init (&n->content_type);
cherokee_buffer_init (&n->stylesheet);
n->global = NULL;
n->globalDoc = NULL;
n->xinclude = false;
n->xincludestyle = false;
// n->sec = xsltNewSecurityPrefs();
// xsltSetDefaultSecurityPrefs(n->sec);
n->defaultEntityLoader = xmlGetExternalEntityLoader();
// xmlSetExternalEntityLoader(xsltprocExternalEntityLoader);
*_props = MODULE_PROPS(n);
}
props = PROP_XSLT(*_props);
/* processing of the parameters, we only know about xslt_config
* it might be a good thing to abort if we found a wrong key, understand
* the consequences: your handler will prevent the server startup upon
* a wrong configuration.
*
* You see the for each method is rather creative. Read more code
* to see with what nice things Cherokee extended the C syntax.
*/
cherokee_config_node_foreach (i, conf) {
cherokee_config_node_t *subconf = CONFIG_NODE(i);
/* Cherokee has a nifty string equal function that allows
* lazy programmers to do strcmp without the == 0.
*/
/*if (equal_buf_str (&subconf->key, "maxdepth")) {
cherokee_atoi(subconf->val.buf, &props->xsltMaxDepth);
} else if (equal_buf_str (&subconf->key, "maxparserdepth")) {
cherokee_atoi(subconf->val.buf, &props->xsltParserMaxDepth);
} else */
if (equal_buf_str (&subconf->key, "options")) {
if (equal_buf_str (&subconf->val, "novalid")) {
props->options |= XML_PARSE_NOENT | XML_PARSE_NOCDATA;
} else if (equal_buf_str (&subconf->val, "nodtdattr")) {
props->options |= XML_PARSE_NOENT | XML_PARSE_DTDLOAD | XML_PARSE_NOCDATA;
} else {
PRINT_MSG ("ERROR: Handler xslt: Unknown value: '%s'\n", subconf->val.buf);
return ret_error;
}
} else if (equal_buf_str (&subconf->key, "nodict")) {
cherokee_boolean_t nodict;
ret = cherokee_atob (subconf->val.buf, &nodict);
if (ret != ret_ok) return ret;
if (nodict) {
props->options |= XML_PARSE_NODICT;
}
#ifdef LIBXML_CATALOG_ENABLED
} else if (equal_buf_str (&subconf->key, "catalogs")) {
cherokee_boolean_t catalogs;
ret = cherokee_atob (subconf->val.buf, &catalogs);
if (ret != ret_ok) return ret;
if (catalogs) {
const char *catalogs = getenv("SGML_CATALOG_FILES");
if (catalogs != NULL) {
xmlLoadCatalogs(catalogs);
}
}
#endif
#ifdef LIBXML_XINCLUDE_ENABLED
} else if (equal_buf_str (&subconf->key, "xinclude")) {
ret = cherokee_atob (subconf->val.buf, &props->xinclude);
} else if (equal_buf_str (&subconf->key, "xincludestyle")) {
ret = cherokee_atob (subconf->val.buf, &props->xincludestyle);
if (props->xincludestyle) {
xsltSetXIncludeDefault(1);
}
#endif
} else if (equal_buf_str (&subconf->key, "contenttype")) {
cherokee_buffer_add(&props->content_type, subconf->val.buf, subconf->val.len);
} else if (equal_buf_str (&subconf->key, "stylesheet")) {
cherokee_buffer_add(&props->stylesheet, subconf->val.buf, subconf->val.len);
} else {
PRINT_MSG ("ERROR: Handler xslt: Unknown key: '%s'\n", subconf->key.buf);
return ret_error;
}
}
/* Tool to migrate existing user settings from GConf to GSettings
*
* This tool will first run some sanity checks to see if migration
* is necessary/possible. The actual migration works directly from
* the GConf .xml files. Using an xsl transform it will convert them
* in a guile script to set most settings found.
*
* Notes:
* - due to some limitations in the xslt code, all the gconf xml files are
* first copied into a temporary directory. After the migration has finished,
* that temporary directory and its contents are removed.
* - not all settings can be migrated. All the important ones are though.
* The ones that are missing are mostly with respect to window position
* and size.
* - column widths/visibilities, sorting orders,... are no longer stored
* in gsettings, so these will obviously not be migrated either.
* - upon a successful run, a flag will be set to prevent the migration
* from running again. So in normal circumstances the migration will
* be executed only once.
*/
static void gnc_gsettings_migrate_from_gconf (void)
{
gchar *pkgdatadir, *stylesheet, *input, *output, *command;
gchar *gconf_root, *gconf_apps, *gconf_gnucash;
gchar *base_dir, *iter;
SCM migr_script;
xsltStylesheetPtr stylesheetptr = NULL;
xmlDocPtr inputxml, transformedxml;
FILE *outfile;
gboolean migration_ok = FALSE;
ENTER ();
base_dir = g_strdup (g_get_home_dir ());
for (iter = base_dir; *iter != 0; iter++)
{
if ( *iter == '\\')
*iter = '/';
}
/* Only attempt to migrate if there is something to migrate */
gconf_root = g_build_filename(base_dir, ".gconf", NULL);
gconf_apps = g_build_filename(gconf_root, "apps", NULL);
gconf_gnucash = g_build_filename(gconf_apps, "gnucash", NULL);
migration_ok = (g_file_test (gconf_root, G_FILE_TEST_IS_DIR) &&
g_file_test (gconf_apps, G_FILE_TEST_IS_DIR) &&
g_file_test (gconf_gnucash, G_FILE_TEST_IS_DIR));
g_free (gconf_root);
g_free (gconf_apps);
g_free (gconf_gnucash);
if (!migration_ok)
{
g_free (base_dir);
gnc_gsettings_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_MIGRATE_PREFS_DONE, TRUE);
PINFO ("No pre-existing GConf gnucash section found.\n"
"Most likely this system never ran GnuCash before.\n"
"Assume migration is not needed.");
LEAVE ();
return;
}
pkgdatadir = gnc_path_get_pkgdatadir();
stylesheet = g_build_filename(pkgdatadir, "make-prefs-migration-script.xsl", NULL);
input = g_build_filename(pkgdatadir, "migratable-prefs.xml", NULL);
g_free (pkgdatadir);
migration_ok = (g_file_test (stylesheet, G_FILE_TEST_IS_REGULAR) &&
g_file_test (input, G_FILE_TEST_IS_REGULAR));
if (!migration_ok)
{
/* Critical files not found, abort migration */
g_free (base_dir);
g_free (stylesheet);
g_free (input);
PWARN ("Migration input file and stylesheet missing. Skip migration.");
return;
}
command = g_strconcat ("(use-modules (migrate-prefs))(migration-prepare \"",
base_dir, "\")", NULL);
DEBUG ("command = %s", command);
migration_ok = scm_is_true (scm_c_eval_string (command));
g_free (command);
if (!migration_ok)
{
/* Preparation step failed */
g_free (base_dir);
g_free (stylesheet);
g_free (input);
PWARN ("Migration preparation step failed. Skip migration.");
LEAVE ();
return;
}
output = g_build_filename(base_dir, ".gnc-migration-tmp", "migrate-prefs-user.scm", NULL);
xmlSubstituteEntitiesDefault(1);
xmlLoadExtDtdDefaultValue = 1;
defaultEntityLoader = xmlGetExternalEntityLoader();
xmlSetExternalEntityLoader(xsltprocExternalEntityLoader);
stylesheetptr = xsltParseStylesheetFile((const xmlChar *)stylesheet);
inputxml = xmlParseFile(input);
transformedxml = xsltApplyStylesheet(stylesheetptr, inputxml, NULL);
outfile = fopen(output, "w");
xsltSaveResultToFile(outfile, transformedxml, stylesheetptr);
fclose(outfile);
xsltFreeStylesheet(stylesheetptr);
xmlFreeDoc(inputxml);
xmlFreeDoc(transformedxml);
xsltCleanupGlobals();
xmlCleanupParser();
g_free (stylesheet);
g_free (input);
migr_script = scm_from_locale_string (output);
scm_primitive_load (migr_script);
g_free (output);
migration_ok = scm_is_true (scm_c_eval_string ("(use-modules (migrate-prefs-user))(run-migration)"));
if (!migration_ok)
{
/* Actual migration step failed */
g_free (base_dir);
PWARN ("Actual migration step failed. Skip migration.");
LEAVE ();
return;
}
/* If we got here, the preferences were migrated successfully
* Mark this success in gsettings, so we won't run the migration again.
*/
gnc_gsettings_set_bool (GNC_PREFS_GROUP_GENERAL, GNC_PREF_MIGRATE_PREFS_DONE, TRUE);
/* All that is left now is to cleanup... */
command = g_strconcat ("(use-modules (migrate-prefs))(migration-cleanup \"",
base_dir, "\")", NULL);
DEBUG ("command = %s", command);
migration_ok = scm_is_true (scm_c_eval_string (command));
g_free (command);
if (!migration_ok) /* Cleanup step failed, not critical */
PWARN ("Cleanup step failed. You may need to delete %s/.gnc-migration-tmp manually.", base_dir);
else
PINFO ("Preferences migration completed successfully");
LEAVE ("");
g_free (base_dir);
}
int
main(int argc, char **argv)
{
int i;
xsltStylesheetPtr cur = NULL;
xmlDocPtr doc, style;
if (argc <= 1) {
usage(argv[0]);
return (1);
}
xmlInitMemory();
LIBXML_TEST_VERSION
defaultLoader = xmlGetExternalEntityLoader();
xmlLineNumbersDefault(1);
if (novalid == 0) /* TODO XML_DETECT_IDS | XML_COMPLETE_ATTRS */
xmlLoadExtDtdDefaultValue = 6;
else
xmlLoadExtDtdDefaultValue = 0;
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-"))
break;
if (argv[i][0] != '-')
continue;
#ifdef LIBXML_DEBUG_ENABLED
if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug"))) {
debug++;
} else
#endif
if ((!strcmp(argv[i], "-v")) ||
(!strcmp(argv[i], "-verbose")) ||
(!strcmp(argv[i], "--verbose"))) {
xsltSetGenericDebugFunc(stderr, NULL);
} else if ((!strcmp(argv[i], "-o")) ||
(!strcmp(argv[i], "-output")) ||
(!strcmp(argv[i], "--output"))) {
i++;
output = argv[i++];
} else if ((!strcmp(argv[i], "-V")) ||
(!strcmp(argv[i], "-version")) ||
(!strcmp(argv[i], "--version"))) {
printf("Using libxml %s, libxslt %s and libexslt %s\n",
xmlParserVersion, xsltEngineVersion, exsltLibraryVersion);
printf
("xsltproc was compiled against libxml %d, libxslt %d and libexslt %d\n",
LIBXML_VERSION, LIBXSLT_VERSION, LIBEXSLT_VERSION);
printf("libxslt %d was compiled against libxml %d\n",
xsltLibxsltVersion, xsltLibxmlVersion);
printf("libexslt %d was compiled against libxml %d\n",
exsltLibexsltVersion, exsltLibxmlVersion);
} else if ((!strcmp(argv[i], "-repeat"))
|| (!strcmp(argv[i], "--repeat"))) {
if (repeat == 0)
repeat = 20;
else
repeat = 100;
} else if ((!strcmp(argv[i], "-novalid")) ||
(!strcmp(argv[i], "--novalid"))) {
novalid++;
} else if ((!strcmp(argv[i], "-noout")) ||
(!strcmp(argv[i], "--noout"))) {
noout++;
#ifdef LIBXML_DOCB_ENABLED
} else if ((!strcmp(argv[i], "-docbook")) ||
(!strcmp(argv[i], "--docbook"))) {
docbook++;
#endif
#ifdef LIBXML_HTML_ENABLED
} else if ((!strcmp(argv[i], "-html")) ||
(!strcmp(argv[i], "--html"))) {
html++;
#endif
} else if ((!strcmp(argv[i], "-timing")) ||
(!strcmp(argv[i], "--timing"))) {
timing++;
} else if ((!strcmp(argv[i], "-profile")) ||
(!strcmp(argv[i], "--profile"))) {
profile++;
} else if ((!strcmp(argv[i], "-norman")) ||
(!strcmp(argv[i], "--norman"))) {
profile++;
} else if ((!strcmp(argv[i], "-warnnet")) ||
(!strcmp(argv[i], "--warnnet"))) {
xmlSetExternalEntityLoader(xsltNoNetExternalEntityLoader);
} else if ((!strcmp(argv[i], "-nonet")) ||
(!strcmp(argv[i], "--nonet"))) {
xmlSetExternalEntityLoader(xsltNoNetExternalEntityLoader);
nonet = 1;
#ifdef LIBXML_CATALOG_ENABLED
} else if ((!strcmp(argv[i], "-catalogs")) ||
(!strcmp(argv[i], "--catalogs"))) {
const char *catalogs;
catalogs = getenv("SGML_CATALOG_FILES");
if (catalogs == NULL) {
fprintf(stderr, "Variable $SGML_CATALOG_FILES not set\n");
} else {
xmlLoadCatalogs(catalogs);
}
#endif
#ifdef LIBXML_XINCLUDE_ENABLED
} else if ((!strcmp(argv[i], "-xinclude")) ||
(!strcmp(argv[i], "--xinclude"))) {
xinclude++;
xsltSetXIncludeDefault(1);
#endif
} else if ((!strcmp(argv[i], "-param")) ||
(!strcmp(argv[i], "--param"))) {
i++;
params[nbparams++] = argv[i++];
params[nbparams++] = argv[i];
if (nbparams >= 16) {
fprintf(stderr, "too many params\n");
return (1);
}
} else if ((!strcmp(argv[i], "-maxdepth")) ||
(!strcmp(argv[i], "--maxdepth"))) {
int value;
i++;
if (sscanf(argv[i], "%d", &value) == 1) {
if (value > 0)
xsltMaxDepth = value;
}
} else if (!strcmp(argv[i], "--r")) {
startRAutomatically = 1;
RstartupScript = strchr(argv[i],'=');
continue;
} else {
fprintf(stderr, "Unknown option %s\n", argv[i]);
usage(argv[0]);
return (1);
}
}
params[nbparams] = NULL;
/*
* Replace entities with their content.
*/
xmlSubstituteEntitiesDefault(1);
/*
* Register the EXSLT extensions
*/
exsltRegisterAll();
registerRModule(0);
if(startRAutomatically) {
extern int RXSLT_internalSource(const char *fileName);
int rargs = 1;
const char *rargv[] = { "Sxsltproc" };
Rf_initEmbeddedR(rargs, rargv);
loadXSLPackage();
if(RstartupScript && RstartupScript[0])
RXSLT_internalSource(RstartupScript);
}
for (i = 1; i < argc; i++) {
if ((!strcmp(argv[i], "-maxdepth")) ||
(!strcmp(argv[i], "--maxdepth"))) {
i++;
continue;
} else if ((!strcmp(argv[i], "-o")) ||
(!strcmp(argv[i], "-output")) ||
(!strcmp(argv[i], "--output"))) {
i++;
continue;
}
if ((!strcmp(argv[i], "-param")) || (!strcmp(argv[i], "--param"))) {
i += 2;
continue;
} else if(!strcmp(argv[i], "--r")) {
continue;
}
if ((argv[i][0] != '-') || (strcmp(argv[i], "-") == 0)) {
if (timing)
gettimeofday(&begin, NULL);
style = xmlParseFile((const char *) argv[i]);
if (timing) {
long msec;
gettimeofday(&end, NULL);
msec = end.tv_sec - begin.tv_sec;
msec *= 1000;
msec += (end.tv_usec - begin.tv_usec) / 1000;
fprintf(stderr, "Parsing stylesheet %s took %ld ms\n",
argv[i], msec);
}
if (style == NULL) {
fprintf(stderr, "cannot parse %s\n", argv[i]);
cur = NULL;
} else {
cur = xsltLoadStylesheetPI(style);
if (cur != NULL) {
/* it is an embedded stylesheet */
xsltProcess(style, cur, argv[i]);
xsltFreeStylesheet(cur);
exit(0);
}
cur = xsltParseStylesheetDoc(style);
if (cur != NULL) {
if (cur->indent == 1)
xmlIndentTreeOutput = 1;
else
xmlIndentTreeOutput = 0;
i++;
}
}
break;
}
}
/*
* disable CDATA from being built in the document tree
*/
xmlDefaultSAXHandlerInit();
xmlDefaultSAXHandler.cdataBlock = NULL;
if ((cur != NULL) && (cur->errors == 0)) {
for (; i < argc; i++) {
doc = NULL;
if (timing)
gettimeofday(&begin, NULL);
#ifdef LIBXML_HTML_ENABLED
if (html)
doc = htmlParseFile(argv[i], NULL);
else
#endif
#ifdef LIBXML_DOCB_ENABLED
if (docbook)
doc = docbParseFile(argv[i], NULL);
else
#endif
doc = xmlParseFile(argv[i]);
if (doc == NULL) {
fprintf(stderr, "unable to parse %s\n", argv[i]);
continue;
}
if (timing) {
long msec;
gettimeofday(&end, NULL);
msec = end.tv_sec - begin.tv_sec;
msec *= 1000;
msec += (end.tv_usec - begin.tv_usec) / 1000;
fprintf(stderr, "Parsing document %s took %ld ms\n",
argv[i], msec);
}
xsltProcess(doc, cur, argv[i]);
}
xsltFreeStylesheet(cur);
}
#ifdef CAN_UNREGISTER_MODULES
xsltUnregisterAllExtModules();
#endif
xmlCleanupParser();
xmlMemoryDump();
return (0);
}
QString transform(const QString &pat, const QString &tss,
const QVector<const char *> ¶ms)
{
QString parsed;
INFO(i18n("Parsing stylesheet"));
#if defined (SIMPLE_XSLT) && defined(Q_OS_WIN)
// prepare use of local available dtd versions instead of fetching every time from the internet
// this approach is url based
if (!defaultEntityLoader) {
defaultEntityLoader = xmlGetExternalEntityLoader();
xmlSetExternalEntityLoader(xsltprocExternalEntityLoader);
replaceURLList[QLatin1String("http://www.oasis-open.org/docbook/xml/4.5")] = QString("file:///%1").arg(DOCBOOK_XML_CURRDTD);
}
#endif
xsltStylesheetPtr style_sheet =
xsltParseStylesheetFile((const xmlChar *)QFile::encodeName(tss).constData());
if (!style_sheet) {
return parsed;
}
if (style_sheet->indent == 1) {
xmlIndentTreeOutput = 1;
} else {
xmlIndentTreeOutput = 0;
}
INFO(i18n("Parsing document"));
xmlParserCtxtPtr pctxt;
pctxt = xmlNewParserCtxt();
if ( pctxt == NULL ) {
return parsed;
}
xmlDocPtr doc = xmlCtxtReadFile(pctxt, QFile::encodeName(pat).constData(), NULL,
XML_PARSE_NOENT|XML_PARSE_DTDLOAD|XML_PARSE_NONET);
/* Clean the context pointer, now useless */
const bool context_valid = (pctxt->valid == 0);
xmlFreeParserCtxt(pctxt);
/* Check both the returned doc (for parsing errors) and the context
(for validation errors) */
if (doc == NULL) {
return parsed;
} else {
if (context_valid) {
xmlFreeDoc(doc);
return parsed;
}
}
INFO(i18n("Applying stylesheet"));
QVector<const char *> p = params;
p.append(NULL);
xmlDocPtr res = xsltApplyStylesheet(style_sheet, doc, const_cast<const char **>(&p[0]));
xmlFreeDoc(doc);
if (res != NULL) {
xmlOutputBufferPtr outp = xmlOutputBufferCreateIO(writeToQString, 0, &parsed, 0);
outp->written = 0;
INFO(i18n("Writing document"));
xsltSaveResultTo(outp, res, style_sheet);
xmlOutputBufferClose(outp);
xmlFreeDoc(res);
}
xsltFreeStylesheet(style_sheet);
if (parsed.isEmpty()) {
parsed = QLatin1Char(' '); // avoid error message
}
return parsed;
}
