[assembler] Distinguish single and multiple RC-word reservations.

The pipe construct can reserve only one RC-word, and this change uses
type information to enforce this.

Author: youngman-g

assembler/src/asmlib/ast.rs

@@ -335,14 +335,100 @@ impl ConfigValue {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct RegistersContaining(Vec<RegisterContaining>);
+
+impl RegistersContaining {
+    pub(crate) fn from_words(words: Vec<RegisterContaining>) -> RegistersContaining {
+        Self(words)
+    }
+
+    pub(crate) fn words(&self) -> &[RegisterContaining] {
+        &self.0
+    }
+
+    fn symbol_uses(
+        &self,
+        block_id: BlockIdentifier,
+        block_offset: Unsigned18Bit,
+    ) -> impl Iterator<Item = (SymbolName, Span, SymbolUse)> + use<'_> {
+        self.0
+            .iter()
+            .flat_map(move |rc| rc.symbol_uses(block_id, block_offset))
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct RegisterContaining(Box<TaggedProgramInstruction>);
+
+impl From<TaggedProgramInstruction> for RegisterContaining {
+    fn from(inst: TaggedProgramInstruction) -> Self {
+        Self(Box::new(inst))
+    }
+}
+
+impl RegisterContaining {
+    pub(crate) fn instruction(&self) -> &TaggedProgramInstruction {
+        &self.0
+    }
+
+    fn symbol_uses(
+        &self,
+        block_id: BlockIdentifier,
+        block_offset: Unsigned18Bit,
+    ) -> impl Iterator<Item = (SymbolName, Span, SymbolUse)> + use<'_> {
+        // Tags defined inside the RC-word are not counted as
+        // defined outside it.  But if we refer to a symbol
+        // inside the RC-word it counts as a reference for the
+        // purpose of determining which contexts it has been
+        // used in.
+        let mut result = Vec::new();
+        for symbol_use in self.0.symbol_uses(block_id, block_offset) {
+            let (name, span, symbol_definition) = symbol_use;
+            match symbol_definition {
+                def @ SymbolUse::Reference(_) => {
+                    result.push((name, span, def));
+                }
+                SymbolUse::Definition(tagdef @ SymbolDefinition::Tag { .. }) => {
+                    result.push((name, span, SymbolUse::LocalDefinition(tagdef)));
+                }
+                SymbolUse::LocalDefinition(_) => {
+                    panic!("found local definition inside RC-word, don't know how to handle this.");
+                }
+                SymbolUse::Origin(_name, _block) => {
+                    unreachable!("Found origin {name} inside an RC-word; the parser should have rejected this.");
+                }
+                SymbolUse::Definition(_) => {
+                    // e.g. we have an input like
+                    //
+                    // { X = 2 }
+                    //
+                    //
+                    // Ideally we would issue an error for
+                    // this, but since this function cannot
+                    // fail, it's better to do that at the
+                    // time we parse the RC-word reference
+                    // (thus eliminating this case).
+                    //
+                    // When working on this case we should
+                    // figure out if an equality is allowed
+                    // inside a macro expansion.
+                    panic!("Found unexpected definition of {name} inside RC-word reference at {span:?}");
+                }
+            }
+        }
+        result.into_iter()
+    }
+}
+
 /// Eventually we will support real expressions, but for now we only
 /// suport literals and references to symbols ("equalities" in the
 /// User Handbook).
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum Atom {
     SymbolOrLiteral(SymbolOrLiteral),
     Parens(Span, Script, Box<ArithmeticExpression>),
-    RcRef(Span, Vec<TaggedProgramInstruction>),
+    RcRef(Span, RegistersContaining),
 }
 
 impl From<(Span, Script, SymbolName)> for Atom {
@@ -385,49 +471,8 @@ impl Atom {
             Atom::Parens(_span, _script, expr) => {
                 result.extend(expr.symbol_uses(block_id, block_offset));
             }
-            Atom::RcRef(_span, tagged_instructions) => {
-                // Tags defined inside the RC-word are not counted as
-                // defined outside it.  But if we refer to a symbol
-                // inside the RC-word it counts as a reference for the
-                // purpose of determining which contexts it has been
-                // used in.
-                for symbol_use in tagged_instructions
-                    .iter()
-                    .flat_map(|instr| instr.symbol_uses(block_id, block_offset))
-                {
-                    let (name, span, symbol_definition) = symbol_use;
-                    match symbol_definition {
-                        def @ SymbolUse::Reference(_) => {
-                            result.push((name, span, def));
-                        }
-                        SymbolUse::Definition(tagdef @ SymbolDefinition::Tag { .. }) => {
-                            result.push((name, span, SymbolUse::LocalDefinition(tagdef)));
-                        }
-                        SymbolUse::LocalDefinition(_) => {
-                            panic!("found local definition inside RC-word, don't know how to handle this.");
-                        }
-                        SymbolUse::Origin(_name, _block) => {
-                            unreachable!("Found origin {name} inside an RC-word; the parser should have rejected this.");
-                        }
-                        SymbolUse::Definition(_) => {
-                            // e.g. we have an input like
-                            //
-                            // { X = 2 }
-                            //
-                            //
-                            // Ideally we would issue an error for
-                            // this, but since this function cannot
-                            // fail, it's better to do that at the
-                            // time we parse the RC-word reference
-                            // (thus eliminating this case).
-                            //
-                            // When working on this case we should
-                            // figure out if an equality is allowed
-                            // inside a macro expansion.
-                            panic!("Found unexpected definition of {name} inside RC-word reference at {span:?}");
-                        }
-                    }
-                }
+            Atom::RcRef(_span, rc_words) => {
+                result.extend(rc_words.symbol_uses(block_id, block_offset));
             }
         }
         result.into_iter()
@@ -544,7 +589,7 @@ pub(crate) enum InstructionFragment {
     PipeConstruct {
         index: SpannedSymbolOrLiteral,
         rc_word_span: Span,
-        rc_word_value: Box<(InstructionFragment, Atom)>,
+        rc_word_value: RegisterContaining,
     },
     Null,
     // TODO: subscript/superscript atom (if the `Arithmetic` variant
@@ -584,9 +629,7 @@ impl InstructionFragment {
                             (name, span, symbol_use)
                         }),
                 );
-                let (base, index) = rc_word_value.as_ref();
-                result.extend(base.symbol_uses(block_id, block_offset));
-                result.extend(index.symbol_uses(block_id, block_offset));
+                result.extend(rc_word_value.symbol_uses(block_id, block_offset));
             }
         }
         result.into_iter()

