Issue #377: assign a logic subset to logic (array) (#456)

Author: RPG-coder-intc

lib/src/exceptions/logic/signal_width_mismatch_exception.dart

@@ -31,4 +31,12 @@ class SignalWidthMismatchException extends RohdException {
   SignalWidthMismatchException.forNull(dynamic val)
       : super('Could not infer width of input $val.'
             ' Please provide a valid width.');
+
+  /// Constructs a new [Exception] for when a dynamic has a wrong width.
+  SignalWidthMismatchException.forWidthOverflow(int actualWidth, int maxWidth,
+      {String? customMessage})
+      : super(customMessage ??
+            'Value has the wrong width.'
+                ' Expected $actualWidth to be less than'
+                ' or equal to $maxWidth.');
 }

lib/src/signals/logic_array.dart

@@ -127,4 +127,33 @@ class LogicArray extends LogicStructure {
     return LogicArray(dimensions, elementWidth,
         numUnpackedDimensions: numUnpackedDimensions, name: name);
   }
+
+  /// Perform Assign operation on a Logic subset or slice
+  ///
+  /// Assigns part of this LogicArray with a given [updatedSubset] of type
+  /// [List<Logic>]. The update is performed from a given [start] position
+  /// to the length of the [updatedSubset].
+  ///
+  /// Example:
+  /// ```
+  /// LogicArray sampleLogic;
+  /// // Note: updatedSubset.length < (sampleLogic.length - start)
+  /// List<Logic> updatedSubset;
+  /// // Assign part of sampleLogic as [updatedSubset]
+  /// sampleLogic.assignSubset(updatedSubset); // start = 0 by default
+  /// // assign updated subset to sampleLogic[10:10+updatedSubset.length]
+  /// sampleLogic.assignSubset(updatedSubset, 10);
+  /// ```
+  ///
+  void assignSubset(List<Logic> updatedSubset, {int start = 0}) {
+    if (updatedSubset.length > elements.length - start) {
+      throw SignalWidthMismatchException.forWidthOverflow(
+          updatedSubset.length, elements.length - start);
+    }
+
+    // Assign Logic array from `start` index to `start+updatedSubset.length`
+    for (var i = 0; i < updatedSubset.length; i++) {
+      elements[start + i] <= updatedSubset[i];
+    }
+  }
 }

test/logic_array_test.dart

@@ -477,6 +477,28 @@ class IndexBitOfArrayModule extends Module {
   }
 }
 
+class AssignSubsetModule extends Module {
+  AssignSubsetModule(LogicArray updatedSubset,
+      {int? start, bool? isError = false}) {
+    final dim = ((isError != null && isError) ? 10 : 5);
+    updatedSubset = addInputArray('inputLogicArray', updatedSubset,
+        dimensions: [dim], elementWidth: 3);
+
+    final o =
+        addOutputArray('outputLogicArray', dimensions: [10], elementWidth: 3);
+    final error = addOutput('errorBit');
+    try {
+      if (start != null) {
+        o.assignSubset(updatedSubset.elements, start: start);
+      } else {
+        o.assignSubset(updatedSubset.elements);
+      }
+    } on SignalWidthMismatchException {
+      error <= Const(1);
+    }
+  }
+}
+
 void main() {
   tearDown(() async {
     await Simulator.reset();
@@ -938,5 +960,58 @@ void main() {
       await SimCompare.checkFunctionalVector(mod, vectors);
       SimCompare.checkIverilogVector(mod, vectors);
     });
+
+    test('assign subset of logic array without mentioning start', () async {
+      final updatedSubset = LogicArray([5], 3, name: 'updatedSubset');
+      final mod = AssignSubsetModule(updatedSubset);
+      await mod.build();
+
+      final vectors = [
+        Vector({'inputLogicArray': 0},
+            {'outputLogicArray': LogicValue.ofString(('z' * 15) + ('0' * 15))}),
+        Vector({'inputLogicArray': bin('101' * 5)},
+            {'outputLogicArray': LogicValue.ofString(('z' * 15) + ('101' * 5))})
+      ];
+
+      await SimCompare.checkFunctionalVector(mod, vectors);
+      SimCompare.checkIverilogVector(mod, vectors);
+    });
+
+    test('assign subset of logic array with mentioning start', () async {
+      final updatedSubset = LogicArray([5], 3, name: 'updatedSubset');
+      final mod = AssignSubsetModule(updatedSubset, start: 3);
+      await mod.build();
+
+      final vectors = [
+        Vector({
+          'inputLogicArray': 0
+        }, {
+          'outputLogicArray':
+              LogicValue.ofString(('z' * 3 * 2) + ('0' * 3 * 5) + ('z' * 3 * 3))
+        }),
+        Vector({
+          'inputLogicArray': bin('101' * 5)
+        }, {
+          'outputLogicArray':
+              LogicValue.ofString(('z' * 3 * 2) + ('101' * 5) + ('z' * 3 * 3))
+        }),
+      ];
+
+      await SimCompare.checkFunctionalVector(mod, vectors);
+      SimCompare.checkIverilogVector(mod, vectors);
+    });
+
+    test('error in assign subset of logic array', () async {
+      final updatedSubset = LogicArray([10], 3, name: 'updatedSubset');
+      final mod = AssignSubsetModule(updatedSubset, start: 3, isError: true);
+      await mod.build();
+
+      final vectors = [
+        Vector({'inputLogicArray': bin('101' * 10)}, {'errorBit': 1})
+      ];
+
+      await SimCompare.checkFunctionalVector(mod, vectors);
+      SimCompare.checkIverilogVector(mod, vectors);
+    });
   });
 }