示例#1
0
static void DumpTypes(IDiaSession *session)
{
    IDiaSymbol *        globalScope = NULL;
    IDiaEnumSymbols *   enumSymbols = NULL;
    IDiaSymbol *        symbol = NULL;

    HRESULT hr = session->get_globalScope(&globalScope);
    if (FAILED(hr))
        return;

    AddReportSepLine();
    g_report.Append("Types:\n");

    DWORD flags = nsfCaseInsensitive|nsfUndecoratedName; // nsNone ?
    hr = globalScope->findChildren(SymTagUDT, 0, flags, &enumSymbols);
    if (FAILED(hr))
        goto Exit;

    ULONG celt = 0;
    for (;;)
    {
        hr = enumSymbols->Next(1, &symbol, &celt);
        if (FAILED(hr) || (celt != 1))
            break;
        DumpType(symbol, 0);
        symbol->Release();
    }

Exit:
    UnkReleaseSafe(enumSymbols);
    UnkReleaseSafe(globalScope);
}
示例#2
0
文件: common.cpp 项目: nealey/vera
//----------------------------------------------------------------------
static HRESULT for_all_children(
  IDiaSymbol *sym,
  enum SymTagEnum type,
  children_visitor_t &cv)
{
  IDiaEnumSymbols *pEnumSymbols;
  HRESULT hr = sym->findChildren(type, NULL, nsNone, &pEnumSymbols);
  if ( SUCCEEDED(hr) )
  {
    while ( true )
    {
      ULONG celt = 0;
      IDiaSymbol *pChild;
      hr = pEnumSymbols->Next(1, &pChild, &celt);
      if ( FAILED(hr) || celt != 1 )
      {
        hr = S_OK; // end of enumeration
        break;
      }
      hr = cv.visit_child(pChild);
      pChild->Release();
      if ( FAILED(hr) )
        break;
    }
    pEnumSymbols->Release();
  }
  return hr;
}
示例#3
0
static void DumpType(IDiaSymbol *symbol, int deep)
{
    IDiaEnumSymbols *   enumChilds = NULL;
    HRESULT             hr;
    const char *        nameStr = NULL;
    const char *        type;
    LONG                offset;
    ULONGLONG           length;
    ULONG               celt = 0;
    ULONG               symtag;
    DWORD               locType;
    bool                typeSeen;

#if 0
    if (deep > 2)
        return;
#endif

    if (symbol->get_symTag(&symtag) != S_OK)
        return;

    nameStr = GetTypeName(symbol);

    g_typesSeen.Intern(nameStr, &typeSeen);
    if (typeSeen)
        return;

    symbol->get_length(&length);
    symbol->get_offset(&offset);

    if (SymTagData == symtag) {
        if (symbol->get_locationType(&locType) != S_OK)
            return; // must be a symbol in optimized code

        // TODO: use get_offsetInUdt (http://msdn.microsoft.com/en-us/library/dd997149.aspx) ?
        // TODO: use get_type (http://msdn.microsoft.com/en-US/library/cwx3656b(v=vs.80).aspx) ?
        // TODO: see what else we can get http://msdn.microsoft.com/en-US/library/w8ae4k32(v=vs.80).aspx
        if (LocIsThisRel == locType) {
            g_report.AppendFmt("%s%s|%d\n", spaces(deep), nameStr, (int)offset);
        }
    } else if (SymTagUDT == symtag) {
        // TODO: why is it always "struct" even for classes?
        type = GetUdtType(symbol);
        g_report.AppendFmt("%s%s|%s|%d\n", spaces(deep), type, nameStr, (int)length);
        hr = symbol->findChildren(SymTagNull, NULL, nsNone, &enumChilds);
        if (!SUCCEEDED(hr))
            return;
        IDiaSymbol* child;
        while (SUCCEEDED(enumChilds->Next(1, &child, &celt)) && (celt == 1))
        {
            DumpType(child, deep+1);
            child->Release();
        }
        enumChilds->Release();
    } else {
        if (symbol->get_locationType(&locType) != S_OK)
            return; // must be a symbol in optimized code
        // TODO: assert?
    }
}
示例#4
0
DDR_RC
PdbScanner::addEnumMembers(IDiaSymbol *symbol, EnumUDT *enumUDT)
{
	DDR_RC rc = DDR_RC_OK;

	/* All children symbols of a symbol for an Enum type should be
	 * enum members.
	 */
	IDiaEnumSymbols *enumSymbols = NULL;
	HRESULT hr = symbol->findChildren(SymTagNull, NULL, nsNone, &enumSymbols);
	if (FAILED(hr)) {
		ERRMSG("findChildren() failed with HRESULT = %08lX", hr);
		rc = DDR_RC_ERROR;
	}

	if (DDR_RC_OK == rc) {
		vector<EnumMember *> *members = NULL;
		NamespaceUDT *outerUDT = enumUDT->_outerNamespace;
		/* literals of a nested anonymous enum are collected in the enclosing namespace */
		if ((NULL != outerUDT) && enumUDT->isAnonymousType()) {
			members = &outerUDT->_enumMembers;
		} else {
			members = &enumUDT->_enumMembers;
		}
		set<string> memberNames;
		for (vector<EnumMember *>::iterator m = members->begin(); m != members->end(); ++m) {
			memberNames.insert((*m)->_name);
		}
		IDiaSymbol *childSymbol = NULL;
		ULONG celt = 0;
		LONG count = 0;
		enumSymbols->get_Count(&count);
		members->reserve(count);
		while (SUCCEEDED(enumSymbols->Next(1, &childSymbol, &celt))
			&& (1 == celt)
			&& (DDR_RC_OK == rc)
		) {
			string name = "";
			int value = 0;
			rc = getName(childSymbol, &name);

			if (DDR_RC_OK == rc) {
				VARIANT variantValue;
				variantValue.vt = VT_EMPTY;

				hr = childSymbol->get_value(&variantValue);
				if (FAILED(hr)) {
					ERRMSG("get_value() failed with HRESULT = %08lX", hr);
					rc = DDR_RC_ERROR;
				} else {
					switch (variantValue.vt) {
					case VT_I1:
						value = variantValue.cVal;
						break;
					case VT_I2:
						value = variantValue.iVal;
						break;
					case VT_I4:
						value = (int)variantValue.lVal;
						break;
					case VT_UI1:
						value = variantValue.bVal;
						break;
					case VT_UI2:
						value = variantValue.uiVal;
						break;
					case VT_UI4:
						value = (int)variantValue.ulVal;
						break;
					case VT_INT:
						value = variantValue.intVal;
						break;
					case VT_UINT:
						value = (int)variantValue.uintVal;
						break;
					default:
						ERRMSG("get_value() unexpected variant: 0x%02X", variantValue.vt);
						rc = DDR_RC_ERROR;
						break;
					}
				}
			}

			if (DDR_RC_OK == rc) {
				if (memberNames.end() == memberNames.find(name)) {
					EnumMember *enumMember = new EnumMember;
					enumMember->_name = name;
					enumMember->_value = value;
					members->push_back(enumMember);
					memberNames.insert(name);
				}
			}
			childSymbol->Release();
		}

		enumSymbols->Release();
	}

	return rc;
}
示例#5
0
DDR_RC
PdbScanner::addChildrenSymbols(IDiaSymbol *symbol, enum SymTagEnum symTag, NamespaceUDT *outerNamespace)
{
	DDR_RC rc = DDR_RC_OK;
	IDiaEnumSymbols *classSymbols = NULL;

	/* Find children symbols. SymTagUDT covers struct, union, and class symbols. */
	HRESULT hr = symbol->findChildren(symTag, NULL, nsNone, &classSymbols);
	if (FAILED(hr)) {
		ERRMSG("findChildren() failed with HRESULT = %08lX", hr);
		rc = DDR_RC_ERROR;
	}

	/* Allocate space for the children symbols. */
	LONG count = 0;
	if (DDR_RC_OK == rc) {
		hr = classSymbols->get_Count(&count);
		if (FAILED(hr)) {
			ERRMSG("Failed to get count of children symbols with HRESULT = %08lX", hr);
			rc = DDR_RC_ERROR;
		}
	}
	IDiaSymbol **childSymbols = NULL;
	ULONG celt = 0;
	if ((DDR_RC_OK == rc) && (0 != count)) {
		childSymbols = new IDiaSymbol*[count];
		hr = classSymbols->Next(count, childSymbols, &celt);
		if (FAILED(hr)) {
			ERRMSG("Failed to get children symbols with HRESULT = %08lX", hr);
			rc = DDR_RC_ERROR;
		}
	}

	/* Iterate the children symbols, adding them to the IR.
	 * Inner symbols are first found with a decorated name and no
	 * parent reference. Ignore these for now and add the outer
	 * types first.
	 */
	vector<ULONG> innerTypeSymbols;
	if (DDR_RC_OK == rc) {
		bool alreadyHadFields = false;
		bool alreadyCheckedFields = false;
		bool alreadyHadSubtypes = false;
		if (NULL != outerNamespace) {
			alreadyHadSubtypes = !outerNamespace->_subUDTs.empty();
		}
		for (ULONG index = 0; index < celt; ++index) {
			string udtName = "";
			DWORD childTag = 0;
			hr = childSymbols[index]->get_symTag(&childTag);
			if (FAILED(hr)) {
				ERRMSG("Failed to get child symbol SymTag with HRESULT = %08lX", hr);
				rc = DDR_RC_ERROR;
			}
			if ((DDR_RC_OK == rc) && ((SymTagEnum == childTag) || (SymTagUDT == childTag))) {
				rc = getName(childSymbols[index], &udtName);
			}
			if (DDR_RC_OK == rc) {
				if ((NULL == outerNamespace) || (string::npos == udtName.find("::"))) {
					/* When adding fields/subtypes to a type, only add fields to a type with no fields
					 * and only add subtypes to a type with no subtypes. This avoids adding duplicates
					 * fields/subtypes when scanning multiple files. Children symbols must be processed
					 * for already existing symbols because fields and subtypes can appear separately.
					 */
					if (!alreadyCheckedFields && (SymTagData == childTag)) {
						alreadyCheckedFields = true;
						alreadyHadFields = !((ClassType *)outerNamespace)->_fieldMembers.empty();
					}

					if (!((SymTagData == childTag) ? alreadyHadFields : alreadyHadSubtypes)) {
						rc = addSymbol(childSymbols[index], outerNamespace);
					}
					childSymbols[index]->Release();
				} else {
					innerTypeSymbols.push_back(index);
				}
			}
			if (DDR_RC_OK != rc) {
				break;
			}
		}
	}

	/* Iterate the inner types. Only namespaces will be added to the IR
	 * here, since they have no associated symbol.
	 */
	if (DDR_RC_OK == rc) {
		for (vector<ULONG>::iterator it = innerTypeSymbols.begin(); it != innerTypeSymbols.end() && DDR_RC_OK == rc; ++it) {
			rc = addSymbol(childSymbols[*it], outerNamespace);
			childSymbols[*it]->Release();
		}
	}

	if (NULL != childSymbols) {
		delete childSymbols;
	}
	if (NULL != classSymbols) {
		classSymbols->Release();
	}
	return rc;
}
示例#6
0
//-----------------------------------------------------------------------------
// Name: ParseModules
// Object: parse all compilands
// Parameters :
//     in  : 
//     out : 
//     return : TRUE on success
//-----------------------------------------------------------------------------
BOOL CDebugInfos::ParseModules()
{
    HRESULT hr;
    IDiaEnumSymbols* pEnumSymbols;
    IDiaEnumSymbols* pEnumChildren;
    IDiaSymbol* pCompiland;
    IDiaSymbol* pSymbol;
    ULONG celt = 0;
    CModuleInfos* pModuleInfo;
    BSTR Name;

    // Retrieve the compilands first
    if(FAILED(this->pDiaGlobalSymbol->findChildren(SymTagCompiland, NULL, nsNone, &pEnumSymbols)))
        return FALSE;

    // for each compiland
    while(pEnumSymbols->Next(1, &pCompiland, &celt) == S_OK && celt == 1) 
    {
        // Retrieve the name of the module
        Name=NULL;
        pCompiland->get_name(&Name);

#if (REMOVE_LINKER_COMPILAND==1)
        // avoid to display "* Linker *" infos
        if (Name)
        {
            if (wcsicmp(Name,LINKER_COMPILAND_NAME)==0)
            {
                SysFreeString(Name);
                pCompiland->Release();
                continue;
            }
        }
#endif

        // create module info
        pModuleInfo=new CModuleInfos();
        // add it to modules list
        this->pLinkListModules->AddItem(pModuleInfo);
        // assume module name is set
        if (Name)
        {
#if (defined(UNICODE)||defined(_UNICODE))
            pModuleInfo->Name=_tcsdup(Name);
#else
            CAnsiUnicodeConvert::UnicodeToAnsi(Name,&pModuleInfo->Name);
#endif
            SysFreeString(Name);
        }
        else
            pModuleInfo->Name=_tcsdup(_T(""));

        // Find all the symbols defined in this compiland and get their info
        if(SUCCEEDED(pCompiland->findChildren(SymTagNull, NULL, nsNone, &pEnumChildren)))
        {
            ULONG celt_ = 0;
            while (pEnumChildren->Next(1, &pSymbol, &celt_) == S_OK && celt_ == 1) 
            {
                hr=pModuleInfo->Parse(pSymbol);
                if (FAILED(hr))
                    this->ReportError(_T("Error parsing module information"),hr);
                pSymbol->Release();
            }
            pEnumChildren->Release();
        }
        pCompiland->Release();
    }
    pEnumSymbols->Release();
    return TRUE;
}
示例#7
0
文件: SymWrap.cpp 项目: 0cch/SymWrap
HRESULT SymBase::GetInfoTable( SymbolInfoTable &InfoTable )
{
	HRESULT hr;
	ULONG SymULONG;
	LPCWSTR SymStr;
	BSTR SymBStr;
	BOOL SymBOOL;
	IDiaSymbol *SymSymbol;
	IDiaEnumSymbols *SymEnum;
	BOOL TableRet;
	CString Tmp;
	

	//
	// Children
	//
	hr = Self()->findChildren(SymTagNull, NULL, nsNone, &SymEnum);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_CHILDREN, BOOL_STR(SymEnum != NULL));
		VERIFY_EXP(TableRet);
		SymEnum->Release();
	}


	//
	// access
	//
	hr = Self()->get_access(&SymULONG);
	if (HR_OK(hr)) {
		SymStr = GetAccessStr(SymULONG);
		TableRet = InfoTable.Add(SYMBOL_ACCESS, SymStr);
		VERIFY_EXP(TableRet);
	}


	//
	// addressOffset
	//
	hr = Self()->get_addressOffset(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_ADDRESSOFFSET, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// addressSection 
	//
	hr = Self()->get_addressSection(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_ADDRESSSECTION, Tmp);
		VERIFY_EXP(TableRet);
	}

	//
	// addressTaken 
	//
	hr = Self()->get_addressTaken(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_ADDRESSTAKEN, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}

	//
	// age 
	//
	hr = Self()->get_age(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_AGE, Tmp);
		VERIFY_EXP(TableRet);
	}

	
	//
	// arrayIndexType
	//
	hr = Self()->get_arrayIndexType(&SymSymbol);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_ARRAYINDEXTYPE, BOOL_STR(SymSymbol != NULL));
		VERIFY_EXP(TableRet);
		SymSymbol->Release();
	}


	//
	// arrayIndexTypeId 
	//
	hr = Self()->get_arrayIndexTypeId(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_ARRAYINDEXTYPEID, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// backEndMajor (Not implement)
	//


	//
	// backEndMinor (Not implement)
	//


	//
	// backEndBuild (Not implement)
	//



	//
	// baseType 
	//
	hr = Self()->get_baseType(&SymULONG);
	if (HR_OK(hr)) {
		SymStr = GetBaseTypeStr(SymULONG, 0);
		TableRet = InfoTable.Add(SYMBOL_BASETYPE, SymStr);
		VERIFY_EXP(TableRet);
	}


	//
	// bitPosition 
	//
	hr = Self()->get_bitPosition(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_BITPOSITION, Tmp);
		VERIFY_EXP(TableRet);
	}

	//
	// callingConvention 
	//
	hr = Self()->get_callingConvention(&SymULONG);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_CALLINGCONVENTION, GetCallingConventionStr(SymULONG));
		VERIFY_EXP(TableRet);
	}
	



	//
	// classParent
	//
	hr = Self()->get_classParent(&SymSymbol);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_CLASSPARENT, BOOL_STR(SymSymbol != NULL));
		VERIFY_EXP(TableRet);
		SymSymbol->Release();
	}


	//
	// classParentId 
	//
	hr = Self()->get_classParentId(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_CLASSPARENTID, Tmp);
		VERIFY_EXP(TableRet);
	}

	
	//
	// code 
	//
	hr = Self()->get_code(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_CODE, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// compilerGenerated 
	//
	hr = Self()->get_compilerGenerated(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_COMPILERGENERATED, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}

	
	//
	// compilerName 
	//
	hr = Self()->get_compilerName(&SymBStr);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_COMPILERNAME, SymBStr);
		VERIFY_EXP(TableRet);
	}


	//
	// constructor 
	//
	hr = Self()->get_constructor(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_CONSTRUCTOR, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// container
	//
	hr = Self()->get_container(&SymSymbol);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_CONTAINER, BOOL_STR(SymSymbol != NULL));
		VERIFY_EXP(TableRet);
		SymSymbol->Release();
	}


	//
	// constType 
	//
	hr = Self()->get_constType(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_CONSTTYPE, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}



	//
	// count 
	//
	hr = Self()->get_count(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_COUNT, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// customCallingConvention
	//
	hr = Self()->get_customCallingConvention(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_CUSTOMCALLINGCONVENTION, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// dataBytes (Not implement)
	//


	//
	// dataKind 
	//
	hr = Self()->get_dataKind(&SymULONG);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_DATAKIND, GetDataKindStr(SymULONG));
		VERIFY_EXP(TableRet);
	}

	//
	// editAndContinueEnabled 
	//
	hr = Self()->get_editAndContinueEnabled(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_EDITANDCONTINUEENABLED, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}

	//
	// farReturn
	//
	hr = Self()->get_farReturn(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_FARRETURN, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// frontEndMajor (Not implement)
	//


	//
	// frontEndMinor (Not implement)
	//


	//
	// frontEndBuild (Not implement)
	//

	
	//
	// function 
	//
	hr = Self()->get_function(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_FARRETURN, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// guid 
	//
	GUID SymGuid;
	hr = Self()->get_guid(&SymGuid);
	if (HR_OK(hr)) {
		Tmp.Format(L"{%08X-%04X-%04x-%02X%02X-%02X%02X%02X%02X%02X%02X} ", 
			SymGuid.Data1, SymGuid.Data2, SymGuid.Data3, SymGuid.Data4[0],
			SymGuid.Data4[1], SymGuid.Data4[2], SymGuid.Data4[3], 
			SymGuid.Data4[4], SymGuid.Data4[5], 
			SymGuid.Data4[6], SymGuid.Data4[7]);

		TableRet = InfoTable.Add(SYMBOL_GUID, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// hasAlloca
	//
	hr = Self()->get_hasAlloca(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_HASALLOCA, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}



	//
	// hasAssignmentOperator 
	//
	hr = Self()->get_hasAssignmentOperator(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_HASASSIGNMENTOPERATOR, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// hasCastOperator 
	//
	hr = Self()->get_hasCastOperator(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_HASCASTOPERATOR, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// hasDebugInfo
	//
	hr = Self()->get_hasDebugInfo(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_HASDEBUGINFO, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// hasEH
	//
	hr = Self()->get_hasEH(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_HASEH, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// hasEHa
	//
	hr = Self()->get_hasEHa(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_HASEHA, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// hasInlAsm
	//
	hr = Self()->get_hasInlAsm(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_HASINLASM, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// hasLongJump
	//
	hr = Self()->get_hasLongJump(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_HASLONGJUMP, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// hasManagedCode
	//
	hr = Self()->get_hasManagedCode(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_HASMANAGEDCODE, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// hasNestedTypes 
	//
	hr = Self()->get_hasNestedTypes(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_HASNESTEDTYPES, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// hasSecurityChecks
	//
	hr = Self()->get_hasSecurityChecks(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_HASSECURITYCHECKS, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// hasSEH
	//
	hr = Self()->get_hasSEH(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_HASSEH, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// hasSetJump
	//
	hr = Self()->get_hasSetJump(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_HASSETJUMP, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// indirectVirtualBaseClass 
	//
	hr = Self()->get_indirectVirtualBaseClass(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_INDIRECTVIRTUALBASECLASS, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// inlSpec
	//
	hr = Self()->get_inlSpec(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_INLSPEC, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// interruptReturn
	//
	hr = Self()->get_interruptReturn(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_INTERRUPTRETURN, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// intro 
	//
	hr = Self()->get_intro(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_INTRO, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// isAggregated
	//
	hr = Self()->get_isAggregated(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_ISAGGREGATED, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// isCTypes
	//
	hr = Self()->get_isCTypes(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_ISCTYPES, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// isCVTCIL
	//
	hr = Self()->get_isCVTCIL(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_ISCVTCIL, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// isDataAligned
	//
	hr = Self()->get_isDataAligned(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_ISDATAALIGNED, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// isHotpatchable
	//
	hr = Self()->get_isHotpatchable(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_ISHOTPATCHABLE, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}

	//
	// isLTCG
	//
	hr = Self()->get_isLTCG(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_ISLTCG, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// isMSILNetmodule
	//
	hr = Self()->get_isMSILNetmodule(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_ISMSILNETMODULE, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// isNaked
	//
	hr = Self()->get_isNaked(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_ISNAKED, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// isSplitted
	//
	hr = Self()->get_isSplitted(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_ISSPLITTED, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// isStatic
	//
	hr = Self()->get_isStatic(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_ISSTATIC, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// isStripped
	//
	hr = Self()->get_isStripped(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_ISSTRIPPED, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// language 
	//
	hr = Self()->get_language(&SymULONG);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_LANGUAGE, GetLanguageStr(SymULONG));
		VERIFY_EXP(TableRet);
	}


	//
	// length 
	//
	ULONGLONG SymULONGLONG;
	hr = Self()->get_length(&SymULONGLONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%0.16I64X", SymULONGLONG);
		TableRet = InfoTable.Add(SYMBOL_LENGTH, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// lexicalParent 
	//
	hr = Self()->get_lexicalParent(&SymSymbol);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_LEXICALPARENT, BOOL_STR(SymSymbol != NULL));
		VERIFY_EXP(TableRet);
		SymSymbol->Release();
	}

	//
	// lexicalParentId 
	//
	hr = Self()->get_lexicalParentId(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_LEXICALPARENTID, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// libraryName 
	//
	hr = Self()->get_libraryName(&SymBStr);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_LIBRARYNAME, SymBStr);
		VERIFY_EXP(TableRet);
	}


	//
	// liveLVarInstances (Not implement)
	//


	//
	// locationType 
	//
	hr = Self()->get_locationType(&SymULONG);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_LOCATIONTYPE, GetLocationTypeStr(SymULONG));
		VERIFY_EXP(TableRet);
	}


	//
	// lowerBound (Not implement)
	//


	//
	// lowerBoundId (Not implement)
	//


	//
	// machineType 
	//
	hr = Self()->get_machineType(&SymULONG);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_MACHINETYPE, GetMachineTypeStr(SymULONG));
		VERIFY_EXP(TableRet);
	}


	//
	// managed 
	//
	hr = Self()->get_managed(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_MANAGED, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}

	//
	// msil 
	//
	hr = Self()->get_msil(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_MSIL, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}

	//
	// name 
	//
	hr = Self()->get_name(&SymBStr);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_NAME, SymBStr);
		VERIFY_EXP(TableRet);
	}


	//
	// nested
	//
	hr = Self()->get_nested(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_NESTED, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// noInline
	//
	hr = Self()->get_noInline(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_NOINLINE, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// noReturn
	//
	hr = Self()->get_noReturn(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_NORETURN, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// noStackOrdering
	//
	hr = Self()->get_noStackOrdering(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_NOSTACKORDERING, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// notReached
	//
	hr = Self()->get_notReached(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_NOTREACHED, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// objectPointerType 
	//
	hr = Self()->get_objectPointerType(&SymSymbol);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_OBJECTPOINTERTYPE, BOOL_STR(SymSymbol != NULL));
		VERIFY_EXP(TableRet);
		SymSymbol->Release();
	}

	
	//
	// oemId 
	//
	hr = Self()->get_oemId(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_OEMID, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// oemSymbolId 
	//
	hr = Self()->get_oemSymbolId(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_OEMSYMBOLID, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// offset 
	//
	LONG SymLONG;
	hr = Self()->get_offset(&SymLONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymLONG);
		TableRet = InfoTable.Add(SYMBOL_OFFSET, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// optimizedCodeDebugInfo
	//
	hr = Self()->get_optimizedCodeDebugInfo(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_OPTIMIZEDCODEDEBUGINFO, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// overloadedOperator
	//
	hr = Self()->get_overloadedOperator(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_OVERLOADEDOPERATOR, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// packed
	//
	hr = Self()->get_packed(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_PACKED, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// platform 
	//
	hr = Self()->get_platform(&SymULONG);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_OEMSYMBOLID, GetMachineTypeStr(SymULONG));
		VERIFY_EXP(TableRet);
	}


	//
	// pure
	//
	hr = Self()->get_pure(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_PURE, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// rank (Not implement)
	//


	//
	// reference
	//
	hr = Self()->get_reference(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_REFERENCE, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// registerId 
	//
	hr = Self()->get_platform(&SymULONG);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_REGISTERID, GetMachineTypeStr(SymULONG));
		VERIFY_EXP(TableRet);
	}


	//
	// relativeVirtualAddress 
	//
	hr = Self()->get_platform(&SymULONG);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_RELATIVEVIRTUALADDRESS, GetMachineTypeStr(SymULONG));
		VERIFY_EXP(TableRet);
	}


	//
	// scoped 
	//
	hr = Self()->get_scoped(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_SCOPED, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// signature 
	//
	hr = Self()->get_signature(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_SIGNATURE, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// slot 
	//
	hr = Self()->get_slot(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_SLOT, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// sourceFileName 
	//
	hr = Self()->get_sourceFileName(&SymBStr);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_SOURCEFILENAME, SymBStr);
		VERIFY_EXP(TableRet);
	}


	//
	// symbolsFileName  
	//
	hr = Self()->get_symbolsFileName(&SymBStr);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_SYMBOLSFILENAME, SymBStr);
		VERIFY_EXP(TableRet);
	}


	//
	// symIndexId 
	//
	hr = Self()->get_symIndexId(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_SYMINDEXID, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// symTag 
	//
	hr = Self()->get_symTag(&SymULONG);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_SYMTAG, GetSymTagStr(SymULONG));
		VERIFY_EXP(TableRet);
	}


	//
	// targetOffset 
	//
	hr = Self()->get_targetOffset(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_SYMINDEXID, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// targetRelativeVirtualAddress 
	//
	hr = Self()->get_targetRelativeVirtualAddress(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_TARGETRELATIVEVIRTUALADDRESS, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// targetSection 
	//
	hr = Self()->get_targetSection(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_TARGETSECTION, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// targetVirtualAddress 
	//
	hr = Self()->get_targetVirtualAddress(&SymULONGLONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%0.16I64X", SymULONGLONG);
		TableRet = InfoTable.Add(SYMBOL_TARGETVIRTUALADDRESS, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// thisAdjust 
	//
	hr = Self()->get_thisAdjust(&SymLONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymLONG);
		TableRet = InfoTable.Add(SYMBOL_THISADJUST, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// thunkOrdinal 
	//
	hr = Self()->get_thunkOrdinal(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_THISADJUST, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// timeStamp 
	//
	hr = Self()->get_timeStamp(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_TIMESTAMP, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// token 
	//
	hr = Self()->get_token(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_TOKEN, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// type 
	//
	hr = Self()->get_type(&SymSymbol);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_TYPE, BOOL_STR(SymSymbol != NULL));
		VERIFY_EXP(TableRet);
		SymSymbol->Release();
	}


	//
	// typeId 
	//
	hr = Self()->get_typeId(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_TYPEID, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// types (Not implement)
	//
	

	//
	// typeIds (Not implement)
	//


	//
	// udtKind 
	//
	hr = Self()->get_udtKind(&SymULONG);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_UDTKIND, GetUdtKindStr(SymULONG));
		VERIFY_EXP(TableRet);
	}


	//
	// unalignedType 
	// 
	hr = Self()->get_unalignedType(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_UNALIGNEDTYPE, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// undecoratedName 
	//
	hr = Self()->get_undecoratedName(&SymBStr);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_UNDECORATEDNAME, SymBStr);
		VERIFY_EXP(TableRet);
	}
	
	
	//
	// undecoratedNameEx (Not implement)
	//


	//
	// upperBound (Not implement)
	//
	

	//
	// upperBoundId (Not implement)
	//


	//
	// value 
	//
	VARIANT SymVar;
	SymVar.vt = VT_EMPTY;
	hr = Self()->get_value(&SymVar);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_VALUE, L"TRUE");
		VERIFY_EXP(TableRet);
	}


	//
	// virtual 
	//
	hr = Self()->get_virtual(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_VIRTUAL, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// virtualAddress 
	//
	hr = Self()->get_virtualAddress(&SymULONGLONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%0.16I64X", SymULONGLONG);
		TableRet = InfoTable.Add(SYMBOL_VIRTUALADDRESS, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// virtualBaseClass 
	//
	hr = Self()->get_virtualBaseClass(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_VIRTUALBASECLASS, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}


	//
	// virtualBaseDispIndex 
	//
	hr = Self()->get_virtualBaseDispIndex(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_VIRTUALBASEDISPINDEX, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// virtualBaseOffset 
	//
	hr = Self()->get_virtualBaseOffset(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_VIRTUALBASEOFFSET, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// virtualBasePointerOffset 
	//
	hr = Self()->get_virtualBasePointerOffset(&SymLONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymLONG);
		TableRet = InfoTable.Add(SYMBOL_VIRTUALBASEPOINTEROFFSET, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// virtualBaseTableType
	//
	hr = Self()->get_virtualBaseTableType(&SymSymbol);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_VIRTUALBASETABLETYPE, BOOL_STR(SymSymbol != NULL));
		VERIFY_EXP(TableRet);
		SymSymbol->Release();
	}


	//
	// virtualTableShape 
	//
	hr = Self()->get_virtualTableShape(&SymSymbol);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_VIRTUALTABLESHAPE, BOOL_STR(SymSymbol != NULL));
		VERIFY_EXP(TableRet);
		SymSymbol->Release();
	}


	//
	// virtualTableShapeId 
	//
	hr = Self()->get_virtualTableShapeId(&SymULONG);
	if (HR_OK(hr)) {
		Tmp.Format(L"%08X", SymULONG);
		TableRet = InfoTable.Add(SYMBOL_VIRTUALTABLESHAPEID, Tmp);
		VERIFY_EXP(TableRet);
	}


	//
	// volatileType 
	//
	hr = Self()->get_volatileType(&SymBOOL);
	if (HR_OK(hr)) {
		TableRet = InfoTable.Add(SYMBOL_VOLATILETYPE, BOOL_STR(SymBOOL));
		VERIFY_EXP(TableRet);
	}

#ifdef DEBUG_PRINT
	DisplayInfo(InfoTable);
#endif
	
	return S_OK;
}