c-next 0.1.0 → 0.1.2

package/README.md

@@ -301,6 +301,40 @@ Write-only registers generate optimized code:
 GPIO7.DR_SET[LED_BIT] <- true;    // Generates: GPIO7_DR_SET = (1 << LED_BIT);
 ```
 
+### Slice Assignment for Memory Operations
+
+Multi-byte copying with bounds-checked `memcpy` generation:
+
+```cnx
+u8 buffer[256];
+u32 magic <- 0x12345678;
+u8 length <- 4;
+u32 offset <- 0;
+
+// Copy 4 bytes from value into buffer at offset
+buffer[offset, length] <- magic;
+```
+
+Transpiles to runtime bounds-checked code:
+
+```c
+uint8_t buffer[256] = {0};
+uint32_t magic = 0x12345678;
+uint8_t length = 4;
+uint32_t offset = 0;
+
+if (offset + length <= sizeof(buffer)) {
+    memcpy(&buffer[offset], &magic, length);
+}
+```
+
+**Key Features:**
+
+- Runtime bounds checking prevents buffer overflows
+- Enables binary serialization and protocol implementation
+- Works with struct fields: `buffer[offset, len] <- config.magic`
+- Distinct from bit operations: array slices use `memcpy`, scalar bit ranges use bit manipulation
+
 ### Scopes (ADR-016)
 
 Organize code with automatic name prefixing. Inside scopes, explicit qualification is required:
@@ -702,14 +736,16 @@ Decisions are documented in `/docs/decisions/`:
 | [ADR-031](docs/decisions/adr-031-inline-functions.md)            | Inline Functions    | Trust compiler; `inline` is just a hint anyway                          |
 | [ADR-033](docs/decisions/adr-033-packed-structs.md)              | Packed Structs      | Use ADR-004 register bindings or explicit serialization                 |
 
-## Build Commands
+## Development Commands
 
 ```bash
-npm run build      # Full build: ANTLR + TypeScript
 npm run antlr      # Regenerate parser from grammar
