tjmemorymanager.java

智能卡多应用一直是业界的重要课题

/**
 *        Title:  Memory Management Routines
 *
 *      Project:  Universal Application Specification v1.0 for PBOCv2
 *
 *    Copyright:  Copyright (c) CUP 2005
 *      Company:  China Unionpay Co., Ltd
 *
 *  Platform   :  Java virtual machine
 *  Language   :  1.3.0-C
 *  Devl tool  :  Borland (c) JBuilder 4.0 *
 *  author     :  Meng Hongwen<[e-mail]>
 *  version 1.0
 */

package cupUAPP;

import javacard.framework.*;

public class tjMemoryManager {
    private boolean  bReady;

    private TFreeCell[]  mArray;
    protected byte[]  vector;

    public short    remain;    // public for debug
    //------------------------------------------------
    public tjMemoryManager() {
        bReady = false;
        remain = (short)0;
    }
    //------------------------------------------------
    public boolean reset()
    {
       return bReady;
    }
    //------------------------------------------------
    public void initlize()
    {
        short i;
        TFreeCell  pfc;

        // alloc memory for storage
        vector = new byte[constdef.ct_memory_size];
        if ( vector == null ) return;

        mArray = new TFreeCell[constdef.ct_freespacecells];
        if (mArray==null) return;
        remain = constdef.ct_memory_size;

        pfc = new TFreeCell();
        if (pfc==null)  return;

        pfc.used = true;
        pfc.offset = 0;
        pfc.length = remain;
        pfc.tailer = remain;

        mArray[0] = pfc;

        for(i=1; i<constdef.ct_freespacecells;i++) {
           pfc = new TFreeCell();
           if (pfc==null)  return;
           pfc.used = false;
           mArray[i] = pfc;
        }

        bReady = true;
    }
    //------------------------------------------------
    private boolean  mergeblock(short fca,short fcb)
    {
       if (mArray[fca].tailer == mArray[fcb].offset) {
          mArray[fca].length += mArray[fcb].length;
          mArray[fca].tailer += mArray[fcb].length;
          mArray[fcb].used = false;
          return true;
       } else if (mArray[fcb].tailer == mArray[fca].offset) {
          mArray[fca].offset = mArray[fcb].offset;
          mArray[fca].tailer = (short)(mArray[fcb].tailer + mArray[fca].length);
          mArray[fca].length += mArray[fcb].length;
          mArray[fcb].used = false;
          return true;
       }
       return false;
    }
    //------------------------------------------------
    public void  JCompress()
    {
       boolean   bMerge,bQuit = false;
       short     uscurrent,uscursor;

       for(uscurrent=0; !bQuit&& (uscurrent<constdef.ct_freespacecells); uscurrent++ )
          for(uscursor=(short)(uscurrent+1); uscursor<constdef.ct_freespacecells; uscursor++ ) {
             if ( mArray[uscurrent].used && mArray[uscursor].used ) {
                bMerge = mergeblock(uscurrent,uscursor);
                if (bMerge) { // reset
                   uscurrent=0;
                   break;
                }
             } else bQuit = true;
          }
    }
    //------------------------------------------------
    public short JMalloc(short size)
    {
       short  i,address;

       JCompress();

       // search free space
       for(i=(short)1; i<constdef.ct_freespacecells; i++ )
          if (mArray[i].used && (mArray[i].length >= size) ) break;

       if (i>=constdef.ct_freespacecells) {
          if ( mArray[0].used && (mArray[0].length >= size) )i=(short)0;
          else return (short)-1;
       }

       address = mArray[i].offset;

       mArray[i].length -= size;
       if ( mArray[i].length == (short)0) {
           mArray[i].used = false;
       } else {
           mArray[i].offset += size;
       }

       remain -= size;
       return address;
    }
    //------------------------------------------------
    public short JReduce(short pADOff, short pADLen, short usReduceSize)
    // return new length for orignal length
    {
        short  pGapOff, newSize;

        if ( pADLen < usReduceSize ) return pADLen;

        newSize = (short)(pADLen - usReduceSize);
        pGapOff = (short)(pADOff + newSize);

        if (!JFree(pGapOff,usReduceSize)) return pADLen;
        return newSize;
    }
    //------------------------------------------------
    public boolean  JFree( short pAddOffset, short pAddLength )
    {
       boolean    rc = false;
       short      uscurrent,uscursor,usfreeTailer, usEmptyLocation;

       usEmptyLocation = constdef.ct_freespacecells;
       usfreeTailer = (short)(pAddOffset + pAddLength);
       for(uscurrent=0; uscurrent<constdef.ct_freespacecells; uscurrent++ ) {

          // nearby ?
          if (mArray[uscurrent].used) {
             if (!rc) {
                if ( mArray[uscurrent].offset == usfreeTailer ) { // above ?
                   mArray[uscurrent].offset = pAddOffset;
                   mArray[uscurrent].tailer = (short)(usfreeTailer + mArray[uscurrent].length);
                   mArray[uscurrent].length += pAddLength;
                   remain += pAddLength;
                   rc = true;
                } else if ( mArray[uscurrent].tailer == pAddOffset ) { // below ?
                   mArray[uscurrent].length += pAddLength;
                   mArray[uscurrent].tailer += pAddLength;
                   remain += pAddLength;
                   rc = true;
                }

                // mini merge case
                if (rc) {
                   // backward
                   uscursor = (short)(uscurrent-1);
                   while( uscursor>0 && !mArray[uscursor].used) uscursor--;
                   if (uscursor>=0 && mArray[uscursor].used )
                       mergeblock(uscursor,uscurrent);

                   // forward
                   uscursor = (short)(uscurrent+1);
                   while( uscursor < constdef.ct_freespacecells && !mArray[uscursor].used) uscursor++;
                   if (uscursor < constdef.ct_freespacecells && mArray[uscursor].used )
                      mergeblock(uscurrent,uscursor);
                } // end rc

             } // end !rc
          } else if ( uscurrent < usEmptyLocation ) usEmptyLocation = uscurrent;

          if (rc) break;

       } // end for

       if ( !rc )
          if ( usEmptyLocation <constdef.ct_freespacecells) { //add new cell
             mArray[usEmptyLocation].offset = pAddOffset;
             mArray[usEmptyLocation].length = pAddLength;
             mArray[usEmptyLocation].used = true;
             mArray[usEmptyLocation].tailer = usfreeTailer;
             remain += pAddLength;
             rc = true;
          }

       return rc;
    }
    //------------------------------------------------
    public byte getByte(short ADOff,short ADSize, short offset )
    {
        if ( offset > ADSize ) return (byte)0x0;

        return vector[(short)(ADOff+offset)];
    }
    //------------------------------------------------
    public void putByte(short ADOff,short ADSize, short offset, byte c)
    {
        if ( offset > ADSize ) return;
        vector[(short)(ADOff+offset)] = c;
    }
    //------------------------------------------------
    public boolean memcpyIN(short ADOff,short ADSize, short offset, byte[] src,short soff,short length)
    {
        if ( (short)(offset+length) > ADSize ) return false;
        Util.arrayCopyNonAtomic(src, soff,vector,(short)(ADOff+offset),length);
        return true;
    }
    //------------------------------------------------
    public boolean memcpyOUT(short ADOff,short ADSize, short offset, byte[] dst,short doff,short length)
    {
        if ( (short)(offset+length) > ADSize ) return false;

        Util.arrayCopyNonAtomic(vector,(short)(ADOff+offset), dst, doff,length);
        return true;
    }
    //------------------------------------------------
}