protected void CompileSortElements(Compiler compiler) { NavigatorInput input = compiler.Input; do { switch (input.NodeType) { case XPathNodeType.Element: if (Keywords.Equals(input.NamespaceURI, input.Atoms.XsltNamespace) && Keywords.Equals(input.LocalName, input.Atoms.Sort)) { if (sortContainer == null) { sortContainer = new ContainerAction(); } sortContainer.AddAction(compiler.CreateSortAction()); continue; } return; case XPathNodeType.Text: return; case XPathNodeType.SignificantWhitespace: this.AddEvent(compiler.CreateTextEvent()); continue; default: continue; } }while (input.Advance()); }
protected void CompileParameters(Compiler compiler) { NavigatorInput input = compiler.Input; do { switch (input.NodeType) { case XPathNodeType.Element: if (Keywords.Equals(input.NamespaceURI, input.Atoms.XsltNamespace) && Keywords.Equals(input.LocalName, input.Atoms.Param)) { compiler.PushNamespaceScope(); AddAction(compiler.CreateVariableAction(VariableType.LocalParameter)); compiler.PopScope(); continue; } else { return; } case XPathNodeType.Text: return; case XPathNodeType.SignificantWhitespace: this.AddEvent(compiler.CreateTextEvent()); continue; default: continue; } }while (input.Advance()); }
internal override bool CompileAttribute(Compiler compiler) { string name = compiler.Input.LocalName; string value = compiler.Input.Value; if (Keywords.Equals(name, compiler.Atoms.Select)) { this.select = value; this.selectKey = compiler.AddQuery(this.select); Debug.WriteLine("apply-templates select: \"" + this.select + "\" (#" + this.selectKey.ToString() + ")"); } else if (Keywords.Equals(name, compiler.Atoms.Mode)) { Debug.Assert(this.mode == null); if (compiler.AllowBuiltInMode && value.Trim() == "*") { this.mode = Compiler.BuiltInMode; } else { this.mode = compiler.CreateXPathQName(value); } Debug.WriteLine("mode attribute found: \"" + this.mode + "\""); } else { return(false); } return(true); }
private int FindAttribute(string name, string nspace, ref string prefix) { Debug.Assert(this.attributeCount <= this.attributeList.Count); for (int attrib = 0; attrib < this.attributeCount; attrib++) { Debug.Assert(this.attributeList[attrib] != null && this.attributeList[attrib] is BuilderInfo); BuilderInfo attribute = (BuilderInfo)this.attributeList[attrib]; if (Keywords.Equals(attribute.LocalName, name)) { if (Keywords.Equals(attribute.NamespaceURI, nspace)) { return(attrib); } if (Keywords.Equals(attribute.Prefix, prefix)) { // prefix conflict. Should be renamed. prefix = string.Empty; } } } return(-1); }
internal bool FindPrefix(string nspace, out string prefix) { Debug.Assert(nspace != null); for (int i = this.elementScopesStack.Length - 1; 0 <= i; i--) { Debug.Assert(this.elementScopesStack[i] is OutputScope); OutputScope elementScope = (OutputScope)this.elementScopesStack[i]; string pfx = null; if (elementScope.FindPrefix(nspace, out pfx)) { string testNspace = ResolveNamespace(pfx); if (testNspace != null && Keywords.Equals(testNspace, nspace)) { prefix = pfx; return(true); } else { break; } } } prefix = null; return(false); }
internal override bool CompileAttribute(Compiler compiler) { string name = compiler.Input.LocalName; string value = compiler.Input.Value; if (Keywords.Equals(name, compiler.Atoms.Select)) { this.selectKey = compiler.AddQuery(value); } else if (Keywords.Equals(name, compiler.Atoms.Lang)) { this.langAvt = Avt.CompileAvt(compiler, value); } else if (Keywords.Equals(name, compiler.Atoms.DataType)) { this.dataTypeAvt = Avt.CompileAvt(compiler, value); } else if (Keywords.Equals(name, compiler.Atoms.Order)) { this.orderAvt = Avt.CompileAvt(compiler, value); } else if (Keywords.Equals(name, compiler.Atoms.CaseOrder)) { this.caseOrderAvt = Avt.CompileAvt(compiler, value); } else { return(false); } return(true); }
protected void CompileOnceTemplate(Compiler compiler) { NavigatorInput input = compiler.Input; Debug.Trace(input); if (input.NodeType == XPathNodeType.Element) { string nspace = input.NamespaceURI; if (Keywords.Equals(nspace, input.Atoms.XsltNamespace)) { compiler.PushNamespaceScope(); CompileInstruction(compiler); compiler.PopScope(); } else { compiler.PushLiteralScope(); compiler.InsertExtensionNamespace(); if (compiler.IsExtensionNamespace(nspace)) { AddAction(compiler.CreateNewInstructionAction()); } else { CompileLiteral(compiler); } compiler.PopScope(); } } else { CompileLiteral(compiler); } }
internal override bool CompileAttribute(Compiler compiler) { string name = compiler.Input.LocalName; string value = compiler.Input.Value; if (Keywords.Equals(name, compiler.Atoms.Name)) { Debug.Assert(this.name == null && this.nameStr == null); this.nameStr = value; this.name = compiler.CreateXPathQName(this.nameStr); Debug.WriteLine("name attribute found: " + this.name); } else if (Keywords.Equals(name, compiler.Atoms.Select)) { Debug.Assert(this.select == null); this.select = value; this.selectKey = compiler.AddQuery(this.select); Debug.WriteLine("select attribute = \"" + this.select + "\" (#" + this.selectKey + ")"); } else { return(false); } return(true); }
internal override bool CompileAttribute(Compiler compiler) { string name = compiler.Input.LocalName; string value = compiler.Input.Value; if (Keywords.Equals(name, compiler.Atoms.Name)) { this.nameAvt = Avt.CompileAvt(compiler, value); Debug.WriteLine("name = \"" + value + "\""); } else if (Keywords.Equals(name, compiler.Atoms.Namespace)) { this.nsAvt = Avt.CompileAvt(compiler, value); Debug.WriteLine("namespace = \"" + value + "\""); } else if (Keywords.Equals(name, compiler.Atoms.UseAttributeSets)) { AddAction(compiler.CreateUseAttributeSetsAction()); } else { return(false); } return(true); }
internal override bool CompileAttribute(Compiler compiler) { string name = compiler.Input.LocalName; string value = compiler.Input.Value; if (Keywords.Equals(name, compiler.Atoms.Level)) { if (value != s_any && value != s_multiple && value != s_single) { throw XsltException.InvalidAttrValue(Keywords.s_Level, value); } this.level = value; } else if (Keywords.Equals(name, compiler.Atoms.Count)) { this.countPattern = value; this.countKey = compiler.AddPatternQuery(value, /*allowVars:*/ true, /*allowKey:*/ true); } else if (Keywords.Equals(name, compiler.Atoms.From)) { this.from = value; this.fromKey = compiler.AddPatternQuery(value, /*allowVars:*/ true, /*allowKey:*/ true); } else if (Keywords.Equals(name, compiler.Atoms.Value)) { this.value = value; this.valueKey = compiler.AddQuery(value); } else if (Keywords.Equals(name, compiler.Atoms.Format)) { this.formatAvt = Avt.CompileAvt(compiler, value); Debug.WriteLine("name = \"" + value + "\""); } else if (Keywords.Equals(name, compiler.Atoms.Lang)) { this.langAvt = Avt.CompileAvt(compiler, value); Debug.WriteLine("name = \"" + value + "\""); } else if (Keywords.Equals(name, compiler.Atoms.LetterValue)) { this.letterAvt = Avt.CompileAvt(compiler, value); Debug.WriteLine("name = \"" + value + "\""); } else if (Keywords.Equals(name, compiler.Atoms.GroupingSeparator)) { this.groupingSepAvt = Avt.CompileAvt(compiler, value); Debug.WriteLine("name = \"" + value + "\""); } else if (Keywords.Equals(name, compiler.Atoms.GroupingSize)) { this.groupingSizeAvt = Avt.CompileAvt(compiler, value); Debug.WriteLine("name = \"" + value + "\""); } else { return(false); } return(true); }
private void CompileConditions(Compiler compiler) { NavigatorInput input = compiler.Input; bool when = false; bool otherwise = false; do { Debug.Trace(input); switch (input.NodeType) { case XPathNodeType.Element: compiler.PushNamespaceScope(); string nspace = input.NamespaceURI; string name = input.LocalName; if (Keywords.Equals(nspace, input.Atoms.XsltNamespace)) { IfAction action = null; if (Keywords.Equals(name, input.Atoms.When) && !otherwise) { action = compiler.CreateIfAction(IfAction.ConditionType.ConditionWhen); when = true; } else if (Keywords.Equals(name, input.Atoms.Otherwise) && !otherwise) { action = compiler.CreateIfAction(IfAction.ConditionType.ConditionOtherwise); otherwise = true; } else { throw XsltException.UnexpectedKeyword(compiler); } AddAction(action); } else { throw XsltException.UnexpectedKeyword(compiler); } compiler.PopScope(); break; case XPathNodeType.Comment: case XPathNodeType.ProcessingInstruction: case XPathNodeType.Whitespace: case XPathNodeType.SignificantWhitespace: break; default: throw new XsltException(Res.Xslt_InvalidContents, Keywords.s_Choose); } }while (compiler.Advance()); if (!when) { throw new XsltException(Res.Xslt_NoWhen); } }
private void CompileContent(Compiler compiler) { NavigatorInput input = compiler.Input; if (compiler.Recurse()) { do { Debug.Trace(input); switch (input.NodeType) { case XPathNodeType.Element: compiler.PushNamespaceScope(); string nspace = input.NamespaceURI; string name = input.LocalName; if (Keywords.Equals(nspace, input.Atoms.XsltNamespace)) { if (Keywords.Equals(name, input.Atoms.Sort)) { this.sort = true; AddAction(compiler.CreateSortAction()); } else if (Keywords.Equals(name, input.Atoms.WithParam)) { WithParamAction par = compiler.CreateWithParamAction(); CheckDuplicateParams(par.Name); AddAction(par); } else { throw XsltException.UnexpectedKeyword(compiler); } } else { throw XsltException.UnexpectedKeyword(compiler); } compiler.PopScope(); break; case XPathNodeType.Comment: case XPathNodeType.ProcessingInstruction: case XPathNodeType.Whitespace: case XPathNodeType.SignificantWhitespace: break; default: throw new XsltException(Res.Xslt_InvalidContents, Keywords.s_ApplyTemplates); } }while (compiler.Advance()); compiler.ToParent(); } }
internal void CompileKey(Compiler compiler) { NavigatorInput input = compiler.Input; string element = input.LocalName; int MatchKey = Compiler.InvalidQueryKey; int UseKey = Compiler.InvalidQueryKey; XmlQualifiedName Name = null; if (input.MoveToFirstAttribute()) { do { Debug.TraceAttribute(input); string nspace = input.NamespaceURI; string name = input.LocalName; string value = input.Value; if (!Keywords.Equals(nspace, input.Atoms.Empty)) { continue; } if (Keywords.Equals(name, input.Atoms.Name)) { Name = compiler.CreateXPathQName(value); } else if (Keywords.Equals(name, input.Atoms.Match)) { MatchKey = compiler.AddPatternQuery(value, /*allowVars:*/ false, /*allowKey*/ false); } else if (Keywords.Equals(name, input.Atoms.Use)) { UseKey = compiler.AddQuery(value, /*allowVars:*/ false, /*allowKey*/ false); } else { if (!compiler.ForwardCompatibility) { throw XsltException.InvalidAttribute(element, name); } } }while(input.MoveToNextAttribute()); input.ToParent(); } CheckRequiredAttribute(compiler, MatchKey != Compiler.InvalidQueryKey, Keywords.s_Match); CheckRequiredAttribute(compiler, UseKey != Compiler.InvalidQueryKey, Keywords.s_Use); CheckRequiredAttribute(compiler, Name != null, Keywords.s_Name); compiler.InsertKey(Name, MatchKey, UseKey); }
void CompileLiteralAttributesAndNamespaces(Compiler compiler) { NavigatorInput input = compiler.Input; if (input.Navigator.MoveToAttribute(Keywords.s_UseAttributeSets, input.Atoms.XsltNamespace)) { AddAction(compiler.CreateUseAttributeSetsAction()); input.Navigator.MoveToParent(); } compiler.InsertExcludedNamespace(); if (input.MoveToFirstAttribute()) { do { // Skip everything from Xslt namespace if (Keywords.Equals(input.NamespaceURI, input.Atoms.XsltNamespace)) { continue; } // Add attribute events this.AddEvent(compiler.CreateBeginEvent()); this.AddEvents(compiler.CompileAvt(input.Value)); this.AddEvent(new EndEvent(XPathNodeType.Attribute)); }while (input.MoveToNextAttribute()); input.ToParent(); } if (input.MoveToFirstNamespace()) { do { string uri = input.Value; if (Keywords.Compare(uri, input.Atoms.XsltNamespace)) { continue; } if ( compiler.IsExcludedNamespace(uri) || compiler.IsExtensionNamespace(uri) || compiler.IsNamespaceAlias(uri) ) { continue; } this.AddEvent(new NamespaceEvent(input)); }while (input.MoveToNextNamespace()); input.ToParent(); } }
internal string ResolveAtom(string prefix) { Debug.Assert(prefix != null && prefix.Length > 0); for (NamespaceDecl scope = this.scopes; scope != null; scope = scope.Next) { if (Keywords.Equals(scope.Prefix, prefix)) { Debug.Assert(scope.Uri != null); return(scope.Uri); } } return(null); }
private void FixupElement() { Debug.Assert(this.mainNode.NodeType == XmlNodeType.Element); if (Keywords.Equals(this.mainNode.NamespaceURI, this.atoms.Empty)) { this.mainNode.Prefix = this.atoms.Empty; } if (Keywords.Equals(this.mainNode.Prefix, this.atoms.Empty)) { if (Keywords.Equals(this.mainNode.NamespaceURI, this.scopeManager.DefaultNamespace)) { // Main Node is OK } else { DeclareNamespace(this.mainNode.NamespaceURI, this.mainNode.Prefix); } } else { bool thisScope = false; string nspace = this.scopeManager.ResolveNamespace(this.mainNode.Prefix, out thisScope); if (nspace != null) { if (!Keywords.Equals(this.mainNode.NamespaceURI, nspace)) { if (thisScope) // Prefix conflict { this.mainNode.Prefix = GetPrefixForNamespace(this.mainNode.NamespaceURI); } else { DeclareNamespace(this.mainNode.NamespaceURI, this.mainNode.Prefix); } } } else { DeclareNamespace(this.mainNode.NamespaceURI, this.mainNode.Prefix); } } OutputScope elementScope = this.scopeManager.CurrentElementScope; elementScope.Prefix = this.mainNode.Prefix; }
internal void CompileSingleTemplate(Compiler compiler) { NavigatorInput input = compiler.Input; // // find mandatory version attribute and launch compilation of single template // string version = null; bool wrongns = false; if (input.MoveToFirstAttribute()) { do { Debug.TraceAttribute(input); string nspace = input.NamespaceURI; string name = input.LocalName; if (Keywords.Equals(name, input.Atoms.Version)) { if (Keywords.Equals(nspace, input.Atoms.XsltNamespace)) { version = input.Value; } else { wrongns = true; } } }while(input.MoveToNextAttribute()); input.ToParent(); } if (version == null) { if (wrongns) { throw new XsltException(Res.Xslt_WrongNamespace); } throw new XsltException(Res.Xslt_MissingAttribute, Keywords.s_Version); } Debug.TraceElement(input); compiler.AddTemplate(compiler.CreateSingleTemplateAction()); }
internal override bool CompileAttribute(Compiler compiler) { string name = compiler.Input.LocalName; string value = compiler.Input.Value; if (Keywords.Equals(name, compiler.Atoms.DisableOutputEscaping)) { this.disableOutputEscaping = compiler.GetYesNo(value); } else { return(false); } return(true); }
internal override bool CompileAttribute(Compiler compiler) { string name = compiler.Input.LocalName; string value = compiler.Input.Value; if (Keywords.Equals(name, compiler.Atoms.Match)) { Debug.Assert(this.match == null); this.match = value; this.matchKey = compiler.AddPatternQuery(value, /*allowVars:*/ false, /*allowKey:*/ true); Debug.WriteLine("match attribute found: \"" + this.match + "\" (#" + this.matchKey + ")"); } else if (Keywords.Equals(name, compiler.Atoms.Name)) { Debug.Assert(this.name == null); this.name = compiler.CreateXPathQName(value); Debug.WriteLine("name attribute found: " + this.name); } else if (Keywords.Equals(name, compiler.Atoms.Priority)) { Debug.Assert(Double.IsNaN(this.priority)); this.priority = XmlConvert.ToXPathDouble(value); if (double.IsNaN(this.priority) && !compiler.ForwardCompatibility) { throw XsltException.InvalidAttrValue(Keywords.s_Priority, value); } } else if (Keywords.Equals(name, compiler.Atoms.Mode)) { Debug.Assert(this.mode == null); if (compiler.AllowBuiltInMode && value.Trim() == "*") { this.mode = Compiler.BuiltInMode; } else { this.mode = compiler.CreateXPathQName(value); } Debug.WriteLine("mode attribute found: " + this.mode); } else { return(false); } return(true); }
internal override bool CompileAttribute(Compiler compiler) { string name = compiler.Input.LocalName; string value = compiler.Input.Value; if (Keywords.Equals(name, compiler.Atoms.Terminate)) { _Terminate = compiler.GetYesNo(value); Debug.WriteLine("Message terminate == \"" + _Terminate + "\""); } else { return(false); } return(true); }
internal override bool CompileAttribute(Compiler compiler) { string name = compiler.Input.LocalName; string value = compiler.Input.Value; if (Keywords.Equals(name, compiler.Atoms.UseAttributeSets)) { this.useAttributeSets = value; AddAction(compiler.CreateUseAttributeSetsAction()); Debug.WriteLine("UseAttributeSets = \"" + this.useAttributeSets + "\""); } else { return(false); } return(true); }
internal void CompileNamespaceAlias(Compiler compiler) { NavigatorInput input = compiler.Input; string element = input.LocalName; string namespace1 = null, namespace2 = null; string prefix1 = null, prefix2 = null; if (input.MoveToFirstAttribute()) { do { string nspace = input.NamespaceURI; string name = input.LocalName; if (!Keywords.Equals(nspace, input.Atoms.Empty)) { continue; } if (Keywords.Equals(name, input.Atoms.StylesheetPrefix)) { prefix1 = input.Value; namespace1 = compiler.GetNsAlias(ref prefix1); } else if (Keywords.Equals(name, input.Atoms.ResultPrefix)) { prefix2 = input.Value; namespace2 = compiler.GetNsAlias(ref prefix2); } else { if (!compiler.ForwardCompatibility) { throw XsltException.InvalidAttribute(element, name); } } }while(input.MoveToNextAttribute()); input.ToParent(); } CheckRequiredAttribute(compiler, namespace1, Keywords.s_StylesheetPrefix); CheckRequiredAttribute(compiler, namespace2, Keywords.s_ResultPrefix); //String[] resultarray = { prefix2, namespace2 }; compiler.AddNamespaceAlias(namespace1, new NamespaceInfo(prefix2, namespace2, compiler.Stylesheetid)); }
internal override bool CompileAttribute(Compiler compiler) { string name = compiler.Input.LocalName; string value = compiler.Input.Value; if (Keywords.Equals(name, compiler.Atoms.Select)) { this.select = value; this.selectKey = compiler.AddQuery(this.select); Debug.WriteLine("Select expression == \"" + this.select + "\" + (#" + this.selectKey + ")"); } else { return(false); } return(true); }
internal override bool CompileAttribute(Compiler compiler) { string name = compiler.Input.LocalName; string value = compiler.Input.Value; if (Keywords.Equals(name, compiler.Atoms.Name)) { Debug.Assert(this.name == null); this.name = compiler.CreateXPathQName(value); Debug.WriteLine("Name attribute found: " + this.name); } else { return(false); } return(true); }
internal void CompileSelectiveTemplate(Compiler compiler) { NavigatorInput input = compiler.Input; do { if (Keywords.Equals(input.NamespaceURI, input.Atoms.XsltNamespace) && Keywords.Equals(input.LocalName, input.Atoms.Fallback)) { fallback = true; if (compiler.Recurse()) { CompileTemplate(compiler); compiler.ToParent(); } } }while (compiler.Advance()); }
internal bool FindPrefix(string urn, out string prefix) { Debug.Assert(urn != null); for (NamespaceDecl scope = this.scopes; scope != null; scope = scope.Next) { if (Keywords.Equals(scope.Uri, urn) && scope.Prefix != null && scope.Prefix.Length > 0) { prefix = scope.Prefix; return(true); } } prefix = String.Empty; return(false); }
private void FixupAttributes(int attributeCount) { for (int attr = 0; attr < attributeCount; attr++) { Debug.Assert(this.attributeList[attr] is BuilderInfo); BuilderInfo info = (BuilderInfo)this.attributeList[attr]; if (Keywords.Equals(info.NamespaceURI, this.atoms.Empty)) { info.Prefix = this.atoms.Empty; } else { if (Keywords.Equals(info.Prefix, this.atoms.Empty)) { info.Prefix = GetPrefixForNamespace(info.NamespaceURI); } else { bool thisScope = false; string nspace = this.scopeManager.ResolveNamespace(info.Prefix, out thisScope); if (nspace != null) { if (!Keywords.Equals(info.NamespaceURI, nspace)) { if (thisScope) // prefix conflict { info.Prefix = GetPrefixForNamespace(info.NamespaceURI); } else { DeclareNamespace(info.NamespaceURI, info.Prefix); } } } else { DeclareNamespace(info.NamespaceURI, info.Prefix); } } } } }
private void CompileContent(Compiler compiler) { NavigatorInput input = compiler.Input; if (compiler.Recurse()) { do { Debug.Trace(input); switch (input.NodeType) { case XPathNodeType.Element: compiler.PushNamespaceScope(); string nspace = input.NamespaceURI; string name = input.LocalName; if (Keywords.Equals(nspace, input.Atoms.XsltNamespace) && Keywords.Equals(name, input.Atoms.Attribute)) { // found attribute so add it AddAction(compiler.CreateAttributeAction()); } else { throw XsltException.UnexpectedKeyword(compiler); } compiler.PopScope(); break; case XPathNodeType.Comment: case XPathNodeType.ProcessingInstruction: case XPathNodeType.Whitespace: case XPathNodeType.SignificantWhitespace: break; default: throw new XsltException(Res.Xslt_InvalidContents, Keywords.s_AttributeSet); } }while(compiler.Advance()); compiler.ToParent(); } }
private void BeginNamespace(string name, string nspace) { bool thisScope = false; if (Keywords.Equals(name, this.atoms.Empty)) { if (Keywords.Equals(nspace, this.scopeManager.DefaultNamespace)) { // Main Node is OK } else if (Keywords.Equals(this.mainNode.NamespaceURI, this.atoms.Empty)) { // http://www.w3.org/1999/11/REC-xslt-19991116-errata/ E25 // Should throw an error but ingnoring it in Everett. // Would be a breaking change } else { DeclareNamespace(nspace, name); } } else { string nspaceDeclared = this.scopeManager.ResolveNamespace(name, out thisScope); if (nspaceDeclared != null) { if (!Keywords.Equals(nspace, nspaceDeclared)) { if (!thisScope) { DeclareNamespace(nspace, name); } } } else { DeclareNamespace(nspace, name); } } this.currentInfo = dummy; currentInfo.NodeType = XmlNodeType.Attribute; }
public string GetNsAlias(ref string prefix) { Debug.Assert( Keywords.Equals(this.input.LocalName, this.input.Atoms.StylesheetPrefix) || Keywords.Equals(this.input.LocalName, this.input.Atoms.ResultPrefix) ); if (Keywords.Compare(this.input.Atoms.HashDefault, prefix)) { prefix = string.Empty; return(this.DefaultNamespace); } else { if (!PrefixQName.ValidatePrefix(prefix) || prefix.Length == 0) { throw XsltException.InvalidAttrValue(this.input.LocalName, prefix); } return(this.ResolveXPathNamespace(prefix)); } }