22021596307

Committed 14 Feb 2026 05:41PM UTC coverage: 34.555% (+0.2%) from 34.4%

Build # 22021596307

Build Type

push

github

Committed by

SamboyCoding

Commit Message

Lib: Support v35, v38, v39

Run Details

1847 of 6675 branches covered (27.67%)

Branch coverage included in aggregate %.

281 of 350 new or added lines in 34 files covered. (80.29%)

1 existing line in 1 file now uncovered.

4252 of 10975 relevant lines covered (38.74%)

219034.19 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

33.33

/Cpp2IL.Core/Model/CustomAttributes/CustomAttributeArrayParameter.cs

using System.Collections.Generic;
using System.IO;
using System.Linq;
using Cpp2IL.Core.Extensions;
using Cpp2IL.Core.Model.Contexts;
using Cpp2IL.Core.Utils;
using LibCpp2IL.BinaryStructures;
using LibCpp2IL.Metadata;

namespace Cpp2IL.Core.Model.CustomAttributes;

/// <summary>
/// Represents a custom attribute parameter which is an array of other parameters, which can themselves potentially be arrays, enums, etc.
///
/// When parsing this, first check IsNullArray - if it's true, emit a null and continue.
///
/// Then check EnumType - if it's non-null, it means this is an enum array, not a simple primitive array, and the type of the enum should be used when emitting.
///
/// If it's null, use ArrType to determine the type of the array, which will be a primitive, string, or type.
///
/// Then read the ArrayElements list and output each one. Remember to type-prefix if ArrType is Object.
/// </summary>
public class CustomAttributeArrayParameter(AnalyzedCustomAttribute owner, CustomAttributeParameterKind kind, int index)
    : BaseCustomAttributeParameter(owner, kind, index)
{
    public bool IsNullArray;
    public Il2CppType? EnumType;

    public Il2CppTypeEnum ArrType;

    public List<BaseCustomAttributeParameter> ArrayElements = [];

    public override void ReadFromV29Blob(BinaryReader reader, ApplicationAnalysisContext context)
    {
        var arrLength = reader.BaseStream.ReadUnityCompressedInt();
        if (arrLength == -1)
        {
            //Array length is -1 when the array itself is null
            IsNullArray = true;
            return;
        }

        ArrType = (Il2CppTypeEnum)reader.ReadByte();
        if (ArrType == Il2CppTypeEnum.IL2CPP_TYPE_ENUM)
        {
            var enumTypeIndex = reader.BaseStream.ReadUnityCompressedInt();

            //Save the actual enum type for later.
            EnumType = context.Binary.GetType(Il2CppVariableWidthIndex<Il2CppType>.MakeTemporaryForFixedWidthUsage(enumTypeIndex)); //DynWidth: enumTypeIndex is already compressed, they didn't make it dynamic

            //We read as the primitive underlying type.
            var enumClass = EnumType.AsClass();
            ArrType = enumClass.EnumUnderlyingType.Type;
        }

        var arrayElementsAreTypePrefixed = reader.ReadBoolean();

        if (arrayElementsAreTypePrefixed && ArrType != Il2CppTypeEnum.IL2CPP_TYPE_OBJECT)
            throw new("Array elements are type-prefixed, but the array type is not object");

        for (var i = 0; i < arrLength; i++)
        {
            var thisType = ArrType;

            if (arrayElementsAreTypePrefixed)
                thisType = (Il2CppTypeEnum)reader.ReadByte();

            //ConstructParameterForType will handle reading the enum type
            var arrayElement = V29AttributeUtils.ConstructParameterForType(reader, context, thisType, Owner, CustomAttributeParameterKind.ArrayElement, i);

            arrayElement.ReadFromV29Blob(reader, context);

            ArrayElements.Add(arrayElement);
        }
    }

    public override string ToString()
    {
        if (IsNullArray)
            return "(array) null";

        var arrType = ArrType.ToString();
        if (EnumType != null)
            arrType = EnumType.AsClass().ToString();

        return $"new {arrType}[] {{{string.Join(", ", ArrayElements.Select(x => x.ToString()))}}}";
    }
}

