bool XMLReader::set_relaxng_schema(String source, int type) {
SYNC_VM_REGS_SCOPED();
if (source.empty()) {
raise_warning("Schema data source is required");
return false;
}
if (m_ptr) {
int ret = -1;
xmlRelaxNGPtr schema = nullptr;
if (!source.empty()) {
schema = _xmlreader_get_relaxNG(source, type, nullptr, nullptr);
if (schema) {
ret = xmlTextReaderRelaxNGSetSchema(m_ptr, schema);
}
} else {
ret = xmlTextReaderRelaxNGSetSchema(m_ptr, nullptr);
}
if (ret == 0) {
if (m_schema) {
xmlRelaxNGFree((xmlRelaxNGPtr) m_schema);
}
m_schema = schema;
return true;
}
}
raise_warning("Unable to set schema. This must be set prior to reading or schema contains errors.");
return false;
}
/*!
* \brief Private constructor from a libxml pointer
*
* Do the real configuration from a libxml pointer
* \param pctxt[in]: lib xml document pointer
*/
void QRelaxNGvalidator::finish(const void * pctxt)
{
// Parse schema
this->rng = xmlRelaxNGParse((xmlRelaxNGParserCtxtPtr)pctxt);
xmlRelaxNGFreeParserCtxt((xmlRelaxNGParserCtxtPtr)pctxt);
if(!rng) {
goto schemaerror;
}
// Create a validation context
vctxt = xmlRelaxNGNewValidCtxt((xmlRelaxNGPtr)this->rng);
if(!vctxt) {
goto contexterror;
}
/* Ask the validation parser to return error */
xmlRelaxNGSetValidErrors((xmlRelaxNGValidCtxtPtr)this->vctxt,
(xmlRelaxNGValidityErrorFunc) fprintf,
(xmlRelaxNGValidityWarningFunc) fprintf,
stderr);
return;
schemaerror:
this->raiseError(QString("Schema ") + this->filename + QString(" has an error"));
return;
contexterror:
this->raiseError(QString("Could not create validation context for ")
+ this->filename + QString("schema"));
xmlRelaxNGFree((xmlRelaxNGPtr)this->rng);
return;
}
//-----------------------------------------
bool RngValidator::run(const std::string& xml_file_pathname, const std::string& rng_file_pathname)
//-----------------------------------------
{
// TODO handle multiple RNG files (eg viz)
// RELAX NG Parser Context
xmlRelaxNGParserCtxtPtr ctxt = xmlRelaxNGNewParserCtxt(rng_file_pathname.c_str());
xmlRelaxNGSetParserErrors(ctxt,
(xmlRelaxNGValidityErrorFunc)RngValidator::rngErr,
(xmlRelaxNGValidityWarningFunc)RngValidator::rngWarn,
NULL);
xmlRelaxNGPtr schema = xmlRelaxNGParse(ctxt);
xmlRelaxNGFreeParserCtxt(ctxt);
xmlTextReaderPtr reader = xmlNewTextReaderFilename(xml_file_pathname.c_str());
xmlTextReaderRelaxNGSetSchema(reader, schema);
xmlTextReaderSetErrorHandler(reader, (xmlTextReaderErrorFunc)RngValidator::readerErr, NULL);
xmlTextReaderSetStructuredErrorHandler(reader, (xmlStructuredErrorFunc)RngValidator::structErr, NULL);
while (xmlTextReaderRead(reader));
const bool valid = xmlTextReaderIsValid(reader) == 1;
xmlFreeTextReader(reader);
xmlRelaxNGFree(schema);
return valid;
}
void RelaxNGSchema::release_underlying()
{
if (pimpl_->schema)
{
xmlRelaxNGFree(pimpl_->schema);
pimpl_->schema = 0;
}
}
void
ruby_xml_relaxng_free(ruby_xml_relaxng *rxrelaxng) {
if (rxrelaxng->relaxng != NULL) {
xmlRelaxNGFree(rxrelaxng->relaxng);
rxrelaxng->relaxng = NULL;
}
ruby_xfree(rxrelaxng);
}
/* {{{ php_xmlreader_set_relaxng_schema */
static void php_xmlreader_set_relaxng_schema(INTERNAL_FUNCTION_PARAMETERS, int type) {
#ifdef LIBXML_SCHEMAS_ENABLED
zval *id;
size_t source_len = 0;
int retval = -1;
xmlreader_object *intern;
xmlRelaxNGPtr schema = NULL;
char *source;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "p!", &source, &source_len) == FAILURE) {
return;
}
if (source != NULL && !source_len) {
php_error_docref(NULL, E_WARNING, "Schema data source is required");
RETURN_FALSE;
}
id = getThis();
intern = Z_XMLREADER_P(id);
if (intern && intern->ptr) {
if (source) {
schema = _xmlreader_get_relaxNG(source, source_len, type, NULL, NULL);
if (schema) {
retval = xmlTextReaderRelaxNGSetSchema(intern->ptr, schema);
}
} else {
/* unset the associated relaxNG context and schema if one exists */
retval = xmlTextReaderRelaxNGSetSchema(intern->ptr, NULL);
}
if (retval == 0) {
if (intern->schema) {
xmlRelaxNGFree((xmlRelaxNGPtr) intern->schema);
}
intern->schema = schema;
RETURN_TRUE;
}
}
php_error_docref(NULL, E_WARNING, "Unable to set schema. This must be set prior to reading or schema contains errors.");
RETURN_FALSE;
#else
php_error_docref(NULL, E_WARNING, "No Schema support built into libxml.");
RETURN_FALSE;
#endif
}
void c_XMLReader::close_impl() {
if (m_ptr) {
xmlFreeTextReader(m_ptr);
m_ptr = NULL;
}
if (m_input) {
xmlFreeParserInputBuffer(m_input);
m_input = NULL;
}
if (m_schema) {
xmlRelaxNGFree((xmlRelaxNGPtr) m_schema);
m_schema = NULL;
}
}
void XMLReader::close() {
SYNC_VM_REGS_SCOPED();
if (m_ptr) {
xmlFreeTextReader(m_ptr);
m_ptr = nullptr;
}
if (m_input) {
xmlFreeParserInputBuffer(m_input);
m_input = nullptr;
}
if (m_schema) {
xmlRelaxNGFree((xmlRelaxNGPtr) m_schema);
m_schema = nullptr;
}
}
/* {{{ xmlreader_free_resources */
static void xmlreader_free_resources(xmlreader_object *intern) {
if (intern) {
if (intern->input) {
xmlFreeParserInputBuffer(intern->input);
intern->input = NULL;
}
if (intern->ptr) {
xmlFreeTextReader(intern->ptr);
intern->ptr = NULL;
}
#ifdef LIBXML_SCHEMAS_ENABLED
if (intern->schema) {
xmlRelaxNGFree((xmlRelaxNGPtr) intern->schema);
intern->schema = NULL;
}
#endif
}
}
XMLValidationRelaxNG::~XMLValidationRelaxNG()
{
scope->unregisterPointer(validationFile);
scope->removeId(id);
if (validationFile)
{
xmlRelaxNGFree((xmlRelaxNG *) validationFile);
openValidationFiles.remove(this);
if (openValidationFiles.size() == 0 && XMLDocument::getOpenDocuments().size() == 0)
{
resetScope();
}
}
if (errorBuffer)
{
delete errorBuffer;
errorBuffer = 0;
}
}
~RelaxNGSchema()
{
if (m_Schema)
xmlRelaxNGFree(m_Schema);
}
/**
* Parse elements from the configuration file.
*
*/
ods_status
parse_file_check(const char* cfgfile, const char* rngfile)
{
xmlDocPtr doc = NULL;
xmlDocPtr rngdoc = NULL;
xmlRelaxNGParserCtxtPtr rngpctx = NULL;
xmlRelaxNGValidCtxtPtr rngctx = NULL;
xmlRelaxNGPtr schema = NULL;
if (!cfgfile || !rngfile) {
ods_log_error("[%s] no cfgfile or rngfile", parser_str);
return ODS_STATUS_ASSERT_ERR;
}
ods_log_assert(cfgfile);
ods_log_assert(rngfile);
ods_log_debug("[%s] check cfgfile %s with rngfile %s", parser_str,
cfgfile, rngfile);
/* Load XML document */
doc = xmlParseFile(cfgfile);
if (doc == NULL) {
ods_log_error("[%s] unable to read cfgfile %s", parser_str,
cfgfile);
return ODS_STATUS_XML_ERR;
}
/* Load rng document */
rngdoc = xmlParseFile(rngfile);
if (rngdoc == NULL) {
ods_log_error("[%s] unable to read rngfile %s", parser_str,
rngfile);
xmlFreeDoc(doc);
return ODS_STATUS_XML_ERR;
}
/* Create an XML RelaxNGs parser context for the relax-ng document. */
rngpctx = xmlRelaxNGNewDocParserCtxt(rngdoc);
if (rngpctx == NULL) {
xmlFreeDoc(rngdoc);
xmlFreeDoc(doc);
ods_log_error("[%s] unable to create XML RelaxNGs parser context",
parser_str);
return ODS_STATUS_XML_ERR;
}
/* Parse a schema definition resource and
* build an internal XML schema structure.
*/
schema = xmlRelaxNGParse(rngpctx);
if (schema == NULL) {
ods_log_error("[%s] unable to parse a schema definition resource",
parser_str);
xmlRelaxNGFreeParserCtxt(rngpctx);
xmlFreeDoc(rngdoc);
xmlFreeDoc(doc);
return ODS_STATUS_PARSE_ERR;
}
/* Create an XML RelaxNGs validation context. */
rngctx = xmlRelaxNGNewValidCtxt(schema);
if (rngctx == NULL) {
ods_log_error("[%s] unable to create RelaxNGs validation context",
parser_str);
xmlRelaxNGFree(schema);
xmlRelaxNGFreeParserCtxt(rngpctx);
xmlFreeDoc(rngdoc);
xmlFreeDoc(doc);
return ODS_STATUS_RNG_ERR;
}
/* Validate a document tree in memory. */
/*
better not check: if not correct, this will segfault.
status = xmlRelaxNGValidateDoc(rngctx,doc);
if (status != 0) {
ods_log_error("[%s] cfgfile validation failed %s", parser_str,
cfgfile);
xmlRelaxNGFreeValidCtxt(rngctx);
xmlRelaxNGFree(schema);
xmlRelaxNGFreeParserCtxt(rngpctx);
xmlFreeDoc(rngdoc);
xmlFreeDoc(doc);
return ODS_STATUS_RNG_ERR;
}
*/
xmlRelaxNGFreeValidCtxt(rngctx);
xmlRelaxNGFree(schema);
xmlRelaxNGFreeParserCtxt(rngpctx);
xmlFreeDoc(rngdoc);
xmlFreeDoc(doc);
return ODS_STATUS_OK;
}
/*!
* \brief Default destructor
*
* Free libxml object
*/
QRelaxNGvalidator::~QRelaxNGvalidator()
{
xmlRelaxNGFreeValidCtxt((xmlRelaxNGValidCtxtPtr)this->vctxt);
xmlRelaxNGFree((xmlRelaxNGPtr)this->rng);
}
static void dealloc(xmlRelaxNGPtr schema)
{
NOKOGIRI_DEBUG_START(schema);
xmlRelaxNGFree(schema);
NOKOGIRI_DEBUG_END(schema);
}
/* Check an XML file against its rng */
int check_rng(const char *filename, const char *rngfilename) {
xmlDocPtr doc = NULL;
xmlDocPtr rngdoc = NULL;
xmlRelaxNGParserCtxtPtr rngpctx = NULL;
xmlRelaxNGValidCtxtPtr rngctx = NULL;
xmlRelaxNGPtr schema = NULL;
if (verbose) {
dual_log("DEBUG: About to check XML validity in %s\n", filename);
}
/* Load XML document */
doc = xmlParseFile(filename);
if (doc == NULL) {
dual_log("ERROR: unable to parse file \"%s\"\n", filename);
/* Maybe the file doesn't exist? */
check_file(filename, "Configuration file");
return(1);
}
/* Load rng document */
rngdoc = xmlParseFile(rngfilename);
if (rngdoc == NULL) {
dual_log("ERROR: unable to parse file \"%s\"\n", rngfilename);
/* Maybe the file doesn't exist? */
check_file(rngfilename, "RNG file");
xmlFreeDoc(doc);
return(1);
}
/* Create an XML RelaxNGs parser context for the relax-ng document. */
rngpctx = xmlRelaxNGNewDocParserCtxt(rngdoc);
if (rngpctx == NULL) {
dual_log("ERROR: unable to create XML RelaxNGs parser context\n");
xmlFreeDoc(doc);
xmlFreeDoc(rngdoc);
return(1);
}
xmlRelaxNGSetParserErrors(rngpctx,
(xmlRelaxNGValidityErrorFunc) fprintf,
(xmlRelaxNGValidityWarningFunc) fprintf,
stderr);
/* parse a schema definition resource and build an internal XML Shema struture which can be used to validate instances. */
schema = xmlRelaxNGParse(rngpctx);
if (schema == NULL) {
dual_log("ERROR: unable to parse a schema definition resource\n");
xmlRelaxNGFreeParserCtxt(rngpctx);
xmlFreeDoc(doc);
xmlFreeDoc(rngdoc);
return(1);
}
/* Create an XML RelaxNGs validation context based on the given schema */
rngctx = xmlRelaxNGNewValidCtxt(schema);
if (rngctx == NULL) {
dual_log("ERROR: unable to create RelaxNGs validation context based on the schema\n");
xmlRelaxNGFree(schema);
xmlRelaxNGFreeParserCtxt(rngpctx);
xmlFreeDoc(doc);
xmlFreeDoc(rngdoc);
return(1);
}
xmlRelaxNGSetValidErrors(rngctx,
(xmlRelaxNGValidityErrorFunc) fprintf,
(xmlRelaxNGValidityWarningFunc) fprintf,
stderr);
/* Validate a document tree in memory. */
if (xmlRelaxNGValidateDoc(rngctx,doc) != 0) {
dual_log("ERROR: %s fails to validate\n", filename);
xmlRelaxNGFreeValidCtxt(rngctx);
xmlRelaxNGFree(schema);
xmlRelaxNGFreeParserCtxt(rngpctx);
xmlFreeDoc(doc);
xmlFreeDoc(rngdoc);
return(1);
}
xmlRelaxNGFreeValidCtxt(rngctx);
xmlRelaxNGFree(schema);
xmlRelaxNGFreeParserCtxt(rngpctx);
xmlFreeDoc(doc);
xmlFreeDoc(rngdoc);
return 0;
}
/**
* 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;
}
/**
* Validation function take first argument as XML type, then check if is
* well formated. If so, do the same for RNG document. If both success, check
* XML document against RNG schema restrictions.
* @return true if pass, false otherwise
*/
Datum
xmlvalidate_rng(PG_FUNCTION_ARGS)
{
#ifdef USE_LIBXML
text *data = NULL;
char *rng = NULL;
xmlChar *utf8rng = NULL;
xmltype *xmldata = NULL;
char *xmldataint = NULL;
xmlChar *xmldatastr = NULL;
bool result = false;
int lenxml = -1; // length of xml data
int lenrng = -1; // length of xsd data
xmlDocPtr doc = NULL;
int ret = -1;
xmlRelaxNGParserCtxtPtr ctxt = NULL;
xmlRelaxNGPtr schema = NULL;
xmlRelaxNGValidCtxtPtr validctxt = NULL;
// creating xmlChar * from internal xmltype of stored XML
xmldata = PG_GETARG_XML_P(0);
xmldataint = VARDATA(xmldata);
lenxml = VARSIZE(xmldata) - VARHDRSZ;
xmldatastr = (xmlChar *) palloc((lenxml + 1) * sizeof(xmlChar));
memcpy(xmldatastr, xmldataint, lenxml);
xmldatastr[lenxml] = '\0';
// creating xmlChar* from text representation of XSD
data = PG_GETARG_TEXT_P(1);
lenrng = VARSIZE(data) - VARHDRSZ;
rng = text_to_cstring(data);
//encode XML to internal representation with UTF-8, only one used in LibXML
utf8rng = pg_do_encoding_conversion((unsigned char*)rng,
lenrng,
GetDatabaseEncoding(),
PG_UTF8);
//initialize LibXML structures, if allready done -> do nothing
pg_xml_init();
xmlInitParser();
doc = xmlReadMemory((const char *)xmldatastr, lenxml, "include.xml", NULL, 0);
if (doc == NULL) {
elog(ERROR, "Failed to parse XML document");
PG_RETURN_BOOL (false);
}
ctxt = xmlRelaxNGNewMemParserCtxt(rng, lenrng);
if (ctxt == NULL)
{ // unable to create parser context
elog(ERROR, "Error with creating schema, check if RelaxNG schema is valid");
PG_RETURN_BOOL (false);
}
schema = xmlRelaxNGParse(ctxt); // parse schema
xmlRelaxNGFreeParserCtxt(ctxt); // realease parser context
validctxt = xmlRelaxNGNewValidCtxt(schema);
if (validctxt == NULL)
{ // cant create validation context
xmlRelaxNGFree(schema);
elog(ERROR, "Cant create validation context");
PG_RETURN_BOOL (false);
}
// set errors to SQL errors
xmlRelaxNGSetValidErrors(validctxt,
xml_error_handler,
NULL,
0);
ret = xmlRelaxNGValidateDoc(validctxt, doc);
if (ret == 0)
{
elog(INFO, "Validates");
result = true;
} else if (ret > 0)
{
elog(INFO, "Dont validates");
result = false;
} else
{
elog(INFO, "Validation generated an internal error");
result = false;
}
xmlRelaxNGFree(schema);
xmlRelaxNGFreeValidCtxt(validctxt);
xmlFreeDoc(doc); // clean up document in memmory
xmlCleanupParser(); // clean up stream parser
PG_RETURN_BOOL (result);
#else
NO_XML_SUPPORT();
PG_RETURN_BOOL (false);
#endif
}
int main(int argc, char **argv) {
int i;
int files = 0;
xmlRelaxNGPtr schema = NULL;
for (i = 1; i < argc ; i++) {
#ifdef LIBXML_DEBUG_ENABLED
if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug")))
debug++;
else
#endif
#ifdef HAVE_SYS_MMAN_H
if ((!strcmp(argv[i], "-memory")) || (!strcmp(argv[i], "--memory"))) {
memory++;
} else
#endif
if ((!strcmp(argv[i], "-noout")) || (!strcmp(argv[i], "--noout"))) {
noout++;
} else
if ((!strcmp(argv[i], "-tree")) || (!strcmp(argv[i], "--tree"))) {
tree++;
}
}
xmlLineNumbersDefault(1);
xmlSubstituteEntitiesDefault(1);
for (i = 1; i < argc ; i++) {
if (argv[i][0] != '-') {
if (schema == NULL) {
xmlRelaxNGParserCtxtPtr ctxt;
#ifdef HAVE_SYS_MMAN_H
if (memory) {
int fd;
struct stat info;
const char *base;
if (stat(argv[i], &info) < 0)
break;
if ((fd = open(argv[i], O_RDONLY)) < 0)
break;
base = mmap(NULL, info.st_size, PROT_READ,
MAP_SHARED, fd, 0) ;
if (base == (void *) MAP_FAILED)
break;
ctxt = xmlRelaxNGNewMemParserCtxt((char *)base,info.st_size);
xmlRelaxNGSetParserErrors(ctxt,
(xmlRelaxNGValidityErrorFunc) fprintf,
(xmlRelaxNGValidityWarningFunc) fprintf,
stderr);
schema = xmlRelaxNGParse(ctxt);
xmlRelaxNGFreeParserCtxt(ctxt);
munmap((char *) base, info.st_size);
} else
#endif
{
ctxt = xmlRelaxNGNewParserCtxt(argv[i]);
xmlRelaxNGSetParserErrors(ctxt,
(xmlRelaxNGValidityErrorFunc) fprintf,
(xmlRelaxNGValidityWarningFunc) fprintf,
stderr);
schema = xmlRelaxNGParse(ctxt);
xmlRelaxNGFreeParserCtxt(ctxt);
}
if (schema == NULL) {
printf("Relax-NG schema %s failed to compile\n", argv[i]);
files = -1;
break;
}
#ifdef LIBXML_OUTPUT_ENABLED
#ifdef LIBXML_DEBUG_ENABLED
if (debug)
xmlRelaxNGDump(stdout, schema);
#endif
if (tree)
xmlRelaxNGDumpTree(stdout, schema);
#endif /* LIBXML_OUTPUT_ENABLED */
} else {
xmlDocPtr doc;
doc = xmlReadFile(argv[i],NULL,0);
if (doc == NULL) {
fprintf(stderr, "Could not parse %s\n", argv[i]);
} else {
xmlRelaxNGValidCtxtPtr ctxt;
int ret;
ctxt = xmlRelaxNGNewValidCtxt(schema);
xmlRelaxNGSetValidErrors(ctxt,
(xmlRelaxNGValidityErrorFunc) fprintf,
(xmlRelaxNGValidityWarningFunc) fprintf,
stderr);
ret = xmlRelaxNGValidateDoc(ctxt, doc);
if (ret == 0) {
printf("%s validates\n", argv[i]);
} else if (ret > 0) {
printf("%s fails to validate\n", argv[i]);
} else {
printf("%s validation generated an internal error\n",
argv[i]);
}
xmlRelaxNGFreeValidCtxt(ctxt);
xmlFreeDoc(doc);
}
}
files ++;
}
}
if (schema != NULL)
xmlRelaxNGFree(schema);
if (files == 0) {
printf("Usage : %s [--debug] [--noout] schemas XMLfiles ...\n",
argv[0]);
printf("\tParse the HTML files and output the result of the parsing\n");
#ifdef LIBXML_DEBUG_ENABLED
printf("\t--debug : dump a debug tree of the in-memory document\n");
#endif
printf("\t--noout : do not print the result\n");
printf("\t--tree : print the intermediate Relax-NG document tree\n");
#ifdef HAVE_SYS_MMAN_H
printf("\t--memory : test the schemas in memory parsing\n");
#endif
}
xmlRelaxNGCleanupTypes();
xmlCleanupParser();
xmlMemoryDump();
return(0);
}