c-next 0.1.0

package/src/project/FileDiscovery.ts

@@ -0,0 +1,236 @@
+/**
+ * File Discovery
+ * Scans directories for source files
+ */
+
+import { readdirSync, statSync, existsSync } from "fs";
+import { join, extname, resolve } from "path";
+
+/**
+ * File types supported by the transpiler
+ */
+enum EFileType {
+  CNext = "cnext",
+  CHeader = "c_header",
+  CppHeader = "cpp_header",
+  CSource = "c_source",
+  CppSource = "cpp_source",
+  Unknown = "unknown",
+}
+
+/**
+ * Discovered source file
+ */
+interface IDiscoveredFile {
+  /** Absolute path to the file */
+  path: string;
+
+  /** File type */
+  type: EFileType;
+
+  /** File extension */
+  extension: string;
+}
+
+/**
+ * Options for file discovery
+ */
+interface IDiscoveryOptions {
+  /** File extensions to include (default: all supported) */
+  extensions?: string[];
+
+  /** Whether to recurse into subdirectories */
+  recursive?: boolean;
+
+  /** Patterns to exclude */
+  excludePatterns?: RegExp[];
+}
+
+/**
+ * Default extensions for each file type
+ */
+const EXTENSION_MAP: Record<string, EFileType> = {
+  ".cnx": EFileType.CNext,
+  ".cnext": EFileType.CNext,
+  ".h": EFileType.CHeader,
+  ".hpp": EFileType.CppHeader,
+  ".hxx": EFileType.CppHeader,
+  ".hh": EFileType.CppHeader,
+  ".c": EFileType.CSource,
+  ".cpp": EFileType.CppSource,
+  ".cxx": EFileType.CppSource,
+  ".cc": EFileType.CppSource,
+};
+
+/**
+ * Discovers source files in directories
+ */
+class FileDiscovery {
+  /**
+   * Discover files in the given directories
+   */
+  static discover(
+    directories: string[],
+    options: IDiscoveryOptions = {},
+  ): IDiscoveredFile[] {
+    const files: IDiscoveredFile[] = [];
+    const recursive = options.recursive ?? true;
+    const excludePatterns = options.excludePatterns ?? [
+      /node_modules/,
+      /\.git/,
+      /\.build/,
+      /\.pio/,
+    ];
+
+    for (const dir of directories) {
+      const resolvedDir = resolve(dir);
+
+      if (!existsSync(resolvedDir)) {
+        console.warn(`Warning: Directory not found: ${dir}`);
+        continue;
+      }
+
+      this.scanDirectory(
+        resolvedDir,
+        files,
+        recursive,
+        options.extensions,
+        excludePatterns,
+      );
+    }
+
+    return files;
+  }
+
+  /**
+   * Discover a single file
+   */
+  static discoverFile(filePath: string): IDiscoveredFile | null {
+    const resolvedPath = resolve(filePath);
+
+    if (!existsSync(resolvedPath)) {
+      return null;
+    }
+
+    const ext = extname(resolvedPath).toLowerCase();
+    const type = EXTENSION_MAP[ext] ?? EFileType.Unknown;
+
+    return {
+      path: resolvedPath,
+      type,
+      extension: ext,
+    };
+  }
+
+  /**
+   * Discover multiple specific files
+   */
+  static discoverFiles(filePaths: string[]): IDiscoveredFile[] {
+    const files: IDiscoveredFile[] = [];
+
+    for (const filePath of filePaths) {
+      const file = this.discoverFile(filePath);
+      if (file) {
+        files.push(file);
+      } else {
+        console.warn(`Warning: File not found: ${filePath}`);
+      }
+    }
+
+    return files;
+  }
+
+  /**
+   * Filter discovered files by type
+   */
+  static filterByType(
+    files: IDiscoveredFile[],
+    type: EFileType,
+  ): IDiscoveredFile[] {
+    return files.filter((f) => f.type === type);
+  }
+
+  /**
+   * Get C-Next files from a list
+   */
+  static getCNextFiles(files: IDiscoveredFile[]): IDiscoveredFile[] {
+    return this.filterByType(files, EFileType.CNext);
+  }
+
+  /**
+   * Get C/C++ header files from a list
+   */
+  static getHeaderFiles(files: IDiscoveredFile[]): IDiscoveredFile[] {
+    return files.filter(
+      (f) => f.type === EFileType.CHeader || f.type === EFileType.CppHeader,
+    );
+  }
+
+  /**
+   * Scan a directory for source files
+   */
+  private static scanDirectory(
+    dir: string,
+    files: IDiscoveredFile[],
+    recursive: boolean,
+    extensions: string[] | undefined,
+    excludePatterns: RegExp[],
+  ): void {
+    let entries: string[];
+
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      console.warn(`Warning: Cannot read directory: ${dir}`);
+      return;
+    }
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+
+      // Check exclude patterns
+      if (excludePatterns.some((pattern) => pattern.test(fullPath))) {
+        continue;
+      }
+
+      let stats;
+      try {
+        stats = statSync(fullPath);
+      } catch {
+        continue;
+      }
+
+      if (stats.isDirectory()) {
+        if (recursive) {
+          this.scanDirectory(
+            fullPath,
+            files,
+            recursive,
+            extensions,
+            excludePatterns,
+          );
+        }
+      } else if (stats.isFile()) {
+        const ext = extname(fullPath).toLowerCase();
+
+        // Check extension filter
+        if (extensions && !extensions.includes(ext)) {
+          continue;
+        }
+
+        const type = EXTENSION_MAP[ext];
+        if (type) {
+          files.push({
+            path: fullPath,
+            type,
+            extension: ext,
+          });
+        }
+      }
+    }
+  }
+}
+
+export default FileDiscovery;
+export { EFileType };
+export type { IDiscoveredFile, IDiscoveryOptions };

