/*

 * reserved comment block

 * DO NOT REMOVE OR ALTER!

 */

/*

 * Copyright 2001-2004 The Apache Software Foundation.

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

/*

 * $Id: Predicate.java,v 1.2.4.1 2005/09/12 11:02:18 pvedula Exp $

 */

package com.sun.org.apache.xalan.internal.xsltc.compiler;

import java.util.ArrayList;

import com.sun.org.apache.bcel.internal.classfile.Field;

import com.sun.org.apache.bcel.internal.generic.ASTORE;

import com.sun.org.apache.bcel.internal.generic.CHECKCAST;

import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;

import com.sun.org.apache.bcel.internal.generic.GETFIELD;

import com.sun.org.apache.bcel.internal.generic.INVOKESPECIAL;

import com.sun.org.apache.bcel.internal.generic.InstructionList;

import com.sun.org.apache.bcel.internal.generic.LocalVariableGen;

import com.sun.org.apache.bcel.internal.generic.NEW;

import com.sun.org.apache.bcel.internal.generic.PUSH;

import com.sun.org.apache.bcel.internal.generic.PUTFIELD;

import com.sun.org.apache.xalan.internal.xsltc.compiler.util.BooleanType;

import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ClassGenerator;

import com.sun.org.apache.xalan.internal.xsltc.compiler.util.FilterGenerator;

import com.sun.org.apache.xalan.internal.xsltc.compiler.util.IntType;

import com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator;

import com.sun.org.apache.xalan.internal.xsltc.compiler.util.NumberType;

import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ReferenceType;

import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ResultTreeType;

import com.sun.org.apache.xalan.internal.xsltc.compiler.util.TestGenerator;

import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Type;

import com.sun.org.apache.xalan.internal.xsltc.compiler.util.TypeCheckError;

import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Util;

import com.sun.org.apache.xalan.internal.xsltc.runtime.Operators;

/**

 * @author Jacek Ambroziak

 * @author Santiago Pericas-Geertsen

 * @author Morten Jorgensen

 */

final class Predicate extends Expression implements Closure {

    /**

     * The predicate's expression.

     */

    private Expression _exp = null;

    /**

     * This flag indicates if optimizations are turned on. The

     * method <code>dontOptimize()</code> can be called to turn

     * optimizations off.

     */

    private boolean _canOptimize = true;

    /**

     * Flag indicatig if the nth position optimization is on. It

     * is set in <code>typeCheck()</code>.

     */

    private boolean _nthPositionFilter = false;

    /**

     * Flag indicatig if the nth position descendant is on. It

     * is set in <code>typeCheck()</code>.

     */

    private boolean _nthDescendant = false;

    /**

     * Cached node type of the expression that owns this predicate.

     */

    int _ptype = -1;

    /**

     * Name of the inner class.

     */

    private String _className = null;

    /**

     * List of variables in closure.

     */

    private ArrayList _closureVars = null;

    /**

     * Reference to parent closure.

     */

    private Closure _parentClosure = null;

    /**

     * Cached value of method <code>getCompareValue()</code>.

     */

    private Expression _value = null;

    /**

     * Cached value of method <code>getCompareValue()</code>.

     */

    private Step _step = null;

    /**

     * Initializes a predicate.

     */

    public Predicate(Expression exp) {

        _exp = exp;

        _exp.setParent(this);

    }

    /**

     * Set the parser for this expression.

     */

    public void setParser(Parser parser) {

        super.setParser(parser);

        _exp.setParser(parser);

    }

    /**

     * Returns a boolean value indicating if the nth position optimization

     * is on. Must be call after type checking!

     */

    public boolean isNthPositionFilter() {

        return _nthPositionFilter;

    }

    /**

     * Returns a boolean value indicating if the nth descendant optimization

     * is on. Must be call after type checking!

     */

    public boolean isNthDescendant() {

        return _nthDescendant;

    }

    /**

     * Turns off all optimizations for this predicate.

     */

    public void dontOptimize() {

        _canOptimize = false;

    }

    /**

     * Returns true if the expression in this predicate contains a call

     * to position().

     */

    public boolean hasPositionCall() {

        return _exp.hasPositionCall();

    }

    /**

     * Returns true if the expression in this predicate contains a call

     * to last().

     */

    public boolean hasLastCall() {

        return _exp.hasLastCall();

    }

    // -- Begin Closure interface --------------------

    /**

     * Returns true if this closure is compiled in an inner class (i.e.

     * if this is a real closure).

     */

    public boolean inInnerClass() {

        return (_className != null);

    }

    /**

     * Returns a reference to its parent closure or null if outermost.

     */

    public Closure getParentClosure() {

        if (_parentClosure == null) {

            SyntaxTreeNode node = getParent();

            do {

                if (node instanceof Closure) {

                    _parentClosure = (Closure) node;

                    break;

                }

                if (node instanceof TopLevelElement) {

                    break;      // way up in the tree

                }

                node = node.getParent();

            } while (node != null);

        }

        return _parentClosure;

    }

    /**

     * Returns the name of the auxiliary class or null if this predicate

     * is compiled inside the Translet.

     */

