generator.java

来自「RESIN 3.2 最新源码」· Java 代码 · 共 2,537 行 · 第 1/5 页

    return true;
  }

  void generateXslText(Element element)
    throws Exception
  {
    _text.clear();
    for (Node child = element.getFirstChild();
	 child != null;
	 child = child.getNextSibling()) {
      if (! (child instanceof Text))
	continue;

      String data = child.getNodeValue();
      int length = data.length();
      
      _text.append(data);
    }

    String disableEscaping = element.getAttribute("disable-output-escaping");
    if (disableEscaping.equals(""))
      disableEscaping = "no";

    if (_text.length() <= 0) {
    }
    else if (! disableEscaping.equals("yes") &&
             ! disableEscaping.equals("true"))
      writeText(_text.toString());
    else {
      startDisableEscaping();
      writeText(_text.toString());
      endDisableEscaping();
    }
  }

  private void generateApplyTemplates(Node node)
    throws Exception
  {
    QElement element = (QElement) node;
    String select = element.getAttribute("select");
    String mode = element.getAttribute("mode");
    AbstractPattern selectPattern = null;
    if (! select.equals(""))
      selectPattern = parseSelect(select, node);

    Sort []sort = generateSort(node);

    if (sort != null && selectPattern == null)
      selectPattern = parseSelect("*", node);

    pushCall();
    generateArgs(element);
    printApplyTemplates(selectPattern, mode, sort);
    popCall();
  }

  private void generateApplyImports(Node node)
    throws Exception
  {
    QElement element = (QElement) node;
    String mode = element.getAttribute("mode");

    if (element.getFirstChild() != null)
      throw error(L.l("xsl:apply-imports must be empty"));

    pushCall();
    generateArgs(element);
    printApplyImports(mode, _minImportance, _importance);
    popCall();
  }

  private void generateCallTemplate(Element element)
    throws Exception
  {
    String name = element.getAttribute("name");
    String mode = element.getAttribute("mode");

    if (name.equals(""))
      throw error(L.l("{0} expects `{1}' attribute",
                      "xsl:call-template", "name"));

    if (findMacro(name) == null)
      throw error(element, L.l("`{0}' is an unknown macro for xsl:call-template.  All macros must be defined in an <xsl:template name='...'> element.", name));

    pushCall();
    generateArgs(element);
    printCallTemplate(name, mode);
    popCall();
  }

  private Element findMacro(String name)
    throws Exception
  {
    Element template = findMacroInDocument(_doc, name);
    if (template != null)
      return template;
    
    Iterator iter = _files.values().iterator();
    while (iter.hasNext()) {
      Document doc = (Document) iter.next();

      template = findMacroInDocument(doc, name);

      if (template != null)
        return template;
    }

    return null;
  }

  private Element findMacroInDocument(Document doc, String name)
  {
    Element elt = doc.getDocumentElement();

    for (Node child = elt.getFirstChild();
         child != null;
         child = child.getNextSibling()) {
      if (! child.getNodeName().equals("xsl:template"))
        continue;

      Element template = (Element) child;

      if (template.getAttribute("name").equals(name))
        return template;
    }

    return null;
  }

  private void generateMacro(Element element)
    throws Exception
  {
    QElement elt = (QElement) element;

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

    pushCall();
    for (Node node = elt.getFirstAttribute();
	 node != null;
	 node = node.getNextSibling()) {
      String argName = node.getNodeName();
      String argValue = node.getNodeValue();

      printParam(argName, argValue, elt);
    }
    printParam("contents", elt);
    printCallTemplate(name, mode);
    popCall();
  }

  private void generateArgs(Element element)
    throws Exception
  {
    for (Node node = element.getFirstChild(); node != null;
	 node = node.getNextSibling()) {
      String localName = getXslLocal(node);

      if ("with-param".equals(localName)) {
	String key = ((Element) node).getAttribute("name");
	String expr = ((Element) node).getAttribute("select");
	if (key.equals(""))
	  throw error(L.l("{0} requires `{1}' attribute",
                          "xsl:with-param", "name"));

	if (! expr.equals(""))
	  printParam(key, parseExpr(expr));
	else
	  printParam(key, node);
      }
    }
  }

  private void generateParamVariable(Element element)
    throws Exception
  {
    int i = _vars.size() - 1;
    _vars.set(i, _vars.get(i) + 1);
    
    String name = element.getAttribute("name");
    String expr = element.getAttribute("select");
    if (name.equals(""))
      throw error(L.l("{0} expects `{1}' attribute",
                      "xsl:param", "name"));

    if (! expr.equals(""))
      printParamVariable(name, parseExpr(expr));
    else
      printParamVariable(name, element);
  }

  private void generateVariable(Element element)
    throws Exception
  {
    int i = _vars.size() - 1;
    _vars.set(i, _vars.get(i) + 1);

    String name = element.getAttribute("name");
    String expr = element.getAttribute("select");
    if (name.equals(""))
      throw error(L.l("{0} expects `{1}' attribute.",
                      "xsl:variable", "name"));

    if (! expr.equals(""))
      printVariable(name, parseExpr(expr));
    else
      printVariable(name, element);
  }

  private void generateAssign(Element element)
    throws Exception
  {
    String name = element.getAttribute("name");
    String expr = element.getAttribute("select");
    if (name.equals(""))
      throw error(L.l("{0} expects `{1}' attribute.",
                      "xtp:assign", "name"));

    if (! expr.equals(""))
      printAssign(name, parseExpr(expr));
    else
      printAssign(name, element);
  }

  private void generateResultDocument(Element element)
    throws Exception
  {
    String href = element.getAttribute("href");
    String format = element.getAttribute("format");
    if (href.equals(""))
      throw error(L.l("{0} expects `{1}' attribute.",
                      "xtp:result-document", "href"));

    printResultDocument(element, href, format);
  }

  private void generateValueOf(Element element)
    throws Exception
  {
    String select = element.getAttribute("select");
    if (select.equals(""))
      throw error(L.l("{0} expects `{1}' attribute.",
                      "xsl:value-of", "select"));
    
    if (element.getFirstChild() != null)
      throw error(L.l("{0} must be empty", "xsl:value-of"));

    String disable = element.getAttribute("disable-output-escaping");
    boolean isDisabled = disable.equals("yes");
    if (isDisabled)
      startDisableEscaping();

    printSelectValue(select, element);

    if (isDisabled)
      endDisableEscaping();
  }

  private void generateCopyOf(Element element)
    throws Exception
  {
    String select = element.getAttribute("select");
    if (select.equals(""))
      throw error(L.l("{0} expects `{1}' attribute",
                      "xsl:copy-of", "select"));

    if (element.getFirstChild() != null)
      throw error(L.l("{0} must be empty", "xsl:copy-of"));
    
    printCopyOf(select, element);
  }

  /**
   * Generates code for the xsl:for-each element
   */
  void generateForEach(Element element)
    throws Exception
  {
    String select = element.getAttribute("select");
    if (select.equals(""))
      throw error(L.l("{0} expects `{1}' attribute",
                      "xsl:for-each", "select"));

    Sort []sort = generateSort(element);

    if (sort != null)
      printForEach(element, select, sort);
    else
      printForEach(element, select);
  }

  private Sort []generateSort(Node node)
    throws XslParseException, IOException
  {
    ArrayList<Sort> sorts = new ArrayList<Sort>();
  sort:
    for (Node child = node.getFirstChild();
	 child != null;
	 child = child.getNextSibling()) {
      if (child.getNodeType() == child.TEXT_NODE) {
	String data = child.getNodeValue();
	for (int i = 0; i < data.length(); i++) {
	  if (! XmlChar.isWhitespace(data.charAt(i)))
	    break sort;
	}
	continue;
      }
      else if (child.getNodeType() == child.COMMENT_NODE ||
               child.getNodeType() == child.PROCESSING_INSTRUCTION_NODE)
        continue;

      String name = getXslLocal(child);
      if (! "sort".equals(name))
	break;

      Element elt = (Element) child;
      String select = elt.getAttribute("select");
      if (select.equals(""))
	throw error(L.l("{0} expects attribute `{1}'",
                        "xsl:sort", "select"));

      Expr expr = parseExpr(select);
      String order = elt.getAttribute("order");
      Expr isAscending = null;
      if (order.equals("")) {
        isAscending = parseExpr("true()");
      }
      else if (order.startsWith("{") && order.endsWith("}")) {
        order = order.substring(1, order.length() - 1);
        
        isAscending = parseExpr(order + " = 'ascending'");
      }
      else if (order.equals("ascending"))
        isAscending = parseExpr("true()");
      else
        isAscending = parseExpr("false()");
      
      String dataType = elt.getAttribute("data-type");
      boolean isText = true;
      if (dataType.equals("number"))
	isText = false;

      String lang = elt.getAttribute("lang");
      if (lang.equals("")) {
        sorts.add(Sort.create(expr, isAscending, isText));
      }
      else {
	if (lang.startsWith("{") && lang.endsWith("}"))
	  lang = lang.substring(1, lang.length() - 1);
	else
	  lang = "'" + lang + "'";

        sorts.add(Sort.create(expr, isAscending, parseExpr(lang)));
	/*
        int p = lang.indexOf('-');
        Locale locale = null;

        if (p < 0) {
          locale = new Locale(lang, "");
        }
        else {
          String language = lang.substring(0, p);
          
          int q = lang.indexOf(p + 1, '-');

          if (q < 0) {
            String country = lang.substring(p + 1);

            locale = new Locale(language, country);
          }
          else {
            String country = lang.substring(p + 1, q);
            String variant = lang.substring(q);

            locale = new Locale(language, country, variant);
          }
        }

        sorts.add(Sort.create(expr, isAscending, lang));
	*/
      }
    }

    if (sorts.size() > 0)
      return (Sort []) sorts.toArray(new Sort[sorts.size()]);
    else
      return null;
  }

  void generateIf(Element element)
    throws Exception
  {
    String test = (String) element.getAttribute("test");
    if (test.equals(""))
      throw error(L.l("{0} expects `{1}' attribute", "xsl:if", "test"));

    printIf(element, parseExpr(test));
  }

  void generateWhile(Element element)
    throws Exception
  {
    String test = (String) element.getAttribute("test");
    if (test.equals(""))
      throw error(L.l("{0} expects `{1}' attribute", "xsl:while", "test"));

    printWhile(element, parseExpr(test));
  }

  void generateChoose(Element element)
    throws Exception
  {
    boolean first = true;
    for (Node child = element.getFirstChild();
	 child != null;
	 child = child.getNextSibling()) {
      if (! (child instanceof Element))
	continue;
      
      String name = getXslLocal(child);

      if ("when".equals(name)) {
	Element elt = (Element) child;
	String test = elt.getAttribute("test");
	if (test.equals(""))
	  throw error(L.l("{0} expects `{1}' attribute", "xsl:when", "test"));

	printChoose(elt, parseExpr(test), first);
	first = false;
      }
      else if ("otherwise".equals(name)) {
	printOtherwise((Element) child, first);
      }
      else
	throw error(L.l("xsl:choose expects `xsl:when' or `xsl:otherwise' at `{0}'",
                        child.getNodeName()));
    }
  }

  void generateElement(Element element)
    throws Exception
  {
    String name = (String) element.getAttribute("name");
    if (name.equals(""))
      throw error(L.l("{0} expects `{1}' attribute.", "xsl:element", "name"));
    Attr nsAttr = element.getAttributeNode("namespace");

    if (nsAttr == null)
      printElement(element, name);
    else
      printElement(element, name, nsAttr.getNodeValue());
  }

  void generateAttribute(Element element)
    throws Exception
  {
    String name = (String) element.getAttribute("name");
    if (name.equals(""))
      throw error(L.l("{0} expects `{1}' attribute",
                      "xsl:attribute", "name"));
    Attr nsAttr = element.getAttributeNode("namespace");

    boolean oldSpecial = _isSpecial;
    _isSpecial = true;
    
    if (nsAttr == null)
      printAttribute(element, name);
    else
      printAttribute(element, name, nsAttr.getNodeValue());

    _isSpecial = oldSpecial;
  }

  void generateNumber(Element element)
    throws Exception
  {
    String value = element.getAttribute("value");
    String count = element.getAttribute("count");
    String from = element.getAttribute("from");
    String level = element.getAttribute("level");
    String format = element.getAttribute("format");
    String letter = element.getAttribute("letter-value");
    String separator = element.getAttribute("grouping-separator");
    String lang = element.getAttribute("lang");
    String size_name = element.getAttribute("grouping-size");

    int size = 0;
    for (int i = 0; i < size_name.length(); i++) {
	char ch = size_name.charAt(i);
	if (ch >= '0' && ch <= '9')
	    size = 10 * size + ch - '0';
    }

    boolean isAlphabetic = true;
    if (! letter.equals("alphabetic"))
      isAlphabetic = false;

    AbstractPattern countPattern = null;
    if (! count.equals(""))
      countPattern = parseMatch(count);

    AbstractPattern fromPattern = null;
    if (! from.equals(""))
      fromPattern = parseMatch(from);

    if (level.equals("") || level.equals("single"))
      level = "single";
    else if (level.equals("multiple")) {