bool ddDatabaseDesign::readXmlModel(wxString file, ctlAuiNotebook *notebook)
{
emptyModel();
mappingIdToName.clear();
//Initial Parse Model
xmlTextReaderPtr reader = xmlReaderForFile(file.mb_str(wxConvUTF8), NULL, 0);
ddXmlStorage::setModel(this);
ddXmlStorage::setModel(this);
ddXmlStorage::initialModelParse(reader);
//Parse Model
xmlReaderNewFile(reader, file.mb_str(wxConvUTF8), NULL, 0);
ddXmlStorage::setModel(this);
ddXmlStorage::setNotebook(notebook);
if(!ddXmlStorage::Read(reader))
{
return false;
}
xmlFreeTextReader(reader);
return true;
}
/**
* This is the main function for 'validate' option
*/
int
valMain(int argc, char **argv)
{
int start;
static valOptions ops;
static ErrorInfo errorInfo;
int invalidFound = 0;
int options = XML_PARSE_DTDLOAD | XML_PARSE_DTDATTR;
if (argc <= 2) valUsage(argc, argv, EXIT_BAD_ARGS);
valInitOptions(&ops);
start = valParseOptions(&ops, argc, argv);
if (ops.nonet) options |= XML_PARSE_NONET;
errorInfo.verbose = ops.err;
xmlSetStructuredErrorFunc(&errorInfo, reportError);
xmlLineNumbersDefault(1);
if (ops.dtd)
{
/* xmlReader doesn't work with external dtd, have to use SAX
* interface */
int i;
for (i=start; i<argc; i++)
{
xmlDocPtr doc;
int ret;
ret = 0;
doc = NULL;
errorInfo.filename = argv[i];
doc = xmlReadFile(argv[i], NULL, options);
if (doc)
{
/* TODO: precompile DTD once */
ret = valAgainstDtd(&ops, ops.dtd, doc, argv[i]);
xmlFreeDoc(doc);
}
else
{
ret = 1; /* Malformed XML or could not open file */
if ((ops.listGood < 0) && !ops.show_val_res)
{
fprintf(stdout, "%s\n", argv[i]);
}
}
if (ret) invalidFound = 1;
if (ops.show_val_res)
{
if (ret == 0)
fprintf(stdout, "%s - valid\n", argv[i]);
else
fprintf(stdout, "%s - invalid\n", argv[i]);
}
}
}
else if (ops.schema || ops.relaxng || ops.embed || ops.wellFormed)
{
int i;
xmlTextReaderPtr reader = NULL;
#ifdef LIBXML_SCHEMAS_ENABLED
xmlSchemaPtr schema = NULL;
xmlSchemaParserCtxtPtr schemaParserCtxt = NULL;
xmlSchemaValidCtxtPtr schemaCtxt = NULL;
xmlRelaxNGPtr relaxng = NULL;
xmlRelaxNGParserCtxtPtr relaxngParserCtxt = NULL;
/* there is no xmlTextReaderRelaxNGValidateCtxt() !? */
/* TODO: Do not print debug stuff */
if (ops.schema)
{
schemaParserCtxt = xmlSchemaNewParserCtxt(ops.schema);
if (!schemaParserCtxt)
{
invalidFound = 2;
goto schemaCleanup;
}
errorInfo.filename = ops.schema;
schema = xmlSchemaParse(schemaParserCtxt);
if (!schema)
{
invalidFound = 2;
goto schemaCleanup;
}
xmlSchemaFreeParserCtxt(schemaParserCtxt);
schemaCtxt = xmlSchemaNewValidCtxt(schema);
if (!schemaCtxt)
{
invalidFound = 2;
goto schemaCleanup;
}
}
else if (ops.relaxng)
{
relaxngParserCtxt = xmlRelaxNGNewParserCtxt(ops.relaxng);
if (!relaxngParserCtxt)
{
invalidFound = 2;
goto schemaCleanup;
}
errorInfo.filename = ops.relaxng;
relaxng = xmlRelaxNGParse(relaxngParserCtxt);
if (!relaxng)
{
invalidFound = 2;
goto schemaCleanup;
}
}
#endif /* LIBXML_SCHEMAS_ENABLED */
for (i=start; i<argc; i++)
{
int ret = 0;
if (ops.embed) options |= XML_PARSE_DTDVALID;
if (!reader)
{
reader = xmlReaderForFile(argv[i], NULL, options);
}
else
{
ret = xmlReaderNewFile(reader, argv[i], NULL, options);
}
errorInfo.xmlReader = reader;
errorInfo.filename = argv[i];
if (reader && ret == 0)
{
#ifdef LIBXML_SCHEMAS_ENABLED
if (schemaCtxt)
{
ret = xmlTextReaderSchemaValidateCtxt(reader,
schemaCtxt, 0);
}
else if (relaxng)
{
ret = xmlTextReaderRelaxNGSetSchema(reader,
relaxng);
}
#endif /* LIBXML_SCHEMAS_ENABLED */
if (ret == 0)
{
do
{
ret = xmlTextReaderRead(reader);
} while (ret == 1);
if (ret != -1 && (schema || relaxng || ops.embed))
ret = !xmlTextReaderIsValid(reader);
}
}
else
{
if (ops.err)
fprintf(stderr, "couldn't read file '%s'\n", errorInfo.filename);
ret = 1; /* could not open file */
}
if (ret) invalidFound = 1;
if (!ops.show_val_res)
{
if ((ops.listGood > 0) && (ret == 0))
fprintf(stdout, "%s\n", argv[i]);
if ((ops.listGood < 0) && (ret != 0))
fprintf(stdout, "%s\n", argv[i]);
}
else
{
if (ret == 0)
fprintf(stdout, "%s - valid\n", argv[i]);
else
fprintf(stdout, "%s - invalid\n", argv[i]);
}
}
errorInfo.xmlReader = NULL;
xmlFreeTextReader(reader);
#ifdef LIBXML_SCHEMAS_ENABLED
schemaCleanup:
xmlSchemaFreeValidCtxt(schemaCtxt);
xmlRelaxNGFree(relaxng);
xmlSchemaFree(schema);
xmlRelaxNGCleanupTypes();
xmlSchemaCleanupTypes();
#endif /* LIBXML_SCHEMAS_ENABLED */
}
xmlCleanupParser();
return invalidFound;
}
int main(int argc, char **argv) {
xmlTextReaderPtr readerPtr;
int i;
xmlDocPtr docPtr;
if (argc < 2)
return(1);
/*
* this initialises the library and check potential ABI mismatches
* between the version it was compiled for and the actual shared
* library used.
*/
LIBXML_TEST_VERSION
/*
* Create a new reader for the first file and process the
* document.
*/
readerPtr = xmlReaderForFile(argv[1], NULL, 0);
if (NULL == readerPtr) {
fprintf(stderr, "%s: failed to create reader\n", argv[1]);
return(1);
}
processDoc(readerPtr);
/*
* The reader can be reused for subsequent files.
*/
for (i=2; i < argc; ++i) {
xmlReaderNewFile(readerPtr, argv[i], NULL, 0);
if (NULL == readerPtr) {
fprintf(stderr, "%s: failed to create reader\n", argv[i]);
return(1);
}
processDoc(readerPtr);
}
/*
* Since we've called xmlTextReaderCurrentDoc, we now have to
* clean up after ourselves. We only have to do this the last
* time, because xmlReaderNewFile calls xmlCtxtReset which takes
* care of it.
*/
docPtr = xmlTextReaderCurrentDoc(readerPtr);
if (docPtr != NULL)
xmlFreeDoc(docPtr);
/*
* Clean up the reader.
*/
xmlFreeTextReader(readerPtr);
/*
* Cleanup function for the XML library.
*/
xmlCleanupParser();
/*
* this is to debug memory for regression tests
*/
xmlMemoryDump();
return(0);
}
