c-next 0.1.1 → 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.1",
+  "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

@@ -4570,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])
@@ -6433,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
@@ -6446,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]