/*

  * 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.algorithmic.forward.analysis;

 import java.util.Set;

 import org.apache.commons.nabla.core.DifferentiationException;

 import org.apache.commons.nabla.core.UnivariateDerivative;

 import org.apache.commons.nabla.core.UnivariateDifferentiable;

 import org.objectweb.asm.AnnotationVisitor;

 import org.objectweb.asm.Attribute;

 import org.objectweb.asm.ClassVisitor;

 import org.objectweb.asm.FieldVisitor;

 import org.objectweb.asm.MethodVisitor;

 import org.objectweb.asm.Opcodes;

 /**

  * Visitor (in asm sense) for differentiating classes.

  * <p>

  * This visitor visits classes implementing the

  * {@link UnivariateDifferentiable UnivariateDifferentiable} interface and convert

  * them to classes implementing the {@link UnivariateDerivative

  * UnivariateDerivative} interface.

  * </p>

  * <p>

  * The visitor creates a new class as an inner class of the visited class.

  * Instances of the generated class are therefore automatically bound to their

  * primitive instance which is their directly enclosing instance. As such they

  * have access to the current value of all fields.

  * </p>

  * <p>

  * The visited class bytecode is not changed at all.

  * </p>

  */

 public class ClassDifferentiator implements ClassVisitor {

     /** Name for the primitive instance field. */

     private static final String PRIMITIVE_FIELD = "primitive";

     /** Math implementation classes. */

     private final Set<String> mathClasses;

     /** Class generating visitor. */

     private final ClassVisitor generator;

     /** Error reporter. */

     private final ErrorReporter errorReporter;

     /** Primitive class name. */

     private String primitiveName;

     /** Descriptor for the primitive class. */

     private String primitiveDesc;

     /** Derivative class name. */

     private String derivativeName;

     /** Indicator for specific fields and method addition. */

     private boolean specificMembersAdded;

     /**

      * Simple constructor.

      * @param mathClasses math implementation classes

      * @param generator visitor to which class generation calls will be delegated

      */

     public ClassDifferentiator(final Set<String> mathClasses,

                           final ClassVisitor generator) {

         this.mathClasses = mathClasses;

         this.generator   = generator;

         errorReporter    = new ErrorReporter();

     }

     /**

      * Get the name of the derivative class.

      * @return name of the (generated) derivative class

      */

     public String getDerivativeClassName() {

         return derivativeName;

     }

     /** {@inheritDoc} */

     public void visit(final int version, final int access,

                       final String name, final String signature,

                       final String superName, final String[] interfaces) {

         // set up the various names

         primitiveName = name;

         derivativeName   = primitiveName + "$NablaUnivariateDerivative";

         primitiveDesc = "L" + primitiveName + ";";

         // check the UnivariateDifferentiable interface is implemented

         final Class<UnivariateDifferentiable> uDerClass = UnivariateDifferentiable.class;

         boolean isDifferentiable = false;

         for (String interf : interfaces) {

             final String interfName = interf.replace('/', '.');

             Class<?> interfClass = null;

             try {

                 interfClass = Class.forName(interfName);

             } catch (ClassNotFoundException cnfe) {

                 // this should never occur since class has already been loaded

                 // and an instance already exists ...

                 errorReporter.register(new DifferentiationException("interface {0} not found " +

                                                                     "while differentiating class {1}",

                                                                     interfName, name));

             }

             if (interfClass != null) {

                 isDifferentiable = isDifferentiable || uDerClass.isAssignableFrom(interfClass);

             }

         }

         if (isDifferentiable) {

             // generate the new class implementing the UnivariateDerivative interface

             generator.visit(version, Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC,

                             derivativeName, signature, superName,

                             new String[] {

                                 UnivariateDerivative.class.getName().replace('.', '/')

                             });

         } else {

             errorReporter.register(new DifferentiationException("the {0} class does not implement " +

                                                                 "the {1} interface",

                                                                 name, uDerClass.getName()));

         }

         specificMembersAdded = false;

     }

     /** {@inheritDoc} */

     public MethodVisitor visitMethod(final int access, final String name,

                                      final String desc, final String signature,

                                      final String[] exceptions) {

         // don't do anything if an error has already been encountered

         if (errorReporter.hasError()) {

             return null;

         }

         if (!specificMembersAdded) {

             // add the specific members we need

             addPrimitiveField();

             addConstructor();

             addGetPrimitive();

             specificMembersAdded = true;

         }

         // is it the "public double f(double)" method we want to differentiate ?

         if (((access & Opcodes.ACC_PUBLIC) == Opcodes.ACC_PUBLIC) &&

                 "f".equals(name) && "(D)D".equals(desc) &&

                 ((exceptions == null) || (exceptions.length == 0))) {

             // get a generator for the method we are going to create

             final MethodVisitor visitor =

                 generator.visitMethod(access | Opcodes.ACC_SYNTHETIC, name,

                                       MethodDifferentiator.DP_RETURN_DP_DESCRIPTOR, null, null);

             // make sure our own differentiator will be used to transform the code

             return new MethodDifferentiator(access, name, desc, signature, exceptions,

                                        visitor, primitiveName, mathClasses, errorReporter);

         }

         // we are not interested in this method

         return null;

     }

     /** {@inheritDoc} */

     public FieldVisitor visitField(final int access, final String name,

                                    final String desc, final  String signature,

                                    final Object value) {

         // we are not interested in any fields

         return null;

     }

     /** {@inheritDoc} */

     public void visitSource(final String source, final String debug) {

     }

     /** {@inheritDoc} */

     public void visitOuterClass(final String owner, final String name,

                                 final String desc) {

     }

     /** {@inheritDoc} */

     public AnnotationVisitor visitAnnotation(final String desc,

                                              final boolean visible) {

         return null;

     }

     /** {@inheritDoc} */

     public void visitAttribute(final Attribute attr) {

     }

     /** {@inheritDoc} */

     public void visitInnerClass(final String name, final String outerName,

                                 final String innerName, final int access) {

     }

     /** {@inheritDoc} */

     public void visitEnd() {

         // don't do anything if an error has already been encountered

         if (errorReporter.hasError()) {

             return;

         }

         generator.visitEnd();

     }

     /** Add the primitive field.

      */

     private void addPrimitiveField() {

         final FieldVisitor visitor =

             generator.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC,

                                  PRIMITIVE_FIELD, primitiveDesc, null, null);

         visitor.visitEnd();

     }

     /** Add the class constructor.

      */

     private void addConstructor() {

         final String init = "<init>";

         final MethodVisitor visitor =

             generator.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, init,

                                   "(" + primitiveDesc + ")V", null, null);

         visitor.visitCode();

         visitor.visitVarInsn(Opcodes.ALOAD, 0);

         visitor.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", init, "()V");

         visitor.visitVarInsn(Opcodes.ALOAD, 0);

         visitor.visitVarInsn(Opcodes.ALOAD, 1);

         visitor.visitFieldInsn(Opcodes.PUTFIELD, derivativeName, PRIMITIVE_FIELD, primitiveDesc);

         visitor.visitInsn(Opcodes.RETURN);

         visitor.visitMaxs(0, 0);

         visitor.visitEnd();

     }

     /** Add the {@link UnivariateDerivative#getPrimitive() getPrimitive()} method.

      */

     private void addGetPrimitive() {

         final MethodVisitor visitor =

             generator.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, "getPrimitive",

                                   "()" + primitiveDesc, null, null);

         visitor.visitCode();

         visitor.visitVarInsn(Opcodes.ALOAD, 0);

         visitor.visitFieldInsn(Opcodes.GETFIELD, derivativeName, PRIMITIVE_FIELD, primitiveDesc);

         visitor.visitInsn(Opcodes.ARETURN);

         visitor.visitMaxs(0, 0);

         visitor.visitEnd();

     }

     /** Report the errors that may have occurred during analysis.

      * @exception DifferentiationException if the derivative class

      * could not be generated

      */

     public void reportErrors() throws DifferentiationException {

         errorReporter.reportErrors();

     }

 }