The Labs \ Source Viewer \ SSCLI \ System.Xml.Xsl.Xslt \ XsltQilFactory

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XsltQilFactory.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.Collections.Generic;
  16. using System.Diagnostics;
  17. using System.Xml.Schema;
  18. using System.Xml.Xsl.Qil;
  19. using System.Xml.Xsl.Runtime;
  20. using System.Xml.Xsl.XPath;
  21. namespace System.Xml.Xsl.Xslt
  22. {
  23.     using Res = System.Xml.Utils.Res;
  24.     using T = XmlQueryTypeFactory;
  25.    
  26.     internal class XsltQilFactory : XPathQilFactory
  27.     {
  28.        
  29.         public XsltQilFactory(QilFactory f, bool debug) : base(f, debug)
  30.         {
  31.         }
  32.        
  33.         [Conditional("DEBUG")]
  34.         public void CheckXsltType(QilNode n)
  35.         {
  36.             // Five possible types are: anyType, node-set, string, boolean, and number
  37.             XmlQueryType xt = n.XmlType;
  38.             switch (xt.TypeCode) {
  39.                 case XmlTypeCode.String:
  40.                 case XmlTypeCode.Boolean:
  41.                 case XmlTypeCode.Double:
  42.                     Debug.Assert(xt.IsSingleton && xt.IsStrict, "Xslt assumes that these types will always be singleton and strict");
  43.                     break;
  44.                 case XmlTypeCode.Item:
  45.                 case XmlTypeCode.None:
  46.                     break;
  47.                 case XmlTypeCode.QName:
  48.                     Debug.Assert(IsDebug, "QName is reserved as the marker for missing values");
  49.                     break;
  50.                 default:
  51.                     Debug.Assert(xt.IsNode, "Unexpected expression type: " + xt.ToString());
  52.                     break;
  53.             }
  54.         }
  55.        
  56.         [Conditional("DEBUG")]
  57.         public void CheckQName(QilNode n)
  58.         {
  59.             Debug.Assert(n != null && n.XmlType.IsSubtypeOf(T.QNameX), "Must be a singleton QName");
  60.         }
  61.        
  62.         // We use a value of XmlQualifiedName type to denote a missing parameter
  63.         public QilNode DefaultValueMarker()
  64.         {
  65.             return QName("default-value", XmlReservedNs.NsXslDebug);
  66.         }
  67.        
  68.         public QilNode IsDefaultValueMarker(QilNode n)
  69.         {
  70.             return IsType(n, T.QNameX);
  71.         }
  72.        
  73.         public QilNode InvokeIsSameNodeSort(QilNode n1, QilNode n2)
  74.         {
  75.             CheckNodeNotRtf(n1);
  76.             CheckNodeNotRtf(n2);
  77.             return XsltInvokeEarlyBound(QName("is-same-node-sort"), XsltMethods.IsSameNodeSort, T.BooleanX, new QilNode[] {n1, n2});
  78.         }
  79.        
  80.         public QilNode InvokeSystemProperty(QilNode n)
  81.         {
  82.             CheckQName(n);
  83.             return XsltInvokeEarlyBound(QName("system-property"), XsltMethods.SystemProperty, T.Choice(T.DoubleX, T.StringX), new QilNode[] {n});
  84.         }
  85.        
  86.         public QilNode InvokeElementAvailable(QilNode n)
  87.         {
  88.             CheckQName(n);
  89.             return XsltInvokeEarlyBound(QName("element-available"), XsltMethods.ElementAvailable, T.BooleanX, new QilNode[] {n});
  90.         }
  91.        
  92.         public QilNode InvokeCheckScriptNamespace(string nsUri)
  93.         {
  94.             return XsltInvokeEarlyBound(QName("register-script-namespace"), XsltMethods.CheckScriptNamespace, T.IntX, new QilNode[] {String(nsUri)});
  95.         }
  96.        
  97.         public QilNode InvokeFunctionAvailable(QilNode n)
  98.         {
  99.             CheckQName(n);
  100.             return XsltInvokeEarlyBound(QName("function-available"), XsltMethods.FunctionAvailable, T.BooleanX, new QilNode[] {n});
  101.         }
  102.        
  103.         public QilNode InvokeBaseUri(QilNode n)
  104.         {
  105.             CheckNode(n);
  106.             return XsltInvokeEarlyBound(QName("base-uri"), XsltMethods.BaseUri, T.StringX, new QilNode[] {n});
  107.         }
  108.        
  109.         public QilNode InvokeLangToLcid(QilNode n, bool fwdCompat)
  110.         {
  111.             CheckString(n);
  112.             return XsltInvokeEarlyBound(QName("lang-to-lcid"), XsltMethods.LangToLcid, T.IntX, new QilNode[] {n, Boolean(fwdCompat)});
  113.         }
  114.        
  115.         public QilNode InvokeNumberFormat(QilNode value, QilNode format, QilNode lang, QilNode letterValue, QilNode groupingSeparator, QilNode groupingSize)
  116.         {
  117.             Debug.Assert(value != null && (value.XmlType.IsSubtypeOf(T.IntXS) || value.XmlType.IsSubtypeOf(T.DoubleX)), "Value must be either a sequence of ints, or a double singleton");
  118.             CheckString(format);
  119.             CheckDouble(lang);
  120.             CheckString(letterValue);
  121.             CheckString(groupingSeparator);
  122.             CheckDouble(groupingSize);
  123.            
  124.             return XsltInvokeEarlyBound(QName("number-format"), XsltMethods.NumberFormat, T.StringX, new QilNode[] {value, format, lang, letterValue, groupingSeparator, groupingSize});
  125.         }
  126.        
  127.         public QilNode InvokeRegisterDecimalFormat(DecimalFormatDecl format)
  128.         {
  129.             Debug.Assert(format != null);
  130.             return XsltInvokeEarlyBound(QName("register-decimal-format"), XsltMethods.RegisterDecimalFormat, T.IntX, new QilNode[] {QName(format.Name.Name, format.Name.Namespace), String(format.InfinitySymbol), String(format.NanSymbol), String(new string(format.Characters))});
  131.         }
  132.        
  133.         public QilNode InvokeRegisterDecimalFormatter(QilNode formatPicture, DecimalFormatDecl format)
  134.         {
  135.             CheckString(formatPicture);
  136.             Debug.Assert(format != null);
  137.             return XsltInvokeEarlyBound(QName("register-decimal-formatter"), XsltMethods.RegisterDecimalFormatter, T.DoubleX, new QilNode[] {formatPicture, String(format.InfinitySymbol), String(format.NanSymbol), String(new string(format.Characters))});
  138.         }
  139.        
  140.         public QilNode InvokeFormatNumberStatic(QilNode value, QilNode decimalFormatIndex)
  141.         {
  142.             CheckDouble(value);
  143.             CheckDouble(decimalFormatIndex);
  144.             return XsltInvokeEarlyBound(QName("format-number-static"), XsltMethods.FormatNumberStatic, T.StringX, new QilNode[] {value, decimalFormatIndex});
  145.         }
  146.        
  147.         public QilNode InvokeFormatNumberDynamic(QilNode value, QilNode formatPicture, QilNode decimalFormatName, QilNode errorMessageName)
  148.         {
  149.             CheckDouble(value);
  150.             CheckString(formatPicture);
  151.             CheckQName(decimalFormatName);
  152.             CheckString(errorMessageName);
  153.             return XsltInvokeEarlyBound(QName("format-number-dynamic"), XsltMethods.FormatNumberDynamic, T.StringX, new QilNode[] {value, formatPicture, decimalFormatName, errorMessageName});
  154.         }
  155.        
  156.         public QilNode InvokeOuterXml(QilNode n)
  157.         {
  158.             CheckNode(n);
  159.             return XsltInvokeEarlyBound(QName("outer-xml"), XsltMethods.OuterXml, T.StringX, new QilNode[] {n});
  160.         }
  161.        
  162.         public QilNode InvokeMsFormatDateTime(QilNode datetime, QilNode format, QilNode lang, QilNode isDate)
  163.         {
  164.             CheckString(datetime);
  165.             CheckString(format);
  166.             CheckString(lang);
  167.             CheckBool(isDate);
  168.             return XsltInvokeEarlyBound(QName("ms:format-date-time"), XsltMethods.MSFormatDateTime, T.StringX, new QilNode[] {datetime, format, lang, isDate});
  169.         }
  170.        
  171.         public QilNode InvokeMsStringCompare(QilNode x, QilNode y, QilNode lang, QilNode options)
  172.         {
  173.             CheckString(x);
  174.             CheckString(y);
  175.             CheckString(lang);
  176.             CheckString(options);
  177.             return XsltInvokeEarlyBound(QName("ms:string-compare"), XsltMethods.MSStringCompare, T.DoubleX, new QilNode[] {x, y, lang, options});
  178.         }
  179.        
  180.         public QilNode InvokeMsUtc(QilNode n)
  181.         {
  182.             CheckString(n);
  183.             return XsltInvokeEarlyBound(QName("ms:utc"), XsltMethods.MSUtc, T.StringX, new QilNode[] {n});
  184.         }
  185.        
  186.         public QilNode InvokeMsNumber(QilNode n)
  187.         {
  188.             return XsltInvokeEarlyBound(QName("ms:number"), XsltMethods.MSNumber, T.DoubleX, new QilNode[] {n});
  189.         }
  190.        
  191.         public QilNode InvokeMsLocalName(QilNode n)
  192.         {
  193.             CheckString(n);
  194.             return XsltInvokeEarlyBound(QName("ms:local-name"), XsltMethods.MSLocalName, T.StringX, new QilNode[] {n});
  195.         }
  196.        
  197.         public QilNode InvokeMsNamespaceUri(QilNode n, QilNode currentNode)
  198.         {
  199.             CheckString(n);
  200.             CheckNodeNotRtf(currentNode);
  201.             return XsltInvokeEarlyBound(QName("ms:namespace-uri"), XsltMethods.MSNamespaceUri, T.StringX, new QilNode[] {n, currentNode});
  202.         }
  203.        
  204.         public QilNode InvokeEXslObjectType(QilNode n)
  205.         {
  206.             return XsltInvokeEarlyBound(QName("exsl:object-type"), XsltMethods.EXslObjectType, T.StringX, new QilNode[] {n});
  207.         }
  208.     }
  209. }

Developer Fusion