Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / ndp / fx / src / XmlUtils / System / Xml / Xsl / XsltOld / TemplateAction.cs / 1 / TemplateAction.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
//-----------------------------------------------------------------------------
namespace System.Xml.Xsl.XsltOld {
using Res = System.Xml.Utils.Res;
using System;
using System.Diagnostics;
using System.Collections;
using System.Xml;
using System.Xml.XPath;
using MS.Internal.Xml.XPath;
using System.Globalization;
internal class TemplateAction : TemplateBaseAction {
private int matchKey = Compiler.InvalidQueryKey;
private XmlQualifiedName name;
private double priority = double.NaN;
private XmlQualifiedName mode;
private int templateId;
private bool replaceNSAliasesDone;
internal int MatchKey {
get { return this.matchKey; }
}
internal XmlQualifiedName Name {
get { return this.name; }
}
internal double Priority {
get { return this.priority; }
}
internal XmlQualifiedName Mode {
get { return this.mode; }
}
internal int TemplateId {
get { return this.templateId; }
set {
Debug.Assert(this.templateId == 0);
this.templateId = value;
}
}
internal override void Compile(Compiler compiler) {
CompileAttributes(compiler);
if (this.matchKey == Compiler.InvalidQueryKey) {
if (this.name == null) {
throw XsltException.Create(Res.Xslt_TemplateNoAttrib);
}
if (this.mode != null ) {
throw XsltException.Create(Res.Xslt_InvalidModeAttribute);
}
}
compiler.BeginTemplate(this);
if (compiler.Recurse()) {
CompileParameters(compiler);
CompileTemplate(compiler);
compiler.ToParent();
}
compiler.EndTemplate();
AnalyzePriority(compiler);
}
internal virtual void CompileSingle(Compiler compiler) {
this.matchKey = compiler.AddQuery("/", /*allowVars:*/false, /*allowKey:*/true, /*pattern*/true);
this.priority = Compiler.RootPriority;
CompileOnceTemplate(compiler);
}
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.matchKey == Compiler.InvalidQueryKey);
this.matchKey = compiler.AddQuery(value, /*allowVars:*/false, /*allowKey:*/true, /*pattern*/true);
}
else if (Keywords.Equals(name, compiler.Atoms.Name)) {
Debug.Assert(this.name == null);
this.name = compiler.CreateXPathQName(value);
}
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.Create(Res.Xslt_InvalidAttrValue, Keywords.s_Priority, value);
}
}
else if (Keywords.Equals(name, compiler.Atoms.Mode)) {
Debug.Assert(this.mode == null);
if (compiler.AllowBuiltInMode && value == "*") {
this.mode = Compiler.BuiltInMode;
}
else {
this.mode = compiler.CreateXPathQName(value);
}
}
else {
return false;
}
return true;
}
private void AnalyzePriority(Compiler compiler) {
NavigatorInput input = compiler.Input;
if (!Double.IsNaN(this.priority) || this.matchKey == Compiler.InvalidQueryKey) {
return;
}
// Split Unions:
TheQuery theQuery = (TheQuery)compiler.QueryStore[this.MatchKey];
CompiledXpathExpr expr = (CompiledXpathExpr)theQuery.CompiledQuery;
Query query = expr.QueryTree;
UnionExpr union;
while ((union = query as UnionExpr) != null) {
Debug.Assert(!(union.qy2 is UnionExpr), "only qy1 can be union");
TemplateAction copy = this.CloneWithoutName();
compiler.QueryStore.Add(new TheQuery(
new CompiledXpathExpr(union.qy2, expr.Expression, false),
theQuery._ScopeManager
));
copy.matchKey = compiler.QueryStore.Count - 1;
copy.priority = union.qy2.XsltDefaultPriority;
compiler.AddTemplate(copy);
query = union.qy1;
}
if (expr.QueryTree != query) {
// query was splitted and we need create new TheQuery for this template
compiler.QueryStore[this.MatchKey] = new TheQuery(
new CompiledXpathExpr(query, expr.Expression, false),
theQuery._ScopeManager
);
}
this.priority = query.XsltDefaultPriority;
}
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());
}
//
// Priority calculation plus template splitting
//
private TemplateAction CloneWithoutName() {
TemplateAction clone = new TemplateAction(); {
clone.containedActions = this.containedActions;
clone.mode = this.mode;
clone.variableCount = this.variableCount;
clone.replaceNSAliasesDone = true; // We shouldn't replace NS in clones.
}
return clone;
}
internal override void ReplaceNamespaceAlias(Compiler compiler) {
// if template has both name and match it will be twice caled by stylesheet to replace NS aliases.
if (! replaceNSAliasesDone) {
base.ReplaceNamespaceAlias(compiler);
replaceNSAliasesDone = true;
}
}
//
// Execution
//
internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
switch (frame.State) {
case Initialized:
if (this.variableCount > 0) {
frame.AllocateVariables(this.variableCount);
}
if (this.containedActions != null && this.containedActions.Count > 0) {
processor.PushActionFrame(frame);
frame.State = ProcessingChildren;
}
else {
frame.Finished();
}
break; // Allow children to run
case ProcessingChildren:
frame.Finished();
break;
default:
Debug.Fail("Invalid Container action execution state");
break;
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
//-----------------------------------------------------------------------------
namespace System.Xml.Xsl.XsltOld {
using Res = System.Xml.Utils.Res;
using System;
using System.Diagnostics;
using System.Collections;
using System.Xml;
using System.Xml.XPath;
using MS.Internal.Xml.XPath;
using System.Globalization;
internal class TemplateAction : TemplateBaseAction {
private int matchKey = Compiler.InvalidQueryKey;
private XmlQualifiedName name;
private double priority = double.NaN;
private XmlQualifiedName mode;
private int templateId;
private bool replaceNSAliasesDone;
internal int MatchKey {
get { return this.matchKey; }
}
internal XmlQualifiedName Name {
get { return this.name; }
}
internal double Priority {
get { return this.priority; }
}
internal XmlQualifiedName Mode {
get { return this.mode; }
}
internal int TemplateId {
get { return this.templateId; }
set {
Debug.Assert(this.templateId == 0);
this.templateId = value;
}
}
internal override void Compile(Compiler compiler) {
CompileAttributes(compiler);
if (this.matchKey == Compiler.InvalidQueryKey) {
if (this.name == null) {
throw XsltException.Create(Res.Xslt_TemplateNoAttrib);
}
if (this.mode != null ) {
throw XsltException.Create(Res.Xslt_InvalidModeAttribute);
}
}
compiler.BeginTemplate(this);
if (compiler.Recurse()) {
CompileParameters(compiler);
CompileTemplate(compiler);
compiler.ToParent();
}
compiler.EndTemplate();
AnalyzePriority(compiler);
}
internal virtual void CompileSingle(Compiler compiler) {
this.matchKey = compiler.AddQuery("/", /*allowVars:*/false, /*allowKey:*/true, /*pattern*/true);
this.priority = Compiler.RootPriority;
CompileOnceTemplate(compiler);
}
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.matchKey == Compiler.InvalidQueryKey);
this.matchKey = compiler.AddQuery(value, /*allowVars:*/false, /*allowKey:*/true, /*pattern*/true);
}
else if (Keywords.Equals(name, compiler.Atoms.Name)) {
Debug.Assert(this.name == null);
this.name = compiler.CreateXPathQName(value);
}
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.Create(Res.Xslt_InvalidAttrValue, Keywords.s_Priority, value);
}
}
else if (Keywords.Equals(name, compiler.Atoms.Mode)) {
Debug.Assert(this.mode == null);
if (compiler.AllowBuiltInMode && value == "*") {
this.mode = Compiler.BuiltInMode;
}
else {
this.mode = compiler.CreateXPathQName(value);
}
}
else {
return false;
}
return true;
}
private void AnalyzePriority(Compiler compiler) {
NavigatorInput input = compiler.Input;
if (!Double.IsNaN(this.priority) || this.matchKey == Compiler.InvalidQueryKey) {
return;
}
// Split Unions:
TheQuery theQuery = (TheQuery)compiler.QueryStore[this.MatchKey];
CompiledXpathExpr expr = (CompiledXpathExpr)theQuery.CompiledQuery;
Query query = expr.QueryTree;
UnionExpr union;
while ((union = query as UnionExpr) != null) {
Debug.Assert(!(union.qy2 is UnionExpr), "only qy1 can be union");
TemplateAction copy = this.CloneWithoutName();
compiler.QueryStore.Add(new TheQuery(
new CompiledXpathExpr(union.qy2, expr.Expression, false),
theQuery._ScopeManager
));
copy.matchKey = compiler.QueryStore.Count - 1;
copy.priority = union.qy2.XsltDefaultPriority;
compiler.AddTemplate(copy);
query = union.qy1;
}
if (expr.QueryTree != query) {
// query was splitted and we need create new TheQuery for this template
compiler.QueryStore[this.MatchKey] = new TheQuery(
new CompiledXpathExpr(query, expr.Expression, false),
theQuery._ScopeManager
);
}
this.priority = query.XsltDefaultPriority;
}
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());
}
//
// Priority calculation plus template splitting
//
private TemplateAction CloneWithoutName() {
TemplateAction clone = new TemplateAction(); {
clone.containedActions = this.containedActions;
clone.mode = this.mode;
clone.variableCount = this.variableCount;
clone.replaceNSAliasesDone = true; // We shouldn't replace NS in clones.
}
return clone;
}
internal override void ReplaceNamespaceAlias(Compiler compiler) {
// if template has both name and match it will be twice caled by stylesheet to replace NS aliases.
if (! replaceNSAliasesDone) {
base.ReplaceNamespaceAlias(compiler);
replaceNSAliasesDone = true;
}
}
//
// Execution
//
internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
switch (frame.State) {
case Initialized:
if (this.variableCount > 0) {
frame.AllocateVariables(this.variableCount);
}
if (this.containedActions != null && this.containedActions.Count > 0) {
processor.PushActionFrame(frame);
frame.State = ProcessingChildren;
}
else {
frame.Finished();
}
break; // Allow children to run
case ProcessingChildren:
frame.Finished();
break;
default:
Debug.Fail("Invalid Container action execution state");
break;
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- BooleanToVisibilityConverter.cs
- ErrorTableItemStyle.cs
- SignalGate.cs
- ConfigXmlCDataSection.cs
- RenderOptions.cs
- ClientProxyGenerator.cs
- MobileComponentEditorPage.cs
- ReadOnlyObservableCollection.cs
- SortedDictionary.cs
- ArgumentException.cs
- TrackBar.cs
- SafeWaitHandle.cs
- TreeNodeBindingDepthConverter.cs
- RowsCopiedEventArgs.cs
- SizeAnimationClockResource.cs
- UrlPropertyAttribute.cs
- TextServicesHost.cs
- MsmqSecureHashAlgorithm.cs
- RepeaterItemEventArgs.cs
- ListBase.cs
- LinqDataSourceDeleteEventArgs.cs
- SeverityFilter.cs
- SharedStatics.cs
- ProfileSettings.cs
- XmlNodeComparer.cs
- FrameworkReadOnlyPropertyMetadata.cs
- SqlDataReaderSmi.cs
- Authorization.cs
- ToolBar.cs
- SessionStateSection.cs
- Error.cs
- XmlCodeExporter.cs
- ServiceNameCollection.cs
- KeyGestureConverter.cs
- AdRotator.cs
- TimeoutException.cs
- QueryOutputWriter.cs
- NetworkInterface.cs
- ConstNode.cs
- filewebresponse.cs
- HttpListenerContext.cs
- ContentFileHelper.cs
- EventLogEntry.cs
- ModelUIElement3D.cs
- counter.cs
- MachineKeyConverter.cs
- DocumentViewerHelper.cs
- WebPartDeleteVerb.cs
- SiteMapNode.cs
- SortFieldComparer.cs
- ObfuscationAttribute.cs
- nulltextnavigator.cs
- ConditionCollection.cs
- ControlHelper.cs
- DashStyle.cs
- ZoneButton.cs
- SafeFileMappingHandle.cs
- DataRowView.cs
- AsyncWaitHandle.cs
- EpmContentSerializerBase.cs
- ToolStripOverflow.cs
- AsyncOperationManager.cs
- PropertyManager.cs
- WindowsSolidBrush.cs
- WebColorConverter.cs
- CodeParameterDeclarationExpressionCollection.cs
- IOException.cs
- Operand.cs
- Line.cs
- ObjectTag.cs
- DockPattern.cs
- RotationValidation.cs
- OpCodes.cs
- DataBindingCollection.cs
- Peer.cs
- OptimalBreakSession.cs
- PriorityQueue.cs
- KeyTimeConverter.cs
- WebConfigurationManager.cs
- OdbcReferenceCollection.cs
- ZipIOLocalFileBlock.cs
- BitmapEffectOutputConnector.cs
- ReadOnlyCollection.cs
- ValueUnavailableException.cs
- WorkflowWebService.cs
- XPathNavigatorException.cs
- SafePointer.cs
- RulePatternOps.cs
- _RegBlobWebProxyDataBuilder.cs
- CodeRemoveEventStatement.cs
- Compiler.cs
- TransferMode.cs
- ToolboxItemFilterAttribute.cs
- ElementProxy.cs
- WebControlsSection.cs
- MsmqBindingFilter.cs
- SelectionWordBreaker.cs
- DelegatingTypeDescriptionProvider.cs
- SamlAuthenticationClaimResource.cs
- CqlIdentifiers.cs