mcs/class/System.XML/Mono.Xml.Xsl/XslTransformProcessor.cs

   1 //
   2 // XslTransformProcessor.cs
   3 //
   4 // Authors:
   5 //      Ben Maurer (bmaurer@users.sourceforge.net)
   6 //      Atsushi Enomoto (ginga@kit.hi-ho.ne.jp)
   7 //
   8 // (C) 2003 Ben Maurer
   9 // (C) 2003 Atsushi Enomoto
  10 //
  11
  12 //
  13 // Permission is hereby granted, free of charge, to any person obtaining
  14 // a copy of this software and associated documentation files (the
  15 // "Software"), to deal in the Software without restriction, including
  16 // without limitation the rights to use, copy, modify, merge, publish,
  17 // distribute, sublicense, and/or sell copies of the Software, and to
  18 // permit persons to whom the Software is furnished to do so, subject to
  19 // the following conditions:
  20 //
  21 // The above copyright notice and this permission notice shall be
  22 // included in all copies or substantial portions of the Software.
  23 //
  24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  28 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  29 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  30 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  31 //
  32
  33 using System;
  34 using System.IO;
  35 using System.Collections;
  36 using System.Text;
  37 using System.Xml;
  38 using System.Xml.XPath;
  39 using System.Xml.Xsl;
  40 using Mono.Xml.Xsl.Operations;
  41 using Mono.Xml.XPath;
  42
  43 using QName = System.Xml.XmlQualifiedName;
  44
  45 namespace Mono.Xml.Xsl {
  46         internal class XslTransformProcessor {
  47                 CompiledStylesheet compiledStyle;
  48
  49                 XslStylesheet style;
  50
  51                 Stack currentTemplateStack = new Stack ();
  52
  53                 XPathNavigator root;
  54                 XsltArgumentList args;
  55                 XmlResolver resolver;
  56                 bool outputStylesheetXmlns;
  57                 string currentOutputUri;
  58
  59                 internal readonly XsltCompiledContext XPathContext;
  60
  61                 // Store the values of global params
  62                 internal Hashtable globalVariableTable = new Hashtable ();
  63
  64                 public XslTransformProcessor (CompiledStylesheet style)
  65                 {
  66                         this.XPathContext = new XsltCompiledContext (this);
  67                         this.compiledStyle = style;
  68                         this.style = style.Style;
  69                 }
  70
  71                 public void Process (XPathNavigator root, Outputter outputtter, XsltArgumentList args, XmlResolver resolver)
  72                 {
  73                         this.args = args;
  74                         this.root = root;
  75                         this.resolver = resolver != null ? resolver : new XmlUrlResolver ();
  76                         this.outputStylesheetXmlns = true;
  77                         this.currentOutputUri = String.Empty;
  78
  79                         // This is also done after the transformation, just for reuse after exception.
  80                         foreach (XslKey key in style.Keys.Values)
  81                                 key.ClearKeyTable ();
  82
  83                         XPathExpression exp = root.Compile (".");
  84                         PushNodeset (root.Select (exp, this.XPathContext));
  85
  86                         foreach (XslGlobalVariable v in CompiledStyle.Variables.Values) {
  87                                 if (args != null && v is XslGlobalParam) {
  88                                         object p = args.GetParam(v.Name.Name, v.Name.Namespace);
  89                                         if (p != null)
  90                                                 ((XslGlobalParam)v).Override (this, p);
  91                                         else
  92                                                 v.Evaluate (this);
  93                                 }
  94                                 v.Evaluate (this);
  95                         }
  96
  97                         PopNodeset ();
  98
  99                         this.PushOutput (outputtter);
 100                         this.ApplyTemplates (root.Select (exp, this.XPathContext), QName.Empty, null);
 101                         this.PopOutput ();
 102
 103                         foreach (XslKey key in style.Keys.Values)
 104                                 key.ClearKeyTable ();
 105                 }
 106
 107                 public CompiledStylesheet CompiledStyle { get { return compiledStyle; }}
 108                 public XsltArgumentList Arguments {get{return args;}}
 109
 110                 public MSXslScriptManager ScriptManager {
 111                         get { return compiledStyle.ScriptManager; }
 112                 }
 113
 114                 #region Document Resolution
 115                 public XmlResolver Resolver {get{return resolver;}}
 116
 117                 Hashtable docCache;
 118
 119                 public XPathNavigator GetDocument (Uri uri)
 120                 {
 121                         XPathNavigator result;
 122
 123                         if (docCache != null) {
 124                                 result = docCache [uri] as XPathNavigator;
 125                                 if (result != null)
 126                                         return result.Clone();
 127                         } else {
 128                                 docCache = new Hashtable();
 129                         }
 130
 131                         XmlReader rdr = null;
 132                         try {
 133                                 rdr = new XmlTextReader (uri.ToString(), (Stream) resolver.GetEntity (uri, null, null), root.NameTable);
 134                                 XmlValidatingReader xvr = new XmlValidatingReader (rdr);
 135                                 xvr.ValidationType = ValidationType.None;
 136                                 result = new XPathDocument (xvr, XmlSpace.Preserve).CreateNavigator ();
 137                         } finally {
 138                                 if (rdr != null)
 139                                         rdr.Close ();
 140                         }
 141                         docCache [uri] = result.Clone ();
 142                         return result;
 143                 }
 144
 145                 #endregion
 146
 147                 #region Output
 148                 Stack outputStack = new Stack ();
 149
 150                 public Outputter Out { get { return (Outputter)outputStack.Peek(); }}
 151
 152                 public void PushOutput (Outputter newOutput)
 153                 {
 154                         this.outputStack.Push (newOutput);
 155                 }
 156
 157                 public Outputter PopOutput ()
 158                 {
 159                         Outputter ret = (Outputter)this.outputStack.Pop ();
 160                         ret.Done ();
 161                         return ret;
 162                 }
 163
 164                 public Hashtable Outputs { get { return compiledStyle.Outputs; }}
 165
 166                 public XslOutput Output { get { return Outputs [currentOutputUri] as XslOutput; } }
 167
 168                 public string CurrentOutputUri { get { return currentOutputUri; } }
 169
 170                 public bool InsideCDataElement { get { return this.XPathContext.IsCData; } }
 171                 #endregion
 172
 173                 #region AVT StringBuilder
 174                 StringBuilder avtSB;
 175
 176                 #if DEBUG
 177                 bool avtSBlock = false;
 178                 #endif
 179
 180                 public StringBuilder GetAvtStringBuilder ()
 181                 {
 182                         #if DEBUG
 183                                 if (avtSBlock)
 184                                         throw new XsltException ("String Builder was locked", null);
 185                                 avtSBlock = true;
 186                         #endif
 187
 188                         if (avtSB == null)
 189                                 avtSB = new StringBuilder ();
 190
 191                         return avtSB;
 192                 }
 193
 194                 public string ReleaseAvtStringBuilder ()
 195                 {
 196                         #if DEBUG
 197                                 if (!avtSBlock)
 198                                         throw new XsltException ("you never locked the string builder", null);
 199                                 avtSBlock = false;
 200                         #endif
 201
 202                         string ret = avtSB.ToString ();
 203                         avtSB.Length = 0;
 204                         return ret;
 205                 }
 206                 #endregion
 207
 208                 #region Templates -- Apply/Call
 209                 Stack paramPassingCache = new Stack ();
 210
 211                 Hashtable GetParams (ArrayList withParams)
 212                 {
 213                         if (withParams == null) return null;
 214                         Hashtable ret;
 215
 216                         if (paramPassingCache.Count != 0) {
 217                                 ret = (Hashtable)paramPassingCache.Pop ();
 218                                 ret.Clear ();
 219                         } else
 220                                 ret = new Hashtable ();
 221
 222                         int len = withParams.Count;
 223                         for (int i = 0; i < len; i++) {
 224                                 XslVariableInformation param = (XslVariableInformation)withParams [i];
 225                                 ret.Add (param.Name, param.Evaluate (this));
 226                         }
 227                         return ret;
 228                 }
 229
 230                 public void ApplyTemplates (XPathNodeIterator nodes, QName mode, ArrayList withParams)
 231                 {
 232
 233                         Hashtable passedParams = GetParams (withParams);
 234
 235                         PushNodeset (nodes);
 236                         while (NodesetMoveNext ()) {
 237                                 XslTemplate t = FindTemplate (CurrentNode, mode);
 238                                 currentTemplateStack.Push (t);
 239                                 t.Evaluate (this, passedParams);
 240                                 currentTemplateStack.Pop ();
 241                         }
 242                         PopNodeset ();
 243
 244                         if (passedParams != null) paramPassingCache.Push (passedParams);
 245                 }
 246
 247                 public void CallTemplate (QName name, ArrayList withParams)
 248                 {
 249                         Hashtable passedParams = GetParams (withParams);
 250
 251                         XslTemplate t = FindTemplate (name);
 252                         currentTemplateStack.Push (null);
 253                         t.Evaluate (this, passedParams);
 254                         currentTemplateStack.Pop ();
 255
 256                         if (passedParams != null) paramPassingCache.Push (passedParams);
 257                 }
 258
 259                 public void ApplyImports ()
 260                 {
 261
 262                         XslTemplate currentTemplate = (XslTemplate)currentTemplateStack.Peek();
 263                         if (currentTemplate == null)
 264                                 throw new XsltException ("Invalid context for apply-imports", null, CurrentNode);
 265                         XslTemplate t;
 266
 267                         for (int i = currentTemplate.Parent.Imports.Count - 1; i >= 0; i--) {
 268                                 XslStylesheet s = (XslStylesheet)currentTemplate.Parent.Imports [i];
 269                                 t = s.Templates.FindMatch (CurrentNode, currentTemplate.Mode, this);
 270                                 if (t != null) {
 271                                         currentTemplateStack.Push (t);
 272                                         t.Evaluate (this);
 273                                         currentTemplateStack.Pop ();
 274                                         return;
 275                                 }
 276                         }
 277
 278                         switch (CurrentNode.NodeType) {
 279                         case XPathNodeType.Root:
 280                         case XPathNodeType.Element:
 281                                 if (currentTemplate.Mode == QName.Empty)
 282                                         t = XslDefaultNodeTemplate.Instance;
 283                                 else
 284                                         t = new XslDefaultNodeTemplate(currentTemplate.Mode);
 285
 286                                 break;
 287                         case XPathNodeType.Attribute:
 288                         case XPathNodeType.SignificantWhitespace:
 289                         case XPathNodeType.Text:
 290                         case XPathNodeType.Whitespace:
 291                                 t = XslDefaultTextTemplate.Instance;
 292                                 break;
 293
 294                         case XPathNodeType.Comment:
 295                         case XPathNodeType.ProcessingInstruction:
 296                                 t = XslEmptyTemplate.Instance;
 297                                 break;
 298
 299                         default:
 300                                 t = XslEmptyTemplate.Instance;
 301                                 break;
 302                         }
 303                         currentTemplateStack.Push (t);
 304                         t.Evaluate (this);
 305                         currentTemplateStack.Pop ();
 306                 }
 307
 308                 internal void TryStylesheetNamespaceOutput (ArrayList excluded)
 309                 {
 310                         if (outputStylesheetXmlns) {
 311                                 foreach (XmlQualifiedName qname in this.style.StylesheetNamespaces) {
 312                                         string prefix = style.PrefixInEffect (qname.Name, excluded);
 313                                         if (prefix == null)
 314                                                 continue;
 315                                         else if (prefix == qname.Name)
 316                                                 Out.WriteNamespaceDecl (
 317                                                         prefix == "#default" ? String.Empty : prefix,
 318                                                         qname.Namespace);
 319                                         else
 320                                                 Out.WriteNamespaceDecl (prefix, style.StyleDocument.GetNamespace (prefix));
 321                                 }
 322                                 outputStylesheetXmlns = false;
 323                         }
 324                 }
 325
 326                 XslTemplate FindTemplate (XPathNavigator node, QName mode)
 327                 {
 328                         XslTemplate ret = style.Templates.FindMatch (CurrentNode, mode, this);
 329
 330                         if (ret != null) return ret;
 331
 332                         switch (node.NodeType) {
 333                         case XPathNodeType.Root:
 334                         case XPathNodeType.Element:
 335                                 if (mode == QName.Empty)
 336                                         return XslDefaultNodeTemplate.Instance;
 337                                 else
 338                                         return new XslDefaultNodeTemplate(mode);
 339
 340                         case XPathNodeType.Attribute:
 341                         case XPathNodeType.SignificantWhitespace:
 342                         case XPathNodeType.Text:
 343                         case XPathNodeType.Whitespace:
 344                                 return XslDefaultTextTemplate.Instance;
 345
 346                         case XPathNodeType.Comment:
 347                         case XPathNodeType.ProcessingInstruction:
 348                                 return XslEmptyTemplate.Instance;
 349
 350                         default:
 351                                 return XslEmptyTemplate.Instance;
 352                         }
 353                 }
 354
 355                 XslTemplate FindTemplate (QName name)
 356                 {
 357                         XslTemplate ret = style.Templates.FindTemplate (name);
 358                         if (ret != null) return ret;
 359
 360                         throw new XsltException ("Could not resolve named template " + name, null, CurrentNode);
 361                 }
 362
 363                 #endregion
 364
 365                 public void PushForEachContext ()
 366                 {
 367                         currentTemplateStack.Push (null);
 368                 }
 369
 370                 public void PopForEachContext ()
 371                 {
 372                         currentTemplateStack.Pop ();
 373                 }
 374
 375
 376                 #region Nodeset Context
 377                 ArrayList nodesetStack = new ArrayList ();
 378
 379                 public XPathNodeIterator CurrentNodeset {
 380                         get { return (XPathNodeIterator) nodesetStack [nodesetStack.Count - 1]; }
 381                 }
 382
 383                 public XPathNavigator CurrentNode {
 384                         get {
 385                                 XPathNavigator nav = CurrentNodeset.Current;
 386                                 if (nav != null)
 387                                         return nav;
 388                                 // Inside for-each context, CurrentNodeset.Current may be null
 389                                 for (int i = nodesetStack.Count - 2; i >= 0; i--) {
 390                                         nav = ((XPathNodeIterator) nodesetStack [i]).Current;
 391                                         if (nav != null)
 392                                                 return nav;
 393                                 }
 394                                 return null;
 395                         }
 396                 }
 397
 398                 public bool NodesetMoveNext ()
 399                 {
 400                         return CurrentNodeset.MoveNext ();
 401                 }
 402
 403                 public void PushNodeset (XPathNodeIterator itr)
 404                 {
 405                         nodesetStack.Add (itr.Clone ());
 406                 }
 407
 408                 public void PopNodeset ()
 409                 {
 410                         nodesetStack.RemoveAt (nodesetStack.Count - 1);
 411                 }
 412                 #endregion
 413
 414                 #region Evaluate
 415
 416                 public bool Matches (Pattern p, XPathNavigator n)
 417                 {
 418                         return CompiledStyle.ExpressionStore.PatternMatches (p, this, n);
 419                 }
 420
 421                 public object Evaluate (XPathExpression expr)
 422                 {
 423                         expr = CompiledStyle.ExpressionStore.PrepForExecution (expr, this);
 424                         expr.SetContext (XPathContext);
 425
 426                         XPathNodeIterator itr = CurrentNodeset;
 427                         return itr.Current.Evaluate (expr, itr, XPathContext);
 428                 }
 429
 430                 public string EvaluateString (XPathExpression expr)
 431                 {
 432                         expr = CompiledStyle.ExpressionStore.PrepForExecution (expr, this);
 433                         expr.SetContext (XPathContext);
 434
 435                         XPathNodeIterator itr = CurrentNodeset;
 436                         return itr.Current.EvaluateString (expr, itr, XPathContext);
 437                 }
 438
 439                 public bool EvaluateBoolean (XPathExpression expr)
 440                 {
 441                         expr = CompiledStyle.ExpressionStore.PrepForExecution (expr, this);
 442                         expr.SetContext (XPathContext);
 443
 444                         XPathNodeIterator itr = CurrentNodeset;
 445                         return itr.Current.EvaluateBoolean (expr, itr, XPathContext);
 446                 }
 447
 448                 public double EvaluateNumber (XPathExpression expr)
 449                 {
 450                         expr = CompiledStyle.ExpressionStore.PrepForExecution (expr, this);
 451                         expr.SetContext (XPathContext);
 452
 453                         XPathNodeIterator itr = CurrentNodeset;
 454                         return itr.Current.EvaluateNumber (expr, itr, XPathContext);
 455                 }
 456
 457                 public XPathNodeIterator Select (XPathExpression expr)
 458                 {
 459                         expr = CompiledStyle.ExpressionStore.PrepForExecution (expr, this);
 460                         expr.SetContext (XPathContext);
 461                         return CurrentNodeset.Current.Select (expr, XPathContext);
 462                 }
 463
 464                 #endregion
 465
 466                 public XslAttributeSet ResolveAttributeSet (QName name)
 467                 {
 468                         return CompiledStyle.ResolveAttributeSet (name);
 469                 }
 470
 471                 #region Variable Stack
 472                 Stack variableStack = new Stack ();
 473                 object [] currentStack;
 474                 public int StackItemCount {
 475                         get {
 476                                 if (currentStack == null)
 477                                       return 0;
 478                                 for (int i = 0; i < currentStack.Length; i++)
 479                                         if (currentStack [i] == null)
 480                                                 return i;
 481                                 return currentStack.Length;
 482                         }
 483                 }
 484
 485                 public object GetStackItem (int slot)
 486                 {
 487                         return currentStack [slot];
 488                 }
 489
 490                 public void SetStackItem (int slot, object o)
 491                 {
 492                         currentStack [slot] = o;
 493                 }
 494
 495                 public void PushStack (int stackSize)
 496                 {
 497                         variableStack.Push (currentStack);
 498                         currentStack = new object [stackSize];
 499                 }
 500
 501                 public void PopStack ()
 502                 {
 503                         currentStack = (object[])variableStack.Pop();
 504                 }
 505
 506                 #endregion
 507
 508                 #region Free/Busy
 509                 Hashtable busyTable = new Hashtable ();
 510                 static object busyObject = new object ();
 511
 512                 public void SetBusy (object o)
 513                 {
 514                         busyTable [o] = busyObject;
 515                 }
 516
 517                 public void SetFree (object o)
 518                 {
 519                         busyTable.Remove (o);
 520                 }
 521
 522                 public bool IsBusy (object o)
 523                 {
 524                         return busyTable [o] == busyObject;
 525                 }
 526                 #endregion
 527
 528                 public bool PushElementState (string name, string ns, bool preserveWhitespace)
 529                 {
 530                         bool b = IsCData (name, ns);
 531                         XPathContext.PushScope ();
 532                         Out.InsideCDataSection = XPathContext.IsCData = b;
 533                         XPathContext.WhitespaceHandling = preserveWhitespace;
 534                         return b;
 535                 }
 536
 537                 bool IsCData (string name, string ns)
 538                 {
 539                         for (int i = 0; i < Output.CDataSectionElements.Length; i++) {
 540                                 XmlQualifiedName qname = Output.CDataSectionElements [i];
 541                                 if (qname.Name == name && qname.Namespace == ns) {
 542                                         return true;
 543                                 }
 544                         }
 545                         return false;
 546                 }
 547
 548                 public void PopCDataState (bool isCData)
 549                 {
 550                         XPathContext.PopScope ();
 551                         Out.InsideCDataSection = XPathContext.IsCData;
 552                 }
 553
 554                 public bool PreserveWhitespace ()
 555                 {
 556                         return XPathContext.PreserveWhitespace (CurrentNode);
 557                 }
 558         }
 559 }