Attachment #96544 for bug #148629

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 148629 | Differences between

and this patch

Collapse All | Expand All




// For this header to work, you need to define one of these ARCH symbols:
//
//	WIN32 (means x86)
//	IA32_ARCH (means x86)
//  IPF_ARCH (means Itanium Processor Family)
//  EM64T_ARCH (means Intel/AMD 64-bit processors)
//	IA32_ARCH (means x86)
//	SPARC_ARCH
//	HPPA_ARCH
//	ALPHA_ARCH
//	PPC_ARCH
//  LINUX_PPC_ARCH  (LINUX PPC64)
//	OS390_ARCH (means zSeries)
//	AS400_ARCH (means iSeries)
//

    // This brings _WINDOWS_ into scope. Use _WINDOWS_ to wrap Windows code.
#   include <windows.h>           /* for lots o' stuff, but esp. _WINDOWS_ */
#   include <malloc.h>            /* for alloca */
#elif defined(IPF_ARCH) || (EM64T_ARCH)
#   include <stdint.h>         /* for int64_t and uint64_t */
#endif

/* On LinuxPPC64 we need this to get int64_t */
#if defined(PPC_ARCH)
#   include </usr/include/sys/types.h>
#endif
/* Only on OS400, we need this to get malloc/free */
#ifdef OS400
#include <stdlib.h>

	typedef signed long long int int64_t;
	typedef unsigned long long int uint64_t;
#else
#   if defined(_WINDOWS_)
		typedef __int64 int64_t;
		typedef unsigned __int64 uint64_t;
#elif defined(PPC_ARCH)
#       if !defined(IPF_ARCH) && !defined(EM64T_ARCH) && !defined(LINUX_PPC_ARCH) // Already being declared in stdint.h
		typedef long long int64_t;
		typedef unsigned long long uint64_t;
#   else
#       if !defined(IPF_ARCH) && !defined(EM64T_ARCH)
	        typedef long long int64_t;
			typedef unsigned long long uint64_t;
#       endif
#   endif
#endif

//------------------------------------------------------------------------------

///////
#if defined(WIN32) || defined(IA32_ARCH) || defined(IPF_ARCH) || defined(EM64T_ARCH) || defined(ALPHA_ARCH)
#   define BIG_ENDIAN_HW
#elif defined(SPARC_ARCH) || defined(HPPA_ARCH) || defined(PPC_ARCH) || defined(AS400_ARCH) || defined(OS390_ARCH)
#   define LITTLE_ENDIAN_HW
#else
#   error "Platform-specific configuration required"




#define CONSTANT_InterfaceMethodref	11		// Interface method refernce constant 
#define CONSTANT_NameAndType		12		// Name and type constant

#define CONSTANT_Unknown			0
// Array types
#define T_BOOLEAN					4		// bool
#define T_CHAR						5		// char

#define T_INT						10		// int
#define T_LONG						11		// long

// stack map frame types (new in Java 6.0)
#define SAME_LOCALS_1_STACK_ITEM_EXTENDED   247
#define SAME_FRAME_EXTENDED                 251
#define FULL_FRAME                          255

// verification types (new in Java 6.0)
#define ITEM_Top                    0
#define ITEM_Integer                1
#define ITEM_Float                  2
#define ITEM_Double                 3
#define ITEM_Long                   4
#define ITEM_Null                   5
#define ITEM_UninitializedThis      6
#define ITEM_Object                 7
#define ITEM_Uninitialized          8

// ToDo: other Java specific definitions
typedef unsigned char				u1;		// 1 byte




