public ComField(IComBase parent, ITypeInfo info, string name, VARDESC varDesc, int index, DeclarationType type) { Parent = parent; Name = name; Index = index; Type = type; Flags = (VARFLAGS)varDesc.wVarFlags; if (Type == DeclarationType.Constant) { var value = new ComVariant(varDesc.desc.lpvarValue); DefaultValue = value.Value; if (ComVariant.TypeNames.TryGetValue(value.VariantType, out string typeName)) { _valueType = typeName; } if (value.VariantType.HasFlag(VarEnum.VT_ARRAY)) { IsArray = true; } } else { GetFieldType(varDesc.elemdescVar.tdesc, info); } }
internal static void GetVarDescForVarIndex(ITypeInfo typeInfo, int varIndex, out System.Runtime.InteropServices.ComTypes.VARDESC varDesc, out IntPtr varDescHandle) { IntPtr zero = IntPtr.Zero; typeInfo.GetVarDesc(varIndex, out zero); if (zero == IntPtr.Zero) { throw new COMException(Microsoft.Build.Shared.ResourceUtilities.FormatResourceString("ResolveComReference.CannotRetrieveTypeInformation", new object[0])); } varDesc = (System.Runtime.InteropServices.ComTypes.VARDESC)Marshal.PtrToStructure(zero, typeof(System.Runtime.InteropServices.ComTypes.VARDESC)); varDescHandle = zero; }
public TypeInfoVariable(ComTypes.ITypeInfo typeInfo, int index) { _typeInfo = typeInfo; _typeInfo.GetVarDesc(index, out _varDescPtr); _varDesc = StructHelper.ReadStructureUnsafe <ComTypes.VARDESC>(_varDescPtr); var names = new string[1]; typeInfo.GetNames(_varDesc.memid, names, 1, out var actualCount); Name = actualCount >= 1 ? names[0] : "[unnamed]"; }
public ComEnumerationMember(ITypeInfo info, VARDESC varDesc) { var value = new ComVariant(varDesc.desc.lpvarValue); Value = (int)value.Value; ValueType = value.VariantType; var names = new string[1]; int count; info.GetNames(varDesc.memid, names, names.Length, out count); Debug.Assert(count == 1); Name = names[0]; }
public ComVariableInfo(ComTypeInfo parent, System.Runtime.InteropServices.ComTypes.VARDESC varDesc, object constantValue) : base(parent) { _varDesc = varDesc; _comTypeInfo.GetITypeInfo().GetDocumentation(_varDesc.memid, out _name, out _description, out _helpContext, out _helpFile); _constantValue = constantValue; if (_description == null) { _description = String.Empty; } if (_helpFile == null) { _helpFile = String.Empty; } }
private DeclarationType GetDeclarationType(VARDESC varDesc, DeclarationType typeDeclarationType) { var memberType = DeclarationType.Variable; if (varDesc.varkind == VARKIND.VAR_CONST) { memberType = typeDeclarationType == DeclarationType.Enumeration ? DeclarationType.EnumerationMember : DeclarationType.Constant; } else if (typeDeclarationType == DeclarationType.UserDefinedType) { memberType = DeclarationType.UserDefinedTypeMember; } return(memberType); }
internal static object GetConstantValue(ComTypes.VARDESC varDesc) { if (varDesc.varkind == ComTypes.VARKIND.VAR_CONST) { try { var constantValue = varDesc.desc.lpvarValue; return(Marshal.GetObjectForNativeVariant(constantValue)); } catch (Exception e) { return(null); } } return(null); }
public TypeInfoVar(TypeInfoWrapper typeInfo, int index) { _typeInfo = typeInfo; ((ComTypes.ITypeInfo)_typeInfo).GetVarDesc(index, out _varDescPtr); _varDesc = StructHelper.ReadStructureUnsafe <ComTypes.VARDESC>(_varDescPtr); var names = new string[1]; if (_varDesc.memid != (int)TypeLibConsts.MEMBERID_NIL) { ((ComTypes.ITypeInfo)_typeInfo).GetNames(_varDesc.memid, names, names.Length, out _); _name = names[0]; } else { _name = "{unknown}"; // VBA Constants appear in the typelib with no name } }
public ComField(string name, VARDESC varDesc, int index, DeclarationType type) { Name = name; Index = index; Type = type; Flags = (VARFLAGS)varDesc.wVarFlags; if (Type == DeclarationType.Constant) { var value = new ComVariant(varDesc.desc.lpvarValue); DefaultValue = value.Value; string typeName; ValueType = ComVariant.TypeNames.TryGetValue(value.VariantType, out typeName) ? typeName : "Object"; } else { Debug.Assert(varDesc.varkind == VARKIND.VAR_PERINSTANCE); string typeName; ValueType = ComVariant.TypeNames.TryGetValue((VarEnum)varDesc.elemdescVar.tdesc.vt, out typeName) ? typeName : "Object"; } }
public ComVariableInfo(ComTypeInfo parent, System.Runtime.InteropServices.ComTypes.VARDESC varDesc, object constantValue) : base(parent) { _varDesc = varDesc; _comTypeInfo.GetITypeInfo().GetDocumentation(_varDesc.memid, out _name, out _description, out _helpContext, out _helpFile); _constantValue = constantValue; if (_description == null) _description = String.Empty; if (_helpFile == null) _helpFile = String.Empty; }
public void GetVarDesc(int index, out IntPtr ppVarDesc) { // Fail BEFORE allocating the handle to avoid leaks. If the real COM object fails in this method // and doesn't return the handle or clean it up itself there's not much we can do to avoid the leak. _faultInjector.FailurePointThrow(MockTypeLibrariesFailurePoints.ITypeInfo_GetVarDesc); ppVarDesc = _memoryHelper.AllocateHandle(Marshal.SizeOf<VARDESC>()); _memoryHelper.EnterSubAllocationScope(ppVarDesc); VARDESC varDesc = new VARDESC(); varDesc.elemdescVar.tdesc = _definedVariables[index].CreateTypeDesc(new IntPtr(index + s_HREF_VARS_OFFSET), _memoryHelper); _memoryHelper.ExitSubAllocationScope(); Marshal.StructureToPtr(varDesc, ppVarDesc, false); }
private static IEnumerable <ITypeInfo> GetReferencedEnums(ITypeLib typeLib, ITypeInfo typeInfo, VARDESC varDesc, Dictionary <Guid, ITypeInfo> processedTypeInfo) { return(GetReferencedEnums(typeLib, typeInfo, varDesc.elemdescVar, processedTypeInfo)); }
internal static bool IsConstant(ComTypes.VARDESC varDesc) { return(varDesc.varkind == ComTypes.VARKIND.VAR_CONST); }
internal static string GetMemberName(ComTypes.ITypeInfo typeInfo, ComTypes.VARDESC varDesc) { // first element in the sequence is the name of the method. return(GetNames(typeInfo, varDesc.memid).First()); }
/// <summary> /// Helper method for retrieving type attributes for a given type info /// This method needs to also return the native pointer to be released when we're done with our VARDESC. /// It's not really possible to copy everything to a managed struct and then release the ptr immediately /// here, since VARDESCs contain other native pointers we may need to access. /// </summary> /// <param name="typeInfo"></param> /// <param name="varIndex"></param> /// <param name="typeAttr"></param> /// <param name="varDesc"></param> /// <param name="varDescHandle"></param> /// <returns></returns> internal static void GetVarDescForVarIndex(ITypeInfo typeInfo, int varIndex, out VARDESC varDesc, out IntPtr varDescHandle) { IntPtr pVarDesc = IntPtr.Zero; typeInfo.GetVarDesc(varIndex, out pVarDesc); // GetVarDesc should never return null, this is just to be safe if (pVarDesc == IntPtr.Zero) { throw new COMException( ResourceUtilities.FormatResourceString("ResolveComReference.CannotRetrieveTypeInformation")); } varDesc = (VARDESC)Marshal.PtrToStructure(pVarDesc, typeof(VARDESC)); varDescHandle = pVarDesc; }