/FileExtraction/Java_unseen/dlitz_resin/modules/resin/src/com/caucho/xsl/AbstractStylesheetFactory.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.xsl;

import com.caucho.java.JavaCompiler;
import com.caucho.loader.DynamicClassLoader;
import com.caucho.loader.EnvironmentLocal;
import com.caucho.loader.SimpleLoader;
import com.caucho.server.util.CauchoSystem;
import com.caucho.util.Base64;
import com.caucho.util.CharBuffer;
import com.caucho.util.L10N;
import com.caucho.util.LruCache;
import com.caucho.vfs.Crc64Stream;
import com.caucho.vfs.Path;
import com.caucho.vfs.MergePath;
import com.caucho.vfs.ReadStream;
import com.caucho.vfs.Vfs;
import com.caucho.vfs.WriteStream;
import com.caucho.xml.*;
import com.caucho.xpath.Expr;
import com.caucho.xpath.XPath;

import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentType;
import org.w3c.dom.Node;
import org.xml.sax.ContentHandler;
import org.xml.sax.InputSource;
import org.xml.sax.XMLFilter;
import org.xml.sax.XMLReader;

import javax.xml.transform.ErrorListener;
import javax.xml.transform.Source;
import javax.xml.transform.Templates;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.URIResolver;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.sax.SAXResult;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TemplatesHandler;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.lang.ref.SoftReference;
import java.util.Iterator;
import java.util.Random;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Abstract factory for creating stylesheets.
 */
