c-next 0.1.0

package/src/lib/InputExpansion.ts

@@ -0,0 +1,121 @@
+import { resolve, extname, basename } from "path";
+import { existsSync, statSync, readdirSync } from "fs";
+
+/**
+ * Input expansion for C-Next CLI
+ *
+ * Expands file paths and directories into a list of .cnx files to compile.
+ * Handles recursive directory scanning and file validation.
+ */
+export class InputExpansion {
+  /**
+   * Expand inputs (files or directories) to list of .cnx files
+   *
+   * @param inputs - Array of file paths or directories
+   * @returns Array of .cnx file paths
+   */
+  static expandInputs(inputs: string[]): string[] {
+    const files: string[] = [];
+
+    for (const input of inputs) {
+      const resolvedPath = resolve(input);
+
+      if (!existsSync(resolvedPath)) {
+        throw new Error(`Input not found: ${input}`);
+      }
+
+      const stats = statSync(resolvedPath);
+
+      if (stats.isDirectory()) {
+        // Recursively find .cnx files
+        const cnextFiles = this.findCNextFiles(resolvedPath);
+        files.push(...cnextFiles);
+      } else if (stats.isFile()) {
+        // Validate and add file
+        this.validateFileExtension(resolvedPath);
+        files.push(resolvedPath);
+      }
+    }
+
+    // Remove duplicates
+    return Array.from(new Set(files));
+  }
+
+  /**
+   * Recursively find .cnx files in directory
+   *
+   * @param dir - Directory to scan
+   * @returns Array of .cnx file paths
+   */
+  static findCNextFiles(dir: string): string[] {
+    const files: string[] = [];
+
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = resolve(dir, entry.name);
+
+        // Skip hidden directories and common build/dependency directories
+        if (entry.isDirectory()) {
+          const dirName = entry.name;
+          if (
+            dirName.startsWith(".") ||
+            dirName === "node_modules" ||
+            dirName === "build" ||
+            dirName === ".pio" ||
+            dirName === "dist"
+          ) {
+            continue;
+          }
+
+          // Recursively scan subdirectory
+          const subFiles = this.findCNextFiles(fullPath);
+          files.push(...subFiles);
+        } else if (entry.isFile()) {
+          const ext = extname(entry.name);
+          if (ext === ".cnx" || ext === ".cnext") {
+            files.push(fullPath);
+          }
+        }
+      }
+    } catch (error) {
+      throw new Error(`Failed to scan directory ${dir}: ${error}`);
+    }
+
+    return files;
+  }
+
+  /**
+   * Validate file extension
+   *
+   * Accepts: .cnx, .cnext
+   * Rejects: .c, .cpp, .cc, .cxx, .c++ (implementation files)
+   *
+   * @param path - File path to validate
+   * @throws Error if extension is invalid
+   */
+  static validateFileExtension(path: string): void {
+    const ext = extname(path);
+    const fileName = basename(path);
+
+    // Reject implementation files
+    const rejectedExtensions = [".c", ".cpp", ".cc", ".cxx", ".c++"];
+    if (rejectedExtensions.includes(ext)) {
+      throw new Error(
+        `Cannot process implementation file '${fileName}'. ` +
+          `C-Next only compiles .cnx files. ` +
+          `If you need to include this file, create a header (.h) instead.`,
+      );
+    }
+
+    // Accept C-Next source files
+    const acceptedExtensions = [".cnx", ".cnext"];
+    if (!acceptedExtensions.includes(ext)) {
+      throw new Error(
+        `Invalid file extension '${ext}' for file '${fileName}'. ` +
+          `C-Next only accepts .cnx or .cnext files.`,
+      );
+    }
+  }
+}

package/src/lib/PlatformIODetector.ts