1	using System.Collections.Generic;
2	using System.IO;
3	using System.Linq;
4	using Cpp2IL.Core.Extensions;
5	using Cpp2IL.Core.Model.Contexts;
6	using Cpp2IL.Core.Utils;
7	using LibCpp2IL.BinaryStructures;
8	using LibCpp2IL.Metadata;
9
10	namespace Cpp2IL.Core.Model.CustomAttributes;
11
12	/// <summary>
13	/// Represents a custom attribute parameter which is an array of other parameters, which can themselves potentially be arrays, enums, etc.
14	///
15	/// When parsing this, first check IsNullArray - if it's true, emit a null and continue.
16	///
17	/// Then check EnumType - if it's non-null, it means this is an enum array, not a simple primitive array, and the type of the enum should be used when emitting.
18	///
19	/// If it's null, use ArrType to determine the type of the array, which will be a primitive, string, or type.
20	///
21	/// Then read the ArrayElements list and output each one. Remember to type-prefix if ArrType is Object.
22	/// </summary>
23	public class CustomAttributeArrayParameter(AnalyzedCustomAttribute owner, CustomAttributeParameterKind kind, int index)
24	: BaseCustomAttributeParameter(owner, kind, index)	1✔
25	{
26	public bool IsNullArray;
27	public Il2CppType? EnumType;
28
29	public Il2CppTypeEnum ArrType;
30
31	public List<BaseCustomAttributeParameter> ArrayElements = [];	1✔
32
33	public override void ReadFromV29Blob(BinaryReader reader, ApplicationAnalysisContext context)
34	{
35	var arrLength = reader.BaseStream.ReadUnityCompressedInt();	1✔
36	if (arrLength == -1)	1!
37	{
38	//Array length is -1 when the array itself is null
39	IsNullArray = true;	×
40	return;	×
41	}
42
43	ArrType = (Il2CppTypeEnum)reader.ReadByte();	1✔
44	if (ArrType == Il2CppTypeEnum.IL2CPP_TYPE_ENUM)	1!
45	{
46	var enumTypeIndex = reader.BaseStream.ReadUnityCompressedInt();	×
47
48	//Save the actual enum type for later.
NEW 49	EnumType = context.Binary.GetType(Il2CppVariableWidthIndex<Il2CppType>.MakeTemporaryForFixedWidthUsage(enumTypeIndex)); //DynWidth: enumTypeIndex is already compressed, they didn't make it dynamic	×
50
51	//We read as the primitive underlying type.
52	var enumClass = EnumType.AsClass();	×
53	ArrType = enumClass.EnumUnderlyingType.Type;	×
54	}
55
56	var arrayElementsAreTypePrefixed = reader.ReadBoolean();	1✔
57
58	if (arrayElementsAreTypePrefixed && ArrType != Il2CppTypeEnum.IL2CPP_TYPE_OBJECT)	1!
59	throw new("Array elements are type-prefixed, but the array type is not object");	×
60
61	for (var i = 0; i < arrLength; i++)	2!
62	{
63	var thisType = ArrType;	×
64
65	if (arrayElementsAreTypePrefixed)	×
66	thisType = (Il2CppTypeEnum)reader.ReadByte();	×
67
68	//ConstructParameterForType will handle reading the enum type
69	var arrayElement = V29AttributeUtils.ConstructParameterForType(reader, context, thisType, Owner, CustomAttributeParameterKind.ArrayElement, i);	×
70
71	arrayElement.ReadFromV29Blob(reader, context);	×
72
73	ArrayElements.Add(arrayElement);	×
74	}
75	}	1✔
76
77	public override string ToString()
78	{
79	if (IsNullArray)	×
80	return "(array) null";	×
81
82	var arrType = ArrType.ToString();	×
83	if (EnumType != null)	×
84	arrType = EnumType.AsClass().ToString();	×
85
86	return $"new {arrType}[] {{{string.Join(", ", ArrayElements.Select(x => x.ToString()))}}}";	×
87	}
88	}

SamboyCoding / Cpp2IL / 22021596307

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous