[assembler] Ensure # resolves correctly inside RC-words.

Author: youngman-g

assembler/src/asmlib/ast.rs

@@ -25,6 +25,7 @@ enum SymbolUse {
 
 pub(crate) trait RcAllocator {
     fn allocate(&mut self, span: Span, value: Unsigned36Bit) -> Address;
+    fn update(&mut self, address: Address, value: Unsigned36Bit);
 }
 
 /// Eventually we will support symbolic expressions.

assembler/src/asmlib/driver.rs

@@ -378,6 +378,10 @@ impl RcAllocator for NoRcBlock {
     fn allocate(&mut self, _span: Span, _value: Unsigned36Bit) -> Address {
         panic!("Cannot allocate an RC-word before we know the address of the RC block");
     }
+
+    fn update(&mut self, _address: Address, _value: Unsigned36Bit) {
+        panic!("Cannot update an RC-word in an RC-block which cannot allocate words");
+    }
 }
 
 fn assign_block_positions(

assembler/src/asmlib/driver/tests.rs

@@ -559,3 +559,36 @@ fn test_440_330_220_110_with_commas_in_rc_word() {
     assert_eq!(program.chunks[0].words[0], program.chunks[1].address); // point to first word in RC-block
     assert_eq!(program.chunks[1].words[0], u36!(0o440330220110));
 }
+
+#[test]
+fn test_here_in_rc_word() {
+    let input = "100|{#}\n";
+    let program = assemble_source(input, Default::default()).expect("program is valid");
+    dbg!(&program);
+    assert_eq!(program.chunks.len(), 2); // one regular chunk plus RC-block
+    assert_eq!(program.chunks[0].address, Address::from(u18!(0o100)));
+    assert_eq!(program.chunks[0].words.len(), 1);
+    assert_eq!(program.chunks[0].words[0], u36!(0o101)); // points to first word in RC-block
+
+    assert_eq!(program.chunks[1].address, Address::from(u18!(0o101)));
+    assert_eq!(program.chunks[1].words.len(), 1); // RC block has one word
+    assert_eq!(program.chunks[1].words[0], u36!(0o101)); // # is 0o101 at address 0o101
+}
+
+#[test]
+fn test_here_in_nested_rc_word() {
+    let input = "100|{{#+400}}\n";
+    let program = assemble_source(input, Default::default()).expect("program is valid");
+    dbg!(&program);
+    assert_eq!(program.chunks.len(), 2); // one regular chunk plus RC-block
+    assert_eq!(program.chunks[0].address, Address::from(u18!(0o100)));
+    assert_eq!(program.chunks[0].words.len(), 1);
+    assert_eq!(program.chunks[0].words[0], u36!(0o101)); // points to first word in RC-block
+
+    assert_eq!(program.chunks[1].address, Address::from(u18!(0o101)));
+    assert_eq!(program.chunks[1].words.len(), 2);
+    // The first RC-word points to the second RC-word.
+    assert_eq!(program.chunks[1].words[0], u36!(0o102));
+    // # is 0o102 at address 0o102, so #+400 is 0o502.
+    assert_eq!(program.chunks[1].words[1], u36!(0o502));
+}

assembler/src/asmlib/eval.rs

@@ -186,21 +186,54 @@ pub(crate) struct RcBlock {
     pub(crate) words: Vec<(Span, Unsigned36Bit)>,
 }
 
-impl RcAllocator for RcBlock {
-    fn allocate(&mut self, span: Span, value: Unsigned36Bit) -> Address {
+impl RcBlock {
+    fn end(&self) -> Address {
         match Unsigned18Bit::try_from(self.words.len()) {
-            Ok(offset) => {
-                let addr = self.address.index_by(offset);
-                self.words.push((span, value));
-                addr
-            }
+            Ok(offset) => self.address.index_by(offset),
             Err(_) => {
                 panic!("program is too large"); // TODO: fixme: use Result
             }
         }
     }
 }
 
+impl RcAllocator for RcBlock {
+    fn allocate(&mut self, span: Span, value: Unsigned36Bit) -> Address {
+        let addr = self.end();
+        self.words.push((span, value));
+        addr
+    }
+
+    fn update(&mut self, address: Address, value: Unsigned36Bit) {
+        if address < self.address {
+            panic!(
+                "out of range access to address {address} of RC-block starting at {}",
+                self.address
+            );
+        }
+        match Unsigned18Bit::from(address).checked_sub(Unsigned18Bit::from(self.address)) {
+            Some(offset) => match self.words.get_mut(usize::from(offset)) {
+                Some((_span, spot)) => {
+                    *spot = value;
+                }
+                None => {
+                    panic!(
+                        "out of range access to address {address} of RC-block ending at {}",
+                        self.end()
+                    );
+                }
+            },
+            None => {
+                // The checks above should ensure that address >= self.address.
+                panic!(
+                    "inconsistent checks; {address:o} should be greater than {:o}",
+                    self.address
+                );
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 pub(crate) fn make_empty_rc_block_for_test(location: Address) -> RcBlock {
     RcBlock {
@@ -427,15 +460,27 @@ impl Evaluate for Atom {
             ),
             Atom::Parens(_script, expr) => expr.evaluate(target_address, symtab, rc_allocator, op),
             Atom::RcRef(span, tagged_program_instructions) => {
-                let value: Unsigned36Bit = evaluate_and_combine_values(
-                    tagged_program_instructions,
-                    target_address,
-                    symtab,
-                    rc_allocator,
-                    op,
-                )?;
-                let addr: Address = rc_allocator.allocate(*span, value);
-                Ok(addr.into())
+                let mut first_addr: Option<Address> = None;
+                for inst in tagged_program_instructions.iter() {
+                    let rc_word_addr: Address = rc_allocator.allocate(*span, Unsigned36Bit::ZERO);
+                    if first_addr.is_none() {
+                        first_addr = Some(rc_word_addr);
+                    }
+                    // Within the RC-word, # ("here") resolves to the
+                    // address of the RC-word itself.  So before we
+                    // evaluate the value to be placed in the RC-word,
+                    // we need to know the value that # will take
+                    // during the evaluation process.
+                    let here = HereValue::Address(rc_word_addr);
+                    let value: Unsigned36Bit = inst.evaluate(&here, symtab, rc_allocator, op)?;
+                    rc_allocator.update(rc_word_addr, value);
+                }
+                match first_addr {
+                    Some(addr) => Ok(addr.into()),
+                    None => {
+                        unreachable!("RC-references should not occupy zero words of storage");
+                    }
+                }
             }
         }
     }