c-next 0.2.4 → 0.2.6

package/src/transpiler/output/codegen/assignment/handlers/__tests__/BitmapHandlers.test.ts

@@ -102,7 +102,7 @@ describe("BitmapHandlers", () => {
       const result = getHandler()!(ctx);
 
       expect(result).toContain("flags =");
-      expect(result).toContain("& ~(1 << 0)");
+      expect(result).toContain("& ~(1U << 0)");
       expect(result).toContain("<< 0");
     });
 
@@ -204,8 +204,8 @@ describe("BitmapHandlers", () => {
       const result = getHandler()!(ctx);
 
       expect(result).toContain("flags =");
-      expect(result).toContain("& ~(0x7 << 4)");
-      expect(result).toContain("(3 & 0x7)");
+      expect(result).toContain("& ~(0x7U << 4)");
+      expect(result).toContain("(3 & 0x7U)");
       expect(result).toContain("<< 4");
     });
 
@@ -255,7 +255,7 @@ describe("BitmapHandlers", () => {
       const result = getHandler()!(ctx);
 
       expect(result).toContain("flagsArray[i] =");
-      expect(result).toContain("& ~(1 << 0)");
+      expect(result).toContain("& ~(1U << 0)");
     });
   });
 
@@ -309,7 +309,7 @@ describe("BitmapHandlers", () => {
       const result = getHandler()!(ctx);
 
       expect(result).toContain("MOTOR_CTRL =");
-      expect(result).toContain("& ~(1 << 0)");
+      expect(result).toContain("& ~(1U << 0)");
     });
   });
 

package/src/transpiler/output/codegen/assignment/handlers/__tests__/RegisterHandlers.test.ts

@@ -84,7 +84,7 @@ describe("RegisterHandlers", () => {
       const result = getHandler()!(ctx);
 
       expect(result).toContain("GPIO7_DR_SET");
-      expect(result).toContain("& ~(1 <<");
+      expect(result).toContain("& ~(1U <<");
       expect(result).toContain("LED_BIT");
     });
 
