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; }