diff -r 000000000000 -r 307788aac0a8 realtimenetprots/sipfw/SigComp/SigCompEngine/src/UdvmMemory.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/realtimenetprots/sipfw/SigComp/SigCompEngine/src/UdvmMemory.cpp	Tue Feb 02 01:03:15 2010 +0200
@@ -0,0 +1,233 @@
+// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// Name        : UdvmMemory.cpp
+// Part of     : SigComp / UDVM
+// UDVM memory/memory manipulation
+// Version     : 1.0
+//
+
+
+
+#include "Sigcomp.h"
+#include "Udvm.h"
+#include "UdvmMemory.h"
+
+// ============================ MEMBER FUNCTIONS ==============================
+
+void CUdvmMemory::ConstructL(TUint aMemSize)
+    {
+    iMemSize = aMemSize;
+    iMem = new (ELeave)CArrayFixFlat<TUint8>(8);
+    iMem->ResizeL(iMemSize);
+    }
+
+CUdvmMemory::CUdvmMemory()
+    {
+    }
+
+CUdvmMemory* CUdvmMemory::NewLC(TUint aMemSize)
+    {
+    CUdvmMemory* self= new (ELeave)CUdvmMemory();
+    CleanupStack::PushL(self);
+    self->ConstructL(aMemSize);
+    return self;
+    }
+
+CUdvmMemory* CUdvmMemory::NewL(TUint aMemSize)
+    {
+    CUdvmMemory* self= NewLC(aMemSize);
+    CleanupStack::Pop();
+    return self;
+    }
+
+// Destructor
+CUdvmMemory::~CUdvmMemory()
+    {
+    delete iMem;
+    }
+
+void CUdvmMemory::CheckMemAccessL(TUint aAddr, TUint aSize) const
+    {
+    if ((iFreeMemSize < KMaxUdvmMemorySize) &&
+        ((aAddr + aSize) > iFreeMemSize))
+        {
+        User::Leave(CSigComp::EDecompressionFailure);
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// CUdvmMemory::WriteMem8L
+// write byte to UDVM memory
+// ----------------------------------------------------------------------------
+//
+
+void CUdvmMemory::WriteMem8L(TUint aDest, TUint aVal)
+    {
+
+    CheckMemAccessL(aDest, 1);
+
+    (*iMem)[aDest] = static_cast<TUint8>(aVal & 0xff);
+    }
+
+
+// ----------------------------------------------------------------------------
+// CUdvmMemory::WriteMem16L
+// write 16-bit word to UDVM memory
+// ----------------------------------------------------------------------------
+//
+
+void CUdvmMemory::WriteMem16L(TUint aDest, TUint aVal)
+    {
+
+    CheckMemAccessL(aDest, 2);
+
+    // write 16-bit value in big-endian convention
+    (*iMem)[aDest] = static_cast<TUint8>((aVal >> 8) & 0xff);
+    (*iMem)[(aDest + 1) & KMaxUdvmMemoryMask] = static_cast<TUint8>
+                                                           (aVal & 0xff);
+    }
+
+
+// ----------------------------------------------------------------------------
+// CUdvmMemory::ReadMem8L
+// read byte from UDVM memory
+// ----------------------------------------------------------------------------
+//
+
+TUint8 CUdvmMemory::ReadMem8L(TUint aSrc) const
+    {
+
+    CheckMemAccessL(aSrc, 1);
+
+    return static_cast<TUint8>((*iMem)[aSrc]);
+    }
+
+
+// ----------------------------------------------------------------------------
+// CUdvmMemory::ReadMem16L
+// read 16-bit word from UDVM memory
+// ----------------------------------------------------------------------------
+//
+
+TUint16 CUdvmMemory::ReadMem16L(TUint aSrc) const
+    {
+
+    CheckMemAccessL(aSrc, 2);
+
+    // read 16-bit value in big-endian convention
+    return static_cast<TUint16>(((static_cast<TUint16>((*iMem)[aSrc]) << 8) +
+           static_cast<TUint16>((*iMem)[(aSrc + 1) & KMaxUdvmMemoryMask])));
+    }
+
+
+// ----------------------------------------------------------------------------
+// CUdvmMemory::SetMemL
+// set block of UDVM memory to value
+// ----------------------------------------------------------------------------
+//
+
+void CUdvmMemory::SetMemL(TUint aDest, TUint8 aVal, TUint aSize)
+    {
+
+    CheckMemAccessL(aDest, aSize);
+
+    for (TUint i = 0; i < aSize; i++)
+        {
+        (*iMem)[aDest] = aVal;
+        aDest = (aDest + 1) & KMaxUdvmMemoryMask;
+        }
+    }
+
+
+// ----------------------------------------------------------------------------
+// CUdvmMemory::CopyToMemL
+// copy block of data to UDVM memory
+// ----------------------------------------------------------------------------
+//
+
+void CUdvmMemory::CopyToMemL(TUint aDest, const TUint8* aSrc, TUint aSize)
+    {
+
+    CheckMemAccessL(aDest, aSize);
+
+    for (TUint i = 0; i < aSize; i++)
+        {
+        (*iMem)[aDest] = *aSrc++;
+        aDest = (aDest + 1) & KMaxUdvmMemoryMask;
+        }
+    }
+
+
+// ----------------------------------------------------------------------------
+// CUdvmMemory::CopyFromMemL
+// copy block of data from UDVM memory
+// ----------------------------------------------------------------------------
+//
+
+void CUdvmMemory::CopyFromMemL(TUint8* aDest, TUint aSrc, TUint aSize) const
+    {
+
+    CheckMemAccessL(aSrc, aSize);
+
+    for (TUint i = 0; i < aSize; i++)
+        {
+        *aDest++ = (*iMem)[aSrc];
+        aSrc = (aSrc + 1) & KMaxUdvmMemoryMask;
+        }
+    }
+
+void CUdvmMemory::InitMemoryL(TUint aMsgSize, TUint aCyclesPerBit)
+    {
+    if (iMemSize <= aMsgSize)
+        {
+        User::Leave(CSigComp::EDecompressionFailure);
+        }
+
+    iFreeMemSize = iMemSize-aMsgSize;
+    if (iFreeMemSize > KMaxUdvmMemorySize)
+        {
+        iFreeMemSize = KMaxUdvmMemorySize;
+        }
+
+    WriteMem16L(CUdvm::EMem_UDVM_memory_size, static_cast<TUint16>
+                (iFreeMemSize & KMaxUdvmMemoryMask));
+    WriteMem16L(CUdvm::EMem_cycles_per_bit, static_cast<TUint16>
+                (aCyclesPerBit));
+    WriteMem16L(CUdvm::EMem_SigComp_version, KSigCompVersion);
+    SetMemL(CUdvm::EMem_reserved, 0,
+            CUdvm::EMem_scratch_pad-CUdvm::EMem_reserved);
+    SetMemL(CUdvm::EMem_scratch_pad, 0,
+            CUdvm::EMem_registers - CUdvm::EMem_scratch_pad);
+    WriteMem16L(CUdvm::EReg_byte_copy_left, 0x0000);
+    WriteMem16L(CUdvm::EReg_byte_copy_right, 0x0000);
+    WriteMem16L(CUdvm::EReg_input_bit_order, 0x0000);
+    WriteMem16L(CUdvm::EReg_stack_location, 0x0000);
+    SetMemL(CUdvm::EMem_user_area, 0, iFreeMemSize - CUdvm::EMem_user_area);
+    }
+
+TUint8* CUdvmMemory::MemoryPtr()
+    {
+    return &iMem->At(0);
+    }
+
+TUint CUdvmMemory::MemorySize() const
+    {
+    return iMemSize;
+    }
+
+TUint CUdvmMemory::FreeMemorySize() const
+    {
+    return iFreeMemSize;
+    }
+