public DebugFunctionType CreateFunctionType(DebugInfoBuilder diBuilder , IDebugType <ITypeRef, DIType> retType , params IDebugType <ITypeRef, DIType>[] argTypes ) { return(CreateFunctionType(diBuilder, false, retType, argTypes)); }
public DebugFunctionType CreateFunctionType(DebugInfoBuilder diBuilder , IDebugType <ITypeRef, DIType> retType , IEnumerable <IDebugType <ITypeRef, DIType> > argTypes ) { return(CreateFunctionType(diBuilder, false, retType, argTypes)); }
private static DICompositeType BuildDebugType([ValidatedNotNull] IArrayType llvmType , [ValidatedNotNull] IDebugType <ITypeRef, DIType> elementType , [ValidatedNotNull] BitcodeModule module , uint count , uint lowerBound , uint alignment ) { llvmType.ValidateNotNull(nameof(llvmType)); elementType.ValidateNotNull(nameof(elementType)); module.ValidateNotNull(nameof(module)); if (llvmType.ElementType.GetTypeRef( ) != elementType.GetTypeRef( )) { throw new ArgumentException(Resources.ElementType_doesn_t_match_array_element_type); } if (llvmType.IsSized) { return(module.DIBuilder.CreateArrayType(module.Layout.BitSizeOf(llvmType) , alignment , elementType.DIType ! // validated not null in constructor , module.DIBuilder.CreateSubRange(lowerBound, count) )); } return(module.DIBuilder.CreateReplaceableCompositeType(Tag.ArrayType , string.Empty , module.DICompileUnit ?? default , default
/// <summary>Creates a new <see cref="DebugArrayType"/></summary> /// <param name="llvmType">Underlying LLVM array type to bind debug info to</param> /// <param name="elementType">Array element type with debug information</param> /// <param name="module">module to use for creating debug information</param> /// <param name="count">Number of elements in the array</param> /// <param name="lowerBound">Lower bound of the array [default = 0]</param> /// <param name="alignment">Alignment for the type</param> public DebugArrayType(IArrayType llvmType , IDebugType <ITypeRef, DIType> elementType , NativeModule module , uint count , uint lowerBound = 0 , uint alignment = 0 ) : base(llvmType) { if (llvmType == null) { throw new ArgumentNullException(nameof(llvmType)); } if (elementType == null) { throw new ArgumentNullException(nameof(elementType)); } if (llvmType.ElementType.TypeHandle != elementType.TypeHandle) { throw new ArgumentException("elementType doesn't match array element type"); } DIType = CreateDebugInfoForArray(llvmType, elementType, module, count, lowerBound, alignment); DebugElementType = elementType; }
public override IEnumDebugProperty EnumChildren(EnumerationKind kind, int radix, int timeout, bool allowFuncEval) { if (this.value == null || this.value.IsNullReference()) { return(null); } IDebugType typ = this.value.RuntimeType(); IDebugClassType classType = null; IDebugStreamType streamType = null; if ((classType = typ as IDebugClassType) != null) { //IEnumSymbol enumSymbol = new CEnumClosureClassSymbols(this.value, this.context); IEnumSymbol enumSymbol = classType.GetClosureClassMembers(this.value); //IEnumSymbol enumSymbol = classType.GetMembers(null, true, SymbolKind.Field|SymbolKind.Property, SymbolModifiers.All); return(new EnumDebugPropertySymbols(enumSymbol, this, this.value, this.evaluator)); } else if ((streamType = typ as IDebugStreamType) != null) { //IDebugStreamType classType = (IDebugStreamType)this.value.RuntimeType(); IEnumSymbol enumSymbol = streamType.GetMembers(null, true, SymbolKind.Field | SymbolKind.Property, SymbolModifiers.All); return(new EnumDebugPropertySymbols(enumSymbol, this, this.value, this.evaluator)); } else { return(null); } }
public DebugClassNode(DebugEnvironment envr, IDebugType symbolType, IDebugValue value) { this.debugEnv = envr; this.SymbolType = symbolType; this.Value = value; this.Name = Identifier.For(this.GetDebugType.Name); }
public TypeProperty(IDebugType type, IDebugProperty parent, IDebugValue containerValue, CommonExpressionEvaluator evaluator) { this.type = type; this.parent = parent; this.name = this.type.FullName; this.containerValue = containerValue; this.evaluator = evaluator; }
public BaseProperty(string name, IDebugType staticType, IDebugValue value, IDebugProperty parent, CommonExpressionEvaluator evaluator) { this.name = name; this.staticType = staticType; this.parent = parent; this.value = value; this.evaluator = evaluator; }
/// <summary>Creates a function</summary> /// <param name="name">Name of the function</param> /// <param name="isVarArg">Flag indicating if the function supports a variadic argument list</param> /// <param name="returnType">Return type of the function</param> /// <param name="argumentTypes">Arguments for the function</param> /// <returns> /// Function, matching the signature specified. This may be a previously declared or defined /// function or a new function if none matching the name and signature is already present. /// </returns> public Function CreateFunction(string name , bool isVarArg , IDebugType <ITypeRef, DIType> returnType , params IDebugType <ITypeRef, DIType>[] argumentTypes ) { return(CreateFunction(name, isVarArg, returnType, (IEnumerable <IDebugType <ITypeRef, DIType> >)argumentTypes)); }
public DebugFunctionType CreateFunctionType(DebugInfoBuilder diBuilder , bool isVarArg , IDebugType <ITypeRef, DIType> retType , params IDebugType <ITypeRef, DIType>[] argTypes ) { return(CreateFunctionType(diBuilder, isVarArg, retType, (IEnumerable <IDebugType <ITypeRef, DIType> >)argTypes)); }
public EnumProperty(string name, IDebugType staticType, IDebugValue value, IDebugProperty parent, CommonExpressionEvaluator evaluator) : base(name, staticType, value, parent, evaluator) { this.enumType = value.RuntimeType() as IDebugEnumType; if (this.enumType == null) { this.enumType = staticType as IDebugEnumType; } }
internal EnumArrayIndices(IEnumDebugValues enumValues, IDebugType elementType, IDebugProperty parent, IDebugValue containerValue, CommonExpressionEvaluator evaluator) { this.enumValues = enumValues; this.elementType = elementType; this.parent = parent; this.containerValue = containerValue; this.index = 0; this.evaluator = evaluator; }
/// <summary>Initializes a new instance of the <see cref="DebugArrayType"/> class.</summary> /// <param name="elementType">Type of elements in the array</param> /// <param name="module"><see cref="BitcodeModule"/> to use for the context of the debug information</param> /// <param name="count">Number of elements in the array</param> /// <param name="lowerBound"><see cref="LowerBound"/> value for the array indices [Default: 0]</param> public DebugArrayType(IDebugType <ITypeRef, DIType> elementType, BitcodeModule module, uint count, uint lowerBound = 0) : this(elementType.ValidateNotNull(nameof(elementType)).CreateArrayType(count) , elementType , module , count , lowerBound ) { }
/// <summary>Constructs a new <see cref="DebugArrayType"/></summary> /// <param name="elementType">Type of elements in the array</param> /// <param name="module"><see cref="NativeModule"/> to use for the context of the debug information</param> /// <param name="count">Number of elements in the array</param> /// <param name="lowerBound"><see cref="LowerBound"/> value for the array indices [Default: 0]</param> public DebugArrayType(IDebugType <ITypeRef, DIType> elementType, NativeModule module, uint count, uint lowerBound = 0) : this(elementType.VerifyArgNotNull(nameof(elementType)).CreateArrayType(count) , elementType , module , count , lowerBound ) { }
/// <summary>Creates a FunctionType with Debug information</summary> /// <param name="diBuilder"><see cref="DebugInfoBuilder"/>to use to create the debug information</param> /// <param name="isVarArg">Flag to indicate if this function is variadic</param> /// <param name="retType">Return type of the function</param> /// <param name="argTypes">Argument types of the function</param> /// <returns>Function signature</returns> public DebugFunctionType CreateFunctionType(DebugInfoBuilder diBuilder , bool isVarArg , IDebugType <ITypeRef, DIType> retType , IEnumerable <IDebugType <ITypeRef, DIType> > argTypes ) { if (diBuilder == null) { throw new ArgumentNullException(nameof(diBuilder)); } if (!retType.HasDebugInfo( )) { throw new ArgumentNullException(nameof(retType), "Return type does not have debug information"); } var nativeArgTypes = new List <ITypeRef>( ); var debugArgTypes = new List <DIType>( ); var msg = new StringBuilder("One or more parameter types ar not valid:\n"); bool hasParamErrors = false; foreach (var indexedPair in argTypes.Select((t, i) => new { Type = t, Index = i })) { if (indexedPair.Type == null) { msg.AppendFormat("\tArgument {0} is null", indexedPair.Index); hasParamErrors = true; } else { nativeArgTypes.Add(indexedPair.Type.NativeType); debugArgTypes.Add(indexedPair.Type.DIType); if (indexedPair.Type.HasDebugInfo( )) { continue; } msg.AppendFormat("\tArgument {0} does not contain debug type information", indexedPair.Index); hasParamErrors = true; } } // if any parameters don't have errors, then provide a hopefully helpful message indicating which one(s) if (hasParamErrors) { throw new ArgumentException(msg.ToString( ), nameof(argTypes)); } var llvmType = GetFunctionType(retType.NativeType, nativeArgTypes, isVarArg); var diType = diBuilder.CreateSubroutineType(0, retType.DIType, debugArgTypes); Debug.Assert(diType != null && !diType.IsTemporary); return(new DebugFunctionType(llvmType, diType)); }
/// <summary>Constructs a new <see cref="DebugPointerType"/></summary> /// <param name="debugElementType">Debug type of the pointee</param> /// <param name="module"><see cref="NativeModule"/> used for creating the pointer type and debug information</param> /// <param name="addressSpace">Target address space for the pointer [Default: 0]</param> /// <param name="name">Name of the type [Default: null]</param> /// <param name="alignment">Alignment on pointer</param> public DebugPointerType(IDebugType <ITypeRef, DIType> debugElementType, NativeModule module, uint addressSpace = 0, string name = null, uint alignment = 0) : this(debugElementType.VerifyArgNotNull(nameof(debugElementType)).NativeType , module , debugElementType.VerifyArgNotNull(nameof(debugElementType)).DIType , addressSpace , name , alignment ) { }
/// <summary>Creates a FunctionType with Debug information</summary> /// <param name="diBuilder"><see cref="DebugInfoBuilder"/>to use to create the debug information</param> /// <param name="isVarArg">Flag to indicate if this function is variadic</param> /// <param name="retType">Return type of the function</param> /// <param name="argTypes">Argument types of the function</param> /// <returns>Function signature</returns> public DebugFunctionType CreateFunctionType(DebugInfoBuilder diBuilder , bool isVarArg , [ValidatedNotNull] IDebugType <ITypeRef, DIType> retType , [ValidatedNotNull] IEnumerable <IDebugType <ITypeRef, DIType> > argTypes ) { diBuilder.ValidateNotNull(nameof(diBuilder)); retType.ValidateNotNull(nameof(retType)); argTypes.ValidateNotNull(nameof(retType)); if (!retType.HasDebugInfo( )) { throw new ArgumentNullException(nameof(retType), Resources.Return_type_does_not_have_debug_information); } var nativeArgTypes = new List <ITypeRef>( ); var debugArgTypes = new List <DIType>( ); var msg = new StringBuilder(Resources.One_or_more_parameter_types_are_not_valid); bool hasParamErrors = false; foreach (var indexedPair in argTypes.Select((t, i) => new { Type = t, Index = i })) { if (indexedPair.Type == null) { msg.AppendFormat(CultureInfo.CurrentCulture, Resources.Argument_0_is_null, indexedPair.Index); hasParamErrors = true; } else { nativeArgTypes.Add(indexedPair.Type.NativeType); debugArgTypes.Add(indexedPair.Type.DIType); if (indexedPair.Type.HasDebugInfo( )) { continue; } msg.AppendFormat(CultureInfo.CurrentCulture, Resources.Argument_0_does_not_contain_debug_type_information, indexedPair.Index); hasParamErrors = true; } } // if any parameters have errors, then provide a hopefully helpful message indicating which one(s) if (hasParamErrors) { throw new ArgumentException(msg.ToString( ), nameof(argTypes)); } var llvmType = GetFunctionType(retType.NativeType, nativeArgTypes, isVarArg); var diType = diBuilder.CreateSubroutineType(0, retType.DIType, debugArgTypes); Debug.Assert(diType != null && !diType.IsTemporary, Resources.Assert_Should_have_a_valid_non_temp_type_by_now); return(new DebugFunctionType(llvmType, diType)); }
public virtual BaseProperty MakeProperty(IDebugFieldSymbol symbol, IDebugProperty parent, IDebugValue containerValue) { IDebugType staticType = symbol.Type; IDebugValue value = symbol.GetValue(containerValue); if (symbol.Name == "this value: ") { return(this.MakeProperty("this", symbol.Type, value, parent)); } return(this.MakeProperty(symbol.Name, symbol.Type, value, parent)); }
/// <summary>Creates a function</summary> /// <param name="name">Name of the function</param> /// <param name="isVarArg">Flag indicating if the function supports a variadic argument list</param> /// <param name="returnType">Return type of the function</param> /// <param name="argumentTypes">Arguments for the function</param> /// <returns> /// Function, matching the signature specified. This may be a previously declared or defined /// function or a new function if none matching the name and signature is already present. /// </returns> public Function CreateFunction(string name , bool isVarArg , IDebugType <ITypeRef, DIType> returnType , IEnumerable <IDebugType <ITypeRef, DIType> > argumentTypes ) { ValidateHandle( ); IFunctionType signature = Context.CreateFunctionType(DIBuilder, isVarArg, returnType, argumentTypes); return(AddFunction(name, signature)); }
public StructuralProperty(string name, IDebugType staticType, IDebugValue value, IDebugProperty parent, CommonExpressionEvaluator evaluator) : base(name, staticType, value, parent, evaluator) { if (this.value != null) { this.structuralType = this.value.RuntimeType() as IDebugStructuralType; } else { this.structuralType = staticType as IDebugStructuralType; } }
/// <summary>Initializes a new instance of the <see cref="DebugArrayType"/> class</summary> /// <param name="llvmType">Underlying LLVM array type to bind debug info to</param> /// <param name="elementType">Array element type with debug information</param> /// <param name="module">module to use for creating debug information</param> /// <param name="count">Number of elements in the array</param> /// <param name="lowerBound">Lower bound of the array [default = 0]</param> /// <param name="alignment">Alignment for the type</param> public DebugArrayType(IArrayType llvmType , IDebugType <ITypeRef, DIType> elementType , BitcodeModule module , uint count , uint lowerBound = 0 , uint alignment = 0 ) : base(llvmType, BuildDebugType(llvmType, elementType, module, count, lowerBound, alignment)) { elementType.ValidateNotNull(nameof(elementType)); elementType.DIType.ValidateNotNull($"{nameof( elementType )}.{nameof( elementType.DIType )}"); DebugElementType = elementType; }
// Implementation on IDebugValue public IDebugType RuntimeType() { IDebugType pRetVal = null; IDebugBinder binder = this.m_Context.Binder; if (null == this.m_RuntimeType) { binder.ResolveRuntimeType(this.m_Object, out this.m_RuntimeType); } if (null != this.m_RuntimeType) { pRetVal = SymbolHelper.DebugTypeFromField(this.m_RuntimeType, this.m_Context); } return(pRetVal); }
/// <summary>Initializes a new instance of the <see cref="DebugFunctionType"/> class.</summary> /// <param name="llvmType">Native LLVM function signature</param> /// <param name="module"><see cref="BitcodeModule"/> to use when construction debug information</param> /// <param name="debugFlags"><see cref="DebugInfoFlags"/> for this signature</param> /// <param name="retType">Return type for the function</param> /// <param name="argTypes">Potentially empty set of argument types for the signature</param> public DebugFunctionType(IFunctionType llvmType , BitcodeModule module , DebugInfoFlags debugFlags , IDebugType <ITypeRef, DIType> retType , params IDebugType <ITypeRef, DIType>[] argTypes ) : base(llvmType.ValidateNotNull(nameof(llvmType)) , module.ValidateNotNull(nameof(module)) .DIBuilder.CreateSubroutineType(debugFlags , retType.ValidateNotNull(nameof(retType)).DIType , argTypes.Select(t => t.DIType) ) ) { }
/// <summary>Initializes a new instance of the <see cref="DebugMemberInfo"/> class.</summary> /// <param name="index">Member index</param> /// <param name="name">Member name</param> /// <param name="file">File containing the declaration of the member</param> /// <param name="line">Line number containing the member</param> /// <param name="debugType">Debug type for the member</param> /// <param name="debugInfoFlags">Flags for the member</param> /// <param name="explicitLayout">Explicit layout information for this member, if any</param> public DebugMemberInfo(uint index , string name , DIFile?file , uint line , IDebugType <ITypeRef, DIType> debugType , DebugInfoFlags debugInfoFlags = DebugInfoFlags.None , DebugMemberLayout?explicitLayout = null ) { Index = index; Name = name; File = file; Line = line; DebugType = debugType; DebugInfoFlags = debugInfoFlags; ExplicitLayout = explicitLayout; }
private static DICompositeType CreateDebugInfoForArray(IArrayType llvmType , IDebugType <ITypeRef, DIType> elementType , BitcodeModule module , uint count , uint lowerBound , uint alignment ) { if (llvmType.IsSized) { return(module.DIBuilder.CreateArrayType(module.Layout.BitSizeOf(llvmType) , alignment , elementType.DIType , module.DIBuilder.CreateSubRange(lowerBound, count) )); } return(module.DIBuilder.CreateReplaceableCompositeType(Tag.ArrayType, string.Empty, module.DICompileUnit, null, 0)); }
/// <summary>Initializes a new instance of the <see cref="DebugArrayType"/> class</summary> /// <param name="llvmType">Underlying LLVM array type to bind debug info to</param> /// <param name="elementType">Array element type with debug information</param> /// <param name="module">module to use for creating debug information</param> /// <param name="count">Number of elements in the array</param> /// <param name="lowerBound">Lower bound of the array [default = 0]</param> /// <param name="alignment">Alignment for the type</param> public DebugArrayType(IArrayType llvmType , IDebugType <ITypeRef, DIType> elementType , BitcodeModule module , uint count , uint lowerBound = 0 , uint alignment = 0 ) : base(llvmType) { llvmType.ValidateNotNull(nameof(llvmType)); elementType.ValidateNotNull(nameof(elementType)); if (llvmType.ElementType.GetTypeRef() != elementType.GetTypeRef()) { throw new ArgumentException("elementType doesn't match array element type"); } DIType = CreateDebugInfoForArray(llvmType, elementType, module, count, lowerBound, alignment); DebugElementType = elementType; }
// Override these factory methods to create language specfic IDebugProperty implementations public virtual BaseProperty MakeProperty(string name, IDebugType staticType, IDebugValue value, IDebugProperty parent) { IDebugType type = null; if (value == null || value.IsNullReference() || staticType.Kind == TypeKind.Stream || staticType.Kind == TypeKind.FlexArray || staticType.Kind == TypeKind.Enum) { type = staticType; } else { type = value.RuntimeType(); } switch (type.Kind) { case TypeKind.Primitive: return(MakePrimitiveTypeProperty(name, staticType, value, parent)); case TypeKind.InnerClass: case TypeKind.Class: return(MakeClassProperty(name, staticType, value, parent)); case TypeKind.FlexArray: return(MakeFlexArrayProperty(name, staticType, value, parent)); case TypeKind.Tuple: return(MakeStructuralProperty(name, staticType, value, parent)); case TypeKind.Stream: return(MakeStreamProperty(name, staticType, value, parent)); case TypeKind.Array: return(MakeArrayProperty(name, staticType, value, parent)); case TypeKind.Enum: return(MakeEnumProperty(name, staticType, value, parent)); } return(null); }
private static Function DeclareCopyFunc(BitcodeModule module , DIFile diFile , IDebugType <ITypeRef, DIType> voidType , DIDerivedType constFoo , DebugPointerType fooPtr ) { // Since the first parameter is passed by value // using the pointer + alloca + memcopy pattern, the actual // source, and therefore debug, signature is NOT a pointer. // However, that usage would create a signature with two // pointers as the arguments, which doesn't match the source // To get the correct debug info signature this inserts an // explicit DebugType<> that overrides the default behavior // to pair the LLVM pointer type with the original source type. var copySig = module.Context.CreateFunctionType(module.DIBuilder , voidType , DebugType.Create(fooPtr, constFoo) , fooPtr ); var copyFunc = module.CreateFunction(scope: diFile , name: "copy" , linkageName: null , file: diFile , line: 11 , signature: copySig , isLocalToUnit: true , isDefinition: true , scopeLine: 14 , debugFlags: DebugInfoFlags.Prototyped , isOptimized: false ).Linkage(Linkage.Internal) // static function .AddAttributes(FunctionAttributeIndex.Function, AttributeKind.NoUnwind, AttributeKind.NoInline, AttributeKind.OptimizeNone) .AddAttributes(FunctionAttributeIndex.Function, TargetDependentAttributes); TargetDetails.AddABIAttributesForByValueStructure(copyFunc, 0); return(copyFunc); }
private static Function DeclareDoCopyFunc(BitcodeModule module, DIFile diFile, IDebugType <ITypeRef, DIType> voidType) { var doCopySig = module.Context.CreateFunctionType(module.DIBuilder, voidType); var doCopyFunc = module.CreateFunction(scope: diFile , name: "DoCopy" , linkageName: null , file: diFile , line: 23 , signature: doCopySig , isLocalToUnit: false , isDefinition: true , scopeLine: 24 , debugFlags: DebugInfoFlags.None , isOptimized: false ).AddAttributes(FunctionAttributeIndex.Function, AttributeKind.NoInline, AttributeKind.NoUnwind, AttributeKind.OptimizeNone) .AddAttributes(FunctionAttributeIndex.Function, TargetDependentAttributes); return(doCopyFunc); }
public void Reset() { this.m_Fields.Reset(); if (null != this.m_Current){ this.m_Current = null; } }
public virtual BaseProperty MakeFlexArrayProperty(string name, IDebugType staticType, IDebugValue value, IDebugProperty parent){ return new FlexArrayProperty(name, staticType, value, parent, this); }
public virtual BaseProperty MakeStructuralProperty(string name, IDebugType staticType, IDebugValue value, IDebugProperty parent){ return new StructuralProperty(name, staticType, value, parent, this); }
public virtual BaseProperty MakePrimitiveTypeProperty(string name, IDebugType staticType, IDebugValue value, IDebugProperty parent){ return new PrimitiveTypeProperty(name, staticType, value, parent, this); }
public IDebugValue CreateObjectNoConstructor(IDebugType type) { throw new Exception("Not implemented Yet"); }
internal EnumArrayIndices(IEnumDebugValues enumValues, IDebugType elementType, IDebugProperty parent, IDebugValue containerValue, CommonExpressionEvaluator evaluator){ this.enumValues = enumValues; this.elementType = elementType; this.parent = parent; this.containerValue = containerValue; this.index = 0; this.evaluator = evaluator; }
public TypeProperty(IDebugType type, IDebugProperty parent, IDebugValue containerValue, CommonExpressionEvaluator evaluator){ this.type = type; this.parent = parent; this.name = this.type.FullName; this.containerValue = containerValue; this.evaluator = evaluator; }
public EnumProperty(string name, IDebugType staticType, IDebugValue value, IDebugProperty parent, CommonExpressionEvaluator evaluator) : base(name, staticType, value, parent, evaluator){ this.enumType = value.RuntimeType() as IDebugEnumType; if (this.enumType == null) this.enumType = staticType as IDebugEnumType; }
public ArrayProperty(string name, IDebugType staticType, IDebugValue containerValue, IDebugProperty parent, CommonExpressionEvaluator evaluator) : base(name, staticType, containerValue, parent, evaluator){ arrayValue = (IDebugArrayValue)this.value; }
public bool MoveNext() { bool pRetVal = false; if (null != this.m_Current) { this.m_Current = null; } else { // Skip the first element this.m_Fields.Skip(1); } IDebugField field = null; IDebugField[] fields = new IDebugField[1]; int fetched = 0; this.m_Fields.Next(1, fields, out fetched); if (null != fields[0]){ field = fields[0]; IDebugType type = null; type = SymbolHelper.DebugTypeFromField(field, this.m_Context); if (null != type) { this.m_Current = type; pRetVal = true; } } return pRetVal; }
public BaseProperty(string name, IDebugType staticType, IDebugValue value, IDebugProperty parent, CommonExpressionEvaluator evaluator){ this.name = name; this.staticType = staticType; this.parent = parent; this.value = value; this.evaluator = evaluator; }
// Override these factory methods to create language specfic IDebugProperty implementations public virtual BaseProperty MakeProperty(string name, IDebugType staticType, IDebugValue value, IDebugProperty parent){ IDebugType type = null; if (value == null || value.IsNullReference() || staticType.Kind == TypeKind.Stream || staticType.Kind == TypeKind.FlexArray || staticType.Kind == TypeKind.Enum) type = staticType; else type = value.RuntimeType(); switch (type.Kind){ case TypeKind.Primitive: return MakePrimitiveTypeProperty(name, staticType, value, parent); case TypeKind.InnerClass: case TypeKind.Class: return MakeClassProperty(name, staticType, value, parent); case TypeKind.FlexArray: return MakeFlexArrayProperty(name, staticType, value, parent); case TypeKind.Tuple: return MakeStructuralProperty(name, staticType, value, parent); case TypeKind.Stream: return MakeStreamProperty(name, staticType, value, parent); case TypeKind.Array: return MakeArrayProperty(name, staticType, value, parent); case TypeKind.Enum: return MakeEnumProperty(name, staticType, value, parent); } return null; }
public StructuralProperty(string name, IDebugType staticType, IDebugValue value, IDebugProperty parent, CommonExpressionEvaluator evaluator) : base(name, staticType, value, parent, evaluator){ if (this.value != null) this.structuralType = this.value.RuntimeType() as IDebugStructuralType; else this.structuralType = staticType as IDebugStructuralType; }
public FlexArrayProperty(string name, IDebugType staticType, IDebugValue value, IDebugProperty parent, CommonExpressionEvaluator evaluator) : base(name, staticType, value, parent, evaluator){ }
public CEnumDebugTypes(IEnumDebugFields fields, IDebugContext context) { this.m_Fields = fields; this.m_Context = context; this.m_Current = null; }