* Actually does the work of compiling the stylesheet's object model

*  into the template rules, actions, variable definitions, etc.

*

*  The constructor compiles the stylesheet, the method "process()"

*  runs the transformation

*/

    implements SheetDetails, LoadContext, NamespaceConstants

    private SaxFilterMaker _xrap = null;

   

    private ActionDebugTarget _debugger = null;

    private ImportantBoolean stripSource = null;

    private Hashtable stripSourceElementTable = null;

    private Hashtable stripSourceNamespaceTable = null;

    private TemplateRuleSet templateRules =

        new TemplateRuleSet(new BuiltinAction());

    private Hashtable modeTable = new Hashtable();

    private Hashtable namedTemplateTable = new Hashtable();

    private Hashtable variableInfoTable = new Hashtable();

    private Hashtable userFunctionTable = new Hashtable();

    private Hashtable attributeSetTable = new Hashtable();

    private Hashtable namespaceAliasTable = new Hashtable();

    private Hashtable keysDefinitionsTable = new Hashtable();

    private Vector idAttributes = new Vector();

    private static final Action emptyAction = new EmptyAction();

    private Hashtable topLevelTable = new Hashtable();

    private Hashtable actionTable = new Hashtable();

    Importance currentImportance = Importance.create();

    int importCount = 0;

    static NodeSetExpr childrenExpr = ExprParser.getChildrenExpr();

    VariableSet currentLocalVariables = new EmptyVariableSet();

    int nCurrentLocalVariables = 0;

    Vector excludedNamespaces;

    XMLProcessor _omBuilder;

    static StringVariant emptyStringVariant = new StringVariant("");

    Name XSL_WHEN;

    Name XSL_OTHERWISE;

    Name XSL_STYLESHEET;

    Name XSL_TRANSFORM;

    Name XSL_WITH_PARAM;

    Name XSL_SORT;

    Name XSL_FOR_EACH;

    Name XSL_FALLBACK;

    Name XSL_VERSION;

    Name XSL_VENDOR;

    Name XSL_VENDOR_URL;

    Name XSL_USE_ATTRIBUTE_SETS;

    Name XSL_ATTRIBUTE;

    // stylesheet attribute names

    Name ATTRIBUTE;

    Name CASE_ORDER;

    Name CDATA_SECTION_ELEMENTS;

    Name COUNT;

    Name DATA_TYPE;

    Name DEFAULT;

    Name DISABLE_OUTPUT_ESCAPING;

    Name DOCTYPE_PUBLIC;

    Name DOCTYPE_SYSTEM;

    Name ELEMENTS;

    Name ENCODING;

    Name EXCLUDE_RESULT_PREFIXES;

    Name FORMAT;

    Name FROM;

    Name GROUPING_SEPARATOR;

    Name GROUPING_SIZE;

    Name HREF;

    Name INDENT;

    Name LANG;

    Name LETTER_VALUE;

    Name LEVEL;

    Name MATCH;

    Name MEDIA_TYPE;

    Name METHOD;

    Name MODE;

    Name NAME;

    Name NAMESPACE;

    Name OMIT_XML_DECLARATION;

    Name ORDER;

    Name PRIORITY;

    Name RESULT_PREFIX;

    Name SELECT;

    Name STANDALONE;

    Name STYLESHEET_PREFIX;

    Name TERMINATE;

    Name TEST;

    Name USE;

    Name USE_ATTRIBUTE_SETS;

    Name VALUE;

    Name VERSION;

    // output method properties from the stylesheet

    OutputMethodImpl _outputMethod;

    // output method properties with overrides from client code

    OutputMethodImpl _runtimeOutputMethod = null;

    LoadContext sheetLoadContext;

    NameTable nameTable;

    ExtensionHandler extensionHandler;

 

    /**

     * The constructor builds (compiles) a stylesheet

     * @param node the (xslt D) OM root Node of the loaded stylesheet

     * @param omBuilder a (xslt D) OM builder we can use for

     *               included/imported sheets

     * @param extensionHandler for extensions?

     * @param sheetLoadContext ??

     * @param nameTable ??

     */

    SheetImpl(Node node, XMLProcessor omBuilder,

              ExtensionHandler extensionHandler,

        LoadContext sheetLoadContext,

              NameTable nameTable)

  throws IOException, XSLException

    {

  this.sheetLoadContext = sheetLoadContext;

  this.nameTable = nameTable;

  this._omBuilder = omBuilder;

  this.extensionHandler = extensionHandler;

        _debugger =  sheetLoadContext.getDebugger();

  XSL_WHEN = xsl("when");

  XSL_OTHERWISE = xsl("otherwise");

  XSL_STYLESHEET = xsl("stylesheet");

  XSL_TRANSFORM = xsl("transform");

  XSL_WITH_PARAM = xsl("with-param");

  XSL_SORT = xsl("sort");

  XSL_FOR_EACH = xsl("for-each");

  XSL_FALLBACK = xsl("fallback");

  XSL_VERSION = xsl("version");

  XSL_VENDOR = xsl("vendor");

  XSL_VENDOR_URL = xsl("vendor-url");

  XSL_USE_ATTRIBUTE_SETS = xsl("use-attribute-sets");

  XSL_ATTRIBUTE = xsl("attribute");

        // no namespace for these attribute names

  ATTRIBUTE = nameTable.createName("attribute");

  CASE_ORDER = nameTable.createName("case-order");

  CDATA_SECTION_ELEMENTS = nameTable.createName("cdata-section-elements");

  COUNT = nameTable.createName("count");

  DATA_TYPE = nameTable.createName("data-type");

  DEFAULT = nameTable.createName("default");

  DISABLE_OUTPUT_ESCAPING =

            nameTable.createName("disable-output-escaping");

  DOCTYPE_PUBLIC = nameTable.createName("doctype-public");

  DOCTYPE_SYSTEM = nameTable.createName("doctype-system");

  ELEMENTS = nameTable.createName("elements");

  ENCODING = nameTable.createName("encoding");

  EXCLUDE_RESULT_PREFIXES =

            nameTable.createName("exclude-result-prefixes");

  FORMAT = nameTable.createName("format");

  FROM = nameTable.createName("from");

  GROUPING_SEPARATOR = nameTable.createName("grouping-separator");

  GROUPING_SIZE = nameTable.createName("grouping-size");

  HREF = nameTable.createName("href");

  INDENT = nameTable.createName("indent");

  LANG = nameTable.createName("lang");

  LETTER_VALUE = nameTable.createName("letter-value");

  LEVEL = nameTable.createName("level");

  MATCH = nameTable.createName("match");

  MEDIA_TYPE = nameTable.createName("media-type");

  METHOD = nameTable.createName("method");

  MODE = nameTable.createName("mode");

  NAME = nameTable.createName("name");

  NAMESPACE = nameTable.createName("namespace");

  OMIT_XML_DECLARATION = nameTable.createName("omit-xml-declaration");

  ORDER = nameTable.createName("order");

  PRIORITY = nameTable.createName("priority");

  RESULT_PREFIX = nameTable.createName("result-prefix");

  SELECT = nameTable.createName("select");

  STANDALONE = nameTable.createName("standalone");

  STYLESHEET_PREFIX = nameTable.createName("stylesheet-prefix");

  TERMINATE = nameTable.createName("terminate");

  TEST = nameTable.createName("test");

  USE = nameTable.createName("use");

  USE_ATTRIBUTE_SETS = nameTable.createName("use-attribute-sets");

  VALUE = nameTable.createName("value");

  VERSION = nameTable.createName("version");

   

  topLevelTable.put(xsl("include"), new IncludeParser());

  topLevelTable.put(xsl("import"), new ImportParser());

  topLevelTable.put(xsl("template"), new TemplateParser());

  topLevelTable.put(xsl("attribute-set"), new AttributeSetParser());

  topLevelTable.put(xsl("decimal-format"), new DecimalFormatParser());

  topLevelTable.put(xsl("key"), new KeyParser());

  topLevelTable.put(xsl("variable"), new VariableTopLevelParser());

  topLevelTable.put(xsl("param"), new ParamTopLevelParser());

  topLevelTable.put(xsl("strip-space"), new StripSpaceParser());

  topLevelTable.put(xsl("preserve-space"), new PreserveSpaceParser());

  topLevelTable.put(xsl("output"), new OutputParser());

  topLevelTable.put(xsl("namespace-alias"), new NamespaceAliasParser());

  topLevelTable.put(func("function"), new EXSLFunctionTopLevelParser());

  actionTable.put(xsl("text"), new TextParser());

  actionTable.put(xsl("apply-templates"), new ApplyTemplatesParser());

  actionTable.put(xsl("call-template"), new CallTemplateParser());

  actionTable.put(xsl("for-each"), new ForEachParser());

  actionTable.put(xsl("value-of"), new ValueOfParser());

  actionTable.put(xsl("number"), new NumberParser());

  actionTable.put(xsl("if"), new IfParser());

  actionTable.put(xsl("choose"), new ChooseParser());

  actionTable.put(xsl("copy"), new CopyParser());

  actionTable.put(xsl("copy-of"), new CopyOfParser());

  actionTable.put(xsl("comment"), new CommentParser());

  actionTable.put(xsl("processing-instruction"),

                        new ProcessingInstructionParser());

  actionTable.put(xsl("element"), new ElementParser());

  actionTable.put(xsl("attribute"), new AttributeParser());

  actionTable.put(xsl("apply-imports"), new ApplyImportsParser());

  actionTable.put(xsl("variable"), new VariableActionParser());

  actionTable.put(xsl("param"), new ParamActionParser());

  actionTable.put(xsl("message"), new MessageParser());

  actionTable.put(xt("document"), new DocumentParser());

        actionTable.put(exsl("document"), new DocumentParser());

        actionTable.put(func("result"), new EXSLFunctionResultParser());

  actionTable.put(xfyxt("xrap"), new XRAPParser());

        _outputMethod = new OutputMethodImpl();

        // ... and now, do something big,

        // compile from the OM into something we can execute

  parseSheet(node);

    }

    /**

     * sets the xrap processor for use during processing

     */

    public void setSaxExtensionFilter(SaxFilterMaker xrap)

    { _xrap = xrap; }

    /**

     * gets the xrap processor for use during processing

     */

    public SaxFilterMaker getSaxExtensionFilter()

    { return _xrap; }

    /**

     * sets the xrap processor for use during processing

     */

    public void setDebugger(ActionDebugTarget debugger)

    { _debugger = debugger; }

    /**

     * gets the xrap processor for use during processing

     */

    public ActionDebugTarget getDebugger()

    { return _debugger; }

    //////////////////////////////////////////////////////////

    //

    //

    //

    /**

     * returns the current values set either by client code,

     * the stylesheet, or defaulted for the output method properties

     */

    public OutputMethod getOutputMethod()

    {

        return _runtimeOutputMethod == null ? _outputMethod : _runtimeOutputMethod;

    }

    /**

     * returns the current values set either by client code,

     * the stylesheet, or defaulted for the output method properties

     * see java.xml.transform.Transform.getOutputMethodProperties()

     */

    public Properties getOutputMethodProperties()

    {

        // FIXME

        return null;

    }

    /**

     * resets the output method to just those properties which were

     * set in the stylesheet and/or defaults

     */

    public void clearOutputMethodProperties()

    {

        _runtimeOutputMethod = null;

    }

    /**

     * override the stylesheet's or default value for an

     * output method property

     */

    public void setOutputMethodProperty(String encodedPropertyNamespace,

                                        String encodedPropertyName, String value)

        throws XSLException

    {

        if (_runtimeOutputMethod == null) {

            _runtimeOutputMethod = (OutputMethodImpl) _outputMethod.clone();

        }

        Name name = (encodedPropertyNamespace == null) ?

            nameTable.createName(encodedPropertyName) :

            nameTable.createName("omp:" + encodedPropertyName,

                                 encodedPropertyNamespace);

       

        // null node for namespace prefix mapping

        _runtimeOutputMethod.setSpecifiedValue(name, value, null);    

    }

    /**

     * returns the current value of the named property

     */

    public String getOutputMethodProperty(String encodedPropertyNamespace,

                                          String encodedPropertyName)

    {

        OutputMethod om = ( _runtimeOutputMethod == null) ?

            _outputMethod :

            _runtimeOutputMethod;

       

        Name name = (encodedPropertyNamespace == null) ?

            nameTable.createName(encodedPropertyName) :

            nameTable.createName("omp:" + encodedPropertyName,

                                 encodedPropertyNamespace);

        return om.getSpecifiedValue(name);

    }

    //

    //

    //

    /////////////////////////////////////////////////////////

    /**

     * process an XML input document against this stylesheet

     * @param node the source document

     * @param omBuilder an object model builder we can (re-)use for e.g. "document()"

     * @param params the XSLT run-time parameters

     * @param root the destination for thetransformation results

     */

    public Result process(Node node, XMLProcessor omBuilder,

                          ParameterSet params, Result root)

        throws XSLException

    {

  root.start(_runtimeOutputMethod == null ?

                   _outputMethod :

                   _runtimeOutputMethod);

  ProcessContextImpl pci =

            new ProcessContextImpl(this, node, omBuilder, params);

        pci.processSafe(node, null, root);

  root.end();

  return root;

    }

   

    // parse the om representation of the stylesheet

    // in order to build a compiled sheet

    private void parseSheet(Node rootNode)

        throws XSLException, IOException

    {

        if (rootNode == null) {

            throw new XSLException("null document rootNode");

        }

        // get the root Element

  Node sheetNode = rootNode.getChildren().next(); 

        if (sheetNode == null) {

            throw new XSLException("no root element");

        }

       

        // make sure it's an XSLT stylesheet if it's in the XSL namespace

  if (XSL_NAMESPACE.equals(sheetNode.getName().getNamespace())) {

      if (!XSL_STYLESHEET.equals(sheetNode.getName())

    && !XSL_TRANSFORM.equals(sheetNode.getName()))

    throw new XSLException("bad document element for stylesheet",

               sheetNode);

           

            // now start our recursive descent

      parseTopLevel(sheetNode);

  } else {

            // the root element wasn't in the XSL namespace, so ...

      parseRootTemplate(rootNode);

        }

   currentImportance.set(importCount);

  templateRules.compile();

  for (Enumeration iter = modeTable.elements() ;

             iter.hasMoreElements() ; ) {

      ((TemplateRuleSet)iter.nextElement()).compile();

        }

    }

    //

    //

    //

    private Vector getExcludedNamespaces(Node node) throws XSLException

    {

  String prefixList = node.getAttributeValue(EXCLUDE_RESULT_PREFIXES);

  if (prefixList == null)

      return null;

  Vector v = new Vector();

  StringTokenizer iter = new StringTokenizer(prefixList);

  while (iter.hasMoreElements()) {

      String prefix = (String)iter.nextElement();

      if (prefix == null) {

    break;

            }

      v.addElement(getPrefixNamespace(node, prefix));

  }

  if (v.size() == 0) {

      return null;

        }

  return v;

    }

    /**

     * @return  the namespace URI reference for the given prefix

     *   in scope at the given Node

     */

    String getPrefixNamespace(Node node, String prefix) throws XSLException

    {

  NamespacePrefixMap map = node.getNamespacePrefixMap();

  String ns = map.getNamespace(prefix);

  if (ns == null) {

      if (prefix.equals("#default")) {

    ns = map.getDefaultNamespace();

            }

      if (ns == null) {

    throw new XSLException("undefined prefix", node);

            }

  }

  return ns;

    }

    /**

     * come here if we have a "xsl:stylesheet" root element

     * expect XSLT elements permitted at the top level ... params,

     * templates, keys, etc.

     */

    void parseTopLevel(Node sheetNode) throws XSLException, IOException

    {

        //        System.out.println("parseTopLevel:: {" + sheetNode.getName().getNamespace() + "}" +  sheetNode.getName().getLocalPart());

  Vector saveExcludedNamespaces = excludedNamespaces;

  excludedNamespaces = getExcludedNamespaces(sheetNode);

  // hmmm ... should we really silently ignore some elements?

  for (NodeIterator iter = sheetNode.getChildren();;) {

      Node node = iter.next();

      if (node == null) {

    break;

            }

      TopLevelParser parser = null;

      try {

    Name name = node.getName();

    if (name == null) {

        throw new XSLException("illegal data characters inside xsl:stylesheet", node);

                }

    parser = (TopLevelParser)topLevelTable.get(name);

    if (parser == null && name.getNamespace() == null) {

        throw new XSLException("illegal top-level element", node);

                }

      }

      catch (ClassCastException e) { }

      if (parser != null) {

    parser.parse(node);

            }

  }

  excludedNamespaces = saveExcludedNamespaces;

    }

    //

    // handles a stylesheet with no "xsl:stylesheet" or "xsl:transform"

    //

    private void parseRootTemplate(Node defNode) throws XSLException

    {

        //        System.out.println("parseRootTemplate:: {" + defNode.getName().getNamespace() + "}" +  defNode.getName().getLocalPart());

  templateRules.add(ExprParser.parsePattern(defNode, "/"),

        currentImportance,

        null,

        parseActions(defNode, emptyAction));

    }

    /**

     * Parse the attributes on node as literal attributes and then

     * parse the actions.

     */

    Action parseAttributesAndActions(Node node) throws XSLException

    {

        //        System.out.println("parseAttributesAndActions:: {" + node.getName().getNamespace() + "}" +  node.getName().getLocalPart());

  AppendAction sequence = parseUseAttributeSets(node, true, null);

  for (NodeIterator iter = node.getAttributes();;) {

      Node att = iter.next();

      if (att == null) {

    break;

            }

      if (sequence == null) {

    if (_debugger != null) {

                    sequence = new AppendActionDebug(_debugger, node, "");

                } else {

                    sequence = new AppendAction();

                }

            }

      String value = att.getData();

      Name name = att.getName();

      if (XSL_NAMESPACE.equals(name.getNamespace())) {

    continue; // FIXME error checking

            }

      if (value.indexOf('{') >= 0 || value.indexOf('}') >= 0) {

    sequence.add(new TemplateAttributeAction(name,

               ExprParser.parseValueExpr(node, value, currentLocalVariables)));

            } else {

    sequence.add(new LiteralAttributeAction(name, value));

            }

        }

  return parseActions(node, null, sequence);

    }

    /**

     *

     */

    Action parseUseAttributeSetsAndActions(Node node) throws XSLException

    {

  return parseActions(node,

          emptyAction,

          parseUseAttributeSets(node, false, null));

    }

    /**

     *

     */

    AppendAction parseUseAttributeSets(Node node, boolean literal,

               AppendAction sequence) throws XSLException

    {

  String value = node.getAttributeValue(literal

                ? XSL_USE_ATTRIBUTE_SETS

                : USE_ATTRIBUTE_SETS);

  if (value != null) {

      for (StringTokenizer iter = new StringTokenizer(value);

     iter.hasMoreElements() ;  ) {

    if (sequence == null) {

        sequence = new AppendAction();

                }

    sequence.add(new UseAttributeSetAction(expandSourceElementTypeName((String)iter.nextElement(),node)));

      }

  }

  return sequence;

    }

    /**

     *

     */

    Action parseActions(Node node, Action ifEmpty) throws XSLException

    {

        //        System.out.println("parseActions1:: {" + node.getName().getNamespace() + "}" +  node.getName().getLocalPart());

        return parseActions(node, ifEmpty, null);

    }

 

    /**

     *

     */

    Action parseActions(Node node, Action ifEmpty,

                        AppendAction sequence) throws XSLException

    {

        //        System.out.println("parseActions2:: {" + node.getName().getNamespace() + "}" +  node.getName().getLocalPart());

  final VariableSet startLocalVariables = currentLocalVariables;

  final int nStartLocalVariables = nCurrentLocalVariables;

  NodeIterator iter = node.getChildren();

  node = iter.next();

  if (node == null) {

      if (sequence == null) {

    return ifEmpty;

      } else {

    return sequence;

            }

  }

  if (sequence == null) {

      if (_debugger != null) {

                sequence = new AppendActionDebug(_debugger, node, "");

            } else {

                sequence = new AppendAction();

            }

        }

  do {

      switch (node.getType()) {

      case Node.TEXT:

    if (_debugger != null) {

                    sequence.add(new CharsActionDebug(_debugger, node, "",

                                                      node.getData()));

                } else {

                    sequence.add(new CharsAction(node.getData()));

                }

    break;

      case Node.ELEMENT:

    {

        Name name = node.getName();

        String ns = name.getNamespace();

        if (!XSL_NAMESPACE.equals(ns) &&

                        !XT_NAMESPACE.equals(ns) &&

                        !XFYXT_NAMESPACE.equals(ns)) {

      if (_debugger != null) {

                            sequence.add(new LiteralElementActionDebug(_debugger,

                                                                       node, "",

                                                                       node.getName(),

                                                                       literalNamespacePrefixMap(node),

                                                                       parseAttributesAndActions(node)));

                        } else {

                            sequence.add(new LiteralElementAction(node.getName(),

                                                                  literalNamespacePrefixMap(node),

                                                                  parseAttributesAndActions(node)));

                        }

        } else {

      ActionParser actionParser = null;

      try {

          actionParser = (ActionParser)actionTable.get(name);

      } catch (ClassCastException e) {

                        }

      if (actionParser == null) {

          if (name.equals(XSL_SORT)

        && XSL_FOR_EACH.equals(node.getParent().getName()))

        ;

          else if (name.equals(XSL_FALLBACK))

        ; // FIXME error checking

          else

        throw new XSLException("expected action not " + name, node);

      } else {

          sequence.add(actionParser.parse(node));

                        }

        }

    }

      }

      node = iter.next();

  } while (node != null);

  // FIXME: should use finally here

  if (nStartLocalVariables != nCurrentLocalVariables) {

      sequence.add(new UnbindLocalVariablesAction(nCurrentLocalVariables -

                                                        nStartLocalVariables));

      nCurrentLocalVariables = nStartLocalVariables;

      currentLocalVariables = startLocalVariables;

  }

  return sequence;

    }

    /**

     *

     */

    String getRequiredAttribute(Node node, Name name)

        throws XSLException

    {

  String value = node.getAttributeValue(name);

  if (value == null) {

      throw new XSLException("missing attribute \"" +

                                   name + "\"", node);

        }

  return value;

    }

    /**

     *

     */

    String getOptionalAttribute(Node node, Name name, String dflt)

    {

  String value = node.getAttributeValue(name);

  return value == null ? dflt : value;

    }

    /**

     *

     */

    String getData(Node node) throws XSLException

    {

  node = node.getChildren().next();

  if (node == null) {

      return "";

        }

  String data = node.getData();

  if (data == null) {

      throw new XSLException("only character data allowed", node);

        }

  return data;

    }

    /**

     *

     */

    NumberListFormatTemplate getNumberListFormatTemplate(Node node)

        throws XSLException

    {

  NumberListFormatTemplate t = new NumberListFormatTemplate();

  String value = node.getAttributeValue(FORMAT);

  if (value != null) {

      StringExpr expr =

                ExprParser.parseValueExpr(node, value,

                                          currentLocalVariables);

      String format = expr.constantValue();

      if (format != null) {

    t.setFormat(format);

      } else {

    t.setFormat(expr);

            }

        }

  // FIXME should be able to use attribute value templates for these

  value = node.getAttributeValue(LANG);

  if (value != null)

      t.setLang(value);

  value = node.getAttributeValue(LETTER_VALUE);

  if (value != null)

      t.setLetterValue(value);

  value = node.getAttributeValue(GROUPING_SIZE);

  if (value != null) {

      try {

    t.setGroupingSize(Integer.parseInt(value));

      }

      catch (NumberFormatException e) { }

  }

  value = node.getAttributeValue(GROUPING_SEPARATOR);

  if (value != null)

      t.setGroupingSeparator(value);

  return t;

    }

    /**

     *

     */

    Action addParams(ParamAction action, Node node)

        throws XSLException

    {

  for (NodeIterator iter = node.getChildren() ; ; ) {

      node = iter.next();

      if (node == null) {

    break;

            }

      if (XSL_WITH_PARAM.equals(node.getName()))

    action.addParam(expandSourceElementTypeName(getRequiredAttribute(node, NAME),

                                                            node),

        getVariantExpr(node));

  }

  return action;

    }

    NodeSetExpr getSortNodeSetExpr(Node node,

                                   NodeSetExpr expr) throws XSLException

    {

  ComparatorTemplate comparatorTemplate = null;

  for (NodeIterator iter = node.getChildren();;) {

      node = iter.next();

      if (node == null) {

    break;

            }

      if (XSL_SORT.equals(node.getName())) {

    Locale locale = Lang.getLocale(node.getAttributeValue(LANG));

    Comparator cmp;

    String dataType = node.getAttributeValue(DATA_TYPE);

    if ("number".equals(dataType)) {

        cmp = new NumberComparator();

    } else {

        int caseOrder = 0;

        String caseOrderString =

                        node.getAttributeValue(CASE_ORDER);

        if ("upper-first".equals(caseOrderString)) {

      caseOrder = TextComparator.UPPER_FIRST;

        } else if ("lower-first".equals(caseOrderString)) {

      caseOrder = TextComparator.LOWER_FIRST;

                    }

        cmp = TextComparator.create(locale, caseOrder);

    }

    if ("descending".equals(node.getAttributeValue(ORDER)))

        cmp = new ReverseComparator(cmp);

    ComparatorTemplate templ

        = new NodeComparatorTemplate(cmp,

             ExprParser.parseStringExpr(node,

                      getOptionalAttribute(node, SELECT, "."), currentLocalVariables));

    if (comparatorTemplate == null)

        comparatorTemplate = templ;

    else

        comparatorTemplate = new BilevelComparatorTemplate(comparatorTemplate, templ);

      }

  }

  if (comparatorTemplate == null)

      return expr;

  return new SortNodeSetExpr(expr, comparatorTemplate);

    }

    /**

     * gets the value (an expression to be evaluated later) to be bound for a variable or parameter

     */

    VariantExpr getVariantExpr(Node defNode) throws XSLException