c-next 0.2.6 → 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.6",
+  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) => {
@@ -115928,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;
   }
@@ -116017,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",
@@ -116074,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) {
@@ -116472,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,
@@ -122371,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();
@@ -122379,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();
@@ -122389,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()) {
@@ -122397,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) {
@@ -122472,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();
@@ -122481,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;
@@ -122498,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()) {
@@ -122530,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 {
   /**
@@ -125648,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;
 
@@ -126419,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.
@@ -126774,6 +126545,7 @@ var ParameterInputAdapter = class {
         isPassByReference: false
       };
     }
+    const isCallbackPointer = param.isCallbackPointer ?? false;
     return {
       name: param.name,
       baseType: param.type,
@@ -126783,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
     };
   }
   /**
@@ -127594,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];
@@ -128654,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;
     }
@@ -131102,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);
@@ -132919,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);
@@ -138040,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);
@@ -138097,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(),
@@ -139192,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);
@@ -139595,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);
@@ -139665,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;
     });