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; }