package/src/project/Project.ts

@@ -0,0 +1,425 @@
+/**
+ * Project
+ * Coordinates multi-file compilation with cross-language symbol resolution
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { CharStream, CommonTokenStream } from "antlr4ng";
+import { join, basename, relative, dirname } from "path";
+
+import { CNextLexer } from "../parser/grammar/CNextLexer";
+import { CNextParser } from "../parser/grammar/CNextParser";
+import { CLexer } from "../parser/c/grammar/CLexer";
+import { CParser } from "../parser/c/grammar/CParser";
+import { CPP14Lexer } from "../parser/cpp/grammar/CPP14Lexer";
+import { CPP14Parser } from "../parser/cpp/grammar/CPP14Parser";
+
+import CodeGenerator from "../codegen/CodeGenerator";
+import HeaderGenerator from "../codegen/HeaderGenerator";
+import SymbolTable from "../symbols/SymbolTable";
+import CNextSymbolCollector from "../symbols/CNextSymbolCollector";
+import CSymbolCollector from "../symbols/CSymbolCollector";
+import CppSymbolCollector from "../symbols/CppSymbolCollector";
+import Preprocessor from "../preprocessor/Preprocessor";
+
+import IProjectConfig, { IProjectResult } from "./types/IProjectConfig";
+import FileDiscovery, { EFileType, IDiscoveredFile } from "./FileDiscovery";
+
+/**
+ * Manages multi-file C-Next projects
+ */
+class Project {
+  private config: IProjectConfig;
+
+  private symbolTable: SymbolTable;
+
+  private preprocessor: Preprocessor;
+
+  private codeGenerator: CodeGenerator;
+
+  private headerGenerator: HeaderGenerator;
+
+  constructor(config: IProjectConfig) {
+    this.config = {
+      extensions: [".cnx", ".cnext"],
+      generateHeaders: true,
+      preprocess: true,
+      ...config,
+    };
+
+    this.symbolTable = new SymbolTable();
+    this.preprocessor = new Preprocessor();
+    this.codeGenerator = new CodeGenerator();
+    this.headerGenerator = new HeaderGenerator();
+  }
+
+  /**
+   * Compile the project
+   */
+  async compile(): Promise<IProjectResult> {
+    const result: IProjectResult = {
+      success: true,
+      filesProcessed: 0,
+      symbolsCollected: 0,
+      conflicts: [],
+      errors: [],
+      warnings: [],
+      outputFiles: [],
+    };
+
+    try {
+      // Discover files
+      const files = this.discoverFiles();
+
+      if (files.length === 0) {
+        result.warnings.push("No source files found");
+        return result;
+      }
+
+      // Ensure output directory exists
+      if (!existsSync(this.config.outDir)) {
+        mkdirSync(this.config.outDir, { recursive: true });
+      }
+
+      // Phase 1: Collect symbols from all C/C++ headers
+      const headerFiles = FileDiscovery.getHeaderFiles(files);
+      for (const file of headerFiles) {
+        try {
+          await this.collectHeaderSymbols(file, result);
+          result.filesProcessed++;
+        } catch (err) {
+          result.errors.push(`Failed to process ${file.path}: ${err}`);
+        }
+      }
+
+      // Phase 2: Collect symbols from C-Next files
+      const cnextFiles = FileDiscovery.getCNextFiles(files);
+      for (const file of cnextFiles) {
+        try {
+          this.collectCNextSymbols(file, result);
+          result.filesProcessed++;
+        } catch (err) {
+          result.errors.push(`Failed to process ${file.path}: ${err}`);
+        }
+      }
+
+      // Phase 3: Check for conflicts
+      const conflicts = this.symbolTable.getConflicts();
+      for (const conflict of conflicts) {
+        result.conflicts.push(conflict.message);
+        if (conflict.severity === "error") {
+          result.success = false;
+        }
+      }
+
+      // If there are errors, stop here
+      if (!result.success) {
+        result.errors.push(
+          "Symbol conflicts detected - cannot proceed with code generation",
+        );
+        return result;
+      }
+
+      // Phase 4: Generate C code for each C-Next file
+      for (const file of cnextFiles) {
+        try {
+          const outputFile = this.generateCode(file);
+          result.outputFiles.push(outputFile);
+        } catch (err) {
+          result.errors.push(
+            `Failed to generate code for ${file.path}: ${err}`,
+          );
+          result.success = false;
+        }
+      }
+
+      // Phase 5: Generate headers if enabled
+      if (this.config.generateHeaders && result.success) {
+        for (const file of cnextFiles) {
+          try {
+            const headerFile = this.generateHeader(file);
+            if (headerFile) {
+              result.outputFiles.push(headerFile);
+            }
+          } catch (err) {
+            result.warnings.push(
+              `Failed to generate header for ${file.path}: ${err}`,
+            );
+          }
+        }
+      }
+
+      result.symbolsCollected = this.symbolTable.size;
+    } catch (err) {
+      result.errors.push(`Project compilation failed: ${err}`);
+      result.success = false;
+    }
+
+    return result;
+  }
+
+  /**
+   * Discover all project files
+   */
+  private discoverFiles(): IDiscoveredFile[] {
+    // If specific files are provided, use those
+    if (this.config.files && this.config.files.length > 0) {
+      return FileDiscovery.discoverFiles(this.config.files);
+    }
+
+    // Otherwise, scan directories
+    const allDirs = [...this.config.srcDirs, ...this.config.includeDirs];
+    return FileDiscovery.discover(allDirs, {
+      extensions: this.config.extensions,
+      recursive: true,
+    });
+  }
+
+  /**
+   * Collect symbols from a C/C++ header file
+   */
+  private async collectHeaderSymbols(
+    file: IDiscoveredFile,
+    result: IProjectResult,
+  ): Promise<void> {
+    let content: string;
+
+    // Preprocess if enabled
+    if (this.config.preprocess && this.preprocessor.isAvailable()) {
+      const preprocessResult = await this.preprocessor.preprocess(file.path, {
+        includePaths: this.config.includeDirs,
+        defines: this.config.defines,
+        keepLineDirectives: false,
+      });
+
+      if (!preprocessResult.success) {
+        result.warnings.push(
+          `Preprocessor warning for ${file.path}: ${preprocessResult.error}`,
+        );
+        // Fall back to raw content
+        content = readFileSync(file.path, "utf-8");
+      } else {
+        content = preprocessResult.content;
+      }
+    } else {
+      content = readFileSync(file.path, "utf-8");
+    }
+
+    // Parse based on file type
+    if (file.type === EFileType.CHeader) {
+      this.parseCHeader(content, file.path);
+    } else if (file.type === EFileType.CppHeader) {
+      this.parseCppHeader(content, file.path);
+    }
+  }
+
+  /**
+   * Parse a C header and collect symbols
+   */
+  private parseCHeader(content: string, filePath: string): void {
+    const charStream = CharStream.fromString(content);
+    const lexer = new CLexer(charStream);
+    const tokenStream = new CommonTokenStream(lexer);
+    const parser = new CParser(tokenStream);
+
+    // Suppress error output for header parsing
+    parser.removeErrorListeners();
+
+    try {
+      const tree = parser.compilationUnit();
+      const collector = new CSymbolCollector(filePath, this.symbolTable);
+      const symbols = collector.collect(tree);
+      this.symbolTable.addSymbols(symbols);
+    } catch {
+      // Silently ignore parse errors in headers - they may have unsupported constructs
+    }
+  }
+
+  /**
+   * Parse a C++ header and collect symbols
+   */
+  private parseCppHeader(content: string, filePath: string): void {
+    const charStream = CharStream.fromString(content);
+    const lexer = new CPP14Lexer(charStream);
+    const tokenStream = new CommonTokenStream(lexer);
+    const parser = new CPP14Parser(tokenStream);
+
+    // Suppress error output for header parsing
+    parser.removeErrorListeners();
+
+    try {
+      const tree = parser.translationUnit();
+      const collector = new CppSymbolCollector(filePath);
+      const symbols = collector.collect(tree);
+      this.symbolTable.addSymbols(symbols);
+    } catch {
+      // Silently ignore parse errors in headers
+    }
+  }
+
+  /**
+   * Collect symbols from a C-Next file
+   */
+  private collectCNextSymbols(
+    file: IDiscoveredFile,
+    result: IProjectResult,
+  ): void {
+    const content = readFileSync(file.path, "utf-8");
+    const charStream = CharStream.fromString(content);
+    const lexer = new CNextLexer(charStream);
+    const tokenStream = new CommonTokenStream(lexer);
+    const parser = new CNextParser(tokenStream);
+
+    const errors: string[] = [];
+    parser.removeErrorListeners();
+    parser.addErrorListener({
+      syntaxError(
+        _recognizer,
+        _offendingSymbol,
+        line,
+        charPositionInLine,
+        msg,
+        _e,
+      ) {
+        errors.push(`${file.path}:${line}:${charPositionInLine} - ${msg}`);
+      },
+      reportAmbiguity() {},
+      reportAttemptingFullContext() {},
+      reportContextSensitivity() {},
+    });
+
+    const tree = parser.program();
+
+    if (errors.length > 0) {
+      for (const err of errors) {
+        result.errors.push(err);
+      }
+      return;
+    }
+
+    const collector = new CNextSymbolCollector(file.path);
+    const symbols = collector.collect(tree);
+    this.symbolTable.addSymbols(symbols);
+  }
+
+  /**
+   * Get output path for a file, preserving directory structure if from srcDirs
+   *
+   * @param file - The discovered file
+   * @returns Output path for the generated C file
+   */
+  private getOutputPath(file: IDiscoveredFile): string {
+    const outputName = basename(file.path).replace(/\.cnx$|\.cnext$/, ".c");
+
+    // If file is in a subdirectory of srcDir, preserve structure
+    for (const srcDir of this.config.srcDirs) {
+      const relativePath = relative(srcDir, file.path);
+      if (!relativePath.startsWith("..")) {
+        // File is under srcDir - preserve directory structure
+        const outputRelative = relativePath.replace(/\.cnx$|\.cnext$/, ".c");
+        const outputPath = join(this.config.outDir, outputRelative);
+
+        // Ensure output directory exists
+        const outputDir = dirname(outputPath);
+        if (!existsSync(outputDir)) {
+          mkdirSync(outputDir, { recursive: true });
+        }
+
+        return outputPath;
+      }
+    }
+
+    // Fallback: flat output (for files not in srcDirs)
+    return join(this.config.outDir, outputName);
+  }
+
+  /**
+   * Generate C code from a C-Next file
+   */
+  private generateCode(file: IDiscoveredFile): string {
+    const content = readFileSync(file.path, "utf-8");
+    const charStream = CharStream.fromString(content);
+    const lexer = new CNextLexer(charStream);
+    const tokenStream = new CommonTokenStream(lexer);
+    const parser = new CNextParser(tokenStream);
+
+    const tree = parser.program();
+    const code = this.codeGenerator.generate(tree, this.symbolTable);
+
+    // Write output file with directory structure preserved
+    const outputPath = this.getOutputPath(file);
+
+    writeFileSync(outputPath, code, "utf-8");
+
+    return outputPath;
+  }
+
+  /**
+   * Get output path for a header file, preserving directory structure if from srcDirs
+   *
+   * @param file - The discovered file
+   * @returns Output path for the generated header file
+   */
+  private getHeaderOutputPath(file: IDiscoveredFile): string {
+    const headerName = basename(file.path).replace(/\.cnx$|\.cnext$/, ".h");
+
+    // If file is in a subdirectory of srcDir, preserve structure
+    for (const srcDir of this.config.srcDirs) {
+      const relativePath = relative(srcDir, file.path);
+      if (!relativePath.startsWith("..")) {
+        // File is under srcDir - preserve directory structure
+        const outputRelative = relativePath.replace(/\.cnx$|\.cnext$/, ".h");
+        const outputPath = join(this.config.outDir, outputRelative);
+
+        // Ensure output directory exists
+        const outputDir = dirname(outputPath);
+        if (!existsSync(outputDir)) {
+          mkdirSync(outputDir, { recursive: true });
+        }
+
+        return outputPath;
+      }
+    }
+
+    // Fallback: flat output (for files not in srcDirs)
+    return join(this.config.outDir, headerName);
+  }
+
+  /**
+   * Generate header file for a C-Next file
+   */
+  private generateHeader(file: IDiscoveredFile): string | null {
+    const symbols = this.symbolTable.getSymbolsByFile(file.path);
+
+    // Filter to exported symbols only
+    const exportedSymbols = symbols.filter((s) => s.isExported);
+
+    if (exportedSymbols.length === 0) {
+      return null; // No public symbols, no header needed
+    }
+
+    const headerName = basename(file.path).replace(/\.cnx$|\.cnext$/, ".h");
+    const headerPath = this.getHeaderOutputPath(file);
+
+    const headerContent = this.headerGenerator.generate(
+      exportedSymbols,
+      headerName,
+      {
+        exportedOnly: true,
+      },
+    );
+
+    writeFileSync(headerPath, headerContent, "utf-8");
+
+    return headerPath;
+  }
+
+  /**
+   * Get the symbol table (for testing/inspection)
+   */
+  getSymbolTable(): SymbolTable {
+    return this.symbolTable;
+  }
+}
+
+export default Project;