    public String getInnerClassName() {

        return _className;

    }

    /**

     * Add new variable to the closure.

     */

    public void addVariable(VariableRefBase variableRef) {

        if (_closureVars == null) {

            _closureVars = new ArrayList();

        }

        // Only one reference per variable

        if (!_closureVars.contains(variableRef)) {

            _closureVars.add(variableRef);

            // Add variable to parent closure as well

            Closure parentClosure = getParentClosure();

            if (parentClosure != null) {

                parentClosure.addVariable(variableRef);

            }

        }

    }

    // -- End Closure interface ----------------------

    /**

     * Returns the node type of the expression owning this predicate. The

     * return value is cached in <code>_ptype</code>.

     */

    public int getPosType() {

        if (_ptype == -1) {

            SyntaxTreeNode parent = getParent();

            if (parent instanceof StepPattern) {

                _ptype = ((StepPattern)parent).getNodeType();

            }

            else if (parent instanceof AbsoluteLocationPath) {

                AbsoluteLocationPath path = (AbsoluteLocationPath)parent;

                Expression exp = path.getPath();

                if (exp instanceof Step) {

                    _ptype = ((Step)exp).getNodeType();

                }

            }

            else if (parent instanceof VariableRefBase) {

                final VariableRefBase ref = (VariableRefBase)parent;

                final VariableBase var = ref.getVariable();

                final Expression exp = var.getExpression();

                if (exp instanceof Step) {

                    _ptype = ((Step)exp).getNodeType();

                }

            }

            else if (parent instanceof Step) {

                _ptype = ((Step)parent).getNodeType();

            }

        }

        return _ptype;

    }

    public boolean parentIsPattern() {

        return (getParent() instanceof Pattern);

    }

    public Expression getExpr() {

        return _exp;

    }

    public String toString() {

        return "pred(" + _exp + ')';

    }

    /**

     * Type check a predicate expression. If the type of the expression is

     * number convert it to boolean by adding a comparison with position().

     * Note that if the expression is a parameter, we cannot distinguish

     * at compile time if its type is number or not. Hence, expressions of

     * reference type are always converted to booleans.

     *

     * This method may be called twice, before and after calling

     * <code>dontOptimize()</code>. If so, the second time it should honor

     * the new value of <code>_canOptimize</code>.

     */

    public Type typeCheck(SymbolTable stable) throws TypeCheckError {

        Type texp = _exp.typeCheck(stable);

        // We need explicit type information for reference types - no good!

        if (texp instanceof ReferenceType) {

            _exp = new CastExpr(_exp, texp = Type.Real);

        }

        // A result tree fragment should not be cast directly to a number type,

        // but rather to a boolean value, and then to a numer (0 or 1).

        // Ref. section 11.2 of the XSLT 1.0 spec

        if (texp instanceof ResultTreeType) {

            _exp = new CastExpr(_exp, Type.Boolean);

            _exp = new CastExpr(_exp, Type.Real);

            texp = _exp.typeCheck(stable);

        }

        // Numerical types will be converted to a position filter

        if (texp instanceof NumberType) {

            // Cast any numerical types to an integer

            if (texp instanceof IntType == false) {

                _exp = new CastExpr(_exp, Type.Int);

            }

            if (_canOptimize) {

                // Nth position optimization. Expression must not depend on context

                _nthPositionFilter =

                    !_exp.hasLastCall() && !_exp.hasPositionCall();

                // _nthDescendant optimization - only if _nthPositionFilter is on

                if (_nthPositionFilter) {

                    SyntaxTreeNode parent = getParent();

                    _nthDescendant = (parent instanceof Step) &&

                        (parent.getParent() instanceof AbsoluteLocationPath);

                    return _type = Type.NodeSet;

                }

            }

           // Reset optimization flags

            _nthPositionFilter = _nthDescendant = false;

           // Otherwise, expand [e] to [position() = e]

           final QName position =

                getParser().getQNameIgnoreDefaultNs("position");

           final PositionCall positionCall =

                new PositionCall(position);

           positionCall.setParser(getParser());

           positionCall.setParent(this);

           _exp = new EqualityExpr(Operators.EQ, positionCall,

                                    _exp);

           if (_exp.typeCheck(stable) != Type.Boolean) {

               _exp = new CastExpr(_exp, Type.Boolean);

           }

           return _type = Type.Boolean;

        }

        else {

            // All other types will be handled as boolean values

            if (texp instanceof BooleanType == false) {

                _exp = new CastExpr(_exp, Type.Boolean);

            }

            return _type = Type.Boolean;

        }

    }

    /**

     * Create a new "Filter" class implementing

     * <code>CurrentNodeListFilter</code>. Allocate registers for local

     * variables and local parameters passed in the closure to test().

     * Notice that local variables need to be "unboxed".

     */

