* 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 SoftwareFoundation, Inc.

*   59 Temple Place, Suite 330

*   Boston, MA 02111-1307  USA

*

* @author Scott Ferguson

*/

* Base class for generating code from an XSL tree.  JavaGenerator and

* JavaScriptGenerator extend this class for language-specific code

* generation.

*/

  private static final Logger log

    = Logger.getLogger(Generator.class.getName());

  protected static final L10N L = new L10N(Generator.class);

  public static final String XSLNS = "http://www.w3.org/1999/XSL/Transform";

  public static final String XTPNS = "http://www.caucho.com/XTP/1.0";

  private static final int STYLESHEET = 0;

  private static final int OUTPUT = STYLESHEET + 1;

  private static final int IMPORT = OUTPUT + 1;

  private static final int INCLUDE = IMPORT + 1;

  private static final int TEMPLATE = INCLUDE + 1;

  private static final int STRIP_SPACE = TEMPLATE + 1;

  private static final int PRESERVE_SPACE = STRIP_SPACE + 1;

  private static final int KEY = PRESERVE_SPACE + 1;

  private static final int LOCALE = KEY + 1;

  private static final int ATTRIBUTE_SET = LOCALE + 1;

  private static final int NAMESPACE_ALIAS = ATTRIBUTE_SET + 1;

  private static final int APPLY_TEMPLATES = NAMESPACE_ALIAS + 1;

  private static final int APPLY_IMPORTS = APPLY_TEMPLATES + 1;

  private static final int CALL_TEMPLATE = APPLY_IMPORTS + 1;

  private static final int PARAM = CALL_TEMPLATE + 1;

  private static final int VARIABLE = PARAM + 1;

  private static final int VALUE_OF = VARIABLE + 1;

  private static final int COPY_OF = VALUE_OF + 1;

  private static final int FOR_EACH = COPY_OF + 1;

  private static final int IF = FOR_EACH + 1;

  private static final int CHOOSE = IF + 1;

  private static final int TEXT = CHOOSE + 1;

  private static final int XSL_TEXT = TEXT + 1;

  private static final int NUMBER = XSL_TEXT + 1;

  private static final int COPY = NUMBER + 1;

  private static final int COPY_ELEMENT = COPY + 1;

  private static final int ELEMENT = COPY_ELEMENT + 1;

  private static final int ATTRIBUTE = ELEMENT + 1;

  private static final int PI = ATTRIBUTE + 1;

  private static final int COMMENT = PI + 1;

  private static final int MESSAGE = COMMENT + 1;

  private static final int EXPRESSION = MESSAGE + 1;

  private static final int SCRIPTLET = EXPRESSION + 1;

  private static final int DECLARATION = SCRIPTLET + 1;

  private static final int DIRECTIVE_CACHE = DECLARATION + 1;

  private static final int DIRECTIVE_PAGE = DIRECTIVE_CACHE + 1;

  private static final int WHILE = DIRECTIVE_PAGE + 1;

  private static final int ASSIGN = WHILE + 1;

  private static final int IGNORE = ASSIGN + 1;

  // xslt 2.0

  private static final int RESULT_DOCUMENT = IGNORE + 1;

  private static IntMap _tags;

  private static IntMap _xtpTags;

  private String _version = "1.0";

  String _xslName;

  // the root context

  Path _topContext;

  // the pwd for the file

  Path _baseURL;

  Path _context;

  CharBuffer _text;

  HashMap<String,String> _names = new HashMap<String,String>();

  int _loopDepth;

  Path _workPath;

  int _uniqueId;

  protected HashMap<String,String> _preserve = new HashMap<String,String>();

  protected HashMap<String,String> _strip = new HashMap<String,String>();

  HashMap<String,XslAttributeSet> _attributeSets =

    new HashMap<String,XslAttributeSet>();

  protected HashMap<String,String[]> _namespaceAliases =

    new HashMap<String,String[]>();

  protected HashMap<String,String> _excludedNamespaces =

    new HashMap<String,String>();

  protected KeyFun _keyFun;

  protected FormatNumberFun _formatNumberFun;

  protected NamespaceContext _namespace;

  protected ArrayList _globalActions = new ArrayList();

  protected ArrayList<String> _globalParameters =

    new ArrayList<String>();

  protected Document _doc;

  protected CauchoDocument _qDoc;

  protected Path _path;

  boolean _lineContent;

  int _lineWs;

  String _systemId;

  String _filename;

  int _line;

  protected LineMap _lineMap;

  private ArrayList _frags;

  protected int _destLine = 1;

  boolean _defaultCacheable = true;

  boolean _isCacheable;

  protected String _encoding;

  HashMap<String,ArrayList<Template>> _templates = new HashMap<String,ArrayList<Template>>();

  int _minImportance; // for included files, the minimum importance

  int _importance;

  int _templateCount;

  private IntArray _vars = new IntArray();

  private ArrayList<XslNode> _inits = new ArrayList<XslNode>();

  protected ArrayList<Path> _depends = new ArrayList<Path>();

  protected ArrayList<String> _cacheDepends = new ArrayList<String>();

  private boolean _isCauchoXsl;

  protected boolean _isRawText;

  protected String _errorPage;

  boolean _hasSession;

  protected AbstractPattern _nodeListContext;

  private boolean _isTop;

  private ClassLoader _loader;

  protected boolean _isSpecial;

  protected boolean _isStyleScript;

  HashMap<String,String> _outputAttributes = new HashMap<String,String>();

  HashMap<String,String> _macros;

  HashMap<String,Document> _files;

 

  protected AbstractStylesheetFactory _xslGenerator;

  protected ArrayList<String> _imports = new ArrayList<String>();

  Generator(AbstractStylesheetFactory xslGenerator)

  {

    _xslGenerator = xslGenerator;

   

    _workPath = xslGenerator.getWorkPath();

    Path path = xslGenerator.getStylePath();

    _context = path;

    _topContext = _context;

    _loader = xslGenerator.getClassLoader();

    if (_loader == null)

      _loader = Thread.currentThread().getContextClassLoader();

   

    _text = new CharBuffer();

    _frags = new ArrayList();

    _macros = new HashMap<String,String>();

    _keyFun = new KeyFun();

    _formatNumberFun = new FormatNumberFun();

  }

  void init(String filename)

  {

    _lineMap = new LineMap(filename);

  }

 

  public void setErrorPage(String errorPage)

  {

    _errorPage = errorPage;

  }

  public void setStyleScript(boolean stylescript)

  {

    _isStyleScript = stylescript;

  }

  /**

   * Adds a Java import to the generated stylesheet.

   */

  public void addImport(String pkg)

  {

    if (! _imports.contains(pkg))

      _imports.add(pkg);

  }

 

  public void setContentType(String type)

  {

    // contentType = type;

  }

  void setPath(Path path)

  {

    _path = path;

    _context = path;

  }

  void setWorkPath(Path path)

  {

    _workPath = path;

  }

  public int getMinImportance()

  {

    return _minImportance;

  }

  public int getMaxImportance()

  {

    return _importance;

  }

  public NamespaceContext getNamespace()

  {

    return _namespace;

  }

  public AbstractPattern getNodeListContext()

  {

    return _nodeListContext;

  }

  public void addLocale(String name, DecimalFormatSymbols format)

  {

    _formatNumberFun.addLocale(name, format);

  }

  /**

   * Generates a uniqueId

   */

  public int uniqueId()

  {

    return _uniqueId++;

  }

  /**

   * Starts the generation from the top of the document.

   *

   * @param xsl the stylesheet document.

   */

  public StylesheetImpl generate(Node node) throws Exception

  {

    Document xsl = node.getOwnerDocument();

    if (xsl == null)

      xsl = (Document) node;

    DocumentType dtd = xsl.getDoctype();

    if (dtd != null && dtd.getSystemId() != null) {

      _context = _path.lookup(dtd.getSystemId());

      _topContext = _context;

    }

   

    Element top = (Element) xsl.getDocumentElement();

    if (top == null)

      throw error(xsl, L.l("xsl:stylesheet must be top element."));

    _doc = xsl;

    if (_doc instanceof CauchoDocument)

      _qDoc = (CauchoDocument) _doc;

    QElement qTop = null;

    if (top instanceof QElement)

      qTop = (QElement) top;

    /*

    if (qTop != null && qTop.getFilename() != null)

      context = topContext.lookup(qTop.getFilename()).getParent();

    */

   

    _isTop = true;

    _files = new HashMap<String,Document>();

    scanFiles(top);

    if (_qDoc != null) {

      ArrayList depends = (ArrayList) _qDoc.getProperty(CauchoDocument.DEPENDS);

      for (int i = 0; depends != null && i < depends.size(); i++) {

        Path path = (Path) depends.get(i);

        addDepend(path);

      }

    }

    else {

      addDepend(_path);

    }

    if ("stylesheet".equals(getXslLocal(top)) ||

        "transform".equals(getXslLocal(top))) {

      generateStylesheet(top, true);

    }

    else {

      // literal result element

      printHeader();

      boolean oldCacheable = _isCacheable;

      boolean oldDefaultCacheable = _defaultCacheable;

      _isCacheable = true;

   

      XslNode literal = createChild(top);

      XslTemplate template = new XslTemplate();

      template.setGenerator((JavaGenerator) this);

      template.addAttribute(new QName("match"), "/");

      template.addChild(literal);

      template.generateDeclaration(getOut());

   

      template.generate(getOut());

      // printTemplate(top, null, "/", null, 0.0/0.0);

     

      _isCacheable = oldCacheable;

      _defaultCacheable = oldDefaultCacheable;

    }

    addNamespace(top);

    StylesheetImpl stylesheet = completeGenerate(_inits, _globalActions);

    return stylesheet;

  }

  private static CharScanner commaDelimScanner = new CharScanner(" \t\n\r,");

  /**

   * Scan the stylesheet for imported packages and files.  The imported

   * stylesheets will be read and stored in the 'files' HashMap for when

   * they're actually needed.

   */

  private void scanFiles(Element top)

    throws XslParseException, IOException

  {

    _isCauchoXsl = ! top.getAttribute("xsl-caucho").equals("");

    Iterator iter;

    try {

      iter = XPath.select("//xtp:directive.page/@*", top);

    } catch (Exception e) {

      throw new XslParseException(e);

    }

    while (iter.hasNext()) {

      Attr attr = (Attr) iter.next();

      String name = attr.getNodeName();

      String value = attr.getNodeValue();

      if (name.equals("import")) {

        StringCharCursor cursor = new StringCharCursor(value);

        CharBuffer cb = new CharBuffer();

        while (cursor.current() != cursor.DONE) {

          char ch;

          commaDelimScanner.skip(cursor);

          cb.clear();

          ch = commaDelimScanner.scan(cursor, cb);

          if (cb.length() != 0) {

            addImport(cb.toString());

          }

          else if (ch != cursor.DONE)

            throw new IOException(L.l("illegal `import' directive"));

        }

      }

    }

    try {

      iter = XPath.select("//xsl:import|xsl:include", top);

    } catch (Exception e) {

      throw new XslParseException(e);

    }

    while (iter.hasNext()) {

      Element elt = (Element) iter.next();

      String href = elt.getAttribute("href");

      ReadStream rs;

      try {

        rs = _xslGenerator.openPath(href, _context.getURL());

      } catch (Exception e) {

        throw new XslParseException(e);

      }

      Path path = rs.getPath();

     

      Document xsl = readXsl(rs);

      Element subtop = xsl.getDocumentElement();

      if (subtop == null)

        throw error(elt, L.l("xsl:import file {0} is empty", path.getFullPath()));

     

      Path oldContext = _context;

      Path virtualPath = _context.getParent().lookup(href);

      _context = virtualPath;

      _files.put(virtualPath.getPath(), xsl);

     

      scanFiles(subtop);

      _context = oldContext;

    }

  }

  public void addImportList(String value)

    throws XslParseException

  {

    StringCharCursor cursor = new StringCharCursor(value);

    CharBuffer cb = new CharBuffer();

    while (cursor.current() != cursor.DONE) {

      char ch;

      commaDelimScanner.skip(cursor);

      cb.clear();

      ch = commaDelimScanner.scan(cursor, cb);

      if (cb.length() != 0) {

        addImport(cb.toString());

      }

      else if (ch != cursor.DONE)

        throw error(L.l("illegal `import' directive"));

    }

  }

  /**

   * Read in an imported or included XSL file.

   *

   * @param path Path to the include files.

   *

   * @return XML tree describing the XSL.

   */

  Document readXsl(Path path)

    throws IOException, XslParseException

  {

    return readXsl(path.openRead());

  }

  /**

   * Read in an imported or included XSL file.

   *

   * @param path Path to the include files.

   *

   * @return XML tree describing the XSL.

   */

  Document readXsl(ReadStream file)

    throws IOException, XslParseException

  {

    try {

      addDepend(file.getPath());

     

      if (_isStyleScript) {

        XslParser parser = new XslParser();

        return parser.parse(file);

      }

      else

        return new Xml().parseDocument(file);

    } catch (org.xml.sax.SAXException e) {

      throw new XslParseException(e);

    } finally {

      file.close();

    }

  }

  /**

   * Start the top-level stylesheet generation.

   */

  private void generateStylesheet(Element elt, boolean isTop)

    throws Exception

  {

    QElement element = (QElement) elt;

    _isCauchoXsl = ! element.getAttribute("xsl-caucho").equals("");

    String systemId = element.getBaseURI();

    Path oldContext = _context;

    if (systemId != null)

      _context = _context.lookup(systemId);

   

    XslNode stylesheet = createChild(element);

    addNamespace(element);

   

    if (isTop)

      printHeader();

    stylesheet.generateDeclaration(getOut());

   

    stylesheet.generate(getOut());

    _context = oldContext;

    /*

    _version = element.getAttribute("version");

    if (_version.equals(""))

      _version = "1.0";

   

    // generateAttributeSets(element);

    excludeNamespaces(element);

    String xslSpace = element.getAttribute("xsl-space");

    ArrayList<XslNode> children = new ArrayList<XslNode>();

    for (Node child = element.getFirstChild();

         child != null;

         child = child.getNextSibling()) {

      if (! (child instanceof Element))

        continue;

     

      int code = -1;

      String name = getXslLocal(child);

      if (name != null)

        code = _tags.get(name);

      else if ((name = getXtpLocal(child)) != null)

        code = _xtpTags.get(name);

      else {

        String childName = child.getNodeName();

       

        if (childName.startsWith("jsp:directive.") ||

            childName.equals("jsp:declaration") ||

            childName.equals("jsp:scriptlet"))

          addGlobalAction((Element) child);

        continue;

      }

      NamespaceContext oldNamespace = addNamespace((Element) child);

      // generateTopLevelNode(code, (Element) child);

      XslNode node = createChild(child);

      children.add(node);

      _namespace = oldNamespace;

    }

    for (int i = 0; i < children.size(); i++) {

      XslNode node = children.get(i);

     

      node.generate(getOut());

    }

    */

  }

  abstract protected JavaWriter getOut();

  abstract protected XslNode createChild(Node child)

    throws Exception;

 

  abstract protected XslNode createChild(XslNode parent, Node child)

    throws Exception;

  private void addGlobalAction(Element elt)

  {

    _globalActions.add(elt);

  }

  /**

   * Converts the exclude-result-prefixes into the "excludedNamespaces"

   * hashMap for later use.

   */

  private void excludeNamespaces(Element element)

    throws Exception

  {

    if (! (element instanceof QElement))

      return;

   

    QElement elt = (QElement) element;

    String excludeNamespace;

    excludeNamespace = element.getAttribute("exclude-result-prefixes");

    if (! excludeNamespace.equals("")) {

      for (String prefix : excludeNamespace.split("[,\\s]+")) {

        String ns = elt.getNamespace(prefix);

        if (ns == null)

          throw error(elt, L.l("`{0}' must be a namespace prefix",

                               prefix));

        _excludedNamespaces.put(ns, "");

      }

    }

  }

  public void addExcludedNamespace(String ns)

  {

    _excludedNamespaces.put(ns, "");

  }

  public void addInit(XslNode node)

  {

    _inits.add(node);

  }

  public void addGlobalParameter(String param)

  {

    _globalParameters.add(param);

  }

  /**

   * Adds a file dependency for cacheable references to the output of

   * the stylesheet.

   */

  private void addCacheDepends(String attr)

  {

    if (attr.equals(""))

      return;

    int i = 0;

    int ch = 0;

    int len = attr.length();

    for (;

         i < len && XmlChar.isWhitespace((ch = attr.charAt(i))) || ch == ',';

         i++) {

    }

    CharBuffer cb = new CharBuffer();

    while (i < len) {

      cb.clear();

      for (;

           i < len && ! XmlChar.isWhitespace((ch = attr.charAt(i))) &&

             ch != ',';

           i++) {

        cb.append((char) ch);

      }

      _cacheDepends.add(cb.toString());

      for (;

           i < len && XmlChar.isWhitespace((ch = attr.charAt(i))) || ch == ',';

           i++) {

      }

    }

  }

  private void generateCacheDepends(String attr)

    throws Exception

  {

    if (attr.equals(""))

      return;

    int i = 0;

    int ch = 0;

    int len = attr.length();

    for (;

         i < len && XmlChar.isWhitespace((ch = attr.charAt(i))) || ch == ',';

         i++) {

    }

    CharBuffer cb = new CharBuffer();

    while (i < len) {

      cb.clear();

      for (;

           i < len && ! XmlChar.isWhitespace((ch = attr.charAt(i))) &&

             ch != ',';

           i++) {

        cb.append((char) ch);

      }

      printCacheDepends(cb.toString());

      for (;

           i < len && XmlChar.isWhitespace((ch = attr.charAt(i))) || ch == ',';

           i++) {

      }

    }

  }

  /**

   * Generate code for xsl:template

   */

  void generateTemplate(Element element)

    throws Exception

  {

    String name = element.getAttribute("name");

    String patternString = element.getAttribute("match");

    String mode = element.getAttribute("mode");

    String priority = element.getAttribute("priority");

    double dPriority = 0.0/0.0;

    if (! name.equals(""))

      _macros.put(name, name);

    if (name.equals("") && patternString.equals(""))

      throw error("xsl:template expects a `name' or a `match' attribute.");

    if (! priority.equals("")) {

      try {

        dPriority = Double.valueOf(priority).doubleValue();

      } catch (Exception e) {

        throw error("xsl:template expects `priority' must be a double.");

      }

    }

    boolean oldCacheable = _isCacheable;

    boolean oldDefaultCacheable = _defaultCacheable;

    AbstractPattern oldNodeListContext = _nodeListContext;

    if (! patternString.equals(""))

      _nodeListContext = parseMatch(patternString);

    _isCacheable = true;

    printTemplate(element, name, patternString, mode, dPriority);

    _nodeListContext = oldNodeListContext;

    _isCacheable = oldCacheable;

    _defaultCacheable = oldDefaultCacheable;

  }

  public XslNode generateImport(String href)

    throws Exception

  {

    Path path = lookupPath(href);

    if (_files.get(path.getPath()) != null)

      return null;

    Document xsl = readFile(href, path);

   

    if (xsl == null)

      throw new FileNotFoundException(href);

    QElement top = (QElement) xsl.getDocumentElement();

    if (top == null ||

        ! "stylesheet".equals(getXslLocal(top)) &&

        ! "transform".equals(getXslLocal(top))) {

      throw error("imported stylesheet `" + href +

                  "' missing xsl:stylesheet.");

    }

    int oldMinImportance = _minImportance;

    Path oldContext = _context;

    Path virtualPath = _context.getParent().lookup(href);