c-next 0.2.4 → 0.2.6

package/dist/index.js

@@ -10,7 +10,7 @@ import { hideBin } from "yargs/helpers";
 // package.json
 var package_default = {
   name: "c-next",
-  version: "0.2.4",
+  version: "0.2.6",
   description: "A safer C for embedded systems development. Transpiles to clean, readable C.",
   packageManager: "npm@11.9.0",
   type: "module",
@@ -32,6 +32,8 @@ var package_default = {
     "test:cli": "node scripts/test-cli.js",
     "test:q": "tsx scripts/test.ts -q",
     "test:update": "tsx scripts/test.ts --update",
+    "integration:transpile": "tsx scripts/test.ts --transpile-only",
+    "integration:execute": "tsx scripts/test.ts --execute-only",
     analyze: "./scripts/static-analysis.sh",
     clean: "rm -rf dist src/transpiler/logic/parser/grammar src/transpiler/logic/parser/c/grammar src/transpiler/logic/parser/cpp/grammar",
     "prettier:check": "prettier --check .",
@@ -110764,8 +110766,12 @@ var CodeGenState = class {
   static callbackTypes = /* @__PURE__ */ new Map();
   /** Callback field types: "Struct.field" -> callbackTypeName */
   static callbackFieldTypes = /* @__PURE__ */ new Map();
-  /** Functions that need C-callback-compatible (by-value) struct parameters */
-  static callbackCompatibleFunctions = /* @__PURE__ */ new Set();
+  /**
+   * Functions that are assigned to C callback typedefs.
+   * Maps function name -> typedef name (e.g., "my_flush" -> "flush_cb_t")
+   * Issue #895: We need the typedef name to look up parameter types.
+   */
+  static callbackCompatibleFunctions = /* @__PURE__ */ new Map();
   // ===========================================================================
   // PASS-BY-VALUE ANALYSIS (Issue #269)
   // ===========================================================================
@@ -111133,6 +111139,20 @@ var CodeGenState = class {
   static getCallbackType(name) {
     return this.callbackTypes.get(name);
   }
+  /**
+   * Issue #895: Get the typedef type string for a C typedef by name.
+   * Used to look up function pointer typedef signatures for callback-compatible functions.
+   *
+   * @param typedefName - Name of the typedef (e.g., "flush_cb_t")
+   * @returns The type string (e.g., "void (*)(widget_t *, const rect_t *, uint8_t *)") or undefined
+   */
+  static getTypedefType(typedefName) {
+    const symbol = this.symbolTable.getCSymbol(typedefName);
+    if (symbol?.kind === "type") {
+      return symbol.type;
+    }
+    return void 0;
+  }
   /**
    * Check if a type name is a known C-Next function.
    */
@@ -112906,7 +112926,7 @@ var TYPE_RANGES = {
 };
 var TYPE_RANGES_default = TYPE_RANGES;
 
-// src/transpiler/output/codegen/utils/ExpressionUnwrapper.ts
+// src/utils/ExpressionUnwrapper.ts
 var ExpressionUnwrapper = class {
   /**
    * Navigate from ExpressionContext to ShiftExpressionContext.
@@ -115145,13 +115165,17 @@ var _generateCFunctionArg = (e, targetParam, input, orchestrator) => {
     return wrapWithCppEnumCast(argCode, e, targetParam?.baseType, orchestrator);
   }
   let argType = orchestrator.getExpressionType(e);
+  let isPointerVariable = false;
+  const typeInfo = CodeGenState.getVariableTypeInfo(argCode);
   if (!argType && !argCode.startsWith("&")) {
-    const typeInfo = CodeGenState.getVariableTypeInfo(argCode);
     if (typeInfo) {
       argType = typeInfo.baseType;
     }
   }
-  const needsAddressOf = argType && !argType.endsWith("*") && !argCode.startsWith("&") && !targetParam.isArray && (orchestrator.isStructType(argType) || _parameterExpectsAddressOf(targetParam.baseType, argType, orchestrator));
+  if (typeInfo?.isPointer) {
+    isPointerVariable = true;
+  }
+  const needsAddressOf = argType && !argType.endsWith("*") && !argCode.startsWith("&") && !targetParam.isArray && !isPointerVariable && (orchestrator.isStructType(argType) || _parameterExpectsAddressOf(targetParam.baseType, argType, orchestrator));
   if (needsAddressOf) {
     argCode = `&${argCode}`;
   }
@@ -115744,6 +115768,7 @@ var generatePostfixExpression = (ctx, input, state, orchestrator) => {
   const rootIdentifier = primary.IDENTIFIER()?.getText();
   const paramInfo = rootIdentifier ? state.currentParameters.get(rootIdentifier) : null;
   const isStructParam = paramInfo?.isStruct ?? false;
+  const forcePointerSemantics = paramInfo?.forcePointerSemantics ?? false;
   const hasSubscriptOps = ops.some((op) => op.expression().length > 0);
   const isNonArrayParamWithSubscript = paramInfo && !paramInfo.isArray && !paramInfo.isStruct && hasSubscriptOps;
   let result;
@@ -115764,6 +115789,7 @@ var generatePostfixExpression = (ctx, input, state, orchestrator) => {
   const postfixCtx = {
     rootIdentifier,
     isStructParam,
+    forcePointerSemantics,
     input,
     state,
     orchestrator,
@@ -115855,6 +115881,7 @@ var handleMemberOp = (memberName, tracking, ctx) => {
       memberName,
       rootIdentifier: ctx.rootIdentifier,
       isStructParam: ctx.isStructParam,
+      forcePointerSemantics: ctx.forcePointerSemantics,
       isGlobalAccess: tracking.isGlobalAccess,
       isCppAccessChain: tracking.isCppAccessChain,
       currentStructType: tracking.currentStructType,
@@ -116589,7 +116616,7 @@ var tryStructParamAccess = (ctx, orchestrator) => {
   if (!ctx.isStructParam || ctx.result !== ctx.rootIdentifier) {
     return null;
   }
-  const structParamSep = memberAccessChain_default.getStructParamSeparator({
+  const structParamSep = ctx.forcePointerSemantics ? "->" : memberAccessChain_default.getStructParamSeparator({
     cppMode: orchestrator.isCppMode()
   });
   const output = initializeMemberOutput(ctx);
@@ -116838,15 +116865,18 @@ var VariableModifierBuilder = class {
    *
    * @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, inFunctionBody) {
+  static build(ctx, inFunctionBody, hasInitializer = false, cppMode = false) {
     const hasConst = ctx.constModifier?.() ?? false;
     const constMod = hasConst ? "const " : "";
     const atomicMod = ctx.atomicModifier() ? "volatile " : "";
     const volatileMod = ctx.volatileModifier() ? "volatile " : "";
-    const externMod = hasConst && !inFunctionBody ? "extern " : "";
+    const needsExtern = hasConst && !inFunctionBody && (cppMode || !hasInitializer);
+    const externMod = needsExtern ? "extern " : "";
     if (ctx.atomicModifier() && ctx.volatileModifier()) {
       const line = ctx.start?.line ?? 0;
       throw new Error(
@@ -118034,16 +118064,17 @@ var ScopeGenerator_default = generateScope;
 // src/utils/BitUtils.ts
 var BitUtils = 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) {
-    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)`;
   }
   /**
    * Generate a bit mask for the given width.
@@ -118100,24 +118131,26 @@ var BitUtils = 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) {
-    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) {
-    return `0x${value.toString(16).toUpperCase()}`;
+    return `0x${value.toString(16).toUpperCase()}U`;
   }
   /**
    * Generate code to read a single bit from a value.
@@ -118163,7 +118196,7 @@ var BitUtils = class _BitUtils {
   static singleBitWrite(target, offset, value, targetType) {
     const intValue = _BitUtils.boolToInt(value);
     const is64Bit = targetType === "u64" || targetType === "i64";
-    const one = is64Bit ? "1ULL" : "1";
+    const one = is64Bit ? "1ULL" : "1U";
     const valueShift = is64Bit ? `((uint64_t)${intValue} << ${offset})` : `(${intValue} << ${offset})`;
     return `${target} = (${target} & ~(${one} << ${offset})) | ${valueShift};`;
   }
@@ -120847,7 +120880,7 @@ function getBitmapFieldInfo(bitmapType, fieldName, ctx) {
 function generateBitmapWrite(target, fieldInfo, value) {
   const { maskHex } = calculateMask(fieldInfo.width);
   if (fieldInfo.width === 1) {
-    return `${target} = (${target} & ~(1 << ${fieldInfo.offset})) | (${BitUtils_default.boolToInt(value)} << ${fieldInfo.offset});`;
+    return `${target} = (${target} & ~(1U << ${fieldInfo.offset})) | (${BitUtils_default.boolToInt(value)} << ${fieldInfo.offset});`;
   } else {
     return `${target} = (${target} & ~(${maskHex} << ${fieldInfo.offset})) | ((${value} & ${maskHex}) << ${fieldInfo.offset});`;
   }
@@ -121100,9 +121133,9 @@ function handleRegisterBit(ctx) {
       bitIndex,
       true
     );
-    return `${fullName} = (1 << ${bitIndex});`;
+    return `${fullName} = (1U << ${bitIndex});`;
   }
-  return `${fullName} = (${fullName} & ~(1 << ${bitIndex})) | (${BitUtils_default.boolToInt(ctx.generatedValue)} << ${bitIndex});`;
+  return `${fullName} = (${fullName} & ~(1U << ${bitIndex})) | (${BitUtils_default.boolToInt(ctx.generatedValue)} << ${bitIndex});`;
 }
 function handleRegisterBitRange(ctx) {
   AssignmentHandlerUtils_default.validateNoCompoundForBitAccess(
@@ -121168,9 +121201,9 @@ function handleScopedRegisterBit(ctx) {
       bitIndex,
       true
     );
-    return `${regName} = (1 << ${bitIndex});`;
+    return `${regName} = (1U << ${bitIndex});`;
   }
-  return `${regName} = (${regName} & ~(1 << ${bitIndex})) | (${BitUtils_default.boolToInt(ctx.generatedValue)} << ${bitIndex});`;
+  return `${regName} = (${regName} & ~(1U << ${bitIndex})) | (${BitUtils_default.boolToInt(ctx.generatedValue)} << ${bitIndex});`;
 }
 function handleScopedRegisterBitRange(ctx) {
   AssignmentHandlerUtils_default.validateScopeContext(CodeGenState.currentScope);
@@ -121416,7 +121449,7 @@ function handleStructMemberBit(ctx) {
   validateNotCompound2(ctx);
   const target = gen6().generateAssignmentTarget(ctx.targetCtx);
   const bitIndex = gen6().generateExpression(ctx.subscripts.at(-1));
-  const one = "1";
+  const one = "1U";
   const intValue = BitUtils_default.boolToInt(ctx.generatedValue);
   return `${target} = (${target} & ~(${one} << ${bitIndex})) | (${intValue} << ${bitIndex});`;
 }
@@ -121664,9 +121697,9 @@ function handleGlobalRegisterBit(ctx) {
         `Cannot assign false to write-only register bit ${regName}[${bitIndex}]. Use the corresponding CLEAR register to clear bits.`
       );
     }
-    return `${regName} = (1 << ${bitIndex});`;
+    return `${regName} = (1U << ${bitIndex});`;
   }
-  return `${regName} = (${regName} & ~(1 << ${bitIndex})) | (${BitUtils_default.boolToInt(ctx.generatedValue)} << ${bitIndex});`;
+  return `${regName} = (${regName} & ~(1U << ${bitIndex})) | (${BitUtils_default.boolToInt(ctx.generatedValue)} << ${bitIndex});`;
 }
 function handleMemberChain(ctx) {
   const bitAnalysis = gen9().analyzeMemberChainForBitAccess(ctx.targetCtx);
@@ -122816,6 +122849,9 @@ var ArgumentGenerator = class _ArgumentGenerator {
     if (typeInfo?.isArray && !typeInfo.isString) {
       return id;
     }
+    if (typeInfo?.isPointer) {
+      return id;
+    }
     if (CodeGenState.currentScope) {
       const members = CodeGenState.getScopeMembers(CodeGenState.currentScope);
       if (members?.has(id)) {
@@ -124082,7 +124118,11 @@ var StringDeclHelper = class _StringDeclHelper {
       initValue,
       arrayDims
     );
-    return { code: `${decl} = ${finalInitValue};`, handled: true };
+    const suppression = "// cppcheck-suppress misra-c2012-9.3\n// cppcheck-suppress misra-c2012-9.4\n";
+    return {
+      code: `${suppression}${decl} = ${finalInitValue};`,
+      handled: true
+    };
   }
   /**
    * Handle size inference for empty array dimension.
@@ -124558,15 +124598,21 @@ ${assignments}`;
         { generateType: callbacks.generateType }
       );
     }
+    const hasInitializer = ctx.expression() !== null;
     const modifiers = VariableModifierBuilder_default.build(
       ctx,
-      CodeGenState.inFunctionBody
+      CodeGenState.inFunctionBody,
+      hasInitializer,
+      CodeGenState.cppMode
     );
     const name = ctx.IDENTIFIER().getText();
     const typeCtx = ctx.type();
     _VariableDeclHelper.validateArrayDeclarationSyntax(ctx, typeCtx, name);
     const type = callbacks.inferVariableType(ctx, name);
     callbacks.trackLocalVariable(ctx, name);
+    if (type.endsWith("*")) {
+      callbacks.markVariableAsPointer(name);
+    }
     const stringResult = StringDeclHelper_default.generateStringDecl(
       typeCtx,
       name,
@@ -124794,7 +124840,16 @@ var MemberSeparatorResolver = class _MemberSeparatorResolver {
   /**
    * Build the separator context for a member access chain
    */
-  static buildContext(firstId, hasGlobal, hasThis, currentScope, isStructParam, deps, isCppAccess) {
+  static buildContext(input, deps) {
+    const {
+      firstId,
+      hasGlobal,
+      hasThis,
+      currentScope,
+      isStructParam,
+      isCppAccess,
+      forcePointerSemantics
+    } = input;
     const isCrossScope = hasGlobal && (deps.isKnownScope(firstId) || deps.isKnownRegister(firstId));
     const scopedRegName = hasThis && currentScope ? `${currentScope}_${firstId}` : null;
     const isScopedRegister = scopedRegName !== null && deps.isKnownRegister(scopedRegName);
@@ -124804,7 +124859,8 @@ var MemberSeparatorResolver = class _MemberSeparatorResolver {
       isStructParam,
       isCppAccess,
       scopedRegName,
-      isScopedRegister
+      isScopedRegister,
+      forcePointerSemantics
     };
   }
   /**
@@ -124815,6 +124871,9 @@ var MemberSeparatorResolver = class _MemberSeparatorResolver {
       return "::";
     }
     if (ctx.isStructParam) {
+      if (ctx.forcePointerSemantics) {
+        return "->";
+      }
       return deps.getStructParamSeparator();
     }
     if (ctx.isCrossScope) {
@@ -124875,6 +124934,9 @@ var ParameterDereferenceResolver = class _ParameterDereferenceResolver {
    * Determine if a parameter should be passed by value (no dereference needed)
    */
   static isPassByValue(paramInfo, deps) {
+    if (paramInfo.isCallbackPointerPrimitive) {
+      return false;
+    }
     if (paramInfo.isCallback) {
       return true;
     }
@@ -124913,6 +124975,9 @@ var ParameterDereferenceResolver = class _ParameterDereferenceResolver {
     if (_ParameterDereferenceResolver.isPassByValue(paramInfo, deps)) {
       return id;
     }
+    if (paramInfo.forcePointerSemantics) {
+      return `(*${id})`;
+    }
     return deps.maybeDereference(id);
   }
 };
@@ -125455,6 +125520,137 @@ var CastValidator = class _CastValidator {
 };
 var CastValidator_default = CastValidator;
 
+// src/transpiler/output/codegen/helpers/TypedefParamParser.ts
+var TypedefParamParser = 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) {
+    const funcPtrIndex = typedefType.indexOf("(*)");
+    if (funcPtrIndex === -1) {
+      return null;
+    }
+    const returnType = typedefType.substring(0, funcPtrIndex).trim();
+    const afterFuncPtr = typedefType.substring(funcPtrIndex + 3).trim();
+    if (!afterFuncPtr.startsWith("(")) {
+      return null;
+    }
+    const paramsStr = _TypedefParamParser.extractParenContent(afterFuncPtr);
+    if (paramsStr === null) {
+      return null;
+    }
+    if (!paramsStr || paramsStr === "void") {
+      return { returnType, params: [] };
+    }
+    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
+   */
+  static extractParenContent(str) {
+    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) {
+          return str.substring(1, i);
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Split parameter string by commas, respecting nested parentheses.
+   */
+  static splitParams(paramsStr) {
+    const params = [];
+    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.
+   */
+  static parseParam(paramStr) {
+    const trimmed = paramStr.trim();
+    const isPointer = trimmed.includes("*");
+    const isConst = /\bconst\b/.test(trimmed) || trimmed.startsWith("const");
+    let baseType = trimmed.replaceAll(/\bconst\b/g, "").replace(/^const/, "").replaceAll("*", "").replaceAll(/\s+/g, " ").trim();
+    if (baseType.includes(" ")) {
+      baseType = baseType.replace(/\s+\w+$/, "");
+    }
+    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.
+   */
+  static getParamAt(typedefType, paramIndex) {
+    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, paramIndex) {
+    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, paramIndex) {
+    return _TypedefParamParser.getParamAt(typedefType, paramIndex)?.isConst ?? null;
+  }
+};
+var TypedefParamParser_default = TypedefParamParser;
+
 // src/transpiler/output/codegen/helpers/FunctionContextManager.ts
 var FunctionContextManager = class _FunctionContextManager {
   /**
@@ -125515,14 +125711,15 @@ var FunctionContextManager = class _FunctionContextManager {
   static processParameterList(params, callbacks) {
     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);
     }
   }
   /**
    * Process a single parameter declaration.
    */
-  static processParameter(param, callbacks) {
+  static processParameter(param, callbacks, paramIndex) {
     const name = param.IDENTIFIER().getText();
     const isArray = param.arrayDimension().length > 0 || param.type().arrayType() !== null;
     const isConst = param.constModifier() !== null;
@@ -125531,17 +125728,21 @@ var FunctionContextManager = class _FunctionContextManager {
       typeCtx,
       callbacks
     );
-    const isCallbackCompat = CodeGenState.currentFunctionName !== null && CodeGenState.callbackCompatibleFunctions.has(
-      CodeGenState.currentFunctionName
-    );
+    const callbackTypedefInfo = _FunctionContextManager.getCallbackTypedefParamInfo(paramIndex);
+    const isCallbackPointerParam = callbackTypedefInfo?.shouldBePointer ?? false;
+    const isStruct = callbackTypedefInfo ? isCallbackPointerParam && typeInfo.isStruct : typeInfo.isStruct;
+    const isCallbackPointerPrimitive = isCallbackPointerParam && !typeInfo.isStruct && !isArray;
     const paramInfo = {
       name,
       baseType: typeInfo.typeName,
       isArray,
-      isStruct: isCallbackCompat ? false : typeInfo.isStruct,
+      isStruct,
       isConst,
       isCallback: typeInfo.isCallback,
-      isString: typeInfo.isString
+      isString: typeInfo.isString,
+      isCallbackPointerPrimitive,
+      // Issue #895: Callback-compatible params need pointer semantics even in C++ mode
+      forcePointerSemantics: isCallbackPointerParam
     };
     CodeGenState.currentParameters.set(name, paramInfo);
     _FunctionContextManager.registerParameterType(
@@ -125704,6 +125905,32 @@ var FunctionContextManager = 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) {
+    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_default.shouldBePointer(
+      typedefType,
+      paramIndex
+    );
+    const shouldBeConst = TypedefParamParser_default.shouldBeConst(
+      typedefType,
+      paramIndex
+    );
+    if (shouldBePointer === null) return null;
+    return {
+      shouldBePointer,
+      shouldBeConst: shouldBeConst ?? false
+    };
+  }
   /**
    * Extract string capacity from a string type context.
    */
@@ -126496,7 +126723,8 @@ var ParameterInputAdapter = class {
     }
     const isKnownStruct = deps.isKnownStruct(typeName);
     const isKnownPrimitive = !!deps.typeMap[typeName];
-    const isAutoConst = !deps.isModified && !isConst;
+    const isAutoConst = !deps.isCallbackCompatible && !deps.isModified && !isConst;
+    const isPassByReference = deps.forcePassByReference || isKnownStruct || isKnownPrimitive;
     return {
       name,
       baseType: typeName,
@@ -126507,7 +126735,12 @@ var ParameterInputAdapter = class {
       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
     };
   }
   /**
@@ -126721,11 +126954,15 @@ var ParameterSignatureBuilder = class {
   /**
    * 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.
    */
   static _buildRefParam(param, refSuffix) {
     const constPrefix = this._getConstPrefix(param);
-    return `${constPrefix}${param.mappedType}${refSuffix} ${param.name}`;
+    const actualSuffix = param.forcePointerSyntax ? "*" : refSuffix;
+    return `${constPrefix}${param.mappedType}${actualSuffix} ${param.name}`;
   }
   /**
    * Build unknown type parameter (pass by value, standard C semantics).
@@ -126735,13 +126972,15 @@ var ParameterSignatureBuilder = class {
     return `${constMod}${param.mappedType} ${param.name}`;
   }
   /**
-   * 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.
    */
   static _getConstPrefix(param) {
-    const autoConst = param.isAutoConst && !param.isConst ? "const " : "";
-    const explicitConst = param.isConst ? "const " : "";
-    return `${autoConst}${explicitConst}`;
+    if (param.forceConst || param.isConst || param.isAutoConst) {
+      return "const ";
+    }
+    return "";
   }
 };
 var ParameterSignatureBuilder_default = ParameterSignatureBuilder;
@@ -127717,7 +127956,7 @@ var CodeGenerator = class _CodeGenerator {
   }
   /** Generate parameter list for function signature */
   generateParameterList(ctx) {
-    return ctx.parameter().map((p) => this.generateParameter(p)).join(", ");
+    return ctx.parameter().map((p, index) => this.generateParameter(p, index)).join(", ");
   }
   /** Get the raw type name without C conversion */
   getTypeName(ctx) {
@@ -129463,13 +129702,17 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
     const typedef = this.generateCallbackTypedef(name);
     return typedef ? functionCode + typedef : functionCode;
   }
-  generateParameter(ctx) {
+  generateParameter(ctx, paramIndex) {
     const typeName = this.getTypeName(ctx.type());
     const name = ctx.IDENTIFIER().getText();
     this._validateCStyleArrayParam(ctx, typeName, name);
     this._validateUnboundedArrayParam(ctx);
     const isModified = this._isCurrentParameterModified(name);
-    const isPassByValue = this._isPassByValueType(typeName, name);
+    const callbackInfo = paramIndex === void 0 ? null : FunctionContextManager_default.getCallbackTypedefParamInfo(paramIndex);
+    const isPassByValue = callbackInfo ? !callbackInfo.shouldBePointer : this._isPassByValueType(typeName, name);
+    const isCallbackCompatible = callbackInfo !== null;
+    const forcePassByReference = callbackInfo?.shouldBePointer ?? false;
+    const forceConst = callbackInfo?.shouldBeConst ?? false;
     const input = ParameterInputAdapter_default.fromAST(ctx, {
       getTypeName: (t) => this.getTypeName(t),
       generateType: (t) => this.generateType(t),
@@ -129478,7 +129721,10 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
       isKnownStruct: (t) => this.isKnownStruct(t),
       typeMap: TYPE_MAP_default,
       isModified,
-      isPassByValue
+      isPassByValue,
+      isCallbackCompatible,
+      forcePassByReference,
+      forceConst
     });
     return ParameterSignatureBuilder_default.build(input, CppModeHelper_default.refOrPtr());
   }
@@ -129548,6 +129794,7 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
       getExpressionType: (exprCtx) => this.getExpressionType(exprCtx),
       inferVariableType: (varCtx, name) => this._inferVariableType(varCtx, name),
       trackLocalVariable: (varCtx, name) => this._trackLocalVariable(varCtx, name),
+      markVariableAsPointer: (name) => this._markVariableAsPointer(name),
       getStringConcatOperands: (concatCtx) => this._getStringConcatOperands(concatCtx),
       getSubstringOperands: (substrCtx) => this._getSubstringOperands(substrCtx),
       getStringExprCapacity: (exprCode) => this.getStringExprCapacity(exprCode),
@@ -129556,20 +129803,116 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
   }
   /**
    * Issue #696: Infer variable type, handling nullable C pointer types.
+   * Issue #895 Bug B: Infer pointer type from C function return type.
    */
   _inferVariableType(ctx, name) {
-    let type = this.generateType(ctx.type());
-    if (!name.startsWith("c_") || !ctx.expression()) {
+    const type = this.generateType(ctx.type());
+    if (!ctx.expression()) {
       return type;
     }
-    const exprText = ctx.expression().getText();
-    for (const funcName of NullCheckAnalyzer_default.getStructPointerFunctions()) {
-      if (exprText.includes(`${funcName}(`)) {
-        return `${type}*`;
+    const pointerType = this._inferPointerTypeFromFunctionCall(
+      ctx.expression(),
+      type
+    );
+    if (pointerType) {
+      return pointerType;
+    }
+    if (name.startsWith("c_")) {
+      const exprText = ctx.expression().getText();
+      for (const funcName of NullCheckAnalyzer_default.getStructPointerFunctions()) {
+        if (exprText.includes(`${funcName}(`)) {
+          return `${type}*`;
+        }
       }
     }
     return type;
   }
+  /**
+   * Issue #895 Bug B: Infer pointer type from C function return type.
+   * If initializer is a call to a C function that returns T*, and declared
+   * type is T, return T* instead of T.
+   */
+  _inferPointerTypeFromFunctionCall(expr, declaredType) {
+    const funcName = this._extractCFunctionName(expr);
+    if (!funcName) {
+      return null;
+    }
+    const cFunc = CodeGenState.symbolTable?.getCSymbol(funcName);
+    if (cFunc?.kind !== "function") {
+      return null;
+    }
+    const returnType = cFunc.type;
+    if (!returnType.endsWith("*")) {
+      return null;
+    }
+    const returnBaseType = returnType.replace(/\s*\*\s*$/, "").trim();
+    if (returnBaseType === declaredType) {
+      return `${declaredType}*`;
+    }
+    return null;
+  }
+  /**
+   * Extract C function name from expression patterns.
+   * Handles both:
+   * - global.funcName(...) - explicit global access
+   * - funcName(...) - direct call (if funcName is a known C function)
+   * Returns null if expression doesn't match these patterns.
+   */
+  _extractCFunctionName(expr) {
+    const postfix = ExpressionUnwrapper_default.getPostfixExpression(expr);
+    if (!postfix) {
+      return null;
+    }
+    const primary = postfix.primaryExpression();
+    const ops = postfix.postfixOp();
+    if (primary.GLOBAL()) {
+      return this._extractGlobalPatternFuncName(ops);
+    }
+    const identifier = primary.IDENTIFIER();
+    if (identifier) {
+      return this._extractDirectCallFuncName(identifier.getText(), ops);
+    }
+    return null;
+  }
+  /**
+   * Extract function name from global.funcName(...) pattern.
+   */
+  _extractGlobalPatternFuncName(ops) {
+    if (ops.length < 2) {
+      return null;
+    }
+    const memberOp = ops[0];
+    if (!memberOp.IDENTIFIER()) {
+      return null;
+    }
+    const callOp = ops[1];
+    if (!this._isCallOp(callOp)) {
+      return null;
+    }
+    return memberOp.IDENTIFIER().getText();
+  }
+  /**
+   * Extract function name from direct funcName(...) call if it's a C function.
+   */
+  _extractDirectCallFuncName(funcName, ops) {
+    if (ops.length < 1) {
+      return null;
+    }
+    if (!this._isCallOp(ops[0])) {
+      return null;
+    }
+    const cFunc = CodeGenState.symbolTable?.getCSymbol(funcName);
+    if (cFunc?.kind === "function") {
+      return funcName;
+    }
+    return null;
+  }
+  /**
+   * Check if a postfix op is a function call.
+   */
+  _isCallOp(op) {
+    return Boolean(op.argumentList() || op.getText().startsWith("("));
+  }
   /**
    * Issue #696: Track local variable for type registry and const values.
    */
@@ -129590,6 +129933,20 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
       }
     }
   }
+  /**
+   * Issue #895 Bug B: Mark variable as a pointer in the type registry.
+   * Called when type inference detects that a variable should be a pointer
+   * (e.g., initialized from a C function returning T*).
+   */
+  _markVariableAsPointer(name) {
+    const typeInfo = CodeGenState.getVariableTypeInfo(name);
+    if (typeInfo) {
+      CodeGenState.setVariableTypeInfo(name, {
+        ...typeInfo,
+        isPointer: true
+      });
+    }
+  }
   // Issue #792: Methods _handleArrayDeclaration, _getArrayTypeDimension, _parseArrayTypeDimension,
   // _parseFirstArrayDimension, _validateArrayDeclarationSyntax, _extractBaseTypeName,
   // _generateVariableInitializer, _validateIntegerInitializer, _finalizeCppClassAssignments,
@@ -129816,14 +130173,18 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
     const isStructParam = paramInfo?.isStruct ?? false;
     const isCppAccess = hasGlobal && this.isCppScopeSymbol(firstId);
     const separatorDeps = this._buildMemberSeparatorDeps();
+    const forcePointerSemantics = paramInfo?.forcePointerSemantics ?? false;
     const separatorCtx = MemberSeparatorResolver_default.buildContext(
-      firstId,
-      hasGlobal,
-      hasThis,
-      CodeGenState.currentScope,
-      isStructParam,
-      separatorDeps,
-      isCppAccess
+      {
+        firstId,
+        hasGlobal,
+        hasThis,
+        currentScope: CodeGenState.currentScope,
+        isStructParam,
+        isCppAccess,
+        forcePointerSemantics
+      },
+      separatorDeps
     );
     return {
       generateExpression: (expr) => this.generateExpression(expr),
@@ -133162,6 +133523,8 @@ var FunctionCollector2 = class _FunctionCollector {
     const parameters = _FunctionCollector._mapParameters(
       DeclaratorUtils_default.extractFunctionParameters(declarator)
     );
+    const hasPointer = declarator.pointer() !== null;
+    const returnType = hasPointer ? `${baseType}*` : baseType;
     return {
       kind: "function",
       name,
@@ -133169,7 +133532,7 @@ var FunctionCollector2 = class _FunctionCollector {
       sourceLine: line,
       sourceLanguage: ESourceLanguage_default.C,
       isExported: !isExtern,
-      type: baseType,
+      type: returnType,
       parameters: parameters.length > 0 ? parameters : void 0,
       isDeclaration: true
     };
@@ -136858,6 +137221,8 @@ var FunctionCallAnalyzer = class {
     if (sym?.kind !== "type") return false;
     return "type" in sym && typeof sym.type === "string" && sym.type.includes("(*)");
   }
+  /** Current scope name during callback assignment scanning */
+  scanCurrentScope = null;
   /**
    * Detect functions assigned to C function pointer typedefs.
    * When `PointCallback cb <- my_handler;` is found and PointCallback
@@ -136866,12 +137231,46 @@ var FunctionCallAnalyzer = class {
   collectCallbackCompatibleFunctions(tree) {
     for (const decl of tree.declaration()) {
       const funcDecl = decl.functionDeclaration();
-      if (!funcDecl) continue;
-      const block = funcDecl.block();
-      if (!block) continue;
-      this.scanBlockForCallbackAssignments(block);
+      if (funcDecl) {
+        this.scanStandaloneFunctionForCallbacks(funcDecl);
+        continue;
+      }
+      const scopeDecl = decl.scopeDeclaration();
+      if (scopeDecl) {
+        this.scanScopeForCallbacks(scopeDecl);
+      }
     }
   }
+  /**
+   * Scan a standalone function declaration for callback assignments.
+   */
+  scanStandaloneFunctionForCallbacks(funcDecl) {
+    const block = funcDecl.block();
+    if (!block) return;
+    this.scanCurrentScope = null;
+    this.scanBlockForCallbackAssignments(block);
+  }
+  /**
+   * Scan all member functions in a scope for callback assignments (Issue #895).
+   */
+  scanScopeForCallbacks(scopeDecl) {
+    const scopeName = scopeDecl.IDENTIFIER().getText();
+    for (const member of scopeDecl.scopeMember()) {
+      this.scanScopeMemberForCallbacks(member, scopeName);
+    }
+    this.scanCurrentScope = null;
+  }
+  /**
+   * Scan a single scope member for callback assignments.
+   */
+  scanScopeMemberForCallbacks(member, scopeName) {
+    const memberFunc = member.functionDeclaration();
+    if (!memberFunc) return;
+    const block = memberFunc.block();
+    if (!block) return;
+    this.scanCurrentScope = scopeName;
+    this.scanBlockForCallbackAssignments(block);
+  }
   /**
    * Recursively scan all statements in a block for callback typedef assignments.
    */
@@ -136890,6 +137289,11 @@ var FunctionCallAnalyzer = class {
       this.checkVarDeclForCallbackAssignment(varDecl);
       return;
     }
+    const exprStmt = stmt.expressionStatement();
+    if (exprStmt) {
+      this.checkExpressionForCallbackArgs(exprStmt.expression());
+      return;
+    }
     const ifStmt = stmt.ifStatement();
     if (ifStmt) {
       for (const child of ifStmt.statement()) {
@@ -136945,22 +137349,101 @@ var FunctionCallAnalyzer = class {
     if (!funcRef) return;
     const lookupName = funcRef.includes(".") ? funcRef.replace(".", "_") : funcRef;
     if (this.allLocalFunctions.has(lookupName)) {
-      CodeGenState.callbackCompatibleFunctions.add(lookupName);
+      CodeGenState.callbackCompatibleFunctions.set(lookupName, typeName);
     }
   }
   /**
    * Extract a function reference from an expression context.
-   * Matches bare identifiers (e.g., "my_handler") and qualified scope
-   * names (e.g., "MyScope.handler").
+   * Matches:
+   *   - Bare identifiers: "my_handler"
+   *   - Qualified scope names: "MyScope.handler"
+   *   - Self-scope reference: "this.handler" (resolved using scanCurrentScope)
+   *   - Global scope reference: "global.ScopeName.handler"
    * Returns null if the expression is not a function reference.
    */
   extractFunctionReference(expr) {
     const text = expr.getText();
-    if (/^\w+(\.\w+)?$/.test(text)) {
+    const thisPattern = /^this\.(\w+)$/;
+    const thisMatch = thisPattern.exec(text);
+    if (thisMatch) {
+      if (!this.scanCurrentScope) {
+        return null;
+      }
+      return this.scanCurrentScope + "." + thisMatch[1];
+    }
+    const globalPattern = /^global\.(\w+)\.(\w+)$/;
+    const globalMatch = globalPattern.exec(text);
+    if (globalMatch) {
+      return globalMatch[1] + "." + globalMatch[2];
+    }
+    const simplePattern = /^\w+(\.\w+)?$/;
+    if (simplePattern.test(text)) {
       return text;
     }
     return null;
   }
+  /**
+   * Issue #895: Check expression for function calls that pass C-Next functions
+   * to C function pointer parameters.
+   *
+   * Pattern: `global.widget_set_flush_cb(w, my_flush)`
+   * Where widget_set_flush_cb's 2nd param is a C function pointer typedef.
+   */
+  checkExpressionForCallbackArgs(expr) {
+    const postfix = this.findPostfixExpression(expr);
+    if (!postfix) return;
+    const callInfo = this.extractCallInfo(postfix);
+    if (!callInfo) return;
+    const cFunc = this.symbolTable?.getCSymbol(callInfo.funcName);
+    if (cFunc?.kind !== "function" || !cFunc.parameters) return;
+    for (let i = 0; i < callInfo.args.length; i++) {
+      const param = cFunc.parameters[i];
+      if (!param) continue;
+      if (!this.isCFunctionPointerTypedef(param.type)) continue;
+      const funcRef = this.extractFunctionReference(callInfo.args[i]);
+      if (!funcRef) continue;
+      const lookupName = funcRef.includes(".") ? funcRef.replace(".", "_") : funcRef;
+      if (this.allLocalFunctions.has(lookupName)) {
+        CodeGenState.callbackCompatibleFunctions.set(lookupName, param.type);
+      }
+    }
+  }
+  /**
+   * Find the postfix expression within an expression tree.
+   * Uses ExpressionUnwrapper which validates that expression is "simple"
+   * (single term at each level), returning null for complex expressions.
+   */
+  findPostfixExpression(expr) {
+    return ExpressionUnwrapper_default.getPostfixExpression(expr);
+  }
+  /**
+   * Extract function name and arguments from a postfix expression.
+   * Returns null if not a function call.
+   */
+  extractCallInfo(postfix) {
+    const primary = postfix.primaryExpression();
+    const ops = postfix.postfixOp();
+    const ident = primary.IDENTIFIER();
+    const globalKw = primary.GLOBAL();
+    if (!ident && !globalKw) {
+      return null;
+    }
+    let funcName = ident ? ident.getText() : "";
+    let argListOp = null;
+    for (const op of ops) {
+      if (op.IDENTIFIER()) {
+        const member = op.IDENTIFIER().getText();
+        funcName = funcName ? `${funcName}_${member}` : member;
+      } else if (op.argumentList() || op.getText().startsWith("(")) {
+        argListOp = op;
+        break;
+      }
+    }
+    if (!argListOp || !funcName) return null;
+    const argList = argListOp.argumentList();
+    const args = argList?.expression() ?? [];
+    return { funcName, args };
+  }
   /**
    * ADR-040: Register a variable that holds a callable (ISR or callback)
    */
@@ -138627,7 +139110,7 @@ var Transpiler = class {
     this.state.reset();
     CodeGenState.symbolTable.clear();
     SymbolRegistry_default.reset();
-    CodeGenState.callbackCompatibleFunctions = /* @__PURE__ */ new Set();
+    CodeGenState.callbackCompatibleFunctions = /* @__PURE__ */ new Map();
   }
   /**
    * Ensure output directories exist