c-next 0.1.3 → 0.1.4

package/README.md

@@ -661,42 +661,43 @@ Decisions are documented in `/docs/decisions/`:
 
 ### Implemented
 
-| ADR                                                          | Title                   | Description                                                  |
-| ------------------------------------------------------------ | ----------------------- | ------------------------------------------------------------ |
-| [ADR-001](docs/decisions/adr-001-assignment-operator.md)     | Assignment Operator     | `<-` for assignment, `=` for comparison                      |
-| [ADR-003](docs/decisions/adr-003-static-allocation.md)       | Static Allocation       | No dynamic memory after init                                 |
-| [ADR-004](docs/decisions/adr-004-register-bindings.md)       | Register Bindings       | Type-safe hardware access                                    |
-| [ADR-006](docs/decisions/adr-006-simplified-references.md)   | Simplified References   | Pass by reference, no pointer syntax                         |
-| [ADR-007](docs/decisions/adr-007-type-aware-bit-indexing.md) | Type-Aware Bit Indexing | Integers as bit arrays, `.length` property                   |
-| [ADR-010](docs/decisions/adr-010-c-interoperability.md)      | C Interoperability      | Unified ANTLR parser architecture                            |
-| [ADR-011](docs/decisions/adr-011-vscode-extension.md)        | VS Code Extension       | Live C preview with syntax highlighting                      |
-| [ADR-012](docs/decisions/adr-012-static-analysis.md)         | Static Analysis         | cppcheck integration for generated C                         |
-| [ADR-013](docs/decisions/adr-013-const-qualifier.md)         | Const Qualifier         | Compile-time const enforcement                               |
-| [ADR-014](docs/decisions/adr-014-structs.md)                 | Structs                 | Data containers without methods                              |
-| [ADR-015](docs/decisions/adr-015-null-state.md)              | Null State              | Zero initialization for all variables                        |
-| [ADR-016](docs/decisions/adr-016-scope.md)                   | Scope                   | `this.`/`global.` explicit qualification                     |
-| [ADR-017](docs/decisions/adr-017-enums.md)                   | Enums                   | Type-safe enums with C-style casting                         |
-| [ADR-030](docs/decisions/adr-030-forward-declarations.md)    | Define-Before-Use       | Functions must be defined before called                      |
-| [ADR-037](docs/decisions/adr-037-preprocessor.md)            | Preprocessor            | Flag-only defines, const for values                          |
-| [ADR-043](docs/decisions/adr-043-comments.md)                | Comments                | Comment preservation with MISRA compliance                   |
-| [ADR-044](docs/decisions/adr-044-primitive-types.md)         | Primitive Types         | Fixed-width types with `clamp`/`wrap` overflow               |
-| [ADR-024](docs/decisions/adr-024-type-casting.md)            | Type Casting            | Widening implicit, narrowing uses bit indexing               |
-| [ADR-022](docs/decisions/adr-022-conditional-expressions.md) | Conditional Expressions | Ternary with required parens, boolean condition, no nesting  |
-| [ADR-025](docs/decisions/adr-025-switch-statements.md)       | Switch Statements       | Safe switch with braces, `\|\|` syntax, counted `default(n)` |
-| [ADR-029](docs/decisions/adr-029-function-pointers.md)       | Callbacks               | Function-as-Type pattern with nominal typing                 |
-| [ADR-045](docs/decisions/adr-045-string-type.md)             | Bounded Strings         | `string<N>` with compile-time safety                         |
-| [ADR-023](docs/decisions/adr-023-sizeof.md)                  | Sizeof                  | Type/value size queries with safety checks                   |
-| [ADR-027](docs/decisions/adr-027-do-while.md)                | Do-While                | `do { } while ()` with boolean condition (E0701)             |
-| [ADR-032](docs/decisions/adr-032-nested-structs.md)          | Nested Structs          | Named nested structs only (no anonymous)                     |
-| [ADR-035](docs/decisions/adr-035-array-initializers.md)      | Array Initializers      | `[1, 2, 3]` syntax with `[0*]` fill-all                      |
-| [ADR-036](docs/decisions/adr-036-multidimensional-arrays.md) | Multi-dim Arrays        | `arr[i][j]` with compile-time bounds enforcement             |
-| [ADR-040](docs/decisions/adr-040-isr-declaration.md)         | ISR Type                | Built-in `ISR` type for `void(void)` function pointers       |
-| [ADR-034](docs/decisions/adr-034-bit-fields.md)              | Bitmap Types            | `bitmap8`/`bitmap16`/`bitmap32` for portable bit-packed data |
-| [ADR-048](docs/decisions/adr-048-cli-executable.md)          | CLI Executable          | `cnext` command with smart defaults                          |
-| [ADR-049](docs/decisions/adr-049-atomic-types.md)            | Atomic Types            | `atomic` keyword with LDREX/STREX or PRIMASK fallback        |
-| [ADR-050](docs/decisions/adr-050-critical-sections.md)       | Critical Sections       | `critical { }` blocks with PRIMASK save/restore              |
-| [ADR-108](docs/decisions/adr-108-volatile-keyword.md)        | Volatile Variables      | `volatile` keyword prevents compiler optimization            |
-| [ADR-047](docs/decisions/adr-047-nullable-types.md)          | NULL for C Interop      | `NULL` keyword for C stream function comparisons             |
+| ADR                                                                  | Title                   | Description                                                  |
+| -------------------------------------------------------------------- | ----------------------- | ------------------------------------------------------------ |
+| [ADR-001](docs/decisions/adr-001-assignment-operator.md)             | Assignment Operator     | `<-` for assignment, `=` for comparison                      |
+| [ADR-003](docs/decisions/adr-003-static-allocation.md)               | Static Allocation       | No dynamic memory after init                                 |
+| [ADR-004](docs/decisions/adr-004-register-bindings.md)               | Register Bindings       | Type-safe hardware access                                    |
+| [ADR-006](docs/decisions/adr-006-simplified-references.md)           | Simplified References   | Pass by reference, no pointer syntax                         |
+| [ADR-007](docs/decisions/adr-007-type-aware-bit-indexing.md)         | Type-Aware Bit Indexing | Integers as bit arrays, `.length` property                   |
+| [ADR-010](docs/decisions/adr-010-c-interoperability.md)              | C Interoperability      | Unified ANTLR parser architecture                            |
+| [ADR-011](docs/decisions/adr-011-vscode-extension.md)                | VS Code Extension       | Live C preview with syntax highlighting                      |
+| [ADR-012](docs/decisions/adr-012-static-analysis.md)                 | Static Analysis         | cppcheck integration for generated C                         |
+| [ADR-013](docs/decisions/adr-013-const-qualifier.md)                 | Const Qualifier         | Compile-time const enforcement                               |
+| [ADR-014](docs/decisions/adr-014-structs.md)                         | Structs                 | Data containers without methods                              |
+| [ADR-015](docs/decisions/adr-015-null-state.md)                      | Null State              | Zero initialization for all variables                        |
+| [ADR-016](docs/decisions/adr-016-scope.md)                           | Scope                   | `this.`/`global.` explicit qualification                     |
+| [ADR-017](docs/decisions/adr-017-enums.md)                           | Enums                   | Type-safe enums with C-style casting                         |
+| [ADR-030](docs/decisions/adr-030-forward-declarations.md)            | Define-Before-Use       | Functions must be defined before called                      |
+| [ADR-037](docs/decisions/adr-037-preprocessor.md)                    | Preprocessor            | Flag-only defines, const for values                          |
+| [ADR-043](docs/decisions/adr-043-comments.md)                        | Comments                | Comment preservation with MISRA compliance                   |
+| [ADR-044](docs/decisions/adr-044-primitive-types.md)                 | Primitive Types         | Fixed-width types with `clamp`/`wrap` overflow               |
+| [ADR-024](docs/decisions/adr-024-type-casting.md)                    | Type Casting            | Widening implicit, narrowing uses bit indexing               |
+| [ADR-022](docs/decisions/adr-022-conditional-expressions.md)         | Conditional Expressions | Ternary with required parens, boolean condition, no nesting  |
+| [ADR-025](docs/decisions/adr-025-switch-statements.md)               | Switch Statements       | Safe switch with braces, `\|\|` syntax, counted `default(n)` |
+| [ADR-029](docs/decisions/adr-029-function-pointers.md)               | Callbacks               | Function-as-Type pattern with nominal typing                 |
+| [ADR-045](docs/decisions/adr-045-string-type.md)                     | Bounded Strings         | `string<N>` with compile-time safety                         |
+| [ADR-023](docs/decisions/adr-023-sizeof.md)                          | Sizeof                  | Type/value size queries with safety checks                   |
+| [ADR-027](docs/decisions/adr-027-do-while.md)                        | Do-While                | `do { } while ()` with boolean condition (E0701)             |
+| [ADR-032](docs/decisions/adr-032-nested-structs.md)                  | Nested Structs          | Named nested structs only (no anonymous)                     |
+| [ADR-035](docs/decisions/adr-035-array-initializers.md)              | Array Initializers      | `[1, 2, 3]` syntax with `[0*]` fill-all                      |
+| [ADR-036](docs/decisions/adr-036-multidimensional-arrays.md)         | Multi-dim Arrays        | `arr[i][j]` with compile-time bounds enforcement             |
+| [ADR-040](docs/decisions/adr-040-isr-declaration.md)                 | ISR Type                | Built-in `ISR` type for `void(void)` function pointers       |
+| [ADR-034](docs/decisions/adr-034-bit-fields.md)                      | Bitmap Types            | `bitmap8`/`bitmap16`/`bitmap32` for portable bit-packed data |
+| [ADR-048](docs/decisions/adr-048-cli-executable.md)                  | CLI Executable          | `cnext` command with smart defaults                          |
+| [ADR-049](docs/decisions/adr-049-atomic-types.md)                    | Atomic Types            | `atomic` keyword with LDREX/STREX or PRIMASK fallback        |
+| [ADR-050](docs/decisions/adr-050-critical-sections.md)               | Critical Sections       | `critical { }` blocks with PRIMASK save/restore              |
+| [ADR-108](docs/decisions/adr-108-volatile-keyword.md)                | Volatile Variables      | `volatile` keyword prevents compiler optimization            |
+| [ADR-047](docs/decisions/adr-047-nullable-types.md)                  | NULL for C Interop      | `NULL` keyword for C stream function comparisons             |
+| [ADR-052](docs/decisions/adr-052-safe-numeric-literal-generation.md) | Safe Numeric Literals   | `type_MIN`/`type_MAX` constants + safe hex conversion        |
 
 ### Research (v1 Roadmap)
 

