c-next 0.2.2 → 0.2.3

package/src/transpiler/output/codegen/helpers/FloatBitHelper.ts

@@ -1,14 +1,17 @@
 /**
- * FloatBitHelper - Generates float bit write operations using shadow variables
+ * FloatBitHelper - Generates float bit write operations using union-based type punning
  *
  * Issue #644: Extracted from CodeGenerator to reduce file size.
+ * Issue #857: Changed from memcpy to union for MISRA C:2012 Rule 21.15 compliance.
  *
- * Floats don't support direct bit access in C, so we use a shadow integer
- * variable and memcpy to read/write bit values. The pattern:
- *   1. Declare shadow variable if needed
- *   2. memcpy float → shadow (if not already current)
- *   3. Modify shadow bits
- *   4. memcpy shadow → float
+ * Floats don't support direct bit access in C, so we use a union for type punning.
+ * The pattern:
+ *   1. Declare union variable if needed: union { float f; uint32_t u; } __bits_name;
+ *   2. Copy float to union: __bits_name.f = floatVar;
+ *   3. Modify bits via union member: __bits_name.u = ...
+ *   4. Copy back: floatVar = __bits_name.f;
+ *
+ * This approach is MISRA-compliant because union type punning is well-defined in C99+.
  *
  * Migrated to use CodeGenState instead of constructor DI.
  */