package/src/project/types/IProjectConfig.ts

@@ -0,0 +1,64 @@
+/**
+ * Project Configuration Types
+ */
+
+/**
+ * Configuration for a C-Next project
+ */
+interface IProjectConfig {
+  /** Project name */
+  name?: string;
+
+  /** Source directories to scan for .cnx files */
+  srcDirs: string[];
+
+  /** Include directories for C/C++ headers */
+  includeDirs: string[];
+
+  /** Output directory for generated files */
+  outDir: string;
+
+  /** Specific files to compile (overrides srcDirs) */
+  files?: string[];
+
+  /** File extensions to process (default: ['.cnx']) */
+  extensions?: string[];
+
+  /** Whether to generate header files */
+  generateHeaders?: boolean;
+
+  /** Whether to preprocess C/C++ files */
+  preprocess?: boolean;
+
+  /** Additional preprocessor defines */
+  defines?: Record<string, string | boolean>;
+}
+
+/**
+ * Result of compiling a project
+ */
+interface IProjectResult {
+  /** Whether compilation succeeded */
+  success: boolean;
+
+  /** Number of files processed */
+  filesProcessed: number;
+
+  /** Number of symbols collected */
+  symbolsCollected: number;
+
+  /** Symbol conflicts detected */
+  conflicts: string[];
+
+  /** Errors encountered */
+  errors: string[];
+
+  /** Warnings */
+  warnings: string[];
+
+  /** Generated output files */
+  outputFiles: string[];
+}
+
+export default IProjectConfig;
+export type { IProjectResult };