string
CJClassBuilder::GetSuperClassName()
{
	CCPClassInfo* pccpClassInfo = (CCPClassInfo*)((*m_pConstPool)[GetSuperClass()]);
	CCPUtf8Info* pcpUtf8 = (CCPUtf8Info*)((*m_pConstPool)[pccpClassInfo->GetClassInd()]);
	string strSuperClass = (string)*pcpUtf8;
	return strSuperClass;
}

	CConstPool::iterator itr = m_pConstPool->begin();
	while(itr != m_pConstPool->end())
	{
		if (*itr == NULL) return NULL;
		if((*itr)->GetTag() == CONSTANT_Class)
		{
			CCPClassInfo* pcpci = (CCPClassInfo*)*itr;

}

//------------------------------------------------------------------------------
// CreateClassConstant
// In:
//	i_szClassName - class name
// Returns:
//	CCPClassInfo* - pointer to the class infoin the constant pool
//
CCPClassInfo* 
CJClassBuilder::CreateClassConstant(CSTR i_szClassName)
{
	u2 u2ClassName = m_pConstPool->Add(new CCPUtf8Info(i_szClassName));
	u2 u2ClassRef  = m_pConstPool->Add(new CCPClassInfo(u2ClassName));
	CCPClassInfo* pcpClass = (CCPClassInfo*)((*m_pConstPool)[u2ClassRef]);
	return pcpClass;
}

//------------------------------------------------------------------------------
// CreateIntegerConstant
// In:
//	i_int - Integer value to add

Lines 62-68 public: Link Here

(-)JClass/JClassBuilder.h (-1 / +2 lines)
62		62
63	// Constant pool manipulation	63	// Constant pool manipulation
64	CCPStringInfo* CreateStringConstant(CSTR i_szString);	64	CCPStringInfo* CreateStringConstant(CSTR i_szString);
65	CCPIntegerInfo* CreateIntegerConstant (JINTEGER i_int);	65	CCPClassInfo* CreateClassConstant(CSTR i_szClassName);
		66	CCPIntegerInfo* CreateIntegerConstant (JINTEGER i_int);
66	CCPLongInfo* CreateLongConstant(JLONG i_long);	67	CCPLongInfo* CreateLongConstant(JLONG i_long);
67	CCPFloatInfo* CreateFloatConstant(JFLOAT i_float);	68	CCPFloatInfo* CreateFloatConstant(JFLOAT i_float);
68	CCPDoubleInfo* CreateDoubleConstant(JDOUBLE i_double);	69	CCPDoubleInfo* CreateDoubleConstant(JDOUBLE i_double);




#  include <iostream>
#endif

#include "JavaDef.h"
#include "CommonDef.h"

#include "JClassFile.h"
#include "JMemStream.h"

USE_NAMESPACE(std);


void
CCPUtf8Info::Read(CJStream& i_jstream)
{
	i_jstream >> m_u2Length; 
	m_pu1Bytes = new u1[m_u2Length + 1];
	m_pu1Bytes[m_u2Length] = 0; /*Helps standard string functions find end of the string*/
	i_jstream.ReadUtf8((void*)m_pu1Bytes, m_u2Length);
}


		{
			pCurrent = new CLocalVariableTypeTableAttribute(m_pClassFile);
		}
 		else if(*pcpUtf8 == "StackMapTable")
		{
			pCurrent = new CStackMapTableAttribute(m_pClassFile);
		}
		else if(*pcpUtf8 == "Exceptions")
		{
			pCurrent = new CExceptionsAttribute(m_pClassFile);

	return NULL;
}

//------------------------------------------------------------------------------
CStackMapTableAttribute* 
CCodeAttribute::GetStackMaps()
{
	for(CJAttribs::iterator iter = m_Attribs.begin(); iter < m_Attribs.end(); iter++)
	{
		if(*(*iter)->GetName() == "StackMapTable")
			return (CStackMapTableAttribute*)*iter;
	}
	return NULL;
}

//------------------------------------------------------------------------------
CStackMapTableAttribute* 
CCodeAttribute::GetOrCreateStackMaps()
{
    // Return the StackMapTable attribute of this Code attribute, creating a new one
    // if such an attribute does not exist

    CStackMapTableAttribute* result = NULL;
	for(CJAttribs::iterator iter = m_Attribs.begin(); iter < m_Attribs.end(); iter++)
	{
		if(*(*iter)->GetName() == "StackMapTable")
        {
			result = (CStackMapTableAttribute*)*iter;
        }
	}

    if (result == NULL)
    {
        result = new CStackMapTableAttribute(m_pClassFile);
        m_Attribs.push_back(result);
    }
    return result;
}

//==============================================================================
// CExceptionsAttribute implementation

{}

//==============================================================================
// CStackMapTableAttribute implementation
//
CVerificationTypeInfo::CVerificationTypeInfo(u1 i_u1Tag)
: m_u1Tag(i_u1Tag)
{
}

CVerificationTypeInfo::~CVerificationTypeInfo()
{
}

void
CVerificationTypeInfo::Read(CJStream& i_jstream)
{
    // m_u1Tag is read by the CVerificationTypes container.
}

u2
CVerificationTypeInfo::Read(u1 *i_tbl)
{
    // m_u1Tag is read by the CVerificationTypes container.
	return 0;
}

void
CVerificationTypeInfo::Write(CJStream& i_jstream) const
{
    i_jstream << m_u1Tag;
}

u4
CVerificationTypeInfo::GetSize() const
{
    return sizeof(m_u1Tag);
}

//------------------------------------------------------------------------------
CVerificationTypes::~CVerificationTypes()
{
    for (iterator iter = begin(); iter != end(); iter++)
    {
        delete *iter;
    }
}

CVerificationTypes::CVerificationTypes(const CVerificationTypes &i_VerTypes)
{
    *this = i_VerTypes;
}

CVerificationTypes&
CVerificationTypes::operator =(const CVerificationTypes &i_VerTypes)
{
	for(iterator iter = begin(); iter != end(); iter++)
	{
		delete *iter;
	}
	if(!i_VerTypes.empty())
	{
		const_iterator iterIn;
		clear();
		for(iterIn = i_VerTypes.begin(); iterIn != i_VerTypes.end(); iterIn++)
		{
			push_back((*iterIn)->Clone());
		}
	}
	return *this;
}

void
CVerificationTypes::Read(CJStream& i_jstream, u2 i_u2EntriesToRead)
{
    CVerificationTypeInfo* pCurrent;
    
    resize(i_u2EntriesToRead);
    for(u2 u2Ind = 0; u2Ind < i_u2EntriesToRead; u2Ind++)
    {
        u1 u1Tag;
        i_jstream >> u1Tag;
        switch (u1Tag)
        {
        case ITEM_Top:
        case ITEM_Integer:
        case ITEM_Float:
        case ITEM_Double:
        case ITEM_Long:
        case ITEM_Null:
        case ITEM_UninitializedThis:
            pCurrent = new CVerificationTypeInfo(u1Tag);
            break;
        case ITEM_Object:
            pCurrent = new CVerificationTypeObjectInfo(u1Tag);
            break;
        case ITEM_Uninitialized:
            pCurrent = new CVerificationTypeUninitializedVariableInfo(u1Tag);
            break;
        default:
            throw CJClassFileException(CJClassFileException::X_INTERNAL_ERROR);
        }

        pCurrent->Read(i_jstream);
        (*this)[u2Ind] = pCurrent;
    }
}

void 
CVerificationTypes::Write(CJStream& i_jstream) const
{
    for (u2 u2Ind = 0; u2Ind < size(); u2Ind++)
    {
        (*this)[u2Ind]->Write(i_jstream);
    }
}

u4
CVerificationTypes::GetSize() const
{
    u4 u4Size = 0;
	for (const_iterator iter = begin(); iter != end(); iter++)
	{
		u4Size += (*iter)->GetSize();
	}
    return u4Size;
}

//------------------------------------------------------------------------------
CVerificationTypeObjectInfo::CVerificationTypeObjectInfo(u1 i_u1Tag)
: CVerificationTypeInfo(i_u1Tag)
{
}

CVerificationTypeObjectInfo::~CVerificationTypeObjectInfo()
{
}

void
CVerificationTypeObjectInfo::Read(CJStream& i_jstream)
{
    CVerificationTypeInfo::Read(i_jstream);
    i_jstream >> m_u2CpoolIndex;
}

void
CVerificationTypeObjectInfo::Write(CJStream& i_jstream) const
{
    CVerificationTypeInfo::Write(i_jstream);
    i_jstream << m_u2CpoolIndex;
}

u4
CVerificationTypeObjectInfo::GetSize() const
{
    u4 u4Size = CVerificationTypeInfo::GetSize()
        + sizeof(m_u2CpoolIndex);
    return u4Size;
}

//------------------------------------------------------------------------------
CVerificationTypeUninitializedVariableInfo::CVerificationTypeUninitializedVariableInfo(u1 i_u1Tag)
: CVerificationTypeInfo(i_u1Tag)
{
}

CVerificationTypeUninitializedVariableInfo::~CVerificationTypeUninitializedVariableInfo()
{
}

void
CVerificationTypeUninitializedVariableInfo::Read(CJStream& i_jstream)
{
    CVerificationTypeInfo::Read(i_jstream);
    i_jstream >> m_u2Offset;
}

void
CVerificationTypeUninitializedVariableInfo::Write(CJStream& i_jstream) const
{
    CVerificationTypeInfo::Write(i_jstream);
    i_jstream << m_u2Offset;
}

u4
CVerificationTypeUninitializedVariableInfo::GetSize() const
{
    u4 u4Size = CVerificationTypeInfo::GetSize()
        + sizeof(m_u2Offset);
    return u4Size;
}

//------------------------------------------------------------------------------
CStackMapFrameInfo::CStackMapFrameInfo(u1 i_u1FrameType)
: m_u1FrameType(i_u1FrameType)
{
    m_u2ByteCodeOffset = 0;
    m_u2OffsetDelta = 0;
}

CStackMapFrameInfo::~CStackMapFrameInfo()
{
}

void
CStackMapFrameInfo::Read(CJStream& i_jstream)
{
    // m_u1FrameType is read by the CStackMapTable container
}

void
CStackMapFrameInfo::Write(CJStream& i_jstream) const
{
    i_jstream << m_u1FrameType;
}

u4
CStackMapFrameInfo::GetSize() const
{
    return sizeof(m_u1FrameType);
}

void 
CStackMapFrameInfo::SetByteCodeOffset(u2 i_u2Offset) 
{ 
    m_u2ByteCodeOffset = i_u2Offset; 
}

void
CStackMapFrameInfo::AdjustOffsetDelta(int i_s2PrevFrameOffset)
{
    int newOffsetDelta = m_u2ByteCodeOffset - 1 - i_s2PrevFrameOffset;
    if (newOffsetDelta < 0)
    {
        // Frame order was changed. This is not supported
        throw CJClassFileException(CJClassFileException::X_INTERNAL_ERROR);
    }
    m_u2OffsetDelta = (u2)newOffsetDelta; // this is a safe cast since newDelta >= 1
}

CStackMapFrameInfo::CStackMapFrameInfo(const CStackMapFrameInfo &i_Other)
: m_u2ByteCodeOffset(i_Other.m_u2ByteCodeOffset), m_u2OffsetDelta(i_Other.m_u2OffsetDelta),
    m_u1FrameType(i_Other.m_u1FrameType)
{
}

//------------------------------------------------------------------------------
CStackMapSameFrameInfo::CStackMapSameFrameInfo(u1 i_u1FrameType, bool i_IsExtended)
: CStackMapFrameInfo(i_u1FrameType), m_IsExtended(i_IsExtended)
{
}

CStackMapSameFrameInfo::~CStackMapSameFrameInfo()
{
}

void
CStackMapSameFrameInfo::Read(CJStream& i_jstream)
{
    CStackMapFrameInfo::Read(i_jstream);
    if (m_IsExtended)
    {
        // SAME_FRAME_EXTENDED type
        i_jstream >> m_u2OffsetDelta;
    }
    else        
    {
        // SAME frame type. offset_delta is stored in the tag
        m_u2OffsetDelta = GetFrameType();
    }
}

void
CStackMapSameFrameInfo::Write(CJStream& i_jstream) const
{
    CStackMapFrameInfo::Write(i_jstream);
    if (m_IsExtended)
    {
        // SAME_FRAME_EXTENDED type
        i_jstream << m_u2OffsetDelta;
    }
}

u4
CStackMapSameFrameInfo::GetSize() const
{
    u4 u4Size = CStackMapFrameInfo::GetSize();
    if (m_IsExtended)
    {
        u4Size += sizeof(m_u2OffsetDelta);
    }
    return u4Size;
}

void
CStackMapSameFrameInfo::AdjustOffsetDelta(int i_s2PrevFrameOffset)
{
    CStackMapFrameInfo::AdjustOffsetDelta(i_s2PrevFrameOffset);
    if (m_u2OffsetDelta > 63)
    {
        // Frame type is SAME_FRAME_EXTENDED
        m_u1FrameType = SAME_FRAME_EXTENDED;
        m_IsExtended = true;
    }
    else
    {
        // Frame type is SAME_FRAME. offset_delta is stored in the tag
        m_u1FrameType = (u1)m_u2OffsetDelta; // this is safe since m_u2OffsetDelta <= 63
        m_IsExtended = false;
    }
}

CStackMapFrameInfo*
CStackMapSameFrameInfo::Clone() const
{
    return new CStackMapSameFrameInfo(*this);
}

//------------------------------------------------------------------------------
CStackMapChopFrameInfo::CStackMapChopFrameInfo(u1 i_u1FrameType)
: CStackMapFrameInfo(i_u1FrameType)
{
}

CStackMapChopFrameInfo::~CStackMapChopFrameInfo()
{
}

void
CStackMapChopFrameInfo::Read(CJStream& i_jstream)
{
    CStackMapFrameInfo::Read(i_jstream);
    i_jstream >> m_u2OffsetDelta;
}

void
CStackMapChopFrameInfo::Write(CJStream& i_jstream) const
{
    CStackMapFrameInfo::Write(i_jstream);
    i_jstream << m_u2OffsetDelta;
}

u4
CStackMapChopFrameInfo::GetSize() const
{
    u4 u4Size = CStackMapFrameInfo::GetSize()
        + sizeof(m_u2OffsetDelta);
    return u4Size;
}

CStackMapFrameInfo*
CStackMapChopFrameInfo::Clone() const
{
    return new CStackMapChopFrameInfo(*this);
}

//------------------------------------------------------------------------------
CStackMapSameLocals1StackItemFrameInfo::CStackMapSameLocals1StackItemFrameInfo(u1 i_u1FrameType, 
                                                                               bool i_IsExtended)
: CStackMapFrameInfo(i_u1FrameType), m_IsExtended(i_IsExtended)
{
}

CStackMapSameLocals1StackItemFrameInfo::~CStackMapSameLocals1StackItemFrameInfo()
{
}

void
CStackMapSameLocals1StackItemFrameInfo::Read(CJStream& i_jstream)
{
    CStackMapFrameInfo::Read(i_jstream);
    if (m_IsExtended)
    {
        // SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED type
        i_jstream >> m_u2OffsetDelta;
    }
    else        
    {
        // SAME_LOCALS_1_STACK_ITEM_FRAME frame type
        m_u2OffsetDelta = GetFrameType() - 64;
    }
    m_Stack.Read(i_jstream, 1); // must hold exactly one stack item
}

void
CStackMapSameLocals1StackItemFrameInfo::Write(CJStream& i_jstream) const
{
    CStackMapFrameInfo::Write(i_jstream);
    if (m_IsExtended)
    {
        // SAME_FRAME_EXTENDED type
        i_jstream << m_u2OffsetDelta;
    }
    m_Stack.Write(i_jstream);
}

u4
CStackMapSameLocals1StackItemFrameInfo::GetSize() const
{
    u4 u4Size = CStackMapFrameInfo::GetSize();
    if (m_IsExtended)
    {
        u4Size += sizeof(m_u2OffsetDelta);
    }
    u4Size += m_Stack.GetSize();
    return u4Size;
}

void
CStackMapSameLocals1StackItemFrameInfo::AdjustOffsetDelta(int i_s2PrevFrameOffset)
{
    CStackMapFrameInfo::AdjustOffsetDelta(i_s2PrevFrameOffset);
    if (m_u2OffsetDelta + 64 > 127)
    {
        // Frame type is SAME_LOCALS_1_STACK_FRAME_EXTENDED
        m_u1FrameType = SAME_LOCALS_1_STACK_ITEM_EXTENDED;
        m_IsExtended = true;
    }
    else
    {
        // Frame type is SAME_LOCALS_1_STACK_FRAME. offset_delta is stored in the tag
        m_u1FrameType = (u1)(m_u2OffsetDelta + 64); // this is safe since m_u2OffsetDelta <= 63
        m_IsExtended = false;
    }
}

CStackMapFrameInfo*
CStackMapSameLocals1StackItemFrameInfo::Clone() const
{
    return new CStackMapSameLocals1StackItemFrameInfo(*this);
}

CStackMapSameLocals1StackItemFrameInfo::CStackMapSameLocals1StackItemFrameInfo(const CStackMapSameLocals1StackItemFrameInfo &i_Other)
: CStackMapFrameInfo(i_Other), m_Stack(i_Other.m_Stack), m_IsExtended(i_Other.m_IsExtended)
{
}

//------------------------------------------------------------------------------
CStackMapAppendFrameInfo::CStackMapAppendFrameInfo(u1 i_u1FrameType)
: CStackMapFrameInfo(i_u1FrameType)
{
}

CStackMapAppendFrameInfo::~CStackMapAppendFrameInfo()
{
}

void
CStackMapAppendFrameInfo::Read(CJStream& i_jstream)
{
    CStackMapFrameInfo::Read(i_jstream);
    i_jstream >> m_u2OffsetDelta;
    m_Locals.Read(i_jstream, GetFrameType() - 251);
}

void
CStackMapAppendFrameInfo::Write(CJStream& i_jstream) const
{
    CStackMapFrameInfo::Write(i_jstream);
    i_jstream << m_u2OffsetDelta;
    m_Locals.Write(i_jstream);
}

u4
CStackMapAppendFrameInfo::GetSize() const
{
    u4 u4Size = CStackMapFrameInfo::GetSize()
        + sizeof(m_u2OffsetDelta)
        + m_Locals.GetSize();
    return u4Size;
}

CStackMapFrameInfo*
CStackMapAppendFrameInfo::Clone() const
{
    return new CStackMapAppendFrameInfo(*this);
}

CStackMapAppendFrameInfo::CStackMapAppendFrameInfo(const CStackMapAppendFrameInfo &i_Other)
: CStackMapFrameInfo(i_Other), m_Locals(i_Other.m_Locals)
{
}

//------------------------------------------------------------------------------
CStackMapFullFrameInfo::CStackMapFullFrameInfo(u1 i_u1FrameType)
: CStackMapFrameInfo(i_u1FrameType), m_u2NumberOfLocals(0), m_u2NumberOfStackItems(0)
{
}

CStackMapFullFrameInfo::~CStackMapFullFrameInfo()
{
}

void
CStackMapFullFrameInfo::Read(CJStream& i_jstream)
{
    CStackMapFrameInfo::Read(i_jstream);
    i_jstream >> m_u2OffsetDelta
              >> m_u2NumberOfLocals;
    m_Locals.Read(i_jstream, m_u2NumberOfLocals);
    i_jstream >> m_u2NumberOfStackItems;
    m_Stack.Read(i_jstream, m_u2NumberOfStackItems);
}

void
CStackMapFullFrameInfo::Write(CJStream& i_jstream) const
{
    CStackMapFrameInfo::Write(i_jstream);
    i_jstream << m_u2OffsetDelta
              << m_u2NumberOfLocals;
    m_Locals.Write(i_jstream);
    i_jstream << m_u2NumberOfStackItems;
    m_Stack.Write(i_jstream);
}

u4
CStackMapFullFrameInfo::GetSize() const
{
    u4 u4Size = CStackMapFrameInfo::GetSize()
        + sizeof(m_u2OffsetDelta)
        + sizeof(m_u2NumberOfLocals)
        + m_Locals.GetSize()
        + sizeof(m_u2NumberOfStackItems)
        + m_Stack.GetSize();
    return u4Size;
}

CStackMapFrameInfo*
CStackMapFullFrameInfo::Clone() const
{
    return new CStackMapFullFrameInfo(*this);
}

CStackMapFullFrameInfo::CStackMapFullFrameInfo(const CStackMapFullFrameInfo &i_Other)
: CStackMapFrameInfo(i_Other), m_Locals(i_Other.m_Locals), m_Stack(i_Other.m_Stack),
    m_u2NumberOfLocals(i_Other.m_u2NumberOfLocals), 
    m_u2NumberOfStackItems(i_Other.m_u2NumberOfStackItems)
{
}

//------------------------------------------------------------------------------
CStackMapTable::~CStackMapTable()
{
    for (iterator iter = begin(); iter != end(); iter++)
    {
        delete *iter;
    }
}

void
CStackMapTable::Read(CJStream& i_jstream)
{
    u2 u2Size;
    CStackMapFrameInfo* pCurrent;
    int s2PrevFrameOffset = -1;

    i_jstream >> u2Size;
    resize(u2Size);
    for(u2 u2Ind = 0; u2Ind < u2Size; u2Ind++)
    {
        u1 u1FrameType;
        i_jstream >> u1FrameType;
        if (u1FrameType >= 0 && u1FrameType <= 63)
        {
            pCurrent = new CStackMapSameFrameInfo(u1FrameType, false);
        }
        else if (u1FrameType >= 64 && u1FrameType <= 127)
        {
            pCurrent = new CStackMapSameLocals1StackItemFrameInfo(u1FrameType, false);
        }
        else if (u1FrameType == SAME_LOCALS_1_STACK_ITEM_EXTENDED)
        {
            pCurrent = new CStackMapSameLocals1StackItemFrameInfo(u1FrameType, true);
        }
        else if (u1FrameType >= 248 && u1FrameType <= 250)
        {
            pCurrent = new CStackMapChopFrameInfo(u1FrameType);
        }
        else if (u1FrameType == SAME_FRAME_EXTENDED)
        {
            pCurrent = new CStackMapSameFrameInfo(u1FrameType, true);
        }
        else if (u1FrameType >= 252 && u1FrameType <= 254)
        {
            pCurrent = new CStackMapAppendFrameInfo(u1FrameType);
        }
        else if (u1FrameType == FULL_FRAME)
        {
            pCurrent = new CStackMapFullFrameInfo(u1FrameType);
        }
        else
        {
            // Unknown frame type
            throw CJClassFileException(CJClassFileException::X_INTERNAL_ERROR);
        }
        
        pCurrent->Read(i_jstream);
        pCurrent->SetByteCodeOffset(s2PrevFrameOffset + 1 + pCurrent->m_u2OffsetDelta);
        (*this)[u2Ind] = pCurrent;
        s2PrevFrameOffset = pCurrent->GetByteCodeOffset();
    }
}

void
CStackMapTable::AdjustOffsetDeltas()
{
    // Recalculate offset deltas for all frames. This function must be called before
    // writing the Stack Map Table to the class file or calculating its size
    CStackMapFrameInfo* pCurrent;
    int s2PrevFrameOffset = -1;

    for (u2 u2Ind = 0; u2Ind < size(); u2Ind++)
    {
        pCurrent = (*this)[u2Ind];
        pCurrent->AdjustOffsetDelta(s2PrevFrameOffset);
        s2PrevFrameOffset = pCurrent->GetByteCodeOffset();
    }
}

CStackMapFrameInfo*
CStackMapTable::GetFrameAtOffset(u2 i_u2Offset)
{
    bool found = false;
    iterator it = begin();
    for (; it != end(); ++it)
    {
        if ((*it)->GetByteCodeOffset() == i_u2Offset)
        {
            found = true;
            break;
        }
    }

    if (found)
    {
        return (*it);
    }
    else
    {
        return NULL;
    }
}

void
CStackMapTable::Write(CJStream& i_jstream) const
{
    i_jstream << (u2)size(); // the number_of_entries field

    CStackMapFrameInfo* pCurrent;
    int s2PrevFrameOffset = -1;

    for (u2 u2Ind = 0; u2Ind < size(); u2Ind++)
    {
        pCurrent = (*this)[u2Ind];
        pCurrent->Write(i_jstream);
        s2PrevFrameOffset = pCurrent->GetByteCodeOffset();
    }
}

u4
CStackMapTable::GetSize() const
{
    u4 u4Size = sizeof(u2); // the number_of_entries field
    for (const_iterator iter = begin(); iter != end(); iter++)
    {
        u4Size += (*iter)->GetSize();
    }
    return u4Size;
}

CStackMapTable& 
CStackMapTable::operator = (const CStackMapTable& i_StackMaps)
{
	for(iterator iter = begin(); iter != end(); iter++)
	{
		delete *iter;
	}
	if(!i_StackMaps.empty())
	{
		const_iterator iterIn;
		clear();
		for(iterIn = i_StackMaps.begin(); iterIn != i_StackMaps.end(); iterIn++)
		{
			push_back((*iterIn)->Clone());
		}
	}
	return *this;
}

//------------------------------------------------------------------------------
CStackMapTableAttribute::CStackMapTableAttribute(CJClassFile* i_pClassFile)
: CAttributeInfo(i_pClassFile)
{
    u2 u2NameInd = i_pClassFile->GetConstPool()->Add(new CCPUtf8Info("StackMapTable"));
    m_u2NameInd = u2NameInd;
    m_StackMapTable.clear();
}

CStackMapTableAttribute::~CStackMapTableAttribute()
{
}

void
CStackMapTableAttribute::Read(CJStream& i_jstream)
{
	CAttributeInfo::Read(i_jstream);
    m_StackMapTable.Read(i_jstream);
}

void
CStackMapTableAttribute::Write(CJStream& i_jstream) const
{
	const u4 u4Length = GetLength() - CAttributeInfo::SizeOf();
	i_jstream	<<	m_u2NameInd
				<<	u4Length;
    m_StackMapTable.Write(i_jstream);
}

u4
CStackMapTableAttribute::GetSize() const
{
    return GetLength();
}

u4
CStackMapTableAttribute::GetLength() const
{
    u4 u4Length = CAttributeInfo::SizeOf()
        + m_StackMapTable.GetSize();
    return u4Length;
}

void
CStackMapTableAttribute::RereadFromBuffer(u1 *i_u1Tbl) 
{
	u2 u2skip = 0;
	u4 u4attributeLenght = 0;
	
	if (i_u1Tbl == NULL) return;

	u2skip = i_u1Tbl[0];
	u2skip <<= 8;
	u2skip |= i_u1Tbl[1];

	u4attributeLenght = i_u1Tbl[2];
	u4attributeLenght <<= 8;
	u4attributeLenght |= i_u1Tbl[3];
	u4attributeLenght <<= 8;
	u4attributeLenght |= i_u1Tbl[4];
	u4attributeLenght <<= 8;
	u4attributeLenght |= i_u1Tbl[5];
	m_u4Length = u4attributeLenght;
	CJMemStream memstream;
	memstream.Open(&i_u1Tbl[2], u4attributeLenght 
		+ sizeof(u2) /*part of attribute header (its length)*/
		+ 2 /*workaround for end buffer checking*/);
	CJStream mem_jstream(&memstream);
	//GetStackMapTable().RereadFromBuffer(&i_u1Tbl[6]);
	this->Read(mem_jstream);
}
//==============================================================================
// CJClassFile implementation
//


	{
		throw CJClassFileException(CJClassFileException::X_BAD_MAGIC);
	}
	i_jstream	>>	m_u2MajorVersion;
	if(CJClassFile::MajorVersion < m_u2MajorVersion)
	{
		throw CJClassFileException(CJClassFileException::X_BAD_VERSION);
	}
	i_jstream	>>	m_u2MinorVersion;
	i_jstream	>>	m_u2MajorVersion;
	m_pConstPool->Read(i_jstream);
	i_jstream	>>	m_u2AccessFlags
				>>	m_u2ThisClass

CJClassFile::Write(CJStream& i_jstream) const
{
	i_jstream	<<	m_u4Magic
				<<	m_u2MinorVersion
				<<	m_u2MajorVersion;
	m_pConstPool->Write(i_jstream);
	i_jstream	<<	m_u2AccessFlags
				<<	m_u2ThisClass

Lines 82-87 class CExceptionsAttribute; Link Here

(-)JClass/JClassFile.h (-1 / +289 lines)
82	class CLineNumberTableAttribute;	82	class CLineNumberTableAttribute;
83	class CLocalVariableTableAttribute;	83	class CLocalVariableTableAttribute;
84	class CLocalVariableTypeTableAttribute;	84	class CLocalVariableTypeTableAttribute;
		85	class CStackMapTableAttribute;
85		86
86	//------------------------------------------------------------------------------	87	//------------------------------------------------------------------------------
87	// Container classes	88	// Container classes
Lines 672-677 public: Link Here
672	CLineNumberTableAttribute* GetLineNumbers();	673	CLineNumberTableAttribute* GetLineNumbers();
673	CLocalVariableTableAttribute* GetLocalVariables();	674	CLocalVariableTableAttribute* GetLocalVariables();
674	CLocalVariableTypeTableAttribute* GetLocalVariableTypes();	675	CLocalVariableTypeTableAttribute* GetLocalVariableTypes();
		676	CStackMapTableAttribute* GetStackMaps();
		677	CStackMapTableAttribute* GetOrCreateStackMaps();
		678
675		679
676	protected:	680	protected:
677	u2 m_u2MaxStack;	681	u2 m_u2MaxStack;
Lines 899-904 private: Link Here
899	};	903	};
900		904
901	//------------------------------------------------------------------------------	905	//------------------------------------------------------------------------------
		906	// Verification Type Information (new in Java 6)
		907	//
		908	// Represents the following verification types: Top, Integer, Float, Double, Long, Null,
		909	// UninitializedThis
		910	//
		911	class CVerificationTypeInfo
		912	{
		913	public:
		914	CVerificationTypeInfo(u1 i_u1Tag);
		915	~CVerificationTypeInfo();
		916	virtual void Read(CJStream& i_jstream);
		917	virtual u2 Read(u1* i_tbl);
		918	virtual void Write(CJStream& i_jstream) const;
		919	virtual u4 GetSize() const;
		920	virtual CVerificationTypeInfo* Clone() const
		921	{
		922	return new CVerificationTypeInfo(*this);
		923	}
		924
		925	u1 GetTag() { return m_u1Tag; }
		926
		927	private:
		928	u1 m_u1Tag;
		929	};
		930
		931	//------------------------------------------------------------------------------
		932	// Verification Type Information Vector
		933	//
		934	class CVerificationTypes : public vector<CVerificationTypeInfo*>
		935	{
		936	public:
		937	CVerificationTypes() { clear(); }
		938	CVerificationTypes(const CVerificationTypes &i_VerTypes);
		939	~CVerificationTypes();
		940
		941	CVerificationTypes& operator = (const CVerificationTypes &i_VerTypes);
		942
		943	virtual void Read(CJStream& i_jstream, u2 i_u2EntriesToRead);
		944	virtual void Write(CJStream& i_jstream) const;
		945	virtual u4 GetSize() const;
		946
		947	private:
		948	};
		949
		950	//------------------------------------------------------------------------------
		951	// Verification Type Information: Object (new in Java 6)
		952	//
		953	class CVerificationTypeObjectInfo : public CVerificationTypeInfo
		954	{
		955	public:
		956	CVerificationTypeObjectInfo(u1 i_u1Tag);
		957	~CVerificationTypeObjectInfo();
		958	virtual void Read(CJStream& i_jstream);
		959	virtual void Write(CJStream& i_jstream) const;
		960	virtual u4 GetSize() const;
		961	virtual CVerificationTypeInfo* Clone() const
		962	{
		963	return new CVerificationTypeObjectInfo(*this);
		964	}
		965
		966	u2 GetCpoolIndex() { return m_u2CpoolIndex; }
		967	void SetCpoolIndex(u2 i_u2CpoolIndex) { m_u2CpoolIndex = i_u2CpoolIndex; }
		968
		969	private:
970	u2 m_u2CpoolIndex;
971	};
972
973	//------------------------------------------------------------------------------
974	// Verification Type Information: Uninitialized Variable (new in Java 6)
975	//
976	class CVerificationTypeUninitializedVariableInfo : public CVerificationTypeInfo
977	{
978	public:
979	CVerificationTypeUninitializedVariableInfo(u1 i_u1Tag);
980	~CVerificationTypeUninitializedVariableInfo();
981	virtual void Read(CJStream& i_jstream);
982	virtual void Write(CJStream& i_jstream) const;
983	virtual u4 GetSize() const;
984	virtual CVerificationTypeInfo* Clone() const
985	{
986	return new CVerificationTypeUninitializedVariableInfo(*this);
987	}
988
989	u2 GetOffset() { return m_u2Offset; }
990	void SetOffset(u2 i_u2Offset) { m_u2Offset = i_u2Offset; }
991
992	private:
993	u2 m_u2Offset;
994	};
995
996
997	//------------------------------------------------------------------------------
998	// Stack Map Frame Information (new in Java 6)
999	//
1000	class CStackMapFrameInfo
1001	{
1002	friend class CStackMapTable;
1003	public:
1004	CStackMapFrameInfo(u1 i_u1FrameType);
1005	CStackMapFrameInfo(const CStackMapFrameInfo &i_Other);
1006	~CStackMapFrameInfo();
1007
1008	virtual void Read(CJStream& i_jstream);
1009	virtual void Write(CJStream& i_jstream) const;
1010	virtual u4 GetSize() const;
1011	virtual CStackMapFrameInfo* Clone() const = 0;
1012
1013	u1 GetFrameType() const { return m_u1FrameType; }
1014	u2 GetByteCodeOffset() { return m_u2ByteCodeOffset; }
1015	void SetByteCodeOffset(u2 i_u2Offset);
1016
1017	protected:
1018	virtual void AdjustOffsetDelta(int i_s2PrevFrameOffset);
1019
1020	u2 m_u2ByteCodeOffset;
1021	u2 m_u2OffsetDelta;
1022	u1 m_u1FrameType;
1023	};
1024
1025	//------------------------------------------------------------------------------
1026	// Stack Map Frame Information: same_frame and same_frame_extended (new in Java 6)
1027	//
1028	class CStackMapSameFrameInfo : public CStackMapFrameInfo
1029	{
1030	friend class CStackMapTable;
1031	public:
1032	CStackMapSameFrameInfo(u1 i_u1FrameType, bool i_IsExtended);
1033	~CStackMapSameFrameInfo();
1034
1035	virtual void Read(CJStream& i_jstream);
1036	virtual void Write(CJStream& i_jstream) const;
1037	virtual u4 GetSize() const;
1038	virtual CStackMapFrameInfo* Clone() const;
1039
1040	protected:
1041	virtual void AdjustOffsetDelta(int i_s2PrevFrameOffset);
1042
1043	private:
1044	bool m_IsExtended;
1045	};
1046
1047	//------------------------------------------------------------------------------
1048	// Stack Map Frame Information: chop_frame (new in Java 6)
1049	//
1050	class CStackMapChopFrameInfo : public CStackMapFrameInfo
1051	{
1052	public:
1053	CStackMapChopFrameInfo(u1 i_u1FrameType);
1054	~CStackMapChopFrameInfo();
1055
1056	virtual void Read(CJStream& i_jstream);
1057	virtual void Write(CJStream& i_jstream) const;
1058	virtual u4 GetSize() const;
1059	virtual CStackMapFrameInfo* Clone() const;
1060
1061	private:
1062	};
1063
1064	//------------------------------------------------------------------------------
1065	// Stack Map Frame Information: same_locals_1_stack_item_frame and
1066	// same_locals_1_stack_item_frame_extended (new in Java 6)
1067	//
1068	class CStackMapSameLocals1StackItemFrameInfo : public CStackMapFrameInfo
1069	{
1070	friend class CStackMapTable;
1071	public:
1072	CStackMapSameLocals1StackItemFrameInfo(u1 i_u1FrameType, bool i_IsExtended);
1073	CStackMapSameLocals1StackItemFrameInfo(const CStackMapSameLocals1StackItemFrameInfo &i_Other);
1074	~CStackMapSameLocals1StackItemFrameInfo();
1075
1076	virtual void Read(CJStream& i_jstream);
1077	virtual void Write(CJStream& i_jstream) const;
1078	virtual u4 GetSize() const;
1079	virtual CStackMapFrameInfo* Clone() const;
1080
1081	CVerificationTypes& GetStack() { return m_Stack; }
1082
1083	protected:
1084	virtual void AdjustOffsetDelta(int i_s2PrevFrameOffset);
1085
1086	private:
1087	CStackMapSameLocals1StackItemFrameInfo& operator = (CStackMapSameLocals1StackItemFrameInfo &i_Other);
1088
1089	CVerificationTypes m_Stack; // A vector with 1 entry
1090	bool m_IsExtended;
1091	};
1092
1093	//------------------------------------------------------------------------------
1094	// Stack Map Frame Information: append_frame (new in Java 6)
1095	//
1096	class CStackMapAppendFrameInfo : public CStackMapFrameInfo
1097	{
1098	public:
1099	CStackMapAppendFrameInfo(u1 i_u1FrameType);
1100	CStackMapAppendFrameInfo(const CStackMapAppendFrameInfo &i_Other);
1101	~CStackMapAppendFrameInfo();
1102
1103	virtual void Read(CJStream& i_jstream);
1104	virtual void Write(CJStream& i_jstream) const;
1105	virtual u4 GetSize() const;
1106	virtual CStackMapFrameInfo* Clone() const;
1107
1108	CVerificationTypes& GetLocals() { return m_Locals; }
1109
1110	private:
1111	CStackMapAppendFrameInfo& operator = (const CStackMapAppendFrameInfo &i_Other);
1112
1113	CVerificationTypes m_Locals;
1114	};
1115
1116	//------------------------------------------------------------------------------
1117	// Stack Map Frame Information: full_frame (new in Java 6)
1118	//
1119	class CStackMapFullFrameInfo : public CStackMapFrameInfo
1120	{
1121	public:
1122	CStackMapFullFrameInfo(u1 i_u1FrameType);
1123	CStackMapFullFrameInfo(const CStackMapFullFrameInfo &i_Other);
1124	~CStackMapFullFrameInfo();
1125
1126	virtual void Read(CJStream& i_jstream);
1127	virtual void Write(CJStream& i_jstream) const;
1128	virtual u4 GetSize() const;
1129	virtual CStackMapFrameInfo* Clone() const;
1130
1131	CVerificationTypes& GetLocals() { return m_Locals; }
1132	CVerificationTypes& GetStack() { return m_Stack; }
1133
1134	private:
1135	CStackMapFullFrameInfo& operator = (const CStackMapFullFrameInfo &i_Other);
1136
1137	u2 m_u2NumberOfLocals;
1138	CVerificationTypes m_Locals;
1139	u2 m_u2NumberOfStackItems;
1140	CVerificationTypes m_Stack;
1141	};
1142
1143
1144	//------------------------------------------------------------------------------
1145	// Stack Map Table (new in Java 6)
1146	//
1147	class CStackMapTable : public vector<CStackMapFrameInfo*>
1148	{
1149	public:
1150	CStackMapTable() { clear(); }
1151	~CStackMapTable();
1152	virtual void Read(CJStream& i_jstream);
1153	virtual void Write(CJStream& i_jstream) const;
1154	virtual u4 GetSize() const;
1155
1156	void AdjustOffsetDeltas();
1157	CStackMapFrameInfo* GetFrameAtOffset(u2 i_u2Offset);
1158
1159	CStackMapTable& operator = (const CStackMapTable& i_StackMaps);
1160	};
1161
1162	//------------------------------------------------------------------------------
1163	// Stack Map Table Attribute (new in Java 6 - [4.8.4])
1164	//
1165	class CStackMapTableAttribute : public CAttributeInfo
1166	{
1167	friend class CStackMapTable;
1168	public:
1169	CStackMapTableAttribute(CJClassFile* i_pClassFile);
1170	~CStackMapTableAttribute();
1171	virtual void Read(CJStream& i_jstream);
1172	virtual void Write(CJStream& i_jstream) const;
1173	virtual u4 GetSize() const;
1174	virtual u4 GetLength() const;
1175
1176	CStackMapTable& GetStackMapTable() { return m_StackMapTable; }
1177	void SetStackMapTable(const CStackMapTable& i_stackmap) {m_StackMapTable = i_stackmap;}
1178	void RereadFromBuffer(u1 *i_u1Tbl);
1179
1180	private:
1181	CStackMapTable m_StackMapTable;
1182
1183	// Disable assignment operator.
1184	// To enable, implement these functions as public
1185	CStackMapTableAttribute& operator = (const CStackMapTableAttribute& i_other) {}
1186	};
1187
1188	//------------------------------------------------------------------------------
902	// Interface information	1189	// Interface information
903	//	1190	//
904	class CInterfaceInfo	1191	class CInterfaceInfo
Lines 999-1004 public: Link Here
999	virtual u4 GetSize() const;	1286	virtual u4 GetSize() const;
1000		1287
1001	u2 GetAccessFlags() {return m_u2AccessFlags;}	1288	u2 GetAccessFlags() {return m_u2AccessFlags;}
		1289	void SetAccessFlags(u2 i_u2AccessFlags) {m_u2AccessFlags = i_u2AccessFlags;}