@@ -30,16 +33,25 @@ interface IFloatBitCallbacks {
 }
 
 /**
- * Generates float bit write operations using shadow variables and memcpy.
+ * Get the C float type name for a C-Next float type.
+ */
+const getFloatTypeName = (baseType: string): string => {
+  return baseType === "f64" ? "double" : "float";
+};
+
+/**
+ * Generates float bit write operations using union-based type punning.
  *
  * For single bit: width is null, uses bitIndex only
  * For bit range: width is provided, uses bitIndex as start position
  */
 class FloatBitHelper {
   /**
-   * Generate float bit write using shadow variable + memcpy.
+   * Generate float bit write using union-based type punning.
    * Returns null if typeInfo is not a float type.
    *
+   * Uses union { float f; uint32_t u; } for MISRA 21.15 compliance instead of memcpy.
+   *
    * @param name - Variable name being written
    * @param typeInfo - Type information for the variable
    * @param bitIndex - Bit index expression (start position)
@@ -62,11 +74,11 @@ class FloatBitHelper {
       return null;
     }
 
-    callbacks.requireInclude("string"); // For memcpy
     callbacks.requireInclude("float_static_assert"); // For size verification
 
     const isF64 = typeInfo.baseType === "f64";
-    const shadowType = isF64 ? "uint64_t" : "uint32_t";
+    const floatType = getFloatTypeName(typeInfo.baseType);
+    const intType = isF64 ? "uint64_t" : "uint32_t";
     const shadowName = `__bits_${name}`;
     const maskSuffix = isF64 ? "ULL" : "U";
 
@@ -76,13 +88,15 @@ class FloatBitHelper {
       CodeGenState.floatBitShadows.add(shadowName);
     }
 
-    // Check if shadow already has current value (skip redundant memcpy read)
+    // Check if shadow already has current value (skip redundant read)
     const shadowIsCurrent = CodeGenState.floatShadowCurrent.has(shadowName);
 
-    const decl = needsDeclaration ? `${shadowType} ${shadowName}; ` : "";
-    const readMemcpy = shadowIsCurrent
-      ? ""
-      : `memcpy(&${shadowName}, &${name}, sizeof(${name})); `;
+    // Union declaration: union { float f; uint32_t u; } __bits_name;
+    const decl = needsDeclaration
+      ? `union { ${floatType} f; ${intType} u; } ${shadowName};\n`
+      : "";
+    // Read from float into union: __bits_name.f = floatVar;
+    const readUnion = shadowIsCurrent ? "" : `${shadowName}.f = ${name};\n`;
 
     // Mark shadow as current after this write
     CodeGenState.floatShadowCurrent.add(shadowName);
@@ -90,17 +104,17 @@ class FloatBitHelper {
     if (width === null) {
       // Single bit assignment: floatVar[3] <- true
       return (
-        `${decl}${readMemcpy}` +
-        `${shadowName} = (${shadowName} & ~(1${maskSuffix} << ${bitIndex})) | ((${shadowType})${callbacks.foldBooleanToInt(value)} << ${bitIndex}); ` +
-        `memcpy(&${name}, &${shadowName}, sizeof(${name}));`
+        `${decl}${readUnion}` +
+        `${shadowName}.u = (${shadowName}.u & ~(1${maskSuffix} << ${bitIndex})) | ((${intType})${callbacks.foldBooleanToInt(value)} << ${bitIndex});\n` +
+        `${name} = ${shadowName}.f;`
       );
     } else {
       // Bit range assignment: floatVar[0, 8] <- b0
       const mask = callbacks.generateBitMask(width, isF64);
       return (
-        `${decl}${readMemcpy}` +
-        `${shadowName} = (${shadowName} & ~(${mask} << ${bitIndex})) | (((${shadowType})${value} & ${mask}) << ${bitIndex}); ` +
-        `memcpy(&${name}, &${shadowName}, sizeof(${name}));`
+        `${decl}${readUnion}` +
+        `${shadowName}.u = (${shadowName}.u & ~(${mask} << ${bitIndex})) | (((${intType})${value} & ${mask}) << ${bitIndex});\n` +
+        `${name} = ${shadowName}.f;`
       );
     }
   }

package/src/transpiler/output/codegen/helpers/__tests__/ArrayAccessHelper.test.ts

@@ -243,7 +243,7 @@ describe("ArrayAccessHelper", () => {
       expect(mockDeps.generateBitMask).toHaveBeenCalledWith("8");
     });
 
-    it("should route to float bit range for f32", () => {
+    it("should route to float bit range for f32 (no string.h needed)", () => {
       const info: IArrayAccessInfo = {
         rawName: "fval",
         resolvedName: "fval",
@@ -260,8 +260,9 @@ describe("ArrayAccessHelper", () => {
       };
 
       const result = ArrayAccessHelper.generateBitRange(info, mockDeps);
-      expect(result).toContain("memcpy");
-      expect(mockDeps.requireInclude).toHaveBeenCalledWith("string");
+      expect(result).toContain("__bits_fval");
+      // No string.h - uses union-based type punning (MISRA 21.15 compliant)
+      expect(mockDeps.requireInclude).not.toHaveBeenCalledWith("string");
       expect(mockDeps.requireInclude).toHaveBeenCalledWith(
         "float_static_assert",
       );
@@ -356,9 +357,10 @@ describe("ArrayAccessHelper", () => {
 
       const result = ArrayAccessHelper.generateFloatBitRange(info, mockDeps);
 
-      expect(result).toContain("memcpy(&__bits_fval, &fval, sizeof(fval))");
-      expect(result).toContain("__bits_fval & 0xFF");
-      expect(mockDeps.requireInclude).toHaveBeenCalledWith("string");
+      // Note: BitRangeHelper.buildFloatBitReadExpr still uses memcpy internally,
+      // but ArrayAccessHelper no longer requires string.h (MISRA 21.15 compliant)
+      expect(result).toContain("__bits_fval");
+      expect(mockDeps.requireInclude).not.toHaveBeenCalledWith("string");
       expect(mockDeps.requireInclude).toHaveBeenCalledWith(
         "float_static_assert",
       );

package/src/transpiler/output/codegen/helpers/__tests__/FloatBitHelper.test.ts

@@ -2,6 +2,7 @@
  * Unit tests for FloatBitHelper
  *
  * Issue #644: Tests for the extracted float bit write helper.
+ * Issue #857: Updated for union-based type punning (MISRA 21.15 compliance).
  * Migrated to use CodeGenState instead of constructor DI.
  */
 
@@ -57,7 +58,7 @@ describe("FloatBitHelper", () => {
       expect(callbacks.requireInclude).not.toHaveBeenCalled();
     });
 
-    it("generates single bit write for f32", () => {
+    it("generates single bit write for f32 using union", () => {
       const typeInfo: TTypeInfo = {
         baseType: "f32",
         bitWidth: 32,
@@ -74,17 +75,27 @@ describe("FloatBitHelper", () => {
         callbacks,
       );
 
-      expect(result).toContain("uint32_t __bits_myFloat;");
-      expect(result).toContain("memcpy(&__bits_myFloat, &myFloat");
-      expect(result).toContain("& ~(1U << 3)");
-      expect(result).toContain("memcpy(&myFloat, &__bits_myFloat");
-      expect(callbacks.requireInclude).toHaveBeenCalledWith("string");
+      // Union declaration
+      expect(result).toContain(
+        "union { float f; uint32_t u; } __bits_myFloat;",
+      );
+      // Read via union
+      expect(result).toContain("__bits_myFloat.f = myFloat;");
+      // Bit manipulation via .u
+      expect(result).toContain(
+        "__bits_myFloat.u = (__bits_myFloat.u & ~(1U << 3))",
+      );
+      // Write back via union
+      expect(result).toContain("myFloat = __bits_myFloat.f;");
+      // No memcpy for MISRA compliance
+      expect(result).not.toContain("memcpy");
+      expect(callbacks.requireInclude).not.toHaveBeenCalledWith("string");
       expect(callbacks.requireInclude).toHaveBeenCalledWith(
         "float_static_assert",
       );
     });
 
-    it("generates single bit write for f64", () => {
+    it("generates single bit write for f64 using union", () => {
       const typeInfo: TTypeInfo = {
         baseType: "f64",
         bitWidth: 64,
@@ -101,11 +112,13 @@ describe("FloatBitHelper", () => {
         callbacks,
       );
 
-      expect(result).toContain("uint64_t __bits_myDouble;");
+      expect(result).toContain(
+        "union { double f; uint64_t u; } __bits_myDouble;",
+      );
       expect(result).toContain("1ULL << 5");
     });
 
-    it("generates bit range write for f32", () => {
+    it("generates bit range write for f32 using union", () => {
       const typeInfo: TTypeInfo = {
         baseType: "f32",
         bitWidth: 32,
@@ -122,11 +135,13 @@ describe("FloatBitHelper", () => {
         callbacks,
       );
 
-      expect(result).toContain("uint32_t __bits_myFloat;");
+      expect(result).toContain(
+        "union { float f; uint32_t u; } __bits_myFloat;",
+      );
       expect(callbacks.generateBitMask).toHaveBeenCalledWith("8", false);
     });
 
-    it("skips declaration when shadow already exists", () => {
+    it("skips union declaration when shadow already exists", () => {
       const typeInfo: TTypeInfo = {
         baseType: "f32",
         bitWidth: 32,
@@ -146,11 +161,11 @@ describe("FloatBitHelper", () => {
         callbacks,
       );
 
-      expect(result).not.toContain("uint32_t __bits_myFloat;");
-      expect(result).toContain("memcpy(&__bits_myFloat");
+      expect(result).not.toContain("union { float f; uint32_t u; }");
+      expect(result).toContain("__bits_myFloat.f = myFloat;");
     });
 
-    it("skips redundant memcpy read when shadow is current", () => {
+    it("skips redundant union read when shadow is current", () => {
       const typeInfo: TTypeInfo = {
         baseType: "f32",
         bitWidth: 32,
@@ -171,10 +186,11 @@ describe("FloatBitHelper", () => {
         callbacks,
       );
 
-      expect(result).not.toContain("uint32_t __bits_myFloat;");
-      // Should not have read memcpy, only write memcpy
-      const memcpyMatches = result!.match(/memcpy/g);
-      expect(memcpyMatches).toHaveLength(1);
+      expect(result).not.toContain("union { float f; uint32_t u; }");
+      // Should not have the read assignment, only the write-back
+      expect(result).not.toContain("__bits_myFloat.f = myFloat;");
+      // Should still have the write-back
+      expect(result).toContain("myFloat = __bits_myFloat.f;");
     });
 
     it("marks shadow as current after write", () => {