internal SchemaElementDecl(XmlSchemaDatatype dtype, SchemaNames names) { Datatype = dtype; Content = new CompiledContentModel(names); Content.ContentType = CompiledContentModel.Type.Text; }
public SchemaElementDecl(XmlQualifiedName name, String prefix, SchemaType schemaType, SchemaNames names) : base(name, prefix) { content = new CompiledContentModel(names); }
private void CompileContentModel(CompiledContentModel compiledContentModel, XmlSchemaParticle particle) { if (particle is XmlSchemaElement) { compiledContentModel.AddTerminal(((XmlSchemaElement)particle).QualifiedName, null, this.validationEventHandler); } else if (particle is XmlSchemaAny) { compiledContentModel.AddAny((XmlSchemaAny)particle); } else if (particle is XmlSchemaGroupRef) { XmlSchemaParticle realParticle = ((XmlSchemaGroupRef)particle).Particle; Debug.Assert(realParticle != null && !realParticle.IsEmpty); compiledContentModel.OpenGroup(); CompileContentModel(compiledContentModel, realParticle); compiledContentModel.CloseGroup(); } else if (particle is XmlSchemaAll) { XmlSchemaAll all = (XmlSchemaAll)particle; compiledContentModel.StartAllElements(all.Items.Count); foreach (XmlSchemaElement localElement in all.Items) { if (!compiledContentModel.AddAllElement(localElement.QualifiedName, (all.MinOccurs == decimal.One ? localElement.MinOccurs == decimal.One : false))) { SendValidationEvent(Res.Sch_DupElement, localElement.QualifiedName.ToString(), localElement); } } } else if (particle is XmlSchemaGroupBase) { XmlSchemaObjectCollection particles = ((XmlSchemaGroupBase)particle).Items; bool isChoice = particle is XmlSchemaChoice; compiledContentModel.OpenGroup(); bool first = true; foreach (XmlSchemaParticle p in particles) { if (first) { first = false; } else if (isChoice) { compiledContentModel.AddChoice(); } else { compiledContentModel.AddSequence(); } Debug.Assert(!p.IsEmpty); CompileContentModel(compiledContentModel, p); } compiledContentModel.CloseGroup(); } else { Debug.Assert(false); } if (particle.MinOccurs == decimal.One && particle.MaxOccurs == decimal.One) { // nothing } else if (particle.MinOccurs == decimal.Zero && particle.MaxOccurs == decimal.One) { compiledContentModel.QuestionMark(); } else if (particle.MinOccurs == decimal.Zero && particle.MaxOccurs == decimal.MaxValue) { compiledContentModel.Star(); } else if (particle.MinOccurs == decimal.One && particle.MaxOccurs == decimal.MaxValue) { compiledContentModel.Plus(); } else { compiledContentModel.MinMax(particle.MinOccurs, particle.MaxOccurs); } }
private void CompileComplexContent(XmlSchemaComplexType complexType, CompiledContentModel compiledContentModel) { compiledContentModel.Start(); XmlSchemaParticle particle = complexType.ContentTypeParticle; if (particle != null && compiledContentModel.ContentType != CompiledContentModel.Type.Empty) { #if DEBUG string name = complexType.Name != null ? complexType.Name : string.Empty; Debug.WriteLineIf(CompModSwitches.XmlSchema.TraceVerbose, "CompileComplexContent: "+ name + DumpContentModel(particle)); #endif if (particle != XmlSchemaParticle.Empty) { CompileContentModel(compiledContentModel, particle); } } try { compiledContentModel.Finish(null, this.compileContentModel); } catch(XmlSchemaException e) { e.SetSource(complexType); SendValidationEvent(e); } PushComplexType(complexType); }
private void CompileComplexType(XmlSchemaComplexType complexType) { if (complexType.ElementDecl != null) { //already compiled return; } if (complexType.Validating) { SendValidationEvent(Res.Sch_TypeCircularRef, complexType); return; } complexType.Validating = true; CompiledContentModel compiledContentModel = new CompiledContentModel(this.schemaNames); if (complexType.ContentModel != null) { //simpleContent or complexContent if (complexType.ContentModel is XmlSchemaSimpleContent) { XmlSchemaSimpleContent simpleContent = (XmlSchemaSimpleContent)complexType.ContentModel; complexType.SetContentType(XmlSchemaContentType.TextOnly); if (simpleContent.Content is XmlSchemaSimpleContentExtension) { CompileSimpleContentExtension(complexType, (XmlSchemaSimpleContentExtension)simpleContent.Content); } else { //simpleContent.Content is XmlSchemaSimpleContentRestriction CompileSimpleContentRestriction(complexType, (XmlSchemaSimpleContentRestriction)simpleContent.Content); } } else { // complexType.ContentModel is XmlSchemaComplexContent XmlSchemaComplexContent complexContent = (XmlSchemaComplexContent)complexType.ContentModel; if (complexContent.Content is XmlSchemaComplexContentExtension) { CompileComplexContentExtension(complexType, complexContent, (XmlSchemaComplexContentExtension)complexContent.Content); } else { // complexContent.Content is XmlSchemaComplexContentRestriction CompileComplexContentRestriction(complexType, complexContent, (XmlSchemaComplexContentRestriction)complexContent.Content); } CompileComplexContent(complexType, compiledContentModel); } } else { //equals XmlSchemaComplexContent with baseType is anyType CompileLocalAttributes(XmlSchemaComplexType.AnyType, complexType, complexType.Attributes, complexType.AnyAttribute, XmlSchemaDerivationMethod.Restriction); complexType.SetDerivedBy(XmlSchemaDerivationMethod.Restriction); complexType.SetContentTypeParticle(CompileContentTypeParticle(complexType.Particle, true)); complexType.SetContentType(GetSchemaContentType(complexType, null, complexType.ContentTypeParticle)); CompileComplexContent(complexType, compiledContentModel); } bool hasID = false; foreach(XmlSchemaAttribute attribute in complexType.AttributeUses.Values) { if (attribute.Use != XmlSchemaUse.Prohibited) { XmlSchemaDatatype datatype = attribute.Datatype; if (datatype != null && datatype.TokenizedType == XmlTokenizedType.ID) { if (hasID) { SendValidationEvent(Res.Sch_TwoIdAttrUses, complexType); } else { hasID = true; } } } } SchemaElementDecl decl = new SchemaElementDecl(); decl.Content = compiledContentModel; decl.Content = compiledContentModel; decl.SchemaType = complexType; decl.Datatype = complexType.Datatype; decl.Block = complexType.BlockResolved; switch (complexType.ContentType) { case XmlSchemaContentType.TextOnly : decl.Content.ContentType = CompiledContentModel.Type.Text; break; case XmlSchemaContentType.Empty : decl.Content.ContentType = CompiledContentModel.Type.Empty; break; case XmlSchemaContentType.ElementOnly : decl.Content.ContentType = CompiledContentModel.Type.ElementOnly; break; default: decl.Content.ContentType = CompiledContentModel.Type.Mixed; break; } decl.AnyAttribute = complexType.AttributeWildcard; foreach(XmlSchemaAttribute attribute in complexType.AttributeUses.Values) { if (attribute.Use == XmlSchemaUse.Prohibited) { if (decl.ProhibitedAttributes[attribute.QualifiedName] == null) { decl.ProhibitedAttributes.Add(attribute.QualifiedName, attribute.QualifiedName); } } else { if (decl.AttDefs[attribute.QualifiedName] == null && attribute.AttDef != null && attribute.AttDef != SchemaAttDef.Empty) { decl.AddAttDef(attribute.AttDef); } } } complexType.ElementDecl = decl; complexType.Validating = false; }
private static void HandleMinMax(CompiledContentModel pContent, uint cMin, uint cMax) { if (cMax == uint.MaxValue) { if (cMin == 0) pContent.Star(); // minOccurs="0" and maxOccurs="infinite" else pContent.Plus(); // minOccurs="1" and maxOccurs="infinite" } else if (cMin == 0) { // minOccurs="0" and maxOccurs="1") pContent.QuestionMark(); } }
private void ParseElementDecl() { XmlQualifiedName name = XmlQualifiedName.Empty; while (true) { switch (_SubState) { case 0: _HasSeenWhiteSpace = false; GetToken(); name = GetName(_Token, _Namespaces); _ElementDecl = (SchemaElementDecl)_SchemaInfo.ElementDecls[name]; if (_ElementDecl != null) { SendValidationEvent(Res.Sch_DupElementDecl, _Scanner.GetText()); } else { _ElementDecl = (SchemaElementDecl)_UndeclaredElements[name]; if (_ElementDecl != null) { _UndeclaredElements.Remove(name); } else { _ElementDecl = new SchemaElementDecl(name, name.Namespace, SchemaType.DTD, _SchemaNames); } _SchemaInfo.ElementDecls.Add(name, _ElementDecl); } _ElementDecl.IsDeclaredInExternal = !_IsInternal; _SubState = 1; break; case 1: if (!_HasSeenWhiteSpace) { SkipWhitespace(true); } _SubState = 2; break; case 2: GetToken(); _ContentModel = _ElementDecl.Content; if (_Token == XmlToken.NAME) { if (_Scanner.IsToken(XmlToken.ANY)) { _ContentModel.ContentType = CompiledContentModel.Type.Any; _SubState = 12; } else if (_Scanner.IsToken(XmlToken.EMPTY)) { _ContentModel.ContentType = CompiledContentModel.Type.Empty; _SubState = 12; } else { _SubState = 15; // error; } } else if (_Token == XmlToken.LPAREN) { _ContentModel.Start(); _ContentModel.OpenGroup(); PushGroup(); _SubState = 3; _L = 0; _HasTerminal = false; } else { _SubState = 15; // error } break; case 3: GetToken(); if (_Token == XmlToken.HASH) { _SubState = 4; } else { _ContentModel.ContentType = CompiledContentModel.Type.ElementOnly; _HasTerminal = false; _SubState = 13; Push(DtdFunctionIndex.ParseElementContent); ParseElementContent(); } break; case 4: _HasSeenWhiteSpace = SkipWhitespace(false); _SubState = 5; break; case 5: GetToken(); if (_HasSeenWhiteSpace || !_Scanner.IsToken(XmlToken.PCDATA)) throw new XmlException(Res.Xml_ExpectPcData, _Scanner.StartLineNum, _Scanner.StartLinePos); _ContentModel.AddTerminal( _SchemaNames.QnPCData, null, _InternalValidationEventHandler); _HasTerminal = true; _SubState = 6; break; case 6: _HasSeenWhiteSpace = false; GetToken(); if (_Token == XmlToken.RPAREN) { _ContentModel.ContentType = CompiledContentModel.Type.Text; _ContentModel.CloseGroup(); _ContentModel.Finish(_InternalValidationEventHandler, true); PopGroup(); _L = -1; _SubState = 14; _HasSeenWhiteSpace = false; } else { _ContentModel.ContentType = CompiledContentModel.Type.Mixed; _SubState = 7; } break; case 7: if (_Token == XmlToken.OR) { _ContentModel.AddChoice(); _HasTerminal = false; _SubState = 8; } else if (_Token == XmlToken.RPAREN) { PopGroup(); _L = -1; _HasSeenWhiteSpace = false; _SubState = 10; } else { _SubState = 15; // error } break; case 8: GetToken(); _ContentModel.AddTerminal(GetName(_Token, _Namespaces), _Prefix, _InternalValidationEventHandler); _HasTerminal = true; _SubState = 9; break; case 9: _HasSeenWhiteSpace = false; GetToken(); _SubState = 7; break; case 10: if (!_HasSeenWhiteSpace) { _HasSeenWhiteSpace = SkipWhitespace(false); } _SubState = 11; break; case 11: GetToken(XmlToken.ASTERISK); if (_HasSeenWhiteSpace) throw new XmlException(Res.Xml_UnexpectedToken, "*", _Scanner.StartLineNum, _Scanner.StartLinePos); _ContentModel.CloseGroup(); _ContentModel.Star(); _ContentModel.Finish(_InternalValidationEventHandler, true); _SubState = 12; break; case 12: GetToken(); _SubState = 13; break; case 13: CheckTagend(_Token); Pop(); return; case 14: _HasSeenWhiteSpace = SkipWhitespace(false); GetToken(); if (_Token == XmlToken.ASTERISK) { if (_HasSeenWhiteSpace) throw new XmlException(Res.Xml_UnexpectedToken, "*", _Scanner.StartLineNum, _Scanner.StartLinePos); _SubState = 12; } else { _SubState = 13; } break; case 15: throw new XmlException(Res.Xml_InvalidContentModel, _Scanner.StartLineNum, _Scanner.StartLinePos); } // switch } // while }