c-next 0.2.5 → 0.2.7

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

@@ -303,7 +303,14 @@ class StringDeclHelper {
       initValue,
       arrayDims,
     );
-    return { code: `${decl} = ${finalInitValue};`, handled: true };
+    // MISRA C:2012 Rules 9.3/9.4 - String literals don't fill all inner array bytes,
+    // but C standard guarantees zero-initialization of remaining elements
+    const suppression =
+      "// cppcheck-suppress misra-c2012-9.3\n// cppcheck-suppress misra-c2012-9.4\n";
+    return {
+      code: `${suppression}${decl} = ${finalInitValue};`,
+      handled: true,
+    };
   }
 
   /**

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

@@ -6,8 +6,11 @@
  *   "void (*)(Point p)"
  *
  * Used by Issue #895 to determine if callback params should be pointers or values.
+ * Used by Issue #914 to resolve callback pointer/const info onto IParameterSymbol.
  */
 
+import IParameterSymbol from "../../../../utils/types/IParameterSymbol";
+
 /**
  * Parsed parameter info from a typedef.
  */
@@ -215,6 +218,37 @@ class TypedefParamParser {
       TypedefParamParser.getParamAt(typedefType, paramIndex)?.isConst ?? null
     );
   }
+
+  /**
+   * Resolve callback pointer/const overrides onto an array of IParameterSymbol.
+   *
+   * Issue #914: This is the single point where callback typedef info is applied
+   * to parameters — used by both .c and .h generation paths via IParameterSymbol.
+   *
+   * @param params - The original parameter symbols
+   * @param callbackTypedefType - The typedef type string (e.g., "void (*)(widget_t *, const rect_t *)")
+   * @returns New array with isCallbackPointer/isCallbackConst resolved
+   */
+  static resolveCallbackParams(
+    params: readonly IParameterSymbol[],
+    callbackTypedefType: string,
+  ): IParameterSymbol[] {
+    return params.map((param, index) => {
+      const shouldBePointer = TypedefParamParser.shouldBePointer(
+        callbackTypedefType,
+        index,
+      );
+      const shouldBeConst = TypedefParamParser.shouldBeConst(
+        callbackTypedefType,
+        index,
+      );
+      return {
+        ...param,
+        isCallbackPointer: shouldBePointer ?? undefined,
+        isCallbackConst: shouldBeConst ?? undefined,
+      };
+    });
+  }
 }
 
 export default TypedefParamParser;

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

@@ -139,6 +139,8 @@ interface IVariableDeclCallbacks {
     ctx: Parser.VariableDeclarationContext,
     name: string,
   ) => void;
