void XMLCALL XmlTextInfo::defaulthandler
( void *data
, const XML_Char *s
, int len
)
{
XmlTextInfo *pThis = (XmlTextInfo *)data;
const char *p = s;
const char *end = s + len;
while ( p < end && *p != '\r' )
p++;
if ( p < end )
{
if ( p + 1 < end && p[1] == '\n' )
pThis->mEOL = _T ( "\r\n" );
else
pThis->mEOL = _T ( "\n" );
XML_SetDefaultHandlerExpand ( pThis->p, NULL );
return;
}
p = s;
while ( p < end && *p != '\r')
p++;
if ( p < end )
{
pThis->mEOL = _T ( "\n" );
XML_SetDefaultHandlerExpand ( pThis->p, NULL );
}
}
void XmlParser::EnableDefaultHandler ( bool _isEnable, bool _isExpand )
{
ex_assert( m_pParser, "m_pParser is not create" );
if ( _isExpand )
XML_SetDefaultHandlerExpand( m_pParser, _isEnable ? DefaultHandler : NULL );
else
XML_SetDefaultHandler( m_pParser, _isEnable ? DefaultHandler : NULL );
}
void XMLParser::EnableDefaultHandler(bool enable, bool expand)
{
assert(m_parser != NULL);
if (expand)
XML_SetDefaultHandlerExpand(m_parser, enable ? DefaultHandler : NULL);
else
XML_SetDefaultHandler(m_parser, enable ? DefaultHandler : NULL);
}
/*
* If we're at the bottom of the stack of <article> entries, we're
* finished with this article; print the rest verbatim.
*/
static void
article_end(void *dat, const XML_Char *name)
{
struct pargs *arg = dat;
if (0 == strcasecmp(name, "article") && 0 == --arg->stack) {
XML_SetElementHandler(arg->p, NULL, NULL);
XML_SetDefaultHandlerExpand(arg->p, template_text);
}
}
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 ParserEngine::init()
{
if (_parser)
XML_ParserFree(_parser);
if (!_pBuffer)
_pBuffer = new char[PARSE_BUFFER_SIZE];
if (dynamic_cast<NoNamespacePrefixesStrategy*>(_pNamespaceStrategy))
{
_parser = XML_ParserCreateNS(_encodingSpecified ? _encoding.c_str() : 0, '\t');
if (_parser)
{
XML_SetNamespaceDeclHandler(_parser, handleStartNamespaceDecl, handleEndNamespaceDecl);
}
}
else if (dynamic_cast<NamespacePrefixesStrategy*>(_pNamespaceStrategy))
{
_parser = XML_ParserCreateNS(_encodingSpecified ? _encoding.c_str() : 0, '\t');
if (_parser)
{
XML_SetReturnNSTriplet(_parser, 1);
XML_SetNamespaceDeclHandler(_parser, handleStartNamespaceDecl, handleEndNamespaceDecl);
}
}
else
{
_parser = XML_ParserCreate(_encodingSpecified ? _encoding.c_str() : 0);
}
if (!_parser) throw XMLException("Cannot create Expat parser");
XML_SetUserData(_parser, this);
XML_SetElementHandler(_parser, handleStartElement, handleEndElement);
XML_SetCharacterDataHandler(_parser, handleCharacterData);
XML_SetProcessingInstructionHandler(_parser, handleProcessingInstruction);
if (_expandInternalEntities)
XML_SetDefaultHandlerExpand(_parser, handleDefault);
else
XML_SetDefaultHandler(_parser, handleDefault);
XML_SetUnparsedEntityDeclHandler(_parser, handleUnparsedEntityDecl);
XML_SetNotationDeclHandler(_parser, handleNotationDecl);
XML_SetExternalEntityRefHandler(_parser, handleExternalEntityRef);
XML_SetCommentHandler(_parser, handleComment);
XML_SetCdataSectionHandler(_parser, handleStartCdataSection, handleEndCdataSection);
XML_SetDoctypeDeclHandler(_parser, handleStartDoctypeDecl, handleEndDoctypeDecl);
XML_SetEntityDeclHandler(_parser, handleEntityDecl);
XML_SetSkippedEntityHandler(_parser, handleSkippedEntity);
XML_SetParamEntityParsing(_parser, _externalParameterEntities ? XML_PARAM_ENTITY_PARSING_ALWAYS : XML_PARAM_ENTITY_PARSING_NEVER);
XML_SetUnknownEncodingHandler(_parser, handleUnknownEncoding, this);
}
static int lxp_make_parser (lua_State *L) {
XML_Parser p;
int bufferCharData = (lua_type(L, 3) != LUA_TBOOLEAN) || (lua_toboolean(L, 3) != 0);
char sep = *luaL_optstring(L, 2, "");
lxp_userdata *xpu = createlxp(L);
xpu->bufferCharData = bufferCharData;
p = xpu->parser = (sep == '\0') ? XML_ParserCreate(NULL) :
XML_ParserCreateNS(NULL, sep);
if (!p)
luaL_error(L, "XML_ParserCreate failed");
luaL_checktype(L, 1, LUA_TTABLE);
checkcallbacks(L);
lua_pushvalue(L, 1);
xpu->tableref = luaL_ref(L, LUA_REGISTRYINDEX);
XML_SetUserData(p, xpu);
if (hasfield(L, StartCdataKey) || hasfield(L, EndCdataKey))
XML_SetCdataSectionHandler(p, f_StartCdata, f_EndCdataKey);
if (hasfield(L, CharDataKey))
XML_SetCharacterDataHandler(p, f_CharData);
if (hasfield(L, CommentKey))
XML_SetCommentHandler(p, f_Comment);
if (hasfield(L, DefaultKey))
XML_SetDefaultHandler(p, f_Default);
if (hasfield(L, DefaultExpandKey))
XML_SetDefaultHandlerExpand(p, f_DefaultExpand);
if (hasfield(L, StartElementKey) || hasfield(L, EndElementKey))
XML_SetElementHandler(p, f_StartElement, f_EndElement);
if (hasfield(L, ExternalEntityKey))
XML_SetExternalEntityRefHandler(p, f_ExternaEntity);
if (hasfield(L, StartNamespaceDeclKey) || hasfield(L, EndNamespaceDeclKey))
XML_SetNamespaceDeclHandler(p, f_StartNamespaceDecl, f_EndNamespaceDecl);
if (hasfield(L, NotationDeclKey))
XML_SetNotationDeclHandler(p, f_NotationDecl);
if (hasfield(L, NotStandaloneKey))
XML_SetNotStandaloneHandler(p, f_NotStandalone);
if (hasfield(L, ProcessingInstructionKey))
XML_SetProcessingInstructionHandler(p, f_ProcessingInstruction);
if (hasfield(L, UnparsedEntityDeclKey))
XML_SetUnparsedEntityDeclHandler(p, f_UnparsedEntityDecl);
if (hasfield(L, StartDoctypeDeclKey))
XML_SetStartDoctypeDeclHandler(p, f_StartDoctypeDecl);
if (hasfield(L, XmlDeclKey))
XML_SetXmlDeclHandler(p, f_XmlDecl);
return 1;
}
/*
* Look for important tags in the template.
* This is the main handler for this file.
*/
static void
template_begin(void *dat, const XML_Char *name, const XML_Char **atts)
{
struct pargs *arg = dat;
const XML_Char **attp;
assert(0 == arg->stack);
xmltextx(arg->f, arg->buf, arg->dst, arg->article, 1, 0);
xmlstrflush(arg->buf, &arg->bufsz);
if (strcasecmp(name, "article")) {
xmlopensx(arg->f, name, atts,
arg->dst, arg->article, 1, 0);
return;
}
for (attp = atts; NULL != *attp; attp += 2)
if (0 == strcasecmp(*attp, "data-sblg-article"))
break;
if (NULL == *attp || ! xmlbool(attp[1])) {
xmlopensx(arg->f, name, atts,
arg->dst, arg->article, 1, 0);
return;
}
/*
* If we encounter an <article data-sblg-article="1">, then echo
* the article file and discard content until the matching close
* of the article.
*/
arg->stack++;
XML_SetElementHandler(arg->p, article_begin, article_end);
XML_SetDefaultHandlerExpand(arg->p, NULL);
xmltextx(arg->f, arg->article->article,
arg->dst, arg->article, 1, 0);
}
LLXmlParser::LLXmlParser()
:
mParser( NULL ),
mDepth( 0 )
{
mAuxErrorString = "no error";
// Override the document's declared encoding.
mParser = XML_ParserCreate(NULL);
XML_SetUserData(mParser, this);
XML_SetElementHandler( mParser, startElementHandler, endElementHandler);
XML_SetCharacterDataHandler( mParser, characterDataHandler);
XML_SetProcessingInstructionHandler( mParser, processingInstructionHandler);
XML_SetCommentHandler( mParser, commentHandler);
XML_SetCdataSectionHandler( mParser, startCdataSectionHandler, endCdataSectionHandler);
// This sets the default handler but does not inhibit expansion of internal entities.
// The entity reference will not be passed to the default handler.
XML_SetDefaultHandlerExpand( mParser, defaultDataHandler);
XML_SetUnparsedEntityDeclHandler( mParser, unparsedEntityDeclHandler);
}
int
compile(XML_Parser p, const char *templ,
const char *src, const char *dst)
{
char *out, *cp, *buf;
size_t sz, sargsz;
int fd, rc;
FILE *f;
struct pargs arg;
struct article *sargs;
memset(&arg, 0, sizeof(struct pargs));
rc = 0;
buf = out = NULL;
fd = -1;
f = NULL;
sz = 0;
sargs = NULL;
sargsz = 0;
if ( ! sblg_parse(p, src, &sargs, &sargsz))
goto out;
if (0 == sargsz) {
fprintf(stderr, "%s: contains no article\n", src);
goto out;
} else if (sargsz > 1)
fprintf(stderr, "%s: contains multiple "
"articles (using the first)\n", src);
arg.article = &sargs[0];
if (NULL == dst) {
/*
* If we have no output file name, then name it the same
* as the input but with ".html" at the end.
* However, if we have ".xml", then replace that with
* ".html".
*/
sz = strlen(src);
if (NULL == (cp = strrchr(src, '.')) ||
strcasecmp(cp + 1, "xml")) {
/* Append .html to input name. */
out = xmalloc(sz + 6);
strlcpy(out, src, sz + 6);
strlcat(out, ".html", sz + 6);
} else {
/* Replace .xml with .html. */
out = xmalloc(sz + 2);
strlcpy(out, src, sz - 2);
strlcat(out, "html", sz + 2);
}
} else
out = xstrdup(dst);
f = stdout;
if (strcmp(out, "-") && NULL == (f = fopen(out, "w"))) {
perror(out);
goto out;
}
if ( ! mmap_open(templ, &fd, &buf, &sz))
goto out;
arg.f = f;
arg.src = src;
arg.dst = strcmp(out, "-") ? out : NULL;
arg.p = p;
XML_ParserReset(p, NULL);
XML_SetElementHandler(p, template_begin, template_end);
XML_SetDefaultHandlerExpand(p, template_text);
XML_SetUserData(p, &arg);
if (XML_STATUS_OK != XML_Parse(p, buf, (int)sz, 1)) {
fprintf(stderr, "%s:%zu:%zu: %s\n", templ,
XML_GetCurrentLineNumber(p),
XML_GetCurrentColumnNumber(p),
XML_ErrorString(XML_GetErrorCode(p)));
goto out;
}
xmltextx(arg.f, arg.buf, arg.dst, arg.article, 1, 0);
xmlstrflush(arg.buf, &arg.bufsz);
fputc('\n', f);
rc = 1;
out:
mmap_close(fd, buf, sz);
if (NULL != f && stdin != f)
fclose(f);
sblg_free(sargs, sargsz);
free(out);
free(arg.buf);
return(rc);
}
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;
}
void _Expat_XML_SetDefaultHandlerExpand(struct ExpatIFace * Self, XML_Parser parser, XML_DefaultHandler handler)
{
XML_SetDefaultHandlerExpand(parser, handler);
}
void bmx_expat_XML_SetDefaultHandlerExpand(XML_Parser parser) {
XML_SetDefaultHandlerExpand(parser, bmx_expat_DefaultHandlerExpand);
}