    private void compileFilter(ClassGenerator classGen,

                               MethodGenerator methodGen) {

        TestGenerator testGen;

        LocalVariableGen local;

        FilterGenerator filterGen;

        _className = getXSLTC().getHelperClassName();

        filterGen = new FilterGenerator(_className,

                                        "java.lang.Object",

                                        toString(),

                                        ACC_PUBLIC | ACC_SUPER,

                                        new String[] {

                                            CURRENT_NODE_LIST_FILTER

                                        },

                                        classGen.getStylesheet());

        final ConstantPoolGen cpg = filterGen.getConstantPool();

        final int length = (_closureVars == null) ? 0 : _closureVars.size();

        // Add a new instance variable for each var in closure

        for (int i = 0; i < length; i++) {

            VariableBase var = ((VariableRefBase) _closureVars.get(i)).getVariable();

            filterGen.addField(new Field(ACC_PUBLIC,

                                        cpg.addUtf8(var.getEscapedName()),

                                        cpg.addUtf8(var.getType().toSignature()),

                                        null, cpg.getConstantPool()));

        }

        final InstructionList il = new InstructionList();

        testGen = new TestGenerator(ACC_PUBLIC | ACC_FINAL,

                                    com.sun.org.apache.bcel.internal.generic.Type.BOOLEAN,

                                    new com.sun.org.apache.bcel.internal.generic.Type[] {

                                        com.sun.org.apache.bcel.internal.generic.Type.INT,

                                        com.sun.org.apache.bcel.internal.generic.Type.INT,

                                        com.sun.org.apache.bcel.internal.generic.Type.INT,

                                        com.sun.org.apache.bcel.internal.generic.Type.INT,

                                        Util.getJCRefType(TRANSLET_SIG),

                                        Util.getJCRefType(NODE_ITERATOR_SIG)

                                    },

                                    new String[] {

                                        "node",

                                        "position",

                                        "last",

                                        "current",

                                        "translet",

                                        "iterator"

                                    },

                                    "test", _className, il, cpg);

        // Store the dom in a local variable

        local = testGen.addLocalVariable("document",

                                         Util.getJCRefType(DOM_INTF_SIG),

                                         null, null);

        final String className = classGen.getClassName();

        il.append(filterGen.loadTranslet());

        il.append(new CHECKCAST(cpg.addClass(className)));

        il.append(new GETFIELD(cpg.addFieldref(className,

                                               DOM_FIELD, DOM_INTF_SIG)));

        local.setStart(il.append(new ASTORE(local.getIndex())));

        // Store the dom index in the test generator

        testGen.setDomIndex(local.getIndex());

        _exp.translate(filterGen, testGen);

        il.append(IRETURN);

        filterGen.addEmptyConstructor(ACC_PUBLIC);

        filterGen.addMethod(testGen);

        getXSLTC().dumpClass(filterGen.getJavaClass());

    }

    /**

     * Returns true if the predicate is a test for the existance of an

     * element or attribute. All we have to do is to get the first node

     * from the step, check if it is there, and then return true/false.

     */

    public boolean isBooleanTest() {

        return (_exp instanceof BooleanExpr);

    }

    /**

     * Method to see if we can optimise the predicate by using a specialised

     * iterator for expressions like '/foo/bar[@attr = $var]', which are

     * very common in many stylesheets

     */

    public boolean isNodeValueTest() {

        if (!_canOptimize) return false;

        return (getStep() != null && getCompareValue() != null);

    }

   /**

     * Returns the step in an expression of the form 'step = value'.

     * Null is returned if the expression is not of the right form.

     * Optimization if off if null is returned.

     */

    public Step getStep() {

        // Returned cached value if called more than once

        if (_step != null) {

            return _step;

        }

        // Nothing to do if _exp is null

        if (_exp == null) {

            return null;

        }

        // Ignore if not equality expression

        if (_exp instanceof EqualityExpr) {

            EqualityExpr exp = (EqualityExpr)_exp;

            Expression left = exp.getLeft();

            Expression right = exp.getRight();

            // Unwrap and set _step if appropriate

            if (left instanceof CastExpr) {

                left = ((CastExpr) left).getExpr();

            }

            if (left instanceof Step) {

                _step = (Step) left;

            }

            // Unwrap and set _step if appropriate

            if (right instanceof CastExpr) {

                right = ((CastExpr)right).getExpr();

            }

            if (right instanceof Step) {

                _step = (Step)right;

            }

        }

        return _step;

    }

    /**

     * Returns the value in an expression of the form 'step = value'.

     * A value may be either a literal string or a variable whose

     * type is string. Optimization if off if null is returned.

     */

    public Expression getCompareValue() {

        // Returned cached value if called more than once

        if (_value != null) {

            return _value;

        }

        // Nothing to to do if _exp is null

        if (_exp == null) {

            return null;

        }

        // Ignore if not an equality expression

        if (_exp instanceof EqualityExpr) {

            EqualityExpr exp = (EqualityExpr) _exp;

            Expression left = exp.getLeft();

            Expression right = exp.getRight();

            // Return if left is literal string

            if (left instanceof LiteralExpr) {

                _value = left;

                return _value;

            }

            // Return if left is a variable reference of type string

            if (left instanceof VariableRefBase &&

                left.getType() == Type.String)

            {

                _value = left;

                return _value;

            }

            // Return if right is literal string

            if (right instanceof LiteralExpr) {

                _value = right;

                return _value;

            }