ECode CStructInfo::InitStatic(
/* [in] */ CClsModule* clsModule,
/* [in] */ StructDirEntry* structDirEntry)
{
mClsModule = clsModule;
Int32 base = mClsModule->mBase;
mStructDirEntry = structDirEntry;
mName = adjustNameAddr(base, mStructDirEntry->mName);
StructDescriptor* desc = adjustStructDescAddr(base, structDirEntry->mDesc);
StructElement* elem = NULL;
ECode ec = NOERROR;
mFieldTypeInfos = ArrayOf<IDataTypeInfo*>::Alloc(desc->mElementCount);
if (!mFieldTypeInfos) {
ec = E_OUT_OF_MEMORY;
goto EExit;
}
mFieldNames = ArrayOf<String>::Alloc(desc->mElementCount);
if (!mFieldNames) {
ec = E_OUT_OF_MEMORY;
goto EExit;
}
for (Int32 i = 0; i < desc->mElementCount; i++) {
elem = getStructElementAddr(base, desc->mElements, i);
(*mFieldNames)[i] = adjustNameAddr(base, elem->mName);
AutoPtr<IDataTypeInfo> dataTypeInfo;
ec = g_objInfoList.AcquireDataTypeInfo(mClsModule,
&elem->mType, (IDataTypeInfo**)&dataTypeInfo, TRUE);
if (FAILED(ec)) goto EExit;
mFieldTypeInfos->Set(i, dataTypeInfo);
}
ec = InitFieldElement();
if (FAILED(ec)) goto EExit;
ec = InitFieldInfos();
if (FAILED(ec)) goto EExit;
return NOERROR;
EExit:
mFieldNames = NULL;
mFieldTypeInfos = NULL;
return ec;
}
ECode CInterfaceInfo::CreateIFList()
{
if (mIFList) {
return NOERROR;
}
UInt32* indexList = (UInt32 *)alloca(
mClsMod->mInterfaceCount * sizeof(UInt32));
if (indexList == NULL) {
return E_OUT_OF_MEMORY;
}
Int32 i, j = 0;
mIFCount = 0;
UInt32 index = mIndex;
InterfaceDirEntry* ifDir = NULL;
while (index != 0) {
indexList[mIFCount++] = index;
ifDir = getInterfaceDirAddr(mBase, mClsMod->mInterfaceDirs, index);
index = adjustInterfaceDescAddr(mBase, ifDir->mDesc)->mParentIndex;
}
indexList[mIFCount] = 0;
mIFCount++;
UInt32 beginNo = METHOD_START_NO;
mIFList = new IFIndexEntry[mIFCount];
if (mIFList == NULL) {
return E_OUT_OF_MEMORY;
}
for (i = mIFCount - 1, j = 0; i >= 0; i--, j++) {
index = indexList[i];
mIFList[j].mIndex = index;
mIFList[j].mBeginNo = beginNo;
ifDir = getInterfaceDirAddr(mBase, mClsMod->mInterfaceDirs, index);
mIFList[j].mName = adjustNameAddr(mBase, ifDir->mName);
mIFList[j].mNameSpace = adjustNameAddr(mBase, ifDir->mNameSpace);
mIFList[j].mDesc = adjustInterfaceDescAddr(mBase, ifDir->mDesc);
beginNo += mIFList[j].mDesc->mMethodCount;
}
mMethodCount = 0;
for (i = 0; i < (int)mIFCount; i++) {
mMethodCount += mIFList[i].mDesc->mMethodCount;
}
return NOERROR;
}
ECode CClassInfo::AcquireConstructorList()
{
if (!(mDesc->dwAttribs & ClassAttrib_hasctor)) {
return NOERROR;
}
ECode ec = NOERROR;
g_objInfoList.LockHashTable(EntryType_Class);
if (!mCtorClassInfo) {
AutoPtr<IModuleInfo> pModuleInfo;
ec = mClsModule->GetModuleInfo((IModuleInfo**)&pModuleInfo);
if (FAILED(ec)) {
g_objInfoList.UnlockHashTable(EntryType_Class);
return ec;
}
String clsName;
clsName = adjustNameAddr(mBase, mClassDirEntry->mName);
clsName += "ClassObject";
ec = pModuleInfo->GetClassInfo(clsName, (IClassInfo**)&mCtorClassInfo);
}
g_objInfoList.UnlockHashTable(EntryType_Class);
if (FAILED(ec)) return ec;
mCtorList = NULL;
return mCtorClassInfo->AcquireSpecialMethodList(
EntryType_Constructor, (CEntryList**)&mCtorList);
}
ECode CClsModule::GetModuleInfo(
/* [out] */ IModuleInfo** moduleInfo)
{
if (!moduleInfo) {
return E_INVALID_ARGUMENT;
}
return _CReflector_AcquireModuleInfo(
String(adjustNameAddr(mBase, mClsMod->mUunm)), moduleInfo);
}
ECode CClassInfo::GetNamespace(
/* [out] */ String* ns)
{
if (ns == NULL) {
return E_INVALID_ARGUMENT;
}
*ns = adjustNameAddr(mBase, mClassDirEntry->mNameSpace);
return NOERROR;
}
ECode CInterfaceInfo::GetName(
/* [out] */ String* name)
{
if (name == NULL) {
return E_INVALID_ARGUMENT;
}
*name = adjustNameAddr(mBase, mInterfaceDirEntry->mName);
return NOERROR;
}
Boolean IsSysAlaisType(
/* [in] */ const CClsModule* clsModule,
/* [in] */ UInt32 index)
{
Int32 base = clsModule->mBase;
CLSModule* module = clsModule->mClsMod;
AliasDirEntry* aliasDir = getAliasDirAddr(base, module->mAliasDirs, index);
char* nameSpace = adjustNameAddr(base, aliasDir->mNameSpace);
return (nameSpace) && !strcmp(nameSpace, "systypes");
}
ECode CClassInfo::GetId(
/* [out] */ ClassID* clsid)
{
if (!clsid) {
return E_INVALID_ARGUMENT;
}
clsid->clsid = mDesc->clsid;
strcpy(clsid->pUunm, adjustNameAddr(mBase, mClsMod->mUunm));
return NOERROR;
}
CClassInfo::CClassInfo(
/* [in] */ CClsModule* clsModule,
/* [in] */ ClassDirEntry* clsDirEntry)
{
mClsModule = clsModule;
mClsMod = mClsModule->mClsMod;
mClassDirEntry = clsDirEntry;
mIFList = NULL;
mCBIFList = NULL;
mCBMethodDesc = NULL;
mMethodCount = 0;
mCBMethodCount = 0;
mCBIFCount = 0;
mIFCount = 0;
mBase = mClsModule->mBase;
mDesc = adjustClassDescAddr(mBase, mClassDirEntry->mDesc);
mClsId.pUunm = mUrn;
mClsId.clsid = mDesc->clsid;
strcpy(mClsId.pUunm, adjustNameAddr(mBase, mClsMod->mUunm));
}
ECode CClassInfo::CreateIFList()
{
if (mIFList) {
return NOERROR;
}
UInt32* indexList =
(UInt32 *)alloca(mClsMod->mInterfaceCount * sizeof(UInt32));
if (indexList == NULL) {
return E_OUT_OF_MEMORY;
}
IFIndexEntry* allIFList = (IFIndexEntry *)
alloca(mClsMod->mInterfaceCount * sizeof(IFIndexEntry));
if (allIFList == NULL) {
return E_OUT_OF_MEMORY;
}
Int32 i, j, k, n = 0, iNo, listCount = 0;
UInt32 index = 0, eventNum = 1, beginNo = METHOD_START_NO;
Boolean isCallBack = FALSE;
mIFCount = 0;
mCBIFCount = 0;
ClassInterface* cifDir = NULL;
InterfaceDirEntry* ifDir = NULL;
for (i = 0; i < mDesc->mInterfaceCount; i++) {
cifDir = getCIFAddr(mBase, mDesc->ppInterfaces, i);
if (cifDir->wAttribs & ClassInterfaceAttrib_callback) {
isCallBack = TRUE;
}
else {
isCallBack = FALSE;
}
index = cifDir->mIndex;
iNo = 0;
while (index != 0) {
indexList[iNo++] = index;
ifDir = getInterfaceDirAddr(mBase,
mClsMod->mInterfaceDirs, index);
index = adjustInterfaceDescAddr(mBase, ifDir->mDesc)->sParentIndex;
}
indexList[iNo] = 0;
//Save the indexList to mIFList
for (j = iNo; j >= 0; j--) {
index = indexList[j];
if (listCount != 0) {
//If the same inteface in list, continue
for (k = 0; k < listCount; k++) {
if (allIFList[k].mIndex == index) {
beginNo = allIFList[k].mBeginNo
+ allIFList[k].mDesc->cMethods;
if (!isCallBack) {
if (!(allIFList[k].mAttribs & IFAttrib_normal)) {
mIFCount++;
allIFList[k].mAttribs |= IFAttrib_normal;
}
}
else {
if (!(allIFList[k].mAttribs & IFAttrib_callback)) {
mCBIFCount++;
allIFList[k].mAttribs |= IFAttrib_callback;
}
}
break;
}
}
if (k < listCount) {
continue;
}
}
allIFList[listCount].mIndex = index;
allIFList[listCount].mBeginNo = beginNo;
ifDir = getInterfaceDirAddr(mBase, mClsMod->mInterfaceDirs, index);
allIFList[listCount].mName = adjustNameAddr(mBase, ifDir->mName);
allIFList[listCount].mNameSpace = adjustNameAddr(mBase, ifDir->mNameSpace);
allIFList[listCount].mDesc = adjustInterfaceDescAddr(mBase, ifDir->mDesc);
if (!isCallBack) {
mIFCount++;
allIFList[listCount].mAttribs = IFAttrib_normal;
}
else {
mCBIFCount++;
allIFList[listCount].mAttribs = IFAttrib_callback;
}
beginNo += allIFList[listCount].mDesc->cMethods;
listCount++;
}
}
mIFList = new IFIndexEntry[mIFCount];
if (!mIFList) goto EExit;
if (mCBIFCount) {
mCBIFCount--;
mCBIFList = new IFIndexEntry[mCBIFCount];
if (!mCBIFList) goto EExit;
}
mMethodCount = 0;
mCBMethodCount = 0;
j = 0;
k = 0;
for (i = 0; i < listCount; i++) {
if (allIFList[i].mAttribs & IFAttrib_normal) {
memcpy(&mIFList[j], &allIFList[i], sizeof(IFIndexEntry));
mMethodCount += allIFList[i].mDesc->cMethods;
j++;
}
if (i && mCBIFCount && (allIFList[i].mAttribs & IFAttrib_callback)) {
memcpy(&mCBIFList[k], &allIFList[i], sizeof(IFIndexEntry));
mCBMethodCount += allIFList[i].mDesc->cMethods;
k++;
}
}
//Set Callback Method Info
mCBMethodDesc = new CBMethodDesc[mCBMethodCount];
if (!mCBMethodDesc) goto EExit;
memset(mCBMethodDesc, 0, mCBMethodCount * sizeof(CBMethodDesc));
for (i = 0; i < k; i++) {
for (j = 0; j < mCBIFList[i].mDesc->cMethods; j++) {
mCBMethodDesc[n].mDesc = getMethodDescAddr(mBase,
mCBIFList[i].mDesc->ppMethods, j);
mCBMethodDesc[n].mIndex = MK_METHOD_INDEX(mCBIFList[i].mIndex,
mCBIFList[i].mBeginNo + j);
mCBMethodDesc[n].mEventNum = eventNum;
eventNum++;
n++;
}
eventNum += 2;
}
return NOERROR;
EExit:
mIFCount = 0;
mCBIFCount = 0;
mMethodCount = 0;
mCBMethodCount = 0;
if (mIFList) {
delete [] mIFList;
mIFList = NULL;
}
if (mCBIFList) {
delete [] mCBIFList;
mCBIFList = NULL;
}
if (mCBMethodDesc) {
delete [] mCBMethodDesc;
mCBMethodDesc = NULL;
}
return E_OUT_OF_MEMORY;
}
