c-next 0.2.2 → 0.2.3

package/dist/index.js

@@ -10,7 +10,7 @@ import { hideBin } from "yargs/helpers";
 // package.json
 var package_default = {
   name: "c-next",
-  version: "0.2.2",
+  version: "0.2.3",
   description: "A safer C for embedded systems development. Transpiles to clean, readable C.",
   packageManager: "npm@11.9.0",
   type: "module",
@@ -116790,37 +116790,37 @@ var handleBitRangeSubscript = (ctx, exprs, input, state, orchestrator, effects,
   }
   return output;
 };
+var getFloatTypeName = (baseType) => {
+  return baseType === "f64" ? "double" : "float";
+};
 var handleFloatBitRange = (ctx, state, orchestrator, effects) => {
   if (!state.inFunctionBody) {
     throw new Error(
       `Float bit indexing reads (${ctx.rootIdentifier}[${ctx.start}, ${ctx.width}]) cannot be used at global scope.`
     );
   }
-  effects.push(
-    { type: "include", header: "string" },
-    { type: "include", header: "float_static_assert" }
-  );
+  effects.push({ type: "include", header: "float_static_assert" });
   const isF64 = ctx.baseType === "f64";
-  const shadowType = isF64 ? "uint64_t" : "uint32_t";
+  const floatType = getFloatTypeName(ctx.baseType);
+  const intType = isF64 ? "uint64_t" : "uint32_t";
   const shadowName = `__bits_${ctx.rootIdentifier}`;
   const mask = orchestrator.generateBitMask(ctx.width, isF64);
   const needsDeclaration = !orchestrator.hasFloatBitShadow(shadowName);
   if (needsDeclaration) {
     orchestrator.registerFloatBitShadow(shadowName);
-    orchestrator.addPendingTempDeclaration(`${shadowType} ${shadowName};`);
+    orchestrator.addPendingTempDeclaration(
+      `union { ${floatType} f; ${intType} u; } ${shadowName};`
+    );
   }
   const shadowIsCurrent = orchestrator.isFloatShadowCurrent(shadowName);
   orchestrator.markFloatShadowCurrent(shadowName);
-  if (shadowIsCurrent) {
-    if (ctx.start === "0") {
-      return `(${shadowName} & ${mask})`;
-    }
-    return `((${shadowName} >> ${ctx.start}) & ${mask})`;
+  if (!shadowIsCurrent) {
+    orchestrator.addPendingTempDeclaration(`${shadowName}.f = ${ctx.result};`);
   }
   if (ctx.start === "0") {
-    return `(memcpy(&${shadowName}, &${ctx.result}, sizeof(${ctx.result})), (${shadowName} & ${mask}))`;
+    return `(${shadowName}.u & ${mask})`;
   }
-  return `(memcpy(&${shadowName}, &${ctx.result}, sizeof(${ctx.result})), ((${shadowName} >> ${ctx.start}) & ${mask}))`;
+  return `((${shadowName}.u >> ${ctx.start}) & ${mask})`;
 };
 var applyAccessEffects = (sourceEffects, targetEffects) => {
   for (const effect of sourceEffects) {
@@ -117370,6 +117370,12 @@ var generateSwitch = (node, input, state, orchestrator) => {
     );
     lines.push(defaultResult.code);
     effects.push(...defaultResult.effects);
+  } else {
+    lines.push(
+      orchestrator.indent("default: {"),
+      orchestrator.indent(orchestrator.indent("break;")),
+      orchestrator.indent("}")
+    );
   }
   lines.push("}");
   return { code: lines.join("\n"), effects };
@@ -122737,11 +122743,16 @@ var MemberChainAnalyzer = class _MemberChainAnalyzer {
 var MemberChainAnalyzer_default = MemberChainAnalyzer;
 
 // src/transpiler/output/codegen/helpers/FloatBitHelper.ts
+var getFloatTypeName2 = (baseType) => {
+  return baseType === "f64" ? "double" : "float";
+};
 var FloatBitHelper = class {
   /**
-   * 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)
@@ -122755,10 +122766,10 @@ var FloatBitHelper = class {
     if (!isFloatType) {
       return null;
     }
-    callbacks.requireInclude("string");
     callbacks.requireInclude("float_static_assert");
     const isF64 = typeInfo.baseType === "f64";
-    const shadowType = isF64 ? "uint64_t" : "uint32_t";
+    const floatType = getFloatTypeName2(typeInfo.baseType);
+    const intType = isF64 ? "uint64_t" : "uint32_t";
     const shadowName = `__bits_${name}`;
     const maskSuffix = isF64 ? "ULL" : "U";
     const needsDeclaration = !CodeGenState.floatBitShadows.has(shadowName);
@@ -122766,14 +122777,18 @@ var FloatBitHelper = class {
       CodeGenState.floatBitShadows.add(shadowName);
     }
     const shadowIsCurrent = CodeGenState.floatShadowCurrent.has(shadowName);
-    const decl = needsDeclaration ? `${shadowType} ${shadowName}; ` : "";
-    const readMemcpy = shadowIsCurrent ? "" : `memcpy(&${shadowName}, &${name}, sizeof(${name})); `;
+    const decl = needsDeclaration ? `union { ${floatType} f; ${intType} u; } ${shadowName};
+` : "";
+    const readUnion = shadowIsCurrent ? "" : `${shadowName}.f = ${name};
+`;
     CodeGenState.floatShadowCurrent.add(shadowName);
     if (width === null) {
-      return `${decl}${readMemcpy}${shadowName} = (${shadowName} & ~(1${maskSuffix} << ${bitIndex})) | ((${shadowType})${callbacks.foldBooleanToInt(value)} << ${bitIndex}); memcpy(&${name}, &${shadowName}, sizeof(${name}));`;
+      return `${decl}${readUnion}${shadowName}.u = (${shadowName}.u & ~(1${maskSuffix} << ${bitIndex})) | ((${intType})${callbacks.foldBooleanToInt(value)} << ${bitIndex});
+${name} = ${shadowName}.f;`;
     } else {
       const mask = callbacks.generateBitMask(width, isF64);
-      return `${decl}${readMemcpy}${shadowName} = (${shadowName} & ~(${mask} << ${bitIndex})) | (((${shadowType})${value} & ${mask}) << ${bitIndex}); memcpy(&${name}, &${shadowName}, sizeof(${name}));`;
+      return `${decl}${readUnion}${shadowName}.u = (${shadowName}.u & ~(${mask} << ${bitIndex})) | (((${intType})${value} & ${mask}) << ${bitIndex});
+${name} = ${shadowName}.f;`;
     }
   }
 };
@@ -132808,7 +132823,7 @@ var DeclaratorUtils = class _DeclaratorUtils {
           if (identifier) {
             parts.push(identifier.getText());
           } else {
-            parts.push(typeSpec.getText());
+            parts.push(_DeclaratorUtils.reconstructAnonymousStruct(structSpec));
           }
         } else {
           parts.push(typeSpec.getText());
@@ -132822,6 +132837,74 @@ var DeclaratorUtils = class _DeclaratorUtils {
     }
     return parts.join(" ") || "int";
   }
+  /**
+   * Reconstruct an anonymous struct/union type with proper spacing.
+   * For `struct { unsigned int flag_a: 1; }`, returns the properly formatted string
+   * instead of the concatenated tokens from getText().
+   */
+  static reconstructAnonymousStruct(structSpec) {
+    const structOrUnion = structSpec.structOrUnion();
+    const keyword = structOrUnion.Struct() ? "struct" : "union";
+    const declList = structSpec.structDeclarationList();
+    if (!declList) {
+      return `${keyword} { }`;
+    }
+    const fields = _DeclaratorUtils.reconstructStructFields(declList);
+    return `${keyword} { ${fields} }`;
+  }
+  /**
+   * Reconstruct struct fields with proper spacing.
+   */
+  static reconstructStructFields(declList) {
+    const fieldStrings = [];
+    for (const decl of declList.structDeclaration()) {
+      const fieldStr = _DeclaratorUtils.reconstructStructField(decl);
+      if (fieldStr) {
+        fieldStrings.push(fieldStr);
+      }
+    }
+    return fieldStrings.join(" ");
+  }
+  /**
+   * Reconstruct a single struct field declaration.
+   */
+  static reconstructStructField(decl) {
+    const specQualList = decl.specifierQualifierList();
+    if (!specQualList) return null;
+    const baseType = _DeclaratorUtils.extractTypeFromSpecQualList(specQualList);
+    const declaratorList = decl.structDeclaratorList();
+    if (!declaratorList) {
+      return `${baseType};`;
+    }
+    const declarators = [];
+    for (const structDecl of declaratorList.structDeclarator()) {
+      const declStr = _DeclaratorUtils.reconstructStructDeclarator(structDecl);
+      if (declStr) {
+        declarators.push(declStr);
+      }
+    }
+    if (declarators.length === 0) {
+      return `${baseType};`;
+    }
+    return `${baseType} ${declarators.join(", ")};`;
+  }
+  /**
+   * Reconstruct a struct declarator (field name with optional bitfield width).
+   */
+  static reconstructStructDeclarator(structDecl) {
+    const declarator = structDecl.declarator();
+    const hasColon = structDecl.Colon() !== null;
+    const constExpr = structDecl.constantExpression();
+    let name = "";
+    if (declarator) {
+      name = _DeclaratorUtils.extractDeclaratorName(declarator) || "";
+    }
+    if (hasColon && constExpr) {
+      const width = constExpr.getText();
+      return `${name}: ${width}`;
+    }
+    return name || null;
+  }
   /**
    * Extract typedef name from declaration specifiers.
    * For "typedef struct { ... } AppConfig;", this returns "AppConfig".