+  /** Issue #895 Bug B: Mark variable as pointer in type registry */
+  markVariableAsPointer: (name: string) => void;
   /** Get string concatenation operands */
   getStringConcatOperands: (
     ctx: Parser.ExpressionContext,
@@ -571,9 +573,13 @@ class VariableDeclHelper {
     }
 
     // Issue #696: Use helper for modifier extraction and validation
+    // Issue #852 (MISRA Rule 8.5): Pass hasInitializer and cppMode for correct extern behavior
+    const hasInitializer = ctx.expression() !== null;
     const modifiers = VariableModifierBuilder.build(
       ctx,
       CodeGenState.inFunctionBody,
+      hasInitializer,
+      CodeGenState.cppMode,
     );
 
     const name = ctx.IDENTIFIER().getText();
@@ -587,6 +593,11 @@ class VariableDeclHelper {
     // Track local variable metadata
     callbacks.trackLocalVariable(ctx, name);
 
+    // Issue #895 Bug B: If type was inferred as pointer, mark it in the registry
+    if (type.endsWith("*")) {
+      callbacks.markVariableAsPointer(name);
+    }
+
     // ADR-045: Handle bounded string type specially - early return
     const stringResult = StringDeclHelper.generateStringDecl(
       typeCtx,

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

@@ -46,12 +46,16 @@ class VariableModifierBuilder {
    *
    * @param ctx - Parser context with modifier methods
    * @param inFunctionBody - Whether we're inside a function body (affects extern)
+   * @param hasInitializer - Whether the variable has an initializer (affects extern in C mode)
+   * @param cppMode - Whether we're generating C++ code (affects extern behavior)
    * @returns Modifier strings ready for use in generated code
    * @throws Error if both atomic and volatile are specified
    */
   static build(
     ctx: IModifierContext,
     inFunctionBody: boolean,
+    hasInitializer: boolean = false,
+    cppMode: boolean = false,
   ): IVariableModifiers {
     const hasConst = ctx.constModifier?.() ?? false;
     const constMod = hasConst ? "const " : "";
@@ -59,7 +63,18 @@ class VariableModifierBuilder {
     const volatileMod = ctx.volatileModifier() ? "volatile " : "";
 
     // Issue #525: Add extern for top-level const in C++ for external linkage
-    const externMod = hasConst && !inFunctionBody ? "extern " : "";
+    // In C++, const at file scope has internal linkage by default, so extern is needed.
+    //
+    // Issue #852 (MISRA Rule 8.5): In C mode, do NOT add extern to definitions
+    // (variables with initializers). The extern declaration comes from the header.
+    //
+    // Summary:
+    // - C mode + no initializer: extern (declaration)
+    // - C mode + initializer: NO extern (definition - MISRA 8.5)
+    // - C++ mode: ALWAYS extern for external linkage (both declarations and definitions)
+    const needsExtern =
+      hasConst && !inFunctionBody && (cppMode || !hasInitializer);
+    const externMod = needsExtern ? "extern " : "";
 
     // Validate: cannot use both atomic and volatile
     if (ctx.atomicModifier() && ctx.volatileModifier()) {

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

@@ -285,6 +285,54 @@ describe("ParameterInputAdapter", () => {
 
       expect(result.isAutoConst).toBe(false);
     });
+
+    it("forces pointer when isCallbackPointer is set (Issue #914)", () => {
+      const param: IParameterSymbol = {
+        name: "buf",
+        type: "u8",
+        isConst: false,
+        isArray: false,
+        isCallbackPointer: true,
+      };
+
+      // Even though deps says pass-by-value, callback overrides it
+      const deps = { ...defaultDeps, isPassByValue: true };
+      const result = ParameterInputAdapter.fromSymbol(param, deps);
+
+      expect(result.isPassByValue).toBe(false);
+      expect(result.isPassByReference).toBe(true);
+      expect(result.forcePointerSyntax).toBe(true);
+    });
+
+    it("forces const when isCallbackConst is set (Issue #914)", () => {
+      const param: IParameterSymbol = {
+        name: "area",
+        type: "rect_t",
+        isConst: false,
+        isArray: false,
+        isCallbackPointer: true,
+        isCallbackConst: true,
+      };
+
+      const result = ParameterInputAdapter.fromSymbol(param, defaultDeps);
+
+      expect(result.forceConst).toBe(true);
+      expect(result.forcePointerSyntax).toBe(true);
+    });
+
+    it("does not force pointer when isCallbackPointer is not set", () => {
+      const param: IParameterSymbol = {
+        name: "value",
+        type: "u32",
+        isConst: false,
+        isArray: false,
+      };
+
+      const result = ParameterInputAdapter.fromSymbol(param, defaultDeps);
+
+      expect(result.forcePointerSyntax).toBeUndefined();
+      expect(result.forceConst).toBeUndefined();
+    });
   });
 
   describe("fromAST", () => {

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

@@ -4,6 +4,7 @@
 
 import { describe, expect, it } from "vitest";
 import TypedefParamParser from "../TypedefParamParser";
+import IParameterSymbol from "../../../../../utils/types/IParameterSymbol";
 
 describe("TypedefParamParser", () => {
   describe("parse", () => {
@@ -206,4 +207,91 @@ describe("TypedefParamParser", () => {
       expect(TypedefParamParser.shouldBeConst(typedef, 2)).toBe(false);
     });
   });
+
+  describe("resolveCallbackParams (Issue #914)", () => {
+    function makeParam(
+      name: string,
+      type: string,
+      overrides?: Partial<IParameterSymbol>,
+    ): IParameterSymbol {
+      return {
+        name,
+        type,
+        isConst: false,
+        isArray: false,
+        ...overrides,
+      };
+    }
+
+    it("should set isCallbackPointer for pointer params", () => {
+      const params = [makeParam("w", "widget_t"), makeParam("buf", "u8")];
+      const typedef = "void (*)(widget_t *, uint8_t *)";
+
+      const result = TypedefParamParser.resolveCallbackParams(params, typedef);
+
+      expect(result[0].isCallbackPointer).toBe(true);
+      expect(result[1].isCallbackPointer).toBe(true);
+    });
+
+    it("should set isCallbackConst for const pointer params", () => {
+      const params = [
+        makeParam("w", "widget_t"),
+        makeParam("area", "rect_t"),
+        makeParam("buf", "u8"),
+      ];
+      const typedef = "void (*)(widget_t *, const rect_t *, uint8_t *)";
+
+      const result = TypedefParamParser.resolveCallbackParams(params, typedef);
+
+      expect(result[0].isCallbackPointer).toBe(true);
+      expect(result[0].isCallbackConst).toBe(false);
+
+      expect(result[1].isCallbackPointer).toBe(true);
+      expect(result[1].isCallbackConst).toBe(true);
+
+      expect(result[2].isCallbackPointer).toBe(true);
+      expect(result[2].isCallbackConst).toBe(false);
+    });
+
+    it("should not set callback flags for value params", () => {
+      const params = [makeParam("count", "u32")];
+      const typedef = "void (*)(int count)";
+
+      const result = TypedefParamParser.resolveCallbackParams(params, typedef);
+
+      expect(result[0].isCallbackPointer).toBe(false);
+      expect(result[0].isCallbackConst).toBe(false);
+    });
+
+    it("should preserve existing param fields", () => {
+      const params = [
+        makeParam("data", "u8", {
+          isConst: true,
+          isArray: true,
+          arrayDimensions: ["10"],
+        }),
+      ];
+      const typedef = "void (*)(uint8_t *)";
+
+      const result = TypedefParamParser.resolveCallbackParams(params, typedef);
+
+      expect(result[0].name).toBe("data");
+      expect(result[0].type).toBe("u8");
+      expect(result[0].isConst).toBe(true);
+      expect(result[0].isArray).toBe(true);
+      expect(result[0].arrayDimensions).toEqual(["10"]);
+      expect(result[0].isCallbackPointer).toBe(true);
+    });
+
+    it("should handle params beyond typedef length gracefully", () => {
+      const params = [makeParam("w", "widget_t"), makeParam("extra", "u32")];
+      const typedef = "void (*)(widget_t *)";
+
+      const result = TypedefParamParser.resolveCallbackParams(params, typedef);
+
+      expect(result[0].isCallbackPointer).toBe(true);
+      expect(result[1].isCallbackPointer).toBeUndefined();
+      expect(result[1].isCallbackConst).toBeUndefined();
+    });
+  });
 });

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

@@ -54,14 +54,46 @@ describe("VariableModifierBuilder", () => {
       expect(result.volatile).toBe("volatile ");
     });
 
-    it("returns extern for const at file scope", () => {
+    it("returns extern for const at file scope (declaration without initializer, C mode)", () => {
       const ctx = {
         constModifier: () => ({}),
         atomicModifier: () => null,
         volatileModifier: () => null,
       };
 
-      const result = VariableModifierBuilder.build(ctx, false);
+      // Declaration (no initializer) in C mode - should have extern
+      const result = VariableModifierBuilder.build(ctx, false, false, false);
+
+      expect(result.extern).toBe("extern ");
+    });
+
+    it("does not return extern for const at file scope with initializer in C mode (MISRA 8.5)", () => {
+      // MISRA Rule 8.5: External object/function shall be declared once in one file only.
+      // When a variable has an initializer, it's a DEFINITION, not a declaration.
+      // The extern declaration comes from the header; the .c file should not duplicate it.
+      const ctx = {
+        constModifier: () => ({}),
+        atomicModifier: () => null,
+        volatileModifier: () => null,
+      };
+
+      // Definition (has initializer) in C mode - should NOT have extern
+      const result = VariableModifierBuilder.build(ctx, false, true, false);
+
+      expect(result.extern).toBe("");
+    });
+
+    it("returns extern for const at file scope with initializer in C++ mode (Issue #525)", () => {
+      // In C++, const at file scope has internal linkage by default.
+      // extern is needed for cross-file access, even for definitions.
+      const ctx = {
+        constModifier: () => ({}),
+        atomicModifier: () => null,
+        volatileModifier: () => null,
+      };
+
+      // Definition (has initializer) in C++ mode - SHOULD have extern for external linkage
+      const result = VariableModifierBuilder.build(ctx, false, true, true);
 
       expect(result.extern).toBe("extern ");
     });

package/src/transpiler/output/codegen/types/TTypeInfo.ts

@@ -19,6 +19,7 @@ type TTypeInfo = {
   isAtomic?: boolean;
   isExternalCppType?: boolean; // Issue #375: C++ types instantiated via constructor
   isParameter?: boolean; // Issue #579: Track if this is a function parameter (becomes pointer in C)
+  isPointer?: boolean; // Issue #895 Bug B: Track if variable is a pointer (inferred from C function return type)
 };
 
 export default TTypeInfo;

package/src/transpiler/output/headers/HeaderGeneratorUtils.ts

@@ -278,15 +278,28 @@ class HeaderGeneratorUtils {
     }
 
     // User includes
+    // Issue #933: Transform .h to .hpp in C++ mode so headers include correct files
     if (options.userIncludes && options.userIncludes.length > 0) {
       for (const include of options.userIncludes) {
-        lines.push(include);
+        const transformedInclude = options.cppMode
+          ? include.replace(/\.h"/, '.hpp"').replace(/\.h>/, ".hpp>")
+          : include;
+        lines.push(transformedInclude);
       }
     }
 
     // External type header includes (skip duplicates of user includes)
-    const userIncludeSet = new Set(options.userIncludes ?? []);
+    // Note: External C headers stay as .h - only user includes from .cnx files get
+    // transformed to .hpp in C++ mode (those are C-Next generated headers)
+    const userIncludeSet = new Set(
+      options.userIncludes?.map((inc) =>
+        options.cppMode
+          ? inc.replace(/\.h"/, '.hpp"').replace(/\.h>/, ".hpp>")
+          : inc,
+      ) ?? [],
+    );
     for (const directive of headersToInclude) {
+      // Don't transform external C headers - they should stay as .h
       if (!userIncludeSet.has(directive)) {
         lines.push(directive);
       }

package/src/transpiler/output/headers/__tests__/BaseHeaderGenerator.test.ts

@@ -20,6 +20,8 @@ function createFunctionSymbol(
     isAutoConst?: boolean;
     isArray?: boolean;
     arrayDimensions?: string[];
+    isCallbackPointer?: boolean;
+    isCallbackConst?: boolean;
   }>,
 ): IHeaderSymbol {
   return {
@@ -36,6 +38,8 @@ function createFunctionSymbol(
       isAutoConst: p.isAutoConst ?? false,
       isArray: p.isArray ?? false,
       arrayDimensions: p.arrayDimensions,
+      isCallbackPointer: p.isCallbackPointer,
+      isCallbackConst: p.isCallbackConst,
     })),
   };
 }
@@ -239,4 +243,87 @@ describe("BaseHeaderGenerator", () => {
       expect(result).toContain("void processData(const MyStruct* data);");
     });
   });
+
+  describe("Callback-compatible functions (Issue #914)", () => {
+    it("should use pointer for primitive param when isCallbackPointer is set (C mode)", () => {
+      const generator = new CHeaderGenerator();
+      const symbols: IHeaderSymbol[] = [
+        createFunctionSymbol("Renderer_flush", "void", [
+          { name: "buf", type: "u8", isCallbackPointer: true },
+        ]),
+      ];
+
+      const result = generator.generate(symbols, "test.h");
+
+      expect(result).toContain("uint8_t* buf");
+    });
+
+    it("should use pointer for primitive param when isCallbackPointer is set (C++ mode)", () => {
+      const generator = new CppHeaderGenerator();
+      const symbols: IHeaderSymbol[] = [
+        createFunctionSymbol("Renderer_flush", "void", [
+          { name: "buf", type: "u8", isCallbackPointer: true },
+        ]),
+      ];
+
+      const result = generator.generate(symbols, "test.h");
+
+      // Must use * not & because headers are wrapped in extern "C"
+      expect(result).toContain("uint8_t* buf");
+    });
+
+    it("should use const pointer for struct param with isCallbackConst (C mode)", () => {
+      const generator = new CHeaderGenerator();
+      const symbols: IHeaderSymbol[] = [
+        createFunctionSymbol("Renderer_flush", "void", [
+          {
+            name: "area",
+            type: "rect_t",
+            isCallbackPointer: true,
+            isCallbackConst: true,
+          },
+        ]),
+      ];
+
+      const result = generator.generate(symbols, "test.h");
+
+      expect(result).toContain("const rect_t* area");
+    });
+
+    it("should use non-const pointer for struct param without isCallbackConst (C++ mode)", () => {
+      const generator = new CppHeaderGenerator();
+      const symbols: IHeaderSymbol[] = [
+        createFunctionSymbol("Renderer_flush", "void", [
+          { name: "w", type: "widget_t", isCallbackPointer: true },
+        ]),
+      ];
+
+      const result = generator.generate(symbols, "test.h");
+
+      // Must use * not & for callback params
+      expect(result).toContain("widget_t* w");
+    });
+
+    it("should handle mixed callback and non-callback params", () => {
+      const generator = new CHeaderGenerator();
+      const symbols: IHeaderSymbol[] = [
+        createFunctionSymbol("Renderer_flush", "void", [
+          { name: "w", type: "widget_t", isCallbackPointer: true },
+          {
+            name: "area",
+            type: "rect_t",
+            isCallbackPointer: true,
+            isCallbackConst: true,
+          },
+          { name: "buf", type: "u8", isCallbackPointer: true },
+        ]),
+      ];
+
+      const result = generator.generate(symbols, "test.h");
+
+      expect(result).toContain(
+        "void Renderer_flush(widget_t* w, const rect_t* area, uint8_t* buf);",
+      );
+    });
+  });
 });

package/src/utils/BitUtils.ts

@@ -6,16 +6,17 @@
  */
 class BitUtils {
   /**
-   * Convert a boolean expression to an integer (0 or 1).
+   * Convert a boolean expression to an unsigned integer (0U or 1U).
    * Handles literal "true"/"false" and generates ternary for expressions.
+   * Uses unsigned literals for MISRA C:2012 Rule 10.1 compliance.
    *
    * @param expr - The expression to convert
-   * @returns C code string representing the integer value
+   * @returns C code string representing the unsigned integer value
    */
   static boolToInt(expr: string): string {
-    if (expr === "true") return "1";
-    if (expr === "false") return "0";
-    return `(${expr} ? 1 : 0)`;
+    if (expr === "true") return "1U";
+    if (expr === "false") return "0U";
+    return `(${expr} ? 1U : 0U)`;
   }
 
   /**
@@ -78,25 +79,27 @@ class BitUtils {
   }
 
   /**
-   * Return the appropriate "1" literal for a given type.
-   * Uses "1ULL" for 64-bit types to avoid undefined behavior on large shifts.
+   * Return the appropriate unsigned "1" literal for a given type.
+   * Uses "1ULL" for 64-bit types, "1U" for others.
+   * MISRA C:2012 Rule 10.1 requires unsigned operands for bitwise operations.
    *
    * @param typeName - The C-Next type name (e.g., "u64", "i32")
-   * @returns "1ULL" for 64-bit types, "1" otherwise
+   * @returns "1ULL" for 64-bit types, "1U" otherwise
    */
   static oneForType(typeName: string): string {
-    return typeName === "u64" || typeName === "i64" ? "1ULL" : "1";
+    return typeName === "u64" || typeName === "i64" ? "1ULL" : "1U";
   }
 
   /**
-   * Format a number as an uppercase hex string (e.g., 255 -> "0xFF").
+   * Format a number as an unsigned uppercase hex string (e.g., 255 -> "0xFFU").
    * Used for generating hex mask literals in generated C code.
+   * Includes U suffix for MISRA C:2012 Rule 10.1 compliance.
    *
    * @param value - The numeric value to format
-   * @returns Hex string like "0xFF" or "0x1F"
+   * @returns Hex string like "0xFFU" or "0x1FU"
    */
   static formatHex(value: number): string {
-    return `0x${value.toString(16).toUpperCase()}`;
+    return `0x${value.toString(16).toUpperCase()}U`;
   }
 
   /**
@@ -154,7 +157,7 @@ class BitUtils {
   ): string {
     const intValue = BitUtils.boolToInt(value);
     const is64Bit = targetType === "u64" || targetType === "i64";
-    const one = is64Bit ? "1ULL" : "1";
+    const one = is64Bit ? "1ULL" : "1U";
     // For 64-bit types, cast the value to ensure shift doesn't overflow
     const valueShift = is64Bit
       ? `((uint64_t)${intValue} << ${offset})`
@@ -203,6 +206,7 @@ class BitUtils {
   ): string {
     const intValue = BitUtils.boolToInt(value);
     // For 64-bit types, cast to ensure correct shift width
+    // boolToInt already returns unsigned values (1U/0U) for MISRA 10.1 compliance
     const castPrefix =
       targetType === "u64" || targetType === "i64" ? "(uint64_t)" : "";
     return `${target} = (${castPrefix}${intValue} << ${offset});`;

package/src/utils/ExpressionUtils.ts

@@ -140,6 +140,57 @@ class ExpressionUtils {
     return identifier?.getText() ?? null;
   }
 
+  /**
+   * Collect all additive expressions from a ternary expression.
+   *
+   * Uses flatMap chains to traverse the expression grammar efficiently.
+   * Useful for analyzers that need to examine operands at the additive level.
+   *
+   * @param ctx - The ternary expression context
+   * @returns Array of all additive expression contexts in the tree
+   */
+  static collectAdditiveExpressions(
+    ctx: Parser.TernaryExpressionContext,
+  ): Parser.AdditiveExpressionContext[] {
+    return ExpressionUtils.collectAdditiveFromOrExprs(ctx.orExpression());
+  }
+
+  /**
+   * Collect additive expressions from an array of orExpression contexts.
+   *
+   * Internal helper that performs the actual flatMap traversal.
+   */
+  private static collectAdditiveFromOrExprs(
+    orExprs: Parser.OrExpressionContext[],
+  ): Parser.AdditiveExpressionContext[] {
+    return orExprs
+      .flatMap((or) => or.andExpression())
+      .flatMap((and) => and.equalityExpression())
+      .flatMap((eq) => eq.relationalExpression())
+      .flatMap((rel) => rel.bitwiseOrExpression())
+      .flatMap((bor) => bor.bitwiseXorExpression())
+      .flatMap((bxor) => bxor.bitwiseAndExpression())
+      .flatMap((band) => band.shiftExpression())
+      .flatMap((shift) => shift.additiveExpression());
+  }
+
+  /**
+   * Collect all unary expressions from an orExpression context.
+   *
+   * Traverses through the entire expression hierarchy to find all unary expressions.
+   * Useful for analyzers that need to examine leaf operands.
+   *
+   * @param orExpr - The orExpression context
+   * @returns Array of all unary expression contexts in the tree
+   */
+  static collectUnaryFromOrExpr(
+    orExpr: Parser.OrExpressionContext,
+  ): Parser.UnaryExpressionContext[] {
+    return ExpressionUtils.collectAdditiveFromOrExprs([orExpr])
+      .flatMap((add) => add.multiplicativeExpression())
+      .flatMap((mul) => mul.unaryExpression());
+  }
+
   /**
    * ADR-023: Check if an expression contains a function call anywhere in its tree.
    *