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);
}
void bmx_expat_XML_SetNamespaceDeclHandler(XML_Parser parser, int hasStart, int hasEnd) {
if (hasStart) {
if (hasEnd) {
XML_SetNamespaceDeclHandler(parser, bmx_expat_StartNamespaceDeclHandler, bmx_expat_EndNamespaceDeclHandler);
} else {
XML_SetNamespaceDeclHandler(parser, bmx_expat_StartNamespaceDeclHandler, NULL);
}
} else {
if (hasEnd) {
XML_SetNamespaceDeclHandler(parser, NULL, bmx_expat_EndNamespaceDeclHandler);
} else {
XML_SetNamespaceDeclHandler(parser, NULL, NULL);
}
}
}
int hxcfe_getXmlLayoutID(XmlFloppyBuilder* context,char * container)
{
int i;
AppData *ad = (AppData *) context->ad;
i = 0;
do
{
XML_ParserReset(context->xml_parser, NULL);
XML_SetUserData(context->xml_parser, (void *) ad);
XML_SetElementHandler(context->xml_parser, start, end);
XML_SetCharacterDataHandler(context->xml_parser, charhandler);
XML_SetNamespaceDeclHandler(context->xml_parser, ns_start, ns_end);
ad->xmlcheck = 1;
XML_Parse(context->xml_parser, disklayout_list[i]->unpacked_data, disklayout_list[i]->size, 1);
if(!strcmp((char*)ad->name,container))
{
return i;
}
memset(ad->name,0,512);
i++;
}while(disklayout_list[i]);
return -1;
}
std::unique_ptr<Node> inflate(std::istream* in, SourceLogger* logger) {
Stack stack;
XML_Parser parser = XML_ParserCreateNS(nullptr, kXmlNamespaceSep);
XML_SetUserData(parser, &stack);
XML_UseParserAsHandlerArg(parser);
XML_SetElementHandler(parser, startElementHandler, endElementHandler);
XML_SetNamespaceDeclHandler(parser, startNamespaceHandler, endNamespaceHandler);
XML_SetCharacterDataHandler(parser, characterDataHandler);
XML_SetCommentHandler(parser, commentDataHandler);
char buffer[1024];
while (!in->eof()) {
in->read(buffer, sizeof(buffer) / sizeof(buffer[0]));
if (in->bad() && !in->eof()) {
stack.root = {};
logger->error() << strerror(errno) << std::endl;
break;
}
if (XML_Parse(parser, buffer, in->gcount(), in->eof()) == XML_STATUS_ERROR) {
stack.root = {};
logger->error(XML_GetCurrentLineNumber(parser))
<< XML_ErrorString(XML_GetErrorCode(parser)) << std::endl;
break;
}
}
XML_ParserFree(parser);
return std::move(stack.root);
}
ExpatAdapter::ExpatAdapter() : parser(0)
{
#if XMP_DebugBuild
this->elemNesting = 0;
#if DumpXMLParseEvents
if ( this->parseLog == 0 ) this->parseLog = stdout;
#endif
#endif
this->parser = XML_ParserCreateNS ( 0, FullNameSeparator );
if ( this->parser == 0 ) XMP_Throw ( "Failure creating Expat parser", kXMPErr_ExternalFailure );
XML_SetUserData ( this->parser, this );
XML_SetNamespaceDeclHandler ( this->parser, StartNamespaceDeclHandler, EndNamespaceDeclHandler );
XML_SetElementHandler ( this->parser, StartElementHandler, EndElementHandler );
XML_SetCharacterDataHandler ( this->parser, CharacterDataHandler );
XML_SetCdataSectionHandler ( this->parser, StartCdataSectionHandler, EndCdataSectionHandler );
XML_SetProcessingInstructionHandler ( this->parser, ProcessingInstructionHandler );
XML_SetCommentHandler ( this->parser, CommentHandler );
#if BanAllEntityUsage
XML_SetStartDoctypeDeclHandler ( this->parser, StartDoctypeDeclHandler );
isAborted = false;
#endif
this->parseStack.push_back ( &this->tree ); // Push the XML root node.
} // ExpatAdapter::ExpatAdapter
XmlFloppyBuilder* hxcfe_initXmlFloppy(HXCFLOPPYEMULATOR* floppycontext)
{
AppData *ad;
XmlFloppyBuilder * rfw;
int i;
rfw = malloc(sizeof(XmlFloppyBuilder));
if(rfw)
{
memset(rfw,0,sizeof(XmlFloppyBuilder));
rfw->xml_parser = XML_ParserCreate(NULL);
ad = malloc(sizeof(AppData));
if(!ad)
{
return 0;
}
memset(ad,0,sizeof(AppData));
ad->interface_mode = -1;
i=0;
while( disklayout_list[i])
{
if(disklayout_list[i]->unpacked_data)
{
free(disklayout_list[i]->unpacked_data);
disklayout_list[i]->unpacked_data = 0;
}
disklayout_list[i]->unpacked_data = data_unpack(disklayout_list[i]->data,disklayout_list[i]->csize,0,disklayout_list[i]->size);
i++;
}
ad->floppycontext = floppycontext;
ad->current_state = ENTRY_STATE;
ad->stack_ptr = 0;
memset(ad->statestack,0xFF,sizeof(int) * 32);
ad->statestack[0].state = ad->current_state;
ad->p = rfw->xml_parser;
memset(ad->ts,0,sizeof(track_state)*256);
XML_ParserReset(rfw->xml_parser, NULL);
XML_SetUserData(rfw->xml_parser, (void *) ad);
XML_SetElementHandler(rfw->xml_parser, start, end);
XML_SetCharacterDataHandler(rfw->xml_parser, charhandler);
XML_SetNamespaceDeclHandler(rfw->xml_parser, ns_start, ns_end);
rfw->ad = ad;
}
return rfw;
}
/**
* Creates a new Expat parser. Called from the Java ExpatParser constructor.
*
* @param object the Java ExpatParser instance
* @param javaEncoding the character encoding name
* @param processNamespaces true if the parser should handle namespaces
* @returns the pointer to the C Expat parser
*/
static jlong ExpatParser_initialize(JNIEnv* env, jobject object, jstring javaEncoding,
jboolean processNamespaces) {
// Allocate parsing context.
UniquePtr<ParsingContext> context(new ParsingContext(object));
if (context.get() == NULL) {
jniThrowOutOfMemoryError(env, NULL);
return 0;
}
context->processNamespaces = processNamespaces;
// Create a parser.
XML_Parser parser;
ScopedUtfChars encoding(env, javaEncoding);
if (encoding.c_str() == NULL) {
return 0;
}
if (processNamespaces) {
// Use '|' to separate URIs from local names.
parser = XML_ParserCreateNS(encoding.c_str(), '|');
} else {
parser = XML_ParserCreate(encoding.c_str());
}
if (parser != NULL) {
if (processNamespaces) {
XML_SetNamespaceDeclHandler(parser, startNamespace, endNamespace);
XML_SetReturnNSTriplet(parser, 1);
}
XML_SetCdataSectionHandler(parser, startCdata, endCdata);
XML_SetCharacterDataHandler(parser, text);
XML_SetCommentHandler(parser, comment);
XML_SetDoctypeDeclHandler(parser, startDtd, endDtd);
XML_SetElementHandler(parser, startElement, endElement);
XML_SetExternalEntityRefHandler(parser, handleExternalEntity);
XML_SetNotationDeclHandler(parser, notationDecl);
XML_SetProcessingInstructionHandler(parser, processingInstruction);
XML_SetUnparsedEntityDeclHandler(parser, unparsedEntityDecl);
XML_SetUserData(parser, context.release());
} else {
jniThrowOutOfMemoryError(env, NULL);
return 0;
}
return fromXMLParser(parser);
}
sp<XMLNode> XMLNode::parse(const sp<AaptFile>& file)
{
char buf[16384];
int fd = open(file->getSourceFile().string(), O_RDONLY | O_BINARY);
if (fd < 0) {
SourcePos(file->getSourceFile(), -1).error("Unable to open file for read: %s",
strerror(errno));
return NULL;
}
XML_Parser parser = XML_ParserCreateNS(NULL, 1);
ParseState state;
state.filename = file->getPrintableSource();
state.parser = parser;
XML_SetUserData(parser, &state);
XML_SetElementHandler(parser, startElement, endElement);
XML_SetNamespaceDeclHandler(parser, startNamespace, endNamespace);
XML_SetCharacterDataHandler(parser, characterData);
XML_SetCommentHandler(parser, commentData);
ssize_t len;
bool done;
do {
len = read(fd, buf, sizeof(buf));
done = len < (ssize_t)sizeof(buf);
if (len < 0) {
SourcePos(file->getSourceFile(), -1).error("Error reading file: %s\n", strerror(errno));
close(fd);
return NULL;
}
if (XML_Parse(parser, buf, len, done) == XML_STATUS_ERROR) {
SourcePos(file->getSourceFile(), (int)XML_GetCurrentLineNumber(parser)).error(
"Error parsing XML: %s\n", XML_ErrorString(XML_GetErrorCode(parser)));
close(fd);
return NULL;
}
} while (!done);
XML_ParserFree(parser);
if (state.root == NULL) {
SourcePos(file->getSourceFile(), -1).error("No XML data generated when parsing");
}
close(fd);
return state.root;
}
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;
}
static void
init_parser(struct exmpp_xml_data *edd)
{
/* Set Expat user data to be this structure. */
XML_SetUserData(edd->parser, edd);
/* Configure the parser. */
XML_SetNamespaceDeclHandler(edd->parser,
expat_cb_start_namespace,
NULL);
XML_SetElementHandler(edd->parser,
expat_cb_start_element,
expat_cb_end_element);
XML_SetCharacterDataHandler(edd->parser,
expat_cb_character_data);
XML_SetDefaultHandler(edd->parser, NULL);
}
int main(int argc, char **argv) {
AppData *ad;
XML_Parser p = XML_ParserCreateNS(NULL, '|');
if (! p) {
fprintf(stderr, "Couldn't allocate memory for parser\n");
exit(-1);
}
ad = newAppData();
XML_SetUserData(p, (void *) ad);
XML_SetElementHandler(p, start, end);
XML_SetNamespaceDeclHandler(p, ns_start, ns_end);
for (;;) {
char *buff;
int len;
buff = XML_GetBuffer(p, CHUNK_SIZE);
if (! buff) {
fprintf(stderr, "Ran out of memory for parse buffer\n");
exit(-1);
}
len = read(0, buff, CHUNK_SIZE);
if (len < 0) {
perror("namespace - read error");
exit(-1);
}
if (! XML_ParseBuffer(p, len, len == 0)) {
fprintf(stderr, "Parse error at line %lu:\n%s\n",
XML_GetCurrentLineNumber(p),
XML_ErrorString(XML_GetErrorCode(p)));
exit(-1);
}
if (len == 0)
break;
}
return 0;
} /* End main */
void document_imp::parse(
istream& data)
{
XML_Parser p = XML_ParserCreateNS(NULL, '=');
if (p == NULL)
THROW_EXCEPTION(("failed to create expat parser object"));
try
{
XML_SetUserData(p, this);
XML_SetElementHandler(p, XML_StartElementHandler, XML_EndElementHandler);
XML_SetCharacterDataHandler(p, XML_CharacterDataHandler);
// XML_SetProcessingInstructionHandler(p, XML_ProcessingInstructionHandler);
// XML_SetCommentHandler(p, XML_CommentHandler);
// XML_SetCdataSectionHandler(p, XML_StartCdataSectionHandler, XML_EndCdataSectionHandler);
// XML_SetDefaultHandler(p, XML_DefaultHandler);
// XML_SetDoctypeDeclHandler(p, XML_StartDoctypeDeclHandler, XML_EndDoctypeDeclHandler);
// XML_SetUnparsedEntityDeclHandler(p, XML_UnparsedEntityDeclHandler);
// XML_SetNotationDeclHandler(p, XML_NotationDeclHandler);
XML_SetNamespaceDeclHandler(p, XML_StartNamespaceDeclHandler, XML_EndNamespaceDeclHandler);
XML_SetReturnNSTriplet(p, true);
while (not data.eof())
{
string line;
getline(data, line);
line += '\n';
XML_Status err = XML_Parse(p, line.c_str(), line.length(), data.eof() or line.empty());
if (err != XML_STATUS_OK)
THROW_EXCEPTION((p));
}
}
catch (std::exception& e)
{
XML_ParserFree(p);
throw;
}
XML_ParserFree(p);
}
const char* hxcfe_getXmlLayoutName(XmlFloppyBuilder* context,int moduleID)
{
AppData *ad = (AppData *) context->ad;
if(hxcfe_numberOfXmlLayout(context) > moduleID)
{
ad->xmlcheck = 1;
XML_ParserReset(context->xml_parser, NULL);
XML_SetUserData(context->xml_parser, (void *) ad);
XML_SetElementHandler(context->xml_parser, start, end);
XML_SetCharacterDataHandler(context->xml_parser, charhandler);
XML_SetNamespaceDeclHandler(context->xml_parser, ns_start, ns_end);
XML_Parse(context->xml_parser, disklayout_list[moduleID]->unpacked_data, disklayout_list[moduleID]->size, 1);
return (const char*)ad->name;
}
return NULL;
}
FLOPPY* hxcfe_generateXmlFloppy (XmlFloppyBuilder* context,unsigned char * rambuffer,unsigned buffersize)
{
AppData *ad;
ad = context->ad;
ad->xmlcheck = 0;
ad->image_data = rambuffer;
ad->buffer_size = buffersize;
XML_ParserReset(context->xml_parser, NULL);
XML_SetUserData(context->xml_parser, (void *) ad);
XML_SetElementHandler(context->xml_parser, start, end);
XML_SetCharacterDataHandler(context->xml_parser, charhandler);
XML_SetNamespaceDeclHandler(context->xml_parser, ns_start, ns_end);
XML_Parse(context->xml_parser, disklayout_list[ad->layout_id]->unpacked_data, disklayout_list[ad->layout_id]->size, 1);
return ad->floppy;
}
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_SetNamespaceDeclHandler(struct ExpatIFace * Self, XML_Parser parser, XML_StartNamespaceDeclHandler start, XML_EndNamespaceDeclHandler end)
{
XML_SetNamespaceDeclHandler(parser, start, end);
}
void read_maxgroups(char *pPath) {
int i;
AppData *ad;
int f;
XML_Parser p = XML_ParserCreateNS(NULL, '|');
if (!p) {
fprintf(stderr, "Couldn't allocate memory for parser!\n");
exit(1);
}
ad = newAppData();
// null them out
for (i = 0; i < 1000; i++) {
maxgroup[i] = -1; // no way a 2 digit group # will match that
}
// parse the SSN.xml we've been passed and populate the maxgroup
// array
XML_SetUserData(p, (void *) ad);
XML_SetElementHandler(p, start, end);
XML_SetNamespaceDeclHandler(p, ns_start, ns_end);
f = open(pPath, O_RDONLY);
if (f < 0) {
fprintf(stderr, "can't open %s: %s\n", pPath,
strerror(errno));
exit(1);
}
for (;;) {
char *buff;
int len;
buff = XML_GetBuffer(p, CHUNK_SIZE);
if (! buff) {
fprintf(stderr, "parse buffer\n");
exit(1);
}
len = read(f, buff, CHUNK_SIZE);
if (len < 0) {
fprintf(stderr, "XML read error\n");
exit(1);
}
if (! XML_ParseBuffer(p, len, len == 0)) {
fprintf(stderr, "Parse error at line %d:\n%s\n",
XML_GetCurrentLineNumber(p),
XML_ErrorString(XML_GetErrorCode(p)));
exit(1);
}
if (len == 0) {
break;
}
}
return;
}
