/*

  * 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 org.apache.commons.nabla.automatic.analysis;

 import java.util.Iterator;

 import java.util.List;

 import org.objectweb.asm.Type;

 import org.objectweb.asm.tree.AbstractInsnNode;

 import org.objectweb.asm.tree.analysis.AnalyzerException;

 import org.objectweb.asm.tree.analysis.BasicInterpreter;

 import org.objectweb.asm.tree.analysis.BasicValue;

 import org.objectweb.asm.tree.analysis.Value;

 /** An interpreter tracking which instructions use which values.

  * <p>This interpreter wraps {@link org.objectweb.asm.tree.analysis.BasicValue

  * BasicValue} instances into {@link TrackingValue TrackingValue} instances.</p>

  */

 public class TrackingInterpreter extends BasicInterpreter {

     /** Build an interpreter.

      */

     public TrackingInterpreter() {

     }

     /** {@inheritDoc} */

     @Override

     public Value newValue(final Type type) {

         return (type == null) ? TrackingValue.UNINITIALIZED_VALUE : wrap(super.newValue(type), null);

     }

     /** {@inheritDoc} */

     @Override

     public Value newOperation(final AbstractInsnNode insn) {

         return wrap(super.newOperation(insn), insn);

     }

     /** {@inheritDoc} */

     @Override

     public Value unaryOperation(final AbstractInsnNode insn,

                                 final Value value)

         throws AnalyzerException {

         ((TrackingValue) value).addConsumer(insn);

         return wrap(super.unaryOperation(insn, value), insn);

     }

     /** {@inheritDoc} */

     @Override

     public Value binaryOperation(final AbstractInsnNode insn,

                                  final Value value1, final Value value2)

         throws AnalyzerException {

         ((TrackingValue) value1).addConsumer(insn);

         ((TrackingValue) value2).addConsumer(insn);

         return wrap(super.binaryOperation(insn, value1, value2), insn);

     }

     /** {@inheritDoc} */

     @Override

     public Value ternaryOperation(final AbstractInsnNode insn,

                                   final Value value1, final Value value2,

                                   final Value value3)

         throws AnalyzerException {

         ((TrackingValue) value1).addConsumer(insn);

         ((TrackingValue) value2).addConsumer(insn);

         ((TrackingValue) value3).addConsumer(insn);

         return wrap(super.ternaryOperation(insn, value1, value2, value3), insn);

     }

     /** {@inheritDoc} */

     @SuppressWarnings("unchecked")

     @Override

     public Value naryOperation(final AbstractInsnNode insn,

                                final List values)

         throws AnalyzerException {

         for (final Iterator<?> iterator = values.iterator(); iterator.hasNext();) {

             ((TrackingValue) iterator.next()).addConsumer(insn);

         }

         return wrap(super.naryOperation(insn, values), insn);

     }

     /** {@inheritDoc} */

     @Override

     public Value copyOperation(final AbstractInsnNode insn,

                                final Value value)

         throws AnalyzerException {

         // we reuse the same instance instead of wrapping it again

         // thus simplifying transitive dependencies propagation

         final TrackingValue tv = (TrackingValue) value;

         tv.addConsumer(insn);

         tv.addProducer(insn);

         return value;

     }

     /** {@inheritDoc} */

     @Override

     public Value merge(final Value v, final Value w) {

         final TrackingValue tv = (TrackingValue) v;

         final TrackingValue tw = (TrackingValue) w;

         TrackingValue.merge(tv, tw);

         final BasicValue superMerged = (BasicValue) super.merge(tv.getValue(), tw.getValue());

         return (superMerged == tv.getValue()) ? tv : new TrackingValue(superMerged);

     }

     /** Wrap a value returned by the superclass.

      * @param value underlying value (may be null)

      * @param producer instruction producing the value (may be null)

      * @return the wrapped value

      */

     private TrackingValue wrap(final Value value,

                                final AbstractInsnNode producer) {

         if (value == null) {

             return null;

         }

         // values produced by the superclass are either BasicValue instances

         // (like BasicValue.DOUBLE_VALUE) or already TrackingValue if the

         // superclass called our local implementation of newValue or newOperation

         final TrackingValue tv = (value instanceof TrackingValue) ?

                                  (TrackingValue) value :

                                  new TrackingValue((BasicValue) value);

         if (producer != null) {

             tv.addProducer(producer);

         }

         return tv;

     }

 }