c-next 0.2.4 → 0.2.6

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

@@ -0,0 +1,220 @@
+/**
+ * TypedefParamParser - Parses C function pointer typedef signatures
+ *
+ * Extracts parameter types from typedef strings like:
+ *   "void (*)(widget_t *, const rect_t *, uint8_t *)"
+ *   "void (*)(Point p)"
+ *
+ * Used by Issue #895 to determine if callback params should be pointers or values.
+ */
+
+/**
+ * Parsed parameter info from a typedef.
+ */
+interface ITypedefParam {
+  /** Full type string (e.g., "widget_t *", "const rect_t *", "uint8_t *") */
+  type: string;
+  /** Whether this is a pointer type */
+  isPointer: boolean;
+  /** Whether this has const qualifier */
+  isConst: boolean;
+  /** Base type without pointer/const (e.g., "widget_t", "rect_t", "uint8_t") */
+  baseType: string;
+}
+
+/**
+ * Parse result for a typedef signature.
+ */
+interface ITypedefParseResult {
+  /** Return type */
+  returnType: string;
+  /** Parsed parameters */
+  params: ITypedefParam[];
+}
+
+class TypedefParamParser {
+  /**
+   * Parse a function pointer typedef type string.
+   *
+   * @param typedefType - The type string, e.g., "void (*)(widget_t *, const rect_t *, uint8_t *)"
+   * @returns Parsed result with return type and parameters, or null if parsing fails
+   */
+  static parse(typedefType: string): ITypedefParseResult | null {
+    // Expected format: "return_type (*)(param1, param2, ...)"
+    // Find the (*) marker first
+    const funcPtrIndex = typedefType.indexOf("(*)");
+    if (funcPtrIndex === -1) {
+      return null;
+    }
+
+    const returnType = typedefType.substring(0, funcPtrIndex).trim();
+
+    // Find the opening paren after (*)
+    const afterFuncPtr = typedefType.substring(funcPtrIndex + 3).trim();
+    if (!afterFuncPtr.startsWith("(")) {
+      return null;
+    }
+
+    // Extract params by finding the matching closing paren
+    const paramsStr = TypedefParamParser.extractParenContent(afterFuncPtr);
+    if (paramsStr === null) {
+      return null;
+    }
+
+    // Handle void or empty params
+    if (!paramsStr || paramsStr === "void") {
+      return { returnType, params: [] };
+    }
+
+    // Split by comma, handling nested parentheses
+    const paramStrings = TypedefParamParser.splitParams(paramsStr);
+    const params = paramStrings.map((p) => TypedefParamParser.parseParam(p));
+
+    return { returnType, params };
+  }
+
+  /**
+   * Extract content between matching parentheses, handling arbitrary nesting.
+   * @param str - String starting with '('
+   * @returns Content between outer parens, or null if no match
+   */
+  private static extractParenContent(str: string): string | null {
+    if (!str.startsWith("(")) {
+      return null;
+    }
+
+    let depth = 0;
+    for (let i = 0; i < str.length; i++) {
+      if (str[i] === "(") {
+        depth++;
+      } else if (str[i] === ")") {
+        depth--;
+        if (depth === 0) {
+          // Found matching close paren - return content between
+          return str.substring(1, i);
+        }
+      }
+    }
+
+    // No matching close paren found
+    return null;
+  }
+
+  /**
+   * Split parameter string by commas, respecting nested parentheses.
+   */
+  private static splitParams(paramsStr: string): string[] {
+    const params: string[] = [];
+    let current = "";
+    let depth = 0;
+
+    for (const char of paramsStr) {
+      if (char === "(") {
+        depth++;
+        current += char;
+      } else if (char === ")") {
+        depth--;
+        current += char;
+      } else if (char === "," && depth === 0) {
+        params.push(current.trim());
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+
+    if (current.trim()) {
+      params.push(current.trim());
+    }
+
+    return params;
+  }
+
+  /**
+   * Parse a single parameter type string.
+   */
+  private static parseParam(paramStr: string): ITypedefParam {
+    const trimmed = paramStr.trim();
+
+    // Check for pointer
+    const isPointer = trimmed.includes("*");
+
+    // Check for const - handles both "const " (with space) and merged forms
+    // C grammar getText() strips spaces, so "const rect_t*" may appear merged
+    const isConst = /\bconst\b/.test(trimmed) || trimmed.startsWith("const");
+
+    // Extract base type (remove const, *, and param name if present)
+    let baseType = trimmed
+      .replaceAll(/\bconst\b/g, "") // Remove const (with word boundary)
+      .replace(/^const/, "") // Remove const at start (no space case) - only once
+      .replaceAll("*", "") // Remove pointers
+      .replaceAll(/\s+/g, " ") // Normalize whitespace
+      .trim();
+
+    // Remove trailing param name if present (e.g., "rect_t area" -> "rect_t")
+    // Only remove if there are multiple words (space-separated)
+    if (baseType.includes(" ")) {
+      baseType = baseType.replace(/\s+\w+$/, "");
+    }
+
+    // Handle struct keyword
+    if (baseType.startsWith("struct ")) {
+      baseType = baseType.substring(7);
+    }
+
+    return {
+      type: trimmed,
+      isPointer,
+      isConst,
+      baseType,
+    };
+  }
+
+  /**
+   * Get the parameter info at a given index, or null if not found.
+   */
+  private static getParamAt(
+    typedefType: string,
+    paramIndex: number,
+  ): ITypedefParam | null {
+    const parsed = TypedefParamParser.parse(typedefType);
+    if (!parsed || paramIndex >= parsed.params.length) {
+      return null;
+    }
+    return parsed.params[paramIndex];
+  }
+
+  /**
+   * Check if a parameter at a given index should be a pointer based on the typedef.
+   *
+   * @param typedefType - The typedef type string
+   * @param paramIndex - The parameter index (0-based)
+   * @returns true if the param should be a pointer, false for value, null if unknown
+   */
+  static shouldBePointer(
+    typedefType: string,
+    paramIndex: number,
+  ): boolean | null {
+    return (
+      TypedefParamParser.getParamAt(typedefType, paramIndex)?.isPointer ?? null
+    );
+  }
+
+  /**
+   * Check if a parameter at a given index should be const based on the typedef.
+   *
+   * @param typedefType - The typedef type string
+   * @param paramIndex - The parameter index (0-based)
+   * @returns true if the param should be const, false otherwise, null if unknown
+   */
+  static shouldBeConst(
+    typedefType: string,
+    paramIndex: number,
+  ): boolean | null {
+    return (
+      TypedefParamParser.getParamAt(typedefType, paramIndex)?.isConst ?? null
+    );
+  }
+}
+
+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__/FunctionContextManager.test.ts

@@ -347,7 +347,7 @@ describe("FunctionContextManager", () => {
       const callbacks = createMockCallbacks();
       const param = createMockParam("x", "u32", { isPrimitive: true });
 
-      FunctionContextManager.processParameter(param, callbacks);
+      FunctionContextManager.processParameter(param, callbacks, 0);
 
       const paramInfo = CodeGenState.currentParameters.get("x");
       expect(paramInfo).toBeDefined();
@@ -363,7 +363,7 @@ describe("FunctionContextManager", () => {
         isArray: true,
       });
 
-      FunctionContextManager.processParameter(param, callbacks);
+      FunctionContextManager.processParameter(param, callbacks, 0);
 
       const paramInfo = CodeGenState.currentParameters.get("arr");
       expect(paramInfo).toBeDefined();
@@ -377,7 +377,7 @@ describe("FunctionContextManager", () => {
         isConst: true,
       });
 
-      FunctionContextManager.processParameter(param, callbacks);
+      FunctionContextManager.processParameter(param, callbacks, 0);
 
       const paramInfo = CodeGenState.currentParameters.get("x");
       expect(paramInfo).toBeDefined();
@@ -391,7 +391,7 @@ describe("FunctionContextManager", () => {
       );
       const param = createMockParam("point", "Point", { isUserType: true });
 
-      FunctionContextManager.processParameter(param, callbacks);
+      FunctionContextManager.processParameter(param, callbacks, 0);
 
       const paramInfo = CodeGenState.currentParameters.get("point");
       expect(paramInfo).toBeDefined();
@@ -406,7 +406,7 @@ describe("FunctionContextManager", () => {
         stringCapacity: 32,
       });
 
-      FunctionContextManager.processParameter(param, callbacks);
+      FunctionContextManager.processParameter(param, callbacks, 0);
 
       const paramInfo = CodeGenState.currentParameters.get("name");
       expect(paramInfo).toBeDefined();

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

@@ -46,13 +46,15 @@ describe("MemberSeparatorResolver", () => {
       });
 
       const ctx = MemberSeparatorResolver.buildContext(
-        "Motor",
-        true, // hasGlobal
-        false, // hasThis
-        null,
-        false, // isStructParam
+        {
+          firstId: "Motor",
+          hasGlobal: true,
+          hasThis: false,
+          currentScope: null,
+          isStructParam: false,
+          isCppAccess: false,
+        },
         deps,
-        false, // isCppAccess
       );
 
       expect(ctx.isCrossScope).toBe(true);
@@ -65,13 +67,15 @@ describe("MemberSeparatorResolver", () => {
       });
 
       const ctx = MemberSeparatorResolver.buildContext(
-        "GPIO7",
-        true, // hasGlobal
-        false, // hasThis
-        null,
-        false,
+        {
+          firstId: "GPIO7",
+          hasGlobal: true,
+          hasThis: false,
+          currentScope: null,
+          isStructParam: false,
+          isCppAccess: false,
+        },
         deps,
-        false,
       );
 
       expect(ctx.isCrossScope).toBe(true);
@@ -83,13 +87,15 @@ describe("MemberSeparatorResolver", () => {
       });
 
       const ctx = MemberSeparatorResolver.buildContext(
-        "CONTROL_REG",
-        false, // hasGlobal
-        true, // hasThis
-        "Motor", // currentScope
-        false,
+        {
+          firstId: "CONTROL_REG",
+          hasGlobal: false,
+          hasThis: true,
+          currentScope: "Motor",
+          isStructParam: false,
+          isCppAccess: false,
+        },
         deps,
-        false,
       );
 
       expect(ctx.scopedRegName).toBe("Motor_CONTROL_REG");
@@ -100,13 +106,15 @@ describe("MemberSeparatorResolver", () => {
       const deps = createMockDeps();
 
       const ctx = MemberSeparatorResolver.buildContext(
-        "CONTROL_REG",
-        false,
-        false, // no this
-        "Motor",
-        false,
+        {
+          firstId: "CONTROL_REG",
+          hasGlobal: false,
+          hasThis: false,
+          currentScope: "Motor",
+          isStructParam: false,
+          isCppAccess: false,
+        },
         deps,
-        false,
       );
 
       expect(ctx.scopedRegName).toBe(null);
@@ -117,13 +125,15 @@ describe("MemberSeparatorResolver", () => {
       const deps = createMockDeps();
 
       const ctx = MemberSeparatorResolver.buildContext(
-        "point",
-        false,
-        false,
-        null,
-        true, // isStructParam
+        {
+          firstId: "point",
+          hasGlobal: false,
+          hasThis: false,
+          currentScope: null,
+          isStructParam: true,
+          isCppAccess: false,
+        },
         deps,
-        false,
       );
 
       expect(ctx.isStructParam).toBe(true);
@@ -133,13 +143,15 @@ describe("MemberSeparatorResolver", () => {
       const deps = createMockDeps();
 
       const ctx = MemberSeparatorResolver.buildContext(
-        "SeaDash",
-        true,
-        false,
-        null,
-        false,
+        {
+          firstId: "SeaDash",
+          hasGlobal: true,
+          hasThis: false,
+          currentScope: null,
+          isStructParam: false,
+          isCppAccess: true,
+        },
         deps,
-        true, // isCppAccess
       );
 
       expect(ctx.isCppAccess).toBe(true);

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

@@ -61,6 +61,7 @@ function createDefaultASTDeps(overrides?: {
     typeMap,
     isModified: overrides?.isModified ?? false,
     isPassByValue: overrides?.isPassByValue ?? false,
+    isCallbackCompatible: false,
   };
 }
 
@@ -422,5 +423,41 @@ describe("ParameterInputAdapter", () => {
       expect(result.arrayDimensions).toEqual(["5", "33"]);
       expect(result.isPassByReference).toBe(false);
     });
+
+    it("passes through forceConst from deps (Issue #895)", () => {
+      const ctx = getParameterContext("void foo(Point area) {}");
+      const deps = {
+        ...createDefaultASTDeps({ isKnownStruct: true }),
+        forceConst: true,
+      };
+
+      const result = ParameterInputAdapter.fromAST(ctx, deps);
+
+      expect(result.forceConst).toBe(true);
+    });
+
+    it("passes through forcePassByReference and forceConst together", () => {
+      const ctx = getParameterContext("void foo(Point area) {}");
+      const deps = {
+        ...createDefaultASTDeps({ isKnownStruct: true }),
+        forcePassByReference: true,
+        forceConst: true,
+      };
+
+      const result = ParameterInputAdapter.fromAST(ctx, deps);
+
+      expect(result.forcePointerSyntax).toBe(true);
+      expect(result.forceConst).toBe(true);
+      expect(result.isPassByReference).toBe(true);
+    });
+
+    it("forceConst defaults to undefined when not provided", () => {
+      const ctx = getParameterContext("void foo(Point area) {}");
+      const deps = createDefaultASTDeps({ isKnownStruct: true });
+
+      const result = ParameterInputAdapter.fromAST(ctx, deps);
+
+      expect(result.forceConst).toBeUndefined();
+    });
   });
 });

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

@@ -312,4 +312,67 @@ describe("ParameterSignatureBuilder", () => {
       expect(result).toBe("const UnknownType data");
     });
   });
+
+  describe("callback-compatible parameters (Issue #895)", () => {
+    it("forceConst adds const from typedef signature", () => {
+      const input = createInput({
+        name: "area",
+        baseType: "rect_t",
+        mappedType: "rect_t",
+        isPassByReference: true,
+        forcePointerSyntax: true,
+        forceConst: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "&");
+
+      // Should use pointer (not reference) and add const from typedef
+      expect(result).toBe("const rect_t* area");
+    });
+
+    it("forcePointerSyntax uses pointer in C++ mode", () => {
+      const input = createInput({
+        name: "w",
+        baseType: "widget_t",
+        mappedType: "widget_t",
+        isPassByReference: true,
+        forcePointerSyntax: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "&");
+
+      // Should use pointer even in C++ mode (& suffix)
+      expect(result).toBe("widget_t* w");
+    });
+
+    it("forceConst without forcePointerSyntax still adds const", () => {
+      const input = createInput({
+        name: "data",
+        baseType: "Data",
+        mappedType: "Data",
+        isPassByReference: true,
+        forceConst: true,
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "*");
+
+      expect(result).toBe("const Data* data");
+    });
+
+    it("forceConst combines with forcePointerSyntax in C++ mode", () => {
+      const input = createInput({
+        name: "buf",
+        baseType: "uint8_t",
+        mappedType: "uint8_t",
+        isPassByReference: true,
+        forcePointerSyntax: true,
+        forceConst: false, // typedef doesn't have const
+      });
+
+      const result = ParameterSignatureBuilder.build(input, "&");
+
+      // No const, but still uses pointer
+      expect(result).toBe("uint8_t* buf");
+    });
+  });
 });