abstract public class AbstractStylesheetFactory
  extends SAXTransformerFactory {
  static final Logger log
    = Logger.getLogger(AbstractStylesheetFactory.class.getName());
  static final L10N L = new L10N(AbstractStylesheetFactory.class);

  private static
    EnvironmentLocal<LruCache<String,SoftReference<StylesheetImpl>>> _stylesheetCache =
    new EnvironmentLocal<LruCache<String,SoftReference<StylesheetImpl>>>();

  private URIResolver _uriResolver;
  private ErrorListener _errorListener;

  private String _systemId;

  private Path _workPath;
  private Path _stylePath;
  private ClassLoader _loader;
  private String _className;
  private boolean _isAutoCompile = true;
  private boolean _loadPrecompiledStylesheet = true;

  protected AbstractStylesheetFactory()
  {
  }

  /**
   * Returns an implementation-specific attribute.
   *
   * @param name the attribute name
   */
  public Object getAttribute(String name)
  {
    return null;
  }

  /**
   * Sets an implementation-specific attribute.
   *
   * @param name the attribute name
   * @param value the attribute value
   */
  public void setAttribute(String name, Object value)
  {
  }

  /**
   * Returns an implementation-specific feature.
   *
   * @param name the feature name
   */
  public boolean getFeature(String name)
  {
    if (name.equals(SAXTransformerFactory.FEATURE) ||
        name.equals(SAXTransformerFactory.FEATURE_XMLFILTER) ||
        name.equals(DOMResult.FEATURE) ||
        name.equals(DOMSource.FEATURE) ||
        name.equals(SAXResult.FEATURE) ||
        name.equals(SAXSource.FEATURE) ||
        name.equals(StreamResult.FEATURE) ||
        name.equals(StreamSource.FEATURE))
      return true;
    else
      return false;
  }

  /**
   * Sets an implementation-specific feature
   *
   * @param name the feature name
   * @param value the feature value
   */
  public void setFeature(String name, boolean value)
  {
  }

  /**
   * Returns the URI to filename resolver.
   */
  public URIResolver getURIResolver()
  {
    return _uriResolver;
  }

  /**
   * Sets the URI to filename resolver.
   */
  public void setURIResolver(URIResolver uriResolver)
  {
    _uriResolver = uriResolver;
  }

  /**
   * Returns the error listener.
   */
  public ErrorListener getErrorListener()
  {
    return _errorListener;
  }

  /**
   * Sets the error listener.
   */
  public void setErrorListener(ErrorListener errorListener)
  {
    _errorListener = errorListener;
  }

  public String getSystemId()
  {
    return _systemId;
  }

  public void setSystemId(String systemId)
  {
    _systemId = systemId;
  }

  /**
   * Sets the search path for stylesheets.  Generally applications will use
   * MergePath to create their search path.
   *
   * @param path path containing stylesheets.
   */
  public void setStylePath(Path path)
  {
    _stylePath = path;
  }

  /**
   * Returns the stylesheet search path.
   */
  public Path getStylePath()
  {
    if (_stylePath != null)
      return _stylePath;
    else
      return getSearchPath();
  }

  /**
   * Sets the search path for stylesheets.  Generally applications will use
   * MergePath to create their search path.
   *
   * @param path path containing stylesheets.
   */
  public void setSearchPath(Path path)
  {
    _stylePath = path;
  }

  /**
   * Returns the stylesheet search path.
   */
  public Path getSearchPath()
  {
    if (_stylePath != null)
      return _stylePath;
    else
      return Vfs.getPwd();
  }

  /**
   * Sets the working directory.
   */
  public void setWorkPath(Path path)
  {
    _workPath = path;
  }

  /**
   * Gets the working directory.
   */
  public Path getWorkPath()
  {
    if (_workPath != null)
      return _workPath;
    else
      return CauchoSystem.getWorkPath();
  }

  public void setClassName(String className)
  {
    _className = className;
  }

  public String getClassName()
  {
    return _className;
  }

  /**
   * Sets the classloader for the stylesheet.
   *
   * @param loader the new loader.
   */
  public void setClassLoader(ClassLoader loader)
  {
    _loader = loader;
  }

  /**
   * Gets the classloader for the stylesheet.
   */
  public ClassLoader getClassLoader()
  {
    return _loader;
  }

  /**
   * Returns true if precompiled stylesheets should be loaded.
   */
  public boolean getLoadPrecompiledStylesheet()
  {
    return _loadPrecompiledStylesheet;
  }

  /**
   * Returns true if precompiled stylesheets should be loaded.
   */
  public void setLoadPrecompiledStylesheet(boolean preload)
  {
    _loadPrecompiledStylesheet = preload;
  }

  /**
   * Returns true if the stylesheet should be automatically compiled.
   */
  public boolean isAutoCompile()
  {
    return _isAutoCompile;
  }

  /**
   * Returns true if precompiled stylesheets should be loaded.
   */
  public void setAutoCompile(boolean autoCompile)
  {
    _isAutoCompile = autoCompile;
  }

  /**
   * Returns the stylesheet source object associated with the given
   * XML document.
   *
   * @param source the XML document which needs a stylesheet.
   * @param media the media attribute for the stylesheet
   * @param title the title attribute for the stylesheet
   * @param charset the character encoding for the stylesheet result.
   */
  public Source getAssociatedStylesheet(Source source,
                                        String media,
                                        String title,
                                        String charset)
    throws TransformerConfigurationException
  {
    try {
      XmlStylesheetReader reader = new XmlStylesheetReader();

      parseSAX(source, reader);

      String href = reader.getAssociatedStylesheet(media, title, charset);

      if (href == null)
        return null;

      String base = source.getSystemId();
    
      return getSource(href, base);
    } catch (Exception e) {
      throw new TransformerConfigurationException(e);
    }
  }
  
  /**
   * Opens a relative path.
   */
  private Source getSource(String href, String base)
    throws Exception
  {
    Path subpath;

    if (href == null)
      href = "";
    if (base == null)
      base = "/";
    
    if (_uriResolver != null) {
      if (href.startsWith("/") || base.equals("/"))
        subpath = getSearchPath().lookup(href);
      else {
        subpath = getSearchPath().lookup(base).getParent().lookup(href);
      }
      
      Source source = _uriResolver.resolve(href, base);

      if (source != null) {
        if (source.getSystemId() == null)
          source.setSystemId(subpath.getURL());

        return source;
      }
    }
    
    if (href.startsWith("/") || base.equals("/"))
      subpath = getSearchPath().lookup(href);
    else {
      if (base.startsWith("file:"))
        base = base.substring(5);
      
      subpath = getSearchPath().lookup(base).getParent().lookup(href);
    }

    return new StreamSource(subpath.getURL());
  }

  private void parseSAX(Source source, ContentHandler handler)
    throws TransformerConfigurationException
  {
    try {
      if (source instanceof SAXSource) {
        SAXSource saxSource = (SAXSource) source;

        XMLReader reader = saxSource.getXMLReader();
        InputSource inputSource = saxSource.getInputSource();

        reader.setContentHandler(handler);

        reader.parse(inputSource);
      }
      else if (source instanceof StreamSource) {

        XmlParser parser = new Xml();

        parser.setContentHandler(handler);

        ReadStream rs = openPath(source);
        try {
          parser.parse(rs);
        } finally {
          rs.close();
        }
      }
      else if (source instanceof DOMSource) {
        DOMSource domSource = (DOMSource) source;

        Node node = domSource.getNode();

        XmlUtil.toSAX(node, handler);
      }
    } catch (Exception e) {
      throw new TransformerConfigurationException(e);
    }
  }

  /**
   * Create a transformer from an input stream.
   *
   * @param source the source stream
   *
   * @return the compiled stylesheet
   */
  public javax.xml.transform.Transformer newTransformer(Source source)
    throws TransformerConfigurationException
  {
    Templates templates = newTemplates(source);

    return templates.newTransformer();
  }

  /**
   * Create an identity transformer.
   *
   * @return the compiled stylesheet
   */
  public javax.xml.transform.Transformer newTransformer()
    throws TransformerConfigurationException
  {
    return new TransformerImpl(new IdentityStylesheet());
  }

  /**
   * Creates a new stylesheet from an XML document.
   */
  public StylesheetImpl newStylesheet(Document xsl)
    throws Exception
  {
    return (StylesheetImpl) generate(xsl, null);
  }

  /**
   * Create a new stylesheet from a reader.
   */
  public StylesheetImpl newStylesheet(Reader reader)
    throws Exception
  {
    ReadStream rs = Vfs.openRead(reader);

    return (StylesheetImpl) generate(parseXSL(rs), rs.getPath());
  }

  /**
   * Create a new stylesheet from an input stream.
   */
  public StylesheetImpl newStylesheet(InputStream is)
    throws Exception
  {
    ReadStream rs = Vfs.openRead(is);

    return (StylesheetImpl) generate(parseXSL(rs), rs.getPath());
  }

  /**
   * Loads a stylesheet from a named file
   *
   * @param systemId the URL of the file
   */
  public StylesheetImpl newStylesheet(String systemId)
    throws Exception
  {
    StylesheetImpl stylesheet = loadPrecompiledStylesheet(systemId, systemId);

    if (stylesheet != null)
      return stylesheet;

    synchronized (AbstractStylesheetFactory.class) {
      stylesheet = loadPrecompiledStylesheet(systemId, systemId);

      if (stylesheet != null)
        return stylesheet;
      
      ReadStream is;

      if (_stylePath != null)
        is = _stylePath.lookup(systemId).openRead();
      else
        is = Vfs.lookup(systemId).openRead();
    
      try {
        return newStylesheet(is);
      } finally {
        if (is != null)
          is.close();
      }
    }
  }

  public StylesheetImpl newStylesheet(Path path)
    throws Exception
  {
    StylesheetImpl stylesheet = loadPrecompiledStylesheet(path.getFullPath(),
                                                          path.getUserPath());

    if (stylesheet != null)
      return stylesheet;

    synchronized (AbstractStylesheetFactory.class) {
      stylesheet = loadPrecompiledStylesheet(path.getFullPath(),
                                             path.getUserPath());

      if (stylesheet != null)
        return stylesheet;
    
      Path oldStylePath = _stylePath;
    
      if (_stylePath == null)
        _stylePath = path.getParent();
    
      InputStream is = null;
    
      try {
        is = path.openRead();
        return newStylesheet(is);
      } finally {
        _stylePath = oldStylePath;
        if (is != null)
          is.close();
      }
    }
  }

  /**
   * Create a compiled stylesheet from an input stream.
   *
   * @param source the source stream
   *
   * @return the compiled stylesheet
   */
  public Templates newTemplates(Source source)
    throws TransformerConfigurationException
  {
    String systemId = source.getSystemId();

    try {
      if (systemId != null) {
        StylesheetImpl stylesheet = loadPrecompiledStylesheet(systemId,
                                                              systemId);

        if (stylesheet != null)
          return stylesheet;
      }

      if (source instanceof DOMSource) {
        Node node = ((DOMSource) source).getNode();

        return generateFromNode(node, systemId);
      }
      else if (source instanceof SAXSource) {
        SAXSource saxSource = (SAXSource) source;
        XMLReader reader = saxSource.getXMLReader();
        InputSource inputSource = saxSource.getInputSource();

        Document doc = new QDocument();
        DOMBuilder builder = new DOMBuilder();
        builder.init(doc);
        reader.setContentHandler(builder);

        reader.parse(inputSource);
      
        return generateFromNode(doc, systemId);
      }

      ReadStream rs = openPath(source);
      try {
        Path path = rs.getPath();

        Document doc = parseXSL(rs);

        if (systemId != null) {
          String mangledName = getMangledName(systemId);
          Path genPath = getWorkPath().lookup(mangledName);

          genPath.setUserPath(systemId);

          return generate(doc, genPath);
        }
        else
          return generateFromNode(doc, null);
      } finally {
        if (rs != null)
          rs.close();
      }
    } catch (TransformerConfigurationException e) {
      throw e;
    } catch (Exception e) {
      throw new XslParseException(e);
    } 
  }

  private Templates generateFromNode(Node node, String systemId)
    throws IOException, TransformerConfigurationException
  {
    Path tempPath = writeTempFile(node);

    String tempId = tempPath.getTail();
    
    StylesheetImpl stylesheet = loadPrecompiledStylesheet(tempId,
                                                          tempId,
                                                          false);

    if (systemId != null)
      tempPath.setUserPath(systemId);

    if (stylesheet != null)
      return stylesheet;

    return generate(node, tempPath);
  }

  private Path writeTempFile(Node node)
    throws IOException
  {
    Path workDir = CauchoSystem.getWorkPath().lookup("_xsl");
    workDir.mkdirs();
    
    // Path temp = workDir.createTempFile("tmp", "xsl");

    WriteStream os = Vfs.lookup("null:").openWrite();
    Crc64Stream crcStream = new Crc64Stream(os.getSource());
    os.init(crcStream);
    try {
      XmlPrinter printer = new XmlPrinter(os);

      printer.printNode(node);
    } finally {
      os.close();
    }

    long crc = crcStream.getCRC();
    CharBuffer cb = new CharBuffer();
    Base64.encode(cb, crc);

    String crcValue = cb.toString().replace('/', '-');

    Path xslPath = workDir.lookup(crcValue + ".xsl");

    // temp.renameTo(xslPath);

    return xslPath;
  }
  
  /**
   * Create a new transformer handler.
   */
  public TransformerHandler newTransformerHandler()
    throws TransformerConfigurationException
  {
    return newTransformerHandler(new StylesheetImpl());
  }
  
  /**
   * Create a new transformer handler based on a source.
   */
  public TransformerHandler newTransformerHandler(Source source)
    throws TransformerConfigurationException
  {
    return newTransformerHandler(newTemplates(source));
  }
  
  /**
   * Create a new transformer handler based on a stylesheet.
   */
  public TransformerHandler newTransformerHandler(Templates templates)
    throws TransformerConfigurationException
  {
    return new TransformerHandlerImpl(templates.newTransformer());
  }
  
  /**
   * Returns a templates handler.
   *
   * @param source the source file
   */
  public TemplatesHandler newTemplatesHandler()
    throws TransformerConfigurationException
  {
    return new TemplatesHandlerImpl(this);
  }
  
  /**
   * Returns an XML filter from the transformer.
   *
   * @param source the source file
   */
  public XMLFilter newXMLFilter(Source source)
    throws TransformerConfigurationException
  {
    Templates templates = newTemplates(source);
    
    return newXMLFilter(templates);
  }
  
  /**
   * Returns an XML filter from the transformer.
   *
   * @param source the source file
   */
  public XMLFilter newXMLFilter(Templates templates)
    throws TransformerConfigurationException
  {
    return new SAXFilterImpl((TransformerImpl) templates.newTransformer());
  }

  /**
   * Parses a stylesheet from the source.
   */
  protected Node parseStylesheet(Source source)
    throws TransformerConfigurationException
  {
    if (source instanceof DOMSource)
      return ((DOMSource) source).getNode();
    else if (source instanceof StreamSource) {
      InputStream is = ((StreamSource) source).getInputStream();
      ReadStream rs = null;

      try {
        rs = Vfs.openRead(is);
        return parseXSL(rs);
      } catch (Exception e) {
        throw new TransformerConfigurationException(e);
      } finally {
        if (rs != null)
          rs.close();
      }
    }
    else
      return null;
  }

  /**
   * Convenience class to create a compiled stylesheet.
   *
   * @param node DOM source for the stylesheet.
   *
   * @return a compiled stylesheet
   */
  public javax.xml.transform.Templates newTemplates(Node node)
    throws TransformerConfigurationException
  {
    Document doc = node.getOwnerDocument();
    if (node instanceof Document)
      doc = (Document) node;
    
    DocumentType dtd = doc.getDoctype();
    
    if (dtd != null && dtd.getSystemId() != null)
      return generate(node, getSearchPath().lookup(dtd.getSystemId()));
    else if (doc instanceof CauchoDocument) {
      String systemId = ((CauchoDocument) doc).getFilename();
    
      return generate(node, getSearchPath().lookup(systemId));
    }
    else
      return generate(node, null);
  }

  /**
   * Convenience class to create a compiled stylesheet.
   *
   * @param systemId source path for the stylesheet.
   *
   * @return a compiled stylesheet
   */
  public javax.xml.transform.Templates newTemplates(String systemId)
    throws TransformerConfigurationException
  {
    StylesheetImpl stylesheet = loadPrecompiledStylesheet(systemId, systemId);

    if (stylesheet != null)
      return stylesheet;

    else if (systemId == null)
      return generate(new QDocument(), null);

    Path path = getSearchPath().lookup(systemId);
    
    try {
      ReadStream is = path.openRead();
      Document doc;
      try {
        doc = parseXSL(is);
      } finally {
        is.close();
      }

      return generate(doc, path);
    } catch (TransformerConfigurationException e) {
      throw e;
    } catch (IOException e) {
      System.out.println("MP: " + ((MergePath) getSearchPath()).getMergePaths());
      throw new TransformerConfigurationExceptionWrapper(e);
    } catch (Exception e) {
      throw new TransformerConfigurationExceptionWrapper(e);
    }
  }

  

  /**
   * Opens a relative path.
   */
  ReadStream openPath(String href, String base)
    throws TransformerException, IOException
  {
    if (_uriResolver != null) {
      Source source = _uriResolver.resolve(href, base);

      if (source != null)
        return openPath(source);
    }

    if (href.startsWith("/") || base.equals("/"))
      return getSearchPath().lookup(href).openRead();
    else {
      Path path = getSearchPath().lookup(base).getParent().lookup(href);

      if (path.exists())
        return path.openRead();
      else
        return getSearchPath().lookup(href).openRead();
    }
  }

  /**
   * Opens a path based on a Source.
   */
  ReadStream openPath(Source source)
    throws TransformerException, IOException
  {
    String systemId = source.getSystemId();
    
    Path path;
    if (systemId != null)
      path = getSearchPath().lookup(systemId);
    else
      path = getSearchPath().lookup("anonymous.xsl");

    if (source instanceof StreamSource) {
      StreamSource stream = (StreamSource) source;

      InputStream is = stream.getInputStream();

      if (is instanceof ReadStream) {
        ReadStream rs = (ReadStream) is;

        rs.setPath(path);

        return rs;
      }
      else if (is != null) {
        ReadStream rs = Vfs.openRead(is);
        rs.setPath(path);

        return rs;
      }

      Reader reader = stream.getReader();

      if (reader != null) {
        ReadStream rs = Vfs.openRead(reader);
        rs.setPath(path);

        return rs;
      }
    }
    
    if (systemId != null)
      return getSearchPath().lookup(systemId).openRead();

    throw new TransformerException("bad source " + source);
  }

  Path lookupPath(String base, String href)
    throws TransformerException
  {
    if (_uriResolver != null) {
      Source source = _uriResolver.resolve(href, base);

      if (source != null) {
        String systemId = source.getSystemId();

        if (systemId != null)
          return getSearchPath().lookup(systemId);
      }
    }
    
    return getSearchPath().lookup(base).lookup(href);
  }

  /**
   * Convenience class to create a transformer instance.
   *
   * @param xsl DOM source for the stylesheet.
   *
   * @return a transformer instance.
   */
  public javax.xml.transform.Transformer newTransformer(Document xsl)
    throws TransformerConfigurationException
  {
    return newTemplates(xsl).newTransformer();
  }

  /**
   * Convenience class to transform a node.
   *
   * @param xsl DOM containing the parsed xsl.
   * @param xml DOM document node.
   * @param out output stream destination.
   */
  public void transform(Document xsl, Node xml, OutputStream out)
    throws Exception
  {
    TransformerImpl transformer = (TransformerImpl) newTransformer(xsl);

    transformer.transform(xml, out);
  }
  
  /**
   * Convenience class to transform a node.
   *
   * @param xsl path name to the xsl file.
   * @param xml dom source document.
   * @param out output stream destination.
   */
  public void transform(String xsl, Node xml, OutputStream out)
    throws Exception
  {
    TransformerImpl transformer;

    transformer = (TransformerImpl) newTemplates(xsl).newTransformer();

    transformer.transform(xml, out);
  }

  /**
   * Parses the XSL into a DOM document.
   *
   * @param rs the input stream.
   */
  abstract protected Document parseXSL(ReadStream rs)
    throws TransformerConfigurationException;

  /**
   * Generates a compiled stylesheet from a parsed XSL document.
   *
   * @param xsl the parsed xsl document.
   * @param path the path to the document.
   */
  Templates generate(Node xsl, Path path)
    throws TransformerConfigurationException
  {
    log.fine("Generating XSL from " + path);
    
    // The code generation needs a static lock because the
    // application might have a separate factory object
    // for each thread.  The static lock protects the code generation
    // from overwriting its own code.
    synchronized (AbstractStylesheetFactory.class) {
      Generator gen = null;
    
      try {
        if (path == null && xsl != null) {
          Document doc = xsl.getOwnerDocument();
          if (doc == null && xsl instanceof Document)
            doc = (Document) xsl;

          DocumentType dtd = doc.getDoctype();
          String systemId = null;
          if (dtd != null)
            systemId = dtd.getSystemId();

          if (systemId != null)
            path = getStylePath().lookup(systemId);
        }
      
        if (path == null && xsl instanceof CauchoNode) {
          String filename = ((CauchoNode) xsl).getFilename();
          if (filename != null)
            path = getStylePath().lookup(filename);
        }

        if (path == null)
          path = getStylePath().lookup("anonymous.xsl");

        Path stylePath = path.getParent();
      
        Expr expr = XPath.parseExpr("//xtp:directive.page/@language");
        String language = expr.evalString(xsl);

        String userName = path.getUserPath();
        String mangledName = getMangledName(userName);
      
        String encoding = XPath.evalString("//xsl:output/@encoding", xsl);
        if (encoding != null && encoding.equals(""))
          encoding = null;

        if (language == null || language.equals("") || language.equals("java")) {
          language = "java";
          gen = new JavaGenerator(this, mangledName, encoding);
        }
        else
          throw new XslParseException(L.l("unsupported language `{0}'",
                                          language));

        gen.setPath(path);

        Iterator iter = XPath.select("//xtp:directive.page/@*", xsl);
        while (iter.hasNext()) {
          Attr attr = (Attr) iter.next();
          String name = attr.getNodeName();
          String value = attr.getNodeValue();

          if (name.equals("errorPage"))
            gen.setErrorPage(value);
          else if (name.equals("import"))
            gen.addImport(value);
          else if (name.equals("contentType"))
            gen.setContentType(value);
          else if (name.equals("language")) {
            if (! language.equalsIgnoreCase(value))
              throw new XslParseException(L.l("mismatched language `{0}'",
                                              value));
          }
          else if (name.equals("xml:space")) {
          }
          else
            throw new XslParseException(L.l("unknown directive `{0}'",
                                            name));
        }

        StylesheetImpl stylesheet = gen.generate(xsl);
        gen = null;
        stylesheet.init(path);
        // XXX: why was this here? stylesheet.init(getStylePath());
        stylesheet.setURIResolver(_uriResolver);

        return stylesheet;
      } catch (TransformerConfigurationException e) {
        throw e;
      } catch (Exception e) {
        throw new XslParseException(e);
      } finally {
        try {
          if (gen != null)
            gen.close();
        } catch (IOException e) {
        }
      }
    }
  }

  /**
   * Returns the mangled classname for the stylesheet.  If getClassName()
   * is not null, it will be used as the mangled name.
   *
   * @param userName the user specified name for the stylesheet.
   *
   * @return a valid Java classname for the generated stylesheet.
   */
  private String getMangledName(String userName)
  {
    String name = null;

    if (userName == null || userName.equals("anonymous.xsl") ||
        userName.equals("string") || userName.equals("stream")) {
      userName = "x" + (new Random().nextInt() & 0x3ff) + ".xsl";
    }
    
    if (getClassName() == null)
      name = userName;
    else
      name = getClassName();

    if (name.startsWith("/"))
      name = "xsl" + name;
    else
      name = "xsl/" + name;
    
    return JavaCompiler.mangleName(name);
  }
  
  /**
   * Returns existing compiled Templates if it exists.
   *
   * @param systemId source path for the stylesheet.
   *
   * @return a compiled stylesheet
   */
  StylesheetImpl loadPrecompiledStylesheet(String systemId,
                                           String userId)
  {
    return loadPrecompiledStylesheet(systemId, userId, _isAutoCompile);
  }
  
  /**
   * Returns existing compiled Templates if it exists.
   *
   * @param systemId source path for the stylesheet.
   *
   * @return a compiled stylesheet
   */
  StylesheetImpl loadPrecompiledStylesheet(String systemId,
                                           String userId,
                                           boolean checkModified)
  {
    if (! _loadPrecompiledStylesheet)
      return null;

    try {
      // look for compiled template base on SystemID
      StylesheetImpl stylesheet = loadStylesheet(systemId,
                                                 getMangledName(userId));

      if (stylesheet == null)
        return null;
      
      stylesheet.setURIResolver(_uriResolver);
      // and check if it's modified or not
      if (! checkModified || ! stylesheet.isModified()) {
        stylesheet.setURIResolver(_uriResolver);
        return stylesheet;
      }
    } catch (Throwable e) {
      log.log(Level.FINER, e.toString(), e);
    }
    
    return null;
  }

  /**
   * Loads the compiled stylesheet .class file
   *
   * @param className the mangled classname for the stylesheet
   */
  protected StylesheetImpl loadStylesheet(String systemId, String className)
    throws Exception
  {
    LruCache<String,SoftReference<StylesheetImpl>> cache;

    ClassLoader parentLoader = Thread.currentThread().getContextClassLoader();

    cache = _stylesheetCache.getLevel(parentLoader);
    
    if (cache == null) {
      cache = new LruCache<String,SoftReference<StylesheetImpl>>(256);
      _stylesheetCache.set(cache, parentLoader);
    }

    SoftReference<StylesheetImpl> stylesheetRef;

    stylesheetRef = cache.get(className);

    StylesheetImpl stylesheet = null;

    if (stylesheetRef != null)
      stylesheet = stylesheetRef.get();

    try {
      if (stylesheet != null && ! stylesheet.isModified())
        return stylesheet;
    } catch (Throwable e) {
      log.log(Level.FINER, e.toString(), e);
    }

    Path classPath = getWorkPath().lookup(className.replace('.', '/') + ".class");
    if (! classPath.canRead())
      throw new ClassNotFoundException("can't find compiled XSL `" + className + "'");

    DynamicClassLoader loader;
    loader = SimpleLoader.create(parentLoader, getWorkPath(), className);

    Class cl = null;

    // If the loading fails, remove the class because it may be corrupted
    try {
      cl = CauchoSystem.loadClass(className, false, loader);
    } catch (Error e) {
      try {
        classPath.remove();
      } catch (IOException e1) {
        log.log(Level.FINE, e1.toString(), e1);
      }
      
      throw e;
    }

    stylesheet = (StylesheetImpl) cl.newInstance();
    Path path;

      path = getSearchPath().lookup("").lookup(systemId);
      /*
    try {
    } catch (TransformerException e) {
      log.log(Level.FINE, e.toString(), e);
      
      path = Vfs.lookup(systemId);
    }
      */

    // stylesheet.init(path);
    stylesheet.init(getStylePath());
    stylesheet.setURIResolver(_uriResolver);

    stylesheetRef = new SoftReference<StylesheetImpl>(stylesheet);
    cache.put(className, stylesheetRef);

    return stylesheet;
  }
}

