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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="Keywords.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.    
  22.     internal class Keywords
  23.     {
  24.         XmlNameTable _NameTable;
  25.         internal Keywords(XmlNameTable nameTable)
  26.         {
  27.             Debug.Assert(nameTable != null);
  28.             _NameTable = nameTable;
  29.         }
  30.        
  31.         internal void LookupKeywords()
  32.         {
  33.             _AtomEmpty = _NameTable.Add(string.Empty);
  34.             _AtomXsltNamespace = _NameTable.Add(s_XsltNamespace);
  35.             _AtomApplyTemplates = _NameTable.Add(s_ApplyTemplates);
  36.             _AtomChoose = _NameTable.Add(s_Choose);
  37.             _AtomForEach = _NameTable.Add(s_ForEach);
  38.             _AtomIf = _NameTable.Add(s_If);
  39.             _AtomOtherwise = _NameTable.Add(s_Otherwise);
  40.             _AtomStylesheet = _NameTable.Add(s_Stylesheet);
  41.             _AtomTemplate = _NameTable.Add(s_Template);
  42.             _AtomTransform = _NameTable.Add(s_Transform);
  43.             _AtomValueOf = _NameTable.Add(s_ValueOf);
  44.             _AtomWhen = _NameTable.Add(s_When);
  45.             _AtomMatch = _NameTable.Add(s_Match);
  46.             _AtomName = _NameTable.Add(s_Name);
  47.             _AtomSelect = _NameTable.Add(s_Select);
  48.             _AtomTest = _NameTable.Add(s_Test);
  49.            
  50.             _AtomMsXsltNamespace = _NameTable.Add(s_MsXsltNamespace);
  51.             _AtomScript = _NameTable.Add(s_Script);
  52.             CheckKeyword(_AtomEmpty);
  53.             CheckKeyword(_AtomXsltNamespace);
  54.             CheckKeyword(_AtomApplyTemplates);
  55.             CheckKeyword(_AtomChoose);
  56.             CheckKeyword(_AtomForEach);
  57.             CheckKeyword(_AtomIf);
  58.             CheckKeyword(_AtomOtherwise);
  59.             CheckKeyword(_AtomStylesheet);
  60.             CheckKeyword(_AtomTemplate);
  61.             CheckKeyword(_AtomTransform);
  62.             CheckKeyword(_AtomValueOf);
  63.             CheckKeyword(_AtomWhen);
  64.             CheckKeyword(_AtomMatch);
  65.             CheckKeyword(_AtomName);
  66.             CheckKeyword(_AtomSelect);
  67.             CheckKeyword(_AtomTest);
  68.             CheckKeyword(_AtomMsXsltNamespace);
  69.             CheckKeyword(_AtomScript);
  70.         }
  71.        
  72.         private string _AtomEmpty;
  73.         private string _AtomXsltNamespace;
  74.         private string _AtomApplyImports;
  75.         private string _AtomApplyTemplates;
  76.         private string _AtomAttribute;
  77.         private string _AtomAttributeSet;
  78.         private string _AtomCallTemplate;
  79.         private string _AtomChoose;
  80.         private string _AtomComment;
  81.         private string _AtomCopy;
  82.         private string _AtomCopyOf;
  83.         private string _AtomDecimalFormat;
  84.         private string _AtomElement;
  85.         private string _AtomFallback;
  86.         private string _AtomForEach;
  87.         private string _AtomIf;
  88.         private string _AtomImport;
  89.         private string _AtomInclude;
  90.         private string _AtomKey;
  91.         private string _AtomMessage;
  92.         private string _AtomNamespaceAlias;
  93.         private string _AtomNumber;
  94.         private string _AtomOtherwise;
  95.         private string _AtomOutput;
  96.         private string _AtomParam;
  97.         private string _AtomPreserveSpace;
  98.         private string _AtomProcessingInstruction;
  99.         private string _AtomSort;
  100.         private string _AtomStripSpace;
  101.         private string _AtomStylesheet;
  102.         private string _AtomTemplate;
  103.         private string _AtomText;
  104.         private string _AtomTransform;
  105.         private string _AtomValueOf;
  106.         private string _AtomVariable;
  107.         private string _AtomWhen;
  108.         private string _AtomWithParam;
  109.         private string _AtomCaseOrder;
  110.         private string _AtomCdataSectionElements;
  111.         private string _AtomCount;
  112.         private string _AtomDataType;
  113.         private string _AtomDecimalSeparator;
  114.         private string _AtomDigit;
  115.         private string _AtomDisableOutputEscaping;
  116.         private string _AtomDoctypePublic;
  117.         private string _AtomDoctypeSystem;
  118.         private string _AtomElements;
  119.         private string _AtomEncoding;
  120.         private string _AtomExcludeResultPrefixes;
  121.         private string _AtomExtensionElementPrefixes;
  122.         private string _AtomFormat;
  123.         private string _AtomFrom;
  124.         private string _AtomGroupingSeparator;
  125.         private string _AtomGroupingSize;
  126.         private string _AtomHref;
  127.         private string _AtomId;
  128.         private string _AtomIndent;
  129.         private string _AtomInfinity;
  130.         private string _AtomLang;
  131.         private string _AtomLetterValue;
  132.         private string _AtomLevel;
  133.         private string _AtomMatch;
  134.         private string _AtomMediaType;
  135.         private string _AtomMethod;
  136.         private string _AtomMinusSign;
  137.         private string _AtomMode;
  138.         private string _AtomName;
  139.         private string _AtomNamespace;
  140.         private string _AtomNaN;
  141.         private string _AtomOmitXmlDeclaration;
  142.         private string _AtomOrder;
  143.         private string _AtomPatternSeparator;
  144.         private string _AtomPercent;
  145.         private string _AtomPerMille;
  146.         private string _AtomPriority;
  147.         private string _AtomResultPrefix;
  148.         private string _AtomSelect;
  149.         private string _AtomStandalone;
  150.         private string _AtomStylesheetPrefix;
  151.         private string _AtomTerminate;
  152.         private string _AtomTest;
  153.         private string _AtomUse;
  154.         private string _AtomUseAttributeSets;
  155.         private string _AtomValue;
  156.         private string _AtomVersion;
  157.         private string _AtomZeroDigit;
  158.         private string _AtomHashDefault;
  159.         private string _AtomNo;
  160.         private string _AtomYes;
  161.        
  162.         private string _AtomMsXsltNamespace;
  163.         private string _AtomScript;
  164.         private string _AtomLanguage;
  165.         private string _AtomImplementsPrefix;
  166.        
  167.         internal const string s_Xmlns = "xmlns";
  168.         internal const string s_XsltNamespace = XmlReservedNs.NsXslt;
  169.         internal const string s_XmlNamespace = XmlReservedNs.NsXml;
  170.         internal const string s_XmlnsNamespace = XmlReservedNs.NsXmlNs;
  171.         internal const string s_WdXslNamespace = XmlReservedNs.NsWdXsl;
  172.         internal const string s_Version10 = "1.0";
  173.         internal const string s_ApplyImports = "apply-imports";
  174.         internal const string s_ApplyTemplates = "apply-templates";
  175.         internal const string s_Attribute = "attribute";
  176.         internal const string s_AttributeSet = "attribute-set";
  177.         internal const string s_CallTemplate = "call-template";
  178.         internal const string s_Choose = "choose";
  179.         internal const string s_Comment = "comment";
  180.         internal const string s_Copy = "copy";
  181.         internal const string s_CopyOf = "copy-of";
  182.         internal const string s_DecimalFormat = "decimal-format";
  183.         internal const string s_Element = "element";
  184.         internal const string s_Fallback = "fallback";
  185.         internal const string s_ForEach = "for-each";
  186.         internal const string s_If = "if";
  187.         internal const string s_Import = "import";
  188.         internal const string s_Include = "include";
  189.         internal const string s_Key = "key";
  190.         internal const string s_Message = "message";
  191.         internal const string s_NamespaceAlias = "namespace-alias";
  192.         internal const string s_Number = "number";
  193.         internal const string s_Otherwise = "otherwise";
  194.         internal const string s_Output = "output";
  195.         internal const string s_Param = "param";
  196.         internal const string s_PreserveSpace = "preserve-space";
  197.         internal const string s_ProcessingInstruction = "processing-instruction";
  198.         internal const string s_Sort = "sort";
  199.         internal const string s_StripSpace = "strip-space";
  200.         internal const string s_Stylesheet = "stylesheet";
  201.         internal const string s_Template = "template";
  202.         internal const string s_Text = "text";
  203.         internal const string s_Transform = "transform";
  204.         internal const string s_ValueOf = "value-of";
  205.         internal const string s_Variable = "variable";
  206.         internal const string s_When = "when";
  207.         internal const string s_WithParam = "with-param";
  208.         internal const string s_CaseOrder = "case-order";
  209.         internal const string s_CdataSectionElements = "cdata-section-elements";
  210.         internal const string s_Count = "count";
  211.         internal const string s_DataType = "data-type";
  212.         internal const string s_DecimalSeparator = "decimal-separator";
  213.         internal const string s_Digit = "digit";
  214.         internal const string s_DisableOutputEscaping = "disable-output-escaping";
  215.         internal const string s_DoctypePublic = "doctype-public";
  216.         internal const string s_DoctypeSystem = "doctype-system";
  217.         internal const string s_Elements = "elements";
  218.         internal const string s_Encoding = "encoding";
  219.         internal const string s_ExcludeResultPrefixes = "exclude-result-prefixes";
  220.         internal const string s_ExtensionElementPrefixes = "extension-element-prefixes";
  221.         internal const string s_Format = "format";
  222.         internal const string s_From = "from";
  223.         internal const string s_GroupingSeparator = "grouping-separator";
  224.         internal const string s_GroupingSize = "grouping-size";
  225.         internal const string s_Href = "href";
  226.         internal const string s_Id = "id";
  227.         internal const string s_Indent = "indent";
  228.         internal const string s_Infinity = "infinity";
  229.         internal const string s_Lang = "lang";
  230.         internal const string s_LetterValue = "letter-value";
  231.         internal const string s_Level = "level";
  232.         internal const string s_Match = "match";
  233.         internal const string s_MediaType = "media-type";
  234.         internal const string s_Method = "method";
  235.         internal const string s_MinusSign = "minus-sign";
  236.         internal const string s_Mode = "mode";
  237.         internal const string s_Name = "name";
  238.         internal const string s_Namespace = "namespace";
  239.         internal const string s_NaN = "NaN";
  240.         internal const string s_OmitXmlDeclaration = "omit-xml-declaration";
  241.         internal const string s_Order = "order";
  242.         internal const string s_PatternSeparator = "pattern-separator";
  243.         internal const string s_Percent = "percent";
  244.         internal const string s_PerMille = "per-mille";
  245.         internal const string s_Priority = "priority";
  246.         internal const string s_ResultPrefix = "result-prefix";
  247.         internal const string s_Select = "select";
  248.         internal const string s_Space = "space";
  249.         internal const string s_Standalone = "standalone";
  250.         internal const string s_StylesheetPrefix = "stylesheet-prefix";
  251.         internal const string s_Terminate = "terminate";
  252.         internal const string s_Test = "test";
  253.         internal const string s_Use = "use";
  254.         internal const string s_UseAttributeSets = "use-attribute-sets";
  255.         internal const string s_Value = "value";
  256.         internal const string s_Version = "version";
  257.         internal const string s_ZeroDigit = "zero-digit";
  258.         internal const string s_Alphabetic = "alphabetic";
  259.         internal const string s_Any = "any";
  260.         internal const string s_Ascending = "ascending";
  261.         internal const string s_Descending = "descending";
  262.         internal const string s_HashDefault = "#default";
  263.         internal const string s_Html = "html";
  264.         internal const string s_LowerFirst = "lower-first";
  265.         internal const string s_Multiple = "multiple";
  266.         internal const string s_No = "no";
  267.         internal const string s_Single = "single";
  268.         internal const string s_Traditional = "traditional";
  269.         internal const string s_UpperFirst = "upper-first";
  270.         internal const string s_Xml = "xml";
  271.         internal const string s_Yes = "yes";
  272.         internal const string s_Vendor = "vendor";
  273.         internal const string s_VendorUrl = "vendor-url";
  274.        
  275.         // extension
  276.         internal const string s_MsXsltNamespace = "urn:schemas-microsoft-com:xslt";
  277.         internal const string s_Script = "script";
  278.         internal const string s_Language = "language";
  279.         internal const string s_ImplementsPrefix = "implements-prefix";
  280.        
  281.        
  282.         // string.Empty
  283.         internal string Empty {
  284.             get {
  285.                 CheckKeyword(_AtomEmpty);
  286.                 return _AtomEmpty;
  287.             }
  288.         }
  289.        
  290.         // http://www.w3.org/1999/XSL/Transform
  291.         internal string XsltNamespace {
  292.             get {
  293.                 CheckKeyword(_AtomXsltNamespace);
  294.                 return _AtomXsltNamespace;
  295.             }
  296.         }
  297.        
  298.         // apply-imports
  299.         internal string ApplyImports {
  300.             get {
  301.                 if (_AtomApplyImports == null)
  302.                     _AtomApplyImports = _NameTable.Add(s_ApplyImports);
  303.                 CheckKeyword(_AtomApplyImports);
  304.                 return _AtomApplyImports;
  305.             }
  306.         }
  307.        
  308.         // apply-templates
  309.         internal string ApplyTemplates {
  310.             get {
  311.                 CheckKeyword(_AtomApplyTemplates);
  312.                 return _AtomApplyTemplates;
  313.             }
  314.         }
  315.        
  316.         // attribute
  317.         internal string Attribute {
  318.             get {
  319.                 if (_AtomAttribute == null)
  320.                     _AtomAttribute = _NameTable.Add(s_Attribute);
  321.                 CheckKeyword(_AtomAttribute);
  322.                 return _AtomAttribute;
  323.             }
  324.         }
  325.        
  326.         // attribute-set
  327.         internal string AttributeSet {
  328.             get {
  329.                 if (_AtomAttributeSet == null)
  330.                     _AtomAttributeSet = _NameTable.Add(s_AttributeSet);
  331.                 CheckKeyword(_AtomAttributeSet);
  332.                 return _AtomAttributeSet;
  333.             }
  334.         }
  335.        
  336.         // call-template
  337.         internal string CallTemplate {
  338.             get {
  339.                 if (_AtomCallTemplate == null)
  340.                     _AtomCallTemplate = _NameTable.Add(s_CallTemplate);
  341.                 CheckKeyword(_AtomCallTemplate);
  342.                 return _AtomCallTemplate;
  343.             }
  344.         }
  345.        
  346.         // choose
  347.         internal string Choose {
  348.             get {
  349.                 CheckKeyword(_AtomChoose);
  350.                 return _AtomChoose;
  351.             }
  352.         }
  353.        
  354.         // comment
  355.         internal string Comment {
  356.             get {
  357.                 if (_AtomComment == null)
  358.                     _AtomComment = _NameTable.Add(s_Comment);
  359.                 CheckKeyword(_AtomComment);
  360.                 return _AtomComment;
  361.             }
  362.         }
  363.        
  364.         // copy
  365.         internal string Copy {
  366.             get {
  367.                 if (_AtomCopy == null)
  368.                     _AtomCopy = _NameTable.Add(s_Copy);
  369.                 CheckKeyword(_AtomCopy);
  370.                 return _AtomCopy;
  371.             }
  372.         }
  373.        
  374.         // copy-of
  375.         internal string CopyOf {
  376.             get {
  377.                 if (_AtomCopyOf == null)
  378.                     _AtomCopyOf = _NameTable.Add(s_CopyOf);
  379.                 CheckKeyword(_AtomCopyOf);
  380.                 return _AtomCopyOf;
  381.             }
  382.         }
  383.        
  384.         // decimal-format
  385.         internal string DecimalFormat {
  386.             get {
  387.                 if (_AtomDecimalFormat == null)
  388.                     _AtomDecimalFormat = _NameTable.Add(s_DecimalFormat);
  389.                 CheckKeyword(_AtomDecimalFormat);
  390.                 return _AtomDecimalFormat;
  391.             }
  392.         }
  393.        
  394.         // element
  395.         internal string Element {
  396.             get {
  397.                 if (_AtomElement == null)
  398.                     _AtomElement = _NameTable.Add(s_Element);
  399.                 CheckKeyword(_AtomElement);
  400.                 return _AtomElement;
  401.             }
  402.         }
  403.        
  404.         // fallback
  405.         internal string Fallback {
  406.             get {
  407.                 if (_AtomFallback == null)
  408.                     _AtomFallback = _NameTable.Add(s_Fallback);
  409.                 CheckKeyword(_AtomFallback);
  410.                 return _AtomFallback;
  411.             }
  412.         }
  413.        
  414.         // for-each
  415.         internal string ForEach {
  416.             get {
  417.                 CheckKeyword(_AtomForEach);
  418.                 return _AtomForEach;
  419.             }
  420.         }
  421.        
  422.         // if
  423.         internal string If {
  424.             get {
  425.                 CheckKeyword(_AtomIf);
  426.                 return _AtomIf;
  427.             }
  428.         }
  429.        
  430.         // import
  431.         internal string Import {
  432.             get {
  433.                 if (_AtomImport == null)
  434.                     _AtomImport = _NameTable.Add(s_Import);
  435.                 CheckKeyword(_AtomImport);
  436.                 return _AtomImport;
  437.             }
  438.         }
  439.        
  440.         // include
  441.         internal string Include {
  442.             get {
  443.                 if (_AtomInclude == null)
  444.                     _AtomInclude = _NameTable.Add(s_Include);
  445.                 CheckKeyword(_AtomInclude);
  446.                 return _AtomInclude;
  447.             }
  448.         }
  449.        
  450.         // key
  451.         internal string Key {
  452.             get {
  453.                 if (_AtomKey == null)
  454.                     _AtomKey = _NameTable.Add(s_Key);
  455.                 CheckKeyword(_AtomKey);
  456.                 return _AtomKey;
  457.             }
  458.         }
  459.        
  460.         // message
  461.         internal string Message {
  462.             get {
  463.                 if (_AtomMessage == null)
  464.                     _AtomMessage = _NameTable.Add(s_Message);
  465.                 CheckKeyword(_AtomMessage);
  466.                 return _AtomMessage;
  467.             }
  468.         }
  469.        
  470.         // namespace-alias
  471.         internal string NamespaceAlias {
  472.             get {
  473.                 if (_AtomNamespaceAlias == null)
  474.                     _AtomNamespaceAlias = _NameTable.Add(s_NamespaceAlias);
  475.                 CheckKeyword(_AtomNamespaceAlias);
  476.                 return _AtomNamespaceAlias;
  477.             }
  478.         }
  479.        
  480.         // number
  481.         internal string Number {
  482.             get {
  483.                 if (_AtomNumber == null)
  484.                     _AtomNumber = _NameTable.Add(s_Number);
  485.                 CheckKeyword(_AtomNumber);
  486.                 return _AtomNumber;
  487.             }
  488.         }
  489.        
  490.         // otherwise
  491.         internal string Otherwise {
  492.             get {
  493.                 CheckKeyword(_AtomOtherwise);
  494.                 return _AtomOtherwise;
  495.             }
  496.         }
  497.        
  498.         // output
  499.         internal string Output {
  500.             get {
  501.                 if (_AtomOutput == null)
  502.                     _AtomOutput = _NameTable.Add(s_Output);
  503.                 CheckKeyword(_AtomOutput);
  504.                 return _AtomOutput;
  505.             }
  506.         }
  507.        
  508.         // param
  509.         internal string Param {
  510.             get {
  511.                 if (_AtomParam == null)
  512.                     _AtomParam = _NameTable.Add(s_Param);
  513.                 CheckKeyword(_AtomParam);
  514.                 return _AtomParam;
  515.             }
  516.         }
  517.        
  518.         // preserve-space
  519.         internal string PreserveSpace {
  520.             get {
  521.                 if (_AtomPreserveSpace == null)
  522.                     _AtomPreserveSpace = _NameTable.Add(s_PreserveSpace);
  523.                 CheckKeyword(_AtomPreserveSpace);
  524.                 return _AtomPreserveSpace;
  525.             }
  526.         }
  527.        
  528.         // processing-instruction
  529.         internal string ProcessingInstruction {
  530.             get {
  531.                 if (_AtomProcessingInstruction == null)
  532.                     _AtomProcessingInstruction = _NameTable.Add(s_ProcessingInstruction);
  533.                 CheckKeyword(_AtomProcessingInstruction);
  534.                 return _AtomProcessingInstruction;
  535.             }
  536.         }
  537.        
  538.         // sort
  539.         internal string Sort {
  540.             get {
  541.                 if (_AtomSort == null)
  542.                     _AtomSort = _NameTable.Add(s_Sort);
  543.                 CheckKeyword(_AtomSort);
  544.                 return _AtomSort;
  545.             }
  546.         }
  547.        
  548.         // strip-space
  549.         internal string StripSpace {
  550.             get {
  551.                 if (_AtomStripSpace == null)
  552.                     _AtomStripSpace = _NameTable.Add(s_StripSpace);
  553.                 CheckKeyword(_AtomStripSpace);
  554.                 return _AtomStripSpace;
  555.             }
  556.         }
  557.        
  558.         // stylesheet
  559.         internal string Stylesheet {
  560.             get {
  561.                 CheckKeyword(_AtomStylesheet);
  562.                 return _AtomStylesheet;
  563.             }
  564.         }
  565.        
  566.         // template
  567.         internal string Template {
  568.             get {
  569.                 CheckKeyword(_AtomTemplate);
  570.                 return _AtomTemplate;
  571.             }
  572.         }
  573.        
  574.         // text
  575.         internal string Text {
  576.             get {
  577.                 if (_AtomText == null)
  578.                     _AtomText = _NameTable.Add(s_Text);
  579.                 CheckKeyword(_AtomText);
  580.                 return _AtomText;
  581.             }
  582.         }
  583.        
  584.         // transform
  585.         internal string Transform {
  586.             get {
  587.                 CheckKeyword(_AtomTransform);
  588.                 return _AtomTransform;
  589.             }
  590.         }
  591.        
  592.         // value-of
  593.         internal string ValueOf {
  594.             get {
  595.                 CheckKeyword(_AtomValueOf);
  596.                 return _AtomValueOf;
  597.             }
  598.         }
  599.        
  600.         // variable
  601.         internal string Variable {
  602.             get {
  603.                 if (_AtomVariable == null)
  604.                     _AtomVariable = _NameTable.Add(s_Variable);
  605.                 CheckKeyword(_AtomVariable);
  606.                 return _AtomVariable;
  607.             }
  608.         }
  609.        
  610.         // when
  611.         internal string When {
  612.             get {
  613.                 CheckKeyword(_AtomWhen);
  614.                 return _AtomWhen;
  615.             }
  616.         }
  617.        
  618.         // with-param
  619.         internal string WithParam {
  620.             get {
  621.                 if (_AtomWithParam == null)
  622.                     _AtomWithParam = _NameTable.Add(s_WithParam);
  623.                 CheckKeyword(_AtomWithParam);
  624.                 return _AtomWithParam;
  625.             }
  626.         }
  627.        
  628.         // case-order
  629.         internal string CaseOrder {
  630.             get {
  631.                 if (_AtomCaseOrder == null)
  632.                     _AtomCaseOrder = _NameTable.Add(s_CaseOrder);
  633.                 CheckKeyword(_AtomCaseOrder);
  634.                 return _AtomCaseOrder;
  635.             }
  636.         }
  637.        
  638.         // cdata-section-elements
  639.         internal string CdataSectionElements {
  640.             get {
  641.                 if (_AtomCdataSectionElements == null)
  642.                     _AtomCdataSectionElements = _NameTable.Add(s_CdataSectionElements);
  643.                 CheckKeyword(_AtomCdataSectionElements);
  644.                 return _AtomCdataSectionElements;
  645.             }
  646.         }
  647.        
  648.         // count
  649.         internal string Count {
  650.             get {
  651.                 if (_AtomCount == null)
  652.                     _AtomCount = _NameTable.Add(s_Count);
  653.                 CheckKeyword(_AtomCount);
  654.                 return _AtomCount;
  655.             }
  656.         }
  657.        
  658.         // data-type
  659.         internal string DataType {
  660.             get {
  661.                 if (_AtomDataType == null)
  662.                     _AtomDataType = _NameTable.Add(s_DataType);
  663.                 CheckKeyword(_AtomDataType);
  664.                 return _AtomDataType;
  665.             }
  666.         }
  667.        
  668.         // decimal-separator
  669.         internal string DecimalSeparator {
  670.             get {
  671.                 if (_AtomDecimalSeparator == null)
  672.                     _AtomDecimalSeparator = _NameTable.Add(s_DecimalSeparator);
  673.                 CheckKeyword(_AtomDecimalSeparator);
  674.                 return _AtomDecimalSeparator;
  675.             }
  676.         }
  677.        
  678.         // digit
  679.         internal string Digit {
  680.             get {
  681.                 if (_AtomDigit == null)
  682.                     _AtomDigit = _NameTable.Add(s_Digit);
  683.                 CheckKeyword(_AtomDigit);
  684.                 return _AtomDigit;
  685.             }
  686.         }
  687.        
  688.         // disable-output-escaping
  689.         internal string DisableOutputEscaping {
  690.             get {
  691.                 if (_AtomDisableOutputEscaping == null)
  692.                     _AtomDisableOutputEscaping = _NameTable.Add(s_DisableOutputEscaping);
  693.                 CheckKeyword(_AtomDisableOutputEscaping);
  694.                 return _AtomDisableOutputEscaping;
  695.             }
  696.         }
  697.        
  698.         // doctype-public
  699.         internal string DoctypePublic {
  700.             get {
  701.                 if (_AtomDoctypePublic == null)
  702.                     _AtomDoctypePublic = _NameTable.Add(s_DoctypePublic);
  703.                 CheckKeyword(_AtomDoctypePublic);
  704.                 return _AtomDoctypePublic;
  705.             }
  706.         }
  707.        
  708.         // doctype-system
  709.         internal string DoctypeSystem {
  710.             get {
  711.                 if (_AtomDoctypeSystem == null)
  712.                     _AtomDoctypeSystem = _NameTable.Add(s_DoctypeSystem);
  713.                 CheckKeyword(_AtomDoctypeSystem);
  714.                 return _AtomDoctypeSystem;
  715.             }
  716.         }
  717.        
  718.         // elements
  719.         internal string Elements {
  720.             get {
  721.                 if (_AtomElements == null)
  722.                     _AtomElements = _NameTable.Add(s_Elements);
  723.                 CheckKeyword(_AtomElements);
  724.                 return _AtomElements;
  725.             }
  726.         }
  727.        
  728.         // encoding
  729.         internal string Encoding {
  730.             get {
  731.                 if (_AtomEncoding == null)
  732.                     _AtomEncoding = _NameTable.Add(s_Encoding);
  733.                 CheckKeyword(_AtomEncoding);
  734.                 return _AtomEncoding;
  735.             }
  736.         }
  737.        
  738.         // exclude-result-prefixes
  739.         internal string ExcludeResultPrefixes {
  740.             get {
  741.                 if (_AtomExcludeResultPrefixes == null)
  742.                     _AtomExcludeResultPrefixes = _NameTable.Add(s_ExcludeResultPrefixes);
  743.                 CheckKeyword(_AtomExcludeResultPrefixes);
  744.                 return _AtomExcludeResultPrefixes;
  745.             }
  746.         }
  747.        
  748.         // extension-element-prefixes
  749.         internal string ExtensionElementPrefixes {
  750.             get {
  751.                 if (_AtomExtensionElementPrefixes == null)
  752.                     _AtomExtensionElementPrefixes = _NameTable.Add(s_ExtensionElementPrefixes);
  753.                 CheckKeyword(_AtomExtensionElementPrefixes);
  754.                 return _AtomExtensionElementPrefixes;
  755.             }
  756.         }
  757.        
  758.         // format
  759.         internal string Format {
  760.             get {
  761.                 if (_AtomFormat == null)
  762.                     _AtomFormat = _NameTable.Add(s_Format);
  763.                 CheckKeyword(_AtomFormat);
  764.                 return _AtomFormat;
  765.             }
  766.         }
  767.        
  768.         // from
  769.         internal string From {
  770.             get {
  771.                 if (_AtomFrom == null)
  772.                     _AtomFrom = _NameTable.Add(s_From);
  773.                 CheckKeyword(_AtomFrom);
  774.                 return _AtomFrom;
  775.             }
  776.         }
  777.        
  778.         // grouping-separator
  779.         internal string GroupingSeparator {
  780.             get {
  781.                 if (_AtomGroupingSeparator == null)
  782.                     _AtomGroupingSeparator = _NameTable.Add(s_GroupingSeparator);
  783.                 CheckKeyword(_AtomGroupingSeparator);
  784.                 return _AtomGroupingSeparator;
  785.             }
  786.         }
  787.        
  788.         // grouping-size
  789.         internal string GroupingSize {
  790.             get {
  791.                 if (_AtomGroupingSize == null)
  792.                     _AtomGroupingSize = _NameTable.Add(s_GroupingSize);
  793.                 CheckKeyword(_AtomGroupingSize);
  794.                 return _AtomGroupingSize;
  795.             }
  796.         }
  797.        
  798.         // href
  799.         internal string Href {
  800.             get {
  801.                 if (_AtomHref == null)
  802.                     _AtomHref = _NameTable.Add(s_Href);
  803.                 CheckKeyword(_AtomHref);
  804.                 return _AtomHref;
  805.             }
  806.         }
  807.        
  808.         // id
  809.         internal string Id {
  810.             get {
  811.                 if (_AtomId == null)
  812.                     _AtomId = _NameTable.Add(s_Id);
  813.                 CheckKeyword(_AtomId);
  814.                 return _AtomId;
  815.             }
  816.         }
  817.        
  818.         // indent
  819.         internal string Indent {
  820.             get {
  821.                 if (_AtomIndent == null)
  822.                     _AtomIndent = _NameTable.Add(s_Indent);
  823.                 CheckKeyword(_AtomIndent);
  824.                 return _AtomIndent;
  825.             }
  826.         }
  827.        
  828.         // infinity
  829.         internal string Infinity {
  830.             get {
  831.                 if (_AtomInfinity == null)
  832.                     _AtomInfinity = _NameTable.Add(s_Infinity);
  833.                 CheckKeyword(_AtomInfinity);
  834.                 return _AtomInfinity;
  835.             }
  836.         }
  837.        
  838.         // lang
  839.         internal string Lang {
  840.             get {
  841.                 if (_AtomLang == null)
  842.                     _AtomLang = _NameTable.Add(s_Lang);
  843.                 CheckKeyword(_AtomLang);
  844.                 return _AtomLang;
  845.             }
  846.         }
  847.        
  848.         // letter-value
  849.         internal string LetterValue {
  850.             get {
  851.                 if (_AtomLetterValue == null)
  852.                     _AtomLetterValue = _NameTable.Add(s_LetterValue);
  853.                 CheckKeyword(_AtomLetterValue);
  854.                 return _AtomLetterValue;
  855.             }
  856.         }
  857.        
  858.         // level
  859.         internal string Level {
  860.             get {
  861.                 if (_AtomLevel == null)
  862.                     _AtomLevel = _NameTable.Add(s_Level);
  863.                 CheckKeyword(_AtomLevel);
  864.                 return _AtomLevel;
  865.             }
  866.         }
  867.        
  868.         // match
  869.         internal string Match {
  870.             get {
  871.                 CheckKeyword(_AtomMatch);
  872.                 return _AtomMatch;
  873.             }
  874.         }
  875.        
  876.         // media-type
  877.         internal string MediaType {
  878.             get {
  879.                 if (_AtomMediaType == null)
  880.                     _AtomMediaType = _NameTable.Add(s_MediaType);
  881.                 CheckKeyword(_AtomMediaType);
  882.                 return _AtomMediaType;
  883.             }
  884.         }
  885.        
  886.         // method
  887.         internal string Method {
  888.             get {
  889.                 if (_AtomMethod == null)
  890.                     _AtomMethod = _NameTable.Add(s_Method);
  891.                 CheckKeyword(_AtomMethod);
  892.                 return _AtomMethod;
  893.             }
  894.         }
  895.        
  896.         // minus-sign
  897.         internal string MinusSign {
  898.             get {
  899.                 if (_AtomMinusSign == null)
  900.                     _AtomMinusSign = _NameTable.Add(s_MinusSign);
  901.                 CheckKeyword(_AtomMinusSign);
  902.                 return _AtomMinusSign;
  903.             }
  904.         }
  905.        
  906.         // mode
  907.         internal string Mode {
  908.             get {
  909.                 if (_AtomMode == null)
  910.                     _AtomMode = _NameTable.Add(s_Mode);
  911.                 CheckKeyword(_AtomMode);
  912.                 return _AtomMode;
  913.             }
  914.         }
  915.        
  916.         // name
  917.         internal string Name {
  918.             get {
  919.                 CheckKeyword(_AtomName);
  920.                 return _AtomName;
  921.             }
  922.         }
  923.        
  924.         // namespace
  925.         internal string Namespace {
  926.             get {
  927.                 if (_AtomNamespace == null)
  928.                     _AtomNamespace = _NameTable.Add(s_Namespace);
  929.                 CheckKeyword(_AtomNamespace);
  930.                 return _AtomNamespace;
  931.             }
  932.         }
  933.        
  934.         // NaN
  935.         internal string NaN {
  936.             get {
  937.                 if (_AtomNaN == null)
  938.                     _AtomNaN = _NameTable.Add(s_NaN);
  939.                 CheckKeyword(_AtomNaN);
  940.                 return _AtomNaN;
  941.             }
  942.         }
  943.        
  944.         // omit-xml-declaration
  945.         internal string OmitXmlDeclaration {
  946.             get {
  947.                 if (_AtomOmitXmlDeclaration == null)
  948.                     _AtomOmitXmlDeclaration = _NameTable.Add(s_OmitXmlDeclaration);
  949.                 CheckKeyword(_AtomOmitXmlDeclaration);
  950.                 return _AtomOmitXmlDeclaration;
  951.             }
  952.         }
  953.        
  954.         // order
  955.         internal string Order {
  956.             get {
  957.                 if (_AtomOrder == null)
  958.                     _AtomOrder = _NameTable.Add(s_Order);
  959.                 CheckKeyword(_AtomOrder);
  960.                 return _AtomOrder;
  961.             }
  962.         }
  963.        
  964.         // pattern-separator
  965.         internal string PatternSeparator {
  966.             get {
  967.                 if (_AtomPatternSeparator == null)
  968.                     _AtomPatternSeparator = _NameTable.Add(s_PatternSeparator);
  969.                 CheckKeyword(_AtomPatternSeparator);
  970.                 return _AtomPatternSeparator;
  971.             }
  972.         }
  973.        
  974.         // percent
  975.         internal string Percent {
  976.             get {
  977.                 if (_AtomPercent == null)
  978.                     _AtomPercent = _NameTable.Add(s_Percent);
  979.                 CheckKeyword(_AtomPercent);
  980.                 return _AtomPercent;
  981.             }
  982.         }
  983.        
  984.         // per-mille
  985.         internal string PerMille {
  986.             get {
  987.                 if (_AtomPerMille == null)
  988.                     _AtomPerMille = _NameTable.Add(s_PerMille);
  989.                 CheckKeyword(_AtomPerMille);
  990.                 return _AtomPerMille;
  991.             }
  992.         }
  993.        
  994.         // priority
  995.         internal string Priority {
  996.             get {
  997.                 if (_AtomPriority == null)
  998.                     _AtomPriority = _NameTable.Add(s_Priority);
  999.                 CheckKeyword(_AtomPriority);
  1000.                 return _AtomPriority;
  1001.             }
  1002.         }
  1003.        
  1004.         // result-prefix
  1005.         internal string ResultPrefix {
  1006.             get {
  1007.                 if (_AtomResultPrefix == null)
  1008.                     _AtomResultPrefix = _NameTable.Add(s_ResultPrefix);
  1009.                 CheckKeyword(_AtomResultPrefix);
  1010.                 return _AtomResultPrefix;
  1011.             }
  1012.         }
  1013.        
  1014.         // select
  1015.         internal string Select {
  1016.             get {
  1017.                 CheckKeyword(_AtomSelect);
  1018.                 return _AtomSelect;
  1019.             }
  1020.         }
  1021.        
  1022.         // standalone
  1023.         internal string Standalone {
  1024.             get {
  1025.                 if (_AtomStandalone == null)
  1026.                     _AtomStandalone = _NameTable.Add(s_Standalone);
  1027.                 CheckKeyword(_AtomStandalone);
  1028.                 return _AtomStandalone;
  1029.             }
  1030.         }
  1031.        
  1032.         // stylesheet-prefix
  1033.         internal string StylesheetPrefix {
  1034.             get {
  1035.                 if (_AtomStylesheetPrefix == null)
  1036.                     _AtomStylesheetPrefix = _NameTable.Add(s_StylesheetPrefix);
  1037.                 CheckKeyword(_AtomStylesheetPrefix);
  1038.                 return _AtomStylesheetPrefix;
  1039.             }
  1040.         }
  1041.        
  1042.         // terminate
  1043.         internal string Terminate {
  1044.             get {
  1045.                 if (_AtomTerminate == null)
  1046.                     _AtomTerminate = _NameTable.Add(s_Terminate);
  1047.                 CheckKeyword(_AtomTerminate);
  1048.                 return _AtomTerminate;
  1049.             }
  1050.         }
  1051.        
  1052.         // test
  1053.         internal string Test {
  1054.             get {
  1055.                 CheckKeyword(_AtomTest);
  1056.                 return _AtomTest;
  1057.             }
  1058.         }
  1059.        
  1060.         // use
  1061.         internal string Use {
  1062.             get {
  1063.                 if (_AtomUse == null)
  1064.                     _AtomUse = _NameTable.Add(s_Use);
  1065.                 CheckKeyword(_AtomUse);
  1066.                 return _AtomUse;
  1067.             }
  1068.         }
  1069.        
  1070.         // use-attribute-sets
  1071.         internal string UseAttributeSets {
  1072.             get {
  1073.                 if (_AtomUseAttributeSets == null)
  1074.                     _AtomUseAttributeSets = _NameTable.Add(s_UseAttributeSets);
  1075.                 CheckKeyword(_AtomUseAttributeSets);
  1076.                 return _AtomUseAttributeSets;
  1077.             }
  1078.         }
  1079.        
  1080.         // value
  1081.         internal string Value {
  1082.             get {
  1083.                 if (_AtomValue == null)
  1084.                     _AtomValue = _NameTable.Add(s_Value);
  1085.                 CheckKeyword(_AtomValue);
  1086.                 return _AtomValue;
  1087.             }
  1088.         }
  1089.        
  1090.         // version
  1091.         internal string Version {
  1092.             get {
  1093.                 if (_AtomVersion == null)
  1094.                     _AtomVersion = _NameTable.Add(s_Version);
  1095.                 CheckKeyword(_AtomVersion);
  1096.                 return _AtomVersion;
  1097.             }
  1098.         }
  1099.        
  1100.         // zero-digit
  1101.         internal string ZeroDigit {
  1102.             get {
  1103.                 if (_AtomZeroDigit == null)
  1104.                     _AtomZeroDigit = _NameTable.Add(s_ZeroDigit);
  1105.                 CheckKeyword(_AtomZeroDigit);
  1106.                 return _AtomZeroDigit;
  1107.             }
  1108.         }
  1109.        
  1110.         // #default
  1111.         internal string HashDefault {
  1112.             get {
  1113.                 if (_AtomHashDefault == null)
  1114.                     _AtomHashDefault = _NameTable.Add(s_HashDefault);
  1115.                 CheckKeyword(_AtomHashDefault);
  1116.                 return _AtomHashDefault;
  1117.             }
  1118.         }
  1119.        
  1120.         // no
  1121.         internal string No {
  1122.             get {
  1123.                 if (_AtomNo == null)
  1124.                     _AtomNo = _NameTable.Add(s_No);
  1125.                 CheckKeyword(_AtomNo);
  1126.                 return _AtomNo;
  1127.             }
  1128.         }
  1129.        
  1130.         // yes
  1131.         internal string Yes {
  1132.             get {
  1133.                 if (_AtomYes == null)
  1134.                     _AtomYes = _NameTable.Add(s_Yes);
  1135.                 CheckKeyword(_AtomYes);
  1136.                 return _AtomYes;
  1137.             }
  1138.         }
  1139.        
  1140.         //urn:schemas-microsoft-com:xslt
  1141.         internal string MsXsltNamespace {
  1142.             get {
  1143.                 CheckKeyword(_AtomMsXsltNamespace);
  1144.                 return _AtomMsXsltNamespace;
  1145.             }
  1146.         }
  1147.        
  1148.         // script
  1149.         internal string Script {
  1150.             get {
  1151.                 CheckKeyword(_AtomScript);
  1152.                 return _AtomScript;
  1153.             }
  1154.         }
  1155.        
  1156.         // language
  1157.         internal string Language {
  1158.             get {
  1159.                 if (_AtomLanguage == null)
  1160.                     _AtomLanguage = _NameTable.Add(s_Language);
  1161.                 CheckKeyword(_AtomLanguage);
  1162.                 return _AtomLanguage;
  1163.             }
  1164.         }
  1165.        
  1166.         // implements-prefix
  1167.         internal string ImplementsPrefix {
  1168.             get {
  1169.                 if (_AtomImplementsPrefix == null)
  1170.                     _AtomImplementsPrefix = _NameTable.Add(s_ImplementsPrefix);
  1171.                 CheckKeyword(_AtomImplementsPrefix);
  1172.                 return _AtomImplementsPrefix;
  1173.             }
  1174.         }
  1175.        
  1176.         // Keyword comparison methods
  1177.         static internal bool Equals(string strA, string strB)
  1178.         {
  1179.             Debug.Assert((object)strA == (object)strB || !String.Equals(strA, strB), "String atomization failure");
  1180.             return (object)strA == (object)strB;
  1181.         }
  1182.        
  1183.         static internal bool Compare(string strA, string strB)
  1184.         {
  1185.             return String.Equals(strA, strB);
  1186.         }
  1187.        
  1188.         [System.Diagnostics.Conditional("DEBUG")]
  1189.         private void CheckKeyword(string keyword)
  1190.         {
  1191.             Debug.Assert(keyword != null);
  1192.             Debug.Assert((object)keyword == (object)_NameTable.Get(keyword));
  1193.         }
  1194.     }
  1195. }

Developer Fusion