* MVEL 2.0

* Copyright (C) 2007 The Codehaus

* Mike Brock, Dhanji Prasanna, John Graham, Mark Proctor

*

* 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.

*/

* Implementation of the MVEL Just-in-Time (JIT) compiler for Property Accessors using the ASM bytecode

* engineering library.

* <p/>

*/

  private static final String MAP_IMPL = "java/util/HashMap";

  private static String LIST_IMPL;

  private static String NAMESPACE;

  private static final int OPCODES_VERSION;

  static {

    final String javaVersion = getProperty("java.version");

    if (javaVersion.startsWith("1.4"))

      OPCODES_VERSION = Opcodes.V1_4;

    else if (javaVersion.startsWith("1.5"))

      OPCODES_VERSION = Opcodes.V1_5;

    else if (javaVersion.startsWith("1.6") || javaVersion.startsWith("1.7"))

      OPCODES_VERSION = Opcodes.V1_6;

    else if (javaVersion.startsWith("1.8"))

      OPCODES_VERSION = Opcodes.V1_8;

    else

      OPCODES_VERSION = Opcodes.V1_2;

    String defaultNameSapce = getProperty("mvel2.namespace");

    if (defaultNameSapce == null) NAMESPACE = "org/mvel2/";

    else NAMESPACE = defaultNameSapce;

    String jitListImpl = getProperty("mvel2.jit.list_impl");

    if (jitListImpl == null) LIST_IMPL = NAMESPACE + "util/FastList";

    else LIST_IMPL = jitListImpl;

  }

  private Object ctx;

  private Object thisRef;

  private VariableResolverFactory variableFactory;

  private static final Object[] EMPTYARG = new Object[0];

  private static final Class[] EMPTYCLS = new Class[0];

  private boolean first = true;

  private boolean noinit = false;

  private boolean deferFinish = false;

  private boolean literal = false;

  private boolean propNull = false;

  private boolean methNull = false;

  private String className;

  private ClassWriter cw;

  private MethodVisitor mv;

  private Object val;

  private int stacksize = 1;

  private int maxlocals = 1;

  private long time;

  private ArrayList<ExecutableStatement> compiledInputs;

  private Class ingressType;

  private Class returnType;

  private int compileDepth = 0;

  @SuppressWarnings({"StringBufferField"})

  private StringAppender buildLog;

  public ASMAccessorOptimizer() {

    //do this to confirm we're running the correct version

    //otherwise should create a verification error in VM

    new ClassWriter(ClassWriter.COMPUTE_MAXS);

  }

  private ASMAccessorOptimizer(ClassWriter cw, MethodVisitor mv,

                               ArrayList<ExecutableStatement> compiledInputs, String className,

                               StringAppender buildLog, int compileDepth) {

    this.cw = cw;

    this.mv = mv;

    this.compiledInputs = compiledInputs;

    this.className = className;

    this.buildLog = buildLog;

    this.compileDepth = compileDepth + 1;

    noinit = true;

    deferFinish = true;

  }

  /**

   * Does all the boilerplate for initiating the JIT.

   */

  private void _initJIT() {

    if (isAdvancedDebugging()) {

      buildLog = new StringAppender();

    }

    cw = new ClassWriter(ClassWriter.COMPUTE_MAXS + ClassWriter.COMPUTE_FRAMES);

    synchronized (Runtime.getRuntime()) {

      cw.visit(OPCODES_VERSION, Opcodes.ACC_PUBLIC + Opcodes.ACC_SUPER, className = "ASMAccessorImpl_"

          + valueOf(cw.hashCode()).replaceAll("\\-", "_") + (System.currentTimeMillis() / 10) +

          ((int) Math.random() * 100),

          null, "java/lang/Object", new String[]{NAMESPACE + "compiler/Accessor"});

    }

    MethodVisitor m = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);

    m.visitCode();

    m.visitVarInsn(Opcodes.ALOAD, 0);

    m.visitMethodInsn(INVOKESPECIAL, "java/lang/Object",

        "<init>", "()V");

    m.visitInsn(RETURN);

    m.visitMaxs(1, 1);

    m.visitEnd();

    (mv = cw.visitMethod(ACC_PUBLIC, "getValue",

        "(Ljava/lang/Object;Ljava/lang/Object;L" + NAMESPACE

            + "integration/VariableResolverFactory;)Ljava/lang/Object;", null, null)).visitCode();

  }

  private void _initJIT2() {

    if (isAdvancedDebugging()) {

      buildLog = new StringAppender();

    }

    cw = new ClassWriter(ClassWriter.COMPUTE_MAXS + ClassWriter.COMPUTE_FRAMES);

    synchronized (Runtime.getRuntime()) {

      cw.visit(OPCODES_VERSION, Opcodes.ACC_PUBLIC + Opcodes.ACC_SUPER, className = "ASMAccessorImpl_"

          + valueOf(cw.hashCode()).replaceAll("\\-", "_") + (System.currentTimeMillis() / 10) +

          ((int) Math.random() * 100),

          null, "java/lang/Object", new String[]{NAMESPACE + "compiler/Accessor"});

    }

    MethodVisitor m = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);

    m.visitCode();

    m.visitVarInsn(Opcodes.ALOAD, 0);

    m.visitMethodInsn(INVOKESPECIAL, "java/lang/Object",

        "<init>", "()V");

    m.visitInsn(RETURN);

    m.visitMaxs(1, 1);

    m.visitEnd();

    (mv = cw.visitMethod(ACC_PUBLIC, "setValue",

        "(Ljava/lang/Object;Ljava/lang/Object;L" + NAMESPACE

            + "integration/VariableResolverFactory;Ljava/lang/Object;)Ljava/lang/Object;", null, null)).visitCode();

  }

  public Accessor optimizeAccessor(ParserContext pCtx, char[] property, int start, int offset, Object staticContext,

                                   Object thisRef, VariableResolverFactory factory, boolean root, Class ingressType) {

    time = System.currentTimeMillis();

    if (compiledInputs == null) compiledInputs = new ArrayList<ExecutableStatement>();

    this.start = cursor = start;

    this.end = start + offset;

    this.length = end - this.start;

    this.first = true;

    this.val = null;

    this.pCtx = pCtx;

    this.expr = property;

    this.ctx = staticContext;

    this.thisRef = thisRef;

    this.variableFactory = factory;

    this.ingressType = ingressType;

    if (!noinit) _initJIT();

    return compileAccessor();

  }

  public Accessor optimizeSetAccessor(ParserContext pCtx, char[] property, int start, int offset, Object ctx,

                                      Object thisRef, VariableResolverFactory factory, boolean rootThisRef,

                                      Object value, Class ingressType) {

    this.expr = property;

    this.start = this.cursor = start;

    this.end = start + offset;

    this.length = start + offset;

    this.first = true;

    this.ingressType = ingressType;

    compiledInputs = new ArrayList<ExecutableStatement>();

    this.pCtx = pCtx;

    this.ctx = ctx;

    this.thisRef = thisRef;

    this.variableFactory = factory;

    char[] root = null;

    PropertyVerifier verifier = new PropertyVerifier(property, this.pCtx = pCtx);

    int split = findLastUnion();

    if (split != -1) {

      root = subset(property, 0, split);

    }

    AccessorNode rootAccessor = null;

    _initJIT2();

    if (root != null) {

      int _length = this.length;

      int _end = this.end;

      char[] _expr = this.expr;

      this.length = end = (this.expr = root).length;

      // run the compiler but don't finish building.

      deferFinish = true;

      noinit = true;

      compileAccessor();

      ctx = this.val;

      this.expr = _expr;

      this.cursor = start + root.length + 1;

      this.length = _length - root.length - 1;

      this.end = this.cursor + this.length;

    }

    else {

      assert debug("ALOAD 1");

      mv.visitVarInsn(ALOAD, 1);

    }

    try {

      skipWhitespace();

      if (collection) {

        int st = cursor;

        whiteSpaceSkip();

        if (st == end)

          throw new PropertyAccessException("unterminated '['", expr, start);

        if (scanTo(']'))

          throw new PropertyAccessException("unterminated '['", expr, start);

        String ex = new String(expr, st, cursor - st).trim();

        assert debug("CHECKCAST " + ctx.getClass().getName());

        mv.visitTypeInsn(CHECKCAST, getInternalName(ctx.getClass()));

        if (ctx instanceof Map) {

          if (MVEL.COMPILER_OPT_ALLOW_OVERRIDE_ALL_PROPHANDLING && hasPropertyHandler(Map.class)) {

            propHandlerByteCodePut(ex, ctx, Map.class, value);

          }

          else {

            //noinspection unchecked

            ((Map) ctx).put(eval(ex, ctx, variableFactory), convert(value, returnType = verifier.analyze()));

            writeLiteralOrSubexpression(subCompileExpression(ex.toCharArray(), pCtx));

            assert debug("ALOAD 4");

            mv.visitVarInsn(ALOAD, 4);

            if (value != null && returnType != value.getClass()) {

              dataConversion(returnType);

              checkcast(returnType);

            }

            assert debug("INVOKEINTERFACE Map.put");

            mv.visitMethodInsn(INVOKEINTERFACE, "java/util/Map", "put",

                "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");

            assert debug("POP");

            mv.visitInsn(POP);

            assert debug("ALOAD 4");

            mv.visitVarInsn(ALOAD, 4);

          }

        }

        else if (ctx instanceof List) {

          if (MVEL.COMPILER_OPT_ALLOW_OVERRIDE_ALL_PROPHANDLING && hasPropertyHandler(List.class)) {

            propHandlerByteCodePut(ex, ctx, List.class, value);