c-next 0.1.6 → 0.1.8

package/package.json

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

package/src/codegen/CodeGenerator.ts

@@ -5592,10 +5592,12 @@ export default class CodeGenerator implements IOrchestrator {
 
       // ADR-040: ISR arrays use normal array indexing, not bit manipulation
       // Also handle any array type that isn't an integer scalar
+      // Issue #213: String parameters (isString=true) should also use memcpy for slice assignment
       const isActualArray =
-        typeInfo?.isArray &&
-        typeInfo.arrayDimensions &&
-        typeInfo.arrayDimensions.length > 0;
+        (typeInfo?.isArray &&
+          typeInfo.arrayDimensions &&
+          typeInfo.arrayDimensions.length > 0) ||
+        typeInfo?.isString;
       const isISRType = typeInfo?.baseType === "ISR";
 
       if (isActualArray || isISRType) {
@@ -5617,6 +5619,16 @@ export default class CodeGenerator implements IOrchestrator {
 
           // Generate bounds-checked memcpy
           // if (offset + length <= sizeof(buffer)) { memcpy(&buffer[offset], &value, length); }
+          // Issue #213: For string parameters, use capacity for bounds checking
+          // since sizeof(char*) gives pointer size, not buffer size
+          if (
+            typeInfo?.isString &&
+            typeInfo.stringCapacity &&
+            !typeInfo.isArray
+          ) {
+            const capacity = typeInfo.stringCapacity + 1;
+            return `if (${offset} + ${length} <= ${capacity}) { memcpy(&${name}[${offset}], &${value}, ${length}); }`;
+          }
           return `if (${offset} + ${length} <= sizeof(${name})) { memcpy(&${name}[${offset}], &${value}, ${length}); }`;
         }
 
@@ -6693,6 +6705,33 @@ export default class CodeGenerator implements IOrchestrator {
           continue; // Skip further processing, this just sets the base identifier
         }
 
+        // Issue #212: Check if 'length' is a scope variable before treating it as a property accessor
+        // When accessing this.length, we need to check if 'length' is a scope variable name
+        // If so, transform it to the scope variable (e.g., Scope_length) instead of treating
+        // it as the .length property accessor
+        if (result === "__THIS_SCOPE__" && memberName === "length") {
+          if (!this.context.currentScope) {
+            throw new Error("Error: 'this' can only be used inside a scope");
+          }
+          const members = this.context.scopeMembers.get(
+            this.context.currentScope,
+          );
+          if (members && members.has("length")) {
+            // This is a scope variable named 'length', not a property accessor
+            result = `${this.context.currentScope}_${memberName}`;
+            currentIdentifier = result;
+            // Set struct type for chained access if applicable
+            const resolvedTypeInfo = this.context.typeRegistry.get(result);
+            if (
+              resolvedTypeInfo &&
+              this.isKnownStruct(resolvedTypeInfo.baseType)
+            ) {
+              currentStructType = resolvedTypeInfo.baseType;
+            }
+            continue; // Skip the .length property handler
+          }
+        }
+
         // Handle .length property for arrays, strings, and integers
         if (memberName === "length") {
           // Special case: main function's args.length -> argc
@@ -6749,9 +6788,15 @@ export default class CodeGenerator implements IOrchestrator {
                   subscriptDepth >= dimensions.length
                 ) {
                   // Array member fully subscripted (e.g., ts.arr[0][1].length) -> return element bit width
-                  // Try C-Next types first, then C types
-                  const bitWidth =
+                  // Try C-Next types first, then C types, then enum types
+                  let bitWidth =
                     TYPE_WIDTH[memberType] || C_TYPE_WIDTH[memberType] || 0;
+                  // Issue #208: Check if it's a typed enum
+                  if (bitWidth === 0 && this.symbolTable) {
+                    const enumWidth =
+                      this.symbolTable.getEnumBitWidth(memberType);
+                    if (enumWidth) bitWidth = enumWidth;
+                  }
                   if (bitWidth > 0) {
                     result = String(bitWidth);
                   } else {
@@ -6759,9 +6804,15 @@ export default class CodeGenerator implements IOrchestrator {
                   }
                 } else {
                   // Non-array member -> return bit width
-                  // Try C-Next types first, then C types
-                  const bitWidth =
+                  // Try C-Next types first, then C types, then enum types
+                  let bitWidth =
                     TYPE_WIDTH[memberType] || C_TYPE_WIDTH[memberType] || 0;
+                  // Issue #208: Check if it's a typed enum
+                  if (bitWidth === 0 && this.symbolTable) {
+                    const enumWidth =
+                      this.symbolTable.getEnumBitWidth(memberType);
+                    if (enumWidth) bitWidth = enumWidth;
+                  }
                   if (bitWidth > 0) {
                     result = String(bitWidth);
                   } else {

package/src/index.ts

@@ -25,7 +25,8 @@ const packageJson = require("../package.json");
  * C-Next configuration file options
  */
 interface ICNextConfig {
-  outputExtension?: ".c" | ".cpp";
+  /** Issue #211: Force C++ output. Auto-detection may also enable this. */
+  cppRequired?: boolean;
   generateHeaders?: boolean;
   debugMode?: boolean;
   target?: string; // ADR-049: Target platform (e.g., "teensy41", "cortex-m0")
@@ -130,7 +131,7 @@ function showHelp(): void {
   console.log("  cnext.config.json, .cnext.json, .cnextrc");
   console.log("");
   console.log("Config example:");
-  console.log('  { "outputExtension": ".cpp" }');
+  console.log('  { "cppRequired": true }');
   console.log("");
   console.log("A safer C for embedded systems development.");
 }
@@ -188,7 +189,7 @@ async function runUnifiedMode(
   generateHeaders: boolean,
   preprocess: boolean,
   verbose: boolean,
-  outputExtension: ".c" | ".cpp",
+  cppRequired: boolean,
   noCache: boolean,
 ): Promise<void> {
   // Step 1: Expand directories to .cnx files
@@ -257,7 +258,7 @@ async function runUnifiedMode(
     generateHeaders,
     preprocess,
     defines,
-    outputExtension,
+    cppRequired,
     noCache,
   });
 
@@ -466,7 +467,7 @@ async function main(): Promise<void> {
   const includeDirs: string[] = [];
   const defines: Record<string, string | boolean> = {};
   let cliGenerateHeaders: boolean | undefined;
-  let cliOutputExtension: ".c" | ".cpp" | undefined;
+  let cliCppRequired: boolean | undefined;
   let preprocess = true;
   let verbose = false;
   let noCache = false;
@@ -483,7 +484,7 @@ async function main(): Promise<void> {
     } else if (arg === "--exclude-headers") {
       cliGenerateHeaders = false;
     } else if (arg === "--cpp") {
-      cliOutputExtension = ".cpp";
+      cliCppRequired = true;
     } else if (arg === "--no-preprocess") {
       preprocess = false;
     } else if (arg === "--no-cache") {
@@ -508,7 +509,7 @@ async function main(): Promise<void> {
 
   // Apply config defaults, CLI flags take precedence
   const generateHeaders = cliGenerateHeaders ?? config.generateHeaders ?? true;
-  const outputExtension = cliOutputExtension ?? config.outputExtension ?? ".c";
+  const cppRequired = cliCppRequired ?? config.cppRequired ?? false;
 
   // Unified mode - always use Project class with header discovery
   if (inputFiles.length === 0) {
@@ -525,7 +526,7 @@ async function main(): Promise<void> {
     generateHeaders,
     preprocess,
     verbose,
-    outputExtension,
+    cppRequired,
     noCache,
   );
 }

package/src/pipeline/CacheManager.ts

@@ -27,7 +27,7 @@ import ICachedFileEntry from "./types/ICachedFileEntry";
 import ISerializedSymbol from "./types/ISerializedSymbol";
 
 /** Current cache format version - increment when serialization format changes */
-const CACHE_VERSION = 1;
+const CACHE_VERSION = 2; // Issue #208: Added enumBitWidth
 
 // Read version from package.json
 // eslint-disable-next-line @typescript-eslint/no-var-requires
@@ -109,6 +109,7 @@ class CacheManager {
     symbols: ISymbol[];
     structFields: Map<string, Map<string, IStructFieldInfo>>;
     needsStructKeyword: string[];
+    enumBitWidth: Map<string, number>;
   } | null {
     const entry = this.entries.get(filePath);
     if (!entry) {
@@ -128,10 +129,19 @@ class CacheManager {
       structFields.set(structName, fieldMap);
     }
 
+    // Issue #208: Convert enum bit widths from plain object to Map
+    const enumBitWidth = new Map<string, number>();
+    if (entry.enumBitWidth) {
+      for (const [enumName, width] of Object.entries(entry.enumBitWidth)) {
+        enumBitWidth.set(enumName, width);
+      }
+    }
+
     return {
       symbols,
       structFields,
       needsStructKeyword: entry.needsStructKeyword ?? [],
+      enumBitWidth,
     };
   }
 
@@ -143,6 +153,7 @@ class CacheManager {
     symbols: ISymbol[],
     structFields: Map<string, Map<string, IStructFieldInfo>>,
     needsStructKeyword?: string[],
+    enumBitWidth?: Map<string, number>,
   ): void {
     // Get current mtime
     let mtime: number;
@@ -169,6 +180,14 @@ class CacheManager {
       }
     }
 
+    // Issue #208: Convert enum bit widths from Map to plain object
+    const serializedEnumBitWidth: Record<string, number> = {};
+    if (enumBitWidth) {
+      for (const [enumName, width] of enumBitWidth) {
+        serializedEnumBitWidth[enumName] = width;
+      }
+    }
+
     // Create entry
     const entry: ICachedFileEntry = {
       filePath,
@@ -176,6 +195,7 @@ class CacheManager {
       symbols: serializedSymbols,
       structFields: serializedFields,
       needsStructKeyword,
+      enumBitWidth: serializedEnumBitWidth,
     };
 
     this.entries.set(filePath, entry);

package/src/pipeline/Pipeline.ts

@@ -26,7 +26,6 @@ import { CPP14Parser } from "../parser/cpp/grammar/CPP14Parser";
 import CodeGenerator from "../codegen/CodeGenerator";
 import HeaderGenerator from "../codegen/HeaderGenerator";
 import SymbolTable from "../symbols/SymbolTable";
-import ISymbol from "../types/ISymbol";
 import CNextSymbolCollector from "../symbols/CNextSymbolCollector";
 import CSymbolCollector from "../symbols/CSymbolCollector";
 import CppSymbolCollector from "../symbols/CppSymbolCollector";
@@ -44,6 +43,7 @@ import IFileResult from "./types/IFileResult";
 import runAnalyzers from "./runAnalyzers";
 import CacheManager from "./CacheManager";
 import IStructFieldInfo from "../symbols/types/IStructFieldInfo";
+import detectCppSyntax from "./detectCppSyntax";
 
 /**
  * Unified transpilation pipeline
@@ -56,6 +56,8 @@ class Pipeline {
   private headerGenerator: HeaderGenerator;
   private warnings: string[];
   private cacheManager: CacheManager | null;
+  /** Issue #211: Tracks if C++ output is needed (one-way flag, false → true only) */
+  private cppDetected: boolean;
 
   constructor(config: IPipelineConfig) {
     // Apply defaults
@@ -66,7 +68,7 @@ class Pipeline {
       defines: config.defines ?? {},
       preprocess: config.preprocess ?? true,
       generateHeaders: config.generateHeaders ?? true,
-      outputExtension: config.outputExtension ?? ".c",
+      cppRequired: config.cppRequired ?? false,
       parseOnly: config.parseOnly ?? false,
       debugMode: config.debugMode ?? false,
       target: config.target ?? "",
@@ -74,6 +76,9 @@ class Pipeline {
       noCache: config.noCache ?? false,
     };
 
+    // Issue #211: Initialize cppDetected from config (--cpp flag sets this)
+    this.cppDetected = this.config.cppRequired;
+
     this.symbolTable = new SymbolTable();
     this.preprocessor = new Preprocessor();
     this.codeGenerator = new CodeGenerator();
@@ -312,11 +317,25 @@ class Pipeline {
     if (this.cacheManager?.isValid(file.path)) {
       const cached = this.cacheManager.getSymbols(file.path);
       if (cached) {
-        // Restore symbols, struct fields, and needsStructKeyword from cache
+        // Restore symbols, struct fields, needsStructKeyword, and enumBitWidth from cache
         this.symbolTable.addSymbols(cached.symbols);
         this.symbolTable.restoreStructFields(cached.structFields);
         this.symbolTable.restoreNeedsStructKeyword(cached.needsStructKeyword);
-        return; // Cache hit - skip parsing
+        this.symbolTable.restoreEnumBitWidths(cached.enumBitWidth);
+
+        // Issue #211: Still check for C++ syntax even on cache hit
+        // The detection is cheap (regex only) and ensures cppDetected is set correctly
+        if (file.type === EFileType.CHeader) {
+          const content = readFileSync(file.path, "utf-8");
+          if (detectCppSyntax(content)) {
+            this.cppDetected = true;
+          }
+        } else if (file.type === EFileType.CppHeader) {
+          // .hpp files are always C++
+          this.cppDetected = true;
+        }
+
+        return; // Cache hit - skip full parsing
       }
     }
 
@@ -346,6 +365,8 @@ class Pipeline {
     if (file.type === EFileType.CHeader) {
       this.parseCHeader(content, file.path);
     } else if (file.type === EFileType.CppHeader) {
+      // Issue #211: .hpp files are always C++
+      this.cppDetected = true;
       this.parseCppHeader(content, file.path);
     }
 
@@ -356,23 +377,37 @@ class Pipeline {
       const needsStructKeyword = this.extractNeedsStructKeywordForFile(
         file.path,
       );
+      const enumBitWidth = this.extractEnumBitWidthsForFile(file.path);
       this.cacheManager.setSymbols(
         file.path,
         symbols,
         structFields,
         needsStructKeyword,
+        enumBitWidth,
       );
     }
   }
 
   /**
-   * Parse a C header using dual-parse strategy
+   * Issue #208: Parse a C header using single-parser strategy
+   * Uses heuristic detection to choose the appropriate parser
    */
   private parseCHeader(content: string, filePath: string): void {
-    let cSymbols: ISymbol[] = [];
-    let cppSymbols: ISymbol[] = [];
+    if (detectCppSyntax(content)) {
+      // Issue #211: C++ detected, set flag for .cpp output
+      this.cppDetected = true;
+      // Use C++14 parser for headers with C++ syntax (typed enums, classes, etc.)
+      this.parseCppHeader(content, filePath);
+    } else {
+      // Use C parser for pure C headers
+      this.parsePureCHeader(content, filePath);
+    }
+  }
 
-    // Try C parser first
+  /**
+   * Issue #208: Parse a pure C header (no C++ syntax detected)
+   */
+  private parsePureCHeader(content: string, filePath: string): void {
     try {
       const charStream = CharStream.fromString(content);
       const lexer = new CLexer(charStream);
@@ -382,36 +417,12 @@ class Pipeline {
 
       const tree = parser.compilationUnit();
       const collector = new CSymbolCollector(filePath, this.symbolTable);
-      cSymbols = collector.collect(tree);
-    } catch {
-      // C parser failed
-    }
-
-    // Also try C++ parser for better C++11 support
-    try {
-      const cppCharStream = CharStream.fromString(content);
-      const cppLexer = new CPP14Lexer(cppCharStream);
-      const cppTokenStream = new CommonTokenStream(cppLexer);
-      const cppParser = new CPP14Parser(cppTokenStream);
-      cppParser.removeErrorListeners();
-
-      const cppTree = cppParser.translationUnit();
-      const cppCollector = new CppSymbolCollector(filePath, this.symbolTable);
-      cppSymbols = cppCollector.collect(cppTree);
+      const symbols = collector.collect(tree);
+      if (symbols.length > 0) {
+        this.symbolTable.addSymbols(symbols);
+      }
     } catch {
-      // C++ parser failed
-    }
-
-    // Merge symbols: prefer C++ but supplement with C-only symbols
-    const cppSymbolNames = new Set(cppSymbols.map((s) => s.name));
-    const additionalSymbols = cSymbols.filter(
-      (s) => !cppSymbolNames.has(s.name),
-    );
-
-    const allSymbols = [...cppSymbols, ...additionalSymbols];
-
-    if (allSymbols.length > 0) {
-      this.symbolTable.addSymbols(allSymbols);
+      // Silently ignore parse errors in headers
     }
   }
 
@@ -591,7 +602,8 @@ class Pipeline {
    * Get output path for a file
    */
   private getOutputPath(file: IDiscoveredFile): string {
-    const ext = this.config.outputExtension;
+    // Issue #211: Derive extension from cppDetected flag
+    const ext = this.cppDetected ? ".cpp" : ".c";
     const outputName = basename(file.path).replace(/\.cnx$|\.cnext$/, ext);
 
     // Check if file is in any input directory (for preserving structure)
@@ -961,6 +973,31 @@ class Pipeline {
     const allNeedsKeyword = this.symbolTable.getAllNeedsStructKeyword();
     return structNames.filter((name) => allNeedsKeyword.includes(name));
   }
+
+  /**
+   * Issue #208: Extract enum bit widths for a specific file
+   * Returns enum bit widths for enums defined in that file
+   */
+  private extractEnumBitWidthsForFile(filePath: string): Map<string, number> {
+    const result = new Map<string, number>();
+
+    // Get enum names defined in this file
+    const fileSymbols = this.symbolTable.getSymbolsByFile(filePath);
+    const enumNames = fileSymbols
+      .filter((s) => s.kind === "enum")
+      .map((s) => s.name);
+
+    // Get bit widths for each enum
+    const allBitWidths = this.symbolTable.getAllEnumBitWidths();
+    for (const enumName of enumNames) {
+      const width = allBitWidths.get(enumName);
+      if (width !== undefined) {
+        result.set(enumName, width);
+      }
+    }
+
+    return result;
+  }
 }
 
 export default Pipeline;

package/src/pipeline/detectCppSyntax.ts

@@ -0,0 +1,42 @@
+/**
+ * Issue #208: Detect if header content contains C++ syntax requiring C++14 parser
+ *
+ * This heuristic determines whether to parse a .h file with the C or C++ parser.
+ * Previously, the pipeline would parse ALL .h files with BOTH parsers and merge,
+ * which was wasteful and led to issues with C++-specific features like typed enums.
+ *
+ * C++ indicators:
+ * - Typed enums: enum Name : type { ... }
+ * - Class/struct inheritance: class Foo : public Bar
+ * - Namespaces: namespace Foo { ... }
+ * - Templates: template<...>
+ * - Access specifiers: public:, private:, protected:
+ */
+
+/**
+ * Detect if header content contains C++ syntax requiring C++14 parser
+ * @param content Raw header file content
+ * @returns true if C++ parser should be used, false for C parser
+ */
+function detectCppSyntax(content: string): boolean {
+  // Typed enums: enum Name : type { (C++14 feature, key for Issue #208)
+  if (/enum\s+\w+\s*:\s*\w+\s*\{/.test(content)) return true;
+
+  // Class/struct with inheritance: class Foo : public/private/protected Bar
+  if (/\b(class|struct)\s+\w+\s*:\s*(public|private|protected)/.test(content))
+    return true;
+
+  // namespace keyword: namespace Foo {
+  if (/\bnamespace\s+\w+/.test(content)) return true;
+
+  // template declarations: template<...>
+  if (/\btemplate\s*</.test(content)) return true;
+
+  // Access specifiers at line start (class members)
+  if (/^\s*(public|private|protected)\s*:/m.test(content)) return true;
+
+  // Default to C parser for pure C headers
+  return false;
+}
+
+export default detectCppSyntax;

package/src/pipeline/types/ICachedFileEntry.ts

@@ -16,6 +16,8 @@ interface ICachedFileEntry {
   structFields: Record<string, Record<string, IStructFieldInfo>>;
   /** Issue #196 Bug 3: Struct names requiring 'struct' keyword in C */
   needsStructKeyword?: string[];
+  /** Issue #208: Enum bit widths from typed enums (enum name -> bit width) */
+  enumBitWidth?: Record<string, number>;
 }
 
 export default ICachedFileEntry;

package/src/pipeline/types/IPipelineConfig.ts

@@ -23,8 +23,8 @@ interface IPipelineConfig {
   /** Whether to generate .h files for exported symbols (default: true) */
   generateHeaders?: boolean;
 
-  /** Output file extension (default: ".c") */
-  outputExtension?: ".c" | ".cpp";
+  /** Issue #211: Force C++ output (--cpp flag). Auto-detection may also enable this. */
+  cppRequired?: boolean;
 
   /** Parse only mode - no code generation */
   parseOnly?: boolean;

package/src/project/Project.ts

@@ -49,7 +49,7 @@ class Project {
       defines: this.config.defines,
       preprocess: this.config.preprocess,
       generateHeaders: this.config.generateHeaders,
-      outputExtension: this.config.outputExtension,
+      cppRequired: this.config.cppRequired,
       noCache: this.config.noCache,
     });
   }

package/src/project/types/IProjectConfig.ts

@@ -29,8 +29,8 @@ interface IProjectConfig {
   /** Additional preprocessor defines */
   defines?: Record<string, string | boolean>;
 
-  /** Output file extension (default: ".c") */
-  outputExtension?: ".c" | ".cpp";
+  /** Issue #211: Force C++ output. Auto-detection may also enable this. */
+  cppRequired?: boolean;
 
   /** Issue #183: Disable symbol caching (default: false = cache enabled) */
   noCache?: boolean;

package/src/symbols/CppSymbolCollector.ts

@@ -384,6 +384,66 @@ class CppSymbolCollector {
       isExported: true,
       parent: this.currentNamespace,
     });
+
+    // Issue #208: Extract enum backing type for typed enums (e.g., enum EPressureType : uint8_t)
+    if (this.symbolTable) {
+      const enumbase = enumHead.enumbase?.();
+      if (enumbase) {
+        const typeSpecSeq = enumbase.typeSpecifierSeq?.();
+        if (typeSpecSeq) {
+          const typeName = typeSpecSeq.getText();
+          const bitWidth = this.getTypeWidth(typeName);
+          if (bitWidth > 0) {
+            this.symbolTable.addEnumBitWidth(fullName, bitWidth);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Issue #208: Map C/C++ type names to their bit widths
+   * Supports standard integer types used as enum backing types
+   */
+  private getTypeWidth(typeName: string): number {
+    const typeWidths: Record<string, number> = {
+      // stdint.h types
+      uint8_t: 8,
+      int8_t: 8,
+      uint16_t: 16,
+      int16_t: 16,
+      uint32_t: 32,
+      int32_t: 32,
+      uint64_t: 64,
+      int64_t: 64,
+      // Standard C types (common sizes)
+      char: 8,
+      "signed char": 8,
+      "unsigned char": 8,
+      short: 16,
+      "short int": 16,
+      "signed short": 16,
+      "signed short int": 16,
+      "unsigned short": 16,
+      "unsigned short int": 16,
+      int: 32,
+      "signed int": 32,
+      unsigned: 32,
+      "unsigned int": 32,
+      long: 32,
+      "long int": 32,
+      "signed long": 32,
+      "signed long int": 32,
+      "unsigned long": 32,
+      "unsigned long int": 32,
+      "long long": 64,
+      "long long int": 64,
+      "signed long long": 64,
+      "signed long long int": 64,
+      "unsigned long long": 64,
+      "unsigned long long int": 64,
+    };
+    return typeWidths[typeName] ?? 0;
   }
 
   // Helper methods

package/src/symbols/SymbolTable.ts

@@ -33,6 +33,12 @@ class SymbolTable {
    */
   private needsStructKeyword: Set<string> = new Set();
 
+  /**
+   * Issue #208: Track enum backing type bit widths
+   * C++14 typed enums: enum Name : uint8_t { ... } have explicit bit widths
+   */
+  private enumBitWidth: Map<string, number> = new Map();
+
   /**
    * Add a symbol to the table
    */
@@ -237,6 +243,42 @@ class SymbolTable {
     }
   }
 
+  /**
+   * Issue #208: Add enum bit width for a typed enum
+   * @param enumName Name of the enum (e.g., "EPressureType")
+   * @param bitWidth Bit width from backing type (e.g., 8 for uint8_t)
+   */
+  addEnumBitWidth(enumName: string, bitWidth: number): void {
+    this.enumBitWidth.set(enumName, bitWidth);
+  }
+
+  /**
+   * Issue #208: Get enum bit width for a typed enum
+   * @param enumName Name of the enum
+   * @returns Bit width or undefined if not a typed enum
+   */
+  getEnumBitWidth(enumName: string): number | undefined {
+    return this.enumBitWidth.get(enumName);
+  }
+
+  /**
+   * Issue #208: Get all enum bit widths for cache serialization
+   * @returns Map of enum name -> bit width
+   */
+  getAllEnumBitWidths(): Map<string, number> {
+    return this.enumBitWidth;
+  }
+
+  /**
+   * Issue #208: Restore enum bit widths from cache
+   * @param bitWidths Map of enum name -> bit width
+   */
+  restoreEnumBitWidths(bitWidths: Map<string, number>): void {
+    for (const [enumName, width] of bitWidths) {
+      this.enumBitWidth.set(enumName, width);
+    }
+  }
+
   /**
    * Get all fields for a struct
    * @param structName Name of the struct
@@ -301,6 +343,8 @@ class SymbolTable {
     this.symbols.clear();
     this.byFile.clear();
     this.structFields.clear();
+    this.needsStructKeyword.clear();
+    this.enumBitWidth.clear();
   }
 
   /**