Esempi in C++ (Cpp) per VERIFY_EXP

Esempio n. 1

File: privileges.c Progetto: CyberGrandChallenge/service-launcher

void drop_privileges(const uid_t uid, const gid_t gid) {
    VERIFY(setsid);
    if (insecure_flag == 1) {
        return;
    }
#ifndef RANDOM_UID
    {
        struct passwd *pd;
        pd = getpwuid(uid);
        VERIFY_EXP(pd != NULL);
        setup_chroot(pd->pw_dir);
    }
#endif
#ifdef HAVE_SETRESGID
    VERIFY(setresgid, gid, gid, gid);
#else
    VERIFY(setregid, gid, gid);
#endif
    VERIFY(setgroups, 1, &gid);
    VERIFY(setgid, gid);
    VERIFY(setegid, gid);
#ifdef HAVE_SETRESGID
    VERIFY(setresuid, uid, uid, uid);
#else
    VERIFY(setreuid, UID_MAX, uid);
#endif
    VERIFY(setuid, uid);
    VERIFY(seteuid, uid);
#ifdef HAVE_SETRESGID
    {
        uid_t real;
        uid_t effective;
        uid_t saved;
        VERIFY(getresuid, &real, &effective, &saved);
        VERIFY_EXP(uid == real);
        VERIFY_EXP(uid == effective);
        VERIFY_EXP(uid == saved);

        VERIFY(getresgid, &real, &effective, &saved);
        VERIFY_EXP(gid == real);
        VERIFY_EXP(gid == effective);
        VERIFY_EXP(gid == saved);
    }
#else
    VERIFY_EXP(geteuid() == uid);
    VERIFY_EXP(getuid() == uid);
    VERIFY_EXP(getegid() == gid);
    VERIFY_EXP(getgid() == gid);
#endif
}

Esempio n. 2

File: SymWrap.cpp Progetto: 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;
}