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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XsltOutput.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.IO;
  21.     using System.Xml;
  22.     using System.Text;
  23.     using System.Collections;
  24.    
  25.     internal class XsltOutput : CompiledAction
  26.     {
  27.        
  28.         internal enum OutputMethod
  29.         {
  30.             Xml,
  31.             Html,
  32.             Text,
  33.             Other,
  34.             Unknown
  35.         }
  36.        
  37.         private OutputMethod method = OutputMethod.Unknown;
  38.         private int methodSId = int.MaxValue;
  39.         private Encoding encoding = System.Text.Encoding.UTF8;
  40.         private int encodingSId = int.MaxValue;
  41.         private string version;
  42.         private int versionSId = int.MaxValue;
  43.         private bool omitXmlDecl;
  44.         private int omitXmlDeclSId = int.MaxValue;
  45.         private bool standalone;
  46.         private int standaloneSId = int.MaxValue;
  47.         private string doctypePublic;
  48.         private int doctypePublicSId = int.MaxValue;
  49.         private string doctypeSystem;
  50.         private int doctypeSystemSId = int.MaxValue;
  51.         private bool indent;
  52.         private int indentSId = int.MaxValue;
  53.         private string mediaType = "text/html";
  54.         private int mediaTypeSId = int.MaxValue;
  55.         private Hashtable cdataElements;
  56.        
  57.         internal OutputMethod Method {
  58.             get { return this.method; }
  59.         }
  60.        
  61.         internal bool OmitXmlDeclaration {
  62.             get { return this.omitXmlDecl; }
  63.         }
  64.        
  65.         internal bool HasStandalone {
  66.             get { return this.standaloneSId != int.MaxValue; }
  67.         }
  68.        
  69.         internal bool Standalone {
  70.             get { return this.standalone; }
  71.         }
  72.        
  73.         internal string DoctypePublic {
  74.             get { return this.doctypePublic; }
  75.         }
  76.        
  77.         internal string DoctypeSystem {
  78.             get { return this.doctypeSystem; }
  79.         }
  80.        
  81.         internal Hashtable CDataElements {
  82.             get { return this.cdataElements; }
  83.         }
  84.        
  85.         internal bool Indent {
  86.             get { return this.indent; }
  87.         }
  88.        
  89.         internal Encoding Encoding {
  90.             get { return this.encoding; }
  91.         }
  92.        
  93.         internal string MediaType {
  94.             get { return this.mediaType; }
  95.         }
  96.        
  97.         internal XsltOutput CreateDerivedOutput(OutputMethod method)
  98.         {
  99.             XsltOutput output = (XsltOutput)MemberwiseClone();
  100.             output.method = method;
  101.             if (method == OutputMethod.Html && this.indentSId == int.MaxValue) {
  102.                 // HTML output and Ident wasn't specified
  103.                 output.indent = true;
  104.             }
  105.             return output;
  106.         }
  107.        
  108.         internal override void Compile(Compiler compiler)
  109.         {
  110.             CompileAttributes(compiler);
  111.             CheckEmpty(compiler);
  112.         }
  113.        
  114.         internal override bool CompileAttribute(Compiler compiler)
  115.         {
  116.             string name = compiler.Input.LocalName;
  117.             string value = compiler.Input.Value;
  118.            
  119.             if (Keywords.Equals(name, compiler.Atoms.Method)) {
  120.                 if (compiler.Stylesheetid <= this.methodSId) {
  121.                     this.method = ParseOutputMethod(value, compiler);
  122.                     this.methodSId = compiler.Stylesheetid;
  123.                     if (this.indentSId == int.MaxValue) {
  124.                         this.indent = (this.method == OutputMethod.Html);
  125.                     }
  126.                 }
  127.             }
  128.             else if (Keywords.Equals(name, compiler.Atoms.Version)) {
  129.                 if (compiler.Stylesheetid <= this.versionSId) {
  130.                     this.version = value;
  131.                     this.versionSId = compiler.Stylesheetid;
  132.                 }
  133.             }
  134.             else if (Keywords.Equals(name, compiler.Atoms.Encoding)) {
  135.                 if (compiler.Stylesheetid <= this.encodingSId) {
  136.                     try {
  137.                         this.encoding = System.Text.Encoding.GetEncoding(value);
  138.                         this.encodingSId = compiler.Stylesheetid;
  139.                     }
  140.                     catch (System.NotSupportedException) {
  141.                     }
  142.                     catch (System.ArgumentException) {
  143.                     }
  144.                     Debug.Assert(this.encoding != null);
  145.                 }
  146.             }
  147.             else if (Keywords.Equals(name, compiler.Atoms.OmitXmlDeclaration)) {
  148.                 if (compiler.Stylesheetid <= this.omitXmlDeclSId) {
  149.                     this.omitXmlDecl = compiler.GetYesNo(value);
  150.                     this.omitXmlDeclSId = compiler.Stylesheetid;
  151.                 }
  152.             }
  153.             else if (Keywords.Equals(name, compiler.Atoms.Standalone)) {
  154.                 if (compiler.Stylesheetid <= this.standaloneSId) {
  155.                     this.standalone = compiler.GetYesNo(value);
  156.                     this.standaloneSId = compiler.Stylesheetid;
  157.                 }
  158.             }
  159.             else if (Keywords.Equals(name, compiler.Atoms.DoctypePublic)) {
  160.                 if (compiler.Stylesheetid <= this.doctypePublicSId) {
  161.                     this.doctypePublic = value;
  162.                     this.doctypePublicSId = compiler.Stylesheetid;
  163.                 }
  164.             }
  165.             else if (Keywords.Equals(name, compiler.Atoms.DoctypeSystem)) {
  166.                 if (compiler.Stylesheetid <= this.doctypeSystemSId) {
  167.                     this.doctypeSystem = value;
  168.                     this.doctypeSystemSId = compiler.Stylesheetid;
  169.                 }
  170.             }
  171.             else if (Keywords.Equals(name, compiler.Atoms.Indent)) {
  172.                 if (compiler.Stylesheetid <= this.indentSId) {
  173.                     this.indent = compiler.GetYesNo(value);
  174.                     this.indentSId = compiler.Stylesheetid;
  175.                 }
  176.             }
  177.             else if (Keywords.Equals(name, compiler.Atoms.MediaType)) {
  178.                 if (compiler.Stylesheetid <= this.mediaTypeSId) {
  179.                     this.mediaType = value;
  180.                     this.mediaTypeSId = compiler.Stylesheetid;
  181.                 }
  182.             }
  183.             else if (Keywords.Equals(name, compiler.Atoms.CdataSectionElements)) {
  184.                 string[] qnames = XmlConvert.SplitString(value);
  185.                
  186.                 if (this.cdataElements == null) {
  187.                     this.cdataElements = new Hashtable(qnames.Length);
  188.                 }
  189.                
  190.                 for (int i = 0; i < qnames.Length; i++) {
  191.                     XmlQualifiedName qname = compiler.CreateXmlQName(qnames[i]);
  192.                     this.cdataElements[qname] = qname;
  193.                 }
  194.             }
  195.             else {
  196.                 return false;
  197.             }
  198.             return true;
  199.         }
  200.        
  201.         internal override void Execute(Processor processor, ActionFrame frame)
  202.         {
  203.             Debug.Assert(false);
  204.         }
  205.        
  206.         private static OutputMethod ParseOutputMethod(string value, Compiler compiler)
  207.         {
  208.             XmlQualifiedName method = compiler.CreateXPathQName(value);
  209.             if (method.Namespace.Length != 0) {
  210.                 return OutputMethod.Other;
  211.             }
  212.             switch (method.Name) {
  213.                 case Keywords.s_Xml:
  214.                     return OutputMethod.Xml;
  215.                 case Keywords.s_Html:
  216.                     return OutputMethod.Html;
  217.                 case Keywords.s_Text:
  218.                     return OutputMethod.Text;
  219.                 default:
  220.                     if (compiler.ForwardCompatibility) {
  221.                         return OutputMethod.Unknown;
  222.                     }
  223.                     throw XsltException.Create(Res.Xslt_InvalidAttrValue, Keywords.s_Method, value);
  224.                     break;
  225.             }
  226.         }
  227.     }
  228. }

Developer Fusion