-npx tsc            # TypeScript only
+npm run typecheck  # Type-check TypeScript (no build required)
+npm test           # Run all tests
 ```
 
+**Note:** C-Next runs directly via `tsx` without a build step. The `typecheck` command validates types only and does not generate any output files.
+
 ## Contributing
 
 Ideas and feedback welcome via issues.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "main": "src/index.ts",
   "bin": {
@@ -15,6 +15,7 @@
     "antlr:all": "npm run antlr && npm run antlr:c && npm run antlr:cpp",
     "start": "tsx src/index.ts",
     "dev": "tsx src/index.ts",
+    "typecheck": "tsc --noEmit",
     "test": "tsx scripts/test.js",
     "test:cli": "node scripts/test-cli.js",
     "test:update": "tsx scripts/test.js --update",

package/src/codegen/CodeGenerator.ts

@@ -898,6 +898,10 @@ export default class CodeGenerator {
         const scopeDecl = decl.scopeDeclaration()!;
         const scopeName = scopeDecl.IDENTIFIER().getText();
 
+        // Set currentScope so that this.Type references resolve correctly
+        const savedScope = this.context.currentScope;
+        this.context.currentScope = scopeName;
+
         for (const member of scopeDecl.scopeMember()) {
           if (member.variableDeclaration()) {
             const varDecl = member.variableDeclaration()!;
@@ -907,6 +911,9 @@ export default class CodeGenerator {
             this.trackVariableTypeWithName(varDecl, fullName);
           }
         }
+
+        // Restore previous scope
+        this.context.currentScope = savedScope;
       }
 
       // Note: Function parameters are registered per-function during generation
@@ -4563,7 +4570,28 @@ export default class CodeGenerator {
       const isISRType = typeInfo?.baseType === "ISR";
 
       if (isActualArray || isISRType) {
-        // Normal array element assignment
+        // Check for slice assignment: array[offset, length] <- value
+        if (exprs.length === 2) {
+          // Slice assignment - generate memcpy with bounds checking
+          const offset = this.generateExpression(exprs[0]);
+          const length = this.generateExpression(exprs[1]);
+
+          // Compound operators not supported for slice assignment
+          if (cOp !== "=") {
+            throw new Error(
+              `Compound assignment operators not supported for slice assignment: ${cnextOp}`,
+            );
+          }
+
+          // Set flag to include string.h for memcpy
+          this.needsString = true;
+
+          // Generate bounds-checked memcpy
+          // if (offset + length <= sizeof(buffer)) { memcpy(&buffer[offset], &value, length); }
+          return `if (${offset} + ${length} <= sizeof(${name})) { memcpy(&${name}[${offset}], &${value}, ${length}); }`;
+        }
+
+        // Normal array element assignment (single index)
         const index = this.generateExpression(exprs[0]);
 
         // Check if this is a string array (e.g., string<64> arr[4])
@@ -6426,12 +6454,13 @@ export default class CodeGenerator {
           const isPrimaryArray = identifierTypeInfo?.isArray ?? false;
 
           // Determine if this subscript is array access or bit access
-          // Priority: register access > tracked member array > primary array > bit access
+          // Priority: register access > tracked member array > primary array > primitive integer bit access > default array access
           if (isRegisterAccess) {
             // Register - use bit access: ((value >> index) & 1)
             result = `((${result} >> ${index}) & 1)`;
           } else if (currentMemberIsArray) {
-            // Struct member that is an array (e.g., buf.data[0])
+            // Struct member that is an array (e.g., config.tempInputs[0])
+            // This is the most reliable indicator - we tracked it through member access
             result = `${result}[${index}]`;
             currentMemberIsArray = false; // After subscript, no longer array
             isSubscripted = true; // Track for .length on element
@@ -6439,12 +6468,29 @@ export default class CodeGenerator {
             // Primary identifier is an array (e.g., arr[0] or global.arr[0])
             result = `${result}[${index}]`;
             isSubscripted = true; // Track for .length on element
-          } else if (identifierTypeInfo && !isPrimaryArray) {
-            // Non-array type (integer, etc.) - use bit access
-            result = `((${result} >> ${index}) & 1)`;
+            // After subscripting an array, set currentStructType if the element is a struct
+            if (identifierTypeInfo && !currentStructType) {
+              const elementType = identifierTypeInfo.baseType;
+              if (this.knownStructs.has(elementType)) {
+                currentStructType = elementType;
+              }
+            }
           } else {
-            // Unknown type - default to array access
-            result = `${result}[${index}]`;
+            // Check both currentStructType (for member access chains) and identifierTypeInfo (for simple variables)
+            const typeToCheck =
+              currentStructType || identifierTypeInfo?.baseType;
+            const isPrimitiveInt =
+              typeToCheck &&
+              ["u8", "u16", "u32", "u64", "i8", "i16", "i32", "i64"].includes(
+                typeToCheck,
+              );
+            if (isPrimitiveInt) {
+              // Primitive integer - use bit access: ((value >> index) & 1)
+              result = `((${result} >> ${index}) & 1)`;
+            } else {
+              // Non-primitive type or unknown - default to array access
+              result = `${result}[${index}]`;
+            }
           }
         } else if (exprs.length === 2) {
           // Bit range: flags[start, width]

package/src/codegen/types/ICallbackTypeInfo.ts

@@ -0,0 +1,20 @@
+/**
+ * Callback type info for Function-as-Type pattern
+ * Each function definition creates both a callable function AND a type
+ */
+
+interface ICallbackTypeInfo {
+  functionName: string; // The original function name (also the type name)
+  returnType: string; // Return type for typedef (C type)
+  parameters: Array<{
+    name: string;
+    type: string; // C type
+    isConst: boolean;
+    isPointer: boolean; // Non-array params become pointers
+    isArray: boolean; // Array parameters pass naturally as pointers
+    arrayDims: string; // Array dimensions if applicable
+  }>;
+  typedefName: string; // e.g., "onReceive_fp"
+}
+
+export default ICallbackTypeInfo;

package/src/codegen/types/IFunctionSignature.ts

@@ -0,0 +1,16 @@
+/**
+ * Function signature for const parameter tracking
+ * Used to validate const-to-non-const errors at call sites
+ */
+
+interface IFunctionSignature {
+  name: string;
+  parameters: Array<{
+    name: string;
+    baseType: string; // The C-Next type (e.g., 'u32', 'f32')
+    isConst: boolean;
+    isArray: boolean;
+  }>;
+}
+
+export default IFunctionSignature;

package/src/codegen/types/ITargetCapabilities.ts

@@ -0,0 +1,12 @@
+/**
+ * Target platform capabilities for code generation
+ * Determines which atomic instructions and features are available
+ */
+
+interface ITargetCapabilities {
+  wordSize: 8 | 16 | 32;
+  hasLdrexStrex: boolean;
+  hasBasepri: boolean;
+}
+
+export default ITargetCapabilities;

package/src/codegen/types/TCodeGenContext.ts

@@ -0,0 +1,41 @@
+/**
+ * Code generation context - shared state across all codegen components
+ * Tracks current scope, variables, types, and generation state
+ */
+
+import TParameterInfo from "./TParameterInfo";
+import TTypeInfo from "./TTypeInfo";
+import TOverflowBehavior from "./TOverflowBehavior";
+import ITargetCapabilities from "./ITargetCapabilities";
+
+/**
+ * Assignment context for overflow behavior tracking
+ */
+export interface IAssignmentContext {
+  targetName: string | null;
+  targetType: string | null;
+  overflowBehavior: TOverflowBehavior;
+}
+
+/**
+ * Code generation context - mutable state passed to all codegen components
+ */
+type TCodeGenContext = {
+  currentScope: string | null;
+  indentLevel: number;
+  scopeMembers: Map<string, Set<string>>;
+  currentParameters: Map<string, TParameterInfo>;
+  localArrays: Set<string>;
+  localVariables: Set<string>;
+  inFunctionBody: boolean;
+  typeRegistry: Map<string, TTypeInfo>;
+  expectedType: string | null;
+  mainArgsName: string | null;
+  assignmentContext: IAssignmentContext;
+  lastArrayInitCount: number;
+  lastArrayFillValue: string | undefined;
+  lengthCache: Map<string, string> | null;
+  targetCapabilities: ITargetCapabilities;
+};
+
+export default TCodeGenContext;

package/src/codegen/types/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Codegen types barrel export
+ * Central export point for all codegen type definitions
+ */
+
+export { default as ECommentType } from "./ECommentType";
+export { default as IComment } from "./IComment";
+export { default as ICommentError } from "./ICommentError";
+export { default as TParameterInfo } from "./TParameterInfo";
+export { default as TOverflowBehavior } from "./TOverflowBehavior";
+export { default as TTypeInfo } from "./TTypeInfo";
+export { default as TCodeGenContext } from "./TCodeGenContext";
+export type { IAssignmentContext } from "./TCodeGenContext";
+export { default as ITargetCapabilities } from "./ITargetCapabilities";
+export { default as IFunctionSignature } from "./IFunctionSignature";
+export { default as ICallbackTypeInfo } from "./ICallbackTypeInfo";
+export * from "./TTypeConstants";