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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="VariableAction.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. using System.Diagnostics;
  16. using System.Xml.XPath;
  17. namespace System.Xml.Xsl.XsltOld
  18. {
  19.     using Res = System.Xml.Utils.Res;
  20.    
  21.     internal enum VariableType
  22.     {
  23.         GlobalVariable,
  24.         GlobalParameter,
  25.         LocalVariable,
  26.         LocalParameter,
  27.         WithParameter
  28.     }
  29.    
  30.     internal class VariableAction : ContainerAction, IXsltContextVariable
  31.     {
  32.         private const int ValueCalculated = 2;
  33.        
  34.         protected XmlQualifiedName name;
  35.         protected string nameStr;
  36.         protected string baseUri;
  37.         protected int selectKey = Compiler.InvalidQueryKey;
  38.         protected int stylesheetid;
  39.         protected VariableType varType;
  40.         private int varKey;
  41.        
  42.         internal int Stylesheetid {
  43.             get { return this.stylesheetid; }
  44.         }
  45.         internal XmlQualifiedName Name {
  46.             get { return this.name; }
  47.         }
  48.         internal string NameStr {
  49.             get { return this.nameStr; }
  50.         }
  51.         internal VariableType VarType {
  52.             get { return this.varType; }
  53.         }
  54.         internal int VarKey {
  55.             get { return this.varKey; }
  56.         }
  57.         internal bool IsGlobal {
  58.             get { return this.varType == VariableType.GlobalVariable || this.varType == VariableType.GlobalParameter; }
  59.         }
  60.        
  61.         internal VariableAction(VariableType type)
  62.         {
  63.             this.varType = type;
  64.         }
  65.        
  66.         internal override void Compile(Compiler compiler)
  67.         {
  68.             this.stylesheetid = compiler.Stylesheetid;
  69.             this.baseUri = compiler.Input.BaseURI;
  70.             CompileAttributes(compiler);
  71.             CheckRequiredAttribute(compiler, this.name, Keywords.s_Name);
  72.            
  73.            
  74.             if (compiler.Recurse()) {
  75.                 CompileTemplate(compiler);
  76.                 compiler.ToParent();
  77.                
  78.                 if (this.selectKey != Compiler.InvalidQueryKey && this.containedActions != null) {
  79.                     throw XsltException.Create(Res.Xslt_VariableCntSel2, this.nameStr);
  80.                 }
  81.             }
  82.             if (this.containedActions != null) {
  83.                 baseUri = baseUri + '#' + compiler.GetUnicRtfId();
  84.             }
  85.             else {
  86.                 baseUri = null;
  87.             }
  88.            
  89.             this.varKey = compiler.InsertVariable(this);
  90.         }
  91.        
  92.         internal override bool CompileAttribute(Compiler compiler)
  93.         {
  94.             string name = compiler.Input.LocalName;
  95.             string value = compiler.Input.Value;
  96.            
  97.             if (Keywords.Equals(name, compiler.Atoms.Name)) {
  98.                 Debug.Assert(this.name == null && this.nameStr == null);
  99.                 this.nameStr = value;
  100.                 this.name = compiler.CreateXPathQName(this.nameStr);
  101.             }
  102.             else if (Keywords.Equals(name, compiler.Atoms.Select)) {
  103.                 this.selectKey = compiler.AddQuery(value);
  104.             }
  105.             else {
  106.                 return false;
  107.             }
  108.            
  109.             return true;
  110.         }
  111.        
  112.         internal override void Execute(Processor processor, ActionFrame frame)
  113.         {
  114.             Debug.Assert(processor != null && frame != null && frame.State != ValueCalculated);
  115.             object value = null;
  116.            
  117.             switch (frame.State) {
  118.                 case Initialized:
  119.                     if (IsGlobal) {
  120.                         if (frame.GetVariable(this.varKey) != null) {
  121.                             // This var was calculated already
  122.                             frame.Finished();
  123.                             break;
  124.                         }
  125.                         stylesheetid = -1;
  126.                         // Mark that variable is in use to catch loops in global variables;
  127.                     }
  128.                     // If this is a parameter, check whether the caller has passed the value
  129.                     if (this.varType == VariableType.GlobalParameter) {
  130.                         value = processor.GetGlobalParameter(this.name);
  131.                     }
  132.                     else if (this.varType == VariableType.LocalParameter) {
  133.                         value = processor.GetParameter(this.name);
  134.                     }
  135.                     if (value != null) {
  136.                         goto case ValueCalculated;
  137.                     }
  138.                    
  139.                     // If value was not passed, check the 'select' attribute
  140.                     if (this.selectKey != Compiler.InvalidQueryKey) {
  141.                         value = processor.RunQuery(frame, this.selectKey);
  142.                         goto case ValueCalculated;
  143.                     }
  144.                    
  145.                     // If there is no 'select' attribute and the content is empty, use the empty string
  146.                     if (this.containedActions == null) {
  147.                         value = string.Empty;
  148.                         goto case ValueCalculated;
  149.                     }
  150.                    
  151.                     // RTF case
  152.                     NavigatorOutput output = new NavigatorOutput(this.baseUri);
  153.                     processor.PushOutput(output);
  154.                     processor.PushActionFrame(frame);
  155.                     frame.State = ProcessingChildren;
  156.                     break;
  157.                 case ProcessingChildren:
  158.                    
  159.                     RecordOutput recOutput = processor.PopOutput();
  160.                     Debug.Assert(recOutput is NavigatorOutput);
  161.                     value = ((NavigatorOutput)recOutput).Navigator;
  162.                     goto case ValueCalculated;
  163.                     break;
  164.                 case ValueCalculated:
  165.                    
  166.                     Debug.Assert(value != null);
  167.                     frame.SetVariable(this.varKey, value);
  168.                     frame.Finished();
  169.                     break;
  170.                 default:
  171.                    
  172.                     Debug.Fail("Invalid execution state inside VariableAction.Execute");
  173.                     break;
  174.             }
  175.         }
  176.        
  177.         // ---------------------- IXsltContextVariable --------------------
  178.        
  179.         XPathResultType IXsltContextVariable.VariableType {
  180.             get { return XPathResultType.Any; }
  181.         }
  182.         object IXsltContextVariable.Evaluate(XsltContext xsltContext)
  183.         {
  184.             return ((XsltCompileContext)xsltContext).EvaluateVariable(this);
  185.         }
  186.         bool IXsltContextVariable.IsLocal {
  187.             get { return this.varType == VariableType.LocalVariable || this.varType == VariableType.LocalParameter; }
  188.         }
  189.         bool IXsltContextVariable.IsParam {
  190.             get { return this.varType == VariableType.LocalParameter || this.varType == VariableType.GlobalParameter; }
  191.         }
  192.     }
  193. }

Developer Fusion