internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
Debug.Assert(this.copyEvents != null && this.copyEvents.Count > 0);
switch (frame.State) {
case Initialized:
frame.Counter = 0;
frame.State = Outputting;
goto case Outputting;
case Outputting:
Debug.Assert(frame.State == Outputting);
while (processor.CanContinue) {
Debug.Assert(frame.Counter < this.copyEvents.Count);
Event copyEvent = (Event) this.copyEvents[frame.Counter];
if (copyEvent.Output(processor, frame) == false) {
// This event wasn't processed
break;
}
if (frame.IncrementCounter() >= this.copyEvents.Count) {
frame.Finished();
break;
}
}
break;
default:
Debug.Fail("Invalid CopyCodeAction execution state");
break;
}
}
internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
switch (frame.State) {
case Initialized:
Debug.Assert(frame != null);
Debug.Assert(frame.NodeSet != null);
if (this.selectKey == Compiler.InvalidQueryKey) {
throw new XsltException(Res.Xslt_InvalidXPath, new string[] { select });
}
string value = processor.ValueOf(frame, this.selectKey);
if (processor.TextEvent(value, disableOutputEscaping)) {
frame.Finished();
}
else {
frame.StoredOutput = value;
frame.State = ResultStored;
}
break;
case ResultStored:
Debug.Assert(frame.StoredOutput != null);
processor.TextEvent(frame.StoredOutput);
frame.Finished();
break;
default:
Debug.Fail("Invalid ValueOfAction execution state");
break;
}
}
internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
Debug.Assert(frame.State == Initialized);
Action action = null;
if (this.mode != null) {
action = importsOf == null
? processor.Stylesheet.FindTemplate(processor, frame.Node, this.mode)
: importsOf.FindTemplateImports(processor, frame.Node, this.mode);
}
else {
action = importsOf == null
? processor.Stylesheet.FindTemplate(processor, frame.Node)
: importsOf.FindTemplateImports(processor, frame.Node);
}
// Built-int template rules
if (action == null) {
action = BuiltInTemplate(frame.Node);
}
// Jump
if (action != null) {
frame.SetAction(action);
}
else {
frame.Finished();
}
}
internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
object ParamValue;
switch(frame.State) {
case Initialized:
if (this.selectKey != Compiler.InvalidQueryKey) {
ParamValue = processor.RunQuery(frame, this.selectKey);
processor.SetParameter(this.name, ParamValue);
frame.Finished();
}
else {
if (this.containedActions == null) {
processor.SetParameter(this.name, String.Empty);
frame.Finished();
break;
}
NavigatorOutput output = new NavigatorOutput();
processor.PushOutput(output);
processor.PushActionFrame(frame);
frame.State = ProcessingChildren;
}
break;
case ProcessingChildren:
RecordOutput recOutput = processor.PopOutput();
Debug.Assert(recOutput is NavigatorOutput);
processor.SetParameter(this.name,((NavigatorOutput)recOutput).Navigator);
frame.Finished();
break;
default:
Debug.Fail("Invalid execution state inside VariableAction.Execute");
break;
}
}
internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
switch (frame.State) {
case Initialized:
if (this.type == ConditionType.ConditionIf || this.type == ConditionType.ConditionWhen) {
Debug.Assert(this.testKey != Compiler.InvalidQueryKey);
bool value = processor.EvaluateBoolean(frame, this.testKey);
if (value == false) {
frame.Finished();
break;
}
}
processor.PushActionFrame(frame);
frame.State = ProcessingChildren;
break; // Allow children to run
case ProcessingChildren:
if (this.type == ConditionType.ConditionWhen ||this.type == ConditionType.ConditionOtherwise) {
Debug.Assert(frame.Container != null);
frame.Exit();
}
frame.Finished();
break;
default:
Debug.Fail("Invalid IfAction execution state");
break;
}
}
internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
switch (frame.State) {
case Initialized:
TextOnlyOutput output = new TextOnlyOutput(processor, new StringWriter());
processor.PushOutput(output);
processor.PushActionFrame(frame);
frame.State = ProcessingChildren;
break;
case ProcessingChildren:
TextOnlyOutput recOutput = processor.PopOutput() as TextOnlyOutput;
Debug.Assert(recOutput != null);
Console.WriteLine(recOutput.Writer.ToString());
if (_Terminate) {
throw new XsltException(Res.Xslt_Terminate, recOutput.Writer.ToString());
}
frame.Finished();
break;
default:
Debug.Fail("Invalid MessageAction execution state");
break;
}
}
internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
switch (frame.State) {
case Initialized:
if (processor.BeginEvent(XPathNodeType.Comment, string.Empty, string.Empty, string.Empty, false) == false) {
// Come back later
break;
}
processor.PushActionFrame(frame);
frame.State = ProcessingChildren;
break; // Allow children to run
case ProcessingChildren:
if (processor.EndEvent(XPathNodeType.Comment) == false) {
Debug.WriteLine("Cannot end event, breaking, will restart");
break;
}
frame.Finished();
break;
default:
Debug.Fail("Invalid IfAction execution state");
break;
}
}
//
// Constructor
//
internal TextOnlyOutput(Processor processor, Stream stream) {
if (stream == null) {
throw new ArgumentNullException("stream");
}
this.processor = processor;
this.writer = new StreamWriter(stream, Output.Encoding);
}
internal TextOnlyOutput(Processor processor, TextWriter writer) {
if (writer == null) {
throw new ArgumentNullException("writer");
}
this.processor = processor;
this.writer = writer;
}
internal ReaderOutput(Processor processor) {
Debug.Assert(processor != null);
Debug.Assert(processor.NameTable != null);
this.processor = processor;
this.nameTable = processor.NameTable;
Reset();
}
internal TextOutput(Processor processor, Stream stream)
: base(processor)
{
if (stream == null) {
throw new ArgumentNullException("stream");
}
this.encoding = processor.Output.Encoding;
this.writer = new StreamWriter(stream, this.encoding);
}
internal TextOutput(Processor processor, TextWriter writer)
: base(processor)
{
if (writer == null) {
throw new ArgumentNullException("writer");
}
this.encoding = writer.Encoding;
this.writer = writer;
}
public override bool Output(Processor processor, ActionFrame frame) {
bool res;
res = processor.BeginEvent(XPathNodeType.Namespace, /*prefix:*/null, this.name, this.namespaceUri, /*empty:*/false);
Debug.Assert(res); // Namespace node as any other attribute can't fail because it doesn't signal record change
res = processor.TextEvent(this.namespaceUri);
Debug.Assert(res);
res = processor.EndEvent(XPathNodeType.Namespace);
Debug.Assert(res);
return true;
}
internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
switch (frame.State) {
case Initialized:
processor.PushTemplateLookup(frame.NodeSet, this.mode, /*importsOf:*/this.stylesheet);
frame.State = TemplateProcessed;
break;
case TemplateProcessed:
frame.Finished();
break;
}
}
internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
while (processor.CanContinue) {
switch (frame.State) {
case Initialized:
if (frame.Node.MoveToFirstNamespace(XPathNamespaceScope.ExcludeXml) == false) {
frame.Finished();
break;
}
frame.State = BeginEvent;
goto case BeginEvent;
case BeginEvent:
Debug.Assert(frame.State == BeginEvent);
Debug.Assert(frame.Node.NodeType == XPathNodeType.Namespace);
if (processor.BeginEvent(XPathNodeType.Namespace, null, frame.Node.LocalName, frame.Node.Value, false) == false) {
// This one wasn't output
break;
}
frame.State = EndEvent;
continue;
case EndEvent:
Debug.Assert(frame.State == EndEvent);
Debug.Assert(frame.Node.NodeType == XPathNodeType.Namespace);
if (processor.EndEvent(XPathNodeType.Namespace) == false) {
// This one wasn't output
break;
}
frame.State = Advance;
continue;
case Advance:
Debug.Assert(frame.State == Advance);
Debug.Assert(frame.Node.NodeType == XPathNodeType.Namespace);
if (frame.Node.MoveToNextNamespace(XPathNamespaceScope.ExcludeXml)) {
frame.State = BeginEvent;
continue;
}
else {
frame.Node.MoveToParent();
frame.Finished();
break;
}
}
break;
}// while
}
internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
switch (frame.State) {
case Initialized:
if (sort) {
processor.InitSortArray();
processor.PushActionFrame(sortContainer, frame.NodeSet);
frame.State = ProcessedSort;
break;
}
goto case ProcessedSort;
case ProcessedSort:
if (this.selectKey == Compiler.InvalidQueryKey) {
throw new XsltException(Res.Xslt_InvalidXPath, new string[] { select });
}
if (sort) {
frame.InitNewNodeSet(processor.StartQuery(frame.Node, this.selectKey, processor.SortArray));
}
else {
frame.InitNewNodeSet(processor.StartQuery(frame.Node, this.selectKey));
}
frame.State = ProcessNextNode;
goto case ProcessNextNode;
case ProcessNextNode:
Debug.Assert(frame.State == ProcessNextNode);
Debug.Assert(frame.NewNodeSet != null);
Debug.WriteLine("Processing next Node");
if (frame.NewNextNode(processor)) {
Debug.WriteLine("Node found");
frame.State = PositionAdvanced;
goto case PositionAdvanced;
}
else {
Debug.WriteLine("Node not found, finished ");
frame.Finished();
break;
}
case PositionAdvanced:
processor.PushActionFrame(frame, frame.NewNodeSet);
frame.State = ContentsProcessed;
break;
case ContentsProcessed:
frame.State = ProcessNextNode;
goto case ProcessNextNode;
}
}
internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
switch (frame.State) {
case Initialized:
if (processor.TextEvent(this.text, disableOutputEscaping)) {
frame.Finished();
}
break;
default:
Debug.Fail("Invalid execution state in TextAction");
break;
}
}
internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
switch (frame.State) {
case Initialized:
if(this.nameAvt == null) {
frame.StoredOutput = this.name;
if(this.name == null) {
// name was static but was bad;
frame.Finished();
break;
}
}
else {
frame.StoredOutput = this.nameAvt.Evaluate(processor, frame);
if (! IsProcessingInstructionName(frame.StoredOutput)) {
Debug.WriteLine("Invalid Processing instruction naame: \"" + name + "\"");
frame.Finished();
break;
}
}
goto case NameReady;
case NameReady:
Debug.Assert(frame.StoredOutput != null);
if (processor.BeginEvent(XPathNodeType.ProcessingInstruction, string.Empty, frame.StoredOutput, string.Empty, false) == false) {
// Come back later
frame.State = NameReady;
break;
}
processor.PushActionFrame(frame);
frame.State = ProcessingChildren;
break; // Allow children to run
case ProcessingChildren:
if (processor.EndEvent(XPathNodeType.ProcessingInstruction) == false) {
Debug.WriteLine("Cannot end event, breaking, will restart");
frame.State = ProcessingChildren;
break;
}
frame.Finished();
break;
default:
Debug.Fail("Invalid ElementAction execution state");
frame.Finished();
break;
}
}
internal string Evaluate(Processor processor, ActionFrame frame) {
if (IsConstant) {
Debug.Assert(constAvt != null);
return constAvt;
}
else {
Debug.Assert(processor != null && frame != null);
StringBuilder builder = processor.GetSharedStringBuilder();
for(int i = 0; i < events.Length; i ++) {
builder.Append(events[i].Evaluate(processor, frame));
}
processor.ReleaseSharedStringBuilder();
return builder.ToString();
}
}
internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
switch (frame.State) {
case Initialized:
Debug.Assert(frame.NodeSet != null);
Debug.Assert(this.selectKey != Compiler.InvalidQueryKey);
XPathExpression expr = processor.GetValueQuery(this.selectKey);
object result = frame.Node.Evaluate(expr);
XPathNodeIterator nodeSet = result as XPathNodeIterator;
if (nodeSet != null) {
processor.PushActionFrame(CopyNodeSetAction.GetAction(), nodeSet);
frame.State = NodeSetCopied;
break;
}
XPathNavigator nav = result as XPathNavigator;
if (nav != null) {
processor.PushActionFrame(CopyNodeSetAction.GetAction(), new XPathSingletonIterator(nav));
frame.State = NodeSetCopied;
break;
}
string value = XmlConvert.ToXPathString(result);
if (processor.TextEvent(value)) {
frame.Finished();
}
else {
frame.StoredOutput = value;
frame.State = ResultStored;
}
break;
case ResultStored:
Debug.Assert(frame.StoredOutput != null);
processor.TextEvent(frame.StoredOutput);
frame.Finished();
break;
case NodeSetCopied:
Debug.Assert(frame.State == NodeSetCopied);
frame.Finished();
break;
}
}
internal TemplateAction FindTemplate(Processor processor, XPathNavigator navigator) {
if (this.templates == null) {
return null;
}
Debug.Assert(this.templates != null);
for (int templateIndex = this.templates.Count - 1; templateIndex >= 0 ; templateIndex --) {
TemplateAction action = (TemplateAction) this.templates[templateIndex];
int matchKey = action.MatchKey;
if (matchKey != Compiler.InvalidQueryKey) {
if (processor.Matches(navigator, matchKey)) {
return action;
}
}
}
Debug.WriteLine("Template not found");
return null;
}
internal override void Execute(Processor processor, ActionFrame frame) {
switch(frame.State) {
case Initialized:
frame.Counter = 0;
frame.State = ProcessingSets;
goto case ProcessingSets;
case ProcessingSets:
if (frame.Counter < this.useAttributeSets.Length) {
AttributeSetAction action = processor.RootAction.GetAttributeSet(this.useAttributeSets[frame.Counter]);
frame.IncrementCounter();
processor.PushActionFrame(action, frame.NodeSet);
}
else {
frame.Finished();
}
break;
default:
Debug.Fail("Invalid Container action execution state");
break;
}
}
internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
switch (frame.State) {
case Initialized:
if (!fallback) {
throw XsltException.UnexpectedKeyword(this.name, this.parent);
}
if (this.containedActions != null && this.containedActions.Count > 0) {
processor.PushActionFrame(frame);
frame.State = ProcessingChildren;
break;
}
else goto case ProcessingChildren;
case ProcessingChildren:
frame.Finished();
break;
default:
Debug.Fail("Invalid Container action execution state");
break;
}
}
// check 'from' condition:
// if 'from' exist it has to be ancestor-or-self for the nav
private bool checkFrom(Processor processor, XPathNavigator nav) {
if(this.fromKey == Compiler.InvalidQueryKey) {
return true;
}
do {
if (processor.Matches(nav, this.fromKey)) {
return true;
}
}while (nav.MoveToParent());
return false;
}
private bool moveToCount(XPathNavigator nav, Processor processor, XPathNavigator contextNode) {
do {
if (this.fromKey != Compiler.InvalidQueryKey && processor.Matches(nav, this.fromKey)) {
return false;
}
if (MatchCountKey(processor, contextNode, nav)) {
return true;
}
}while (nav.MoveToParent());
return false;
}
internal override void Execute(Processor processor, ActionFrame frame)
{
Debug.Assert(processor != null && frame != null);
while (processor.CanContinue)
{
switch (frame.State)
{
case Initialized:
if (frame.Node.MoveToFirstNamespace(XPathNamespaceScope.ExcludeXml) == false)
{
frame.Finished();
break;
}
frame.State = BeginEvent;
goto case BeginEvent;
case BeginEvent:
Debug.Assert(frame.State == BeginEvent);
Debug.Assert(frame.Node.NodeType == XPathNodeType.Namespace);
if (processor.BeginEvent(XPathNodeType.Namespace, null, frame.Node.LocalName, frame.Node.Value, false) == false)
{
// This one wasn't output
break;
}
frame.State = EndEvent;
continue;
case EndEvent:
Debug.Assert(frame.State == EndEvent);
Debug.Assert(frame.Node.NodeType == XPathNodeType.Namespace);
if (processor.EndEvent(XPathNodeType.Namespace) == false)
{
// This one wasn't output
break;
}
frame.State = Advance;
continue;
case Advance:
Debug.Assert(frame.State == Advance);
Debug.Assert(frame.Node.NodeType == XPathNodeType.Namespace);
if (frame.Node.MoveToNextNamespace(XPathNamespaceScope.ExcludeXml))
{
frame.State = BeginEvent;
continue;
}
else
{
frame.Node.MoveToParent();
frame.Finished();
break;
}
}
break;
}// while
}
private int numberAny(Processor processor, ActionFrame frame) {
int result = 0;
// Our current point will be our end point in this search
XPathNavigator endNode = frame.Node;
if(endNode.NodeType == XPathNodeType.Attribute) {
endNode = endNode.Clone();
endNode.MoveToParent();
}
XPathNavigator startNode = endNode.Clone();
if(this.fromKey != Compiler.InvalidQueryKey) {
bool hitFrom = false;
// First try to find start by traversing up. This gives the best candidate or we hit root
do{
if(processor.Matches(startNode, this.fromKey)) {
hitFrom = true;
break;
}
}while(startNode.MoveToParent());
Debug.Assert(
processor.Matches(startNode, this.fromKey) || // we hit 'from' or
startNode.NodeType == XPathNodeType.Root // we are at root
);
// from this point (matched parent | root) create descendent quiery:
// we have to reset 'result' on each 'from' node, because this point can' be not last from point;
XPathNodeIterator sel = processor.StartQuery(startNode, Compiler.DescendantKey);
do {
if(processor.Matches(sel.Current, this.fromKey)) {
hitFrom = true;
result = 0;
}
else if(MatchCountKey(processor, frame.Node, sel.Current)) {
result ++;
}
if(sel.Current.IsSamePosition(endNode)) {
break;
}
}while (sel.MoveNext());
if(! hitFrom) {
result = 0;
}
}
else {
// without 'from' we startting from the root
startNode.MoveToRoot();
XPathNodeIterator sel = processor.StartQuery(startNode, Compiler.DescendantKey);
// and count root node by itself
do {
if (MatchCountKey(processor, frame.Node, sel.Current)) {
result ++;
}
if (sel.Current.IsSamePosition(endNode)) {
break;
}
}while (sel.MoveNext());
}
return result;
}
/// <include file='doc\XslTransform.uex' path='docs/doc[@for="XslTransform.Transform3"]/*' />
/// <devdoc>
/// <para>Transforms the XML data in the specified XPathNavigator and outputs the result
/// to a TextWriter.</para>
/// </devdoc>
public void Transform(XPathNavigator input, XsltArgumentList args, TextWriter output)
{
Processor processor = new Processor(this, input, args, _XmlResolver, output);
processor.Execute();
}
/// <include file='doc\XslTransform.uex' path='docs/doc[@for="XslTransform.Transform"]/*' />
/// <devdoc>
/// <para>Transforms the XML data in the specified XPathNavigator and
/// outputs the result to an XmlReader.</para>
/// </devdoc>
public XmlReader Transform(XPathNavigator input, XsltArgumentList args)
{
Processor processor = new Processor(this, input, args, _XmlResolver);
return(processor.Reader);
}
private static bool SendEndEvent(Processor processor, XPathNavigator node)
{
Debug.Assert(node.NodeType == XPathNodeType.Attribute);
return(processor.EndEvent(XPathNodeType.Attribute));
}
private static bool SendBeginEvent(Processor processor, XPathNavigator node)
{
Debug.Assert(node.NodeType == XPathNodeType.Attribute);
return(processor.BeginEvent(XPathNodeType.Attribute, node.Prefix, node.LocalName, node.NamespaceURI, false));
}
internal override void Execute(Processor processor, ActionFrame frame)
{
Debug.Assert(processor != null && frame != null);
while (processor.CanContinue)
{
switch (frame.State)
{
case Initialized:
if (!frame.Node.HasAttributes || frame.Node.MoveToFirstAttribute() == false)
{
frame.Finished();
break;
}
frame.State = BeginEvent;
goto case BeginEvent;
case BeginEvent:
Debug.Assert(frame.State == BeginEvent);
Debug.Assert(frame.Node.NodeType == XPathNodeType.Attribute);
if (SendBeginEvent(processor, frame.Node) == false)
{
// This one wasn't output
break;
}
frame.State = TextEvent;
continue;
case TextEvent:
Debug.Assert(frame.State == TextEvent);
Debug.Assert(frame.Node.NodeType == XPathNodeType.Attribute);
if (SendTextEvent(processor, frame.Node) == false)
{
// This one wasn't output
break;
}
frame.State = EndEvent;
continue;
case EndEvent:
Debug.Assert(frame.State == EndEvent);
Debug.Assert(frame.Node.NodeType == XPathNodeType.Attribute);
if (SendEndEvent(processor, frame.Node) == false)
{
// This one wasn't output
break;
}
frame.State = Advance;
continue;
case Advance:
Debug.Assert(frame.State == Advance);
Debug.Assert(frame.Node.NodeType == XPathNodeType.Attribute);
if (frame.Node.MoveToNextAttribute())
{
frame.State = BeginEvent;
continue;
}
else
{
frame.Node.MoveToParent();
frame.Finished();
break;
}
}
break;
}// while (processor.CanContinue)
}
public override bool Output(Processor processor, ActionFrame frame)
{
Debug.Assert(key != Compiler.InvalidQueryKey);
return(processor.TextEvent(processor.EvaluateString(frame, this.key)));
}
public override string Evaluate(Processor processor, ActionFrame frame)
{
return(processor.EvaluateString(frame, this.key));
}
private int numberCount(XPathNavigator nav, Processor processor, XPathNavigator contextNode) {
Debug.Assert(MatchCountKey(processor, contextNode, nav));
int number = 1;
XPathNodeIterator sel = processor.StartQuery(nav, Compiler.PrecedingSiblingKey);
while (sel.MoveNext()) {
if (MatchCountKey(processor, contextNode, sel.Current)) {
number++;
}
}
return number;
}
private bool MatchCountKey(Processor processor, XPathNavigator contextNode, XPathNavigator nav){
if (this.countKey != Compiler.InvalidQueryKey) {
return processor.Matches(nav, this.countKey);
}
if (contextNode.Name == nav.Name && BasicNodeType(contextNode.NodeType) == BasicNodeType(nav.NodeType)) {
return true;
}
return false;
}
internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
ArrayList list = processor.NumberList;
switch (frame.State) {
case Initialized:
Debug.Assert(frame != null);
Debug.Assert(frame.NodeSet != null);
list.Clear();
if (this.value != null) {
object valueObject = processor.Evaluate(frame, this.valueKey);
double valueDouble = 0;
try {
valueDouble = Processor.ToDouble(valueObject);
}
catch (FormatException) {}
if (0.5 <= valueDouble && valueDouble < double.PositiveInfinity) {
Debug.Assert(! double.IsNaN(valueDouble), "I belive it should be filtered by if condition");
list.Add(Math.Floor(valueDouble + 0.5)); // See XPath round for detailes on the trick with Floor()
}
else {
// It is an error if the number is NaN, infinite or less than 0.5; an XSLT processor may signal the error;
// if it does not signal the error, it must recover by converting the number to a string as if by a call
// to the string function and inserting the resulting string into the result tree.
frame.StoredOutput = XmlConvert.ToXPathString(valueObject);
goto case OutputNumber;
}
}
else if (this.level == "any") {
int number = numberAny(processor, frame);
if (number != 0) {
list.Add(number);
}
}
else {
bool multiple = (this.level == "multiple");
XPathNavigator contextNode = frame.Node; // context of xsl:number element. We using this node in MatchCountKey()
XPathNavigator countNode = frame.Node.Clone(); // node we count for
if(countNode.NodeType == XPathNodeType.Attribute) {
countNode.MoveToParent();
}
while(moveToCount(countNode, processor, contextNode)) {
list.Insert(0, numberCount(countNode, processor, contextNode));
if(! multiple || ! countNode.MoveToParent()) {
break;
}
}
if(! checkFrom(processor, countNode)) {
list.Clear();
}
}
/*CalculatingFormat:*/
frame.StoredOutput = Format(list,
this.formatAvt == null ? this.formatList : ParseFormat(this.formatAvt.Evaluate(processor, frame)),
this.langAvt == null ? this.lang : this.langAvt .Evaluate(processor, frame),
this.letterAvt == null ? this.letter : ParseLetter(this.letterAvt.Evaluate(processor, frame)),
this.groupingSepAvt == null ? this.groupingSep : this.groupingSepAvt .Evaluate(processor, frame),
this.groupingSizeAvt == null ? this.groupingSize : this.groupingSizeAvt.Evaluate(processor, frame)
);
goto case OutputNumber;
case OutputNumber :
Debug.Assert(frame.StoredOutput != null);
if (! processor.TextEvent(frame.StoredOutput)) {
frame.State = OutputNumber;
break;
}
frame.Finished();
break;
default:
Debug.Fail("Invalid Number Action execution state");
break;
}
}
public override bool Output(Processor processor, ActionFrame frame)
{
this.OnInstructionExecute(processor);
return(base.Output(processor, frame));
}
internal override void Execute(Processor processor, ActionFrame frame) {
Debug.Assert(processor != null && frame != null);
Debug.Assert(frame.State == Initialized);
processor.AddSort(this.sort != null ?
this.sort :
new Sort(
this.selectKey,
this.langAvt == null ? this.lang : ParseLang( this.langAvt .Evaluate(processor, frame)),
this.dataTypeAvt == null ? this.dataType : ParseDataType( this.dataTypeAvt .Evaluate(processor, frame), manager),
this.orderAvt == null ? this.order : ParseOrder( this.orderAvt .Evaluate(processor, frame)),
this.caseOrderAvt == null ? this.caseOrder : ParseCaseOrder(this.caseOrderAvt.Evaluate(processor, frame))
)
);
frame.Finished();
}
internal override void Execute(Processor processor, ActionFrame frame)
{
Debug.Assert(false);
}
