static ERL_NIF_TERM new_parser(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
XML_Parser parser;
expat_parser *parser_data = (expat_parser *)enif_alloc(sizeof(expat_parser));
ERL_NIF_TERM parser_resource;
// this is the variant from esl/exml:208d5e17e547b303b310627e3e525b57b2843e83
/*parser = XML_ParserCreate_MM("UTF-8", &ms, "\n");*/
// this makes the tests pass, but according to expat documentation it turns namespace support off
/*parser = XML_ParserCreate_MM("UTF-8", &ms, NULL);*/
// this is a try to preserve namespace support but make the tests pass;
// this is the character defined as a macro in xmlwf sources for namespace-enabled parser
/*XML_Char namespaceSeparator = '\001';*/
/*parser = XML_ParserCreate_MM("UTF-8", &ms, &namespaceSeparator);*/
parser = XML_ParserCreate_MM("UTF-8", &ms, ":");
parser_data->env = env;
parser_data->xmlns = (ERL_NIF_TERM)NULL;
init_parser(parser, parser_data);
XML_Parser *xml_parser = (XML_Parser *)enif_alloc_resource(PARSER_POINTER, sizeof(XML_Parser));
*xml_parser = parser;
parser_resource = enif_make_resource(env, (void *)xml_parser);
enif_release_resource(xml_parser);
return enif_make_tuple(env, 2, OK, parser_resource);
};
XML_Parser OGRCreateExpatXMLParser()
{
XML_Memory_Handling_Suite memsuite;
memsuite.malloc_fcn = OGRExpatMalloc;
memsuite.realloc_fcn = OGRExpatRealloc;
memsuite.free_fcn = free;
return XML_ParserCreate_MM(NULL, &memsuite, NULL);
}
PHPAPI XML_Parser
XML_ParserCreateNS(const XML_Char *encoding, const XML_Char sep)
{
XML_Char tmp[2];
tmp[0] = sep;
tmp[1] = '\0';
return XML_ParserCreate_MM(encoding, NULL, tmp);
}
/**
* 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;
}
static int
create_parser(struct exmpp_xml_data *edd)
{
/* Create a parser. */
edd->parser = XML_ParserCreate_MM("UTF-8", &memory_suite,
&namespace_separator);
if (edd->parser == NULL)
return (-1);
init_parser(edd);
return (0);
}
XML_Parser OGRCreateExpatXMLParser()
{
XML_Memory_Handling_Suite memsuite;
memsuite.malloc_fcn = OGRExpatMalloc;
memsuite.realloc_fcn = OGRExpatRealloc;
memsuite.free_fcn = free;
XML_Parser hParser = XML_ParserCreate_MM(NULL, &memsuite, NULL);
XML_SetUnknownEncodingHandler(hParser,
OGRExpatUnknownEncodingHandler,
NULL);
return hParser;
}
static Variant php_xml_parser_create_impl(CStrRef encoding_param,
CStrRef ns_param, int ns_support) {
XmlParser *parser;
int auto_detect = 0;
XML_Char *encoding;
if (!encoding_param.isNull()) {
/* The supported encoding types are hardcoded here because
* we are limited to the encodings supported by expat/xmltok.
*/
if (encoding_param.size() == 0) {
encoding = XML(default_encoding);
auto_detect = 1;
} else if (strcasecmp(encoding_param.data(), "ISO-8859-1") == 0) {
encoding = (XML_Char*)"ISO-8859-1";
} else if (strcasecmp(encoding_param.data(), "UTF-8") == 0) {
encoding = (XML_Char*)"UTF-8";
} else if (strcasecmp(encoding_param.data(), "US-ASCII") == 0) {
encoding = (XML_Char*)"US-ASCII";
} else {
raise_warning("unsupported source encoding \"%s\"",
encoding_param.c_str());
return false;
}
} else {
encoding = XML(default_encoding);
}
String separator;
if (ns_support && ns_param.empty()){
separator = ":";
} else {
separator = ns_param;
}
parser = NEWOBJ(XmlParser)();
parser->parser = XML_ParserCreate_MM
((auto_detect ? NULL : encoding), &php_xml_mem_hdlrs,
!separator.empty() ? (const XML_Char*)separator.data() : NULL);
parser->target_encoding = encoding;
parser->case_folding = 1;
setNull(parser->object);
parser->isparsing = 0;
XML_SetUserData(parser->parser, parser);
return Object(parser);
}
static Variant php_xml_parser_create_impl(const String& encoding_param,
const String& ns_param,
int ns_support) {
int auto_detect = 0;
XML_Char *encoding;
if (!encoding_param.isNull()) {
/* The supported encoding types are hardcoded here because
* we are limited to the encodings supported by expat/xmltok.
*/
if (encoding_param.size() == 0) {
encoding = XML(default_encoding);
auto_detect = 1;
} else if (strcasecmp(encoding_param.data(), "ISO-8859-1") == 0) {
encoding = (XML_Char*)"ISO-8859-1";
} else if (strcasecmp(encoding_param.data(), "UTF-8") == 0) {
encoding = (XML_Char*)"UTF-8";
} else if (strcasecmp(encoding_param.data(), "US-ASCII") == 0) {
encoding = (XML_Char*)"US-ASCII";
} else {
raise_warning("unsupported source encoding \"%s\"",
encoding_param.c_str());
return false;
}
} else {
encoding = XML(default_encoding);
}
String separator;
if (ns_support && ns_param.empty()) {
separator = ":";
} else {
separator = ns_param;
}
auto parser = req::make<XmlParser>();
parser->parser = XML_ParserCreate_MM
((auto_detect ? NULL : encoding), &php_xml_mem_hdlrs,
!separator.empty() ? (const XML_Char*)separator.data() : NULL);
parser->target_encoding = encoding;
parser->case_folding = 1;
parser->object.asTypedValue()->m_type = KindOfNull;
parser->isparsing = 0;
XML_SetUserData(parser->parser, getParserToken(parser));
return Variant(std::move(parser));
}
static ERL_NIF_TERM new_parser(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
XML_Parser parser;
expat_parser *parser_data = (expat_parser *)enif_alloc(sizeof(expat_parser));
ERL_NIF_TERM parser_resource;
parser = XML_ParserCreate_MM("UTF-8", &ms, "\n");
parser_data->env = env;
parser_data->xmlns = enif_make_list(env, 0);
init_parser(parser, parser_data);
XML_Parser *xml_parser = (XML_Parser *)enif_alloc_resource(PARSER_POINTER, sizeof(XML_Parser));
*xml_parser = parser;
parser_resource = enif_make_resource(env, (void *)xml_parser);
enif_release_resource(xml_parser);
return enif_make_tuple(env, 2, OK, parser_resource);
};
static bool expat_setup_parser(xml_parse_info &info, xml_parse_options const *opts)
{
XML_Memory_Handling_Suite memcallbacks;
/* setup info structure */
memset(&info, 0, sizeof(info));
if (opts != nullptr)
{
info.flags = opts->flags;
if (opts->error != nullptr)
{
opts->error->error_message = nullptr;
opts->error->error_line = 0;
opts->error->error_column = 0;
}
}
/* create a root node */
info.rootnode = xml_data_node::file_create();
if (info.rootnode == nullptr)
return false;
info.curnode = info.rootnode;
/* create the XML parser */
memcallbacks.malloc_fcn = expat_malloc;
memcallbacks.realloc_fcn = expat_realloc;
memcallbacks.free_fcn = expat_free;
info.parser = XML_ParserCreate_MM(nullptr, &memcallbacks, nullptr);
if (info.parser == nullptr)
{
info.rootnode->file_free();
return false;
}
/* configure the parser */
XML_SetElementHandler(info.parser, expat_element_start, expat_element_end);
XML_SetCharacterDataHandler(info.parser, expat_data);
XML_SetUserData(info.parser, &info);
/* optional parser initialization step */
if (opts != nullptr && opts->init_parser != nullptr)
(*opts->init_parser)(info.parser);
return true;
}
static int expat_setup_parser(xml_parse_info *parse_info, xml_parse_options *opts)
{
XML_Memory_Handling_Suite memcallbacks;
/* setup parse_info structure */
memset(parse_info, 0, sizeof(*parse_info));
if (opts != nullptr)
{
parse_info->flags = opts->flags;
if (opts->error != nullptr)
{
opts->error->error_message = nullptr;
opts->error->error_line = 0;
opts->error->error_column = 0;
}
}
/* create a root node */
parse_info->rootnode = xml_file_create();
if (parse_info->rootnode == nullptr)
return FALSE;
parse_info->curnode = parse_info->rootnode;
/* create the XML parser */
memcallbacks.malloc_fcn = expat_malloc;
memcallbacks.realloc_fcn = expat_realloc;
memcallbacks.free_fcn = expat_free;
parse_info->parser = XML_ParserCreate_MM(nullptr, &memcallbacks, nullptr);
if (parse_info->parser == nullptr)
{
free(parse_info->rootnode);
return FALSE;
}
/* configure the parser */
XML_SetElementHandler(parse_info->parser, expat_element_start, expat_element_end);
XML_SetCharacterDataHandler(parse_info->parser, expat_data);
XML_SetUserData(parse_info->parser, parse_info);
/* optional parser initialization step */
if (opts != nullptr && opts->init_parser != nullptr)
(*opts->init_parser)(parse_info->parser);
return TRUE;
}
static ErlDrvData expat_erl_start(ErlDrvPort port, char *buff)
{
expat_data* d = (expat_data*)driver_alloc(sizeof(expat_data));
d->port = port;
d->parser = XML_ParserCreate_MM("UTF-8", &ms, NULL);
XML_SetUserData(d->parser, d);
set_port_control_flags(port, PORT_CONTROL_FLAG_BINARY);
XML_SetStartElementHandler(
d->parser, (XML_StartElementHandler)erlXML_StartElementHandler);
XML_SetEndElementHandler(
d->parser, (XML_EndElementHandler)erlXML_EndElementHandler);
XML_SetCharacterDataHandler(
d->parser, (XML_CharacterDataHandler)erlXML_CharacterDataHandler);
return (ErlDrvData)d;
}
bool XMLParser::Create(const XML_Char* encoding, const XML_Char* sep)
{
Destroy();
if (encoding != NULL && *encoding == '\0')
encoding = NULL;
if (sep != NULL && *sep == '\0')
sep = NULL;
m_parser = XML_ParserCreate_MM(encoding, NULL, sep);
if (m_parser == NULL)
return false;
m_pHandler->OnPostCreate();
XML_SetUserData(m_parser, (void*) m_pHandler);
return true;
}
softlist_parser::softlist_parser(util::core_file &file, const std::string &filename, std::string &description, std::list<software_info> &infolist, std::ostringstream &errors)
: m_file(file),
m_filename(filename),
m_infolist(infolist),
m_errors(errors),
m_done(false),
m_description(description),
m_data_accum_expected(false),
m_current_info(nullptr),
m_current_part(nullptr),
m_pos(POS_ROOT)
{
// create the parser
m_parser = XML_ParserCreate_MM(nullptr, nullptr, nullptr);
if (m_parser == nullptr)
throw std::bad_alloc();
// set the handlers
XML_SetUserData(m_parser, this);
XML_SetElementHandler(m_parser, &softlist_parser::start_handler, &softlist_parser::end_handler);
XML_SetCharacterDataHandler(m_parser, &softlist_parser::data_handler);
// parse the file contents
m_file.seek(0, SEEK_SET);
char buffer[1024];
while (!m_done)
{
UINT32 length = m_file.read(buffer, sizeof(buffer));
m_done = m_file.eof();
if (XML_Parse(m_parser, buffer, length, m_done) == XML_STATUS_ERROR)
{
parse_error("%s", parser_error());
break;
}
}
// free the parser
XML_ParserFree(m_parser);
}
bool XmlParser::create( const tchar* _encoding, const tchar* _sep )
{
// destroy the old parser
destroy ();
// If the encoding or seperator are empty, then NULL
if ( _encoding != NULL && _encoding [0] == 0 )
_encoding = NULL;
if (_sep != NULL && _sep [0] == 0)
_sep = NULL;
// create the new one
m_pParser = XML_ParserCreate_MM( _encoding, NULL, _sep );
if (m_pParser == NULL)
return false;
// Invoke the post create routine
OnPostCreate();
// Set the user data used in callbacks
XML_SetUserData( m_pParser, (void*)this );
return true;
}
PHPAPI XML_Parser
XML_ParserCreate(const XML_Char *encoding)
{
return XML_ParserCreate_MM(encoding, NULL, NULL);
}
/**
* 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;
}
/**
* This routine runs EXPAT parser
*/
Bool XML_ParseStream(File * f, const XMLCallbacks * cb, void * ctx)
{
XML_Parser parser;
Bool ok = False;
/* set up memory management functions */
XML_Memory_Handling_Suite mem;
memset(&mem, 0, sizeof(mem));
mem.malloc_fcn = MEM_Alloc;
mem.realloc_fcn = MEM_Realloc;
mem.free_fcn = MEM_Free;
/* create parser */
parser = XML_ParserCreate_MM(NULL,&mem,NULL);
if (parser) {
int bufsize = 4096;
void * buf = NULL;
Bool done = False;
/* initialize EXPAT */
ExpatContext expat;
expat.ctx = ctx;
expat.cb = (*cb);
STRBUF_Init(&expat.sb);
BUFFER_Init(&expat.buf);
VECTOR_Init(&expat.atts, 0, NULL, NULL);
/* initialize the parser */
XML_SetElementHandler(parser, EXPAT_StartElement, EXPAT_EndElement);
XML_SetCharacterDataHandler(parser, EXPAT_Characters);
XML_SetUserData(parser, &expat);
/*
* By obtaining the buffer from Expat with the XML_GetBuffer,
* we can avoid double copying of the input.
*/
ok = True;
while (ok && !done && (buf = XML_GetBuffer(parser,bufsize)) != NULL) {
int len = -1;
if (!FILE_Eof(f)) {
len = FILE_Read(f, buf, bufsize);
}
if (len <= 0) {
done = True;
len = 0;
}
ok = XML_ParseBuffer(parser, len, done);
}
#if DEBUG
if (!ok) {
enum XML_Error code = XML_GetErrorCode(parser);
int l = XML_GetCurrentLineNumber(parser);
int c = XML_GetCurrentColumnNumber(parser);
Str fname = FILE_Name(f);
const char * msg = XML_ErrorString(code);
if (!fname) fname = TEXT("<noname>");
if (!msg) msg = "<no message>";
# ifdef _WIN32
TRACE4("EXPAT: %s: line %d, column %d: %hs\n",fname,l,c,msg);
# else /* _WIN32 */
TRACE4("EXPAT: %s: line %d, column %d: %s\n",fname,l,c,msg);
# endif /* _WIN32 */
}
#endif /* DEBUG */
if (!buf) ok = False;
/* deallocate parser */
XML_ParserFree(parser);
STRBUF_Destroy(&expat.sb);
BUFFER_Destroy(&expat.buf);
VECTOR_Destroy(&expat.atts);
}
return (ok);
}
XML_Parser _Expat_XML_ParserCreate_MM(struct ExpatIFace * Self, const XML_Char *encoding, const XML_Memory_Handling_Suite *memsuite, const XML_Char *namespaceSeparator)
{
return XML_ParserCreate_MM(encoding, memsuite, namespaceSeparator);
}
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;
}
/* ============================================================================
* Create/Destroy XML parse handler.
*/
HqBool xmlg_p_new(
xmlGContext *xml_ctxt,
xmlGParser **xml_parser,
xmlGMemoryHandler *memory_handler,
xmlGFilterChain *filter_chain)
{
xmlGParser *new_xml_parser;
XMLGASSERT(xml_ctxt != NULL, "xml_ctxt is NULL");
XMLGASSERT(xml_parser != NULL, "xml_parser is NULL");
XMLGASSERT(filter_chain != NULL, "filter_chain is NULL");
*xml_parser = NULL;
/* Although this code is going to be common to all back end XML parsers,
we need to do it here because only this file knows about the size of
xmlGParser - which is back end specific. */
if (memory_handler != NULL) {
if (memory_handler->f_malloc == NULL ||
memory_handler->f_realloc == NULL ||
memory_handler->f_free == NULL) {
XMLGASSERT(FALSE, "incomplete memory handler") ;
return FALSE ;
}
/* Use the pluged memory handler to allocate this structure */
if ((new_xml_parser = memory_handler->f_malloc(sizeof(xmlGParser))) == NULL)
return FALSE;
} else {
/* use the XML sub-system memory management */
if ((new_xml_parser = xmlg_subsystem_malloc(xml_ctxt, sizeof(xmlGParser))) == NULL)
return FALSE;
}
if (! xmlg_parser_common_init(new_xml_parser,
xml_ctxt,
memory_handler,
filter_chain)) {
/* We need to do this as we don't know if the memory handlers have
been plugged successfuly. Better safe than sorry. */
if (memory_handler != NULL) {
memory_handler->f_free(new_xml_parser);
} else {
xmlg_subsystem_free(xml_ctxt, new_xml_parser);
}
return FALSE;
}
/* xmlg_parser_malloc and friends are now available for this
handler. */
/* Do backend XML parser specific stuff. */
/* setup expat memory handler structure */
if (memory_handler != NULL) {
new_xml_parser->expat_mem.malloc_fcn = memory_handler->f_malloc ;
new_xml_parser->expat_mem.realloc_fcn = memory_handler->f_realloc ;
new_xml_parser->expat_mem.free_fcn = memory_handler->f_free ;
} else {
new_xml_parser->expat_mem.malloc_fcn = xml_ctxt->memory_handler.f_malloc ;
new_xml_parser->expat_mem.realloc_fcn = xml_ctxt->memory_handler.f_realloc ;
new_xml_parser->expat_mem.free_fcn = xml_ctxt->memory_handler.f_free ;
}
new_xml_parser->ctxt = XML_ParserCreate_MM(NULL, &new_xml_parser->expat_mem, &sep);
if (new_xml_parser->ctxt == NULL) {
xmlg_parser_free(new_xml_parser, new_xml_parser);
return FALSE;
}
/* Turn prefix mapping on. */
XML_SetReturnNSTriplet(new_xml_parser->ctxt, 1);
XML_SetUserData(new_xml_parser->ctxt, (void *)(new_xml_parser)) ;
XML_SetElementHandler(new_xml_parser->ctxt, expat_start_element_ns_cb,
expat_end_element_ns_cb) ;
XML_SetStartNamespaceDeclHandler(new_xml_parser->ctxt, expat_start_namespace_cb) ;
XML_SetCharacterDataHandler(new_xml_parser->ctxt, expat_characters_data_cb) ;
XML_SetXmlDeclHandler(new_xml_parser->ctxt, expat_xml_decl_cb) ;
XML_SetStartDoctypeDeclHandler(new_xml_parser->ctxt, expat_xml_dtd_cb) ;
if (filter_chain != NULL) {
xmlg_p_set_parse_error_cb(new_xml_parser, filter_chain->parse_error_cb) ;
}
*xml_parser = new_xml_parser;
return TRUE;
}
int messdocs(const char *toc_filename, const char *dest_dir, const char *help_project_filename,
const char *help_contents_filename, const char *help_filename)
{
char buf[4096];
struct messdocs_state state;
int len;
int done;
FILE *in;
FILE *chm_hhp;
int i;
char *s;
XML_Memory_Handling_Suite memcallbacks;
memset(&state, 0, sizeof(state));
state.m_pool = pool_alloc_lib(NULL);
/* open the DOC */
in = fopen(toc_filename, "r");
if (!in)
{
fprintf(stderr, "Cannot open TOC file '%s'\n", toc_filename);
goto error;
}
/* figure out the TOC directory */
state.m_toc_dir = pool_strdup_lib(state.m_pool, toc_filename);
if (!state.m_toc_dir)
goto outofmemory;
for (i = strlen(state.m_toc_dir) - 1; (i > 0) && !osd_is_path_separator(state.m_toc_dir[i]); i--)
state.m_toc_dir[i] = '\0';
/* clean the target directory */
rmdir_recursive(dest_dir);
osd_mkdir(dest_dir);
/* create the help contents file */
s = (char*)pool_malloc_lib(state.m_pool, strlen(dest_dir) + 1 + strlen(help_project_filename) + 1);
if (!s)
goto outofmemory;
strcpy(s, dest_dir);
strcat(s, PATH_SEPARATOR);
strcat(s, help_contents_filename);
state.m_chm_toc = fopen(s, "w");
state.m_dest_dir = dest_dir;
if (!state.m_chm_toc)
{
fprintf(stderr, "Cannot open file %s\n", s);
goto error;
}
fprintf(state.m_chm_toc, "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML//EN\"\n");
fprintf(state.m_chm_toc, "<HTML>\n");
fprintf(state.m_chm_toc, "<HEAD>\n");
fprintf(state.m_chm_toc, "</HEAD>\n");
fprintf(state.m_chm_toc, "<BODY>\n");
fprintf(state.m_chm_toc, "<OBJECT type=\"text/site properties\">\n");
fprintf(state.m_chm_toc, "\t<param name=\"Window Styles\" value=\"0x800625\">\n");
fprintf(state.m_chm_toc, "\t<param name=\"ImageType\" value=\"Folder\">\n");
fprintf(state.m_chm_toc, "\t<param name=\"Font\" value=\"Arial,8,0\">\n");
fprintf(state.m_chm_toc, "</OBJECT>\n");
fprintf(state.m_chm_toc, "<UL>\n");
/* create the XML parser */
memcallbacks.malloc_fcn = expat_malloc;
memcallbacks.realloc_fcn = expat_realloc;
memcallbacks.free_fcn = expat_free;
state.m_parser = XML_ParserCreate_MM(NULL, &memcallbacks, NULL);
if (!state.m_parser)
goto outofmemory;
XML_SetUserData(state.m_parser, &state);
XML_SetElementHandler(state.m_parser, start_handler, end_handler);
XML_SetCharacterDataHandler(state.m_parser, data_handler);
do
{
len = (int) fread(buf, 1, sizeof(buf), in);
done = feof(in);
if (XML_Parse(state.m_parser, buf, len, done) == XML_STATUS_ERROR)
{
process_error(&state, NULL, NULL);
break;
}
}
while(!done);
fprintf(state.m_chm_toc, "</UL>\n");
fprintf(state.m_chm_toc, "</BODY></HTML>");
fclose(state.m_chm_toc);
/* create the help project file */
s = (char*)pool_malloc_lib(state.m_pool, strlen(dest_dir) + 1 + strlen(help_project_filename) + 1);
if (!s)
goto outofmemory;
strcpy(s, dest_dir);
strcat(s, PATH_SEPARATOR);
strcat(s, help_project_filename);
chm_hhp = fopen(s, "w");
if (!chm_hhp)
{
fprintf(stderr, "Cannot open file %s\n", s);
goto error;
}
fprintf(chm_hhp, "[OPTIONS]\n");
fprintf(chm_hhp, "Compiled file=%s\n", help_filename);
fprintf(chm_hhp, "Contents file=%s\n", help_contents_filename);
fprintf(chm_hhp, "Default topic=%s\n", state.m_default_topic);
fprintf(chm_hhp, "Language=0x409 English (United States)\n");
fprintf(chm_hhp, "Title=%s\n", state.m_title);
fprintf(chm_hhp, "\n");
fclose(chm_hhp);
/* finish up */
XML_ParserFree(state.m_parser);
fclose(in);
pool_free_lib(state.m_pool);
return state.m_error ? -1 : 0;
outofmemory:
fprintf(stderr, "Out of memory");
error:
if (state.m_chm_toc) fclose(state.m_chm_toc);
if (in) fclose(in);
return -1;
}