@@ -99,7 +99,7 @@ describe("RegisterHandlers", () => {
 
       const result = getHandler()!(ctx);
 
-      expect(result).toBe("GPIO7_DR_SET = (1 << LED_BIT);");
+      expect(result).toBe("GPIO7_DR_SET = (1U << LED_BIT);");
     });
 
     it("throws on write-only register with false value", () => {
@@ -309,7 +309,7 @@ describe("RegisterHandlers", () => {
       const result = getHandler()!(ctx);
 
       expect(result).toContain("Motor_GPIO7_DR_SET");
-      expect(result).toContain("& ~(1 <<");
+      expect(result).toContain("& ~(1U <<");
     });
 
     it("generates simple write for write-only scoped register", () => {
@@ -327,7 +327,7 @@ describe("RegisterHandlers", () => {
 
       const result = getHandler()!(ctx);
 
-      expect(result).toBe("Motor_GPIO7_DR_SET = (1 << LED_BIT);");
+      expect(result).toBe("Motor_GPIO7_DR_SET = (1U << LED_BIT);");
     });
 
     it("throws when used outside scope", () => {

package/src/transpiler/output/codegen/generators/expressions/CallExprGenerator.ts

@@ -126,21 +126,28 @@ const _generateCFunctionArg = (
 
   // Issue #322: If getExpressionType returns null (e.g., for this.member),
   // fall back to looking up the generated code in the type registry
+  let isPointerVariable = false;
+  const typeInfo = CodeGenState.getVariableTypeInfo(argCode);
   if (!argType && !argCode.startsWith("&")) {
-    const typeInfo = CodeGenState.getVariableTypeInfo(argCode);
     if (typeInfo) {
       argType = typeInfo.baseType;
     }
   }
+  // Issue #895 Bug B: Check if variable was inferred as a pointer
+  if (typeInfo?.isPointer) {
+    isPointerVariable = true;
+  }
 
   // Add & if argument needs address-of to match parameter type.
   // Issue #322: struct types passed to pointer params.
   // Issue #832: typedef'd pointer types (e.g., handle_t passed to handle_t*).
+  // Issue #895 Bug B: Skip address-of for variables that are already pointers
   const needsAddressOf =
     argType &&
     !argType.endsWith("*") &&
     !argCode.startsWith("&") &&
     !targetParam.isArray &&
+    !isPointerVariable &&
     (orchestrator.isStructType(argType) ||
       _parameterExpectsAddressOf(targetParam.baseType, argType, orchestrator));
 

package/src/transpiler/output/codegen/generators/expressions/PostfixExpressionGenerator.ts

@@ -110,6 +110,8 @@ const initializeTrackingState = (
 interface IPostfixContext {
   rootIdentifier: string | undefined;
   isStructParam: boolean;
+  /** Issue #895: Force pointer semantics for callback-compatible params */
+  forcePointerSemantics: boolean;
   input: IGeneratorInput;
   state: IGeneratorState;
   orchestrator: IOrchestrator;
@@ -149,6 +151,8 @@ const generatePostfixExpression = (
     ? state.currentParameters.get(rootIdentifier)
     : null;
   const isStructParam = paramInfo?.isStruct ?? false;
+  // Issue #895: Callback-compatible params need pointer semantics even in C++ mode
+  const forcePointerSemantics = paramInfo?.forcePointerSemantics ?? false;
 
   // Issue #579: Check if we have subscript access on a non-array parameter
   const hasSubscriptOps = ops.some((op) => op.expression().length > 0);
@@ -178,6 +182,7 @@ const generatePostfixExpression = (
   const postfixCtx: IPostfixContext = {
     rootIdentifier,
     isStructParam,
+    forcePointerSemantics,
     input,
     state,
     orchestrator,
@@ -303,6 +308,7 @@ const handleMemberOp = (
       memberName,
       rootIdentifier: ctx.rootIdentifier,
       isStructParam: ctx.isStructParam,
+      forcePointerSemantics: ctx.forcePointerSemantics,
       isGlobalAccess: tracking.isGlobalAccess,
       isCppAccessChain: tracking.isCppAccessChain,
       currentStructType: tracking.currentStructType,
@@ -1409,6 +1415,8 @@ interface IMemberAccessContext {
   memberName: string;
   rootIdentifier: string | undefined;
   isStructParam: boolean;
+  /** Issue #895: Force pointer semantics for callback-compatible params */
+  forcePointerSemantics: boolean;
   isGlobalAccess: boolean;
   isCppAccessChain: boolean;
   currentStructType: string | undefined;
@@ -1657,9 +1665,13 @@ const tryStructParamAccess = (
     return null;
   }
 
-  const structParamSep = memberAccessChain.getStructParamSeparator({
-    cppMode: orchestrator.isCppMode(),
-  });
+  // Issue #895: Force pointer semantics for callback-compatible params
+  // even in C++ mode (use -> instead of .)
+  const structParamSep = ctx.forcePointerSemantics
+    ? "->"
+    : memberAccessChain.getStructParamSeparator({
+        cppMode: orchestrator.isCppMode(),
+      });
 
   const output = initializeMemberOutput(ctx);
   output.result = `${ctx.result}${structParamSep}${ctx.memberName}`;

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

@@ -46,6 +46,11 @@ class ArgumentGenerator {
       return id;
     }
 
+    // Issue #895 Bug B: Inferred pointers are already pointers, don't add &
+    if (typeInfo?.isPointer) {
+      return id;
+    }
+
     // Scope member - may need prefixing
     if (CodeGenState.currentScope) {
       const members = CodeGenState.getScopeMembers(CodeGenState.currentScope);

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

@@ -15,6 +15,8 @@ import CodeGenState from "../../../state/CodeGenState.js";
 import TYPE_WIDTH from "../types/TYPE_WIDTH.js";
 import ArrayDimensionParser from "./ArrayDimensionParser.js";
 import IFunctionContextCallbacks from "../types/IFunctionContextCallbacks.js";
+// Issue #895: Parse typedef signatures to determine pointer vs value params
+import TypedefParamParser from "./TypedefParamParser.js";
 
 /**
  * Result from resolving parameter type information.
@@ -124,8 +126,9 @@ class FunctionContextManager {
     CodeGenState.currentParameters.clear();
     if (!params) return;
 
-    for (const param of params.parameter()) {
-      FunctionContextManager.processParameter(param, callbacks);
+    const paramList = params.parameter();
+    for (let i = 0; i < paramList.length; i++) {
+      FunctionContextManager.processParameter(paramList[i], callbacks, i);
     }
   }
 
@@ -135,6 +138,7 @@ class FunctionContextManager {
   static processParameter(
     param: Parser.ParameterContext,
     callbacks: IFunctionContextCallbacks,
+    paramIndex: number,
   ): void {
     const name = param.IDENTIFIER().getText();
     // Check both C-Next style (u8[8] param) and legacy style (u8 param[8])
@@ -149,23 +153,38 @@ class FunctionContextManager {
       callbacks,
     );
 
-    // For callback-compatible functions, struct params use by-value semantics
-    // (no pointer dereference, dot access instead of arrow in C mode)
-    const isCallbackCompat =
-      CodeGenState.currentFunctionName !== null &&
-      CodeGenState.callbackCompatibleFunctions.has(
-        CodeGenState.currentFunctionName,
-      );
+    // Issue #895: For callback-compatible functions, check the typedef signature
+    // to determine if the param should be a pointer or value
+    const callbackTypedefInfo =
+      FunctionContextManager.getCallbackTypedefParamInfo(paramIndex);
+    const isCallbackPointerParam =
+      callbackTypedefInfo?.shouldBePointer ?? false;
+
+    // Determine isStruct: for callback-compatible params, both typedef AND type info matter
+    // - If typedef says pointer AND it's actually a struct, use -> access (isStruct=true)
+    // - If typedef says pointer BUT it's a primitive (like u8), don't treat as struct
+    //   (primitives use forcePointerSemantics for dereference instead)
+    const isStruct = callbackTypedefInfo
+      ? isCallbackPointerParam && typeInfo.isStruct
+      : typeInfo.isStruct;
+
+    // Issue #895: Primitive types that become pointers need dereferencing when used as values
+    // e.g., "u8 buf" becoming "uint8_t* buf" requires "*buf" when accessing the value
+    const isCallbackPointerPrimitive =
+      isCallbackPointerParam && !typeInfo.isStruct && !isArray;
 
     // Register in currentParameters
     const paramInfo = {
       name,
       baseType: typeInfo.typeName,
       isArray,
-      isStruct: isCallbackCompat ? false : typeInfo.isStruct,
+      isStruct,
       isConst,
       isCallback: typeInfo.isCallback,
       isString: typeInfo.isString,
+      isCallbackPointerPrimitive,
+      // Issue #895: Callback-compatible params need pointer semantics even in C++ mode
+      forcePointerSemantics: isCallbackPointerParam,
     };
     CodeGenState.currentParameters.set(name, paramInfo);
 
@@ -374,6 +393,40 @@ class FunctionContextManager {
     return dimensions;
   }
 
+  /**
+   * Issue #895: Get callback typedef parameter info from the C header.
+   * Returns null if not callback-compatible or index is invalid.
+   */
+  static getCallbackTypedefParamInfo(
+    paramIndex: number,
+  ): { shouldBePointer: boolean; shouldBeConst: boolean } | null {
+    if (CodeGenState.currentFunctionName === null) return null;
+
+    const typedefName = CodeGenState.callbackCompatibleFunctions.get(
+      CodeGenState.currentFunctionName,
+    );
+    if (!typedefName) return null;
+
+    const typedefType = CodeGenState.getTypedefType(typedefName);
+    if (!typedefType) return null;
+
+    const shouldBePointer = TypedefParamParser.shouldBePointer(
+      typedefType,
+      paramIndex,
+    );
+    const shouldBeConst = TypedefParamParser.shouldBeConst(
+      typedefType,
+      paramIndex,
+    );
+
+    if (shouldBePointer === null) return null;
+
+    return {
+      shouldBePointer,
+      shouldBeConst: shouldBeConst ?? false,
+    };
+  }
+
   /**
    * Extract string capacity from a string type context.
    */

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

@@ -15,6 +15,19 @@
 import ISeparatorContext from "../types/ISeparatorContext";
 import IMemberSeparatorDeps from "../types/IMemberSeparatorDeps";
 
+/**
+ * Input parameters for building a separator context
+ */
+interface IBuildContextInput {
+  firstId: string;
+  hasGlobal: boolean;
+  hasThis: boolean;
+  currentScope: string | null;
+  isStructParam: boolean;
+  isCppAccess: boolean;
+  forcePointerSemantics?: boolean;
+}
+
 /**
  * Static utility for resolving member access separators
  */
@@ -23,14 +36,18 @@ class MemberSeparatorResolver {
    * Build the separator context for a member access chain
    */
   static buildContext(
-    firstId: string,
-    hasGlobal: boolean,
-    hasThis: boolean,
-    currentScope: string | null,
-    isStructParam: boolean,
+    input: IBuildContextInput,
     deps: IMemberSeparatorDeps,
-    isCppAccess: boolean,
   ): ISeparatorContext {
+    const {
+      firstId,
+      hasGlobal,
+      hasThis,
+      currentScope,
+      isStructParam,
+      isCppAccess,
+      forcePointerSemantics,
+    } = input;
     const isCrossScope =
       hasGlobal &&
       (deps.isKnownScope(firstId) || deps.isKnownRegister(firstId));
@@ -48,6 +65,7 @@ class MemberSeparatorResolver {
       isCppAccess,
       scopedRegName,
       isScopedRegister,
+      forcePointerSemantics,
     };
   }
 
@@ -66,7 +84,11 @@ class MemberSeparatorResolver {
     }
 
     // Struct parameter uses -> in C mode, . in C++ mode
+    // Issue #895: forcePointerSemantics overrides C++ mode to use ->
     if (ctx.isStructParam) {
+      if (ctx.forcePointerSemantics) {
+        return "->";
+      }
       return deps.getStructParamSeparator();
     }
 

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

@@ -28,6 +28,12 @@ class ParameterDereferenceResolver {
     paramInfo: TParameterInfo,
     deps: IParameterDereferenceDeps,
   ): boolean {
+    // Issue #895: Primitive params that became pointers due to callback typedef
+    // are NOT pass-by-value - they need dereferencing when used as values
+    if (paramInfo.isCallbackPointerPrimitive) {
+      return false; // Not pass-by-value → will be dereferenced
+    }
+
     // ADR-029: Callback parameters are function pointers
     if (paramInfo.isCallback) {
       return true;
@@ -92,6 +98,12 @@ class ParameterDereferenceResolver {
       return id;
     }
 
+    // Issue #895: Callback-compatible primitives always need dereferencing,
+    // even in C++ mode (because they use pointer semantics to match C typedef)
+    if (paramInfo.forcePointerSemantics) {
+      return `(*${id})`;
+    }
+
     // Known primitive that is pass-by-reference needs dereference
     // Issue #558/#644: In C++ mode, primitives become references
     return deps.maybeDereference(id);

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

@@ -42,6 +42,21 @@ interface IFromASTDeps {
 
   /** Whether the parameter should use pass-by-value (pre-computed) */
   isPassByValue: boolean;
+
+  /** Issue #895: Whether the current function is callback-compatible */
+  isCallbackCompatible: boolean;
+
+  /**
+   * Issue #895: Force pass-by-reference for callback-compatible functions
+   * When the typedef signature requires a pointer, this overrides normal logic.
+   */
+  forcePassByReference?: boolean;
+
+  /**
+   * Issue #895: Force const qualifier from callback typedef signature.
+   * When the C typedef has `const T*`, this preserves const on the generated param.
+   */
+  forceConst?: boolean;
 }
 
 /**
@@ -122,7 +137,15 @@ class ParameterInputAdapter {
     // Determine classification for non-array, non-string types
     const isKnownStruct = deps.isKnownStruct(typeName);
     const isKnownPrimitive = !!deps.typeMap[typeName];
-    const isAutoConst = !deps.isModified && !isConst;
+    // Issue #895: Don't add auto-const for callback-compatible functions
+    // because it would change the signature and break typedef compatibility
+    const isAutoConst =
+      !deps.isCallbackCompatible && !deps.isModified && !isConst;
+
+    // Issue #895: For callback-compatible functions, force pass-by-reference
+    // when the typedef signature requires a pointer (e.g., opaque types)
+    const isPassByReference =
+      deps.forcePassByReference || isKnownStruct || isKnownPrimitive;
 
     return {
       name,
@@ -134,7 +157,12 @@ class ParameterInputAdapter {
       isCallback: false,
       isString: false,
       isPassByValue: deps.isPassByValue,
-      isPassByReference: isKnownStruct || isKnownPrimitive,
+      isPassByReference,
+      // Issue #895: Force pointer syntax in C++ mode for callback-compatible functions
+      // because C callback typedefs expect pointers, not C++ references
+      forcePointerSyntax: deps.forcePassByReference,
+      // Issue #895: Preserve const from callback typedef signature
+      forceConst: deps.forceConst,
     };
   }
 

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

@@ -103,14 +103,19 @@ class ParameterSignatureBuilder {
   /**
    * Build pass-by-reference parameter signature.
    * C mode: const Point* p
-   * C++ mode: const Point& p
+   * C++ mode: const Point& p (unless forcePointerSyntax)
+   *
+   * Issue #895: When forcePointerSyntax is set, always use pointer syntax
+   * because C callback typedefs expect pointers, not C++ references.
    */
   private static _buildRefParam(
     param: IParameterInput,
     refSuffix: string,
   ): string {
     const constPrefix = this._getConstPrefix(param);
-    return `${constPrefix}${param.mappedType}${refSuffix} ${param.name}`;
+    // Issue #895: Override refSuffix for callback-compatible functions
+    const actualSuffix = param.forcePointerSyntax ? "*" : refSuffix;
+    return `${constPrefix}${param.mappedType}${actualSuffix} ${param.name}`;
   }
 
   /**
@@ -122,13 +127,16 @@ class ParameterSignatureBuilder {
   }
 
   /**
-   * Get const prefix combining explicit const and auto-const.
-   * Auto-const is applied to unmodified parameters.
+   * Get const prefix combining explicit const, auto-const, and forced const.
+   * Priority: forceConst > isConst > isAutoConst
+   * Issue #895: forceConst preserves const from callback typedef signature.
    */
   private static _getConstPrefix(param: IParameterInput): string {
-    const autoConst = param.isAutoConst && !param.isConst ? "const " : "";
-    const explicitConst = param.isConst ? "const " : "";
-    return `${autoConst}${explicitConst}`;
+    // Any source of const results in "const " prefix
+    if (param.forceConst || param.isConst || param.isAutoConst) {
+      return "const ";
+    }
+    return "";
   }
 }
 

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/StringOperationsHelper.ts

@@ -11,7 +11,7 @@
 import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
 import CodeGenState from "../../../state/CodeGenState.js";
 import StringUtils from "../../../../utils/StringUtils.js";
-import ExpressionUnwrapper from "../utils/ExpressionUnwrapper.js";
+import ExpressionUnwrapper from "../../../../utils/ExpressionUnwrapper";
 
 /** Regex for identifying valid C/C++ identifiers */
 const IDENTIFIER_REGEX = /^[a-zA-Z_]\w*$/;