You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1421 lines
38 KiB
1421 lines
38 KiB
|
|
/***************************************************************************
|
|
files.h - define file related functions
|
|
-------------------
|
|
begin : Sat Nov 10 2001
|
|
copyright : (C) 2001 by Keith Isdale
|
|
email : k_isdale@tpg.com.au
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
/* We want skip most of these includes when building documentation */
|
|
#ifndef BUILD_DOCS
|
|
|
|
#include "xsldbg.h"
|
|
#include <stdio.h>
|
|
#include <libxml/entities.h>
|
|
#include <libxml/tree.h>
|
|
#include <libxml/catalog.h>
|
|
#include <libxml/parserInternals.h>
|
|
#include <libxml/encoding.h> /* needed by filesTranslate, filesEncoding functions */
|
|
#include <libxml/uri.h> /* needed for xmlURIUnescapeString */
|
|
#include "debugXSL.h"
|
|
#include "files.h"
|
|
#include "utils.h"
|
|
#include "options.h"
|
|
#include "xsldbgthread.h"
|
|
#ifdef WIN32
|
|
#include <direct.h>
|
|
#endif
|
|
|
|
#endif /* BUILD_DOCS */
|
|
|
|
|
|
/* top xml document */
|
|
static xmlDocPtr topDocument;
|
|
|
|
/* temporary xml document */
|
|
static xmlDocPtr tempDocument;
|
|
|
|
/* used as a scratch pad for temporary results*/
|
|
static xmlChar filesBuffer[DEBUG_BUFFER_SIZE];
|
|
|
|
/* top stylsheet */
|
|
static xsltStylesheetPtr topStylesheet;
|
|
|
|
/* what is the base path for top stylesheet */
|
|
static xmlChar *stylePathName = NULL;
|
|
|
|
/* what is the path for current working directory*/
|
|
static xmlChar *workingDirPath = NULL;
|
|
|
|
static arrayListPtr entityNameList = NULL;
|
|
|
|
/* Current encoding to use for standard output*/
|
|
static xmlCharEncodingHandlerPtr stdoutEncoding = NULL;
|
|
|
|
/* input and output buffers for encoding*/
|
|
static xmlBufferPtr encodeInBuff = NULL;
|
|
static xmlBufferPtr encodeOutBuff = NULL;
|
|
|
|
/* Current line number and URI for xsldbg*/
|
|
static int currentLineNo = -1;
|
|
static xmlChar *currentUrl = NULL;
|
|
|
|
/* -----------------------------------------
|
|
Private function declarations for files.c
|
|
-------------------------------------------*/
|
|
|
|
/**
|
|
* guessStylesheetHelper:
|
|
* @payload: valid xsltStylesheetPtr
|
|
* @data: valid searchInfoPtr of type SEARCH_NODE
|
|
* @name: not used
|
|
*
|
|
* Try to guess what the complete file/URI is. If successful the search
|
|
* info will be set to found and the search data will contain the
|
|
* file name found. We are given our payload via walkStylesheets
|
|
*/
|
|
static void guessStylesheetHelper(void *payload, void *data,
|
|
xmlChar * name);
|
|
|
|
|
|
/**
|
|
* guessStylesheetHelper2:
|
|
* @payload: valid xmlNodePtr of the included stylesheet
|
|
* @data: valid searchInfoPtr of type SEARCH_NODE
|
|
* @name: not used
|
|
*
|
|
* Try to guess what the complete file/URI is. If successful the search
|
|
* info will be set to found and the search data will contain the
|
|
* file name found. We are given our payload via walkIncludes
|
|
*/
|
|
static void guessStylesheetHelper2(void *payload, void *data,
|
|
xmlChar * name);
|
|
|
|
|
|
entityInfoPtr filesNewEntityInfo(const xmlChar * SystemID,
|
|
const xmlChar * PublicID);
|
|
|
|
void filesFreeEntityInfo(entityInfoPtr info);
|
|
|
|
void filesAddEntityName(const xmlChar * SystemID,
|
|
const xmlChar * PublicID);
|
|
|
|
|
|
/* -------------------------------------
|
|
End private functions
|
|
---------------------------------------*/
|
|
|
|
|
|
FILE *terminalIO;
|
|
|
|
/* No longer needed
|
|
static FILE *oldStdin, *oldStdout, *oldStderr;*/
|
|
|
|
|
|
//static char *ttyName = NULL; /* what is the name of the default terminal */
|
|
static char *termName = NULL; /* what is the name of terminal we are redirected to */
|
|
|
|
|
|
/**
|
|
* redirectToTerminal:
|
|
* @device: terminal to redirect i/o to , will not work under win32
|
|
*
|
|
* Open communications to the terminal device @device
|
|
*
|
|
* Returns 1 if sucessful
|
|
* 0 otherwise
|
|
*/
|
|
int
|
|
openTerminal(xmlChar * device)
|
|
{
|
|
int result = 0;
|
|
|
|
if (!device) { /* Failed; there's no device */
|
|
#ifdef WITH_XSLDBG_DEBUG_PROCESS
|
|
xsltGenericError(xsltGenericErrorContext,
|
|
"Error: NULL argument provided\n");
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* On RISC OS, you get one terminal - the screen.
|
|
* we assume that the parameter is meant to be an output device as
|
|
* per normal - we can use vdu:, rawvdu: or :tt, or a filename for
|
|
* normal VDU output, VDU output without newline expansion,
|
|
* C terminal output with control code escaping, or a raw file
|
|
* respectively.
|
|
* The name passed is expected to be in native file format - no
|
|
* URI escaping here.
|
|
* One assumes that you might use a socket or a pipe here.
|
|
*/
|
|
|
|
if (terminalIO) {
|
|
fclose(terminalIO);
|
|
terminalIO = NULL;
|
|
}
|
|
|
|
|
|
switch (device[0]) {
|
|
case '\0':
|
|
case '0':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
/* look like we are supposed to close the terminal
|
|
* but we've already done that
|
|
*/
|
|
break;
|
|
|
|
case '1':
|
|
if (termName) {
|
|
terminalIO = fopen((char *) termName, "w");
|
|
if (terminalIO != NULL) {
|
|
xmlFree(termName);
|
|
termName = xmlMemStrdup((char *) device);
|
|
result = 1;
|
|
} else {
|
|
xsldbgGenericErrorFunc(i18n("Error: Unable to open terminal %1.\n").tqarg(xsldbgText(termName)));
|
|
}
|
|
} else {
|
|
xsldbgGenericErrorFunc(i18n("Error: Did not previously open terminal.\n"));
|
|
}
|
|
break;
|
|
|
|
case '2':
|
|
#ifdef WITH_XSLDBG_DEBUG_PROCESS
|
|
xsltGenericError(xsltGenericErrorContext,
|
|
"Warning: Terminal level 2 not implemented\n");
|
|
#endif
|
|
break;
|
|
|
|
|
|
default:
|
|
terminalIO = fopen((char *) device, "w");
|
|
if (terminalIO != NULL) {
|
|
if (termName)
|
|
xmlFree(termName);
|
|
termName = xmlMemStrdup((char *) device);
|
|
result = 1;
|
|
} else {
|
|
xsldbgGenericErrorFunc(i18n("Error: Unable to open terminal %1.\n").tqarg(xsldbgText(device)));
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* guessStylesheetHelper:
|
|
* @payload: valid xsltStylesheetPtr
|
|
* @data: valid searchInfoPtr of type SEARCH_NODE
|
|
* @name: not used
|
|
*
|
|
* Try to guess what the complete file/URI is. If successful the search
|
|
* info will be set to found and the search data will contain the
|
|
* file name found. We are given our payload via walkStylesheets
|
|
*/
|
|
void
|
|
guessStylesheetHelper(void *payload, void *data,
|
|
xmlChar * name)
|
|
{
|
|
Q_UNUSED(name);
|
|
xsltStylesheetPtr style = (xsltStylesheetPtr) payload;
|
|
searchInfoPtr searchCriteria = (searchInfoPtr) data;
|
|
nodeSearchDataPtr searchData = NULL;
|
|
/* where did the directory/URI separator occur */
|
|
char *lastSlash;
|
|
|
|
if (!style || !style->doc || !searchCriteria || !searchCriteria->data
|
|
|| (searchCriteria->type != SEARCH_NODE))
|
|
return;
|
|
|
|
searchData = (nodeSearchDataPtr) searchCriteria->data;
|
|
if (searchData->nameInput && (searchData->absoluteNameMatch == NULL)) {
|
|
/* at this point we know that we have not made an absolute match
|
|
* but we may have made a relative match */
|
|
if (xmlStrCmp(style->doc->URL, searchData->nameInput) == 0) {
|
|
/* absolute path match great! */
|
|
searchData->absoluteNameMatch =
|
|
(xmlChar *) xmlMemStrdup((char *) style->doc->URL);
|
|
searchData->node = (xmlNodePtr) style->doc;
|
|
searchCriteria->found = 1;
|
|
return;
|
|
}
|
|
|
|
|
|
/* try to guess we assume that the files are unique */
|
|
xmlStrCpy(filesBuffer, "__#!__");
|
|
/* try relative to top stylesheet directory */
|
|
if (stylePath()) {
|
|
xmlStrCpy(filesBuffer, stylePath());
|
|
xmlStrCat(filesBuffer, searchData->nameInput);
|
|
}
|
|
if (xmlStrCmp(style->doc->URL, filesBuffer) == 0) {
|
|
/* guessed right! */
|
|
searchData->guessedNameMatch =
|
|
(xmlChar *) xmlMemStrdup((char *) filesBuffer);
|
|
searchData->node = (xmlNodePtr) style->doc;
|
|
searchCriteria->found = 1;
|
|
return;
|
|
}
|
|
|
|
if (workingPath()) {
|
|
/* try relative to working directory */
|
|
xmlStrCpy(filesBuffer, workingPath());
|
|
xmlStrCat(filesBuffer, searchData->nameInput);
|
|
}
|
|
if (xmlStrCmp(style->doc->URL, filesBuffer) == 0) {
|
|
/* guessed right! */
|
|
searchData->guessedNameMatch =
|
|
(xmlChar *) xmlMemStrdup((char *) filesBuffer);
|
|
searchData->node = (xmlNodePtr) style->doc;
|
|
searchCriteria->found = 1;
|
|
return;
|
|
}
|
|
|
|
|
|
/* Find the last separator of the stylsheet's URL */
|
|
lastSlash = xmlStrChr(style->doc->URL, URISEPARATORCHAR);
|
|
if (!lastSlash)
|
|
lastSlash = xmlStrChr(style->doc->URL, PATHCHAR);
|
|
|
|
if (lastSlash) {
|
|
/* Last try, assume nameInput contains only a file name
|
|
* Strip of the file name at end of the stylesheet doc URL */
|
|
lastSlash++; /* skip the slash */
|
|
if (xmlStrCmp(lastSlash, searchData->nameInput) == 0) {
|
|
/* guessed right! */
|
|
searchData->guessedNameMatch =
|
|
(xmlChar *) xmlMemStrdup((char *) style->doc->URL);
|
|
searchData->node = (xmlNodePtr) style->doc;
|
|
searchCriteria->found = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* guessStylesheetHelper2:
|
|
* @payload: valid xmlNodePtr of the included stylesheet
|
|
* @data: valid searchInfoPtr of type SEARCH_NODE
|
|
* @name: not used
|
|
*
|
|
* Try to guess what the complete file/URI is. If successful the search
|
|
* info will be set to found and the search data will contain the
|
|
* file name found. We are given our payload via walkIncludes
|
|
*/
|
|
void
|
|
guessStylesheetHelper2(void *payload, void *data,
|
|
xmlChar * name)
|
|
{
|
|
Q_UNUSED(name);
|
|
xmlNodePtr node = (xmlNodePtr) payload;
|
|
searchInfoPtr searchCriteria = (searchInfoPtr) data;
|
|
nodeSearchDataPtr searchData = NULL;
|
|
/* where did the directory/URI separator occur */
|
|
char *lastSlash;
|
|
|
|
if (!node || !node->doc || !searchCriteria || !searchCriteria->data ||
|
|
(searchCriteria->type != SEARCH_NODE))
|
|
return;
|
|
|
|
searchData = (nodeSearchDataPtr) searchCriteria->data;
|
|
if (searchData->nameInput && (searchData->absoluteNameMatch == NULL)) {
|
|
/* at this point we know that we have not made an absolute match
|
|
* but we may have made a relative match */
|
|
if (xmlStrCmp(node->doc->URL, searchData->nameInput) == 0) {
|
|
/* absolute path match great! */
|
|
searchData->absoluteNameMatch =
|
|
(xmlChar *) xmlMemStrdup((char *) node->doc->URL);
|
|
searchData->node = node;
|
|
searchCriteria->found = 1;
|
|
return;
|
|
}
|
|
|
|
|
|
/* try to guess we assume that the files are unique */
|
|
xmlStrCpy(filesBuffer, "__#!__");
|
|
/* try relative to top stylesheet directory */
|
|
if (stylePath()) {
|
|
xmlStrCpy(filesBuffer, stylePath());
|
|
xmlStrCat(filesBuffer, searchData->nameInput);
|
|
}
|
|
if (xmlStrCmp(node->doc->URL, filesBuffer) == 0) {
|
|
/* guessed right! */
|
|
searchData->guessedNameMatch =
|
|
(xmlChar *) xmlMemStrdup((char *) filesBuffer);
|
|
searchData->node = node;
|
|
searchCriteria->found = 1;
|
|
return;
|
|
}
|
|
|
|
if (workingPath()) {
|
|
/* try relative to working directory */
|
|
xmlStrCpy(filesBuffer, workingPath());
|
|
xmlStrCat(filesBuffer, searchData->nameInput);
|
|
}
|
|
if (xmlStrCmp(node->doc->URL, filesBuffer) == 0) {
|
|
/* guessed right! */
|
|
searchData->guessedNameMatch =
|
|
(xmlChar *) xmlMemStrdup((char *) filesBuffer);
|
|
searchData->node = node;
|
|
searchCriteria->found = 1;
|
|
return;
|
|
}
|
|
|
|
|
|
/* Find the last separator of the stylsheet's URL */
|
|
lastSlash = xmlStrChr(node->doc->URL, URISEPARATORCHAR);
|
|
if (!lastSlash)
|
|
lastSlash = xmlStrChr(node->doc->URL, PATHCHAR);
|
|
|
|
if (lastSlash) {
|
|
/* Last try, assume nameInput contains only a file name
|
|
* Strip of the file name at end of the stylesheet doc URL */
|
|
lastSlash++; /* skip the slash */
|
|
if (xmlStrCmp(lastSlash, searchData->nameInput) == 0) {
|
|
/* guessed right! */
|
|
searchData->guessedNameMatch =
|
|
(xmlChar *) xmlMemStrdup((char *) node->doc->URL);
|
|
searchData->node = node;
|
|
searchCriteria->found = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* guessStylesheetName:
|
|
* @searchInf: Is valid
|
|
*
|
|
* Try to find a matching stylesheet name
|
|
* Sets the values in @searchinf depending on outcome of search
|
|
*/
|
|
void
|
|
guessStylesheetName(searchInfoPtr searchCriteria)
|
|
{
|
|
nodeSearchDataPtr searchData;
|
|
|
|
if (!searchCriteria)
|
|
return;
|
|
|
|
searchData = (nodeSearchDataPtr) searchCriteria->data;
|
|
if (searchData->nameInput == NULL)
|
|
return; /* must supply name of file to look for */
|
|
|
|
walkStylesheets((xmlHashScanner) guessStylesheetHelper,
|
|
searchCriteria, filesGetStylesheet());
|
|
if (!searchCriteria->found) {
|
|
/* try looking in the included stylesheets */
|
|
walkIncludes((xmlHashScanner) guessStylesheetHelper2,
|
|
searchCriteria, filesGetStylesheet());
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* stylePath:
|
|
*
|
|
* Return The base path for the top stylesheet ie
|
|
* ie URL minus the actual file name
|
|
*
|
|
* Returns The base path for the top stylesheet ie
|
|
* ie URL minus the actual file name
|
|
*/
|
|
xmlChar *
|
|
stylePath(void)
|
|
{
|
|
return stylePathName;
|
|
}
|
|
|
|
|
|
/**
|
|
* workingPath:
|
|
*
|
|
* Return the working directory as set by changeDir function
|
|
*
|
|
* Returns The working directory as set by changeDir function
|
|
*/
|
|
xmlChar *
|
|
workingPath(void)
|
|
{
|
|
return workingDirPath;
|
|
}
|
|
|
|
|
|
/**
|
|
* changeDir:
|
|
* @path: The path to adopt as new working directory
|
|
*
|
|
* Change working directory to path
|
|
*
|
|
* Returns 1 on success,
|
|
* 0 otherwise
|
|
*/
|
|
int
|
|
changeDir(const xmlChar * path)
|
|
{
|
|
int result = 0;
|
|
int charIndex;
|
|
const char endString[2] = { PATHCHAR, '\0' };
|
|
xmlChar *expandedName = NULL;
|
|
|
|
|
|
if (path && (xmlStrLen(path) > 0)) {
|
|
expandedName = filesExpandName(path);
|
|
} else {
|
|
#ifdef WITH_XSLDBG_DEBUG_PROCESS
|
|
xsltGenericError(xsltGenericErrorContext,
|
|
"Error: Empty path provided to changeDir");
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
if (!expandedName)
|
|
return result; /* out of memory ? */
|
|
|
|
if (xmlStrLen(expandedName) + 1 > sizeof(filesBuffer)) {
|
|
xsldbgGenericErrorFunc(i18n("Error: The file name \"%1\" is too long.\n").tqarg(xsldbgText(path)));
|
|
return result;
|
|
}
|
|
|
|
xmlStrCpy(filesBuffer, expandedName);
|
|
/* strip off any extra PATHCHAR's as win32's chdir function
|
|
* fails if we don't */
|
|
charIndex = xmlStrLen(filesBuffer) - 1;
|
|
while (charIndex && (filesBuffer[charIndex] == PATHCHAR)) {
|
|
charIndex--;
|
|
}
|
|
filesBuffer[charIndex + 1] = '\0';
|
|
|
|
|
|
if (chdir((char *) filesBuffer) == 0) {
|
|
if (workingDirPath)
|
|
xmlFree(workingDirPath);
|
|
/* must have path char at end of path name */
|
|
xmlStrCat(filesBuffer, endString);
|
|
workingDirPath = (xmlChar *) xmlMemStrdup((char *) filesBuffer);
|
|
result = 1;
|
|
}
|
|
xmlFree(expandedName); /* this will always be valid time */
|
|
if (!result) {
|
|
xsldbgGenericErrorFunc(i18n("Error: Unable to change to directory %1.\n").tqarg(xsldbgText(path)));
|
|
} else {
|
|
if (xslDebugStatus != DEBUG_NONE)
|
|
xsldbgGenericErrorFunc(i18n("Changed to directory %1.\n").tqarg(xsldbgText(path)));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* filesLoadXmlFile:
|
|
* @path: xml file to load
|
|
* @fileType: A valid FileTypeEnum
|
|
*
|
|
* Load specified file type, freeing any memory previously used
|
|
*
|
|
* Returns 1 on success,
|
|
* 0 otherwise
|
|
*/
|
|
int
|
|
filesLoadXmlFile(const xmlChar * path, FileTypeEnum fileType)
|
|
{
|
|
int result = 0;
|
|
|
|
if (!filesFreeXmlFile(fileType))
|
|
return result;
|
|
|
|
switch (fileType) {
|
|
case FILES_XMLFILE_TYPE:
|
|
if (path && xmlStrLen(path)) {
|
|
if (optionsGetIntOption(OPTIONS_SHELL)) {
|
|
xsldbgGenericErrorFunc(i18n("Setting XML Data file name to %1.\n").tqarg(xsldbgText(path)));
|
|
}
|
|
optionsSetStringOption(OPTIONS_DATA_FILE_NAME, path);
|
|
}
|
|
topDocument = xsldbgLoadXmlData();
|
|
if (topDocument)
|
|
result = 1;
|
|
break;
|
|
|
|
case FILES_SOURCEFILE_TYPE:
|
|
if (path && xmlStrLen(path)) {
|
|
if (optionsGetIntOption(OPTIONS_SHELL)) {
|
|
xsldbgGenericErrorFunc(i18n("Setting stylesheet file name to %1.\n").tqarg(xsldbgText(path)));
|
|
}
|
|
optionsSetStringOption(OPTIONS_SOURCE_FILE_NAME, path);
|
|
}
|
|
topStylesheet = xsldbgLoadStylesheet();
|
|
if (topStylesheet && topStylesheet->doc) {
|
|
/* look for last slash (or baskslash) of URL */
|
|
char *lastSlash = xmlStrrChr(topStylesheet->doc->URL,
|
|
PATHCHAR);
|
|
const char *docUrl =
|
|
(const char *) topStylesheet->doc->URL;
|
|
|
|
result = 1;
|
|
if (docUrl && lastSlash) {
|
|
stylePathName = (xmlChar *) xmlMemStrdup(docUrl);
|
|
stylePathName[lastSlash - docUrl + 1] = '\0';
|
|
if (optionsGetIntOption(OPTIONS_SHELL)) {
|
|
xsldbgGenericErrorFunc(i18n("Setting stylesheet base path to %1.\n").tqarg(xsldbgText(stylePathName)));
|
|
}
|
|
} else {
|
|
const char cwd[4] = { '.', PATHCHAR, '\0' };
|
|
|
|
/* ie for *nix this becomes "./" */
|
|
stylePathName = xmlStrdup(BAD_CAST cwd);
|
|
}
|
|
|
|
/* try to find encoding for this stylesheet */
|
|
if (optionsGetIntOption(OPTIONS_AUTOENCODE))
|
|
filesSetEncoding((char *) topStylesheet->encoding);
|
|
}
|
|
break;
|
|
|
|
case FILES_TEMPORARYFILE_TYPE:
|
|
if (!path || !xmlStrLen(path)) {
|
|
xsldbgGenericErrorFunc(i18n("Missing file name.\n"));
|
|
break;
|
|
}
|
|
topDocument = xsldbgLoadXmlTemporary(path);
|
|
if (tempDocument)
|
|
result = 1;
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* filesFreeXmlFile:
|
|
* @fileType: A valid FileTypeEnum
|
|
*
|
|
* Free memory associated with the xml file
|
|
*
|
|
* Returns 1 on success,
|
|
* 0 otherwise
|
|
*/
|
|
int
|
|
filesFreeXmlFile(FileTypeEnum fileType)
|
|
{
|
|
int result = 0, type = fileType;
|
|
|
|
switch (type) {
|
|
case FILES_XMLFILE_TYPE:
|
|
if (topDocument)
|
|
xmlFreeDoc(topDocument);
|
|
topDocument = NULL;
|
|
result = 1;
|
|
break;
|
|
|
|
case FILES_SOURCEFILE_TYPE:
|
|
if (topStylesheet)
|
|
xsltFreeStylesheet(topStylesheet);
|
|
if (stylePathName)
|
|
xmlFree(stylePathName);
|
|
stylePathName = NULL;
|
|
topStylesheet = NULL;
|
|
result = 1;
|
|
break;
|
|
|
|
case FILES_TEMPORARYFILE_TYPE:
|
|
if (tempDocument)
|
|
xmlFreeDoc(tempDocument);
|
|
tempDocument = NULL;
|
|
result = 1;
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* filesGetStylesheet:
|
|
*
|
|
* Return The topmost stylesheet non-null on success,
|
|
* NULL otherwise
|
|
*
|
|
* Returns The topmost stylesheet non-null on success,
|
|
* NULL otherwise
|
|
*/
|
|
xsltStylesheetPtr
|
|
filesGetStylesheet(void)
|
|
{
|
|
return topStylesheet;
|
|
}
|
|
|
|
|
|
/**
|
|
* filesGetTemporaryDoc:
|
|
*
|
|
* Return The current "temporary" document
|
|
*
|
|
* Returns The current "temporary" document
|
|
*/
|
|
xmlDocPtr
|
|
filesGetTemporaryDoc(void)
|
|
{
|
|
return tempDocument;
|
|
}
|
|
|
|
|
|
/**
|
|
* filesGetMainDoc:
|
|
*
|
|
* Return The main docment
|
|
*
|
|
* Returns The main docment
|
|
*/
|
|
xmlDocPtr
|
|
filesGetMainDoc(void)
|
|
{
|
|
return topDocument;
|
|
}
|
|
|
|
|
|
/**
|
|
* filesReloaded:
|
|
* @reloaded: if = -1 then ignore @reloaded
|
|
* otherwise change the status of files to value of @reloaded
|
|
*
|
|
* Returns 1 if stylesheet or its xml data file has been "flaged" as reloaded,
|
|
* 0 otherwise
|
|
*/
|
|
int
|
|
filesReloaded(int reloaded)
|
|
{
|
|
static int changed = 0;
|
|
|
|
if (reloaded >= 0) {
|
|
changed = reloaded;
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* filesInit:
|
|
*
|
|
* Initialize the file related structures
|
|
* Returns 1 on success,
|
|
* 0 otherwise
|
|
*/
|
|
int
|
|
filesInit(void)
|
|
{
|
|
int result = 0;
|
|
|
|
terminalIO = NULL;
|
|
#ifdef __riscos
|
|
ttyName = ":tt"; /* Default tty */
|
|
#endif
|
|
#ifdef HAVE_UNISTD
|
|
ttyName = ttyname(fileno(stdin));
|
|
/* save out io for when/if we send debugging to a terminal */
|
|
oldStdin = stdin;
|
|
oldStdout = stdout;
|
|
oldStderr = stderr;
|
|
#endif
|
|
topDocument = NULL;
|
|
tempDocument = NULL;
|
|
topStylesheet = NULL;
|
|
entityNameList = arrayListNew(4, (freeItemFunc) filesFreeEntityInfo);
|
|
#if defined(HAVE_INCLUDE_FIX) && (LIBXML_VERSION < 20508)
|
|
xmlSetEntityReferenceFunc(filesEntityRef);
|
|
#endif
|
|
|
|
/* setup the encoding */
|
|
encodeInBuff = xmlBufferCreate();
|
|
encodeOutBuff = xmlBufferCreate();
|
|
|
|
/* check the result so far and lastly perform platform specific
|
|
* initialization */
|
|
if (entityNameList && encodeInBuff && encodeOutBuff &&
|
|
filesPlatformInit())
|
|
result = 1;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* filesFree:
|
|
*
|
|
* Free memory used by file related structures
|
|
*/
|
|
void
|
|
filesFree(void)
|
|
{
|
|
int result;
|
|
|
|
if (terminalIO) {
|
|
fclose(terminalIO);
|
|
terminalIO = NULL;
|
|
}
|
|
if (termName) {
|
|
xmlFree(termName);
|
|
termName = NULL;
|
|
}
|
|
|
|
result = filesFreeXmlFile(FILES_SOURCEFILE_TYPE);
|
|
if (result)
|
|
result = filesFreeXmlFile(FILES_XMLFILE_TYPE);
|
|
if (result)
|
|
result = filesFreeXmlFile(FILES_TEMPORARYFILE_TYPE);
|
|
if (!result){
|
|
#ifdef WITH_XSLDBG_DEBUG_PROCESS
|
|
xsltGenericError(xsltGenericErrorContext,
|
|
"Error: Unable to free memory used by XML/XSLT files\n");
|
|
#endif
|
|
}
|
|
if (stylePathName) {
|
|
xmlFree(stylePathName);
|
|
stylePathName = NULL;
|
|
}
|
|
|
|
if (workingDirPath) {
|
|
xmlFree(workingDirPath);
|
|
workingDirPath = NULL;
|
|
}
|
|
|
|
if (entityNameList) {
|
|
arrayListFree(entityNameList);
|
|
entityNameList = NULL;
|
|
}
|
|
|
|
/* Free memory used by encoding related structures */
|
|
if (encodeInBuff)
|
|
xmlBufferFree(encodeInBuff);
|
|
|
|
if (encodeOutBuff)
|
|
xmlBufferFree(encodeOutBuff);
|
|
|
|
/* close current encoding */
|
|
filesSetEncoding(NULL);
|
|
|
|
if (currentUrl)
|
|
xmlFree(currentUrl);
|
|
|
|
/* free any memory used by platform specific files module */
|
|
filesPlatformFree();
|
|
}
|
|
|
|
|
|
/**
|
|
* filesIsSourceFile:
|
|
* @fileName : is valid
|
|
*
|
|
* Returns true if @name has the ".xsl" externsion
|
|
*/
|
|
int
|
|
filesIsSourceFile(xmlChar * fileName)
|
|
{
|
|
return strstr((char *) fileName, ".xsl") ||
|
|
strstr((char *) fileName, ".Xsl") ||
|
|
strstr((char *) fileName, ".XSL");
|
|
}
|
|
|
|
|
|
|
|
entityInfoPtr
|
|
filesNewEntityInfo(const xmlChar * SystemID, const xmlChar * PublicID)
|
|
{
|
|
|
|
entityInfoPtr result = (entityInfoPtr) xmlMalloc(sizeof(entityInfo));
|
|
|
|
if (result) {
|
|
if (SystemID)
|
|
result->SystemID = xmlStrdup(SystemID);
|
|
else
|
|
result->SystemID = xmlStrdup(BAD_CAST "");
|
|
|
|
if (PublicID)
|
|
result->PublicID = xmlStrdup(PublicID);
|
|
else
|
|
result->PublicID = xmlStrdup(BAD_CAST "");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void
|
|
filesFreeEntityInfo(entityInfoPtr info)
|
|
{
|
|
if (!info)
|
|
return;
|
|
|
|
if (info->SystemID)
|
|
xmlFree(info->SystemID);
|
|
|
|
if (info->PublicID)
|
|
xmlFree(info->PublicID);
|
|
xmlFree(info);
|
|
}
|
|
|
|
/**
|
|
* filesAddEntityName:
|
|
* @name : is valid
|
|
*
|
|
* Add name to entity name list of know external entities if
|
|
* it does not already exist in list
|
|
*/
|
|
void
|
|
|
|
filesAddEntityName(const xmlChar * SystemID, const xmlChar * PublicID)
|
|
{
|
|
int entityIndex = 0;
|
|
entityInfoPtr tempItem;
|
|
|
|
if (!SystemID || !filesEntityList())
|
|
return;
|
|
|
|
for (entityIndex = 0;
|
|
entityIndex < arrayListCount(filesEntityList()); entityIndex++) {
|
|
tempItem =
|
|
(entityInfoPtr) arrayListGet(filesEntityList(), entityIndex);
|
|
if (tempItem && xmlStrEqual(SystemID, tempItem->SystemID)) {
|
|
/* name aready exits so don't add it */
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
tempItem = filesNewEntityInfo(SystemID, PublicID);
|
|
arrayListAdd(filesEntityList(), tempItem);
|
|
}
|
|
|
|
|
|
/**
|
|
* filesEntityRef :
|
|
* @ent : Is valid as provided by libxslt
|
|
* @firstNode : Is valid
|
|
* @lastNode : Is Valid
|
|
*
|
|
* Fixes the nodes from firstNode to lastNode so that debugging can occur
|
|
*/
|
|
void
|
|
|
|
filesEntityRef(xmlEntityPtr ent, xmlNodePtr firstNode, xmlNodePtr lastNode)
|
|
{
|
|
xmlNodePtr node = firstNode;
|
|
if (!firstNode || !ent || !ent->SystemID ||
|
|
(ent->etype != XML_EXTERNAL_GENERAL_PARSED_ENTITY) )
|
|
return;
|
|
|
|
if (ent->ExternalID)
|
|
filesAddEntityName(ent->SystemID, ent->ExternalID);
|
|
else
|
|
filesAddEntityName(ent->URI, BAD_CAST "");
|
|
while (node){
|
|
filesSetBaseUri(node, ent->URI);
|
|
if (node != lastNode)
|
|
node = node->next;
|
|
else
|
|
node = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* filesSetBaseUri:
|
|
* @node : Is valid and has a doc parent
|
|
* @uri : Is Valid
|
|
*
|
|
* Set the base uri for this node. Function is used when xml file
|
|
* has external entities in its DTD
|
|
*
|
|
* Returns 1 if successful,
|
|
* 0 otherwise
|
|
*/
|
|
|
|
int
|
|
filesSetBaseUri(xmlNodePtr node, const xmlChar * uri)
|
|
{
|
|
int result = 0;
|
|
|
|
if (!node || !uri)
|
|
return result;
|
|
else {
|
|
if (node->type == XML_ELEMENT_NODE){
|
|
xmlChar *xsldbgUrlCopy = xmlGetProp(node, BAD_CAST "xsldbg:uri");
|
|
if (!xsldbgUrlCopy)
|
|
xmlNewProp(node, BAD_CAST "xsldbg:uri", uri);
|
|
else
|
|
xmlFree(xsldbgUrlCopy);
|
|
}
|
|
result = 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* filesGetBaseUri:
|
|
* @node : Is valid and has a doc parent
|
|
*
|
|
* Get a copy of the base uri for this node. Function is most usefull
|
|
* used when xml file has external entities in its DTD
|
|
*
|
|
* Returns the a copy of the base uri for this node,
|
|
* NULL otherwise
|
|
*/
|
|
xmlChar *
|
|
filesGetBaseUri(xmlNodePtr node)
|
|
{
|
|
xmlChar *result = NULL;
|
|
|
|
if (!node || !node->doc)
|
|
return result;
|
|
|
|
while (node && node->parent) {
|
|
/*
|
|
* result = xmlGetNsProp(node, BAD_CAST "uri", XSLDBG_XML_NAMESPACE);
|
|
*/
|
|
if (node->type == XML_ELEMENT_NODE) {
|
|
result = xmlGetProp(node, BAD_CAST "xsldbg:uri");
|
|
if (result)
|
|
break;
|
|
}
|
|
node = node->parent;
|
|
}
|
|
|
|
if (!result && node->doc && node->doc->URL)
|
|
result = xmlStrdup(node->doc->URL);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* filesEntityList:
|
|
*
|
|
* Return the list entity names used for documents loaded
|
|
*
|
|
* Returns the list entity names used for documents loaded
|
|
*/
|
|
arrayListPtr
|
|
filesEntityList(void)
|
|
{
|
|
return entityNameList;
|
|
}
|
|
|
|
extern int intVolitileOptions[OPTIONS_LAST_INT_OPTIONID - OPTIONS_FIRST_INT_OPTIONID + 1];
|
|
|
|
/**
|
|
* filesLoadCatalogs:
|
|
*
|
|
* Load the catalogs specifed by OPTIONS_CATALOG_NAMES if
|
|
* OPTIONS_CATALOGS is enabled
|
|
* Returns 1 if sucessful
|
|
* 0 otherwise
|
|
*/
|
|
int
|
|
filesLoadCatalogs(void)
|
|
{
|
|
int result = 0;
|
|
const char *catalogs = NULL;
|
|
|
|
xmlCatalogCleanup();
|
|
if (optionsGetIntOption(OPTIONS_CATALOGS)) {
|
|
if (optionsGetStringOption(OPTIONS_CATALOG_NAMES) == NULL) {
|
|
/* use the SGML catalog */
|
|
#ifdef __riscos
|
|
catalogs = getenv("SGML$CatalogFiles");
|
|
#else
|
|
catalogs = getenv("SGML_CATALOG_FILES");
|
|
#endif
|
|
if (catalogs == NULL) {
|
|
#ifdef __riscos
|
|
xsldbgGenericErrorFunc("Warning: Environment variable SGML$CatalogFiles is not set.\n");
|
|
#else
|
|
xsldbgGenericErrorFunc("Warning: Environment variabe SGML_CATALOG_FILES FILES not set.\n");
|
|
#endif
|
|
} else
|
|
/* copy the current catalog name(s) for user to see */
|
|
optionsSetStringOption(OPTIONS_CATALOG_NAMES,
|
|
(xmlChar *) catalogs);
|
|
} else
|
|
/* Use the current catalog settings from users*/
|
|
catalogs = (char *)
|
|
optionsGetStringOption(OPTIONS_CATALOG_NAMES);
|
|
|
|
result = 1;
|
|
}
|
|
|
|
if (catalogs){
|
|
/* Load the new cataog selection */
|
|
xmlLoadCatalogs(catalogs);
|
|
}else{
|
|
/* Use default catalogs */
|
|
xmlInitializeCatalog();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
* filesEncode:
|
|
* @text: Is valid, text to translate from UTF-8,
|
|
*
|
|
* Return A new string of converted @text
|
|
*
|
|
* Returns A new string of converted @text, may be NULL
|
|
*/
|
|
xmlChar *
|
|
filesEncode(const xmlChar * text)
|
|
{
|
|
xmlChar *result = NULL;
|
|
|
|
if (!text)
|
|
return result;
|
|
|
|
if (!stdoutEncoding || !encodeInBuff || !encodeOutBuff)
|
|
return xmlStrdup(text); /* no encoding active return as UTF-8 */
|
|
|
|
xmlBufferEmpty(encodeInBuff);
|
|
xmlBufferEmpty(encodeOutBuff);
|
|
xmlBufferCat(encodeInBuff, text);
|
|
|
|
if (xmlCharEncOutFunc(stdoutEncoding, encodeOutBuff, encodeInBuff)
|
|
>= 0) {
|
|
result = xmlStrdup(xmlBufferContent(encodeOutBuff));
|
|
} else {
|
|
xsldbgGenericErrorFunc(i18n("Encoding of text failed.\n"));
|
|
return xmlStrdup(text); /* panic, return as UTF-8 */
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* filesDeccode:
|
|
* @text: Is valid, text to translate from current encoding to UTF-8,
|
|
*
|
|
* Return A string of converted @text
|
|
*
|
|
* Returns A string of converted @text, may be NULL
|
|
*/
|
|
xmlChar *
|
|
filesDecode(const xmlChar * text)
|
|
{
|
|
xmlChar *result = NULL;
|
|
|
|
if (!text)
|
|
return result;
|
|
|
|
if (!stdoutEncoding || !encodeInBuff || !encodeOutBuff)
|
|
return xmlStrdup(text); /* no encoding active return as UTF-8 */
|
|
|
|
xmlBufferEmpty(encodeInBuff);
|
|
xmlBufferEmpty(encodeOutBuff);
|
|
xmlBufferCat(encodeInBuff, text);
|
|
|
|
if (xmlCharEncInFunc(stdoutEncoding, encodeOutBuff, encodeInBuff)
|
|
>= 0) {
|
|
result = xmlStrdup(xmlBufferContent(encodeOutBuff));
|
|
} else {
|
|
xsldbgGenericErrorFunc(i18n("Encoding of text failed.\n"));
|
|
return xmlStrdup(text); /* panic, return @text unchanged */
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
/*
|
|
* filesSetEncoding:
|
|
* @encoding : Is a valid encoding supported by the iconv library or NULL
|
|
*
|
|
* Opens encoding for all standard output to @encoding. If @encoding
|
|
* is NULL then close current encoding and use UTF-8 as output encoding
|
|
*
|
|
* Returns 1 if successful in setting the encoding of all standard output
|
|
* to @encoding
|
|
* 0 otherwise
|
|
*/
|
|
int
|
|
filesSetEncoding(const char *encoding)
|
|
{
|
|
int result = 0;
|
|
|
|
if (encoding) {
|
|
/* don't switch encoding unless we've found a valid encoding */
|
|
xmlCharEncodingHandlerPtr tempEncoding =
|
|
xmlFindCharEncodingHandler(encoding);
|
|
if (tempEncoding) {
|
|
filesSetEncoding(NULL); /* re-use code to close encoding */
|
|
stdoutEncoding = tempEncoding;
|
|
result =
|
|
(xmlCharEncOutFunc(stdoutEncoding, encodeOutBuff, NULL)
|
|
>= 0);
|
|
if (!result) {
|
|
xmlCharEncCloseFunc(stdoutEncoding);
|
|
stdoutEncoding = NULL;
|
|
xsldbgGenericErrorFunc(i18n("Unable to initialize encoding %1.").tqarg(xsldbgText(encoding)));
|
|
} else
|
|
optionsSetStringOption(OPTIONS_ENCODING,
|
|
(xmlChar *) encoding);
|
|
} else {
|
|
xsldbgGenericErrorFunc(i18n("Invalid encoding %1.\n").tqarg(xsldbgText(encoding)));
|
|
}
|
|
} else {
|
|
/* close encoding and use UTF-8 */
|
|
if (stdoutEncoding)
|
|
result = (xmlCharEncCloseFunc(stdoutEncoding) >= 0);
|
|
else
|
|
result = 1;
|
|
stdoutEncoding = NULL;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* filesMoreFile:
|
|
* @fileName : May be NULL
|
|
* @file : May be NULL
|
|
*
|
|
* Do a "more" like print of file specified by @fileName OR
|
|
* @file. If both are provided @file will be used. The content
|
|
* of file chosen must be in UTF-8, and will be printed in
|
|
* the current encoding selected.The function will pause output
|
|
* after FILES_NO_LINES lines have been printed waiting for
|
|
* user to enter "q" to quit or any other text to continue.
|
|
*
|
|
* Returns 1 if successful,
|
|
* 0 otherwise
|
|
*/
|
|
int
|
|
filesMoreFile(const xmlChar * fileName, FILE * file)
|
|
{
|
|
int result = 0;
|
|
int openedFile = 0;
|
|
int lineCount;
|
|
int reachedEof = 0;
|
|
|
|
if (fileName && !file) {
|
|
#ifdef __riscos
|
|
/* convert into RISC OS format a *nix style file name */
|
|
fileName = (const xmlChar *) riscosfilename((char *) fileName);
|
|
#endif
|
|
file = fopen((char *) fileName, "r");
|
|
openedFile = 1; /* since we opened the file we must close it */
|
|
}
|
|
if (file) {
|
|
while (!feof(file) && !reachedEof) {
|
|
lineCount = 0;
|
|
while (!feof(file) && (lineCount < FILES_NO_LINES) &&
|
|
!reachedEof) {
|
|
if (fgets((char *) filesBuffer, sizeof(filesBuffer), file)) {
|
|
xsltGenericError(xsltGenericErrorContext, "%s",
|
|
filesBuffer);
|
|
lineCount++;
|
|
} else {
|
|
reachedEof = 1;
|
|
}
|
|
}
|
|
|
|
if (!feof(file) && !reachedEof) {
|
|
xsldbgGenericErrorFunc(i18n(" ----- more ---- \n"));
|
|
fflush(stderr);
|
|
if (fgets((char *) filesBuffer, sizeof(filesBuffer), stdin)) {
|
|
if ((*filesBuffer == 'q') || (*filesBuffer == 'Q'))
|
|
reachedEof = 1;
|
|
} else {
|
|
reachedEof = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (openedFile) {
|
|
fclose(file);
|
|
}
|
|
xsltGenericError(xsltGenericErrorContext, "\n");
|
|
result = 1;
|
|
} else {
|
|
#ifdef WITH_XSLDBG_DEBUG_PROCESS
|
|
xsltGenericError(xsltGenericErrorContext,
|
|
"Error: No valid file provided to print\n");
|
|
#endif
|
|
}
|
|
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* filesSearchResultsPath:
|
|
*
|
|
* Get the base path to be used for storing search results
|
|
*
|
|
* Returns The base path to be used for storing search results
|
|
*/
|
|
const xmlChar *
|
|
filesSearchResultsPath()
|
|
{
|
|
const xmlChar *result;
|
|
|
|
if (optionsGetStringOption(OPTIONS_SEARCH_RESULTS_PATH))
|
|
result = optionsGetStringOption(OPTIONS_SEARCH_RESULTS_PATH);
|
|
else
|
|
result = stylePath();
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* filesURItoFileName:
|
|
* @uri : A valid URI that uses the "file://" prefix
|
|
*
|
|
* Return A copy of the conversion of @uri to a file name
|
|
* that is suitable to be used with the fopen function.
|
|
* May be NULL, if out of memory, @uri does not use the
|
|
* "file://" prefix, or unable to convert to a valid file name
|
|
*
|
|
* Returns A copy of the conversion of @uri to a file name
|
|
* that is suitable to be used with the fopen function.
|
|
* May be NULL, if out of memory, @uri does not use the
|
|
* "file://" prefix, or unable to convert to a valid file name
|
|
*
|
|
*/
|
|
xmlChar *filesURItoFileName(const xmlChar* uri)
|
|
{
|
|
xmlChar *result = NULL;
|
|
xmlChar *unescapedFileName = NULL;
|
|
const xmlChar* tempName = NULL;
|
|
|
|
if (uri){
|
|
if (!xmlStrnCmp(uri, "file://localhost", 16 )){
|
|
tempName = uri + 16;
|
|
}else{
|
|
#if defined(WIN32) && ! defined(CYGWIN)
|
|
if (!xmlStrnCmp(uri, "file:///", 8))
|
|
tempName = uri + 8;
|
|
#else
|
|
if (!xmlStrnCmp(uri, "file:/", 6))
|
|
tempName = uri + 5; // we need the leading '/'*/
|
|
while (tempName[0] == '/' && tempName[1] == '/' )
|
|
tempName++;
|
|
#endif
|
|
}
|
|
|
|
/* If we've found something check to see if the file name
|
|
found is to be valid */
|
|
if (tempName)
|
|
result = (xmlChar*) xmlStrdup(tempName);
|
|
unescapedFileName = (xmlChar*) xmlStrdup(tempName);
|
|
if (result && unescapedFileName){
|
|
if (PATHCHAR != URISEPARATORCHAR){
|
|
/* Must convert path separators first */
|
|
xmlChar *probe = result;
|
|
while(*probe != '\0'){
|
|
if (*probe == (xmlChar)URISEPARATORCHAR)
|
|
*probe = (xmlChar)PATHCHAR;
|
|
probe++;
|
|
}
|
|
}
|
|
/* Now unescape the file name in result so far
|
|
* NB: An unescaped name takes less memory that an escaped name
|
|
*/
|
|
xmlURIUnescapeString((char*)result, -1, (char*)unescapedFileName);
|
|
xmlFree(result);
|
|
/* success we've got an local unescaped file name */
|
|
result = unescapedFileName;
|
|
}else{
|
|
xsldbgGenericErrorFunc(i18n("Error: Out of memory.\n"));
|
|
if (result){
|
|
xmlFree(result);
|
|
}
|
|
if (unescapedFileName) /* not needed, here for completeness */
|
|
xmlFree(unescapedFileName);
|
|
|
|
result = NULL;
|
|
}
|
|
}else{
|
|
xsldbgGenericErrorFunc(i18n("Error: Unable to convert %1 to local file name.\n").tqarg(xsldbgText(uri)));
|
|
}
|
|
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/* TODO in xsldbg 3.x rename these to use files prefix */
|
|
|
|
/**
|
|
* xsldbgUpdateFileDetails:
|
|
* @node : A valid node
|
|
*
|
|
* Update the URL and line number that we stoped at
|
|
*/
|
|
void
|
|
xsldbgUpdateFileDetails(xmlNodePtr node)
|
|
{
|
|
if ((node != NULL) && (node->doc != NULL)){
|
|
if (currentUrl != NULL)
|
|
xmlFree(currentUrl);
|
|
currentUrl = filesGetBaseUri(node);
|
|
currentLineNo = xmlGetLineNo(node);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* xsldbgLineNo:
|
|
*
|
|
* What line number are we at
|
|
*
|
|
* Returns The current line number of xsldbg, may be -1
|
|
**/
|
|
int
|
|
xsldbgLineNo(void)
|
|
{
|
|
return currentLineNo;
|
|
}
|
|
|
|
|
|
/**
|
|
* xsldbgUrl:
|
|
*
|
|
* What URL did we stop at
|
|
*
|
|
* Returns A NEW copy of URL stopped at. Caller must free memory for URL.
|
|
* May be NULL
|
|
*/
|
|
xmlChar *
|
|
xsldbgUrl(void)
|
|
{
|
|
if (currentUrl != NULL)
|
|
return (xmlChar *) xmlMemStrdup((char *) currentUrl);
|
|
else
|
|
return NULL;
|
|
}
|