c-next 0.1.25 → 0.1.26

package/package.json

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

package/src/codegen/CodeGenerator.ts

@@ -255,6 +255,12 @@ export default class CodeGenerator implements IOrchestrator {
   /** ADR-010: Source file path for validating includes */
   private sourcePath: string | null = null;
 
+  /** Issue #349: Include directories for resolving angle-bracket .cnx includes */
+  private includeDirs: string[] = [];
+
+  /** Issue #349: Input directories for calculating relative paths */
+  private inputs: string[] = [];
+
   /** Token stream for comment extraction (ADR-043) */
   private tokenStream: CommonTokenStream | null = null;
 
@@ -1309,6 +1315,10 @@ export default class CodeGenerator implements IOrchestrator {
     // ADR-010: Store source path for include validation
     this.sourcePath = options?.sourcePath ?? null;
 
+    // Issue #349: Store include directories and inputs for angle-bracket include resolution
+    this.includeDirs = options?.includeDirs ?? [];
+    this.inputs = options?.inputs ?? [];
+
     // Issue #250: Store C++ mode for temp variable generation
     this.cppMode = options?.cppMode ?? false;
     // Reset temp var state for each generation
@@ -1617,9 +1627,14 @@ export default class CodeGenerator implements IOrchestrator {
   /**
    * ADR-010: Transform #include directives, converting .cnx to .h
    * ADR-053 A5: Delegates to IncludeGenerator
+   * Issue #349: Now passes includeDirs and inputs for angle-bracket resolution
    */
   private transformIncludeDirective(includeText: string): string {
-    return includeTransformIncludeDirective(includeText, this.sourcePath);
+    return includeTransformIncludeDirective(includeText, {
+      sourcePath: this.sourcePath,
+      includeDirs: this.includeDirs,
+      inputs: this.inputs,
+    });
   }
 
   // Issue #63: validateIncludeNotImplementationFile moved to TypeValidator

package/src/codegen/HeaderGenerator.ts

@@ -268,7 +268,9 @@ class HeaderGenerator {
     passByValueParams?: TPassByValueParams,
   ): string | null {
     // Map return type from C-Next to C
-    const returnType = sym.type ? mapType(sym.type) : "void";
+    // Special case: main() always returns int for C/C++ compatibility
+    const mappedType = sym.type ? mapType(sym.type) : "void";
+    const returnType = sym.name === "main" ? "int" : mappedType;
 
     // Issue #269: Get pass-by-value parameter names for this function
     const passByValueSet = passByValueParams?.get(sym.name);

package/src/codegen/generators/support/IncludeGenerator.ts

@@ -6,22 +6,98 @@ import * as fs from "fs";
 import * as path from "path";
 import * as Parser from "../../../parser/grammar/CNextParser";
 
+/**
+ * Issue #349: Options for include transformation
+ */
+interface IIncludeTransformOptions {
+  sourcePath: string | null;
+  includeDirs?: string[];
+  inputs?: string[];
+}
+
+/**
+ * Issue #349: Find a .cnx file in the given search paths.
+ * Returns the absolute path if found, null otherwise.
+ */
+const findCnxFile = (
+  filename: string,
+  searchPaths: string[],
+): string | null => {
+  for (const searchPath of searchPaths) {
+    const cnxPath = path.resolve(searchPath, `${filename}.cnx`);
+    if (fs.existsSync(cnxPath)) {
+      return cnxPath;
+    }
+  }
+  return null;
+};
+
+/**
+ * Issue #349: Calculate the relative path from input directories.
+ * Returns the relative path (e.g., "Display/utils.cnx") or null if not found.
+ */
+const getRelativePathFromInputs = (
+  filePath: string,
+  inputs: string[],
+): string | null => {
+  for (const input of inputs) {
+    const resolvedInput = path.resolve(input);
+
+    // Skip if input is a file (not a directory)
+    if (fs.existsSync(resolvedInput) && fs.statSync(resolvedInput).isFile()) {
+      continue;
+    }
+
+    const relativePath = path.relative(resolvedInput, filePath);
+
+    // If relative path doesn't start with '..' it's under this input
+    if (!relativePath.startsWith("..") && !path.isAbsolute(relativePath)) {
+      return relativePath;
+    }
+  }
+  return null;
+};
+
 /**
  * ADR-010: Transform #include directives, converting .cnx to .h
  * Validates that .cnx files exist if sourcePath is available
  * Supports both <file.cnx> and "file.cnx" forms
+ *
+ * Issue #349: For angle-bracket includes, resolves the correct output path
+ * by finding the .cnx file and calculating its relative path from inputs.
  */
 const transformIncludeDirective = (
   includeText: string,
-  sourcePath: string | null,
+  options: IIncludeTransformOptions,
 ): string => {
+  const { sourcePath, includeDirs = [], inputs = [] } = options;
+
   // Match: #include <file.cnx> or #include "file.cnx"
   const angleMatch = includeText.match(/#\s*include\s*<([^>]+)\.cnx>/);
   const quoteMatch = includeText.match(/#\s*include\s*"([^"]+)\.cnx"/);
 
   if (angleMatch) {
     const filename = angleMatch[1];
-    // Angle brackets: system/library includes - no validation needed
+
+    // Issue #349: Try to resolve the .cnx file to get correct output path
+    if (sourcePath) {
+      const sourceDir = path.dirname(sourcePath);
+      // Build search paths: source directory first, then include directories
+      const searchPaths = [sourceDir, ...includeDirs];
+
+      const foundPath = findCnxFile(filename, searchPaths);
+      if (foundPath && inputs.length > 0) {
+        // Calculate relative path from inputs for correct header path
+        const relativePath = getRelativePathFromInputs(foundPath, inputs);
+        if (relativePath) {
+          // Transform .cnx to .h
+          const headerPath = relativePath.replace(/\.cnx$/, ".h");
+          return includeText.replace(`<${filename}.cnx>`, `<${headerPath}>`);
+        }
+      }
+    }
+
+    // Fallback: simple replacement (for external includes or when resolution fails)
     return includeText.replace(`<${filename}.cnx>`, `<${filename}.h>`);
   } else if (quoteMatch) {
     const filepath = quoteMatch[1];

package/src/codegen/types/ICodeGeneratorOptions.ts

@@ -24,6 +24,16 @@ interface ICodeGeneratorOptions {
    * Example: "Display/Utils.cnx" -> #include "Display/Utils.h"
    */
   sourceRelativePath?: string;
+  /**
+   * Issue #349: Include directories for resolving angle-bracket .cnx includes.
+   * Used to search for .cnx files referenced in #include <file.cnx> directives.
+   */
+  includeDirs?: string[];
+  /**
+   * Issue #349: Input directories for calculating relative paths.
+   * Used to determine the correct output path prefix for headers.
+   */
+  inputs?: string[];
 }
 
 export default ICodeGeneratorOptions;

package/src/index.ts

@@ -196,6 +196,7 @@ async function runUnifiedMode(
   verbose: boolean,
   cppRequired: boolean,
   noCache: boolean,
+  parseOnly: boolean,
   headerOutDir?: string,
 ): Promise<void> {
   // Issue #337: Identify which inputs are directories (for structure preservation)
@@ -283,6 +284,7 @@ async function runUnifiedMode(
     defines,
     cppRequired,
     noCache,
+    parseOnly,
   });
 
   // Step 5: Compile
@@ -494,6 +496,7 @@ async function main(): Promise<void> {
   let preprocess = true;
   let verbose = false;
   let noCache = false;
+  let parseOnly = false;
   let headerOutDir: string | undefined;
   let cleanMode = false;
 
@@ -514,6 +517,8 @@ async function main(): Promise<void> {
       preprocess = false;
     } else if (arg === "--no-cache") {
       noCache = true;
+    } else if (arg === "--parse") {
+      parseOnly = true;
     } else if (arg === "--header-out" && i + 1 < args.length) {
       headerOutDir = args[++i];
     } else if (arg === "--clean") {
@@ -526,7 +531,26 @@ async function main(): Promise<void> {
       } else {
         defines[define] = true;
       }
-    } else if (!arg.startsWith("-")) {
+    } else if (arg.startsWith("-I")) {
+      // Common mistake: -I is GCC syntax, we use --include
+      // Catches both "-I path" and "-Ipath" (no space)
+      console.error(`Error: Unknown flag '${arg}'`);
+      console.error("  Did you mean: --include <dir>");
+      console.error("");
+      console.error("Example:");
+      console.error("  cnext src --include path/to/headers");
+      process.exit(1);
+    } else if (arg.startsWith("--")) {
+      // Catch unknown long flags (e.g., --foo)
+      console.error(`Error: Unknown flag '${arg}'`);
+      showHelp();
+      process.exit(1);
+    } else if (arg.startsWith("-")) {
+      // Catch other unknown short flags (e.g., -x)
+      console.error(`Error: Unknown flag '${arg}'`);
+      showHelp();
+      process.exit(1);
+    } else {
       inputFiles.push(arg);
     }
   }
@@ -563,6 +587,7 @@ async function main(): Promise<void> {
     verbose,
     cppRequired,
     noCache,
+    parseOnly,
     headerOutDir,
   );
 }

package/src/pipeline/Pipeline.ts

@@ -643,6 +643,8 @@ class Pipeline {
           generateHeaders: this.config.generateHeaders, // Issue #230: Enable self-include when headers are generated
           cppMode: this.cppDetected, // Issue #250: C++ compatible code generation
           sourceRelativePath: this.getSourceRelativePath(file.path), // Issue #339: For correct self-include paths
+          includeDirs: this.config.includeDirs, // Issue #349: For angle-bracket include resolution
+          inputs: this.config.inputs, // Issue #349: For calculating relative paths
         },
       );
 

package/src/project/Project.ts

@@ -52,6 +52,7 @@ class Project {
       generateHeaders: this.config.generateHeaders,
       cppRequired: this.config.cppRequired,
       noCache: this.config.noCache,
+      parseOnly: this.config.parseOnly,
     });
   }
 

package/src/project/types/IProjectConfig.ts

@@ -37,6 +37,9 @@ interface IProjectConfig {
 
   /** Issue #183: Disable symbol caching (default: false = cache enabled) */
   noCache?: boolean;
+
+  /** Parse only mode - validate syntax without generating output */
+  parseOnly?: boolean;
 }
 
 export default IProjectConfig;