package/grammar/CNext.g4

@@ -345,8 +345,8 @@ switchCase
 caseLabel
     : qualifiedType      // Enum value: EState.IDLE
     | IDENTIFIER         // Const or enum member
-    | INTEGER_LITERAL
-    | HEX_LITERAL
+    | '-'? INTEGER_LITERAL  // Allow negative integers
+    | '-'? HEX_LITERAL      // Allow negative hex (e.g., -0x80)
     | BINARY_LITERAL
     | CHAR_LITERAL
     ;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "main": "src/index.ts",
   "bin": {

package/src/codegen/CodeGenerator.ts

@@ -42,6 +42,21 @@ const TYPE_MAP: Record<string, string> = {
   ISR: "ISR", // ADR-040: Interrupt Service Routine function pointer
 };
 
+/**
+ * Maps C-Next types to wider C types for clamp helper operands
+ * Issue #94: Prevents silent truncation when operand exceeds target type range
+ */
+const WIDER_TYPE_MAP: Record<string, string> = {
+  u8: "uint32_t",
+  u16: "uint32_t",
+  u32: "uint64_t",
+  u64: "uint64_t", // Already widest
+  i8: "int32_t",
+  i16: "int32_t",
+  i32: "int64_t",
+  i64: "int64_t", // Already widest
+};
+
 /**
  * Maps C-Next assignment operators to C assignment operators
  */
@@ -329,6 +344,23 @@ export default class CodeGenerator {
     return undefined;
   }
 
+  /**
+   * Check if a type name is a known struct (C-Next or C header).
+   * Issue #103: Must check both local knownStructs AND SymbolTable
+   * for proper type chain tracking through nested C header structs.
+   */
+  private isKnownStruct(typeName: string): boolean {
+    // Check C-Next structs first (local definitions)
+    if (this.knownStructs.has(typeName)) {
+      return true;
+    }
+    // Check SymbolTable for C header structs
+    if (this.symbolTable?.getStructFields(typeName)) {
+      return true;
+    }
+    return false;
+  }
+
   /**
    * Check if a function is a C-Next function (uses pass-by-reference semantics).
    * Checks both internal tracking and external symbol table.
@@ -1896,7 +1928,7 @@ export default class CodeGenerator {
       );
     }
 
-    if (this.knownStructs.has(identifier)) {
+    if (this.isKnownStruct(identifier)) {
       throw new Error(
         `Error: Use 'global.${identifier}' to access global struct '${identifier}' inside scope '${this.context.currentScope}'`,
       );
@@ -4147,7 +4179,7 @@ export default class CodeGenerator {
 
           // ADR-029: Validate callback field assignments with nominal typing
           const rootTypeInfo = this.context.typeRegistry.get(rootName);
-          if (rootTypeInfo && this.knownStructs.has(rootTypeInfo.baseType)) {
+          if (rootTypeInfo && this.isKnownStruct(rootTypeInfo.baseType)) {
             const structType = rootTypeInfo.baseType;
             const callbackFieldKey = `${structType}.${memberName}`;
             const expectedCallbackType =
@@ -4439,7 +4471,7 @@ export default class CodeGenerator {
           let _lastMemberStructType: string | undefined; // Struct type containing the last member (kept for future use)
           const firstTypeInfo = this.context.typeRegistry.get(firstId);
           if (firstTypeInfo) {
-            currentStructType = this.knownStructs.has(firstTypeInfo.baseType)
+            currentStructType = this.isKnownStruct(firstTypeInfo.baseType)
               ? firstTypeInfo.baseType
               : undefined;
           }
@@ -4472,7 +4504,7 @@ export default class CodeGenerator {
                     this.structFieldArrays.get(currentStructType);
                   lastMemberIsArray = arrayFields?.has(memberName) ?? false;
                   // Check if this member is itself a struct
-                  if (lastMemberType && this.knownStructs.has(lastMemberType)) {
+                  if (lastMemberType && this.isKnownStruct(lastMemberType)) {
                     currentStructType = lastMemberType;
                   } else {
                     currentStructType = undefined;
@@ -4518,7 +4550,7 @@ export default class CodeGenerator {
                 if (firstTypeInfo?.isArray && exprIndex === 1) {
                   // First subscript on array - element type might be a struct
                   const elementType = firstTypeInfo.baseType;
-                  if (this.knownStructs.has(elementType)) {
+                  if (this.isKnownStruct(elementType)) {
                     currentStructType = elementType;
                   }
                 }
@@ -4543,10 +4575,7 @@ export default class CodeGenerator {
             const fieldName = identifiers[1].getText();
 
             const structTypeInfo = this.context.typeRegistry.get(structName);
-            if (
-              structTypeInfo &&
-              this.knownStructs.has(structTypeInfo.baseType)
-            ) {
+            if (structTypeInfo && this.isKnownStruct(structTypeInfo.baseType)) {
               const structType = structTypeInfo.baseType;
               const fieldDimensions =
                 this.structFieldDimensions.get(structType);
@@ -5084,7 +5113,7 @@ export default class CodeGenerator {
         const fieldName = identifiers[1].getText();
 
         const structTypeInfo = this.context.typeRegistry.get(structName);
-        if (structTypeInfo && this.knownStructs.has(structTypeInfo.baseType)) {
+        if (structTypeInfo && this.isKnownStruct(structTypeInfo.baseType)) {
           const structType = structTypeInfo.baseType;
 
           // Check if this field is a string array in the struct
@@ -5759,13 +5788,19 @@ export default class CodeGenerator {
       return ctx.IDENTIFIER()!.getText();
     }
 
-    // Numeric literals
+    // Numeric literals (may have optional minus prefix)
     if (ctx.INTEGER_LITERAL()) {
-      return ctx.INTEGER_LITERAL()!.getText();
+      const num = ctx.INTEGER_LITERAL()!.getText();
+      // Check if minus token exists (first child would be '-')
+      const hasNeg = ctx.children && ctx.children[0]?.getText() === "-";
+      return hasNeg ? `-${num}` : num;
     }
 
     if (ctx.HEX_LITERAL()) {
-      return ctx.HEX_LITERAL()!.getText();
+      const hex = ctx.HEX_LITERAL()!.getText();
+      // Check if minus token exists (first child would be '-')
+      const hasNeg = ctx.children && ctx.children[0]?.getText() === "-";
+      return hasNeg ? `-${hex}` : hex;
     }
 
     if (ctx.BINARY_LITERAL()) {
@@ -5928,17 +5963,24 @@ export default class CodeGenerator {
       return ctx.IDENTIFIER()!.getText();
     }
     if (ctx.INTEGER_LITERAL()) {
-      return ctx.INTEGER_LITERAL()!.getText();
+      const num = ctx.INTEGER_LITERAL()!.getText();
+      // Check if minus token exists (first child would be '-')
+      const hasNeg = ctx.children && ctx.children[0]?.getText() === "-";
+      const value = BigInt(num);
+      return String(hasNeg ? -value : value);
     }
     if (ctx.HEX_LITERAL()) {
       // Normalize hex to decimal for comparison
       const hex = ctx.HEX_LITERAL()!.getText();
-      return String(parseInt(hex, 16));
+      // Check if minus token exists (first child would be '-')
+      const hasNeg = ctx.children && ctx.children[0]?.getText() === "-";
+      const value = BigInt(hex); // BigInt handles 0x prefix natively
+      return String(hasNeg ? -value : value);
     }
     if (ctx.BINARY_LITERAL()) {
       // Normalize binary to decimal for comparison
       const bin = ctx.BINARY_LITERAL()!.getText();
-      return String(parseInt(bin.replace(/0[bB]/, ""), 2));
+      return String(BigInt(bin)); // BigInt handles 0b prefix natively
     }
     if (ctx.CHAR_LITERAL()) {
       return ctx.CHAR_LITERAL()!.getText();
@@ -6854,7 +6896,7 @@ export default class CodeGenerator {
             const resolvedTypeInfo = this.context.typeRegistry.get(result);
             if (
               resolvedTypeInfo &&
-              this.knownStructs.has(resolvedTypeInfo.baseType)
+              this.isKnownStruct(resolvedTypeInfo.baseType)
             ) {
               currentStructType = resolvedTypeInfo.baseType;
             }
@@ -6908,7 +6950,7 @@ export default class CodeGenerator {
                 this.context.typeRegistry.get(currentIdentifier);
               if (
                 identifierTypeInfo &&
-                this.knownStructs.has(identifierTypeInfo.baseType)
+                this.isKnownStruct(identifierTypeInfo.baseType)
               ) {
                 currentStructType = identifierTypeInfo.baseType;
               }
@@ -6937,7 +6979,7 @@ export default class CodeGenerator {
                 this.context.typeRegistry.get(currentIdentifier);
               if (
                 identifierTypeInfo &&
-                this.knownStructs.has(identifierTypeInfo.baseType)
+                this.isKnownStruct(identifierTypeInfo.baseType)
               ) {
                 currentStructType = identifierTypeInfo.baseType;
               }
@@ -6977,7 +7019,7 @@ export default class CodeGenerator {
               const resolvedTypeInfo = this.context.typeRegistry.get(result);
               if (
                 resolvedTypeInfo &&
-                this.knownStructs.has(resolvedTypeInfo.baseType)
+                this.isKnownStruct(resolvedTypeInfo.baseType)
               ) {
                 currentStructType = resolvedTypeInfo.baseType;
               }
@@ -7096,7 +7138,7 @@ export default class CodeGenerator {
             // After consuming all array dimensions, set struct type if element is struct
             if (remainingArrayDims === 0 && primaryTypeInfo) {
               const elementType = primaryTypeInfo.baseType;
-              if (this.knownStructs.has(elementType)) {
+              if (this.isKnownStruct(elementType)) {
                 currentStructType = elementType;
               }
             }
@@ -7112,7 +7154,7 @@ export default class CodeGenerator {
             // After subscripting an array, set currentStructType if the element is a struct
             if (identifierTypeInfo && !currentStructType) {
               const elementType = identifierTypeInfo.baseType;
-              if (this.knownStructs.has(elementType)) {
+              if (this.isKnownStruct(elementType)) {
                 currentStructType = elementType;
               }
             }
@@ -7344,11 +7386,19 @@ export default class CodeGenerator {
       return id;
     }
     if (ctx.literal()) {
-      const literalText = ctx.literal()!.getText();
+      let literalText = ctx.literal()!.getText();
       // Track boolean literal usage to include stdbool.h
       if (literalText === "true" || literalText === "false") {
         this.needsStdbool = true;
       }
+      // ADR-024: Transform C-Next float suffixes to standard C syntax
+      // 3.14f32 -> 3.14f (C float)
+      // 3.14f64 -> 3.14 (C double, no suffix needed)
+      if (/[fF]32$/.test(literalText)) {
+        literalText = literalText.replace(/[fF]32$/, "f");
+      } else if (/[fF]64$/.test(literalText)) {
+        literalText = literalText.replace(/[fF]64$/, "");
+      }
       return literalText;
     }
     if (ctx.expression()) {
@@ -7450,7 +7500,7 @@ export default class CodeGenerator {
         }
 
         // Check if it's a known struct (actual type)
-        if (this.knownStructs.has(varName)) {
+        if (this.isKnownStruct(varName)) {
           return `sizeof(${varName})`;
         }
 
@@ -7725,7 +7775,7 @@ export default class CodeGenerator {
           let lastMemberIsArray = false; // Track if last accessed member is an array
           const firstTypeInfo = this.context.typeRegistry.get(firstPart);
           if (firstTypeInfo) {
-            currentStructType = this.knownStructs.has(firstTypeInfo.baseType)
+            currentStructType = this.isKnownStruct(firstTypeInfo.baseType)
               ? firstTypeInfo.baseType
               : undefined;
           }
@@ -7754,7 +7804,7 @@ export default class CodeGenerator {
                     this.structFieldArrays.get(currentStructType);
                   lastMemberIsArray = arrayFields?.has(memberName) ?? false;
                   // Check if this member is itself a struct
-                  if (lastMemberType && this.knownStructs.has(lastMemberType)) {
+                  if (lastMemberType && this.isKnownStruct(lastMemberType)) {
                     currentStructType = lastMemberType;
                   } else {
                     currentStructType = undefined;
@@ -7795,7 +7845,7 @@ export default class CodeGenerator {
                 if (firstTypeInfo?.isArray && exprIndex === 1) {
                   // First subscript on array - element type might be a struct
                   const elementType = firstTypeInfo.baseType;
-                  if (this.knownStructs.has(elementType)) {
+                  if (this.isKnownStruct(elementType)) {
                     currentStructType = elementType;
                   }
                 }
@@ -8363,6 +8413,7 @@ export default class CodeGenerator {
     cnxType: string,
   ): string | null {
     const cType = TYPE_MAP[cnxType];
+    const widerType = WIDER_TYPE_MAP[cnxType] || cType;
     const maxValue = CodeGenerator.TYPE_MAX[cnxType];
     const minValue = CodeGenerator.TYPE_MIN[cnxType];
 
@@ -8372,16 +8423,29 @@ export default class CodeGenerator {
 
     const isUnsigned = cnxType.startsWith("u");
 
+    // For signed types narrower than i64, use wider arithmetic to avoid UB (Issue #94)
+    const useWiderArithmetic =
+      !isUnsigned && widerType !== cType && cnxType !== "i64";
+
     switch (operation) {
       case "add":
         if (isUnsigned) {
-          // Unsigned addition: check if result would wrap
-          return `static inline ${cType} cnx_clamp_add_${cnxType}(${cType} a, ${cType} b) {
-    if (a > ${maxValue} - b) return ${maxValue};
-    return a + b;
+          // Unsigned addition: use wider type for b to prevent truncation (Issue #94)
+          return `static inline ${cType} cnx_clamp_add_${cnxType}(${cType} a, ${widerType} b) {
+    if (b > ${maxValue} - a) return ${maxValue};
+    return a + (${cType})b;
+}`;
+        } else if (useWiderArithmetic) {
+          // Signed addition: compute in wider type, then clamp (Issue #94)
+          // This avoids UB from casting out-of-range values
+          return `static inline ${cType} cnx_clamp_add_${cnxType}(${cType} a, ${widerType} b) {
+    ${widerType} result = (${widerType})a + b;
+    if (result > ${maxValue}) return ${maxValue};
+    if (result < ${minValue}) return ${minValue};
+    return (${cType})result;
 }`;
         } else {
-          // Signed addition: check both overflow and underflow
+          // i64: already widest type, use original check logic
           return `static inline ${cType} cnx_clamp_add_${cnxType}(${cType} a, ${cType} b) {
     if (b > 0 && a > ${maxValue} - b) return ${maxValue};
     if (b < 0 && a < ${minValue} - b) return ${minValue};
@@ -8391,13 +8455,22 @@ export default class CodeGenerator {
 
       case "sub":
         if (isUnsigned) {
-          // Unsigned subtraction: check if result would underflow
-          return `static inline ${cType} cnx_clamp_sub_${cnxType}(${cType} a, ${cType} b) {
-    if (a < b) return 0;
-    return a - b;
+          // Unsigned subtraction: use wider type for b to prevent truncation (Issue #94)
+          // Cast a to wider type for comparison to handle b > type max
+          return `static inline ${cType} cnx_clamp_sub_${cnxType}(${cType} a, ${widerType} b) {
+    if (b >= (${widerType})a) return 0;
+    return a - (${cType})b;
+}`;
+        } else if (useWiderArithmetic) {
+          // Signed subtraction: compute in wider type, then clamp (Issue #94)
+          return `static inline ${cType} cnx_clamp_sub_${cnxType}(${cType} a, ${widerType} b) {
+    ${widerType} result = (${widerType})a - b;
+    if (result > ${maxValue}) return ${maxValue};
+    if (result < ${minValue}) return ${minValue};
+    return (${cType})result;
 }`;
         } else {
-          // Signed subtraction: check both overflow and underflow
+          // i64: already widest type, use original check logic
           return `static inline ${cType} cnx_clamp_sub_${cnxType}(${cType} a, ${cType} b) {
     if (b < 0 && a > ${maxValue} + b) return ${maxValue};
     if (b > 0 && a < ${minValue} + b) return ${minValue};
@@ -8407,13 +8480,21 @@ export default class CodeGenerator {
 
       case "mul":
         if (isUnsigned) {
-          // Unsigned multiplication
-          return `static inline ${cType} cnx_clamp_mul_${cnxType}(${cType} a, ${cType} b) {
+          // Unsigned multiplication: use wider type for b to prevent truncation (Issue #94)
+          return `static inline ${cType} cnx_clamp_mul_${cnxType}(${cType} a, ${widerType} b) {
     if (b != 0 && a > ${maxValue} / b) return ${maxValue};
-    return a * b;
+    return a * (${cType})b;
+}`;
+        } else if (useWiderArithmetic) {
+          // Signed multiplication: compute in wider type, then clamp (Issue #94)
+          return `static inline ${cType} cnx_clamp_mul_${cnxType}(${cType} a, ${widerType} b) {
+    ${widerType} result = (${widerType})a * b;
+    if (result > ${maxValue}) return ${maxValue};
+    if (result < ${minValue}) return ${minValue};
+    return (${cType})result;
 }`;
         } else {
-          // Signed multiplication: handle negative cases
+          // i64: already widest type, use original check logic
           return `static inline ${cType} cnx_clamp_mul_${cnxType}(${cType} a, ${cType} b) {
     if (a == 0 || b == 0) return 0;
     if (a > 0 && b > 0 && a > ${maxValue} / b) return ${maxValue};
@@ -8437,6 +8518,7 @@ export default class CodeGenerator {
     cnxType: string,
   ): string | null {
     const cType = TYPE_MAP[cnxType];
+    const widerType = WIDER_TYPE_MAP[cnxType] || cType;
     const maxValue = CodeGenerator.TYPE_MAX[cnxType];
     const minValue = CodeGenerator.TYPE_MIN[cnxType];
 
@@ -8452,17 +8534,33 @@ export default class CodeGenerator {
           ? "subtraction"
           : "multiplication";
 
+    // For signed types narrower than i64, use wider arithmetic to avoid UB (Issue #94)
+    const useWiderArithmetic =
+      !isUnsigned && widerType !== cType && cnxType !== "i64";
+
     switch (operation) {
       case "add":
         if (isUnsigned) {
-          return `static inline ${cType} cnx_clamp_add_${cnxType}(${cType} a, ${cType} b) {
-    if (a > ${maxValue} - b) {
+          // Use wider type for b to prevent truncation (Issue #94)
+          return `static inline ${cType} cnx_clamp_add_${cnxType}(${cType} a, ${widerType} b) {
+    if (b > ${maxValue} - a) {
         fprintf(stderr, "PANIC: Integer overflow in ${cnxType} ${opName}\\n");
         abort();
     }
-    return a + b;
+    return a + (${cType})b;
+}`;
+        } else if (useWiderArithmetic) {
+          // Signed addition: compute in wider type, check bounds (Issue #94)
+          return `static inline ${cType} cnx_clamp_add_${cnxType}(${cType} a, ${widerType} b) {
+    ${widerType} result = (${widerType})a + b;
+    if (result > ${maxValue} || result < ${minValue}) {
+        fprintf(stderr, "PANIC: Integer overflow in ${cnxType} ${opName}\\n");
+        abort();
+    }
+    return (${cType})result;
 }`;
         } else {
+          // i64: already widest type, use original check logic
           return `static inline ${cType} cnx_clamp_add_${cnxType}(${cType} a, ${cType} b) {
     if ((b > 0 && a > ${maxValue} - b) || (b < 0 && a < ${minValue} - b)) {
         fprintf(stderr, "PANIC: Integer overflow in ${cnxType} ${opName}\\n");
@@ -8474,14 +8572,26 @@ export default class CodeGenerator {
 
       case "sub":
         if (isUnsigned) {
-          return `static inline ${cType} cnx_clamp_sub_${cnxType}(${cType} a, ${cType} b) {
-    if (a < b) {
+          // Use wider type for b to prevent truncation (Issue #94)
+          return `static inline ${cType} cnx_clamp_sub_${cnxType}(${cType} a, ${widerType} b) {
+    if (b >= (${widerType})a) {
         fprintf(stderr, "PANIC: Integer underflow in ${cnxType} ${opName}\\n");
         abort();
     }
-    return a - b;
+    return a - (${cType})b;
+}`;
+        } else if (useWiderArithmetic) {
+          // Signed subtraction: compute in wider type, check bounds (Issue #94)
+          return `static inline ${cType} cnx_clamp_sub_${cnxType}(${cType} a, ${widerType} b) {
+    ${widerType} result = (${widerType})a - b;
+    if (result > ${maxValue} || result < ${minValue}) {
+        fprintf(stderr, "PANIC: Integer overflow in ${cnxType} ${opName}\\n");
+        abort();
+    }
+    return (${cType})result;
 }`;
         } else {
+          // i64: already widest type, use original check logic
           return `static inline ${cType} cnx_clamp_sub_${cnxType}(${cType} a, ${cType} b) {
     if ((b < 0 && a > ${maxValue} + b) || (b > 0 && a < ${minValue} + b)) {
         fprintf(stderr, "PANIC: Integer overflow in ${cnxType} ${opName}\\n");
@@ -8493,14 +8603,26 @@ export default class CodeGenerator {
 
       case "mul":
         if (isUnsigned) {
-          return `static inline ${cType} cnx_clamp_mul_${cnxType}(${cType} a, ${cType} b) {
+          // Use wider type for b to prevent truncation (Issue #94)
+          return `static inline ${cType} cnx_clamp_mul_${cnxType}(${cType} a, ${widerType} b) {
     if (b != 0 && a > ${maxValue} / b) {
         fprintf(stderr, "PANIC: Integer overflow in ${cnxType} ${opName}\\n");
         abort();
     }
-    return a * b;
+    return a * (${cType})b;
+}`;
+        } else if (useWiderArithmetic) {
+          // Signed multiplication: compute in wider type, check bounds (Issue #94)
+          return `static inline ${cType} cnx_clamp_mul_${cnxType}(${cType} a, ${widerType} b) {
+    ${widerType} result = (${widerType})a * b;
+    if (result > ${maxValue} || result < ${minValue}) {
+        fprintf(stderr, "PANIC: Integer overflow in ${cnxType} ${opName}\\n");
+        abort();
+    }
+    return (${cType})result;
 }`;
         } else {
+          // i64: already widest type, use original check logic
           return `static inline ${cType} cnx_clamp_mul_${cnxType}(${cType} a, ${cType} b) {
     if (a != 0 && b != 0) {
         if ((a > 0 && b > 0 && a > ${maxValue} / b) ||

package/src/codegen/TypeResolver.ts

@@ -47,12 +47,22 @@ class TypeResolver {
   }
 
   /**
-   * Check if a type is a user-defined struct
+   * Check if a type is a user-defined struct (C-Next or C header).
+   * Issue #103: Now checks both knownStructs AND SymbolTable.
    */
   isStructType(typeName: string): boolean {
-    // Access CodeGenerator's knownStructs set via reference
+    // Check C-Next structs first
     // eslint-disable-next-line @typescript-eslint/dot-notation
-    return this.codeGen["knownStructs"].has(typeName);
+    if (this.codeGen["knownStructs"].has(typeName)) {
+      return true;
+    }
+    // Check SymbolTable for C header structs
+    // eslint-disable-next-line @typescript-eslint/dot-notation
+    const symbolTable = this.codeGen["symbolTable"];
+    if (symbolTable?.getStructFields(typeName)) {
+      return true;
+    }
+    return false;
   }
 
   /**
@@ -340,11 +350,28 @@ class TypeResolver {
   /**
    * Get type info for a struct member field
    * Used to track types through member access chains like buf.data[0]
+   * Issue #103: Now checks SymbolTable first for C header structs
    */
   getMemberTypeInfo(
     structType: string,
     memberName: string,
   ): { isArray: boolean; baseType: string } | undefined {
+    // First check SymbolTable (C header structs) - Issue #103 fix
+    // eslint-disable-next-line @typescript-eslint/dot-notation
+    const symbolTable = this.codeGen["symbolTable"];
+    if (symbolTable) {
+      const fieldInfo = symbolTable.getStructFieldInfo(structType, memberName);
+      if (fieldInfo) {
+        return {
+          isArray:
+            fieldInfo.arrayDimensions !== undefined &&
+            fieldInfo.arrayDimensions.length > 0,
+          baseType: fieldInfo.type,
+        };
+      }
+    }
+
+    // Fall back to local C-Next struct fields
     // eslint-disable-next-line @typescript-eslint/dot-notation
     const fieldType = this.codeGen["structFields"]
       .get(structType)