The Labs \ Source Viewer \ SSCLI \ System.Xml.Xsl.XsltOld \ CallTemplateAction

  1. //------------------------------------------------------------------------------
  2. // <copyright file="CallTemplateAction.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. namespace System.Xml.Xsl.XsltOld
  16. {
  17.     using Res = System.Xml.Utils.Res;
  18.     using System;
  19.     using System.Diagnostics;
  20.     using System.Xml;
  21.     using System.Xml.XPath;
  22.    
  23.     internal class CallTemplateAction : ContainerAction
  24.     {
  25.         private const int ProcessedChildren = 2;
  26.         private const int ProcessedTemplate = 3;
  27.         private XmlQualifiedName name;
  28.        
  29.         internal override void Compile(Compiler compiler)
  30.         {
  31.             CompileAttributes(compiler);
  32.             CheckRequiredAttribute(compiler, this.name, Keywords.s_Name);
  33.             CompileContent(compiler);
  34.         }
  35.        
  36.         internal override bool CompileAttribute(Compiler compiler)
  37.         {
  38.             string name = compiler.Input.LocalName;
  39.             string value = compiler.Input.Value;
  40.             if (Keywords.Equals(name, compiler.Atoms.Name)) {
  41.                 Debug.Assert(this.name == null);
  42.                 this.name = compiler.CreateXPathQName(value);
  43.             }
  44.             else {
  45.                 return false;
  46.             }
  47.            
  48.             return true;
  49.         }
  50.        
  51.         private void CompileContent(Compiler compiler)
  52.         {
  53.             NavigatorInput input = compiler.Input;
  54.            
  55.             if (compiler.Recurse()) {
  56.                 do {
  57.                     switch (input.NodeType) {
  58.                         case XPathNodeType.Element:
  59.                             compiler.PushNamespaceScope();
  60.                             string nspace = input.NamespaceURI;
  61.                             string name = input.LocalName;
  62.                            
  63.                             if (Keywords.Equals(nspace, input.Atoms.XsltNamespace) && Keywords.Equals(name, input.Atoms.WithParam)) {
  64.                                 WithParamAction par = compiler.CreateWithParamAction();
  65.                                 CheckDuplicateParams(par.Name);
  66.                                 AddAction(par);
  67.                             }
  68.                             else {
  69.                                 throw compiler.UnexpectedKeyword();
  70.                             }
  71.                             compiler.PopScope();
  72.                             break;
  73.                         case XPathNodeType.Comment:
  74.                         case XPathNodeType.ProcessingInstruction:
  75.                         case XPathNodeType.Whitespace:
  76.                         case XPathNodeType.SignificantWhitespace:
  77.                             break;
  78.                         default:
  79.                             throw XsltException.Create(Res.Xslt_InvalidContents, Keywords.s_CallTemplate);
  80.                             break;
  81.                     }
  82.                 }
  83.                 while (compiler.Advance());
  84.                
  85.                 compiler.ToParent();
  86.             }
  87.         }
  88.        
  89.         internal override void Execute(Processor processor, ActionFrame frame)
  90.         {
  91.             Debug.Assert(processor != null && frame != null);
  92.             switch (frame.State) {
  93.                 case Initialized:
  94.                     processor.ResetParams();
  95.                     if (this.containedActions != null && this.containedActions.Count > 0) {
  96.                         processor.PushActionFrame(frame);
  97.                         frame.State = ProcessedChildren;
  98.                         break;
  99.                     }
  100.                     goto case ProcessedChildren;
  101.                     break;
  102.                 case ProcessedChildren:
  103.                     TemplateAction action = processor.Stylesheet.FindTemplate(this.name);
  104.                     if (action != null) {
  105.                         frame.State = ProcessedTemplate;
  106.                         processor.PushActionFrame(action, frame.NodeSet);
  107.                         break;
  108.                     }
  109.                     else {
  110.                         throw XsltException.Create(Res.Xslt_InvalidCallTemplate, this.name.ToString());
  111.                     }
  112.                     break;
  113.                 case ProcessedTemplate:
  114.                     frame.Finished();
  115.                     break;
  116.                 default:
  117.                     Debug.Fail("Invalid CallTemplateAction execution state");
  118.                     break;
  119.             }
  120.         }
  121.     }
  122. }

Developer Fusion