c-next 0.1.0

package/src/preprocessor/Preprocessor.ts

@@ -0,0 +1,301 @@
+/**
+ * C/C++ Preprocessor
+ * Runs the system preprocessor on C/C++ files before parsing
+ */
+
+import { exec } from "child_process";
+import { promisify } from "util";
+import { writeFile, mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join, basename, dirname } from "path";
+import IToolchain from "./types/IToolchain";
+import IPreprocessResult, { ISourceMapping } from "./types/IPreprocessResult";
+import ToolchainDetector from "./ToolchainDetector";
+
+const execAsync = promisify(exec);
+
+/**
+ * Preprocessor options
+ */
+interface IPreprocessOptions {
+  /** Additional include paths */
+  includePaths?: string[];
+
+  /** Preprocessor defines (-D flags) */
+  defines?: Record<string, string | boolean>;
+
+  /** Specific toolchain to use (auto-detect if not specified) */
+  toolchain?: IToolchain;
+
+  /** Keep #line directives for source mapping (default: true) */
+  keepLineDirectives?: boolean;
+}
+
+/**
+ * Handles preprocessing of C/C++ files
+ */
+class Preprocessor {
+  private toolchain: IToolchain | null;
+
+  private defaultIncludePaths: string[] = [];
+
+  constructor(toolchain?: IToolchain) {
+    this.toolchain = toolchain ?? ToolchainDetector.detect();
+
+    if (this.toolchain) {
+      this.defaultIncludePaths = ToolchainDetector.getDefaultIncludePaths(
+        this.toolchain,
+      );
+    }
+  }
+
+  /**
+   * Check if a toolchain is available
+   */
+  isAvailable(): boolean {
+    return this.toolchain !== null;
+  }
+
+  /**
+   * Get the current toolchain
+   */
+  getToolchain(): IToolchain | null {
+    return this.toolchain;
+  }
+
+  /**
+   * Preprocess a C/C++ file
+   */
+  async preprocess(
+    filePath: string,
+    options: IPreprocessOptions = {},
+  ): Promise<IPreprocessResult> {
+    if (!this.toolchain) {
+      return {
+        content: "",
+        sourceMappings: [],
+        success: false,
+        error:
+          "No C/C++ toolchain available. Install gcc, clang, or arm-none-eabi-gcc.",
+        originalFile: filePath,
+      };
+    }
+
+    try {
+      const content = await this.runPreprocessor(filePath, options);
+      const sourceMappings =
+        options.keepLineDirectives !== false
+          ? this.parseLineDirectives(content)
+          : [];
+
+      // Optionally strip #line directives for cleaner output
+      const cleanContent =
+        options.keepLineDirectives === false
+          ? this.stripLineDirectives(content)
+          : content;
+
+      return {
+        content: cleanContent,
+        sourceMappings,
+        success: true,
+        originalFile: filePath,
+        toolchain: this.toolchain.name,
+      };
+    } catch (error) {
+      return {
+        content: "",
+        sourceMappings: [],
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        originalFile: filePath,
+        toolchain: this.toolchain.name,
+      };
+    }
+  }
+
+  /**
+   * Preprocess content from a string (creates temp file)
+   */
+  async preprocessString(
+    content: string,
+    filename: string,
+    options: IPreprocessOptions = {},
+  ): Promise<IPreprocessResult> {
+    let tempDir: string | null = null;
+
+    try {
+      // Create temp directory
+      tempDir = await mkdtemp(join(tmpdir(), "cnext-"));
+      const tempFile = join(tempDir, basename(filename));
+
+      // Write content to temp file
+      await writeFile(tempFile, content, "utf-8");
+
+      // Preprocess
+      const result = await this.preprocess(tempFile, options);
+
+      // Update the original file reference
+      result.originalFile = filename;
+
+      return result;
+    } finally {
+      // Clean up temp directory
+      if (tempDir) {
+        try {
+          await rm(tempDir, { recursive: true });
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+    }
+  }
+
+  /**
+   * Run the preprocessor command
+   */
+  private async runPreprocessor(
+    filePath: string,
+    options: IPreprocessOptions,
+  ): Promise<string> {
+    const toolchain = options.toolchain ?? this.toolchain!;
+    const args: string[] = [
+      "-E", // Preprocess only
+      "-P", // Don't generate linemarkers (we'll add them back if needed)
+    ];
+
+    // If we want line directives, don't use -P
+    if (options.keepLineDirectives !== false) {
+      args.pop(); // Remove -P
+    }
+
+    // Add include paths
+    const includePaths = [
+      ...this.defaultIncludePaths,
+      ...(options.includePaths ?? []),
+      dirname(filePath), // Include the file's directory
+    ];
+
+    for (const path of includePaths) {
+      args.push(`-I${path}`);
+    }
+
+    // Add defines
+    if (options.defines) {
+      for (const [key, value] of Object.entries(options.defines)) {
+        if (value === true) {
+          args.push(`-D${key}`);
+        } else if (value !== false) {
+          args.push(`-D${key}=${value}`);
+        }
+      }
+    }
+
+    // Add the input file
+    args.push(filePath);
+
+    // Build command
+    const command = `${toolchain.cpp} ${args.join(" ")}`;
+
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        maxBuffer: 50 * 1024 * 1024, // 50MB buffer for large headers
+      });
+
+      // Log warnings to console but don't fail
+      if (stderr && stderr.trim()) {
+        console.warn(`Preprocessor warnings for ${filePath}:\n${stderr}`);
+      }
+
+      return stdout;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } catch (error: any) {
+      // Include stderr in error message for better debugging
+      const stderr = error.stderr ?? "";
+      throw new Error(
+        `Preprocessor failed for ${filePath}:\n${error.message}\n${stderr}`,
+      );
+    }
+  }
+
+  /**
+   * Parse #line directives to build source mappings
+   * Format: # linenum "filename" [flags]
+   */
+  private parseLineDirectives(content: string): ISourceMapping[] {
+    const mappings: ISourceMapping[] = [];
+    const lines = content.split("\n");
+
+    let currentFile = "";
+    let currentOriginalLine = 1;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // Match # linenum "filename" or #line linenum "filename"
+      const match = line.match(
+        /^#\s*(?:line\s+)?(\d+)\s+"([^"]+)"(?:\s+\d+)*\s*$/,
+      );
+
+      if (match) {
+        currentOriginalLine = parseInt(match[1], 10);
+        currentFile = match[2];
+      } else if (currentFile) {
+        mappings.push({
+          preprocessedLine: i + 1,
+          originalFile: currentFile,
+          originalLine: currentOriginalLine,
+        });
+        currentOriginalLine++;
+      }
+    }
+
+    return mappings;
+  }
+
+  /**
+   * Strip #line directives from preprocessed output
+   */
+  private stripLineDirectives(content: string): string {
+    return content
+      .split("\n")
+      .filter((line) => !line.match(/^#\s*(?:line\s+)?\d+\s+"/))
+      .join("\n");
+  }
+
+  /**
+   * Map a line in preprocessed output back to original source
+   */
+  static mapToOriginal(
+    mappings: ISourceMapping[],
+    preprocessedLine: number,
+  ): { file: string; line: number } | null {
+    // Find the mapping for this line or the closest previous one
+    let bestMapping: ISourceMapping | null = null;
+
+    for (const mapping of mappings) {
+      if (mapping.preprocessedLine <= preprocessedLine) {
+        if (
+          !bestMapping ||
+          mapping.preprocessedLine > bestMapping.preprocessedLine
+        ) {
+          bestMapping = mapping;
+        }
+      }
+    }
+
+    if (!bestMapping) {
+      return null;
+    }
+
+    // Calculate the offset from the mapping
+    const offset = preprocessedLine - bestMapping.preprocessedLine;
+
+    return {
+      file: bestMapping.originalFile,
+      line: bestMapping.originalLine + offset,
+    };
+  }
+}
+
+export default Preprocessor;
+export type { IPreprocessOptions };

package/src/preprocessor/ToolchainDetector.ts

@@ -0,0 +1,225 @@
+/**
+ * Toolchain Detector
+ * Finds available C/C++ compilers on the system
+ */
+
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+import IToolchain from "./types/IToolchain";
+
+/**
+ * Detects available C/C++ toolchains
+ */
+class ToolchainDetector {
+  /**
+   * Detect the best available toolchain
+   * Priority: ARM cross-compiler > clang > gcc
+   */
+  static detect(): IToolchain | null {
+    // Try ARM cross-compiler first (for embedded)
+    const arm = this.detectArmToolchain();
+    if (arm) return arm;
+
+    // Try clang
+    const clang = this.detectClang();
+    if (clang) return clang;
+
+    // Try gcc
+    const gcc = this.detectGcc();
+    if (gcc) return gcc;
+
+    return null;
+  }
+
+  /**
+   * Detect all available toolchains
+   */
+  static detectAll(): IToolchain[] {
+    const toolchains: IToolchain[] = [];
+
+    const arm = this.detectArmToolchain();
+    if (arm) toolchains.push(arm);
+
+    const clang = this.detectClang();
+    if (clang) toolchains.push(clang);
+
+    const gcc = this.detectGcc();
+    if (gcc) toolchains.push(gcc);
+
+    return toolchains;
+  }
+
+  /**
+   * Detect ARM cross-compiler (arm-none-eabi-gcc)
+   */
+  private static detectArmToolchain(): IToolchain | null {
+    const cc = this.findExecutable("arm-none-eabi-gcc");
+    if (!cc) return null;
+
+    const cxx = this.findExecutable("arm-none-eabi-g++") ?? cc;
+    const version = this.getVersion(cc);
+
+    return {
+      name: "arm-none-eabi-gcc",
+      cc,
+      cxx,
+      cpp: cc, // Use cc with -E flag
+      version,
+      isCrossCompiler: true,
+      target: "arm-none-eabi",
+    };
+  }
+
+  /**
+   * Detect clang
+   */
+  private static detectClang(): IToolchain | null {
+    const cc = this.findExecutable("clang");
+    if (!cc) return null;
+
+    const cxx = this.findExecutable("clang++") ?? cc;
+    const version = this.getVersion(cc);
+
+    return {
+      name: "clang",
+      cc,
+      cxx,
+      cpp: cc,
+      version,
+      isCrossCompiler: false,
+    };
+  }
+
+  /**
+   * Detect GCC
+   */
+  private static detectGcc(): IToolchain | null {
+    const cc = this.findExecutable("gcc");
+    if (!cc) return null;
+
+    const cxx = this.findExecutable("g++") ?? cc;
+    const version = this.getVersion(cc);
+
+    return {
+      name: "gcc",
+      cc,
+      cxx,
+      cpp: cc,
+      version,
+      isCrossCompiler: false,
+    };
+  }
+
+  /**
+   * Find an executable in PATH
+   */
+  private static findExecutable(name: string): string | null {
+    try {
+      const result = execSync(`which ${name}`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+      }).trim();
+
+      if (result && existsSync(result)) {
+        return result;
+      }
+    } catch {
+      // Not found
+    }
+
+    return null;
+  }
+
+  /**
+   * Get compiler version string
+   */
+  private static getVersion(compiler: string): string | undefined {
+    try {
+      const result = execSync(`${compiler} --version`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+
+      // Extract first line which usually has version info
+      const firstLine = result.split("\n")[0];
+      return firstLine?.trim();
+    } catch {
+      return undefined;
+    }
+  }
+
+  /**
+   * Get default include paths for a toolchain
+   */
+  static getDefaultIncludePaths(toolchain: IToolchain): string[] {
+    try {
+      // Ask the compiler for its default include paths
+      const result = execSync(`echo | ${toolchain.cc} -E -Wp,-v - 2>&1`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+
+      const paths: string[] = [];
+      let inIncludeSection = false;
+
+      for (const line of result.split("\n")) {
+        if (line.includes("#include <...> search starts here:")) {
+          inIncludeSection = true;
+          continue;
+        }
+        if (line.includes("End of search list.")) {
+          break;
+        }
+        if (inIncludeSection && line.trim()) {
+          paths.push(line.trim());
+        }
+      }
+
+      return paths;
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Parse PlatformIO environment for include paths
+   * Looks for platformio.ini in project root
+   */
+  static getPlatformIOIncludePaths(projectRoot: string): string[] {
+    const paths: string[] = [];
+    const pioIniPath = join(projectRoot, "platformio.ini");
+
+    if (!existsSync(pioIniPath)) {
+      return paths;
+    }
+
+    try {
+      // Use pio to get the include paths
+      const result = execSync("pio project config --json-output", {
+        cwd: projectRoot,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+
+      const config = JSON.parse(result);
+
+      // Extract include directories from build flags
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      for (const env of Object.values(config) as any[]) {
+        const buildFlags = env.build_flags ?? [];
+        for (const flag of buildFlags) {
+          if (flag.startsWith("-I")) {
+            paths.push(flag.slice(2));
+          }
+        }
+      }
+    } catch {
+      // PlatformIO not available or project not configured
+    }
+
+    return paths;
+  }
+}
+
+export default ToolchainDetector;

package/src/preprocessor/types/IPreprocessResult.ts

@@ -0,0 +1,39 @@
+/**
+ * Source location mapping from preprocessed output back to original file
+ */
+interface ISourceMapping {
+  /** Line number in preprocessed output */
+  preprocessedLine: number;
+
+  /** Original file path */
+  originalFile: string;
+
+  /** Line number in original file */
+  originalLine: number;
+}
+
+/**
+ * Result of preprocessing a C/C++ file
+ */
+interface IPreprocessResult {
+  /** Preprocessed content */
+  content: string;
+
+  /** Source mappings from #line directives */
+  sourceMappings: ISourceMapping[];
+
+  /** Whether preprocessing succeeded */
+  success: boolean;
+
+  /** Error message if failed */
+  error?: string;
+
+  /** Original file that was preprocessed */
+  originalFile: string;
+
+  /** Toolchain used for preprocessing */
+  toolchain?: string;
+}
+
+export default IPreprocessResult;
+export type { ISourceMapping };

package/src/preprocessor/types/IToolchain.ts

@@ -0,0 +1,27 @@
+/**
+ * Represents a detected C/C++ toolchain
+ */
+interface IToolchain {
+  /** Name of the toolchain (e.g., "gcc", "clang", "arm-none-eabi-gcc") */
+  name: string;
+
+  /** Path to the C compiler */
+  cc: string;
+
+  /** Path to the C++ compiler */
+  cxx: string;
+
+  /** Path to the preprocessor (usually same as cc with -E flag) */
+  cpp: string;
+
+  /** Toolchain version string */
+  version?: string;
+
+  /** Whether this is a cross-compiler (e.g., for ARM) */
+  isCrossCompiler: boolean;
+
+  /** Target triple if cross-compiling (e.g., "arm-none-eabi") */
+  target?: string;
+}
+
+export default IToolchain;