static void RemoveBlock(PPMdSubAllocatorVariantH *self,struct PPMdMemoryBlockVariantH *block)
{
struct PPMdMemoryBlockVariantH *preceeding=OffsetToPointer(self,block->prev);
struct PPMdMemoryBlockVariantH *following=OffsetToPointer(self,block->next);
preceeding->next=PointerToOffset(self,following);
following->prev=PointerToOffset(self,preceeding);
}
static uint32_t _AllocUnits(PPMdSubAllocatorVariantI *self,int index)
{
if(self->GlueCount==0)
{
GlueFreeBlocks(self);
if(AreBlocksAvailable(&self->BList[index])) return PointerToOffset(self,RemoveBlockAfter(&self->BList[index],self));
}
for(int i=index+1;i<N_INDEXES;i++)
{
if(AreBlocksAvailable(&self->BList[i]))
{
void *units=RemoveBlockAfter(&self->BList[i],self);
SplitBlock(self,units,i,index);
return PointerToOffset(self,units);
}
}
self->GlueCount--;
int i=I2B(self,index);
if(self->UnitsStart-self->pText>i)
{
self->UnitsStart-=i;
return PointerToOffset(self,self->UnitsStart);
}
return 0;
}
static uint32_t _AllocUnits(PPMdSubAllocatorVariantH *self,int index)
{
if(self->GlueCount==0)
{
self->GlueCount=255;
GlueFreeBlocks(self);
if(self->FreeList[index].next) return PointerToOffset(self,RemoveNode(self,index));
}
for(int i=index+1;i<N_INDEXES;i++)
{
if(self->FreeList[i].next)
{
void *units=RemoveNode(self,i);
SplitBlock(self,units,i,index);
return PointerToOffset(self,units);
}
}
self->GlueCount--;
int i=I2B(self,index);
if(self->UnitsStart-self->pText>i)
{
self->UnitsStart-=i;
return PointerToOffset(self,self->UnitsStart);
}
return 0;
}
static inline void InsertBlockAfter(PPMdSubAllocatorVariantH *self,struct PPMdMemoryBlockVariantH *block,struct PPMdMemoryBlockVariantH *preceeding)
{
struct PPMdMemoryBlockVariantH *following=OffsetToPointer(self,preceeding->next);
block->prev=PointerToOffset(self,preceeding);
block->next=PointerToOffset(self,following);
preceeding->next=PointerToOffset(self,block);
following->prev=PointerToOffset(self,block);
}
static uint32_t AllocContextVariantI(PPMdSubAllocatorVariantI *self)
{
if(self->HighUnit!=self->LowUnit)
{
self->HighUnit-=UNIT_SIZE;
return PointerToOffset(self,self->HighUnit);
}
else if(AreBlocksAvailable(&self->BList[0])) return PointerToOffset(self,RemoveBlockAfter(&self->BList[0],self));
else return _AllocUnits(self,0);
}
static uint32_t AllocContextVariantH(PPMdSubAllocatorVariantH *self)
{
if(self->HighUnit!=self->LowUnit)
{
self->HighUnit-=UNIT_SIZE;
return PointerToOffset(self,self->HighUnit);
}
if(self->FreeList->next) return PointerToOffset(self,RemoveNode(self,0));
return _AllocUnits(self,0);
}
static uint32_t AllocUnitsVariantI(PPMdSubAllocatorVariantI *self,int num)
{
int index=self->Units2Index[num-1];
if(AreBlocksAvailable(&self->BList[index])) return PointerToOffset(self,RemoveBlockAfter(&self->BList[index],self));
void *units=self->LowUnit;
self->LowUnit+=I2B(self,index);
if(self->LowUnit<=self->HighUnit) return PointerToOffset(self,units);
self->LowUnit-=I2B(self,index);
return _AllocUnits(self,index);
}
static uint32_t AllocUnitsVariantH(PPMdSubAllocatorVariantH *self,int num)
{
int index=self->Units2Index[num-1];
if(self->FreeList[index].next) return PointerToOffset(self,RemoveNode(self,index));
void *units=self->LowUnit;
self->LowUnit+=I2B(self,index);
if(self->LowUnit<=self->HighUnit) return PointerToOffset(self,units);
self->LowUnit-=I2B(self,index);
return _AllocUnits(self,index);
}
static uint32_t AllocContextBrimstone(PPMdSubAllocatorBrimstone *self)
{
if(self->HighUnit>self->LowUnit)
{
self->HighUnit-=UNIT_SIZE;
return PointerToOffset(self,self->HighUnit);
}
return AllocUnitsBrimstone(self,1);
}
static inline void GlueFreeBlocks(PPMdSubAllocatorVariantH *self)
{
if(self->LowUnit!=self->HighUnit) *self->LowUnit=0;
self->sentinel.next=self->sentinel.prev=PointerToOffset(self,&self->sentinel);
for(int i=0;i<N_INDEXES;i++)
{
while(self->FreeList[i].next)
{
struct PPMdMemoryBlockVariantH* p=(struct PPMdMemoryBlockVariantH *)RemoveNode(self,i);
InsertBlockAfter(self,p,&self->sentinel);
p->Stamp=0xFFFF;
p->NU=self->Index2Units[i];
}
}
for(struct PPMdMemoryBlockVariantH *p=OffsetToPointer(self,self->sentinel.next);
p!=&self->sentinel;p=OffsetToPointer(self,p->next))
{
for(;;)
{
struct PPMdMemoryBlockVariantH *p1=p+p->NU;
if(p1->Stamp!=0xFFFF) break;
if(p->NU+p1->NU>=0x10000) break;
RemoveBlock(self,p1);
p->NU+=p1->NU;
}
}
for(;;)
{
struct PPMdMemoryBlockVariantH *p=OffsetToPointer(self,self->sentinel.next);
if(p==&self->sentinel) break;
RemoveBlock(self,p);
int sz=p->NU;
while(sz>128)
{
InsertNode(self,p,N_INDEXES-1);
sz-=128;
p+=128;
}
int i=self->Units2Index[sz-1];
if(self->Index2Units[i]!=sz)
{
i--;
int k=sz-self->Index2Units[i];
InsertNode(self,p+(sz-k),k-1);
}
InsertNode(self,p,i);
}
}
/** help DoExtendedFunction to perform KFontDeleteShaping function
@param aParam Input parameter block
@return KErrNone if successful, KErrGeneral if the font does not have a valid handle.
*/
TInt CFbsFont::DoFontDeleteShaping(TFontShapeDeleteFunctionParameters* aParam) const
{
if (!iHandle)
{
return KErrGeneral;
}
// Convert the address of the shape header to an offset from the heap base
// of this process before the offset is sent to the server
iFbs->SendCommand(EFbsMessShapeDelete,iHandle,PointerToOffset(aParam->iShapeHeader, iFbs->HeapBase()));
return KErrNone;
}
static uint32_t AllocUnitsBrimstone(PPMdSubAllocatorBrimstone *self,int num)
{
int index=self->Units2Index[num-1];
if(self->FreeList[index].next) return PointerToOffset(self,RemoveNode(self,index));
void *units=self->LowUnit;
self->LowUnit+=I2B(self,index);
if(self->LowUnit<=self->HighUnit) return PointerToOffset(self,units);
self->LowUnit-=I2B(self,index);
for(int i=index+1;i<N_INDEXES;i++)
{
if(self->FreeList[i].next)
{
void *units=RemoveNode(self,i);
SplitBlock(self,units,i,index);
return PointerToOffset(self,units);
}
}
return 0;
}
uint32_t MoveUnitsUpVariantI(PPMdSubAllocatorVariantI *self,uint32_t oldoffs,int num)
{
void *oldptr=OffsetToPointer(self,oldoffs);
int index=self->Units2Index[num-1];
if((uint8_t *)oldptr>self->UnitsStart+16*1024||oldoffs>self->BList[index].next) return oldoffs;
void *ptr=RemoveBlockAfter(&self->BList[index],self);
memcpy(ptr,oldptr,num*UNIT_SIZE);
int newnum=self->Index2Units[index];
if((uint8_t *)oldptr!=self->UnitsStart) InsertBlockAfter(&self->BList[index],oldptr,newnum,self);
else self->UnitsStart+=newnum*UNIT_SIZE;
return PointerToOffset(self,ptr);
}
static uint32_t ShrinkUnitsVariantI(PPMdSubAllocatorVariantI *self,uint32_t oldoffs,int oldnum,int newnum)
{
void *oldptr=OffsetToPointer(self,oldoffs);
int oldindex=self->Units2Index[oldnum-1];
int newindex=self->Units2Index[newnum-1];
if(oldindex==newindex) return oldoffs;
if(AreBlocksAvailable(&self->BList[newindex]))
{
void *ptr=RemoveBlockAfter(&self->BList[newindex],self);
memcpy(ptr,oldptr,newnum*UNIT_SIZE);
InsertBlockAfter(&self->BList[oldindex],oldptr,self->Index2Units[oldindex],self);
return PointerToOffset(self,ptr);
}
else
{
SplitBlock(self,oldptr,oldindex,newindex);
return oldoffs;
}
}
static uint32_t ShrinkUnitsBrimstone(PPMdSubAllocatorBrimstone *self,uint32_t oldoffs,int oldnum,int newnum)
{
void *oldptr=OffsetToPointer(self,oldoffs);
int oldindex=self->Units2Index[oldnum-1];
int newindex=self->Units2Index[newnum-1];
if(oldindex==newindex) return oldoffs;
if(self->FreeList[newindex].next)
{
void *ptr=RemoveNode(self,newindex);
memcpy(ptr,oldptr,I2B(self,newindex));
InsertNode(self,oldptr,oldindex);
return PointerToOffset(self,ptr);
}
else
{
SplitBlock(self,oldptr,oldindex,newindex);
return oldoffs;
}
}
static void SetNextBlock(PPMdMemoryBlockVariantI *self,PPMdMemoryBlockVariantI *newnext,PPMdSubAllocatorVariantI *alloc)
{
self->next=PointerToOffset(&alloc->core,newnext);
}
void SetPPMdContextSuffixPointer(PPMdContext *self,PPMdContext *newsuffix,PPMdCoreModel *model)
{ self->Suffix=PointerToOffset(model->alloc,newsuffix); }
void SetPPMdContextStatesPointer(PPMdContext *self, PPMdState *newstates,PPMdCoreModel *model)
{ self->States=PointerToOffset(model->alloc,newstates); }
void SetPPMdStateSuccessorPointer(PPMdState *self,PPMdContext *newsuccessor,PPMdCoreModel *model)
{ self->Successor=PointerToOffset(model->alloc,newsuccessor); }
