[assembler] Add test for default-assigned index registers.

Thre's a little ambiguity over previsely what section 6-2.2 of the
User Handbook intends for the case where index register values are
hard-coded elsewhere in the source, but the test (like our
pre-existing code) takes what I believe to be the most likely
interpretation.

The ambiguity is also called out in OPEN-QUESTIONS.md.

This fixes #109.

Author: youngman-g

OPEN-QUESTIONS.md

@@ -71,10 +71,14 @@
 2. Is there a difference between the configuration values 34 and -3?
    Both seem to occur in symbolic code (e.g. the examples memo by
    H. Philip Peterson, 6M-5780, July 23, 1958).
-3. The user handbook (ch. 6) appears to state that it is possible to
-   assemble an instruction into both the left and right halves of a
-   word.  Is the operand address portion of both instructions
-   discarded?  If not, how is it handled?
-4. In the pipe construct "Z ₚ|ₜ Q" described in the User Handbook
+3. In the pipe construct "Z ₚ|ₜ Q" described in the User Handbook
    section 2-2.8 "SPECIAL SYMBOLS", are spaces allowed in the "ₚ" or
    "ₜ"?
+4. Symexes used only for index register values (User Handbook section
+   6-2.2) are assigned as "The lowest numerical index register value
+   not already used".  What does "used" mean?  We currently assume it
+   means "not already default-assigned", meaning that the assembler
+   does not need to track which index registers are used via explicit
+   equalities or numeric literals.  (Otherwise, use of index register
+   0o52 would mean that the first value to be default-assigned would
+   be 0o53, which isn't very helpful).

assembler/src/asmlib/driver/tests.rs

@@ -18,8 +18,8 @@ use super::{assemble_pass1, Binary, BinaryChunk};
 use base::{
     charset::Script,
     prelude::{
-        u18, u36, Address, Instruction, Opcode, OperandAddress, SymbolicInstruction, Unsigned18Bit,
-        Unsigned36Bit, Unsigned5Bit, Unsigned6Bit,
+        u18, u36, u6, Address, Instruction, Opcode, OperandAddress, SymbolicInstruction,
+        Unsigned18Bit, Unsigned36Bit, Unsigned5Bit, Unsigned6Bit,
     },
 };
 
@@ -652,11 +652,8 @@ fn default_assigned_rc_word() {
     // The numerical memory location of the next place in the RC words
     // block. The contents of this RC word are set to zero.  This
     // provision is useful in assigning temporary storage.
-    let program = assemble_source(
-        concat!("100| STA TEMP1\n", "     STB TEMP2\n"),
-        Default::default(),
-    )
-    .expect("program is valid");
+    let program = assemble_source("100| STA TEMP1\n     STB TEMP2\n", Default::default())
+        .expect("program is valid");
     assert_eq!(
         program,
         Binary {
@@ -694,3 +691,68 @@ fn default_assigned_rc_word() {
         }
     );
 }
+
+#[test]
+fn default_assigned_index_register_easy_case() {
+    // See section 6-2.2 of the User Handbook for a description of how
+    // this is supposed to work.
+    //
+    // It states that for symexes used only in an index register
+    // context, the default assignment is, "The lowest numerical index
+    // register value not already used.  Except zero and no higher
+    // than 77."
+    //
+    // It's not clear what "not already used" really means.  For
+    // example, in this program:
+    //
+    // STAⱼ 0
+    // STAₖ 0
+    //
+    // It seems clear that j and k would be default-addiend to 1 and 2
+    // respectively.  But suppose instead that the program looked like
+    // this:
+    //
+    // STA₁ 0  ** USES INDEX REGISTER 1
+    // STAⱼ 0  ** SHOULD j BE DEFAULT ASSIGNED as 1 or 2?
+    //
+    // Here, index register 1 is used by the first instruction.  Does
+    // index register 1 count as used?
+    //
+    // This test uses the first program above.  IOW it doesn't assume
+    // any particular answer to the second question.
+    //
+    // But, if the intent was that we would avoid assigning j=1 in the
+    // case above, a somewhat legalistic interpretation would be that
+    // any use of hardware-specific sequence 65 (LW input) would cause
+    // the assembler to default-assign 66 (which is also a hardware
+    // device, LW output).  That doesn't seem very useful.
+    let program =
+        assemble_source("100|STAⱼ 0\nSTAₖ 0\n", Default::default()).expect("program is valid");
+    assert_eq!(
+        program,
+        Binary {
+            entry_point: None,
+            chunks: vec![BinaryChunk {
+                address: Address::from(u18!(0o100)),
+                words: vec![
+                    Instruction::from(&SymbolicInstruction {
+                        held: false,
+                        configuration: Unsigned5Bit::ZERO,
+                        opcode: Opcode::Sta,
+                        index: u6!(1), // j
+                        operand_address: OperandAddress::Direct(Address::from(Unsigned18Bit::ZERO)),
+                    })
+                    .bits(),
+                    Instruction::from(&SymbolicInstruction {
+                        held: false,
+                        configuration: Unsigned5Bit::ZERO,
+                        opcode: Opcode::Sta,
+                        index: u6!(2), // k
+                        operand_address: OperandAddress::Direct(Address::from(Unsigned18Bit::ZERO)),
+                    })
+                    .bits()
+                ]
+            }]
+        }
+    );
+}