/*

 * reserved comment block

 * DO NOT REMOVE OR ALTER!

 */

/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You 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.

 */

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

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

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

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

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

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

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

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

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

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

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;

/**

 * @author Jacek Ambroziak

 * @author Santiago Pericas-Geertsen

 */

final class ParentPattern extends RelativePathPattern {

    private final Pattern _left;

    private final RelativePathPattern _right;

    public ParentPattern(Pattern left, RelativePathPattern right) {

        (_left = left).setParent(this);

        (_right = right).setParent(this);

    }

    public void setParser(Parser parser) {

        super.setParser(parser);

        _left.setParser(parser);

        _right.setParser(parser);

    }

    public boolean isWildcard() {

        return false;

    }

    public StepPattern getKernelPattern() {

        return _right.getKernelPattern();

    }

    public void reduceKernelPattern() {

        _right.reduceKernelPattern();

    }

    public Type typeCheck(SymbolTable stable) throws TypeCheckError {

        _left.typeCheck(stable);

        return _right.typeCheck(stable);

    }

    public void translate(ClassGenerator classGen, MethodGenerator methodGen) {

        final ConstantPoolGen cpg = classGen.getConstantPool();

        final InstructionList il = methodGen.getInstructionList();

        final LocalVariableGen local =

            methodGen.addLocalVariable2("ppt",

                                        Util.getJCRefType(NODE_SIG),

                                        null);

        final com.sun.org.apache.bcel.internal.generic.Instruction loadLocal =

            new ILOAD(local.getIndex());

        final com.sun.org.apache.bcel.internal.generic.Instruction storeLocal =

            new ISTORE(local.getIndex());

        if (_right.isWildcard()) {

            il.append(methodGen.loadDOM());

            il.append(SWAP);

        }

        else if (_right instanceof StepPattern) {

            il.append(DUP);

            local.setStart(il.append(storeLocal));

            _right.translate(classGen, methodGen);

            il.append(methodGen.loadDOM());

            local.setEnd(il.append(loadLocal));

        }

        else {

            _right.translate(classGen, methodGen);

            if (_right instanceof AncestorPattern) {

                il.append(methodGen.loadDOM());

                il.append(SWAP);

            }

        }

        final int getParent = cpg.addInterfaceMethodref(DOM_INTF,

                                                        GET_PARENT,

                                                        GET_PARENT_SIG);

        il.append(new INVOKEINTERFACE(getParent, 2));

        final SyntaxTreeNode p = getParent();

        if (p == null || p instanceof Instruction ||

            p instanceof TopLevelElement)

        {

            _left.translate(classGen, methodGen);

        }

        else {

            il.append(DUP);

            InstructionHandle storeInst = il.append(storeLocal);

            if (local.getStart() == null) {

                local.setStart(storeInst);

            }

            _left.translate(classGen, methodGen);

            il.append(methodGen.loadDOM());

            local.setEnd(il.append(loadLocal));

        }

        methodGen.removeLocalVariable(local);

        /*

         * If _right is an ancestor pattern, backpatch _left false

         * list to the loop that searches for more ancestors.

         */

        if (_right instanceof AncestorPattern) {

            final AncestorPattern ancestor = (AncestorPattern) _right;

            _left.backPatchFalseList(ancestor.getLoopHandle());    // clears list

        }

        _trueList.append(_right._trueList.append(_left._trueList));

        _falseList.append(_right._falseList.append(_left._falseList));

    }

    public String toString() {

        return "Parent(" + _left + ", " + _right + ')';

    }

}