mfw_mfw.c

是一个手机功能的模拟程序

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW                |
| STATE   : code                        ROUTINE : mfwParent          |
+--------------------------------------------------------------------+

  PURPOSE : get parent of given element

*/

MfwHnd mfwParent (MfwHdr *h)
{
    if (!h)                             /* no element               */
        return 0;

    while (h->next && h->type != MfwTypMax)
        h = h->next;
    if (h->type != MfwTypMax)
        return 0;                       /* ERROR !                  */
    h = h->next;                        /* h points to root element */
    if (h && h->type == MfwTypWin)      /* parent should be window  */
        return h;

    return 0;                           /* root element             */
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW                |
| STATE   : code                        ROUTINE : mfwHeader          |
+--------------------------------------------------------------------+

  PURPOSE : get header of a given element

*/

MfwHnd mfwHeader (void)
{
  return current_mfw_elem;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW                |
| STATE   : code                        ROUTINE : mfwControl         |
+--------------------------------------------------------------------+

  PURPOSE : retrieve element control block

*/

MfwHnd mfwControl (MfwHdr *h)
{
    if (!h)
        return 0;
    if (h->type <= MfwTypNone || h->type >= MfwTypMax)
        return 0;

    return h->data;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW                |
| STATE   : code                        ROUTINE : mfwAlloc           |
+--------------------------------------------------------------------+

  PURPOSE : alloc MFW memory

*/

U8 *mfwAlloc (U16 size)
{
    MfwMemHdr *p, *n, *l;

    if (!mfwMemBase)
        return (U8 *) sysAlloc(size);

    size = (U16) mfwMemLarge(size);
    if (size >= mfwMemLeft)
    {
        TRACE_ERROR("mfwAlloc(): no memory");
        return 0;
    }
    if (!size)
    {
        TRACE_ERROR("mfwAlloc(): invalid memory request");
        return 0;
    }
    if (mfwMemBase + mfwMem.next > mfwMemEnd
              || mfwMemBase + mfwMem.next < mfwMemBase)
    {
        TRACE_ERROR("mfwAlloc(): corrupted memory");
        return 0;
    }

    p = &mfwMem;                        /* root of dyn memory       */
    n = (MfwMemHdr *) (mfwMemBase + p->next); /* first free block   */
    while ((U8 *) n < mfwMemEnd)
    {
        if (n->len == size)             /* fits exactly:            */
        {
            p->next = n->next;          /* just remove from chain   */
            mfwMemLeft -= size;
            if (mfwMemLeft < mfwMemLowWater)
                mfwMemLowWater = mfwMemLeft;
            memset(n,0,size);
            #ifdef ONEKEY_TOIDLE
            if(needreg==1)
            regEcMemory((MfwHnd)n,size);
            #endif

			// modify by clrobert
			// add
			#ifdef _INNOVATION_EMULATOR_
			mfwMemBlock ++;
			ShowHeapStatus(0);
			#endif
			// add end

            return (U8 *) n;
        }
        if (n->len > size)              /* take it from a big one   */
        {
            l = (MfwMemHdr *) ((U8 *) n + size); /* new header    */
            l->next = n->next;          /* setup chain to next    */
            l->len = (U16) (n->len - size); /* remaining memory   */
            p->next += size;            /* link with previous block */
            mfwMemLeft -= size;
            if (mfwMemLeft < mfwMemLowWater)
                mfwMemLowWater = mfwMemLeft;
            memset(n,0,size);
            #ifdef ONEKEY_TOIDLE
            if(needreg==1)
            regEcMemory((MfwHnd)n,size);
            #endif

			// modify by clrobert
			// add
			#ifdef _INNOVATION_EMULATOR_
			mfwMemBlock ++;
			ShowHeapStatus(0);
			#endif
			// add end
            
            return (U8 *) n;            /* allocated me address     */
        }
        p = n;
        n = (MfwMemHdr *) (mfwMemBase + n->next);
    }
    TRACE_ERROR("mfwAlloc(): no memory");

    return 0;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW                |
| STATE   : code                        ROUTINE : mfwFree            |
+--------------------------------------------------------------------+

  PURPOSE : free allocated MFW memory

*/

void mfwFree (U8 *mem, U16 size)
{
    MfwMemHdr *p, *n;

#ifdef TRACE_MEMORY
    TRACE_EVENT_P2("MFWFree address = %p - %d bytes",mem,size);
#endif

    if (!mfwMemBase)
    {
        void *m = mem;
//NM later
        sysFree(m);
#ifdef ONEKEY_TOIDLE
		if(needreg==1)
    freeEcMemory((MfwHnd)mem,size);
		#endif
        return;
    }

    size = (U16) mfwMemLarge(size);
    if (!size || !mem || mem < mfwMemBase || mem >= mfwMemEnd
              || mem + size > mfwMemEnd
              || mem + size <= mfwMemBase)
    {
        TRACE_ERROR("mfwFree(): invalid");
        return;                         /* nothing to free          */
    }

    memset(mem,0,size);
    p = &mfwMem;                        /* root of dyn memory       */
    n = (MfwMemHdr *) (mfwMemBase + p->next); /* first free block   */
    while ((U8 *) n < mfwMemEnd && (U8 *) n < mem)
    {                                   /* search allocated area    */
        p = n;
        n = (MfwMemHdr *) (mfwMemBase + n->next);
    }
    if (mem == (U8 *) p || mem == (U8 *) n)
    {
        TRACE_ERROR("mfwFree(): already free");
        return;                         /* already free             */
    }

    if (p != &mfwMem && (U8 *) p + p->len == mem)
    {                                   /* adjacent to left free:   */
        p->len += size;                 /* just add it              */
    }
    else
    {
        p->next = (U16) (mem - mfwMemBase); /* new free link        */
        p = (MfwMemHdr *) mem;          /* to new header            */
        p->next = (U16) ((U8 *) n - mfwMemBase); /* link to next    */
        p->len = size;
    }
    if ((U8 *) n < mfwMemEnd && mem + size == (U8 *) n)
    {                                   /* adjacent to right free:  */
        p->next = n->next;              /* eliminate link and       */
        p->len += n->len;               /* eat up the space         */
    }
    mfwMemLeft += size;
    #ifdef ONEKEY_TOIDLE
    if(needreg==1)
    freeEcMemory((MfwHnd)mem,size);
    #endif

    // modify by clrobert
	// add
	#ifdef _INNOVATION_EMULATOR_
	mfwMemBlock --;
	ShowHeapStatus(0);
	#endif
	// add end
}

U16 mfwCheckMemoryLeft(void){
  char temp[40];
  sprintf(temp,"memory left %d",mfwMemLeft);
  TRACE_EVENT(temp);

  return mfwMemLeft;

}
//yq add for one key to idle
void freeandreg(void *addr)
{
	EcMemInfo *h=memInfoRoot;
	while(h&&(h!=&memInfoNull))
		{
			if(h->addr==addr)
				{
					
					mfwFree((U8 *)h->addr,h->size);
					break;
				}
			else
				h=h->next;
		}
}


int freeAll(void)
{

	EcMemInfo *h=memInfoRoot;
	EcMemInfo *c=0;
	while(h&&(h!=&memInfoNull))
		{
			if(h->win!=idle_get_window())
				{
					c=h;
					h=h->next;
					mfwFree((U8 *)(c->addr),(U16)(c->size));
				}
			else
				break;
		}
	memInfoRoot=&memInfoNull;
	return 1;
}
static void regEcMemory(MfwHnd addr,int size)
{
	EcMemInfo *t;
	unsigned char old_flag;
	MfwHdr *cur_hdr=(MfwHdr *)mfwParent(mfwFocus);
	//TRACE_EVENT("regecmemory");
	if(cur_hdr&&cur_hdr->type==MfwTypWin)
		{
	needreg=0;
	t=(EcMemInfo *)mfwAlloc(sizeof(EcMemInfo));
	needreg=1;
	t->addr=addr;
	t->size=size;
	t->win=(MfwHnd)cur_hdr;
	t->next=memInfoRoot;

	memInfoRoot=t;
		}
	return;
}

static void freeEcMemory(MfwHnd addr,int size)
{
	EcMemInfo **h=&memInfoRoot;
	EcMemInfo *c=0;
	unsigned char old_flag;
	//TRACE_EVENT("freeecmemory");
	while((*h)&&((*h)!=&memInfoNull))
		{
			if((*h)->addr==addr)
				{
					c=*h;
					*h=(*h)->next;
					break;
				}
			else
				h=&((*h)->next);
		}
	if(c)
		{
			needreg=0;
			mfwFree((U8 *)c,sizeof(EcMemInfo));
			needreg=1;
		}
	return;
}
unsigned char Set_regflag(unsigned char flag)
{
	unsigned char old_flag;
	old_flag=needreg;
	needreg=flag;
	return old_flag;
}

void Tracememory()
{
	 MfwMemHdr *p, *n;
	 p = &mfwMem;                        /* root of dyn memory       */
    n = (MfwMemHdr *) (mfwMemBase + p->next); /* first free block   */
    TRACE_EVENT("begin trace memory");
    while ((U8 *) n < mfwMemEnd )
    {                                   /* search allocated area    */
        p = n;
        n = (MfwMemHdr *) (mfwMemBase + n->next);
    }
    TRACE_EVENT("end trace memory");
    return;
}