int
XML_ProcessFile(XML_Parser parser,
const XML_Char *filename,
unsigned flags)
{
int result;
if (!XML_SetBase(parser, filename)) {
ftprintf(stderr, T("%s: out of memory"), filename);
exit(1);
}
if (flags & XML_EXTERNAL_ENTITIES)
XML_SetExternalEntityRefHandler(parser,
(flags & XML_MAP_FILE)
? externalEntityRefFilemap
: externalEntityRefStream);
if (flags & XML_MAP_FILE) {
PROCESS_ARGS args;
args.retPtr = &result;
args.parser = parser;
if (!filemap(filename, processFile, &args))
result = 0;
}
else
result = processStream(filename, parser);
return result;
}
XML_Status bmx_expat_XML_SetBase(XML_Parser parser, BBString * base) {
char * c = bbStringToUTF8String(base);
XML_Status res = XML_SetBase(parser, c);
bbMemFree(c);
return res;
}
/**
* Parses the given input stream and returns a DOM Document.
* A NULL pointer will be returned if errors occurred
*/
nsresult
txDriver::parse(istream& aInputStream, const nsAString& aUri)
{
mErrorString.Truncate();
if (!aInputStream) {
mErrorString.AppendLiteral("unable to parse xml: invalid or unopen stream encountered.");
return NS_ERROR_FAILURE;
}
static const XML_Memory_Handling_Suite memsuite = {
(void *(*)(size_t))PR_Malloc,
(void *(*)(void *, size_t))PR_Realloc,
PR_Free
};
static const PRUnichar expatSeparator = kExpatSeparatorChar;
mExpatParser = XML_ParserCreate_MM(nsnull, &memsuite, &expatSeparator);
if (!mExpatParser) {
return NS_ERROR_OUT_OF_MEMORY;
}
XML_SetReturnNSTriplet(mExpatParser, XML_TRUE);
XML_SetUserData(mExpatParser, this);
XML_SetElementHandler(mExpatParser, startElement, endElement);
XML_SetCharacterDataHandler(mExpatParser, charData);
#ifdef XML_DTD
XML_SetParamEntityParsing(mExpatParser, XML_PARAM_ENTITY_PARSING_ALWAYS);
#endif
XML_SetExternalEntityRefHandler(mExpatParser, externalEntityRefHandler);
XML_SetExternalEntityRefHandlerArg(mExpatParser, this);
XML_SetBase(mExpatParser,
(const XML_Char*)(PromiseFlatString(aUri).get()));
const int bufferSize = 1024;
char buf[bufferSize];
PRBool done;
int success;
mRV = NS_OK;
do {
aInputStream.read(buf, bufferSize);
done = aInputStream.eof();
success = XML_Parse(mExpatParser, buf, aInputStream.gcount(), done);
// mRV is set in onDoneCompiling in case of an error
if (!success || NS_FAILED(mRV)) {
createErrorString();
done = MB_TRUE;
}
} while (!done);
aInputStream.clear();
// clean up
XML_ParserFree(mExpatParser);
mCompiler->doneLoading();
if (!success) {
return NS_ERROR_FAILURE;
}
return mRV;
}
gboolean
pdb_xml_parse (PdbXmlParser *parser,
const char *filename,
GError **error)
{
PdbRevoFile *file;
gboolean ret = TRUE;
const char *last_slash;
if ((last_slash = strrchr (filename, '/')))
{
char *base = g_strndup (filename, last_slash - filename);
XML_SetBase (pdb_xml_get_parser (parser), base);
g_free (base);
}
g_array_index (parser->stack,
PdbXmlStackEntry,
parser->stack->len - 1).filename = filename;
file = pdb_revo_open (parser->revo,
filename,
error);
if (file == NULL)
ret = FALSE;
else
{
char buf[512];
size_t got;
do
{
got = sizeof (buf);
if (!pdb_revo_read (file, buf, &got, error) ||
!pdb_xml_handle_data (parser,
buf,
got,
got < sizeof (buf),
error))
{
ret = FALSE;
break;
}
}
while (got >= sizeof (buf));
pdb_revo_close (file);
}
g_array_index (parser->stack,
PdbXmlStackEntry,
parser->stack->len - 1).filename = NULL;
return ret;
}
XmlTextInfo::XmlTextInfo
( const wxString &path
, const char *encoding /*= NULL*/
)
: WrapExpat ( encoding )
{
XML_SetUserData ( p, this );
XML_SetBase ( p, path.utf8_str() );
XML_SetDoctypeDeclHandler ( p, startdoctypehandler, NULL );
XML_SetProcessingInstructionHandler ( p, processinghandler );
XML_SetElementHandler ( p, start, NULL );
XML_SetDefaultHandlerExpand ( p, defaulthandler );
}
void
RS_XML(initParser)(XML_Parser parser, RS_XMLParserData *parserData)
{
XML_SetUserData(parser, parserData);
XML_SetElementHandler(parser, RS_XML(startElement), RS_XML(endElement));
XML_SetCommentHandler(parser, RS_XML(commentHandler));
XML_SetExternalEntityRefHandler(parser, RS_XML(externalEntityHandler));
XML_SetUnparsedEntityDeclHandler(parser, RS_XML(entityDeclarationHandler));
XML_SetCharacterDataHandler(parser, RS_XML(textHandler));
XML_SetProcessingInstructionHandler(parser, RS_XML(processingInstructionHandler));
XML_SetCdataSectionHandler(parser, RS_XML(startCdataSectionHandler), RS_XML(endCdataSectionHandler));
XML_SetBase(parser, parserData->fileName);
XML_SetNotStandaloneHandler(parser, RS_XML(notStandAloneHandler));
}
int
nsExpatDriver::HandleExternalEntityRef(const PRUnichar *openEntityNames,
const PRUnichar *base,
const PRUnichar *systemId,
const PRUnichar *publicId)
{
if (mInInternalSubset && !mInExternalDTD && openEntityNames) {
mInternalSubset.Append(PRUnichar('%'));
mInternalSubset.Append(nsDependentString(openEntityNames));
mInternalSubset.Append(PRUnichar(';'));
}
// Load the external entity into a buffer.
nsCOMPtr<nsIInputStream> in;
nsAutoString absURL;
nsresult rv = OpenInputStreamFromExternalDTD(publicId, systemId, base,
getter_AddRefs(in), absURL);
NS_ENSURE_SUCCESS(rv, 1);
nsCOMPtr<nsIUnicharInputStream> uniIn;
rv = nsSimpleUnicharStreamFactory::GetInstance()->
CreateInstanceFromUTF8Stream(in, getter_AddRefs(uniIn));
NS_ENSURE_SUCCESS(rv, 1);
int result = 1;
if (uniIn) {
XML_Parser entParser = XML_ExternalEntityParserCreate(mExpatParser, 0,
kUTF16);
if (entParser) {
XML_SetBase(entParser, absURL.get());
mInExternalDTD = PR_TRUE;
PRUint32 totalRead;
do {
rv = uniIn->ReadSegments(ExternalDTDStreamReaderFunc, entParser,
PRUint32(-1), &totalRead);
} while (NS_SUCCEEDED(rv) && totalRead > 0);
result = XML_Parse(entParser, nsnull, 0, 1);
mInExternalDTD = PR_FALSE;
XML_ParserFree(entParser);
}
}
return result;
}
int
txXMLParser::ExternalEntityRef(const XML_Char *aContext,
const XML_Char *aBase,
const XML_Char *aSystemId,
const XML_Char *aPublicId)
{
if (aPublicId) {
// not supported, this is "http://some.site.net/foo.dtd" stuff
return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
}
nsAutoString absUrl;
URIUtils::resolveHref(nsDependentString((PRUnichar*)aSystemId),
nsDependentString((PRUnichar*)aBase), absUrl);
istream* extInput = URIUtils::getInputStream(absUrl, mErrorString);
if (!extInput) {
return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
}
XML_Parser parent = mExpatParser;
mExpatParser =
XML_ExternalEntityParserCreate(mExpatParser, aContext, nsnull);
if (!mExpatParser) {
mExpatParser = parent;
delete extInput;
return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
}
XML_SetBase(mExpatParser, absUrl.get());
const int bufSize = 1024;
char buffer[bufSize];
int result;
PRBool done;
do {
extInput->read(buffer, bufSize);
done = extInput->eof();
if (!(result =
XML_Parse(mExpatParser, buffer, extInput->gcount(), done))) {
createErrorString();
mErrorString.Append(PRUnichar('\n'));
done = MB_TRUE;
}
} while (!done);
delete extInput;
XML_ParserFree(mExpatParser);
mExpatParser = parent;
return result;
}
static int
externalEntityRefStream(XML_Parser parser,
const XML_Char *context,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId)
{
XML_Char *s;
const XML_Char *filename;
int ret;
XML_Parser entParser = XML_ExternalEntityParserCreate(parser, context, 0);
filename = resolveSystemId(base, systemId, &s);
XML_SetBase(entParser, filename);
ret = processStream(filename, entParser);
free(s);
XML_ParserFree(entParser);
return ret;
}
static int
externalEntityRefFilemap(XML_Parser parser,
const XML_Char *context,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId)
{
int result;
XML_Char *s;
const XML_Char *filename;
XML_Parser entParser = XML_ExternalEntityParserCreate(parser, context, 0);
PROCESS_ARGS args;
args.retPtr = &result;
args.parser = entParser;
filename = resolveSystemId(base, systemId, &s);
XML_SetBase(entParser, filename);
if (!filemap(filename, processFile, &args))
result = 0;
free(s);
XML_ParserFree(entParser);
return result;
}
NS_IMETHODIMP
nsExpatDriver::WillBuildModel(const CParserContext& aParserContext,
nsITokenizer* aTokenizer,
nsIContentSink* aSink)
{
mSink = do_QueryInterface(aSink);
if (!mSink) {
NS_ERROR("nsExpatDriver didn't get an nsIExpatSink");
// Make sure future calls to us bail out as needed
mInternalState = NS_ERROR_UNEXPECTED;
return mInternalState;
}
mOriginalSink = aSink;
static const XML_Memory_Handling_Suite memsuite =
{
(void *(*)(size_t))PR_Malloc,
(void *(*)(void *, size_t))PR_Realloc,
PR_Free
};
static const PRUnichar kExpatSeparator[] = { kExpatSeparatorChar, '\0' };
mExpatParser = XML_ParserCreate_MM(kUTF16, &memsuite, kExpatSeparator);
NS_ENSURE_TRUE(mExpatParser, NS_ERROR_FAILURE);
XML_SetReturnNSTriplet(mExpatParser, XML_TRUE);
#ifdef XML_DTD
XML_SetParamEntityParsing(mExpatParser, XML_PARAM_ENTITY_PARSING_ALWAYS);
#endif
mURISpec = aParserContext.mScanner->GetFilename();
XML_SetBase(mExpatParser, mURISpec.get());
nsCOMPtr<nsIDocument> doc = do_QueryInterface(mOriginalSink->GetTarget());
if (doc) {
nsCOMPtr<nsPIDOMWindow> win = doc->GetWindow();
if (!win) {
PRBool aHasHadScriptHandlingObject;
nsIScriptGlobalObject *global =
doc->GetScriptHandlingObject(aHasHadScriptHandlingObject);
if (global) {
win = do_QueryInterface(global);
}
}
if (win && !win->IsInnerWindow()) {
win = win->GetCurrentInnerWindow();
}
if (win) {
mInnerWindowID = win->WindowID();
}
}
// Set up the callbacks
XML_SetXmlDeclHandler(mExpatParser, Driver_HandleXMLDeclaration);
XML_SetElementHandler(mExpatParser, Driver_HandleStartElement,
Driver_HandleEndElement);
XML_SetCharacterDataHandler(mExpatParser, Driver_HandleCharacterData);
XML_SetProcessingInstructionHandler(mExpatParser,
Driver_HandleProcessingInstruction);
XML_SetDefaultHandlerExpand(mExpatParser, Driver_HandleDefault);
XML_SetExternalEntityRefHandler(mExpatParser,
(XML_ExternalEntityRefHandler)
Driver_HandleExternalEntityRef);
XML_SetExternalEntityRefHandlerArg(mExpatParser, this);
XML_SetCommentHandler(mExpatParser, Driver_HandleComment);
XML_SetCdataSectionHandler(mExpatParser, Driver_HandleStartCdataSection,
Driver_HandleEndCdataSection);
XML_SetParamEntityParsing(mExpatParser,
XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE);
XML_SetDoctypeDeclHandler(mExpatParser, Driver_HandleStartDoctypeDecl,
Driver_HandleEndDoctypeDecl);
// If the sink is an nsIExtendedExpatSink,
// register some addtional handlers.
mExtendedSink = do_QueryInterface(mSink);
if (mExtendedSink) {
XML_SetNamespaceDeclHandler(mExpatParser,
Driver_HandleStartNamespaceDecl,
Driver_HandleEndNamespaceDecl);
XML_SetUnparsedEntityDeclHandler(mExpatParser,
Driver_HandleUnparsedEntityDecl);
XML_SetNotationDeclHandler(mExpatParser,
Driver_HandleNotationDecl);
}
// Set up the user data.
XML_SetUserData(mExpatParser, this);
// XML must detect invalid character convertion
aParserContext.mScanner->OverrideReplacementCharacter(0xffff);
return mInternalState;
}
int
nsExpatDriver::HandleExternalEntityRef(const char16_t *openEntityNames,
const char16_t *base,
const char16_t *systemId,
const char16_t *publicId)
{
if (mInInternalSubset && !mInExternalDTD && openEntityNames) {
mInternalSubset.Append(char16_t('%'));
mInternalSubset.Append(nsDependentString(openEntityNames));
mInternalSubset.Append(char16_t(';'));
}
// Load the external entity into a buffer.
nsCOMPtr<nsIInputStream> in;
nsAutoString absURL;
nsresult rv = OpenInputStreamFromExternalDTD(publicId, systemId, base,
getter_AddRefs(in), absURL);
if (NS_FAILED(rv)) {
#ifdef DEBUG
nsCString message("Failed to open external DTD: publicId \"");
AppendUTF16toUTF8(publicId, message);
message += "\" systemId \"";
AppendUTF16toUTF8(systemId, message);
message += "\" base \"";
AppendUTF16toUTF8(base, message);
message += "\" URL \"";
AppendUTF16toUTF8(absURL, message);
message += "\"";
NS_WARNING(message.get());
#endif
return 1;
}
nsCOMPtr<nsIUnicharInputStream> uniIn;
rv = nsSimpleUnicharStreamFactory::GetInstance()->
CreateInstanceFromUTF8Stream(in, getter_AddRefs(uniIn));
NS_ENSURE_SUCCESS(rv, 1);
int result = 1;
if (uniIn) {
XML_Parser entParser = XML_ExternalEntityParserCreate(mExpatParser, 0,
kUTF16);
if (entParser) {
XML_SetBase(entParser, absURL.get());
mInExternalDTD = true;
uint32_t totalRead;
do {
rv = uniIn->ReadSegments(ExternalDTDStreamReaderFunc, entParser,
uint32_t(-1), &totalRead);
} while (NS_SUCCEEDED(rv) && totalRead > 0);
result = XML_Parse(entParser, nullptr, 0, 1);
mInExternalDTD = false;
XML_ParserFree(entParser);
}
}
return result;
}
void MeaXMLParser::SetBasePath(const CString& path)
{
XML_SetBase(m_parser, ToUTF8(path));
}
enum XML_Status _Expat_XML_SetBase(struct ExpatIFace * Self, XML_Parser parser, const XML_Char *p)
{
return XML_SetBase(parser, p);
}
/**
* Parses the given input stream and returns a DOM Document.
* A NULL pointer will be returned if errors occurred
*/
nsresult
txXMLParser::parse(istream& aInputStream, const nsAString& aUri,
txXPathNode** aResultDoc)
{
mErrorString.Truncate();
*aResultDoc = nsnull;
if (!aInputStream) {
mErrorString.AppendLiteral("unable to parse xml: invalid or unopen stream encountered.");
return NS_ERROR_FAILURE;
}
static const XML_Memory_Handling_Suite memsuite = {
(void *(*)(size_t))PR_Malloc,
(void *(*)(void *, size_t))PR_Realloc,
PR_Free
};
static const PRUnichar expatSeparator = kExpatSeparatorChar;
mExpatParser = XML_ParserCreate_MM(nsnull, &memsuite, &expatSeparator);
if (!mExpatParser) {
return NS_ERROR_OUT_OF_MEMORY;
}
mDocument = new Document();
if (!mDocument) {
XML_ParserFree(mExpatParser);
return NS_ERROR_OUT_OF_MEMORY;
}
mDocument->documentBaseURI = aUri;
mCurrentNode = mDocument;
XML_SetReturnNSTriplet(mExpatParser, XML_TRUE);
XML_SetUserData(mExpatParser, this);
XML_SetElementHandler(mExpatParser, startElement, endElement);
XML_SetCharacterDataHandler(mExpatParser, charData);
XML_SetProcessingInstructionHandler(mExpatParser, piHandler);
XML_SetCommentHandler(mExpatParser, commentHandler);
#ifdef XML_DTD
XML_SetParamEntityParsing(mExpatParser, XML_PARAM_ENTITY_PARSING_ALWAYS);
#endif
XML_SetExternalEntityRefHandler(mExpatParser, externalEntityRefHandler);
XML_SetExternalEntityRefHandlerArg(mExpatParser, this);
XML_SetBase(mExpatParser,
(const XML_Char*)(PromiseFlatString(aUri).get()));
const int bufferSize = 1024;
char buf[bufferSize];
PRBool done;
do {
aInputStream.read(buf, bufferSize);
done = aInputStream.eof();
if (!XML_Parse(mExpatParser, buf, aInputStream.gcount(), done)) {
createErrorString();
done = MB_TRUE;
delete mDocument;
mDocument = nsnull;
}
} while (!done);
aInputStream.clear();
// clean up
XML_ParserFree(mExpatParser);
// ownership to the caller
*aResultDoc = txXPathNativeNode::createXPathNode(mDocument);
mDocument = nsnull;
return *aResultDoc ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
static int setbase (lua_State *L) {
lxp_userdata *xpu = checkparser(L, 1);
if (XML_SetBase(xpu->parser, luaL_checkstring(L, 2)) == 0)
luaL_error(L, "no memory to store base");
return 0;
}
int CSAX2ParserBase::HandleExternalEntityRef(const XML_Char* context, const XML_Char* base,
const XML_Char* systemId, const XML_Char* publicId)
{
csl_assert (systemId != NULL);
if (context == NULL && !m_includeExtParEntities) return 0;
if (context != NULL && !m_includeExtGenEntities) return 0;
CInputSource* pInputSource = NULL;
XMLString resolvedSystemId;
if (base)
resolvedSystemId = ResolveSystemId(base, systemId);
else
resolvedSystemId = systemId;
CEntityResolver* pEntityResolver = NULL;
CEntityResolverImp defaultResolver;
XMLString pId;
if (publicId) pId = XMLString(publicId);
if (m_pEntityResolver)
{
pInputSource = m_pEntityResolver->ResolveEntity(publicId ? &pId : NULL, resolvedSystemId);
pEntityResolver = m_pEntityResolver;
}
if (!pInputSource && m_includeExtGenEntities)
{
pInputSource = defaultResolver.ResolveEntity(publicId ? &pId : NULL, resolvedSystemId);
pEntityResolver = &defaultResolver;
}
if (pInputSource)
{
XML_Parser extParser = XML_ExternalEntityParserCreate(GetExpatParser(), context, 0);
XML_SetBase(extParser, resolvedSystemId.c_str());
try
{
if (pInputSource->GetCharacterStream())
{
ParseCharExternal(extParser, pInputSource->GetCharacterStream());
}
else if (pInputSource->GetByteStream())
{
ParseExternal(extParser, pInputSource->GetByteStream());
}
else
{
throw CSAXParseException("no input stream", EMPTY_STRING, pInputSource->GetSystemId(), 0, 0, CXMLException(CXMLException::EXMLBadInputSource, string()));
}
}
catch (CXMLException& e)
{
// cleanup before we propagate the exception
pEntityResolver->DoneWithInputSource(pInputSource);
XML_ParserFree(extParser);
throw e;
}
pEntityResolver->DoneWithInputSource(pInputSource);
XML_ParserFree(extParser);
return 1;
}
else
{
return 0;
}
}
