/**

  * Back 2 Browser Bytecode Translator

  * Copyright (C) 2012 Jaroslav Tulach <jaroslav.tulach@apidesign.org>

  *

  * This program is free software: you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation, version 2 of the License.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program. Look for COPYING file in the top folder.

  * If not, see http://opensource.org/licenses/GPL-2.0.

  */

 package org.apidesign.vm4brwsr;

 import org.apidesign.javap.TypeArray;

 import static org.apidesign.javap.RuntimeConstants.ITEM_Bogus;

 import static org.apidesign.javap.RuntimeConstants.ITEM_Integer;

 import static org.apidesign.javap.RuntimeConstants.ITEM_Float;

 import static org.apidesign.javap.RuntimeConstants.ITEM_Double;

 import static org.apidesign.javap.RuntimeConstants.ITEM_Long;

 import static org.apidesign.javap.RuntimeConstants.ITEM_Null;

 import static org.apidesign.javap.RuntimeConstants.ITEM_InitObject;

 import static org.apidesign.javap.RuntimeConstants.ITEM_Object;

 import static org.apidesign.javap.RuntimeConstants.ITEM_NewObject;

 public final class StackToVariableMapper {

     private final TypeArray stackTypeIndexPairs;

     private int[] typeCounters;

     private int[] typeMaxCounters;

     public StackToVariableMapper() {

         stackTypeIndexPairs = new TypeArray();

         typeCounters = new int[Variable.LAST_TYPE + 1];

         typeMaxCounters = new int[Variable.LAST_TYPE + 1];

     }

     public void clear() {

         for (int type = 0; type <= Variable.LAST_TYPE; ++type) {

             typeCounters[type] = 0;

         }

         stackTypeIndexPairs.clear();

     }

     public void syncWithFrameStack(final TypeArray frameStack) {

         clear();

         final int size = frameStack.getSize();

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

             final int frameStackValue = frameStack.get(i);

             switch (frameStackValue & 0xff) {

                 case ITEM_Integer:

                     pushTypeImpl(Variable.TYPE_INT);

                     break;

                 case ITEM_Float:

                     pushTypeImpl(Variable.TYPE_FLOAT);

                     break;

                 case ITEM_Double:

                     pushTypeImpl(Variable.TYPE_DOUBLE);

                     break;

                 case ITEM_Long:

                     pushTypeImpl(Variable.TYPE_LONG);

                     break;

                 case ITEM_Object:

                     pushTypeImpl(Variable.TYPE_REF);

                     break;

                 case ITEM_Bogus:

                 case ITEM_Null:

                 case ITEM_InitObject:

                 case ITEM_NewObject:

                     /* unclear how to handle for now */

                 default:

                     throw new IllegalStateException(

                                   "Unhandled frame stack type");

             }

         }

     }

     public Variable pushI() {

         return pushT(Variable.TYPE_INT);

     }

     public Variable pushL() {

         return pushT(Variable.TYPE_LONG);

     }

     public Variable pushF() {

         return pushT(Variable.TYPE_FLOAT);

     }

     public Variable pushD() {

         return pushT(Variable.TYPE_DOUBLE);

     }

     public Variable pushA() {

         return pushT(Variable.TYPE_REF);

     }

     public Variable pushT(final int type) {

         return getVariable(pushTypeImpl(type));

     }

     public Variable popI() {

         return popT(Variable.TYPE_INT);

     }

     public Variable popL() {

         return popT(Variable.TYPE_LONG);

     }

     public Variable popF() {

         return popT(Variable.TYPE_FLOAT);

     }

     public Variable popD() {

         return popT(Variable.TYPE_DOUBLE);

     }

     public Variable popA() {

         return popT(Variable.TYPE_REF);

     }

     public Variable popT(final int type) {

         final Variable variable = getT(0, type);

         popImpl(1);

         return variable;

     }

     public Variable pop() {

         final Variable variable = get(0);

         popImpl(1);

         return variable;

     }

     public void pop(final int count) {

         final int stackSize = stackTypeIndexPairs.getSize();

         if (count > stackSize) {

             throw new IllegalStateException("Stack underflow");

         }

         popImpl(count);

     }

     public Variable getI(final int indexFromTop) {

         return getT(indexFromTop, Variable.TYPE_INT);

     }

     public Variable getL(final int indexFromTop) {

         return getT(indexFromTop, Variable.TYPE_LONG);

     }

     public Variable getF(final int indexFromTop) {

         return getT(indexFromTop, Variable.TYPE_FLOAT);

     }

     public Variable getD(final int indexFromTop) {

         return getT(indexFromTop, Variable.TYPE_DOUBLE);

     }

     public Variable getA(final int indexFromTop) {

         return getT(indexFromTop, Variable.TYPE_REF);

     }

     public Variable getT(final int indexFromTop, final int type) {

         final int stackSize = stackTypeIndexPairs.getSize();

         if (indexFromTop >= stackSize) {

             throw new IllegalStateException("Stack underflow");

         }

         final int stackValue =

                 stackTypeIndexPairs.get(stackSize - indexFromTop - 1);

         if ((stackValue & 0xff) != type) {

             throw new IllegalStateException("Type mismatch");

         }

         return getVariable(stackValue);

     }

     public Variable get(final int indexFromTop) {

         final int stackSize = stackTypeIndexPairs.getSize();

         if (indexFromTop >= stackSize) {

             throw new IllegalStateException("Stack underflow");

         }

         final int stackValue =

                 stackTypeIndexPairs.get(stackSize - indexFromTop - 1);

         return getVariable(stackValue);

     }

     private int pushTypeImpl(final int type) {

         final int count = typeCounters[type];

         final int value = (count << 8) | (type & 0xff);

         incCounter(type);

         stackTypeIndexPairs.add(value);

         return value;

     }

     private void popImpl(final int count) {

         final int stackSize = stackTypeIndexPairs.getSize();

         for (int i = stackSize - count; i < stackSize; ++i) {

             final int value = stackTypeIndexPairs.get(i);

             decCounter(value & 0xff);

         }

         stackTypeIndexPairs.setSize(stackSize - count);

     }

     private void incCounter(final int type) {

         final int newValue = ++typeCounters[type];

         if (typeMaxCounters[type] < newValue) {

             typeMaxCounters[type] = newValue;

         }

     }

     private void decCounter(final int type) {

         --typeCounters[type];

     }

     public Variable getVariable(final int typeAndIndex) {

         final int type = typeAndIndex & 0xff;

         final int index = typeAndIndex >> 8;

         return Variable.getStackVariable(type, index);

     }

 }