// 1. name and public must be present
// public and system must be anyURI
internal override int Compile(ValidationEventHandler h, XmlSchema schema)
{
// If this is already compiled this time, simply skip.
if (CompilationId == schema.CompilationId)
return 0;
if(Name == null)
error(h,"Required attribute name must be present");
else if(!XmlSchemaUtil.CheckNCName(this.name))
error(h,"attribute name must be NCName");
else
qualifiedName = new XmlQualifiedName(Name, AncestorSchema.TargetNamespace);
if(Public==null)
error(h,"public must be present");
else if(!XmlSchemaUtil.CheckAnyUri(Public))
error(h,"public must be anyURI");
if(system != null && !XmlSchemaUtil.CheckAnyUri(system))
error(h,"system must be present and of Type anyURI");
XmlSchemaUtil.CompileID(Id,this,schema.IDCollection,h);
return errorCount;
}
public static void AddToTable (XmlSchemaObjectTable table, XmlSchemaObject obj,
XmlQualifiedName qname, ValidationEventHandler h)
{
if (table.Contains (qname)) {
// FIXME: This logic unexpectedly allows
// one redefining item and two or more redefining items.
// FIXME: redefining item is not simple replacement,
// but much more complex stuff.
if (obj.isRedefineChild) { // take precedence.
if (obj.redefinedObject != null)
obj.error (h, String.Format ("Named item {0} was already contained in the schema object table.", qname));
else
obj.redefinedObject = table [qname];
table.Set (qname, obj);
}
else if (table [qname].isRedefineChild) {
if (table [qname].redefinedObject != null)
obj.error (h, String.Format ("Named item {0} was already contained in the schema object table.", qname));
else
table [qname].redefinedObject = obj;
return; // never add to the table.
}
else if (StrictMsCompliant) {
table.Set (qname, obj);
}
else
obj.error (h, String.Format ("Named item {0} was already contained in the schema object table. {1}",
qname, "Consider setting MONO_STRICT_MS_COMPLIANT to 'yes' to mimic MS implementation."));
}
else
table.Set (qname, obj);
}
public Preprocessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings)
: base(nameTable, schemaNames, eventHandler, compilationSettings)
{
_referenceNamespaces = new Hashtable();
_processedExternals = new Hashtable();
_lockList = new SortedList();
}
public static void Validate(
XmlTextReader treader,
ValidationEventHandler validationHandler
)
{
XmlReaderSettings validator = null;
try
{
validator = new XmlReaderSettings();
XmlSchema schema = GetSchema();
validator.Schemas.Add(schema);
validator.ValidationType = ValidationType.Schema;
if (validationHandler!=null)
validator.ValidationEventHandler += validationHandler;
else
validator.ValidationEventHandler += new ValidationEventHandler(ValidationEvent);
XmlReader objXmlReader = XmlReader.Create(treader, validator);
while( objXmlReader.Read() ) {}
}
catch( Exception ex )
{
Console.WriteLine(ex.ToString()) ;
throw ;
}
finally
{
if (validationHandler!=null)
validator.ValidationEventHandler -= validationHandler;
else
validator.ValidationEventHandler -= new ValidationEventHandler(ValidationEvent);
}
}
/// <summary>
/// Parses the xml file into a list of polling venues
/// </summary>
/// <param name="xDocument">The xml file</param>
/// <param name="notifier">Event subscriber if validation of the xml file fails</param>
/// <returns>A list of polling venues</returns>
private List<PollingVenue> LoadVenues(XDocument xDocument, ValidationEventHandler notifier)
{
if (!this.ValidateXmlFile(xDocument, notifier)){
var pollingVenuesElements = from n in xDocument.Descendants("PollingVenue") select n;
List<PollingVenue> pollingVenues = new List<PollingVenue>();
foreach (var xElement in pollingVenuesElements){
Address pollingVenueAddress = new Address{
Name = xElement.Element("Name").Value,
Street = xElement.Element("Street").Value,
City = xElement.Element("City").Value
};
Address municipalityAddress = new Address{
Name = xElement.Parent.Parent.Element("Name").Value,
Street = xElement.Parent.Parent.Element("Street").Value,
City = xElement.Parent.Parent.Element("City").Value
};
PollingVenue pollingVenue = new PollingVenue{
Persons = this.LoadPersons(xElement),
PollingVenueAddress = pollingVenueAddress,
MunicipalityAddress = municipalityAddress
};
pollingVenues.Add(pollingVenue);
}
return pollingVenues;
}
return null;
}
public static WebReferenceOptions Read(XmlReader xmlReader, ValidationEventHandler validationEventHandler)
{
WebReferenceOptions options;
XmlValidatingReader reader = new XmlValidatingReader(xmlReader) {
ValidationType = ValidationType.Schema
};
if (validationEventHandler != null)
{
reader.ValidationEventHandler += validationEventHandler;
}
else
{
reader.ValidationEventHandler += new ValidationEventHandler(WebReferenceOptions.SchemaValidationHandler);
}
reader.Schemas.Add(Schema);
webReferenceOptionsSerializer serializer = new webReferenceOptionsSerializer();
try
{
options = (WebReferenceOptions) serializer.Deserialize(reader);
}
catch (Exception exception)
{
throw exception;
}
finally
{
reader.Close();
}
return options;
}
/// <summary>
/// Reads an XML Schema from the supplied TextReader.
/// </summary>
/// <param name="reader">The TextReader containing the XML Schema to read.</param>
/// <param name="validationEventHandler">The validation event handler that receives information about the XML Schema syntax errors.</param>
/// <returns>The XmlSchema object representing the XML Schema.</returns>
public static new XmlSchema Read(TextReader reader, ValidationEventHandler validationEventHandler)
{
using (XmlReader xr = XmlReader.Create(reader, SafeXmlSchema.defaultSettings))
{
return XmlSchema.Read(xr, validationEventHandler);
}
}
internal override int Compile(ValidationEventHandler h, XmlSchema schema)
{
// If this is already compiled this time, simply skip.
if (CompilationId == schema.CompilationId)
return 0;
XmlSchemaUtil.CompileID(Id, this, schema.IDCollection, h);
CompileOccurence (h, schema);
if (Items.Count == 0)
this.warn (h, "Empty choice is unsatisfiable if minOccurs not equals to 0");
foreach(XmlSchemaObject obj in Items)
{
if(obj is XmlSchemaElement ||
obj is XmlSchemaGroupRef ||
obj is XmlSchemaChoice ||
obj is XmlSchemaSequence ||
obj is XmlSchemaAny)
{
errorCount += obj.Compile(h,schema);
}
else
error(h, "Invalid schema object was specified in the particles of the choice model group.");
}
this.CompilationId = schema.CompilationId;
return errorCount;
}
public override bool CheckValidity(XmlSchemaSet schemas, ValidationEventHandler validationEventHandler)
{
XmlDocument source;
if (this.source.NodeType == XmlNodeType.Document)
{
source = (XmlDocument) this.source;
}
else
{
source = this.source.OwnerDocument;
if (schemas != null)
{
throw new ArgumentException(Res.GetString("XPathDocument_SchemaSetNotAllowed", (object[]) null));
}
}
if ((schemas == null) && (source != null))
{
schemas = source.Schemas;
}
if ((schemas == null) || (schemas.Count == 0))
{
throw new InvalidOperationException(Res.GetString("XmlDocument_NoSchemaInfo"));
}
DocumentSchemaValidator validator = new DocumentSchemaValidator(source, schemas, validationEventHandler) {
PsviAugmentation = false
};
return validator.Validate(this.source);
}
public Boolean Validate()
{
XmlTextReader txtreader = null;
try
{
txtreader = new XmlTextReader(fileName);
XmlDocument doc = new XmlDocument();
doc.Load(txtreader);
ValidationEventHandler eventHandler = new ValidationEventHandler(ValidationEventHandler);
doc.Validate(eventHandler);
}
catch (IOException e)
{
LogBookController.Instance.addLogLine("Error accessing chapter files. Probably doesn't exist. \n" + e, LogMessageCategories.Error);
return false;
}
catch (XmlException e)
{
LogBookController.Instance.addLogLine("Error inside chapters XML file, trying again.\n" + e, LogMessageCategories.Error);
return false;
}
finally
{
txtreader.Close();
}
return true;
}
///<remarks>
/// 1. Content must be present and one of restriction or extention
///</remarks>
internal override int Compile(ValidationEventHandler h, XmlSchema schema)
{
// If this is already compiled this time, simply skip.
if (CompilationId == schema.CompilationId)
return 0;
if(Content == null)
{
error(h, "Content must be present in a simpleContent");
}
else
{
if(Content is XmlSchemaSimpleContentRestriction)
{
XmlSchemaSimpleContentRestriction xscr = (XmlSchemaSimpleContentRestriction) Content;
errorCount += xscr.Compile(h, schema);
}
else if(Content is XmlSchemaSimpleContentExtension)
{
XmlSchemaSimpleContentExtension xsce = (XmlSchemaSimpleContentExtension) Content;
errorCount += xsce.Compile(h, schema);
}
else
error(h,"simpleContent can't have any value other than restriction or extention");
}
XmlSchemaUtil.CompileID(Id,this, schema.IDCollection,h);
this.CompilationId = schema.CompilationId;
return errorCount;
}
: this(nameTable, schemaNames, eventHandler, new XmlSchemaCompilationSettings()) {} //Use the default for XmlSchemaCollection
public BaseProcessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings) {
Debug.Assert(nameTable != null);
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.eventHandler = eventHandler;
this.compilationSettings = compilationSettings;
NsXml = nameTable.Add(XmlReservedNs.NsXml);
}
/// <summary>
/// Initializes the type generator
/// </summary>
/// <param name="useXmlSerializerImporter">if set to <c>true</c> [use XML serializer importer].</param>
/// <param name="targetNamespace">The target namespace.</param>
public XmlSchemaTypeGenerator(bool useXmlSerializerImporter, string targetNamespace)
{
Guard.ArgumentNotNull(targetNamespace, "targetNamespace");
this.validationEventHandler = new ValidationEventHandler(OnSchemasValidation);
this.useXmlSerializerImporter = useXmlSerializerImporter;
this.targetNamespace = targetNamespace;
}
public static WebReferenceOptions Read(TextReader reader, ValidationEventHandler validationEventHandler)
{
XmlTextReader xmlReader = new XmlTextReader(reader) {
XmlResolver = null,
DtdProcessing = DtdProcessing.Prohibit
};
return Read(xmlReader, validationEventHandler);
}
public BaseProcessor(XmlNameTable nameTable, System.Xml.Schema.SchemaNames schemaNames, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings)
{
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.eventHandler = eventHandler;
this.compilationSettings = compilationSettings;
this.NsXml = nameTable.Add("http://www.w3.org/XML/1998/namespace");
}
/// <summary>
/// Validate gbxml file against the 6.01 schema XSD
/// </summary>
private void ValidategbXML_601()
{
XmlDocument xml = new XmlDocument();
xml.Load(@"data/TestgbXML.xml");
xml.Schemas.Add(null, @"data/GreenBuildingXML_Ver6.01.xsd");
ValidationEventHandler eventHandler = new ValidationEventHandler(ValidationEventHandler);
xml.Validate(eventHandler);
}
internal override int Compile(ValidationEventHandler h, XmlSchema schema)
{
// If this is already compiled this time, simply skip.
if (CompilationId == schema.CompilationId)
return 0;
this.CompilationId = schema.CompilationId;
return 0;
}
static XmlReader CreateValidatingReader(Stream stream, XmlSchemaSet schemas, ValidationEventHandler eventHandler)
{
XmlReaderSettings settings = new XmlReaderSettings();
settings.Schemas.Add(schemas);
settings.ValidationType = ValidationType.Schema;
if (eventHandler != null)
settings.ValidationEventHandler += eventHandler;
return XmlReader.Create(stream, settings);
}
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) {
this.schemaType = schemaType;
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.eventHandler = eventHandler;
this.xmlResolver = System.Xml.XmlConfiguration.XmlReaderSection.CreateDefaultResolver();
processMarkup = true;
dummyDocument = new XmlDocument();
}
public static void ValidateXmlDoc(System.Xml.XmlDocument xmlDocument, string[] sSchemaFiles)
{
foreach (string sSchema in sSchemaFiles)
{
xmlDocument.Schemas.Add(null, sSchema);
}
System.Xml.Schema.ValidationEventHandler validationHandler = new ValidationEventHandler(ValidationEvent);
xmlDocument.Validate(validationHandler);
}
/// <summary>
/// Can you load this xml file, and parse it to a list of polling venues?
/// </summary>
/// <param name="path">The path of the file</param>
/// <param name="notifier">Event subscriber if validation of the xml file fails</param>
/// <returns>A list of polling venues</returns>
public List<PollingVenue> GetPollingVenues(string path, ValidationEventHandler notifier)
{
Contract.Requires(path != null);
Contract.Requires(notifier != null);
Contract.Requires(File.Exists(path));
Contract.Requires(Path.GetExtension(path).Equals(".xml"));
return this.LoadVenues(XDocument.Load(path), notifier);
}
static XmlReader CreateValidatingReader (Stream stream, XmlSchemaCollection schemas, ValidationEventHandler eventHandler)
{
XmlValidatingReader reader = new XmlValidatingReader (new XmlTextReader (stream));
reader.Schemas.Add (schemas);
reader.ValidationType = ValidationType.Schema;
if (eventHandler != null)
reader.ValidationEventHandler += eventHandler;
return reader;
}
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) {
this.schemaType = schemaType;
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.eventHandler = eventHandler;
this.xmlResolver = new XmlUrlResolver();
processMarkup = true;
dummyDocument = new XmlDocument();
}
public BaseValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, ValidationEventHandler eventHandler) {
Debug.Assert(schemaCollection == null || schemaCollection.NameTable == reader.NameTable);
this.reader = reader;
this.schemaCollection = schemaCollection;
this.eventHandler = eventHandler;
nameTable = reader.NameTable;
positionInfo = PositionInfo.GetPositionInfo(reader);
elementName = new XmlQualifiedName();
}
//<documentation
// source = anyURI
// xml:lang = language>
// Content: ({any})*
//</documentation>
internal static XmlSchemaDocumentation Read(XmlSchemaReader reader, ValidationEventHandler h, out bool skip)
{
skip = false;
XmlSchemaDocumentation doc = new XmlSchemaDocumentation();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != "documentation")
{
error(h,"Should not happen :1: XmlSchemaDocumentation.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
doc.LineNumber = reader.LineNumber;
doc.LinePosition = reader.LinePosition;
doc.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "source")
{
doc.source = reader.Value;
}
else if(reader.Name == "xml:lang")
{
doc.language = reader.Value;
}
else
{
error(h,reader.Name + " is not a valid attribute for documentation",null);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement) {
doc.Markup = new XmlNode[0];
return doc;
}
//Content {any}*
XmlDocument xmldoc = new XmlDocument();
xmldoc.AppendChild(xmldoc.ReadNode(reader));
XmlNode root = xmldoc.FirstChild;
if(root != null && root.ChildNodes != null)
{
doc.Markup = new XmlNode[root.ChildNodes.Count];
for(int i=0;i<root.ChildNodes.Count;i++)
{
doc.Markup[i] = root.ChildNodes[i];
}
}
if(reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.EndElement)
skip = true;
return doc;
}
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler)
{
_schemaType = schemaType;
_nameTable = nameTable;
_schemaNames = schemaNames;
_eventHandler = eventHandler;
_xmlResolver = null;
_processMarkup = true;
_dummyDocument = new XmlDocument();
}
public XmlSchemaReader(XmlReader reader,ValidationEventHandler handler)
{
this.reader = reader;
this.handler = handler;
if(reader is IXmlLineInfo)
{
IXmlLineInfo info = (IXmlLineInfo)reader;
hasLineInfo = info.HasLineInfo();
}
}
public BaseValidator(BaseValidator other) {
reader = other.reader;
schemaCollection = other.schemaCollection;
eventHandler = other.eventHandler;
nameTable = other.nameTable;
schemaNames = other.schemaNames;
positionInfo = other.positionInfo;
xmlResolver = other.xmlResolver;
baseUri = other.baseUri;
elementName = other.elementName;
}
public void Compile (string nss,
ValidationEventHandler h, XmlSchema schema)
{
if (SkipCompile)
return; // used by XmlSchemaAny.AnyTypeContent.
Reset ();
int nscount = 0;
string actualNamespace = nss == null ? "##any" : nss;
string[] nslist = XmlSchemaUtil.SplitList(actualNamespace);
for (int i = 0; i < nslist.Length; i++) {
string ns = nslist [i];
switch(ns) {
case "##any":
if (HasValueAny)
xsobj.error (h, "Multiple specification of ##any was found.");
nscount |= 1;
HasValueAny = true;
break;
case "##other":
if (HasValueOther)
xsobj.error (h, "Multiple specification of ##other was found.");
nscount |= 2;
HasValueOther = true;
break;
case "##targetNamespace":
if (HasValueTargetNamespace)
xsobj.error (h, "Multiple specification of ##targetNamespace was found.");
nscount |= 4;
HasValueTargetNamespace = true;
break;
case "##local":
if (HasValueLocal)
xsobj.error (h, "Multiple specification of ##local was found.");
nscount |= 8;
HasValueLocal = true;
break;
default:
if(!XmlSchemaUtil.CheckAnyUri(ns))
xsobj.error(h,"the namespace is not a valid anyURI");
else if (ResolvedNamespaces.Contains (ns))
xsobj.error (h, "Multiple specification of '" + ns + "' was found.");
else {
nscount |= 16;
ResolvedNamespaces.Add (ns);
}
break;
}
}
if((nscount&1) == 1 && nscount != 1)
xsobj.error (h, "##any if present must be the only namespace attribute");
if((nscount&2) == 2 && nscount != 2)
xsobj.error (h, "##other if present must be the only namespace attribute");
}
/// <remarks>
/// 1. name must be present
/// 2. selector and field must be present
/// 3. refer must be present
/// </remarks>
internal override int Compile(ValidationEventHandler h, XmlSchema schema)
{
base.Compile(h, schema);
if(refer == null || refer.IsEmpty)
error(h,"refer must be present");
else if(!XmlSchemaUtil.CheckQName(refer))
error(h,"Refer is not a valid XmlQualifiedName");
return errorCount;
}
public void Compile(ValidationEventHandler validationEventHandler, System.Xml.XmlResolver resolver)
{
}
internal override void CheckRecursion(Stack stack,
ValidationEventHandler h, XmlSchema schema)
{
// do nothing
}
/// <include file='doc\XmlSchemas.uex' path='docs/doc[@for="XmlSchemas.Compile"]/*' />
public void Compile(ValidationEventHandler handler, bool fullCompile)
{
if (isCompiled)
{
return;
}
foreach (XmlSchema s in delayedSchemas.Values)
{
Merge(s);
}
delayedSchemas.Clear();
if (fullCompile)
{
schemaSet = new XmlSchemaSet();
schemaSet.XmlResolver = null;
schemaSet.ValidationEventHandler += handler;
foreach (XmlSchema s in References.Values)
{
schemaSet.Add(s);
}
int schemaCount = schemaSet.Count;
foreach (XmlSchema s in List)
{
if (!SchemaSet.Contains(s))
{
schemaSet.Add(s);
schemaCount++;
}
}
if (!SchemaSet.Contains(XmlSchema.Namespace))
{
AddReference(XsdSchema);
schemaSet.Add(XsdSchema);
schemaCount++;
}
if (!SchemaSet.Contains(XmlReservedNs.NsXml))
{
AddReference(XmlSchema);
schemaSet.Add(XmlSchema);
schemaCount++;
}
schemaSet.Compile();
schemaSet.ValidationEventHandler -= handler;
isCompiled = schemaSet.IsCompiled && schemaCount == schemaSet.Count;
}
else
{
try {
XmlNameTable nameTable = new System.Xml.NameTable();
Preprocessor prep = new Preprocessor(nameTable, new SchemaNames(nameTable), null);
prep.XmlResolver = null;
prep.SchemaLocations = new Hashtable();
prep.ChameleonSchemas = new Hashtable();
foreach (XmlSchema schema in SchemaSet.Schemas())
{
prep.Execute(schema, schema.TargetNamespace, true);
}
}
catch (XmlSchemaException e) {
throw CreateValidationException(e, e.Message);
}
}
}
/// <summary>
/// Loads the RSS feedlist from the given URL and validates it against the schema.
/// </summary>
/// <param name="feedListUrl">The URL of the feedlist</param>
/// <param name="veh">The event handler that should be invoked on the client if validation errors occur</param>
/// <exception cref="XmlException">XmlException thrown if XML is not well-formed</exception>
private void LoadFeedlist(string feedListUrl, ValidationEventHandler veh)
{
LoadFeedlist(SyncWebRequest.GetResponseStream(feedListUrl, null, UserAgent, Proxy), veh);
SearchHandler.CheckIndex();
}
//<fractionDigits
// fixed = boolean : false
// id = ID
// value = nonNegativeInteger
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</fractionDigits>
internal static XmlSchemaFractionDigitsFacet Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaFractionDigitsFacet fraction = new XmlSchemaFractionDigitsFacet();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaFractionDigitsFacet.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
fraction.LineNumber = reader.LineNumber;
fraction.LinePosition = reader.LinePosition;
fraction.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
fraction.Id = reader.Value;
}
else if (reader.Name == "fixed")
{
Exception innerex;
fraction.IsFixed = XmlSchemaUtil.ReadBoolAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for fixed attribute", innerex);
}
}
else if (reader.Name == "value")
{
fraction.Value = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for " + xmlname, null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, fraction);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(fraction);
}
// Content: (annotation?)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaFractionDigitsFacet.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
fraction.Annotation = annotation;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(fraction);
}
internal bool ValidateSeqRecurseMapSumCommon(XmlSchemaGroupBase baseGroup,
ValidationEventHandler h, XmlSchema schema, bool isLax, bool isMapAndSum, bool raiseError)
{
int index = 0;
int baseIndex = 0;
decimal baseOccured = 0;
if (baseGroup.CompiledItems.Count == 0 && this.CompiledItems.Count > 0)
{
if (raiseError)
{
error(h, "Invalid particle derivation by restriction was found. base particle does not contain particles.");
}
return(false);
}
for (int i = 0; i < CompiledItems.Count; i++)
{
// get non-empty derived particle
XmlSchemaParticle pd = null;
while (this.CompiledItems.Count > index)
{
pd = ((XmlSchemaParticle)this.CompiledItems [index]); //.GetOptimizedParticle (false);
if (pd != XmlSchemaParticle.Empty) // && pd.ValidatedMaxOccurs > 0)
{
break;
}
else
{
index++;
}
}
if (index >= CompiledItems.Count)
{
if (raiseError)
{
error(h, "Invalid particle derivation by restriction was found. Cannot be mapped to base particle.");
}
return(false);
}
// get non-empty base particle
XmlSchemaParticle pb = null;
while (baseGroup.CompiledItems.Count > baseIndex)
{
pb = ((XmlSchemaParticle)baseGroup.CompiledItems [baseIndex]);//.GetOptimizedParticle (false);
if (pb == XmlSchemaParticle.Empty && pb.ValidatedMaxOccurs > 0)
{
continue;
}
if (!pd.ValidateDerivationByRestriction(pb, h, schema, false))
{
if (!isLax && !isMapAndSum && pb.MinOccurs > baseOccured && !pb.ValidateIsEmptiable())
{
if (raiseError)
{
error(h, "Invalid particle derivation by restriction was found. Invalid sub-particle derivation was found.");
}
return(false);
}
else
{
baseOccured = 0;
baseIndex++;
}
}
else
{
baseOccured += pb.ValidatedMinOccurs;
if (baseOccured >= baseGroup.ValidatedMaxOccurs)
{
baseOccured = 0;
baseIndex++;
}
index++;
break;
}
}
}
if (this.CompiledItems.Count > 0 && index != this.CompiledItems.Count)
{
if (raiseError)
{
error(h, "Invalid particle derivation by restriction was found. Extraneous derived particle was found.");
}
return(false);
}
if (!isLax && !isMapAndSum)
{
if (baseOccured > 0)
{
baseIndex++;
}
for (int i = baseIndex; i < baseGroup.CompiledItems.Count; i++)
{
XmlSchemaParticle p = baseGroup.CompiledItems [i] as XmlSchemaParticle;
if (!p.ValidateIsEmptiable())
{
if (raiseError)
{
error(h, "Invalid particle derivation by restriction was found. There is a base particle which does not have mapped derived particle and is not emptiable.");
}
return(false);
}
}
}
return(true);
}
internal static XmlSchemaRedefine Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaRedefine xmlSchemaRedefine = new XmlSchemaRedefine();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "redefine")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaRedefine.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
xmlSchemaRedefine.LineNumber = reader.LineNumber;
xmlSchemaRedefine.LinePosition = reader.LinePosition;
xmlSchemaRedefine.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
xmlSchemaRedefine.Id = reader.Value;
}
else if (reader.Name == "schemaLocation")
{
xmlSchemaRedefine.SchemaLocation = reader.Value;
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for redefine", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaRedefine);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaRedefine);
}
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "redefine")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaRedefine.Read, name=" + reader.Name, null);
}
break;
}
if (reader.LocalName == "annotation")
{
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaRedefine.items.Add(xmlSchemaAnnotation);
}
}
else if (reader.LocalName == "simpleType")
{
XmlSchemaSimpleType xmlSchemaSimpleType = XmlSchemaSimpleType.Read(reader, h);
if (xmlSchemaSimpleType != null)
{
xmlSchemaRedefine.items.Add(xmlSchemaSimpleType);
}
}
else if (reader.LocalName == "complexType")
{
XmlSchemaComplexType xmlSchemaComplexType = XmlSchemaComplexType.Read(reader, h);
if (xmlSchemaComplexType != null)
{
xmlSchemaRedefine.items.Add(xmlSchemaComplexType);
}
}
else if (reader.LocalName == "group")
{
XmlSchemaGroup xmlSchemaGroup = XmlSchemaGroup.Read(reader, h);
if (xmlSchemaGroup != null)
{
xmlSchemaRedefine.items.Add(xmlSchemaGroup);
}
}
else if (reader.LocalName == "attributeGroup")
{
XmlSchemaAttributeGroup xmlSchemaAttributeGroup = XmlSchemaAttributeGroup.Read(reader, h);
if (xmlSchemaAttributeGroup != null)
{
xmlSchemaRedefine.items.Add(xmlSchemaAttributeGroup);
}
}
else
{
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaRedefine);
}
public static void Validate(this XElement source, XmlSchemaObject partialValidationType, XmlSchemaSet schemas, ValidationEventHandler validationEventHandler, bool addSchemaInfo)
{
throw new NotImplementedException();
}
public static void Validate(this XAttribute source, XmlSchemaObject partialValidationType, XmlSchemaSet schemas, ValidationEventHandler validationEventHandler)
{
Validate(source, partialValidationType, schemas, validationEventHandler, false);
}
/// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Read1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public static XmlSchema Read(Stream stream, ValidationEventHandler validationEventHandler)
{
return(Read(new XmlTextReader(stream), validationEventHandler));
}
//<complexContent
// id = ID
// mixed = boolean
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (restriction | extension))
//</complexContent>
internal static XmlSchemaComplexContent Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaComplexContent complex = new XmlSchemaComplexContent();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaComplexContent.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
complex.LineNumber = reader.LineNumber;
complex.LinePosition = reader.LinePosition;
complex.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
complex.Id = reader.Value;
}
else if (reader.Name == "mixed")
{
Exception innerex;
complex.isMixed = XmlSchemaUtil.ReadBoolAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is an invalid value for mixed", innerex);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for complexContent", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, complex);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(complex);
}
//Content: (annotation?, (restriction | extension))
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaComplexContent.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
complex.Annotation = annotation;
}
continue;
}
if (level <= 2)
{
if (reader.LocalName == "restriction")
{
level = 3;
XmlSchemaComplexContentRestriction restriction = XmlSchemaComplexContentRestriction.Read(reader, h);
if (restriction != null)
{
complex.content = restriction;
}
continue;
}
if (reader.LocalName == "extension")
{
level = 3;
XmlSchemaComplexContentExtension extension = XmlSchemaComplexContentExtension.Read(reader, h);
if (extension != null)
{
complex.content = extension;
}
continue;
}
}
reader.RaiseInvalidElementError();
}
return(complex);
}
/// <include file='doc\XmlSchema.uex' path='docs/doc[@for="XmlSchema.Read"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public static XmlSchema Read(TextReader reader, ValidationEventHandler validationEventHandler)
{
return(Read(new XmlTextReader(reader), validationEventHandler));
}
#pragma warning disable 618
internal bool CompileSchema(XmlSchemaCollection xsc, XmlResolver resolver, SchemaInfo schemaInfo, string ns, ValidationEventHandler validationEventHandler, XmlNameTable nameTable, bool CompileContentModel)
{
//Need to lock here to prevent multi-threading problems when same schema is added to set and compiled
lock (this)
{
//Preprocessing
SchemaCollectionPreprocessor prep = new SchemaCollectionPreprocessor(nameTable, null, validationEventHandler);
prep.XmlResolver = resolver;
if (!prep.Execute(this, ns, true, xsc))
{
return(false);
}
//Compilation
SchemaCollectionCompiler compiler = new SchemaCollectionCompiler(nameTable, validationEventHandler);
_isCompiled = compiler.Execute(this, schemaInfo, CompileContentModel);
this.SetIsCompiled(_isCompiled);
return(_isCompiled);
}
}
/*
* internal new void error(ValidationEventHandler handle, string message)
* {
* errorCount++;
* ValidationHandler.RaiseValidationError(handle, this, message);
* }
*/
//<key
// id = ID
// name = NCName
// refer = QName
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (selector, field+))
//</key>
internal static XmlSchemaKeyref Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaKeyref keyref = new XmlSchemaKeyref();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaKeyref.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
keyref.LineNumber = reader.LineNumber;
keyref.LinePosition = reader.LinePosition;
keyref.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
keyref.Id = reader.Value;
}
else if (reader.Name == "name")
{
keyref.Name = reader.Value;
}
else if (reader.Name == "refer")
{
Exception innerex;
keyref.refer = XmlSchemaUtil.ReadQNameAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for refer attribute", innerex);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for keyref", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, keyref);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(keyref);
}
// Content: annotation?, selector, field+
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaKeyref.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
keyref.Annotation = annotation;
}
continue;
}
if (level <= 2 && reader.LocalName == "selector")
{
level = 3;
XmlSchemaXPath selector = XmlSchemaXPath.Read(reader, h, "selector");
if (selector != null)
{
keyref.Selector = selector;
}
continue;
}
if (level <= 3 && reader.LocalName == "field")
{
level = 3;
if (keyref.Selector == null)
{
error(h, "selector must be defined before field declarations", null);
}
XmlSchemaXPath field = XmlSchemaXPath.Read(reader, h, "field");
if (field != null)
{
keyref.Fields.Add(field);
}
continue;
}
reader.RaiseInvalidElementError();
}
return(keyref);
}
public void Compile(ValidationEventHandler validationEventHandler)
{
}
public static void Validate(this XAttribute source, XmlSchemaObject partialValidationType, XmlSchemaSet schemas, ValidationEventHandler validationEventHandler, bool addSchemaInfo)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (schemas == null)
{
throw new ArgumentNullException("schemas");
}
var nsmgr = new XmlNamespaceManager(new NameTable());
var v = new XmlSchemaValidator(nsmgr.NameTable, schemas, nsmgr, XmlSchemaValidationFlags.None);
if (validationEventHandler != null)
{
v.ValidationEventHandler += validationEventHandler;
}
if (partialValidationType != null)
{
v.Initialize(partialValidationType);
}
else
{
v.Initialize();
}
var xi = addSchemaInfo ? new XmlSchemaInfo() : null;
v.ValidateAttribute(source.Name.LocalName, source.Name.NamespaceName, source.Value, xi);
}
public static XmlSchema Read(System.IO.Stream stream, ValidationEventHandler validationEventHandler)
{
}
public static void Validate(this XDocument source, XmlSchemaSet schemas, ValidationEventHandler validationEventHandler)
{
Validate(source, schemas, validationEventHandler, false);
}
internal bool ValidateRecurse(XmlSchemaGroupBase baseGroup,
ValidationEventHandler h, XmlSchema schema, bool raiseError)
{
return(ValidateSeqRecurseMapSumCommon(baseGroup, h, schema, false, false, raiseError));
}
// <group
// id = ID
// ref = QName
// minOccurs = ? : 1
// maxOccurs = ? : 1>
// Content: (annotation?)
// </group>
internal static XmlSchemaGroupRef Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaGroupRef groupref = new XmlSchemaGroupRef();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaGroup.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
groupref.LineNumber = reader.LineNumber;
groupref.LinePosition = reader.LinePosition;
groupref.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
groupref.Id = reader.Value;
}
else if (reader.Name == "ref")
{
Exception innerex;
groupref.refName = XmlSchemaUtil.ReadQNameAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for ref attribute", innerex);
}
}
else if (reader.Name == "maxOccurs")
{
try
{
groupref.MaxOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for maxOccurs", e);
}
}
else if (reader.Name == "minOccurs")
{
try
{
groupref.MinOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for minOccurs", e);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for group", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, groupref);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(groupref);
}
// Content: (annotation?)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaGroupRef.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
groupref.Annotation = annotation;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(groupref);
}
/// <summary>
/// Loads the RSS feedlist from the given URL and validates it against the schema.
/// </summary>
/// <param name="xmlStream">The XML Stream of a feedlist to load</param>
/// <param name="veh">The event handler that should be invoked on the client if validation errors occur. NOT USED.</param>
/// <exception cref="XmlException">XmlException thrown if XML is not well-formed</exception>
private void LoadFeedlist(Stream xmlStream, ValidationEventHandler veh)
{
var context =
new XmlParserContext(null, new RssBanditXmlNamespaceResolver(), null, XmlSpace.None);
XmlReader reader = new RssBanditXmlReader(xmlStream, XmlNodeType.Document, context);
validationErrorOccured = false;
//convert XML to objects
XmlSerializer serializer = XmlHelper.SerializerCache.GetSerializer(typeof(feeds));
var myFeeds = (feeds)serializer.Deserialize(reader);
reader.Close();
// reset migration properties dictionary:
MigrationProperties.Clear();
//copy over category info if we are importing a new feed
if (myFeeds.categories != null)
{
foreach (var cat in myFeeds.categories)
{
string cat_trimmed = cat.Value.Trim();
if (!categories.ContainsKey(cat_trimmed))
{
cat.Value = cat_trimmed;
categories.Add(cat_trimmed, cat);
}
}
}
//copy feeds over if we are importing a new feed
if (myFeeds.feed != null)
{
foreach (var f in myFeeds.feed)
{
if (feedsTable.ContainsKey(f.link) == false)
{
Uri uri;
if (Uri.TryCreate(f.link, UriKind.Absolute, out uri))
{
// CLR 2.0 Uri does not like "news:" scheme, so we
// switch it to "nntp:" (see http://msdn2.microsoft.com/en-us/library/system.uri.scheme.aspx)
if (NntpWebRequest.NewsUriScheme.Equals(uri.Scheme))
{
f.link = NntpWebRequest.NntpUriScheme +
uri.CanonicalizedUri().Substring(uri.Scheme.Length);
}
else
{
f.link = uri.CanonicalizedUri();
}
}
else
{
// bad uri:
continue;
}
// test again: we may have changed to Uri above:
if (feedsTable.ContainsKey(f.link) == false)
{
f.owner = this;
feedsTable.Add(f.link, f);
//add category if needed
if (f.category != null)
{
string cat_trimmed = f.category = f.category.Trim();
if (!categories.ContainsKey(cat_trimmed))
{
AddCategory(cat_trimmed);
}
}
}
}
}
}
////copy over layout info if we are importing a new feed
//if (myFeeds.listviewLayouts != null)
//{
// foreach (var layout in myFeeds.listviewLayouts)
// {
// string layout_trimmed = layout.ID.Trim();
// if (!layouts.ContainsKey(layout_trimmed))
// {
// layouts.Add(layout_trimmed, layout.FeedColumnLayout);
// }
// }
//}
/*
* props. set by configuration/static, but required for migration:
*/
if (MigrateProperties)
{
//copy user-identities over if we are migrating
if (myFeeds.identities != null)
{
MigrationProperties.Add("UserIdentity", myFeeds.identities);
}
//copy nntp-server defs. over if we are migrating
if (myFeeds.nntpservers != null)
{
foreach (var sd in myFeeds.nntpservers)
{
// using the public property will initiate a load:
if (NntpServers.ContainsKey(sd.Name) == false)
{
NntpServers.Add(sd.Name, sd);
}
}
}
//if refresh rate in imported feed then use that
if (myFeeds.refreshrateSpecified)
{
MigrationProperties.Add("RefreshRate", myFeeds.refreshrate);
}
//if stylesheet specified in imported feed then use that
if (!string.IsNullOrEmpty(myFeeds.stylesheet))
{
MigrationProperties.Add("Stylesheet", myFeeds.stylesheet);
//this.stylesheet = myFeeds.stylesheet;
}
//if download enclosures specified in imported feed then use that
if (myFeeds.downloadenclosuresSpecified)
{
MigrationProperties.Add("DownloadEnclosures", myFeeds.downloadenclosures);
}
//if maximum enclosure cache size specified in imported feed then use that
if (myFeeds.enclosurecachesizeSpecified)
{
MigrationProperties.Add("EnclosureCacheSize", myFeeds.enclosurecachesize);
//this.enclosurecachesize = myFeeds.enclosurecachesize;
}
//if maximum number of enclosures to download on a new feed specified in imported feed then use that
if (myFeeds.numtodownloadonnewfeedSpecified)
{
MigrationProperties.Add("NumEnclosuresToDownloadOnNewFeed", myFeeds.numtodownloadonnewfeed);
//this.numtodownloadonnewfeed = myFeeds.numtodownloadonnewfeed;
}
//if cause alert on enclosures specified in imported feed then use that
if (myFeeds.enclosurealertSpecified)
{
MigrationProperties.Add("EnclosureAlert", myFeeds.enclosurealert);
//this.enclosurealert = myFeeds.enclosurealert;
}
//if create subfolders for enclosures specified in imported feed then use that
if (myFeeds.createsubfoldersforenclosuresSpecified)
{
MigrationProperties.Add("CreateSubfoldersForEnclosures", myFeeds.createsubfoldersforenclosures);
//this.createsubfoldersforenclosures = myFeeds.createsubfoldersforenclosures;
}
//if marking items as read on exit specified in imported feed then use that
if (myFeeds.markitemsreadonexitSpecified)
{
MigrationProperties.Add("MarkItemsReadOnExit", myFeeds.markitemsreadonexit);
//this.markitemsreadonexit = myFeeds.markitemsreadonexit;
}
//if enclosure folder specified in imported feed then use that
if (!string.IsNullOrEmpty(myFeeds.enclosurefolder))
{
MigrationProperties.Add("EnclosureFolder", myFeeds.enclosurefolder);
}
//if podcast folder specified in imported feed then use that
if (!string.IsNullOrEmpty(myFeeds.podcastfolder))
{
MigrationProperties.Add("PodcastFolder", myFeeds.podcastfolder);
}
//if podcast file extensions specified in imported feed then use that
if (!string.IsNullOrEmpty(myFeeds.podcastfileexts))
{
MigrationProperties.Add("PodcastFileExtensions", myFeeds.podcastfileexts);
}
////if listview layout specified in imported feed then use that
//if (!string.IsNullOrEmpty(myFeeds.listviewlayout))
//{
// FeedColumnLayout = myFeeds.listviewlayout;
//}
//if max item age in imported feed then use that
try
{
if (!string.IsNullOrEmpty(myFeeds.maxitemage))
{
MigrationProperties.Add("MaxItemAge", myFeeds.maxitemage);
//this.maxitemage = XmlConvert.ToTimeSpan(myFeeds.maxitemage);
}
}
catch (FormatException fe)
{
Trace("Error occured while parsing maximum item age from feed list: {0}", fe.ToDescriptiveString());
}
} //if(FeedSource.MigrateProperties){
}
internal override void ValidateUniqueTypeAttribution(XmlSchemaObjectTable labels,
ValidationEventHandler h, XmlSchema schema)
{
// do nothing
}
internal XmlReader Validate(XmlReader reader, XmlResolver resolver, XmlSchemaSet schemaSet, ValidationEventHandler valEventHandler)
{
if (schemaSet != null)
{
XmlReaderSettings readerSettings = new XmlReaderSettings();
readerSettings.ValidationType = ValidationType.Schema;
readerSettings.Schemas = schemaSet;
readerSettings.ValidationEventHandler += valEventHandler;
return(new XsdValidatingReader(reader, resolver, readerSettings, this));
}
return(null);
}
protected static void ProcessEntity(System.Xml.Schema.SchemaInfo sinfo, string name, object sender, ValidationEventHandler eventhandler, string baseUri, int lineNumber, int linePosition)
{
SchemaEntity entity;
XmlSchemaException ex = null;
if (!sinfo.GeneralEntities.TryGetValue(new XmlQualifiedName(name), out entity))
{
ex = new XmlSchemaException("Sch_UndeclaredEntity", name, baseUri, lineNumber, linePosition);
}
else if (entity.NData.IsEmpty)
{
ex = new XmlSchemaException("Sch_UnparsedEntityRef", name, baseUri, lineNumber, linePosition);
}
if (ex != null)
{
if (eventhandler == null)
{
throw ex;
}
eventhandler(sender, new ValidationEventArgs(ex));
}
}
public static int Main(string[] args)
{
ThisAssembly = Assembly.GetExecutingAssembly();
XmlSchemaSet set = new XmlSchemaSet();
ValidationEventHandler veh = new ValidationEventHandler(ValidationCallback);
set.ValidationEventHandler += veh;
string csFileName = string.Empty;
string configFileName = null;
string assemblyName = string.Empty;
bool fSourceNameProvided = false;
bool xmlSerializable = false;
bool nameMangler2 = false;
if (args.Length == 0)
{
PrintHelp();
return(0);
}
for (int i = 0; i < args.Length; i++)
{
string arg = args[i];
string value = string.Empty;
bool argument = false;
if (arg.StartsWith("/") || arg.StartsWith("-"))
{
argument = true;
int colonPos = arg.IndexOf(":");
if (colonPos != -1)
{
value = arg.Substring(colonPos + 1);
arg = arg.Substring(0, colonPos);
}
}
arg = arg.ToLower(CultureInfo.InvariantCulture);
if (!argument)
{
try
{
set.Add(null, CreateReader(arg));
}
catch (Exception e) {
PrintErrorMessage(e.ToString());
return(1);
}
if (csFileName == string.Empty)
{
csFileName = Path.ChangeExtension(arg, "cs");
}
}
else if (ArgumentMatch(arg, "?") || ArgumentMatch(arg, "help"))
{
PrintHelp();
return(0);
}
else if (ArgumentMatch(arg, "config"))
{
configFileName = value;
}
else if (ArgumentMatch(arg, "filename"))
{
csFileName = value;
fSourceNameProvided = true;
}
else if (ArgumentMatch(arg, "enableservicereference"))
{
xmlSerializable = true;
}
else if (ArgumentMatch(arg, "lib"))
{
assemblyName = value;
}
else if (ArgumentMatch(arg, "namemangler2"))
{
nameMangler2 = true;
}
}
if (assemblyName != string.Empty && !fSourceNameProvided)
{
//only generate assembly
csFileName = string.Empty;
}
set.Compile();
set.ValidationEventHandler -= veh;
if (set.Count > 0 && set.IsCompiled)
{
/*
* GenerateXObjects(
* set, csFileName, configFileName, assemblyName, xmlSerializable, nameMangler2);
*/
try
{
GenerateXObjects(
set, csFileName, configFileName, assemblyName, xmlSerializable, nameMangler2);
}
catch (Exception e)
{
PrintErrorMessage(e.ToString());
return(1);
}
}
return(0);
}
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler)
{
_schemaType = schemaType;
_nameTable = nameTable;
_schemaNames = schemaNames;
_eventHandler = eventHandler;
_xmlResolver = null;
_processMarkup = true;
_dummyDocument = new XmlDocument();
}
internal override void ValidateUniqueParticleAttribution(XmlSchemaObjectTable qnames,
ArrayList nsNames, ValidationEventHandler h, XmlSchema schema)
{
// do nothing
}
// Methods
public static XmlSchema Read(System.IO.TextReader reader, ValidationEventHandler validationEventHandler)
{
}
//<all
// id = ID
// maxOccurs = 1 : 1
// minOccurs = (0 | 1) : 1
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, element*)
//</all>
internal static XmlSchemaAll Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAll all = new XmlSchemaAll();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaAll.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
all.LineNumber = reader.LineNumber;
all.LinePosition = reader.LinePosition;
all.SourceUri = reader.BaseURI;
//Read Attributes
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
all.Id = reader.Value;
}
else if (reader.Name == "maxOccurs")
{
try
{
all.MaxOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for maxOccurs", e);
}
}
else if (reader.Name == "minOccurs")
{
try
{
all.MinOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for minOccurs", e);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for all", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, all);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(all);
}
//Content: (annotation?, element*)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaAll.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
#if NOT_PFX
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
all.Annotation = annotation;
}
#endif
continue;
}
if (level <= 2 && reader.LocalName == "element")
{
level = 2;
XmlSchemaElement element = XmlSchemaElement.Read(reader, h);
if (element != null)
{
all.items.Add(element);
}
continue;
}
reader.RaiseInvalidElementError();
}
return(all);
}
/// <summary>
/// Validates the xml against known schemas.
/// </summary>
public static XmlDocument ValidateXml(IProgressMonitor monitor, string xml, string fileName)
{
monitor.BeginTask(GettextCatalog.GetString("Validating XML..."), 1);
bool error = false;
XmlDocument doc = null;
StringReader stringReader = new StringReader(xml);
XmlReaderSettings settings = new XmlReaderSettings();
settings.ValidationFlags = XmlSchemaValidationFlags.ProcessIdentityConstraints
| XmlSchemaValidationFlags.ProcessInlineSchema
| XmlSchemaValidationFlags.ProcessSchemaLocation
| XmlSchemaValidationFlags.ReportValidationWarnings;
settings.ValidationType = ValidationType.Schema;
settings.ProhibitDtd = false;
ValidationEventHandler validationHandler = delegate(object sender, System.Xml.Schema.ValidationEventArgs args) {
if (args.Severity == XmlSeverityType.Warning)
{
monitor.Log.WriteLine(args.Message);
AddTask(fileName, args.Exception.Message, args.Exception.LinePosition, args.Exception.LineNumber, TaskSeverity.Warning);
}
else
{
AddTask(fileName, args.Exception.Message, args.Exception.LinePosition, args.Exception.LineNumber, TaskSeverity.Error);
monitor.Log.WriteLine(args.Message);
error = true;
}
};
settings.ValidationEventHandler += validationHandler;
try {
foreach (XmlSchemaCompletionData sd in XmlSchemaManager.SchemaCompletionDataItems)
{
settings.Schemas.Add(sd.Schema);
}
settings.Schemas.Compile();
XmlReader reader = XmlReader.Create(stringReader, settings);
doc = new XmlDocument();
doc.Load(reader);
} catch (XmlSchemaException ex) {
monitor.ReportError(ex.Message, ex);
AddTask(fileName, ex.Message, ex.LinePosition, ex.LineNumber, TaskSeverity.Error);
error = true;
}
catch (XmlException ex) {
monitor.ReportError(ex.Message, ex);
AddTask(fileName, ex.Message, ex.LinePosition, ex.LineNumber, TaskSeverity.Error);
error = true;
}
finally {
if (stringReader != null)
{
stringReader.Dispose();
}
settings.ValidationEventHandler -= validationHandler;
}
if (error)
{
monitor.Log.WriteLine(GettextCatalog.GetString("Validation failed."));
TaskService.ShowErrors();
}
else
{
monitor.Log.WriteLine(GettextCatalog.GetString("XML is valid."));
}
monitor.EndTask();
return(error? null: doc);
}
