c-next 0.2.5 → 0.2.7

package/dist/index.js

@@ -10,7 +10,7 @@ import { hideBin } from "yargs/helpers";
 // package.json
 var package_default = {
   name: "c-next",
-  version: "0.2.5",
+  version: "0.2.7",
   description: "A safer C for embedded systems development. Transpiles to clean, readable C.",
   packageManager: "npm@11.9.0",
   type: "module",
@@ -770,18 +770,20 @@ var PathResolver = class {
     return join(dirname(file.path), outputName);
   }
   /**
-   * Get output path for a header file (.h)
+   * Get output path for a header file (.h or .hpp)
    * Uses headerOutDir if specified, otherwise falls back to outDir
    *
    * @param file - The discovered file to get header path for
+   * @param cppMode - If true, output .hpp; otherwise .h (Issue #933)
    * @returns The full header output path
    */
-  getHeaderOutputPath(file) {
+  getHeaderOutputPath(file, cppMode = false) {
+    const ext = cppMode ? ".hpp" : ".h";
     const headerDir = this.config.headerOutDir || this.config.outDir;
     const relativePath = this.getRelativePathFromInputs(file.path);
     if (relativePath) {
       const strippedPath = this.stripBasePath(relativePath);
-      const outputRelative = strippedPath.replace(/\.cnx$|\.cnext$/, ".h");
+      const outputRelative = strippedPath.replace(/\.cnx$|\.cnext$/, ext);
       const outputPath = join(headerDir, outputRelative);
       const outputDir = dirname(outputPath);
       if (!this.fs.exists(outputDir)) {
@@ -794,7 +796,7 @@ var PathResolver = class {
       const relativeFromCwd = relative(cwd, file.path);
       if (relativeFromCwd && !relativeFromCwd.startsWith("..")) {
         const strippedPath = this.stripBasePath(relativeFromCwd);
-        const outputRelative = strippedPath.replace(/\.cnx$|\.cnext$/, ".h");
+        const outputRelative = strippedPath.replace(/\.cnx$|\.cnext$/, ext);
         const outputPath2 = join(this.config.headerOutDir, outputRelative);
         const outputDir = dirname(outputPath2);
         if (!this.fs.exists(outputDir)) {
@@ -802,14 +804,14 @@ var PathResolver = class {
         }
         return outputPath2;
       }
-      const headerName2 = basename2(file.path).replace(/\.cnx$|\.cnext$/, ".h");
+      const headerName2 = basename2(file.path).replace(/\.cnx$|\.cnext$/, ext);
       const outputPath = join(this.config.headerOutDir, headerName2);
       if (!this.fs.exists(this.config.headerOutDir)) {
         this.fs.mkdir(this.config.headerOutDir, { recursive: true });
       }
       return outputPath;
     }
-    const headerName = basename2(file.path).replace(/\.cnx$|\.cnext$/, ".h");
+    const headerName = basename2(file.path).replace(/\.cnx$|\.cnext$/, ext);
     return join(dirname(file.path), headerName);
   }
   /**
@@ -113466,6 +113468,38 @@ var ExpressionUtils = class _ExpressionUtils {
     const identifier = primary.IDENTIFIER();
     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) {
+    return _ExpressionUtils.collectAdditiveFromOrExprs(ctx.orExpression());
+  }
+  /**
+   * Collect additive expressions from an array of orExpression contexts.
+   *
+   * Internal helper that performs the actual flatMap traversal.
+   */
+  static collectAdditiveFromOrExprs(orExprs) {
+    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) {
+    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.
    *
@@ -114776,6 +114810,95 @@ var binaryExprGenerators = {
 };
 var BinaryExprGenerator_default = binaryExprGenerators;
 
+// src/transpiler/output/codegen/helpers/CppModeHelper.ts
+var CppModeHelper = class {
+  /**
+   * Get address-of expression for struct parameter passing.
+   * C mode: `&expr` (pass pointer to struct)
+   * C++ mode: `expr` (pass reference directly)
+   *
+   * @param expr - The expression to potentially wrap
+   * @returns The expression with address-of operator in C mode
+   */
+  static maybeAddressOf(expr) {
+    return CodeGenState.cppMode ? expr : `&${expr}`;
+  }
+  /**
+   * Get dereference expression for struct parameter access.
+   * C mode: `(*expr)` (dereference pointer)
+   * C++ mode: `expr` (reference can be used directly)
+   *
+   * @param expr - The expression to potentially dereference
+   * @returns The expression with dereference in C mode
+   */
+  static maybeDereference(expr) {
+    return CodeGenState.cppMode ? expr : `(*${expr})`;
+  }
+  /**
+   * Get the type modifier for struct parameter declarations.
+   * C mode: `*` (pointer type)
+   * C++ mode: `&` (reference type)
+   *
+   * @returns The type modifier character
+   */
+  static refOrPtr() {
+    return CodeGenState.cppMode ? "&" : "*";
+  }
+  /**
+   * Get the member access separator for struct parameters.
+   * C mode: `->` (pointer member access)
+   * C++ mode: `.` (reference member access)
+   *
+   * @returns The member access separator
+   */
+  static memberSeparator() {
+    return CodeGenState.cppMode ? "." : "->";
+  }
+  /**
+   * Get NULL literal for the current mode.
+   * C mode: `NULL`
+   * C++ mode: `nullptr`
+   *
+   * @returns The null pointer literal
+   */
+  static nullLiteral() {
+    return CodeGenState.cppMode ? "nullptr" : "NULL";
+  }
+  /**
+   * Generate a cast expression for the current mode.
+   * C mode: `(type)expr`
+   * C++ mode: `static_cast<type>(expr)`
+   *
+   * @param type - The target type
+   * @param expr - The expression to cast
+   * @returns The cast expression
+   */
+  static cast(type, expr) {
+    return CodeGenState.cppMode ? `static_cast<${type}>(${expr})` : `(${type})${expr}`;
+  }
+  /**
+   * Generate a reinterpret cast expression for the current mode.
+   * C mode: `(type)expr`
+   * C++ mode: `reinterpret_cast<type>(expr)`
+   *
+   * @param type - The target type
+   * @param expr - The expression to cast
+   * @returns The cast expression
+   */
+  static reinterpretCast(type, expr) {
+    return CodeGenState.cppMode ? `reinterpret_cast<${type}>(${expr})` : `(${type})${expr}`;
+  }
+  /**
+   * Check if we're in C++ mode.
+   *
+   * @returns True if generating C++ code
+   */
+  static isCppMode() {
+    return CodeGenState.cppMode;
+  }
+};
+var CppModeHelper_default = CppModeHelper;
+
 // src/transpiler/output/codegen/generators/expressions/UnaryExprGenerator.ts
 var generateUnaryExpr = (node, _input, _state, orchestrator) => {
   if (node.postfixExpression()) {
@@ -114788,7 +114911,16 @@ var generateUnaryExpr = (node, _input, _state, orchestrator) => {
   const text = node.getText();
   if (text.startsWith("!")) return { code: `!${inner}`, effects: [] };
   if (text.startsWith("-")) return { code: `-${inner}`, effects: [] };
-  if (text.startsWith("~")) return { code: `~${inner}`, effects: [] };
+  if (text.startsWith("~")) {
+    const innerType = TypeResolver_default2.getUnaryExpressionType(
+      node.unaryExpression()
+    );
+    if (innerType && TypeResolver_default2.isUnsignedType(innerType)) {
+      const cType = TYPE_MAP_default[innerType] ?? innerType;
+      return { code: CppModeHelper_default.cast(cType, `~${inner}`), effects: [] };
+    }
+    return { code: `~${inner}`, effects: [] };
+  }
   if (text.startsWith("&")) return { code: `&${inner}`, effects: [] };
   return { code: inner, effects: [] };
 };
@@ -114828,170 +114960,6 @@ var expressionGenerators = {
 var ExpressionGenerator_default = expressionGenerators;
 
 // src/transpiler/output/codegen/generators/expressions/AccessExprGenerator.ts
-var TYPE_WIDTH2 = {
-  u8: 8,
-  u16: 16,
-  u32: 32,
-  u64: 64,
-  i8: 8,
-  i16: 16,
-  i32: 32,
-  i64: 64,
-  f32: 32,
-  f64: 64,
-  bool: 1
-};
-var C_TYPE_WIDTH = {
-  uint8_t: 8,
-  uint16_t: 16,
-  uint32_t: 32,
-  uint64_t: 64,
-  int8_t: 8,
-  int16_t: 16,
-  int32_t: 32,
-  int64_t: 64,
-  float: 32,
-  double: 64
-};
-function getTypeBitWidth(typeName) {
-  return TYPE_WIDTH2[typeName] || C_TYPE_WIDTH[typeName] || 0;
-}
-function makeStrlenResult(expr, skipContinue) {
-  return {
-    code: `strlen(${expr})`,
-    effects: [{ type: "include", header: "string" }],
-    skipContinue
-  };
-}
-function makeBitWidthResult(typeName, skipContinue, isElement = false) {
-  const bitWidth = getTypeBitWidth(typeName);
-  if (bitWidth > 0) {
-    return { code: String(bitWidth), effects: [], skipContinue };
-  }
-  const typeLabel = isElement ? "element type" : "type";
-  return {
-    code: `/* .length: unsupported ${typeLabel} ${typeName} */0`,
-    effects: [],
-    skipContinue
-  };
-}
-function handleStructMemberLength(ctx) {
-  if (!ctx.previousStructType || !ctx.previousMemberName) {
-    return null;
-  }
-  const fieldInfo = ctx.getStructFieldInfo(
-    ctx.previousStructType,
-    ctx.previousMemberName
-  );
-  if (!fieldInfo) {
-    return null;
-  }
-  const { type: memberType, dimensions } = fieldInfo;
-  const isStringField = memberType.startsWith("string<");
-  if (dimensions && dimensions.length > 1 && isStringField) {
-    if (ctx.subscriptDepth === 0) {
-      return { code: String(dimensions[0]), effects: [], skipContinue: true };
-    }
-    return makeStrlenResult(ctx.result, true);
-  }
-  if (dimensions?.length === 1 && isStringField) {
-    return makeStrlenResult(ctx.result, true);
-  }
-  if (dimensions && dimensions.length > 0 && ctx.subscriptDepth < dimensions.length) {
-    return {
-      code: String(dimensions[ctx.subscriptDepth]),
-      effects: [],
-      skipContinue: true
-    };
-  }
-  if (dimensions && dimensions.length > 0 && ctx.subscriptDepth >= dimensions.length) {
-    return makeBitWidthResult(memberType, true, true);
-  }
-  return makeBitWidthResult(memberType, true, false);
-}
-function handleStringLength(ctx, typeInfo) {
-  if (typeInfo.arrayDimensions && typeInfo.arrayDimensions.length > 1) {
-    if (ctx.subscriptDepth === 0) {
-      return {
-        code: String(typeInfo.arrayDimensions[0]),
-        effects: [],
-        skipContinue: false
-      };
-    }
-    return makeStrlenResult(ctx.result, false);
-  }
-  if (ctx.currentIdentifier && ctx.lengthCache?.has(ctx.currentIdentifier)) {
-    return {
-      code: ctx.lengthCache.get(ctx.currentIdentifier),
-      effects: [],
-      skipContinue: false
-    };
-  }
-  const target = ctx.currentIdentifier ?? ctx.result;
-  return makeStrlenResult(target, false);
-}
-function handleFullySubscriptedArrayLength(ctx, typeInfo) {
-  if (typeInfo.isEnum) {
-    return { code: "32", effects: [], skipContinue: false };
-  }
-  if (typeInfo.baseType.startsWith("string<") || typeInfo.isString) {
-    return makeStrlenResult(ctx.result, false);
-  }
-  let elementBitWidth = getTypeBitWidth(typeInfo.baseType);
-  if (elementBitWidth === 0 && typeInfo.isBitmap && typeInfo.bitmapTypeName && ctx.getBitmapBitWidth) {
-    elementBitWidth = ctx.getBitmapBitWidth(typeInfo.bitmapTypeName) || 0;
-  }
-  if (elementBitWidth > 0) {
-    return { code: String(elementBitWidth), effects: [], skipContinue: false };
-  }
-  return {
-    code: `/* .length: unsupported element type ${typeInfo.baseType} */0`,
-    effects: [],
-    skipContinue: false
-  };
-}
-var generateLengthProperty = (ctx) => {
-  if (ctx.mainArgsName && ctx.primaryId === ctx.mainArgsName) {
-    return { code: "argc", effects: [], skipContinue: false };
-  }
-  const structResult = handleStructMemberLength(ctx);
-  if (structResult) {
-    return structResult;
-  }
-  const typeInfo = ctx.typeInfo;
-  if (!typeInfo) {
-    return {
-      code: `/* .length: unknown type for ${ctx.result} */0`,
-      effects: [],
-      skipContinue: false
-    };
-  }
-  if (typeInfo.isString) {
-    return handleStringLength(ctx, typeInfo);
-  }
-  const hasDimensions = typeInfo.isArray && typeInfo.arrayDimensions && typeInfo.arrayDimensions.length > 0;
-  if (hasDimensions && ctx.subscriptDepth < typeInfo.arrayDimensions.length) {
-    return {
-      code: String(typeInfo.arrayDimensions[ctx.subscriptDepth]),
-      effects: [],
-      skipContinue: false
-    };
-  }
-  if (hasDimensions && ctx.subscriptDepth >= typeInfo.arrayDimensions.length) {
-    return handleFullySubscriptedArrayLength(ctx, typeInfo);
-  }
-  if (typeInfo.isArray) {
-    return {
-      code: `/* .length unknown for ${ctx.currentIdentifier} */0`,
-      effects: [],
-      skipContinue: false
-    };
-  }
-  if (typeInfo.isEnum) {
-    return { code: "32", effects: [], skipContinue: false };
-  }
-  return { code: String(typeInfo.bitWidth), effects: [], skipContinue: false };
-};
 var generateCapacityProperty = (typeInfo) => {
   if (typeInfo?.isString && typeInfo.stringCapacity !== void 0) {
     return { code: String(typeInfo.stringCapacity), effects: [] };
@@ -115016,7 +114984,6 @@ var generateBitmapFieldAccess = (result, fieldInfo) => {
   }
 };
 var accessGenerators = {
-  generateLengthProperty,
   generateCapacityProperty,
   generateSizeProperty,
   generateBitmapFieldAccess
@@ -115104,7 +115071,7 @@ var CallExprUtils = class _CallExprUtils {
 var CallExprUtils_default = CallExprUtils;
 
 // src/transpiler/output/codegen/types/C_TYPE_WIDTH.ts
-var C_TYPE_WIDTH2 = {
+var C_TYPE_WIDTH = {
   uint8_t: 8,
   int8_t: 8,
   uint16_t: 16,
@@ -115132,7 +115099,7 @@ var C_TYPE_WIDTH2 = {
   "long long": 64,
   "unsigned long long": 64
 };
-var C_TYPE_WIDTH_default = C_TYPE_WIDTH2;
+var C_TYPE_WIDTH_default = C_TYPE_WIDTH;
 
 // src/transpiler/output/codegen/generators/expressions/CallExprGenerator.ts
 var wrapWithCppEnumCast = (argCode, argExpr, targetParamBaseType, orchestrator) => {
@@ -115165,13 +115132,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}`;
   }
@@ -115924,7 +115895,7 @@ var handleGlobalPrefix = (memberName, tracking, input, state, orchestrator) => {
   }
   return true;
 };
-var handleThisScopeLength = (memberName, tracking, input, state, orchestrator) => {
+var handleThisScopeLength = (memberName, tracking, _input, state, orchestrator) => {
   if (tracking.result !== "__THIS_SCOPE__" || memberName !== "length") {
     return false;
   }
@@ -116013,19 +115984,9 @@ var tryExplicitLengthProperty = (memberName, tracking, rootIdentifier, input, st
 };
 var tryPropertyAccess = (memberName, tracking, rootIdentifier, input, state, orchestrator, effects) => {
   if (memberName === "length") {
-    const ctx = createExplicitLengthContext(tracking, rootIdentifier);
-    const lengthResult = generateLengthProperty2(
-      ctx,
-      input,
-      state,
-      orchestrator,
-      effects
+    throw new Error(
+      `Error: '.length' on '${tracking.result}' is deprecated. Use explicit properties: .bit_length (bit width), .byte_length (byte size), .element_count (array size), or .char_count (string length)`
     );
-    if (lengthResult !== null) {
-      applyPropertyResult(tracking, lengthResult);
-      return true;
-    }
-    return false;
   }
   const explicitProps = /* @__PURE__ */ new Set([
     "bit_length",
@@ -116070,129 +116031,6 @@ var tryPropertyAccess = (memberName, tracking, rootIdentifier, input, state, orc
   }
   return false;
 };
-var generateLengthProperty2 = (ctx, input, state, orchestrator, effects) => {
-  if (state.mainArgsName && ctx.rootIdentifier === state.mainArgsName) {
-    return "argc";
-  }
-  if (ctx.previousStructType && ctx.previousMemberName) {
-    const fieldInfo = orchestrator.getStructFieldInfo(
-      ctx.previousStructType,
-      ctx.previousMemberName
-    );
-    if (fieldInfo) {
-      return generateStructFieldLength(
-        ctx.result,
-        fieldInfo,
-        ctx.subscriptDepth,
-        input,
-        orchestrator,
-        effects
-      );
-    }
-  }
-  const typeInfo = ctx.resolvedIdentifier ? CodeGenState.getVariableTypeInfo(ctx.resolvedIdentifier) : void 0;
-  if (!typeInfo) {
-    return `/* .length: unknown type for ${ctx.result} */0`;
-  }
-  return generateTypeInfoLength(
-    ctx.result,
-    typeInfo,
-    ctx.subscriptDepth,
-    ctx.resolvedIdentifier,
-    input,
-    state,
-    effects
-  );
-};
-var generateStructFieldLength = (result, fieldInfo, subscriptDepth, input, orchestrator, effects) => {
-  const memberType = fieldInfo.type;
-  const dimensions = fieldInfo.dimensions;
-  const isStringField = TypeCheckUtils_default.isString(memberType);
-  if (dimensions?.length && dimensions.length > 1 && isStringField) {
-    if (subscriptDepth === 0) {
-      return String(dimensions[0]);
-    } else {
-      effects.push({ type: "include", header: "string" });
-      return `strlen(${result})`;
-    }
-  } else if (dimensions?.length === 1 && isStringField) {
-    effects.push({ type: "include", header: "string" });
-    return `strlen(${result})`;
-  } else if (dimensions?.length && dimensions.length > 0 && subscriptDepth < dimensions.length) {
-    return String(dimensions[subscriptDepth]);
-  } else if (dimensions?.length && dimensions.length > 0 && subscriptDepth >= dimensions.length) {
-    return getTypeBitWidth2(memberType, input);
-  } else {
-    return getTypeBitWidth2(memberType, input);
-  }
-};
-var generateTypeInfoLength = (result, typeInfo, subscriptDepth, resolvedIdentifier, input, state, effects) => {
-  if (typeInfo.isString) {
-    return generateStringLength(
-      result,
-      typeInfo,
-      subscriptDepth,
-      resolvedIdentifier,
-      state
-    );
-  }
-  if (typeInfo.isEnum && !typeInfo.isArray) {
-    return "32";
-  }
-  if (!typeInfo.isArray) {
-    return String(typeInfo.bitWidth || 0);
-  }
-  const dims = typeInfo.arrayDimensions;
-  if (!dims || dims.length === 0) {
-    return `/* .length unknown for ${resolvedIdentifier} */0`;
-  }
-  if (subscriptDepth < dims.length) {
-    return String(dims[subscriptDepth]);
-  }
-  return generateElementTypeLength(result, typeInfo, input, effects);
-};
-var generateStringLength = (result, typeInfo, subscriptDepth, resolvedIdentifier, state) => {
-  const dims = typeInfo.arrayDimensions;
-  if (dims && dims.length > 1) {
-    return subscriptDepth === 0 ? String(dims[0]) : `strlen(${result})`;
-  }
-  if (subscriptDepth > 0) {
-    return `strlen(${result})`;
-  }
-  if (resolvedIdentifier && state.lengthCache?.has(resolvedIdentifier)) {
-    return state.lengthCache.get(resolvedIdentifier);
-  }
-  return resolvedIdentifier ? `strlen(${resolvedIdentifier})` : `strlen(${result})`;
-};
-var generateElementTypeLength = (result, typeInfo, input, effects) => {
-  if (typeInfo.isEnum) {
-    return "32";
-  }
-  if (TypeCheckUtils_default.isString(typeInfo.baseType) || typeInfo.isString) {
-    effects.push({ type: "include", header: "string" });
-    return `strlen(${result})`;
-  }
-  let elementBitWidth = TYPE_WIDTH_default[typeInfo.baseType] || 0;
-  if (elementBitWidth === 0 && typeInfo.isBitmap && typeInfo.bitmapTypeName) {
-    elementBitWidth = input.symbols.bitmapBitWidth.get(typeInfo.bitmapTypeName) || 0;
-  }
-  if (elementBitWidth > 0) {
-    return String(elementBitWidth);
-  }
-  return `/* .length: unsupported element type ${typeInfo.baseType} */0`;
-};
-var getTypeBitWidth2 = (typeName, input) => {
-  let bitWidth = TYPE_WIDTH_default[typeName] || C_TYPE_WIDTH_default[typeName] || 0;
-  if (bitWidth === 0 && input.symbolTable) {
-    const enumWidth = input.symbolTable.getEnumBitWidth(typeName);
-    if (enumWidth) bitWidth = enumWidth;
-  }
-  if (bitWidth > 0) {
-    return String(bitWidth);
-  } else {
-    return `/* .length: unsupported type ${typeName} */0`;
-  }
-};
 var getNumericBitWidth = (typeName, input) => {
   let bitWidth = TYPE_WIDTH_default[typeName] ?? C_TYPE_WIDTH_default[typeName] ?? 0;
   if (bitWidth === 0 && input.symbolTable) {
@@ -116468,11 +116306,10 @@ var generateCharCountProperty = (ctx, input, state, orchestrator, effects) => {
     );
   }
   effects.push({ type: "include", header: "string" });
-  if (ctx.resolvedIdentifier && state.lengthCache?.has(ctx.resolvedIdentifier)) {
+  if (ctx.subscriptDepth === 0 && ctx.resolvedIdentifier && state.lengthCache?.has(ctx.resolvedIdentifier)) {
     return state.lengthCache.get(ctx.resolvedIdentifier);
   }
-  const target = ctx.resolvedIdentifier ?? ctx.result;
-  return `strlen(${target})`;
+  return `strlen(${ctx.result})`;
 };
 var initializeMemberOutput = (ctx) => ({
   result: ctx.result,
@@ -116861,15 +116698,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(
@@ -118057,16 +117897,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.
@@ -118123,24 +117964,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.
@@ -118186,7 +118029,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};`;
   }
@@ -120870,7 +120713,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});`;
   }
@@ -121123,9 +120966,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(
@@ -121191,9 +121034,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);
@@ -121439,7 +121282,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});`;
 }
@@ -121687,9 +121530,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);
@@ -122361,7 +122204,7 @@ var AssignmentContextBuilder_default = buildAssignmentContext;
 // src/transpiler/output/codegen/analysis/StringLengthCounter.ts
 var StringLengthCounter = class _StringLengthCounter {
   /**
-   * Count .length accesses in an expression.
+   * Count .char_count accesses in an expression.
    */
   static countExpression(ctx) {
     const counts = /* @__PURE__ */ new Map();
@@ -122369,7 +122212,7 @@ var StringLengthCounter = class _StringLengthCounter {
     return counts;
   }
   /**
-   * Count .length accesses in a block.
+   * Count .char_count accesses in a block.
    */
   static countBlock(ctx) {
     const counts = /* @__PURE__ */ new Map();
@@ -122379,7 +122222,7 @@ var StringLengthCounter = class _StringLengthCounter {
     return counts;
   }
   /**
-   * Count .length accesses in a block, adding to existing counts.
+   * Count .char_count accesses in a block, adding to existing counts.
    */
   static countBlockInto(ctx, counts) {
     for (const stmt of ctx.statement()) {
@@ -122387,7 +122230,7 @@ var StringLengthCounter = class _StringLengthCounter {
     }
   }
   /**
-   * Walk an expression tree, counting .length accesses.
+   * Walk an expression tree, counting .char_count accesses.
    * Uses generic traversal - only postfix expressions need special handling.
    */
   static walkExpression(ctx, counts) {
@@ -122462,7 +122305,7 @@ var StringLengthCounter = class _StringLengthCounter {
     }
   }
   /**
-   * Walk a postfix expression - this is where we detect .length accesses.
+   * Walk a postfix expression - this is where we detect .char_count accesses.
    */
   static walkPostfixExpr(ctx, counts) {
     const primary = ctx.primaryExpression();
@@ -122471,7 +122314,7 @@ var StringLengthCounter = class _StringLengthCounter {
     if (primaryId && ops.length > 0) {
       for (const op of ops) {
         const memberName = op.IDENTIFIER()?.getText();
-        if (memberName === "length") {
+        if (memberName === "char_count") {
           const typeInfo = CodeGenState.getVariableTypeInfo(primaryId);
           if (typeInfo?.isString) {
             const currentCount = counts.get(primaryId) || 0;
@@ -122488,7 +122331,7 @@ var StringLengthCounter = class _StringLengthCounter {
     }
   }
   /**
-   * Walk a statement, counting .length accesses.
+   * Walk a statement, counting .char_count accesses.
    */
   static walkStatement(ctx, counts) {
     if (ctx.assignmentStatement()) {
@@ -122520,95 +122363,6 @@ var StringLengthCounter = class _StringLengthCounter {
 };
 var StringLengthCounter_default = StringLengthCounter;
 
-// src/transpiler/output/codegen/helpers/CppModeHelper.ts
-var CppModeHelper = class {
-  /**
-   * Get address-of expression for struct parameter passing.
-   * C mode: `&expr` (pass pointer to struct)
-   * C++ mode: `expr` (pass reference directly)
-   *
-   * @param expr - The expression to potentially wrap
-   * @returns The expression with address-of operator in C mode
-   */
-  static maybeAddressOf(expr) {
-    return CodeGenState.cppMode ? expr : `&${expr}`;
-  }
-  /**
-   * Get dereference expression for struct parameter access.
-   * C mode: `(*expr)` (dereference pointer)
-   * C++ mode: `expr` (reference can be used directly)
-   *
-   * @param expr - The expression to potentially dereference
-   * @returns The expression with dereference in C mode
-   */
-  static maybeDereference(expr) {
-    return CodeGenState.cppMode ? expr : `(*${expr})`;
-  }
-  /**
-   * Get the type modifier for struct parameter declarations.
-   * C mode: `*` (pointer type)
-   * C++ mode: `&` (reference type)
-   *
-   * @returns The type modifier character
-   */
-  static refOrPtr() {
-    return CodeGenState.cppMode ? "&" : "*";
-  }
-  /**
-   * Get the member access separator for struct parameters.
-   * C mode: `->` (pointer member access)
-   * C++ mode: `.` (reference member access)
-   *
-   * @returns The member access separator
-   */
-  static memberSeparator() {
-    return CodeGenState.cppMode ? "." : "->";
-  }
-  /**
-   * Get NULL literal for the current mode.
-   * C mode: `NULL`
-   * C++ mode: `nullptr`
-   *
-   * @returns The null pointer literal
-   */
-  static nullLiteral() {
-    return CodeGenState.cppMode ? "nullptr" : "NULL";
-  }
-  /**
-   * Generate a cast expression for the current mode.
-   * C mode: `(type)expr`
-   * C++ mode: `static_cast<type>(expr)`
-   *
-   * @param type - The target type
-   * @param expr - The expression to cast
-   * @returns The cast expression
-   */
-  static cast(type, expr) {
-    return CodeGenState.cppMode ? `static_cast<${type}>(${expr})` : `(${type})${expr}`;
-  }
-  /**
-   * Generate a reinterpret cast expression for the current mode.
-   * C mode: `(type)expr`
-   * C++ mode: `reinterpret_cast<type>(expr)`
-   *
-   * @param type - The target type
-   * @param expr - The expression to cast
-   * @returns The cast expression
-   */
-  static reinterpretCast(type, expr) {
-    return CodeGenState.cppMode ? `reinterpret_cast<${type}>(${expr})` : `(${type})${expr}`;
-  }
-  /**
-   * Check if we're in C++ mode.
-   *
-   * @returns True if generating C++ code
-   */
-  static isCppMode() {
-    return CodeGenState.cppMode;
-  }
-};
-var CppModeHelper_default = CppModeHelper;
-
 // src/transpiler/output/codegen/analysis/MemberChainAnalyzer.ts
 var MemberChainAnalyzer = class _MemberChainAnalyzer {
   /**
@@ -122839,6 +122593,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)) {
@@ -124105,7 +123862,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.
@@ -124581,15 +124342,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,
@@ -125625,6 +125392,33 @@ var TypedefParamParser = class _TypedefParamParser {
   static shouldBeConst(typedefType, paramIndex) {
     return _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, callbackTypedefType) {
+    return params.map((param, index) => {
+      const shouldBePointer = _TypedefParamParser.shouldBePointer(
+        callbackTypedefType,
+        index
+      );
+      const shouldBeConst = _TypedefParamParser.shouldBeConst(
+        callbackTypedefType,
+        index
+      );
+      return {
+        ...param,
+        isCallbackPointer: shouldBePointer ?? void 0,
+        isCallbackConst: shouldBeConst ?? void 0
+      };
+    });
+  }
 };
 var TypedefParamParser_default = TypedefParamParser;
 
@@ -126396,7 +126190,7 @@ var PassByValueAnalyzer = class _PassByValueAnalyzer {
    * Used by both function call tracking and subscript access tracking.
    */
   static walkOrExpression(orExpr, handler) {
-    orExpr.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()).flatMap((add) => add.multiplicativeExpression()).flatMap((mul) => mul.unaryExpression()).forEach(handler);
+    ExpressionUtils_default.collectUnaryFromOrExpr(orExpr).forEach(handler);
   }
   /**
    * Walk an orExpression tree for function calls.
@@ -126751,6 +126545,7 @@ var ParameterInputAdapter = class {
         isPassByReference: false
       };
     }
+    const isCallbackPointer = param.isCallbackPointer ?? false;
     return {
       name: param.name,
       baseType: param.type,
@@ -126760,8 +126555,10 @@ var ParameterInputAdapter = class {
       isArray: false,
       isCallback: false,
       isString: false,
-      isPassByValue: deps.isPassByValue,
-      isPassByReference: !deps.isPassByValue
+      isPassByValue: isCallbackPointer ? false : deps.isPassByValue,
+      isPassByReference: isCallbackPointer ? true : !deps.isPassByValue,
+      forcePointerSyntax: isCallbackPointer || void 0,
+      forceConst: param.isCallbackConst || void 0
     };
   }
   /**
@@ -127571,7 +127368,7 @@ var CodeGenerator = class _CodeGenerator {
     if (!arrayAccessMatch) {
       return false;
     }
-    if (text.endsWith(".length") || text.endsWith(".capacity") || text.endsWith(".size")) {
+    if (text.endsWith(".length") || text.endsWith(".capacity") || text.endsWith(".size") || text.endsWith(".bit_length") || text.endsWith(".byte_length") || text.endsWith(".element_count") || text.endsWith(".char_count")) {
       return false;
     }
     const arrayName = arrayAccessMatch[1];
@@ -128631,7 +128428,8 @@ typedef ${callbackInfo.returnType} (*${callbackInfo.typedefName})(${paramList});
     );
     if (symbols.hasPublicSymbols() && CodeGenState.sourcePath) {
       const pathToUse = options?.sourceRelativePath || CodeGenState.sourcePath.replace(/^.*[\\/]/, "");
-      const headerName = pathToUse.replace(/\.cnx$|\.cnext$/, ".h");
+      const ext = CodeGenState.cppMode ? ".hpp" : ".h";
+      const headerName = pathToUse.replace(/\.cnx$|\.cnext$/, ext);
       output.push(`#include "${headerName}"`, "");
       CodeGenState.selfIncludeAdded = true;
     }
@@ -129771,6 +129569,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),
@@ -129779,20 +129578,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.
    */
@@ -129813,6 +129708,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,
@@ -130968,10 +130877,15 @@ var HeaderGeneratorUtils = class _HeaderGeneratorUtils {
     }
     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);
       }
     }
-    const userIncludeSet = new Set(options.userIncludes ?? []);
+    const userIncludeSet = new Set(
+      options.userIncludes?.map(
+        (inc) => options.cppMode ? inc.replace(/\.h"/, '.hpp"').replace(/\.h>/, ".hpp>") : inc
+      ) ?? []
+    );
     for (const directive of headersToInclude) {
       if (!userIncludeSet.has(directive)) {
         lines.push(directive);
@@ -132785,7 +132699,7 @@ var TSymbolInfoAdapter = class _TSymbolInfoAdapter {
 var TSymbolInfoAdapter_default = TSymbolInfoAdapter;
 
 // src/transpiler/logic/symbols/SymbolUtils.ts
-var RESERVED_FIELD_NAMES = /* @__PURE__ */ new Set(["length"]);
+var RESERVED_FIELD_NAMES = /* @__PURE__ */ new Set([]);
 function parseArrayDimensions2(text) {
   const dimensions = [];
   const arrayMatches = text.match(/\[(\d+)\]/g);
@@ -133389,6 +133303,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,
@@ -133396,7 +133312,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
     };
@@ -137085,6 +137001,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
@@ -137093,11 +137011,45 @@ 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.
@@ -137182,13 +137134,30 @@ var FunctionCallAnalyzer = class {
   }
   /**
    * 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;
@@ -137851,6 +137820,162 @@ var ArrayIndexTypeAnalyzer = class {
 };
 var ArrayIndexTypeAnalyzer_default = ArrayIndexTypeAnalyzer;
 
+// src/transpiler/logic/analysis/SignedShiftAnalyzer.ts
+import { ParseTreeWalker as ParseTreeWalker9 } from "antlr4ng";
+var SignedVariableCollector = class extends CNextListener {
+  signedVars = /* @__PURE__ */ new Set();
+  getSignedVars() {
+    return this.signedVars;
+  }
+  /**
+   * Track a typed identifier if it has a signed type
+   */
+  trackIfSigned(typeCtx, identifier) {
+    if (!typeCtx) return;
+    const typeName = typeCtx.getText();
+    if (!TypeConstants_default.SIGNED_TYPES.includes(typeName)) return;
+    if (!identifier) return;
+    this.signedVars.add(identifier.getText());
+  }
+  /**
+   * Track variable declarations with signed types
+   */
+  enterVariableDeclaration = (ctx) => {
+    this.trackIfSigned(ctx.type(), ctx.IDENTIFIER());
+  };
+  /**
+   * Track function parameters with signed types
+   */
+  enterParameter = (ctx) => {
+    this.trackIfSigned(ctx.type(), ctx.IDENTIFIER());
+  };
+  /**
+   * Track for-loop variable declarations with signed types
+   */
+  enterForVarDecl = (ctx) => {
+    this.trackIfSigned(ctx.type(), ctx.IDENTIFIER());
+  };
+};
+var SignedShiftListener = class extends CNextListener {
+  analyzer;
+  // eslint-disable-next-line @typescript-eslint/lines-between-class-members
+  signedVars;
+  constructor(analyzer, signedVars) {
+    super();
+    this.analyzer = analyzer;
+    this.signedVars = signedVars;
+  }
+  /**
+   * Check shift expressions for signed operands
+   * shiftExpression: additiveExpression (('<<' | '>>') additiveExpression)*
+   */
+  enterShiftExpression = (ctx) => {
+    const operands = ctx.additiveExpression();
+    if (operands.length < 2) return;
+    for (let i = 0; i < operands.length - 1; i++) {
+      const operatorToken = ctx.getChild(i * 2 + 1);
+      if (!operatorToken) continue;
+      const operator = operatorToken.getText();
+      if (operator !== "<<" && operator !== ">>") continue;
+      const leftOperand = operands[i];
+      if (this.isSignedOperand(leftOperand)) {
+        const { line, column } = ParserUtils_default.getPosition(leftOperand);
+        this.analyzer.addError(line, column, operator);
+      }
+    }
+  };
+  /**
+   * Check if an additive expression contains a signed type operand
+   */
+  isSignedOperand(ctx) {
+    const multExprs = ctx.multiplicativeExpression();
+    for (const multExpr of multExprs) {
+      const unaryExprs = multExpr.unaryExpression();
+      for (const unaryExpr of unaryExprs) {
+        if (this.isSignedUnaryExpression(unaryExpr)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if a unary expression is a signed type
+   */
+  isSignedUnaryExpression(ctx) {
+    if (ctx.MINUS()) {
+      const nestedUnary = ctx.unaryExpression();
+      if (nestedUnary) {
+        const nestedPostfix = nestedUnary.postfixExpression();
+        if (nestedPostfix) {
+          const nestedPrimary = nestedPostfix.primaryExpression();
+          if (nestedPrimary?.literal()) {
+            return true;
+          }
+        }
+        return this.isSignedUnaryExpression(nestedUnary);
+      }
+      return false;
+    }
+    const postfixExpr = ctx.postfixExpression();
+    if (!postfixExpr) return false;
+    const primaryExpr = postfixExpr.primaryExpression();
+    if (!primaryExpr) return false;
+    const parenExpr = primaryExpr.expression();
+    if (parenExpr) {
+      return this.isSignedExpression(parenExpr);
+    }
+    const identifier = primaryExpr.IDENTIFIER();
+    if (identifier) {
+      return this.signedVars.has(identifier.getText());
+    }
+    return false;
+  }
+  /**
+   * Check if a full expression contains signed operands
+   */
+  isSignedExpression(ctx) {
+    const ternary = ctx.ternaryExpression();
+    if (!ternary) return false;
+    const additiveExprs = ExpressionUtils_default.collectAdditiveExpressions(ternary);
+    return additiveExprs.some((addExpr) => this.isSignedOperand(addExpr));
+  }
+};
+var SignedShiftAnalyzer = class {
+  errors = [];
+  /**
+   * Analyze the parse tree for signed shift operations
+   */
+  analyze(tree) {
+    this.errors = [];
+    const collector = new SignedVariableCollector();
+    ParseTreeWalker9.DEFAULT.walk(collector, tree);
+    const signedVars = collector.getSignedVars();
+    const listener = new SignedShiftListener(this, signedVars);
+    ParseTreeWalker9.DEFAULT.walk(listener, tree);
+    return this.errors;
+  }
+  /**
+   * Add a signed shift error
+   */
+  addError(line, column, operator) {
+    this.errors.push({
+      code: "E0805",
+      line,
+      column,
+      message: `Shift operator '${operator}' not allowed on signed integer types`,
+      helpText: "Shift operations on signed integers have undefined (<<) or implementation-defined (>>) behavior. Use unsigned types (u8, u16, u32, u64) for bit manipulation."
+    });
+  }
+  /**
+   * Get all detected errors
+   */
+  getErrors() {
+    return this.errors;
+  }
+};
+var SignedShiftAnalyzer_default = SignedShiftAnalyzer;
+
 // src/transpiler/logic/analysis/runAnalyzers.ts
 function collectErrors(analyzerErrors, target, formatMessage) {
   const formatter = formatMessage ?? ((e) => e.message);
@@ -137908,6 +138033,10 @@ function runAnalyzers(tree, tokenStream, options) {
   if (collectErrors(indexTypeAnalyzer.analyze(tree), errors, formatWithCode)) {
     return errors;
   }
+  const signedShiftAnalyzer = new SignedShiftAnalyzer_default();
+  if (collectErrors(signedShiftAnalyzer.analyze(tree), errors, formatWithCode)) {
+    return errors;
+  }
   const commentExtractor = new CommentExtractor_default(tokenStream);
   collectErrors(
     commentExtractor.validate(),
@@ -139003,7 +139132,8 @@ var Transpiler = class {
       const headerContent = this.generateHeaderForFile(file);
       if (headerContent) {
         const headerPath = this.pathResolver.getHeaderOutputPath(
-          file.discoveredFile
+          file.discoveredFile,
+          this.cppDetected
         );
         this.fs.writeFile(headerPath, headerContent);
         result.outputFiles.push(headerPath);
@@ -139406,7 +139536,8 @@ var Transpiler = class {
     if (exportedSymbols.length === 0) {
       return null;
     }
-    const headerName = basename5(sourcePath).replace(/\.cnx$|\.cnext$/, ".h");
+    const ext = this.cppDetected ? ".hpp" : ".h";
+    const headerName = basename5(sourcePath).replace(/\.cnx$|\.cnext$/, ext);
     const typeInput = this.state.getSymbolInfo(sourcePath);
     const passByValueParams = this.state.getPassByValueParams(sourcePath) ?? /* @__PURE__ */ new Map();
     const userIncludes = this.state.getUserIncludes(sourcePath);
@@ -139476,19 +139607,31 @@ var Transpiler = class {
   convertToHeaderSymbols(symbols, unmodifiedParams, knownEnums) {
     return symbols.map((symbol) => {
       const headerSymbol = HeaderSymbolAdapter_default.fromTSymbol(symbol);
-      if (symbol.kind === "function" && headerSymbol.parameters && headerSymbol.parameters.length > 0) {
-        const unmodified = unmodifiedParams.get(headerSymbol.name);
-        if (unmodified) {
-          const updatedParams = headerSymbol.parameters.map((param) => {
-            const isPointerParam = !param.isConst && !param.isArray && param.type !== "f32" && param.type !== "f64" && param.type !== "ISR" && !knownEnums.has(param.type ?? "");
-            const isArrayParam = param.isArray && !param.isConst;
-            if ((isPointerParam || isArrayParam) && unmodified.has(param.name)) {
-              return { ...param, isAutoConst: true };
-            }
-            return param;
-          });
-          return { ...headerSymbol, parameters: updatedParams };
-        }
+      if (symbol.kind !== "function" || !headerSymbol.parameters || headerSymbol.parameters.length === 0) {
+        return headerSymbol;
+      }
+      const typedefName = CodeGenState.callbackCompatibleFunctions.get(
+        headerSymbol.name
+      );
+      const callbackTypedefType = typedefName ? CodeGenState.getTypedefType(typedefName) : void 0;
+      if (callbackTypedefType) {
+        const updatedParams = TypedefParamParser_default.resolveCallbackParams(
+          headerSymbol.parameters,
+          callbackTypedefType
+        );
+        return { ...headerSymbol, parameters: updatedParams };
+      }
+      const unmodified = unmodifiedParams.get(headerSymbol.name);
+      if (unmodified) {
+        const updatedParams = headerSymbol.parameters.map((param) => {
+          const isPointerParam = !param.isConst && !param.isArray && param.type !== "f32" && param.type !== "f64" && param.type !== "ISR" && !knownEnums.has(param.type ?? "");
+          const isArrayParam = param.isArray && !param.isConst;
+          if ((isPointerParam || isArrayParam) && unmodified.has(param.name)) {
+            return { ...param, isAutoConst: true };
+          }
+          return param;
+        });
+        return { ...headerSymbol, parameters: updatedParams };
       }
       return headerSymbol;
     });