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);
}
static void
buildMenu(void)
{
/* XML parsing is done using expat */
int done = 1;
int len = strlen(crut_api.menuBuffer);
XML_Parser p = XML_ParserCreate(NULL);
if (! p)
{
fprintf(stderr, "Couldn't allocate memory for parser\n");
exit(-1);
}
XML_UseParserAsHandlerArg(p);
XML_SetElementHandler(p, start_hndl, end_hndl);
if (! XML_Parse(p, crut_api.menuBuffer, len, done))
{
crError("Parse error at line %d:\n%s\n",
XML_GetCurrentLineNumber(p),
XML_ErrorString(XML_GetErrorCode(p)));
}
buildGLUTMenu( crut_server.stack );
buildValueArray();
}
int main(int argc, char **argv) {
// int res = isatty(fileno( stdin));
//
// if(!res){
// fprintf(stderr, "Must provide input document on stdin\n");
// exit(1);
// }
XML_Parser p = XML_ParserCreate(NULL);
if (!p) {
fprintf(stderr, "Couldn't allocate memory for parser\n");
exit(-1);
}
XML_UseParserAsHandlerArg(p);
XML_SetElementHandler(p, start_hndl, end_hndl);
XML_SetCharacterDataHandler(p, char_hndl);
XML_SetProcessingInstructionHandler(p, proc_hndl);
/* Notice that the default handler is not set at this point */
for (;;) {
int done;
int len;
fgets(Buff, sizeof(Buff), stdin);
len = strlen(Buff);
if (ferror(stdin)) {
fprintf(stderr, "Read error\n");
exit(-1);
}
done = feof(stdin);
if (XML_Parse(p, Buff, len, done) != XML_STATUS_OK) {
fprintf(stderr, "Parse error at line %lu :\n %s \n",
XML_GetCurrentLineNumber(p), XML_ErrorString(
XML_GetErrorCode(p)));
exit(-1);
}
if (done)
break;
}
printf("\n");
return 0;
} /* End main */
/****************************************************************************************************************
* Parse configuration
*****************************************************************************************************************/
NFcompModel_p NFmodelParse (FILE *inFile, bool report)
{
char *doc;
NFdata_t data;
XML_Parser parser;
data.SkipName = "root";
data.Abort = false;
data.Buffer = (char *) NULL;
data.BufferLen = 0;
data.Skip = false;
data.Stack =
data.StackSize =
data.SkipLevel = 0;
data.Model = (NFcompModel_p) NULL;
data.Objects = (NFobject_p *) NULL;
if ((doc = _NFreadDoc (inFile)) == (char *) NULL) {
CMmsgPrint (CMmsgAppError, "Document reading error in %s:%d\n",__FILE__,__LINE__);
return ((NFcompModel_p) NULL);
}
if ((parser = XML_ParserCreate(NULL)) == (XML_Parser) NULL) {
CMmsgPrint (CMmsgSysError, "Memory allocation in %s:%d\n",__FILE__,__LINE__);
return ((NFcompModel_p) NULL);
}
XML_SetUserData (parser, &data);
XML_SetElementHandler (parser, _NFentryStart, _NFentryEnd);
XML_SetCharacterDataHandler (parser, _NFentryText);
XML_UseParserAsHandlerArg (parser);
if (XML_Parse(parser, doc, strlen (doc), true) == XML_STATUS_ERROR) {
CMmsgPrint (CMmsgAppError,"Parse error at line %d\n", XML_GetCurrentLineNumber(parser));
return ((NFcompModel_p) NULL);
}
XML_ParserFree (parser);
if (data.Objects != (NFobject_p *) NULL) free (data.Objects);
if ((data.Abort) && (data.Model != (NFcompModel_p) NULL)) {
NFobjectFree ((NFobject_p) data.Model);
return ((NFcompModel_p) NULL);
}
if (report) NFobjectPrint ((NFobject_p) (data.Model));
return (data.Model);
}
void load_settings(const char *filename)
{
struct stat stat_p;
int filehandle;
char *buffer;
long nread;
XML_Parser myparse;
init_settings();
init_parsinginfo();
myparse=XML_ParserCreate("UTF-8");
XML_UseParserAsHandlerArg(myparse);
XML_SetElementHandler(myparse,handlestart,handleend);
XML_SetCharacterDataHandler(myparse,handlechar);
filehandle=open(filename,O_RDONLY);
if(filehandle == -1) {
XML_ParserFree(myparse);
return;
}
stat(filename,&stat_p);
buffer=(char *)malloc(stat_p.st_size);
nread=read(filehandle,(void *)buffer,stat_p.st_size);
XML_Parse(myparse,buffer,nread,1);
free(buffer);
free_parsinginfo();
close(filehandle);
XML_ParserFree(myparse);
}
void LoadPropertyTreeFromXmlString(Sys::PropertyTree* props, const char* xml)
{
if (xml != NULL)
{
XML_Parser parser = XML_ParserCreate("UTF-8");
if (parser != NULL)
{
try
{
// Prepare parser
XML_SetElementHandler(parser,
LoadPropertyTreeFromXml_OnStartRootElement,
LoadPropertyTreeFromXml_OnEndRootElement);
XML_SetCharacterDataHandler(parser, LoadPropertyTreeFromXml_OnCharacterData);
XML_UseParserAsHandlerArg(parser);
XML_SetUserData(parser, props);
// Parse
int n = (int)strlen(xml);
if (XML_Parse(parser, xml, (int)n, true) == XML_STATUS_ERROR)
throw new Sys::Exception("cannot parse XML string");
}
catch (...)
{
// Protect from possible exceptions in callbacks (e.g. XML_SetElementHandler)
XML_ParserFree(parser);
throw;
}
XML_ParserFree(parser);
}
else
throw new Sys::Exception("cannot create XML parser");
}
else
throw Sys::CreateArgumentNullException();
}
void LoadPropertyTreeFromXmlFile(Sys::PropertyTree* props, const char* xmlFilePath)
{
if (xmlFilePath != NULL)
{
FILE* f = fopen(xmlFilePath, "r");
if (f != NULL)
{
try
{
XML_Parser parser = XML_ParserCreate("UTF-8");
if (parser != NULL)
{
char *buf = NULL;
try
{
// Prepare parser
XML_SetElementHandler(parser,
LoadPropertyTreeFromXml_OnStartRootElement,
LoadPropertyTreeFromXml_OnEndRootElement);
XML_SetCharacterDataHandler(parser, LoadPropertyTreeFromXml_OnCharacterData);
XML_UseParserAsHandlerArg(parser);
XML_SetUserData(parser, props);
// Prepare buffer
const size_t BUF_SIZE = 16 * 1024;
buf = new char[BUF_SIZE];
if (buf != NULL)
{
props->Clear();
// Read & parse
size_t n = fread(buf, 1, BUF_SIZE, f);
while (n != 0)
{
if (XML_Parse(parser, buf, (int)n, n != BUF_SIZE) == XML_STATUS_ERROR)
throw new Sys::Exception(Sys::FormattedString(
"cannot parse XML file '%s'", xmlFilePath));
n = fread(buf, 1, BUF_SIZE, f);
}
}
else
throw new Sys::SystemException("out of memory");
}
catch (...)
{
// Protect from possible exceptions in callbacks (e.g. XML_SetElementHandler)
delete[] buf;
XML_ParserFree(parser);
throw;
}
delete[] buf;
XML_ParserFree(parser);
}
else
throw new Sys::Exception("cannot create XML parser");
}
catch (...)
{
// Protect from possible exceptions in callbacks (e.g. XML_SetElementHandler)
fclose(f);
throw;
}
fclose(f);
}
else
throw new Sys::IOException(Sys::FormattedString(
"cannot open file '%s' for reading", xmlFilePath));
}
else
throw Sys::CreateArgumentNullException();
}
void _Expat_XML_UseParserAsHandlerArg(struct ExpatIFace * Self, XML_Parser parser)
{
XML_UseParserAsHandlerArg(parser);
}
