Bit-Fields in Structs + Code-Analysis

  • C#

Es gibt 7 Antworten in diesem Thema. Der letzte Beitrag () ist von Facebamm.

    Bit-Fields in Structs + Code-Analysis

    Hallo :D

    Ich bin gerade dabei mal wieder etwas aus C++ in C# zu Binden und bin auf das Problem gestoßen des Bit-Fields in C#

    Normal kann ich via masken und shiften mein Bits an die Stelle setzten wo ich will.
    Nun bin ich kein Fan von hin und herschieben magischer werten die am Ende irendwo sitzen, sonden würde dem Ganzen gern einen Namen geben wie in C++

    C-Quellcode

    1. typedef struct tTest {
    2. uint32_t Name1: 1;
    3. uint32_t Name2: 1;
    4. uint32_t Name3: 1;
    5. } Test;



    Mein erster gedanke war: ich bauche ein "struct".

    C#-Quellcode

    1. [StructLayout(LayoutKind.Explicit, Size = sizeof(int), Pack = 1)]
    2. struct Example
    3. {
    4. [FieldOffset(0)]
    5. public int BitOne;
    6. [FieldOffset(0)]
    7. public int BitTwo;
    8. [FieldOffset(0)]
    9. public int BitThree;
    10. }


    Nun bin ich kein Fan von Properties in Structs.
    So googelte ich etwas und fand (github.com/dotnet/csharplang/discussions/465) eine Feature request zu den ganzen Thema.
    Enttäuschent musste ich festellen, das dieses nicht existiert :/

    Also Kam ich zu diesen projekt codeproject.com/Articles/10955…ld-in-Csharp-using-struct
    Was eig cool ist aber, ich kann nicht vom endnutzer verlangen das er Konvertierungsmethoden aufrufen soll.

    Zum eig.!!

    Ich hab das ganze Projekt etwas kleiner gemacht (im ersten sinne)(Sieh unten) und würde/bin dabei ein Code-Analysis mit Code-Fix zu schreiben.

    Heißt: Ich durch suche mein QuellCode nach Structs welche Member mit dem Attributs "FieldOffset" und "BitFieldInfo" haben.
    Wenn das fertig ist, starte ich ein Tracking der Structs.
    Schau wo die Structs deklariet werden und ermittel den Scope.
    Schau im Scope nach weiteren aufrufen und nach Inits.
    Sollte ich ein Init finden würde ich per Code-Fix die Anweisung umschreiben in e.g.:

    Quellcode

    1. input = 1;
    2. Example1.BitTwo = input wird zu Example1.BitTwo = (Example1.BitTwo & ~(0b11 << 1)) | ((input & 0b11) << 1);
    3. Bit-Scope: (Example1.BitTwo & ~(0b11 << 1)) => 0b00000]XX[0


    Was haltet ihr davon oder würdet ihr was anders machen?

    Spoiler anzeigen

    C#-Quellcode

    1. /// <summary>
    2. /// Specifies the length of each bit field
    3. /// </summary>
    4. [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
    5. public sealed class BitFieldInfoAttribute : Attribute
    6. {
    7. /// <summary>
    8. /// Initializes new instance of BitFieldInfoAttribute with the specified field offset and length
    9. /// </summary>
    10. /// <param name="offset">The offset of the bit field</param>
    11. /// <param name="length">The number of bits the bit field occupies</param>
    12. public BitFieldInfoAttribute(byte offset, byte length){}
    13. }
    15. [StructLayout(LayoutKind.Explicit, Size = sizeof(int), Pack = 1)]
    16. struct Example
    17. {
    18. [FieldOffset(0)]
    19. [BitFieldInfo(0, 1)]
    20. public int BitOne;
    21. [FieldOffset(0)]
    22. [BitFieldInfo(1, 2)]
    23. public int BitTwo;
    24. [FieldOffset(0)]
    25. [BitFieldInfo(3, 1)]
    26. public int BitThree;
    27. }

    Schwieriges Thema. Ich glaube wenn es um .Net 5 geht, dann würde ich mir mit Code-Generatoren Properties in den Structs generieren lassen. Aber da du schon geschrieben hast:

    Facebamm schrieb:

    Nun bin ich kein Fan von Properties in Structs.
    fallen glaube ich schon viele optionen weg?

    so, da kommt jetzt mal nen update :D

    problem besteht:
    a) ich support noch nicht alle fälle
    b) ich weiß nicht wie ich meinen neuen SyntaxTree zum compiler schicke, bzw. ob ich das richtige module nutz

    Beispiel:
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Runtime.InteropServices;
    3. /// <summary>
    4. /// Specifies the length of each bit field
    5. /// </summary>
    6. [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
    7. public sealed class BitFieldInfoAttribute : Attribute
    8. {
    9. /// <summary>
    10. /// Initializes new instance of BitFieldInfoAttribute with the specified field offset and length
    11. /// </summary>
    12. /// <param name=""offset"">The offset of the bit field</param>
    13. /// <param name=""length"">The number of bits the bit field occupies</param>
    14. public BitFieldInfoAttribute(byte offset, byte length)
    15. {
    16. Offset = offset;
    17. Length = length;
    18. }
    20. /// <summary>
    21. /// The offset of the bit field
    22. /// </summary>
    23. public byte Offset { get; private set; }
    25. /// <summary>
    26. /// The number of bits the bit field occupies
    27. /// </summary>
    28. public byte Length { get; private set; }
    29. }
    31. [StructLayout(LayoutKind.Explicit, Size = sizeof(int), Pack = 1)]
    32. struct StructName
    33. {
    34. [FieldOffset(0)]
    35. public int One;
    36. [FieldOffset(0)]
    37. [BitFieldInfo(2, 2)]
    38. public int Two;
    39. [FieldOffset(0)]
    40. [BitFieldInfo(4, 1)]
    41. public int Three;
    42. }
    44. class Program
    45. {
    46. static void Main(string[] args)
    47. {
    48. StructName stName;
    49. stName.One = 1;
    50. stName.Two = 2 << 1;
    51. stName.Three = 1;
    52. }
    53. }


    DiagnosticAnalyzer:
    Spoiler anzeigen

    C#-Quellcode

    1. [DiagnosticAnalyzer(LanguageNames.CSharp)]
    2. public class BitFieldFixAnalyzer : DiagnosticAnalyzer
    3. {
    4. public const string DiagnosticId = "BitFieldFix";
    5. private const string Category = "Category";
    7. //TODO: Later
    8. private static readonly LocalizableString Title = "Title";
    9. private static readonly LocalizableString MessageFormat = "MessageFormat";
    10. private static readonly LocalizableString Description = "Description";
    12. private static readonly DiagnosticDescriptor Rule
    13. = new DiagnosticDescriptor(
    14. DiagnosticId,
    15. Title,
    16. MessageFormat,
    17. Category,
    18. DiagnosticSeverity.Warning,
    19. true,
    20. Description);
    22. public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
    23. {
    24. get { return ImmutableArray.Create(Rule); }
    25. }
    27. public override void Initialize(AnalysisContext context)
    28. {
    29. context.RegisterCompilationStartAction(AnalyzeNodeCompile);
    30. }
    32. private void AnalyzeNodeCompile(CompilationStartAnalysisContext context)
    33. {
    34. IEnumerable<SyntaxTree> syntaxTree = context.Compilation.SyntaxTrees;
    36. var compilation = CSharpCompilation.Create(context.Compilation.AssemblyName)
    37. .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
    38. .AddSyntaxTrees(syntaxTree);
    40. var syntaxTrees = context.Compilation.SyntaxTrees.ToArray();
    41. foreach (SyntaxTree tree in syntaxTrees)
    42. {
    43. var root = tree.GetRoot();
    44. var semantic = compilation.GetSemanticModel(tree);
    46. var bitFieldMemberWalker = new BitFieldMemberWalker(semantic);
    47. bitFieldMemberWalker.Visit(root);
    48. ;
    49. var rewriter = new SyntaxRewriter(semantic, bitFieldMemberWalker);
    50. var newRoot = rewriter.Visit(root);
    52. var newTree = SyntaxFactory.SyntaxTree(newRoot);
    54. context.Compilation.ReplaceSyntaxTree(tree, newTree);
    56. }
    57. }
    58. }
    60. internal class BitFieldMemberWalker : CSharpSyntaxWalker
    61. {
    62. private const string ATTRIBUTE_BITFIELDINFO = "BitFieldInfo";
    64. private readonly SemanticModel _semantic;
    65. public List<BitFieldDescription> BitFieldDescriptions { get; }
    66. public bool HasBitFields { get => BitFieldDescriptions.Any(); }
    68. public BitFieldMemberWalker(SemanticModel semantic)
    69. : base(SyntaxWalkerDepth.Node)
    70. {
    71. _semantic = semantic;
    72. BitFieldDescriptions = new List<BitFieldDescription>();
    73. }
    75. public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
    76. {
    77. //pre compile
    78. var attributes = node.AttributeLists.SelectMany(attrs => attrs.Attributes).ToArray();
    79. var bitFieldInfo = attributes.FirstOrDefault(x => x.Name.GetText().ToString().Equals(ATTRIBUTE_BITFIELDINFO));
    81. if (bitFieldInfo != null)
    82. {
    83. var args = bitFieldInfo.ArgumentList.Arguments;
    84. foreach (VariableDeclaratorSyntax variable in node.Declaration.Variables)
    85. {
    86. BitFieldDescription bitFieldDescription = new BitFieldDescription
    87. {
    88. DeclaredSymbol = _semantic.GetDeclaredSymbol(variable),
    89. MemberName = variable.ToString(),
    90. BitOffset = int.Parse(args[0].ToString()),
    91. BitCount = int.Parse(args[1].ToString())
    92. };
    94. BitFieldDescriptions.Add(bitFieldDescription);
    95. }
    96. }
    98. base.VisitFieldDeclaration(node);
    99. }
    100. }
    102. internal class SyntaxRewriter : CSharpSyntaxRewriter
    103. {
    104. private const string ATTRIBUTE_BITFIELDINFO = "BitFieldInfoAttribute";
    105. private readonly SemanticModel _semanticModel;
    106. private readonly BitFieldMemberWalker _bitFieldMemberWalker;
    107. public SyntaxRewriter(SemanticModel semanticModel, BitFieldMemberWalker bitFieldMemberWalker)
    108. {
    109. _semanticModel = semanticModel;
    110. _bitFieldMemberWalker = bitFieldMemberWalker;
    111. }
    113. public override SyntaxNode VisitAssignmentExpression(AssignmentExpressionSyntax node)
    114. {
    115. var left = node.Left;
    116. var right = node.Right;
    117. if (left is MemberAccessExpressionSyntax memberAccess)
    118. {
    119. var member = memberAccess.DescendantNodes().OfType<IdentifierNameSyntax>().Last();
    121. var leftType = _semanticModel.GetSymbolInfo(member).Symbol;
    122. var bitFieldDescription = _bitFieldMemberWalker.BitFieldDescriptions.FirstOrDefault(x => x.DeclaredSymbol.Equals(leftType));
    124. if (bitFieldDescription != null)
    125. {
    126. return SyntaxFactory.AssignmentExpression(
    127. node.Kind(),
    128. left,
    129. SyntaxFactory.BinaryExpression(
    130. SyntaxKind.LeftShiftExpression,
    131. SyntaxFactory.ParenthesizedExpression(
    132. SyntaxFactory.BinaryExpression(
    133. SyntaxKind.BitwiseAndExpression,
    134. SyntaxFactory.ParenthesizedExpression(
    135. right),
    136. SyntaxFactory.LiteralExpression(
    137. SyntaxKind.NumericLiteralExpression,
    138. SyntaxFactory.ParseToken(bitFieldDescription.GetMaskValue.ToString())))),
    139. SyntaxFactory.LiteralExpression(
    140. SyntaxKind.NumericLiteralExpression,
    141. SyntaxFactory.ParseToken(bitFieldDescription.BitOffset.ToString())))
    142. ).NormalizeWhitespace();
    143. }
    144. }
    146. return base.VisitAssignmentExpression(node);
    147. }
    148. }
    150. internal class BitFieldDescription
    151. {
    152. public ISymbol DeclaredSymbol;
    153. public string MemberName;
    154. public int BitOffset;
    155. public int BitCount;
    157. public int GetMaskValue => F(BitCount);
    159. private int F(int x)
    160. {
    161. if (x > 1)
    162. {
    163. return (F(x - 1) << 1) + 1;
    164. }
    166. return 1;
    167. }
    168. }

    @Facebamm Ich werfe mal [Flag] Enum in den Raum.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Ja, natürlich kann ich via Flags das ganze aufbauen aber dann muss ich mir immer alles selber zusammen bauen und auslesen,
    so kann ich meinem BitFeld gleich nen namen geben und die einzelnen bits auslesen (beim auslesen bin ich aber noch nicht)

    Also es ist leichter zu hand haben

    Facebamm schrieb:

    Also es ist leichter zu hand haben
    Mit .HasFlag(...) kannst Du einzelne Bits und Gruppen von Bits auslesen ...
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    ja schon richtig!
    Aber ist dock kacke.

    Wenn ich ein Byte beschreiben will für den End-User, dann muss er dämlich Enum-"Items" verodern ...
    oder er bekommt eine Zahl (int) und soll da die Bits auslesen.
    Ist doch kacke!
    Erst recht wenn wir von API's reden und die ins Binary umwandeln wollen.

Facebook
Telefonspende