assembler/src/asmlib/driver/tests.rs

@@ -752,8 +752,12 @@ fn test_kleinrock_200016() {
     let program = assemble_source(input, Default::default()).expect("program is valid");
     dbg!(&program);
     assert_eq!(program.chunks.len(), 3);
-    assert_eq!(program.chunks[0].words.len(), 1); // program length
-    assert_eq!(program.chunks[2].words.len(), 1); // RC block length
+    assert_eq!(
+        program.chunks[0].words.len(),
+        1,
+        "Program code has wrong length"
+    );
+    assert_eq!(program.chunks[2].words.len(), 1, "RC block length is wrong");
 
     assert_eq!(program.chunks[0].address, Address::from(u18!(0o200_000))); // Location of program code
     assert_eq!(program.chunks[0].words[0], u36!(0o031_712_606_336));

assembler/src/asmlib/eval.rs

@@ -10,8 +10,8 @@ use base::{
 use super::ast::{
     ArithmeticExpression, Atom, CommaDelimitedInstruction, Commas, ConfigValue, EqualityValue,
     HoldBit, InstructionFragment, LiteralValue, LocatedBlock, Operator, RcAllocator, RcWordSource,
-    SignedAtom, Statement, SymbolOrLiteral, Tag, TaggedProgramInstruction,
-    UntaggedProgramInstruction,
+    RegisterContaining, RegistersContaining, SignedAtom, Statement, SymbolOrLiteral, Tag,
+    TaggedProgramInstruction, UntaggedProgramInstruction,
 };
 use super::listing::{Listing, ListingLine};
 use super::span::*;
@@ -394,19 +394,20 @@ impl Evaluate for InstructionFragment {
                 // of Q and ₜ were combined into the two parts of the
                 // rc_word_value tuple.  We evaluate Qₜ as
                 // rc_word_val.
-                let (base, index) = rc_word_value.as_ref();
-                let base_value =
-                    base.evaluate(*rc_word_span, target_address, symtab, rc_allocator, op)?;
-                let index_value =
-                    index.evaluate(*rc_word_span, target_address, symtab, rc_allocator, op)?;
-                let rc_word_val: Unsigned36Bit = combine_fragment_values(base_value, index_value);
                 let p_value: Unsigned36Bit =
                     p.item
                         .evaluate(p.span, target_address, symtab, rc_allocator, op)?;
-                let rc_source = RcWordSource::PipeConstruct(*rc_word_span);
-                let addr: Address = rc_allocator.allocate(rc_source, rc_word_val);
+                let source_and_val: (&RcWordSource, &RegisterContaining) =
+                    (&RcWordSource::PipeConstruct(*rc_word_span), rc_word_value);
+                let rc_word_addr: Unsigned36Bit = source_and_val.evaluate(
+                    *rc_word_span,
+                    target_address,
+                    symtab,
+                    rc_allocator,
+                    op,
+                )?;
                 Ok(combine_fragment_values(
-                    combine_fragment_values(Unsigned36Bit::from(addr), p_value),
+                    combine_fragment_values(p_value, rc_word_addr),
                     DEFER_BIT,
                 ))
             }
@@ -467,44 +468,10 @@ impl Evaluate for Atom {
             Atom::Parens(span, _script, expr) => {
                 expr.evaluate(*span, target_address, symtab, rc_allocator, op)
             }
-            Atom::RcRef(span, tagged_program_instructions) => {
-                let mut first_addr: Option<Address> = None;
-                for inst in tagged_program_instructions.iter() {
-                    let rc_source = RcWordSource::Braces(*span);
-                    let rc_word_addr: Address =
-                        rc_allocator.allocate(rc_source, 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);
-
-                    // If inst has a tag, we temporarily override any
-                    // global value for that tag with the address of
-                    // this instruction.
-                    let tag_override: Option<(&Tag, Address)> =
-                        inst.tag.as_ref().map(|t| (t, rc_word_addr));
-                    let value: Unsigned36Bit = symtab.evaluate_with_temporary_tag_override(
-                        tag_override,
-                        inst,
-                        inst.span(),
-                        &here,
-                        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");
-                    }
-                }
+            Atom::RcRef(span, registers_containing) => {
+                let source_and_val: (&RcWordSource, &RegistersContaining) =
+                    (&RcWordSource::Braces(*span), registers_containing);
+                source_and_val.evaluate(*span, target_address, symtab, rc_allocator, op)
             }
         }
     }
@@ -1184,3 +1151,82 @@ impl LocatedBlock {
         Ok(words)
     }
 }
+
+impl Evaluate for (&RcWordSource, &RegistersContaining) {
+    fn evaluate<R: RcAllocator>(
+        &self,
+        span: Span,
+        _target_address: &HereValue,
+        symtab: &mut SymbolTable,
+        rc_allocator: &mut R,
+        op: &mut LookupOperation,
+    ) -> Result<Unsigned36Bit, SymbolLookupFailure> {
+        let rc_source: &RcWordSource = self.0;
+        let registers_containing: &RegistersContaining = self.1;
+        let mut first_addr: Option<Unsigned36Bit> = None;
+        for rc_word in registers_containing.words() {
+            // Evaluation of the RegisterContaining value will compute
+            // a correct here-value, we don't need to pass it in.  But
+            // we can't pass None, and so instead we pass NotAllowed
+            // so that if a bug is introduced we will see a failure
+            // rather than an incorrect result.
+            let must_recompute_here_address = HereValue::NotAllowed;
+            let addr: Unsigned36Bit = (rc_source, rc_word).evaluate(
+                span,
+                &must_recompute_here_address,
+                symtab,
+                rc_allocator,
+                op,
+            )?;
+            if first_addr.is_none() {
+                first_addr = Some(addr);
+            }
+        }
+        match first_addr {
+            Some(addr) => Ok(addr),
+            None => {
+                unreachable!("RC-references should not occupy zero words of storage");
+            }
+        }
+    }
+}
+
+impl Evaluate for (&RcWordSource, &RegisterContaining) {
+    fn evaluate<R: RcAllocator>(
+        &self,
+        _span: Span,
+        _target_address: &HereValue,
+        symtab: &mut SymbolTable,
+        rc_allocator: &mut R,
+        op: &mut LookupOperation,
+    ) -> Result<Unsigned36Bit, SymbolLookupFailure> {
+        let rc_source: &RcWordSource = self.0;
+        let register_containing: &RegisterContaining = self.1;
+
+        let rc_word_addr: Address = rc_allocator.allocate(rc_source.clone(), Unsigned36Bit::ZERO);
+        dbg!(&(rc_source, 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);
+
+        // If inst has a tag, we temporarily override any
+        // global value for that tag with the address of
+        // this instruction.
+        let inst: &TaggedProgramInstruction = register_containing.instruction();
+        let tag_override: Option<(&Tag, Address)> = inst.tag.as_ref().map(|t| (t, rc_word_addr));
+        let value: Unsigned36Bit = symtab.evaluate_with_temporary_tag_override(
+            tag_override,
+            inst,
+            inst.span(),
+            &here,
+            rc_allocator,
+            op,
+        )?;
+        rc_allocator.update(rc_word_addr, value);
+        Ok(Unsigned36Bit::from(rc_word_addr))
+    }
+}