1002	u2 GetNameInd() const {return m_u2NameInd;}	1290	u2 GetNameInd() const {return m_u2NameInd;}
1003	u2 GetDescriptorInd() const {return m_u2DescriptorInd;}	1291	u2 GetDescriptorInd() const {return m_u2DescriptorInd;}
1004	CJAttribs& GetAttribs() {return m_Attribs;}	1292	CJAttribs& GetAttribs() {return m_Attribs;}
Lines 1070-1076 public: Link Here
1070	class CJClassFile	1358	class CJClassFile
1071	{	1359	{
1072	public:	1360	public:
1073	enum {MajorVersion = 3, MinorVersion = 46}; // TODO: comment on version	1361	enum {MajorVersion = 46, MinorVersion = 3}; // J2SE 1.2
1074	CJClassFile();	1362	CJClassFile();
1075	virtual ~CJClassFile();	1363	virtual ~CJClassFile();
1076		1364

Return to bug 148629

Lines 22-35 Link Here

(-)Common/CommonDef.h (-9 / +14 lines)
22	// For this header to work, you need to define one of these ARCH symbols:	22	// For this header to work, you need to define one of these ARCH symbols:
23	//	23	//
24	// WIN32 (means x86)	24	// WIN32 (means x86)
		25	// IA32_ARCH (means x86)
25	// IPF_ARCH (means Itanium Processor Family)	26	// IPF_ARCH (means Itanium Processor Family)
26	// EM64T_ARCH (means Intel/AMD 64-bit processors)	27	// EM64T_ARCH (means Intel/AMD 64-bit processors)
27	// IA32_ARCH (means x86)
28	// SPARC_ARCH	28	// SPARC_ARCH
29	// HPPA_ARCH	29	// HPPA_ARCH
30	// ALPHA_ARCH	30	// ALPHA_ARCH
31	// PPC_ARCH	31	// PPC_ARCH
32	// LINUX_PPC_ARCH (LINUX PPC64)
33	// OS390_ARCH (means zSeries)	32	// OS390_ARCH (means zSeries)
34	// AS400_ARCH (means iSeries)	33	// AS400_ARCH (means iSeries)
35	//	34	//
Lines 72-81 Link Here
72	// This brings _WINDOWS_ into scope. Use _WINDOWS_ to wrap Windows code.	71	// This brings _WINDOWS_ into scope. Use _WINDOWS_ to wrap Windows code.
73	# include <windows.h> /* for lots o' stuff, but esp. _WINDOWS_ */	72	# include <windows.h> /* for lots o' stuff, but esp. _WINDOWS_ */
74	# include <malloc.h> /* for alloca */	73	# include <malloc.h> /* for alloca */
75	#elif defined(IPF_ARCH) \|\| (EM64T_ARCH) \|\| (LINUX_PPC_ARCH)	74	#elif defined(IPF_ARCH) \|\| (EM64T_ARCH)
76	# include <stdint.h> /* for int64_t and uint64_t */	75	# include <stdint.h> /* for int64_t and uint64_t */
77	#endif	76	#endif
78		77
		78	/* On LinuxPPC64 we need this to get int64_t */
		79	#if defined(PPC_ARCH)
		80	# include </usr/include/sys/types.h>
		81	#endif
79	/* Only on OS400, we need this to get malloc/free */	82	/* Only on OS400, we need this to get malloc/free */
80	#ifdef OS400	83	#ifdef OS400
81	#include <stdlib.h>	84	#include <stdlib.h>
Lines 113-127 typedef unsigned short WORD, *PWORD; Link Here
113	typedef signed long long int int64_t;	116	typedef signed long long int int64_t;
114	typedef unsigned long long int uint64_t;	117	typedef unsigned long long int uint64_t;
115	#else	118	#else
116	#if defined(_WINDOWS_)	119	# if defined(_WINDOWS_)
117	typedef __int64 int64_t;	120	typedef __int64 int64_t;
118	typedef unsigned __int64 uint64_t;	121	typedef unsigned __int64 uint64_t;
119	#else	122	#elif defined(PPC_ARCH)
120	# if !defined(IPF_ARCH) && !defined(EM64T_ARCH) && !defined(LINUX_PPC_ARCH) // Already being declared in stdint.h
121	typedef long long int64_t;
122	typedef unsigned long long uint64_t;	123	typedef unsigned long long uint64_t;
		124	# else
		125	# if !defined(IPF_ARCH) && !defined(EM64T_ARCH)
		126	typedef long long int64_t;
		127	typedef unsigned long long uint64_t;
123	# endif	128	# endif
124	#endif	129	# endif
125	#endif	130	#endif
126		131
127	//------------------------------------------------------------------------------	132	//------------------------------------------------------------------------------
Lines 197-203 typedef unsigned short WORD, *PWORD; Link Here
197	///////	202	///////
198	#if defined(WIN32) \|\| defined(IA32_ARCH) \|\| defined(IPF_ARCH) \|\| defined(EM64T_ARCH) \|\| defined(ALPHA_ARCH)	203	#if defined(WIN32) \|\| defined(IA32_ARCH) \|\| defined(IPF_ARCH) \|\| defined(EM64T_ARCH) \|\| defined(ALPHA_ARCH)
199	# define BIG_ENDIAN_HW	204	# define BIG_ENDIAN_HW
200	#elif defined(SPARC_ARCH) \|\| defined(HPPA_ARCH) \|\| defined(PPC_ARCH) \|\| defined(AS400_ARCH) \|\| defined(OS390_ARCH) \|\| defined(LINUX_PPC_ARCH)	205	#elif defined(SPARC_ARCH) \|\| defined(HPPA_ARCH) \|\| defined(PPC_ARCH) \|\| defined(AS400_ARCH) \|\| defined(OS390_ARCH)
201	# define LITTLE_ENDIAN_HW	206	# define LITTLE_ENDIAN_HW
202	#else	207	#else
203	# error "Platform-specific configuration required"	208	# error "Platform-specific configuration required"

Lines 50-55 Link Here

(-)Common/JavaDef.h (-1 / +16 lines)
50	#define CONSTANT_InterfaceMethodref 11 // Interface method refernce constant	50	#define CONSTANT_InterfaceMethodref 11 // Interface method refernce constant
51	#define CONSTANT_NameAndType 12 // Name and type constant	51	#define CONSTANT_NameAndType 12 // Name and type constant
52		52
		53	#define CONSTANT_Unknown 0
53	// Array types	54	// Array types
54	#define T_BOOLEAN 4 // bool	55	#define T_BOOLEAN 4 // bool
55	#define T_CHAR 5 // char	56	#define T_CHAR 5 // char
Lines 60-66 Link Here
60	#define T_INT 10 // int	61	#define T_INT 10 // int
61	#define T_LONG 11 // long	62	#define T_LONG 11 // long
62		63
63	#define CONSTANT_Unknown 0	64	// stack map frame types (new in Java 6.0)
		65	#define SAME_LOCALS_1_STACK_ITEM_EXTENDED 247
		66	#define SAME_FRAME_EXTENDED 251
		67	#define FULL_FRAME 255
		68
		69	// verification types (new in Java 6.0)
		70	#define ITEM_Top 0
		71	#define ITEM_Integer 1
		72	#define ITEM_Float 2
		73	#define ITEM_Double 3
		74	#define ITEM_Long 4
		75	#define ITEM_Null 5
		76	#define ITEM_UninitializedThis 6
		77	#define ITEM_Object 7
		78	#define ITEM_Uninitialized 8
64		79
65	// ToDo: other Java specific definitions	80	// ToDo: other Java specific definitions
66	typedef unsigned char u1; // 1 byte	81	typedef unsigned char u1; // 1 byte

Lines 80-86 CJClassBuilder::GetThisClassName() Link Here

(-)JClass/JClassBuilder.cpp (-1 / +19 lines)
80	string	80	string
81	CJClassBuilder::GetSuperClassName()	81	CJClassBuilder::GetSuperClassName()
82	{	82	{
83	CCPUtf8Info* pcpUtf8 = (CCPUtf8Info)((m_pConstPool)[GetSuperClass()]);	83	CCPClassInfo* pccpClassInfo = (CCPClassInfo)((m_pConstPool)[GetSuperClass()]);
		84	CCPUtf8Info* pcpUtf8 = (CCPUtf8Info)((m_pConstPool)[pccpClassInfo->GetClassInd()]);
84	string strSuperClass = (string)*pcpUtf8;	85	string strSuperClass = (string)*pcpUtf8;
85	return strSuperClass;	86	return strSuperClass;
86	}	87	}
Lines 245-250 CJClassBuilder::FindClass(CSTR i_szName) Link Here
245	CConstPool::iterator itr = m_pConstPool->begin();	246	CConstPool::iterator itr = m_pConstPool->begin();
246	while(itr != m_pConstPool->end())	247	while(itr != m_pConstPool->end())
247	{	248	{
		249	if (*itr == NULL) return NULL;
248	if((*itr)->GetTag() == CONSTANT_Class)	250	if((*itr)->GetTag() == CONSTANT_Class)
249	{	251	{
250	CCPClassInfo* pcpci = (CCPClassInfo)itr;	252	CCPClassInfo* pcpci = (CCPClassInfo)itr;
Lines 278-283 CJClassBuilder::CreateStringConstant(CST Link Here
278	}	280	}
279		281
280	//------------------------------------------------------------------------------	282	//------------------------------------------------------------------------------
		283	// CreateClassConstant
		284	// In:
		285	// i_szClassName - class name
		286	// Returns:
		287	// CCPClassInfo* - pointer to the class infoin the constant pool
		288	//
		289	CCPClassInfo*
		290	CJClassBuilder::CreateClassConstant(CSTR i_szClassName)
		291	{
		292	u2 u2ClassName = m_pConstPool->Add(new CCPUtf8Info(i_szClassName));
		293	u2 u2ClassRef = m_pConstPool->Add(new CCPClassInfo(u2ClassName));
		294	CCPClassInfo* pcpClass = (CCPClassInfo)((m_pConstPool)[u2ClassRef]);
		295	return pcpClass;
		296	}
		297
		298	//------------------------------------------------------------------------------
281	// CreateIntegerConstant	299	// CreateIntegerConstant
282	// In:	300	// In:
283	// i_int - Integer value to add	301	// i_int - Integer value to add