1 /*
   2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
   3  * @LastModified: Oct 2017
   4  */
   5 /*
   6  * Licensed to the Apache Software Foundation (ASF) under one or more
   7  * contributor license agreements.  See the NOTICE file distributed with
   8  * this work for additional information regarding copyright ownership.
   9  * The ASF licenses this file to You under the Apache License, Version 2.0
  10  * (the "License"); you may not use this file except in compliance with
  11  * the License.  You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  */
  21 
  22 package com.sun.org.apache.xpath.internal;
  23 
  24 import javax.xml.transform.TransformerException;
  25 import org.w3c.dom.Node;
  26 
  27 /**
  28  * This class implements an exception object that all
  29  * XPath classes will throw in case of an error.  This class
  30  * extends TransformerException, and may hold other exceptions. In the
  31  * case of nested exceptions, printStackTrace will dump
  32  * all the traces of the nested exceptions, not just the trace
  33  * of this object.
  34  * @xsl.usage general

  35  */
  36 public class XPathException extends TransformerException
  37 {
  38     static final long serialVersionUID = 4263549717619045963L;
  39 
  40   /** The home of the expression that caused the error.
  41    *  @serial  */
  42   Object m_styleNode = null;
  43 
  44   /**
  45    * Get the stylesheet node from where this error originated.
  46    * @return The stylesheet node from where this error originated, or null.
  47    */
  48   public Object getStylesheetNode()
  49   {
  50     return m_styleNode;
  51   }
  52 
  53   /**
  54    * Set the stylesheet node from where this error originated.
  55    * @param styleNode The stylesheet node from where this error originated, or null.
  56    */
  57   public void setStylesheetNode(Object styleNode)
  58   {
  59     m_styleNode = styleNode;
  60   }
  61 
  62 
  63   /** A nested exception.
  64    *  @serial   */
  65   protected Exception m_exception;
  66 
  67   /**
  68    * Create an XPathException object that holds
  69    * an error message.
  70    * @param message The error message.
  71    */
  72   public XPathException(String message, ExpressionNode ex)
  73   {
  74     super(message);
  75     this.setLocator(ex);
  76     setStylesheetNode(getStylesheetNode(ex));
  77   }
  78 
  79   /**
  80    * Create an XPathException object that holds
  81    * an error message.
  82    * @param message The error message.
  83    */
  84   public XPathException(String message)
  85   {
  86     super(message);
  87   }
  88 
  89 
  90   /**
  91    * Get the XSLT ElemVariable that this sub-expression references.  In order for
  92    * this to work, the SourceLocator must be the owning ElemTemplateElement.
  93    * @return The dereference to the ElemVariable, or null if not found.
  94    */
  95   public org.w3c.dom.Node getStylesheetNode(ExpressionNode ex)
  96   {
  97 
  98     ExpressionNode owner = getExpressionOwner(ex);
  99 
 100     if (null != owner && owner instanceof org.w3c.dom.Node)
 101     {
 102                 return ((org.w3c.dom.Node)owner);
 103     }
 104     return null;
 105 
 106   }
 107 
 108   /**
 109    * Get the first non-Expression parent of this node.
 110    * @return null or first ancestor that is not an Expression.
 111    */
 112   protected ExpressionNode getExpressionOwner(ExpressionNode ex)
 113   {
 114         ExpressionNode parent = ex.exprGetParent();
 115         while((null != parent) && (parent instanceof Expression))
 116                 parent = parent.exprGetParent();
 117         return parent;
 118   }
 119 
 120 
 121 
 122   /**
 123    * Create an XPathException object that holds
 124    * an error message and the stylesheet node that
 125    * the error originated from.
 126    * @param message The error message.
 127    * @param styleNode The stylesheet node that the error originated from.
 128    */
 129   public XPathException(String message, Object styleNode)
 130   {
 131 
 132     super(message);
 133 
 134     m_styleNode = styleNode;
 135   }
 136 
 137   /**
 138    * Create an XPathException object that holds
 139    * an error message, the stylesheet node that
 140    * the error originated from, and another exception
 141    * that caused this exception.
 142    * @param message The error message.
 143    * @param styleNode The stylesheet node that the error originated from.
 144    * @param e The exception that caused this exception.
 145    */
 146   public XPathException(String message, Node styleNode, Exception e)
 147   {
 148 
 149     super(message);
 150 
 151     m_styleNode = styleNode;
 152     this.m_exception = e;
 153   }
 154 
 155   /**
 156    * Create an XPathException object that holds
 157    * an error message, and another exception
 158    * that caused this exception.
 159    * @param message The error message.
 160    * @param e The exception that caused this exception.
 161    */
 162   public XPathException(String message, Exception e)
 163   {
 164 
 165     super(message);
 166 
 167     this.m_exception = e;
 168   }
 169 
 170   /**
 171    * Print the the trace of methods from where the error
 172    * originated.  This will trace all nested exception
 173    * objects, as well as this object.
 174    * @param s The stream where the dump will be sent to.
 175    */
 176   public void printStackTrace(java.io.PrintStream s)
 177   {
 178 
 179     if (s == null)
 180       s = System.err;
 181 
 182     try
 183     {
 184       super.printStackTrace(s);
 185     }
 186     catch (Exception e){}
 187 
 188     Throwable exception = m_exception;
 189 
 190     for (int i = 0; (i < 10) && (null != exception); i++)
 191     {
 192       s.println("---------");
 193       exception.printStackTrace(s);
 194 
 195       if (exception instanceof TransformerException)
 196       {
 197         TransformerException se = (TransformerException) exception;
 198         Throwable prev = exception;
 199 
 200         exception = se.getException();
 201 
 202         if (prev == exception)
 203           break;
 204       }
 205       else
 206       {
 207         exception = null;
 208       }
 209     }
 210   }
 211 
 212   /**
 213    * Find the most contained message.
 214    *
 215    * @return The error message of the originating exception.
 216    */
 217   public String getMessage()
 218   {
 219 
 220     String lastMessage = super.getMessage();
 221     Throwable exception = m_exception;
 222 
 223     while (null != exception)
 224     {
 225       String nextMessage = exception.getMessage();
 226 
 227       if (null != nextMessage)
 228         lastMessage = nextMessage;
 229 
 230       if (exception instanceof TransformerException)
 231       {
 232         TransformerException se = (TransformerException) exception;
 233         Throwable prev = exception;
 234 
 235         exception = se.getException();
 236 
 237         if (prev == exception)
 238           break;
 239       }
 240       else
 241       {
 242         exception = null;
 243       }
 244     }
 245 
 246     return (null != lastMessage) ? lastMessage : "";
 247   }
 248 
 249   /**
 250    * Print the the trace of methods from where the error
 251    * originated.  This will trace all nested exception
 252    * objects, as well as this object.
 253    * @param s The writer where the dump will be sent to.
 254    */
 255   public void printStackTrace(java.io.PrintWriter s)
 256   {
 257 
 258     if (s == null)
 259       s = new java.io.PrintWriter(System.err);
 260 
 261     try
 262     {
 263       super.printStackTrace(s);
 264     }
 265     catch (Exception e){}
 266 
 267 
 268     boolean isJdk14OrHigher = false;
 269     try {
 270         Throwable.class.getMethod("getCause", (Class<?>[]) null);
 271         isJdk14OrHigher = true;
 272     } catch (NoSuchMethodException nsme) {
 273         // do nothing
 274     }
 275 
 276     // The printStackTrace method of the Throwable class in jdk 1.4
 277     // and higher will include the cause when printing the backtrace.
 278     // The following code is only required when using jdk 1.3 or lower
 279     if (!isJdk14OrHigher) {
 280 
 281       Throwable exception = m_exception;
 282 
 283       for (int i = 0; (i < 10) && (null != exception); i++)
 284       {
 285         s.println("---------");
 286 
 287         try
 288         {
 289           exception.printStackTrace(s);
 290         }
 291         catch (Exception e)
 292         {
 293           s.println("Could not print stack trace...");
 294         }
 295 
 296         if (exception instanceof TransformerException)
 297         {
 298           TransformerException se = (TransformerException) exception;
 299           Throwable prev = exception;
 300 
 301           exception = se.getException();
 302 
 303           if (prev == exception)
 304           {
 305             exception = null;
 306 
 307             break;
 308           }
 309         }
 310         else
 311         {
 312           exception = null;
 313         }
 314       }
 315     }
 316   }
 317 
 318   /**
 319    *  Return the embedded exception, if any.
 320    *  Overrides javax.xml.transform.TransformerException.getException().
 321    *
 322    *  @return The embedded exception, or null if there is none.
 323    */
 324   public Throwable getException()
 325   {
 326     return m_exception;
 327   }
 328 }
--- EOF ---