static void
handle_styles_element (ParserState *parser_state)
{
int type;
const xmlChar *tag_name;
g_return_if_fail (parser_state->error == NULL);
while (parser_state->error == NULL)
{
/* FIXME: is xmlTextReaderIsValid call needed here or
* error func will be called? */
xmlTextReaderRead (parser_state->reader);
xmlTextReaderIsValid (parser_state->reader);
if (parser_state->error != NULL)
break;
tag_name = xmlTextReaderConstName (parser_state->reader);
type = xmlTextReaderNodeType (parser_state->reader);
/* End at the closing </styles> tag */
if (tag_name && type == XML_READER_TYPE_END_ELEMENT &&
!xmlStrcmp (BAD_CAST "styles", tag_name))
break;
/* Skip nodes that aren't <style> elements */
if (tag_name == NULL || xmlStrcmp (BAD_CAST "style", tag_name))
continue;
/* Handle <style> elements */
parse_style (parser_state);
}
}
/**
* streamFile:
* @filename: the file name to parse
*
* Parse, validate and print information about an XML file.
*/
static void
streamFile(const char *filename) {
xmlTextReaderPtr reader;
int ret;
/*
* Pass some special parsing options to activate DTD attribute defaulting,
* entities substitution and DTD validation
*/
reader = xmlReaderForFile(filename, NULL,
XML_PARSE_DTDATTR | /* default DTD attributes */
XML_PARSE_NOENT | /* substitute entities */
XML_PARSE_DTDVALID); /* validate with the DTD */
if (reader != NULL) {
ret = xmlTextReaderRead(reader);
while (ret == 1) {
processNode(reader);
ret = xmlTextReaderRead(reader);
}
/*
* Once the document has been fully parsed check the validation results
*/
if (xmlTextReaderIsValid(reader) != 1) {
fprintf(stderr, "Document %s does not validate\n", filename);
}
xmlFreeTextReader(reader);
if (ret != 0) {
fprintf(stderr, "%s : failed to parse\n", filename);
}
} else {
fprintf(stderr, "Unable to open %s\n", filename);
}
}
//-----------------------------------------
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;
}
bool XMLValidationRelaxNG::validate(xmlTextReader * reader, std::string * error) const
{
int last;
int valid;
if (errorBuffer)
{
delete errorBuffer;
}
errorBuffer = new std::string();
xmlTextReaderSetErrorHandler(reader, (xmlTextReaderErrorFunc) XMLValidation::errorReaderFunction, 0);
xmlTextReaderRelaxNGSetSchema(reader, getValidationFile < xmlRelaxNG > ());
while ((last = xmlTextReaderRead(reader)) == 1) ;
valid = xmlTextReaderIsValid(reader);
xmlTextReaderSetErrorHandler(reader, 0, 0);
xmlFreeTextReader(reader);
if (last == -1 || valid != 1)
{
*error = *errorBuffer;
return false;
}
return true;
}
/*
* call-seq:
* reader.valid? -> bool
*
* Retrieve the validity status from the parser context.
*/
static VALUE rxml_reader_valid(VALUE self)
{
return xmlTextReaderIsValid(rxml_text_reader_get(self)) ? Qtrue : Qfalse;
}
/*
* call-seq:
* reader.valid? -> bool
*
* Retrieve the validity status from the parser context.
*/
static VALUE rxml_reader_valid(VALUE self)
{
xmlTextReaderPtr xreader = rxml_text_reader_get(self);
return xmlTextReaderIsValid(xreader) ? Qtrue : Qfalse;
}
int XMIResource::load(const char* uri)
{
int ret;
LibXML2State state;
/*
* Allocate the reader object, this API is used as it is simpler to use than SAX2 :
* * we have direct access to a node object
* * Strings are interned by libxml2
* * partial SAX2 callbacks are not supported by libxml2
*/
xmlTextReaderPtr reader;
/* resolve xinclude and intern strings */
reader = xmlReaderForFile(uri, NULL, XML_PARSE_XINCLUDE | XML_PARSE_COMPACT);
/*
* Intern strings to speedup comparaison, this table can be generated using XPath on xcos.ecore .
*/
constXcosNames[e_Annotation] = xmlTextReaderConstString(reader, BAD_CAST ("Annotation"));
constXcosNames[e_BaseObject] = xmlTextReaderConstString(reader, BAD_CAST ("BaseObject"));
constXcosNames[e_Block] = xmlTextReaderConstString(reader, BAD_CAST ("Block"));
constXcosNames[e_CompiledRepresentation] = xmlTextReaderConstString(reader, BAD_CAST ("CompiledRepresentation"));
constXcosNames[e_Diagram] = xmlTextReaderConstString(reader, BAD_CAST ("Diagram"));
constXcosNames[e_Geometry] = xmlTextReaderConstString(reader, BAD_CAST ("Geometry"));
constXcosNames[e_Layer] = xmlTextReaderConstString(reader, BAD_CAST ("Layer"));
constXcosNames[e_Link] = xmlTextReaderConstString(reader, BAD_CAST ("Link"));
constXcosNames[e_Point] = xmlTextReaderConstString(reader, BAD_CAST ("Point"));
constXcosNames[e_Port] = xmlTextReaderConstString(reader, BAD_CAST ("Port"));
constXcosNames[e_PortKind] = xmlTextReaderConstString(reader, BAD_CAST ("PortKind"));
constXcosNames[e_SimulationConfig] = xmlTextReaderConstString(reader, BAD_CAST ("SimulationConfig"));
constXcosNames[e_absoluteTolerance] = xmlTextReaderConstString(reader, BAD_CAST ("absoluteTolerance"));
constXcosNames[e_base64] = xmlTextReaderConstString(reader, BAD_CAST ("base64"));
constXcosNames[e_blocktype] = xmlTextReaderConstString(reader, BAD_CAST ("blocktype"));
constXcosNames[e_child] = xmlTextReaderConstString(reader, BAD_CAST ("child"));
constXcosNames[e_color] = xmlTextReaderConstString(reader, BAD_CAST ("color"));
constXcosNames[e_connectedSignal] = xmlTextReaderConstString(reader, BAD_CAST ("connectedSignal"));
constXcosNames[e_context] = xmlTextReaderConstString(reader, BAD_CAST ("context"));
constXcosNames[e_controlPoint] = xmlTextReaderConstString(reader, BAD_CAST ("controlPoint"));
constXcosNames[e_datatype] = xmlTextReaderConstString(reader, BAD_CAST ("datatype"));
constXcosNames[e_debugLevel] = xmlTextReaderConstString(reader, BAD_CAST ("debugLevel"));
constXcosNames[e_deltaH] = xmlTextReaderConstString(reader, BAD_CAST ("deltaH"));
constXcosNames[e_deltaT] = xmlTextReaderConstString(reader, BAD_CAST ("deltaT"));
constXcosNames[e_dependsOnT] = xmlTextReaderConstString(reader, BAD_CAST ("dependsOnT"));
constXcosNames[e_dependsOnU] = xmlTextReaderConstString(reader, BAD_CAST ("dependsOnU"));
constXcosNames[e_description] = xmlTextReaderConstString(reader, BAD_CAST ("description"));
constXcosNames[e_destinationPort] = xmlTextReaderConstString(reader, BAD_CAST ("destinationPort"));
constXcosNames[e_dstate] = xmlTextReaderConstString(reader, BAD_CAST ("dstate"));
constXcosNames[e_ein] = xmlTextReaderConstString(reader, BAD_CAST ("ein"));
constXcosNames[e_eout] = xmlTextReaderConstString(reader, BAD_CAST ("eout"));
constXcosNames[e_equations] = xmlTextReaderConstString(reader, BAD_CAST ("equations"));
constXcosNames[e_expression] = xmlTextReaderConstString(reader, BAD_CAST ("expression"));
constXcosNames[e_exprs] = xmlTextReaderConstString(reader, BAD_CAST ("exprs"));
constXcosNames[e_finalTime] = xmlTextReaderConstString(reader, BAD_CAST ("finalTime"));
constXcosNames[e_firing] = xmlTextReaderConstString(reader, BAD_CAST ("firing"));
constXcosNames[e_font] = xmlTextReaderConstString(reader, BAD_CAST ("font"));
constXcosNames[e_fontSize] = xmlTextReaderConstString(reader, BAD_CAST ("fontSize"));
constXcosNames[e_functionAPI] = xmlTextReaderConstString(reader, BAD_CAST ("functionAPI"));
constXcosNames[e_functionName] = xmlTextReaderConstString(reader, BAD_CAST ("functionName"));
constXcosNames[e_geometry] = xmlTextReaderConstString(reader, BAD_CAST ("geometry"));
constXcosNames[e_height] = xmlTextReaderConstString(reader, BAD_CAST ("height"));
constXcosNames[e_implicit] = xmlTextReaderConstString(reader, BAD_CAST ("implicit"));
constXcosNames[e_in] = xmlTextReaderConstString(reader, BAD_CAST ("in"));
constXcosNames[e_interfaceFunction] = xmlTextReaderConstString(reader, BAD_CAST ("interfaceFunction"));
constXcosNames[e_ipar] = xmlTextReaderConstString(reader, BAD_CAST ("ipar"));
constXcosNames[e_kind] = xmlTextReaderConstString(reader, BAD_CAST ("kind"));
constXcosNames[e_label] = xmlTextReaderConstString(reader, BAD_CAST ("label"));
constXcosNames[e_lineHeight] = xmlTextReaderConstString(reader, BAD_CAST ("lineHeight"));
constXcosNames[e_lineWidth] = xmlTextReaderConstString(reader, BAD_CAST ("lineWidth"));
constXcosNames[e_nmode] = xmlTextReaderConstString(reader, BAD_CAST ("nmode"));
constXcosNames[e_nzcross] = xmlTextReaderConstString(reader, BAD_CAST ("nzcross"));
constXcosNames[e_odstate] = xmlTextReaderConstString(reader, BAD_CAST ("odstate"));
constXcosNames[e_opar] = xmlTextReaderConstString(reader, BAD_CAST ("opar"));
constXcosNames[e_out] = xmlTextReaderConstString(reader, BAD_CAST ("out"));
constXcosNames[e_parent] = xmlTextReaderConstString(reader, BAD_CAST ("parent"));
constXcosNames[e_parentDiagram] = xmlTextReaderConstString(reader, BAD_CAST ("parentDiagram"));
constXcosNames[e_path] = xmlTextReaderConstString(reader, BAD_CAST ("path"));
constXcosNames[e_properties] = xmlTextReaderConstString(reader, BAD_CAST ("properties"));
constXcosNames[e_realtimeScale] = xmlTextReaderConstString(reader, BAD_CAST ("realtimeScale"));
constXcosNames[e_relativeTolerance] = xmlTextReaderConstString(reader, BAD_CAST ("relativeTolerance"));
constXcosNames[e_rpar] = xmlTextReaderConstString(reader, BAD_CAST ("rpar"));
constXcosNames[e_solver] = xmlTextReaderConstString(reader, BAD_CAST ("solver"));
constXcosNames[e_sourceBlock] = xmlTextReaderConstString(reader, BAD_CAST ("sourceBlock"));
constXcosNames[e_sourcePort] = xmlTextReaderConstString(reader, BAD_CAST ("sourcePort"));
constXcosNames[e_state] = xmlTextReaderConstString(reader, BAD_CAST ("state"));
constXcosNames[e_style] = xmlTextReaderConstString(reader, BAD_CAST ("style"));
constXcosNames[e_timeTolerance] = xmlTextReaderConstString(reader, BAD_CAST ("timeTolerance"));
constXcosNames[e_title] = xmlTextReaderConstString(reader, BAD_CAST ("title"));
constXcosNames[e_type] = xmlTextReaderConstString(reader, BAD_CAST ("type"));
constXcosNames[e_uid] = xmlTextReaderConstString(reader, BAD_CAST ("uid"));
constXcosNames[e_version] = xmlTextReaderConstString(reader, BAD_CAST ("version"));
constXcosNames[e_width] = xmlTextReaderConstString(reader, BAD_CAST ("width"));
constXcosNames[e_x] = xmlTextReaderConstString(reader, BAD_CAST ("x"));
constXcosNames[e_xcos] = xmlTextReaderConstString(reader, BAD_CAST ("xcos"));
constXcosNames[e_y] = xmlTextReaderConstString(reader, BAD_CAST ("y"));
xcosNamespaceUri = xmlTextReaderConstString(reader, BAD_CAST ("org.scilab.modules.xcos"));
xsiNamespaceUri = xmlTextReaderConstString(reader, BAD_CAST ("http://www.w3.org/2001/XMLSchema-instance"));
unresolved.clear();
/*
* Process the document
*/
if (reader != NULL)
{
ret = xmlTextReaderRead(reader);
while (ret == 1)
{
ret = processNode(reader);
if (ret == 1)
{
ret = xmlTextReaderRead(reader);
}
}
/*
* Once the document has been fully parsed check the validation results
*/
if (xmlTextReaderIsValid(reader) < 0)
{
sciprint("Document %s does not validate\n", uri);
}
xmlFreeTextReader(reader);
if (ret < 0)
{
sciprint("%s : failed to parse\n", uri);
return ret;
}
}
else
{
sciprint("Unable to open %s\n", uri);
return -1;
}
/*
* After loading the XML file, resolve all references
*/
for (const unresolvedReference& ref : unresolved)
{
auto it = references.find(ref.m_uid);
if (it != references.end())
{
controller.setObjectProperty(ref.m_id, ref.m_kind, ref.m_prop, it->second);
}
else
{
sciprint("Unable to resolve %s\n", ref.m_uid.c_str());
return -1;
}
}
return ret;
}
/* reader:is_valid() */
static int xmlreader_is_valid(lua_State *L) {
xmlreader xr = check_xmlreader(L, 1);
int ret = xmlTextReaderIsValid(xr);
BOOL_OR_ERROR(L, ret);
}
static gboolean
file_parse (gchar *filename,
GtkSourceLanguage *language,
GtkSourceContextData *ctx_data,
GHashTable *defined_regexes,
GHashTable *styles,
GHashTable *loaded_lang_ids,
GQueue *replacements,
GError **error)
{
ParserState *parser_state;
xmlTextReader *reader = NULL;
int fd = -1;
GError *tmp_error = NULL;
GtkSourceLanguageManager *lm;
const gchar *rng_lang_schema;
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
DEBUG (g_message ("loading file '%s'", filename));
/*
* Use fd instead of filename so that it's utf8 safe on w32.
*/
fd = g_open (filename, O_RDONLY, 0);
if (fd != -1)
reader = xmlReaderForFd (fd, filename, NULL, 0);
if (reader == NULL)
{
g_set_error (&tmp_error,
PARSER_ERROR,
PARSER_ERROR_CANNOT_OPEN,
"unable to open the file");
goto error;
}
lm = _gtk_source_language_get_language_manager (language);
rng_lang_schema = _gtk_source_language_manager_get_rng_file (lm);
if (rng_lang_schema == NULL)
{
g_set_error (&tmp_error,
PARSER_ERROR,
PARSER_ERROR_CANNOT_VALIDATE,
"could not find the RelaxNG schema file");
goto error;
}
if (xmlTextReaderRelaxNGValidate (reader, rng_lang_schema))
{
g_set_error (&tmp_error,
PARSER_ERROR,
PARSER_ERROR_CANNOT_VALIDATE,
"unable to load the RelaxNG schema '%s'",
rng_lang_schema);
goto error;
}
parser_state = parser_state_new (language, ctx_data,
defined_regexes, styles,
replacements, reader,
filename, loaded_lang_ids);
xmlTextReaderSetStructuredErrorHandler (reader,
(xmlStructuredErrorFunc) text_reader_structured_error_func,
parser_state);
while ((parser_state->error == NULL) &&
(1 == xmlTextReaderRead (parser_state->reader)))
{
int type;
/* FIXME: does xmlTextReaderRead already do it? */
xmlTextReaderIsValid (parser_state->reader);
if (parser_state->error != NULL)
break;
type = xmlTextReaderNodeType (parser_state->reader);
switch (type)
{
case XML_READER_TYPE_ELEMENT:
element_start (parser_state);
break;
case XML_READER_TYPE_END_ELEMENT:
element_end (parser_state);
break;
}
}
if (parser_state->error != NULL)
{
g_propagate_error (&tmp_error, parser_state->error);
parser_state->error = NULL;
}
parser_state_destroy (parser_state);
if (tmp_error != NULL)
goto error;
close (fd);
return TRUE;
error:
if (fd != -1)
close (fd);
g_propagate_error (error, tmp_error);
return FALSE;
}
/**
* 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;
}