@@ -0,0 +1,162 @@
+/**
+ * PlatformIO Configuration Detector
+ * ADR-049: Auto-detect target platform from platformio.ini
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+
+/**
+ * PlatformIO board to C-Next target mapping
+ * Maps common board names to their Cortex-M core types
+ */
+const BOARD_TO_TARGET: Record<string, string> = {
+  // Teensy boards (NXP i.MX RT)
+  teensy41: "teensy41",
+  teensy40: "teensy40",
+  teensy36: "cortex-m4", // Kinetis K66
+  teensy35: "cortex-m4", // Kinetis K64
+  teensy32: "cortex-m4", // Kinetis MK20
+  teensy31: "cortex-m4", // Kinetis MK20
+  teensylc: "cortex-m0+", // Kinetis KL26
+
+  // STM32 F7 series (Cortex-M7)
+  nucleo_f767zi: "cortex-m7",
+  disco_f769ni: "cortex-m7",
+
+  // STM32 F4 series (Cortex-M4)
+  nucleo_f446re: "cortex-m4",
+  disco_f407vg: "cortex-m4",
+  black_f407ve: "cortex-m4",
+
+  // STM32 F3 series (Cortex-M4)
+  nucleo_f303re: "cortex-m4",
+
+  // STM32 F1 series (Cortex-M3)
+  bluepill_f103c8: "cortex-m3",
+  nucleo_f103rb: "cortex-m3",
+
+  // STM32 F0/L0 series (Cortex-M0)
+  nucleo_f030r8: "cortex-m0",
+  nucleo_l011k4: "cortex-m0+",
+
+  // Arduino boards (AVR)
+  uno: "avr",
+  mega: "avr",
+  nano: "avr",
+  leonardo: "avr",
+
+  // Arduino ARM boards
+  due: "cortex-m3", // SAM3X8E
+  zero: "cortex-m0+", // SAMD21
+  mkrzero: "cortex-m0+", // SAMD21
+
+  // ESP32 (Xtensa - no LDREX/STREX)
+  esp32dev: "esp32",
+  esp32: "esp32",
+
+  // RP2040 (Cortex-M0+)
+  pico: "cortex-m0+",
+  rpipico: "cortex-m0+",
+};
+
+/**
+ * Parse a platformio.ini file and extract configuration
+ */
+function parsePlatformIOConfig(content: string): Record<string, string> {
+  const result: Record<string, string> = {};
+  let currentSection = "";
+
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+
+    // Skip comments and empty lines
+    if (trimmed.startsWith(";") || trimmed.startsWith("#") || !trimmed) {
+      continue;
+    }
+
+    // Section header
+    const sectionMatch = trimmed.match(/^\[([^\]]+)\]$/);
+    if (sectionMatch) {
+      currentSection = sectionMatch[1];
+      continue;
+    }
+
+    // Key = value pair
+    const kvMatch = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
+    if (kvMatch && currentSection) {
+      const key = `${currentSection}.${kvMatch[1]}`;
+      result[key] = kvMatch[2].trim();
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Search for platformio.ini starting from a directory and going up
+ */
+function findPlatformIOConfig(startDir: string): string | null {
+  let dir = resolve(startDir);
+
+  while (dir !== dirname(dir)) {
+    const configPath = resolve(dir, "platformio.ini");
+    if (existsSync(configPath)) {
+      return configPath;
+    }
+    dir = dirname(dir);
+  }
+
+  return null;
+}
+
+/**
+ * Detect target platform from platformio.ini
+ *
+ * @param startDir - Directory to start searching from (usually input file's directory)
+ * @returns Target name if detected, undefined otherwise
+ *
+ * @example
+ * ```typescript
+ * const target = detectPlatformIOTarget('/home/user/project/src');
+ * // Returns "teensy41" if platformio.ini has board = teensy41
+ * ```
+ */
+export function detectPlatformIOTarget(startDir: string): string | undefined {
+  const configPath = findPlatformIOConfig(startDir);
+  if (!configPath) {
+    return undefined;
+  }
+
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const config = parsePlatformIOConfig(content);
+
+    // Check for board in [env] or [env:*] sections
+    // Priority: [env:default] > [env] > first [env:*]
+    const envDefault = config["env:default.board"];
+    const env = config["env.board"];
+
+    // Find first env:* board if no default
+    let firstEnvBoard: string | undefined;
+    for (const key of Object.keys(config)) {
+      if (key.startsWith("env:") && key.endsWith(".board")) {
+        firstEnvBoard = config[key];
+        break;
+      }
+    }
+
+    const board = envDefault || env || firstEnvBoard;
+    if (!board) {
+      return undefined;
+    }
+
+    // Map board to target
+    const target = BOARD_TO_TARGET[board.toLowerCase()];
+    return target;
+  } catch {
+    return undefined;
+  }
+}
+
+export default detectPlatformIOTarget;

