Xsltproc::ReturnValue Xsltproc::execute()
{
Xsltproc::ReturnValue retval = Xsltproc::Success;
try
{
if( freopen(mErrorFilename.toUtf8().data(),"w",stderr) == NULL ) throw Xsltproc::GenericFailure;
mStylesheet = xsltParseStylesheetFile( (const xmlChar*)mStyleSheetFilename.toUtf8().data() );
if(mStylesheet == 0) throw Xsltproc::InvalidStylesheet;
mXml = xmlParseFile( (const char*)mXmlFilename.toUtf8().data() );
if(mXml == 0) throw Xsltproc::InvalidXmlFile;
mOutput = xsltApplyStylesheet(mStylesheet, mXml, (const char**)mParams);
if(mOutput == 0) throw Xsltproc::GenericFailure;
FILE *foutput = 0;
foutput = fopen(mOutputFilename.toUtf8().data(),"w");
if( foutput == 0 ) throw Xsltproc::CouldNotOpenOutput;
xsltSaveResultToFile(foutput, mOutput, mStylesheet);
fclose(foutput);
}
catch(Xsltproc::ReturnValue e)
{
retval = e;
}
fclose(stderr);
freeResources();
return retval;
}
void ExportDialog::accept()
{
QDialog::accept();
if (ui->csvRadio->isChecked()) {
/// Find the CSV filter in the standard filter list
//!@todo: good and clean solution
QStringList defaultFilters = KEduVocDocument::pattern(KEduVocDocument::Writing).split('\n');
QString filter = defaultFilters.filter(QStringLiteral("csv")).join(QStringLiteral("\n"));
QUrl filename = getFileName(filter);
if (filename != QUrl()) {
m_doc->saveAs(filename);
}
return;
}
QString xslFile;
if (ui->flashCardRadio->isChecked()) {
xslFile = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("parley/xslt/flashcards.xsl"));
} else {
xslFile = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("parley/xslt/table.xsl"));
}
QString filter = "*.html|" + i18n("HTML document");
QUrl filename = getFileName(filter);
if (filename.isEmpty()) {
return;
}
qDebug() << "XSLT starting";
xsltStylesheetPtr cur = NULL;
xmlDocPtr doc, res;
xmlSubstituteEntitiesDefault(1);
xmlLoadExtDtdDefaultValue = 1;
cur = xsltParseStylesheetFile((const xmlChar*) xslFile.toLatin1().constData());
doc = xmlParseDoc((const xmlChar*) m_doc->document()->toByteArray(m_doc->document()->generator()).constData());
res = xsltApplyStylesheet(cur, doc, 0);
FILE* result = fopen(QFile::encodeName(filename.toLocalFile()).constData(), "w");
if (result != NULL) {
xsltSaveResultToFile(result, res, cur);
fclose(result);
} else {
KMessageBox::error(this, i18n("Could not write to file \"%1\"", filename.toLocalFile()));
}
xsltFreeStylesheet(cur);
xmlFreeDoc(res);
xmlFreeDoc(doc);
xsltCleanupGlobals();
xmlCleanupParser();
qDebug() << "XSLT finished";
}
int export_dives_xslt(const char *filename, const bool selected, const int units, const char *export_xslt)
{
FILE *f;
struct membuffer buf = { 0 };
xmlDoc *doc;
xsltStylesheetPtr xslt = NULL;
xmlDoc *transformed;
int res = 0;
char *params[3];
int pnr = 0;
char unitstr[3];
if (verbose)
fprintf(stderr, "export_dives_xslt with stylesheet %s\n", export_xslt);
if (!filename)
return report_error("No filename for export");
/* Save XML to file and convert it into a memory buffer */
save_dives_buffer(&buf, selected);
/*
* Parse the memory buffer into XML document and
* transform it to selected export format, finally dumping
* the XML into a character buffer.
*/
doc = xmlReadMemory(buf.buffer, buf.len, "divelog", NULL, 0);
free_buffer(&buf);
if (!doc)
return report_error("Failed to read XML memory");
/* Convert to export format */
xslt = get_stylesheet(export_xslt);
if (!xslt)
return report_error("Failed to open export conversion stylesheet");
snprintf(unitstr, 3, "%d", units);
params[pnr++] = "units";
params[pnr++] = unitstr;
params[pnr++] = NULL;
transformed = xsltApplyStylesheet(xslt, doc, (const char **)params);
xmlFreeDoc(doc);
/* Write the transformed export to file */
f = subsurface_fopen(filename, "w");
if (f) {
xsltSaveResultToFile(f, transformed, xslt);
fclose(f);
/* Check write errors? */
} else {
res = report_error("Failed to open %s for writing (%s)", filename, strerror(errno));
}
xsltFreeStylesheet(xslt);
xmlFreeDoc(transformed);
return res;
}
bool cepgdata2xmltv::Translate(xmlDocPtr pxmlDoc, const char **params)
{
xmlDocPtr res=NULL;
if ((res = xsltApplyStylesheet (pxsltStylesheet, pxmlDoc, (const char **)params)) == NULL)
{
dsyslog("error applying xslt stylesheet");
return false;
}
else
{
xsltSaveResultToFile(stdout,res,pxsltStylesheet);
xmlFreeDoc (res);
}
return true;
}
int main(int argc, char *argv[])
{
xsltStylesheetPtr cur = NULL;
xmlDocPtr doc, res;
const char *params[16 + 1];
int nbparams = 0;
params[nbparams] = NULL;
KAboutData aboutData( "umbodoc", 0, ki18n("Umbrello UML Modeller autonomous code generator"),
umbrelloVersion(), ki18n(description), KAboutData::License_GPL,
ki18n("(c) 2006 Gael de Chalendar (aka Kleag), (c) 2002-2006 Umbrello UML Modeller Authors"), KLocalizedString(),
"http://uml.sf.net/");
aboutData.addAuthor(ki18n("Gael de Chalendar (aka Kleag)"),KLocalizedString(), "*****@*****.**");
aboutData.addAuthor(ki18n("Umbrello UML Modeller Authors"), KLocalizedString(), "*****@*****.**");
KCmdLineArgs::init( argc, argv, &aboutData );
KCmdLineOptions options;
options.add("+[File]", ki18n("File to transform"));
options.add("xslt <url>", ki18n("The XSLT file to use"));
KCmdLineArgs::addCmdLineOptions( options ); // Add our own options.
KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
QCStringList xsltOpt = args->getOptionList("xslt");
if (xsltOpt.size() > 0)
{
QString xsltFile(xsltOpt.last());
xmlSubstituteEntitiesDefault(1);
xmlLoadExtDtdDefaultValue = 1;
cur = xsltParseStylesheetFile((const xmlChar *)xsltFile.latin1());
doc = xmlParseFile(args->url( 0 ).url().latin1());
res = xsltApplyStylesheet(cur, doc, params);
xsltSaveResultToFile(stdout, res, cur);
xsltFreeStylesheet(cur);
xmlFreeDoc(res);
xmlFreeDoc(doc);
xsltCleanupGlobals();
xmlCleanupParser();
}
return(0);
}
/**********************************************************************
print_xml_using_stylesheet
Print the contents of an XML Doc to a file, applying an
XSLT stylesheet.
**********************************************************************/
BOOLEAN_T print_xml_filename_to_file_using_stylesheet(
char* input_file_path, /* path to XML input file IN */
char* stylesheet_file_path, /* path to MEME XSL stylesheet IN */
FILE* output_file /* path to HTML output file IN */
) {
xsltStylesheetPtr stylesheet = NULL;
xmlDocPtr input_doc = NULL;
xmlDocPtr output_doc = NULL;
const int PERFORM_ENTITY_SUBST = 1;
xmlSubstituteEntitiesDefault(PERFORM_ENTITY_SUBST);
input_doc = xmlParseFile(input_file_path);
if (!input_doc) {
fprintf(stderr, "Unable to parse input file %s.\n", input_file_path);
return FALSE;
}
exsltRegisterAll();
stylesheet = xsltParseStylesheetFile((const xmlChar *) stylesheet_file_path);
if (!stylesheet) {
fprintf(stderr, "Unable to parse stylesheet %s.\n", stylesheet_file_path);
return FALSE;
}
output_doc = xsltApplyStylesheet(stylesheet, input_doc, NULL);
if (!output_doc) {
fprintf(
stderr,
"Unable to apply stylsheet %s to to input.\n",
stylesheet_file_path
);
return FALSE;
}
int result = xsltSaveResultToFile(output_file, output_doc, stylesheet);
if (result == -1) {
fprintf(stderr, "Unable to save result of applying stylesheet %st.\n", stylesheet_file_path);
return FALSE;
}
xmlFreeDoc(output_doc);
xsltFreeStylesheet(stylesheet);
return TRUE;
} /* print_xml_to_file_using_stylesheet_html */
// Processes input XML file (e.g., instance metadata) into output XML file or string (e.g., for libvirt)
// using XSL-T specification file (e.g., libvirt.xsl)
static int apply_xslt_stylesheet (const char * xsltStylesheetPath, const char * inputXmlPath, const char * outputXmlPath, char * outputXmlBuffer, int outputXmlBufferSize)
{
int err = OK;
INIT();
xsltStylesheetPtr cur = xsltParseStylesheetFile ((const xmlChar *)xsltStylesheetPath);
if (cur) {
xmlDocPtr doc = xmlParseFile (inputXmlPath);
if (doc) {
xsltTransformContextPtr ctxt = xsltNewTransformContext (cur, doc); // need context to get result
xsltSetCtxtParseOptions (ctxt, 0); // TODO: do we want any XSL-T parsing options?
xmlDocPtr res = xsltApplyStylesheetUser (cur, doc, NULL, NULL, NULL, ctxt); // applies XSLT to XML
int applied_ok = ctxt->state==XSLT_STATE_OK; // errors are communicated via ctxt->state
xsltFreeTransformContext (ctxt);
if (res && applied_ok) {
// save to a file, if path was provied
if (outputXmlPath!=NULL) {
FILE * fp = fopen (outputXmlPath, "w");
if (fp) {
int bytes = xsltSaveResultToFile (fp, res, cur);
if (bytes==-1) {
logprintfl (EUCAERROR, "ERROR: failed to save XML document to %s\n", outputXmlPath);
err = ERROR;
}
fclose (fp);
} else {
logprintfl (EUCAERROR, "ERROR: failed to create file %s\n", outputXmlPath);
err = ERROR;
}
}
// convert to an ASCII buffer, if such was provided
if (err==OK && outputXmlBuffer!=NULL && outputXmlBufferSize > 0) {
xmlChar * buf;
int buf_size;
if (xsltSaveResultToString (&buf, &buf_size, res, cur)==0) { // success
if (buf_size < outputXmlBufferSize) {
bzero (outputXmlBuffer, outputXmlBufferSize);
for (int i=0, j=0; i<buf_size; i++) {
char c = (char) buf [i];
if (c != '\n') // remove newlines
outputXmlBuffer [j++] = c;
}
} else {
logprintfl (EUCAERROR, "ERROR: XML string buffer is too small (%d > %d)\n", buf_size, outputXmlBufferSize);
err = ERROR;
}
xmlFree (buf);
} else {
logprintfl (EUCAERROR, "ERROR: failed to save XML document to a string\n");
err = ERROR;
}
}
} else {
logprintfl (EUCAERROR, "ERROR: failed to apply stylesheet %s to %s\n", xsltStylesheetPath, inputXmlPath);
err = ERROR;
}
if (res!=NULL) xmlFreeDoc(res);
xmlFreeDoc(doc);
} else {
logprintfl (EUCAERROR, "ERROR: failed to parse XML document %s\n", inputXmlPath);
err = ERROR;
}
xsltFreeStylesheet(cur);
} else {
logprintfl (EUCAERROR, "ERROR: failed to open and parse XSL-T stylesheet file %s\n", xsltStylesheetPath);
err = ERROR;
}
return err;
}
static gboolean
msp_plugin_transform (PlannerPlugin *plugin,
const gchar *input_filename)
{
xsltStylesheet *stylesheet;
xmlDoc *doc;
xmlDoc *final_doc;
gint fd;
FILE *file;
gchar *tmp_name, *uri;
MrpProject *project;
gchar *filename;
/* libxml housekeeping */
xmlSubstituteEntitiesDefault (1);
xmlLoadExtDtdDefaultValue = 1;
exsltRegisterAll ();
filename = mrp_paths_get_stylesheet_dir ("msp2planner.xsl");
stylesheet = xsltParseStylesheetFile (filename);
g_free (filename);
doc = xmlParseFile (input_filename);
if (!doc) {
xsltFreeStylesheet (stylesheet);
return FALSE;
}
final_doc = xsltApplyStylesheet (stylesheet, doc, NULL);
xmlFree (doc);
if (!final_doc) {
xsltFreeStylesheet (stylesheet);
return FALSE;
}
filename = mrp_paths_get_dtd_dir ("mrproject-0.6.dtd");
if (!xml_validate (final_doc, filename)) {
GtkWidget *dialog;
xsltFreeStylesheet (stylesheet);
xmlFree (final_doc);
dialog = gtk_message_dialog_new (GTK_WINDOW (plugin->main_window),
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("Couldn't import file."));
gtk_widget_show (dialog);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
g_free (filename);
return FALSE;
}
g_free (filename);
fd = g_file_open_tmp ("planner-msp-XXXXXX", &tmp_name, NULL);
if (fd == -1) {
xsltFreeStylesheet (stylesheet);
xmlFree (final_doc);
return FALSE;
}
file = fdopen (fd, "w");
if (file == NULL) {
xsltFreeStylesheet (stylesheet);
xmlFree (final_doc);
close (fd);
g_free (tmp_name);
return FALSE;
}
if (xsltSaveResultToFile (file, final_doc, stylesheet) == -1) {
xsltFreeStylesheet (stylesheet);
xmlFree (final_doc);
fclose (file);
g_free (tmp_name);
return FALSE;
}
xsltFreeStylesheet (stylesheet);
xmlFree (final_doc);
uri = g_filename_to_uri (tmp_name, NULL, NULL);
if (uri) {
planner_window_open_in_existing_or_new (plugin->main_window, uri, TRUE);
project = planner_window_get_project (plugin->main_window) ;
mrp_project_set_uri (project, NULL);
}
unlink (tmp_name);
fclose (file);
g_free (tmp_name);
g_free (uri);
return TRUE;
}
int main(int argc, char **argv) {
int arg_indx;
const char *params[16 + 1];
int params_indx = 0;
int stylesheet_indx = 0;
int file_indx = 0;
int i, j, k;
FILE *output_file = stdout;
xsltStylesheetPtr *stylesheets =
(xsltStylesheetPtr *) calloc(argc, sizeof(xsltStylesheetPtr));
xmlDocPtr *files = (xmlDocPtr *) calloc(argc, sizeof(xmlDocPtr));
xmlDocPtr doc, res;
int return_value = 0;
if (argc <= 1) {
usage(argv[0]);
return_value = 1;
goto finish;
}
/* Collect arguments */
for (arg_indx = 1; arg_indx < argc; arg_indx++) {
if (argv[arg_indx][0] != '-')
break;
if ((!strcmp(argv[arg_indx], "-param"))
|| (!strcmp(argv[arg_indx], "--param"))) {
arg_indx++;
params[params_indx++] = argv[arg_indx++];
params[params_indx++] = argv[arg_indx];
if (params_indx >= 16) {
fprintf(stderr, "too many params\n");
return_value = 1;
goto finish;
}
} else if ((!strcmp(argv[arg_indx], "-o"))
|| (!strcmp(argv[arg_indx], "--out"))) {
arg_indx++;
output_file = fopen(argv[arg_indx], "w");
} else {
fprintf(stderr, "Unknown option %s\n", argv[arg_indx]);
usage(argv[0]);
return_value = 1;
goto finish;
}
}
params[params_indx] = 0;
/* Collect and parse stylesheets and files to be transformed */
for (; arg_indx < argc; arg_indx++) {
char *argument =
(char *) malloc(sizeof(char) * (strlen(argv[arg_indx]) + 1));
strcpy(argument, argv[arg_indx]);
if (strtok(argument, ".")) {
char *suffix = strtok(0, ".");
if (suffix && !strcmp(suffix, "xsl")) {
stylesheets[stylesheet_indx++] =
xsltParseStylesheetFile((const xmlChar *)argv[arg_indx]);;
} else {
files[file_indx++] = xmlParseFile(argv[arg_indx]);
}
} else {
files[file_indx++] = xmlParseFile(argv[arg_indx]);
}
free(argument);
}
xmlSubstituteEntitiesDefault(1);
xmlLoadExtDtdDefaultValue = 1;
/* Process files */
for (i = 0; files[i]; i++) {
doc = files[i];
res = doc;
for (j = 0; stylesheets[j]; j++) {
res = xsltApplyStylesheet(stylesheets[j], doc, params);
xmlFreeDoc(doc);
doc = res;
}
if (stylesheets[0]) {
xsltSaveResultToFile(output_file, res, stylesheets[j-1]);
} else {
xmlDocDump(output_file, res);
}
xmlFreeDoc(res);
}
fclose(output_file);
for (k = 0; stylesheets[k]; k++) {
xsltFreeStylesheet(stylesheets[k]);
}
xsltCleanupGlobals();
xmlCleanupParser();
finish:
free(stylesheets);
free(files);
return(return_value);
}
/* 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);
}
Xslt_Convert::Xslt_Convert( const QString xmlfile , const QString xsltfile , QString resulterxml )
:EndingJob(false),xmlcodec(0),xsltcodec(0)
{
////////qDebug() << "### Start Xslt_Convert ................... ->" << UmanTimeFromUnix(QTime_Null());
qt_unlink(XMLERROR_FILE); /* remove debug or error message from last */
qt_unlink(resulterxml); /* if exist */
///////QTimer::singleShot(1000, this, SLOT(CheckError()));
QFile *xfile = new QFile( xmlfile );
if (!xfile->exists()) {
emit ErrorMsg(QString("File %1 not exist!").arg(xmlfile));
return;
}
QFile *sfile = new QFile( xsltfile );
if (!sfile->exists()) {
emit ErrorMsg(QString("File %1 not exist!").arg(xsltfile));
return;
}
xmlcodec = GetcodecfromXml(xmlfile);
xsltcodec = GetcodecfromXml(xsltfile);
///////////qDebug() << "### xmlfile .......................... " << xmlfile;
////////qDebug() << "### xsltfile .......................... " << xsltfile;
////////qDebug() << "### codec .......................... " << xmlcodec->mibEnum();
////////qDebug() << "### codec .......................... " << xmlcodec->name();
//////qDebug() << "### codec .......................... " << xsltcodec->mibEnum();
////////qDebug() << "### codec .......................... " << xsltcodec->name();
const QString maildate = QString("\"%1\"").arg(UmanTimeFromUnix(QTime_Null()));
const QString unixtime = QString("\"%1\"").arg(QTime_Null());
const char* params[2];
params[0] = NULL;
params[1] = NULL;
/* ######################################### */
xsltStylesheetPtr cur = NULL;
xmlDocPtr doc, outputDoc;
xmlSubstituteEntitiesDefault(1);
xmlLoadExtDtdDefaultValue = 1;
/* ######################################### */
char* xslt_errors;
xsltSetGenericErrorFunc(&xslt_errors, qt_libxml_error_handler);
xmlSetGenericErrorFunc(&xslt_errors, qt_libxml_error_handler);
xsltSetGenericDebugFunc(&xslt_errors, qt_libxml_error_handler);
QByteArray gocharxslt = QFile::encodeName(xsltfile);
cur = xsltParseStylesheetFile( (const xmlChar*)gocharxslt.data() );
doc = xmlParseFile( QFile::encodeName(xmlfile) );
outputDoc = xsltApplyStylesheet(cur, doc, params);
xmlFreeDoc( doc ); /* free ram from xml! */
doc = outputDoc; /* swap input and output */
FILE* outfile = fopen( QFile::encodeName( resulterxml ), "w" );
xsltSaveResultToFile( outfile, doc, cur );
fclose( outfile );
xsltFreeStylesheet(cur);
xmlFreeDoc( outputDoc );
xsltCleanupGlobals();
xmlCleanupParser();
//////// qDebug() << "### resulterxml .......................... " << resulterxml;
//////// qDebug() << "### XMLERROR_FILE .......................... " << XMLERROR_FILE;
Rstream = StreamFromFile(resulterxml);
debug_msg = ReadFileUtf8Xml(XMLERROR_FILE);
/////////qDebug() << "### resulterxml .......................... " << debug_msg;
qt_unlink(XMLERROR_FILE);
EndingJob = true;
emit DebugMsg(debug_msg);
}
static void
xsltProcess(xmlDocPtr doc, xsltStylesheetPtr cur, const char *filename) {
xmlDocPtr res;
#ifdef LIBXML_XINCLUDE_ENABLED
if (xinclude) {
if (timing)
gettimeofday(&begin, NULL);
xmlXIncludeProcess(doc);
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, "XInclude processing %s took %ld ms\n",
filename, msec);
}
}
#endif
if (timing)
gettimeofday(&begin, NULL);
if (output == NULL) {
if (repeat) {
int j;
for (j = 1; j < repeat; j++) {
res = xsltApplyStylesheet(cur, doc, params);
xmlFreeDoc(res);
xmlFreeDoc(doc);
#ifdef LIBXML_HTML_ENABLED
if (html)
doc = htmlParseFile(filename, NULL);
else
#endif
#ifdef LIBXML_DOCB_ENABLED
if (docbook)
doc = docbParseFile(filename, NULL);
else
#endif
doc = xmlParseFile(filename);
}
}
if (profile) {
res = xsltProfileStylesheet(cur, doc, params, stderr);
} else {
res = xsltApplyStylesheet(cur, doc, params);
}
if (timing) {
long msec;
gettimeofday(&end, NULL);
msec = end.tv_sec - begin.tv_sec;
msec *= 1000;
msec += (end.tv_usec - begin.tv_usec) / 1000;
if (repeat)
fprintf(stderr,
"Applying stylesheet %d times took %ld ms\n",
repeat, msec);
else
fprintf(stderr,
"Applying stylesheet took %ld ms\n", msec);
}
xmlFreeDoc(doc);
if (res == NULL) {
fprintf(stderr, "no result for %s\n", filename);
return;
}
if (noout) {
xmlFreeDoc(res);
return;
}
#ifdef LIBXML_DEBUG_ENABLED
if (debug)
xmlDebugDumpDocument(stdout, res);
else {
#endif
if (cur->methodURI == NULL) {
if (timing)
gettimeofday(&begin, NULL);
xsltSaveResultToFile(stdout, res, cur);
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, "Saving result took %ld ms\n",
msec);
}
} else {
if (xmlStrEqual
(cur->method, (const xmlChar *) "xhtml")) {
fprintf(stderr, "non standard output xhtml\n");
if (timing)
gettimeofday(&begin, NULL);
xsltSaveResultToFile(stdout, res, cur);
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,
"Saving result took %ld ms\n",
msec);
}
} else {
fprintf(stderr,
"Unsupported non standard output %s\n",
cur->method);
}
}
#ifdef LIBXML_DEBUG_ENABLED
}
#endif
xmlFreeDoc(res);
} else {
xsltRunStylesheet(cur, doc, params, output, NULL, NULL);
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,
"Running stylesheet and saving result took %ld ms\n",
msec);
}
xmlFreeDoc(doc);
}
}