package/src/lib/transpiler.ts

@@ -0,0 +1,439 @@
+/**
+ * C-Next Transpiler Library
+ * Core transpilation API for use by CLI and VS Code extension
+ */
+
+import { CharStream, CommonTokenStream } from "antlr4ng";
+import { CNextLexer } from "../parser/grammar/CNextLexer";
+import { CNextParser } from "../parser/grammar/CNextParser";
+import CodeGenerator from "../codegen/CodeGenerator";
+import CommentExtractor from "../codegen/CommentExtractor";
+import CNextSymbolCollector from "../symbols/CNextSymbolCollector";
+import ESymbolKind from "../types/ESymbolKind";
+import InitializationAnalyzer from "../analysis/InitializationAnalyzer";
+import FunctionCallAnalyzer from "../analysis/FunctionCallAnalyzer";
+import NullCheckAnalyzer from "../analysis/NullCheckAnalyzer";
+import DivisionByZeroAnalyzer from "../analysis/DivisionByZeroAnalyzer";
+import {
+  ITranspileResult,
+  ITranspileError,
+  ISymbolInfo,
+  IParseWithSymbolsResult,
+  TSymbolKind,
+} from "./types/ITranspileResult";
+
+export {
+  ITranspileResult,
+  ITranspileError,
+  ISymbolInfo,
+  IParseWithSymbolsResult,
+  TSymbolKind,
+};
+
+/**
+ * Options for transpilation
+ */
+export interface ITranspileOptions {
+  /** Parse only, don't generate code */
+  parseOnly?: boolean;
+  /** ADR-044: When true, generate panic-on-overflow helpers instead of clamp helpers */
+  debugMode?: boolean;
+  /** ADR-049: Target platform for atomic code generation (e.g., "teensy41", "cortex-m0") */
+  target?: string;
+}
+
+/**
+ * Transpile C-Next source code to C
+ *
+ * @param source - C-Next source code string
+ * @param options - Optional transpilation options
+ * @returns Transpilation result with code or errors
+ *
+ * @example
+ * ```typescript
+ * import { transpile } from './lib/transpiler';
+ *
+ * const result = transpile('u32 x <- 5;');
+ * if (result.success) {
+ *     console.log(result.code);
+ * } else {
+ *     result.errors.forEach(e => console.error(`${e.line}:${e.column} ${e.message}`));
+ * }
+ * ```
+ */
+export function transpile(
+  source: string,
+  options: ITranspileOptions = {},
+): ITranspileResult {
+  const { parseOnly = false, debugMode = false, target } = options;
+  const errors: ITranspileError[] = [];
+
+  // Create the lexer and parser
+  const charStream = CharStream.fromString(source);
+  const lexer = new CNextLexer(charStream);
+  const tokenStream = new CommonTokenStream(lexer);
+  const parser = new CNextParser(tokenStream);
+
+  // Custom error listener to collect errors with line/column info
+  lexer.removeErrorListeners();
+  parser.removeErrorListeners();
+
+  const errorListener = {
+    syntaxError(
+      _recognizer: unknown,
+      _offendingSymbol: unknown,
+      line: number,
+      charPositionInLine: number,
+      msg: string,
+      _e: unknown,
+    ): void {
+      errors.push({
+        line,
+        column: charPositionInLine,
+        message: msg,
+        severity: "error",
+      });
+    },
+    reportAmbiguity(): void {},
+    reportAttemptingFullContext(): void {},
+    reportContextSensitivity(): void {},
+  };
+
+  lexer.addErrorListener(errorListener);
+  parser.addErrorListener(errorListener);
+
+  // Parse the input
+  let tree;
+  try {
+    tree = parser.program();
+  } catch (e) {
+    // Handle catastrophic parse failures
+    const errorMessage = e instanceof Error ? e.message : String(e);
+    errors.push({
+      line: 1,
+      column: 0,
+      message: `Parse failed: ${errorMessage}`,
+      severity: "error",
+    });
+    return {
+      success: false,
+      code: "",
+      errors,
+      declarationCount: 0,
+    };
+  }
+
+  const declarationCount = tree.declaration().length;
+
+  // If there are parse errors or parseOnly mode, return early
+  if (errors.length > 0) {
+    return {
+      success: false,
+      code: "",
+      errors,
+      declarationCount,
+    };
+  }
+
+  if (parseOnly) {
+    return {
+      success: true,
+      code: "",
+      errors: [],
+      declarationCount,
+    };
+  }
+
+  // Run initialization analysis (Rust-style use-before-init detection)
+  const initAnalyzer = new InitializationAnalyzer();
+  const initErrors = initAnalyzer.analyze(tree);
+
+  // Convert initialization errors to transpile errors
+  for (const initError of initErrors) {
+    errors.push({
+      line: initError.line,
+      column: initError.column,
+      message: `error[${initError.code}]: ${initError.message}`,
+      severity: "error",
+    });
+  }
+
+  // If there are initialization errors, fail compilation
+  if (errors.length > 0) {
+    return {
+      success: false,
+      code: "",
+      errors,
+      declarationCount,
+    };
+  }
+
+  // Run function call analysis (ADR-030: define-before-use)
+  const funcAnalyzer = new FunctionCallAnalyzer();
+  const funcErrors = funcAnalyzer.analyze(tree);
+
+  // Convert function call errors to transpile errors
+  for (const funcError of funcErrors) {
+    errors.push({
+      line: funcError.line,
+      column: funcError.column,
+      message: `error[${funcError.code}]: ${funcError.message}`,
+      severity: "error",
+    });
+  }
+
+  // If there are function call errors, fail compilation
+  if (errors.length > 0) {
+    return {
+      success: false,
+      code: "",
+      errors,
+      declarationCount,
+    };
+  }
+
+  // Run NULL check analysis (ADR-047: C library interop)
+  const nullAnalyzer = new NullCheckAnalyzer();
+  const nullErrors = nullAnalyzer.analyze(tree);
+
+  // Convert NULL check errors to transpile errors
+  for (const nullError of nullErrors) {
+    errors.push({
+      line: nullError.line,
+      column: nullError.column,
+      message: `error[${nullError.code}]: ${nullError.message}`,
+      severity: "error",
+    });
+  }
+
+  // If there are NULL check errors, fail compilation
+  if (errors.length > 0) {
+    return {
+      success: false,
+      code: "",
+      errors,
+      declarationCount,
+    };
+  }
+
+  // Run division by zero analysis (ADR-051: compile-time detection)
+  const divZeroAnalyzer = new DivisionByZeroAnalyzer();
+  const divZeroErrors = divZeroAnalyzer.analyze(tree);
+
+  // Convert division by zero errors to transpile errors
+  for (const divZeroError of divZeroErrors) {
+    errors.push({
+      line: divZeroError.line,
+      column: divZeroError.column,
+      message: `error[${divZeroError.code}]: ${divZeroError.message}`,
+      severity: "error",
+    });
+  }
+
+  // If there are division by zero errors, fail compilation
+  if (errors.length > 0) {
+    return {
+      success: false,
+      code: "",
+      errors,
+      declarationCount,
+    };
+  }
+
+  // Validate comments (MISRA C:2012 Rules 3.1, 3.2) - ADR-043
+  const commentExtractor = new CommentExtractor(tokenStream);
+  const commentErrors = commentExtractor.validate();
+
+  for (const commentError of commentErrors) {
+    errors.push({
+      line: commentError.line,
+      column: commentError.column,
+      message: `error[MISRA-${commentError.rule}]: ${commentError.message}`,
+      severity: "error",
+    });
+  }
+
+  // If there are comment validation errors, fail compilation
+  if (errors.length > 0) {
+    return {
+      success: false,
+      code: "",
+      errors,
+      declarationCount,
+    };
+  }
+
+  // Generate C code
+  try {
+    const generator = new CodeGenerator();
+    const code = generator.generate(tree, undefined, tokenStream, {
+      debugMode,
+      target,
+    });
+
+    return {
+      success: true,
+      code,
+      errors: [],
+      declarationCount,
+    };
+  } catch (e) {
+    // Handle code generation errors
+    const errorMessage = e instanceof Error ? e.message : String(e);
+    errors.push({
+      line: 1,
+      column: 0,
+      message: `Code generation failed: ${errorMessage}`,
+      severity: "error",
+    });
+    return {
+      success: false,
+      code: "",
+      errors,
+      declarationCount,
+    };
+  }
+}
+
+/**
+ * Parse C-Next source and return parse result without generating code
+ * Convenience wrapper around transpile with parseOnly: true
+ */
+export function parse(source: string): ITranspileResult {
+  return transpile(source, { parseOnly: true });
+}
+
+/**
+ * Map ESymbolKind to TSymbolKind for extension use
+ */
+function mapSymbolKind(kind: ESymbolKind): TSymbolKind {
+  switch (kind) {
+    case ESymbolKind.Namespace:
+      return "namespace";
+    case ESymbolKind.Class:
+      return "class";
+    case ESymbolKind.Struct:
+      return "struct";
+    case ESymbolKind.Register:
+      return "register";
+    case ESymbolKind.Function:
+      return "function";
+    case ESymbolKind.Variable:
+      return "variable";
+    case ESymbolKind.RegisterMember:
+      return "registerMember";
+    default:
+      return "variable";
+  }
+}
+
+/**
+ * Extract local name from full qualified name
+ * e.g., "LED_toggle" with parent "LED" -> "toggle"
+ */
+function extractLocalName(fullName: string, parent?: string): string {
+  if (parent && fullName.startsWith(parent + "_")) {
+    return fullName.substring(parent.length + 1);
+  }
+  return fullName;
+}
+
+/**
+ * Parse C-Next source and extract symbols for IDE features
+ *
+ * Unlike transpile(), this function attempts to extract symbols even when
+ * there are parse errors, making it suitable for autocomplete during typing.
+ *
+ * @param source - C-Next source code string
+ * @returns Parse result with symbols
+ *
+ * @example
+ * ```typescript
+ * import { parseWithSymbols } from './lib/transpiler';
+ *
+ * const result = parseWithSymbols(source);
+ * // Find namespace members for autocomplete
+ * const ledMembers = result.symbols.filter(s => s.parent === 'LED');
+ * ```
+ */
+export function parseWithSymbols(source: string): IParseWithSymbolsResult {
+  const errors: ITranspileError[] = [];
+
+  // Create the lexer and parser
+  const charStream = CharStream.fromString(source);
+  const lexer = new CNextLexer(charStream);
+  const tokenStream = new CommonTokenStream(lexer);
+  const parser = new CNextParser(tokenStream);
+
+  // Custom error listener to collect errors
+  lexer.removeErrorListeners();
+  parser.removeErrorListeners();
+
+  const errorListener = {
+    syntaxError(
+      _recognizer: unknown,
+      _offendingSymbol: unknown,
+      line: number,
+      charPositionInLine: number,
+      msg: string,
+      _e: unknown,
+    ): void {
+      errors.push({
+        line,
+        column: charPositionInLine,
+        message: msg,
+        severity: "error",
+      });
+    },
+    reportAmbiguity(): void {},
+    reportAttemptingFullContext(): void {},
+    reportContextSensitivity(): void {},
+  };
+
+  lexer.addErrorListener(errorListener);
+  parser.addErrorListener(errorListener);
+
+  // Parse the input - continue even with errors to get partial symbols
+  let tree;
+  try {
+    tree = parser.program();
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : String(e);
+    errors.push({
+      line: 1,
+      column: 0,
+      message: `Parse failed: ${errorMessage}`,
+      severity: "error",
+    });
+    return {
+      success: false,
+      errors,
+      symbols: [],
+    };
+  }
+
+  // Collect symbols from the parse tree
+  const collector = new CNextSymbolCollector("<source>");
+  const rawSymbols = collector.collect(tree);
+
+  // Transform ISymbol[] to ISymbolInfo[]
+  const symbols: ISymbolInfo[] = rawSymbols.map((sym) => ({
+    name: extractLocalName(sym.name, sym.parent),
+    fullName: sym.name,
+    kind: mapSymbolKind(sym.kind),
+    type: sym.type,
+    parent: sym.parent,
+    signature: sym.signature,
+    accessModifier: sym.accessModifier,
+    line: sym.sourceLine,
+    size: sym.size,
+  }));
+
+  return {
+    success: errors.length === 0,
+    errors,
+    symbols,
+  };
+}
+
+export default transpile;