[assembler] Support double-pipe symbol configuration values.

Author: youngman-g

assembler/src/asmlib/ast.rs

@@ -265,6 +265,53 @@ impl Evaluate for ArithmeticExpression {
     }
 }
 
+/// A configuration syllable can be specified by putting it in a
+/// superscript, or by putting it in normal script after a ‖ symbol
+/// (‖x or ‖2, for example).  This is described in section 6-2.1 of
+/// the Users Handbook.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) enum ConfigValue {
+    Literal(Span, Unsigned36Bit),
+    Symbol(Span, SymbolName),
+}
+
+impl ConfigValue {
+    pub(crate) fn symbol_uses(&self) -> impl Iterator<Item = (SymbolName, Span, SymbolUse)> {
+        match self {
+            ConfigValue::Literal(_span, _value) => None,
+            ConfigValue::Symbol(span, name) => Some((
+                name.to_owned(),
+                *span,
+                SymbolUse::Reference(SymbolContext::configuration()),
+            )),
+        }
+        .into_iter()
+    }
+}
+
+impl Evaluate for ConfigValue {
+    fn evaluate<R: RcAllocator>(
+        &self,
+        target_address: &HereValue,
+        symtab: &mut SymbolTable,
+        rc_allocator: &mut R,
+        op: &mut LookupOperation,
+    ) -> Result<Unsigned36Bit, SymbolLookupFailure> {
+        match self {
+            ConfigValue::Literal(_span, value) => Ok(*value),
+            ConfigValue::Symbol(span, name) => {
+                let context = SymbolContext::configuration();
+                match symtab.lookup_with_op(name, *span, target_address, rc_allocator, &context, op)
+                {
+                    Ok(SymbolValue::Final(value)) => Ok(value),
+                    Err(e) => Err(e),
+                }
+            }
+        }
+        .map(|value| value.shl(30u32))
+    }
+}
+
 /// Eventually we will support real expressions, but for now we only
 /// suport literals and references to symbols ("equalities" in the
 /// User Handbook).
@@ -396,8 +443,9 @@ pub(crate) enum InstructionFragment {
     /// allows them in subscript/superscript too.
     Arithmetic(ArithmeticExpression),
     DeferredAddressing,
-    // TODO: subscript/superscript atom (if the `Arithmetic` variant
-    // disallows subscript/superscript).
+    Config(ConfigValue), // some configuration values are specified as Arithmetic variants.
+                         // TODO: subscript/superscript atom (if the `Arithmetic` variant
+                         // disallows subscript/superscript).
 }
 
 impl InstructionFragment {
@@ -408,6 +456,9 @@ impl InstructionFragment {
                 result.extend(expr.symbol_uses());
             }
             InstructionFragment::DeferredAddressing => (),
+            InstructionFragment::Config(value) => {
+                result.extend(value.symbol_uses());
+            }
         }
         result.into_iter()
     }
@@ -426,6 +477,9 @@ impl Evaluate for InstructionFragment {
                 expr.evaluate(target_address, symtab, rc_allocator, op)
             }
             InstructionFragment::DeferredAddressing => Ok(DEFER_BIT),
+            InstructionFragment::Config(value) => {
+                value.evaluate(target_address, symtab, rc_allocator, op)
+            }
         }
     }
 }

assembler/src/asmlib/driver.rs

@@ -663,7 +663,11 @@ fn assemble_pass3(
         };
     }
 
-    final_symbols.check_all_defined(&*symtab);
+    // The evaluation process will have resulted in the computation of
+    // a default definition for any symbols which were not already
+    // inserted into final_symbols, so we make sure those are inserted
+    // now.
+    final_symbols.import_all_defined(&*symtab);
 
     Ok((binary, final_symbols))
 }

assembler/src/asmlib/driver/tests.rs

@@ -401,3 +401,27 @@ fn test_division_overflow_on_constants() {
         assemble_source("100| 1 / 777777777777\n", Default::default()).expect("program is valid");
     assert_eq!(program.chunks[0].words[0], u36!(0o1)); // 1
 }
+
+#[test]
+fn test_double_pipe_config_literal_correctly_shifted() {
+    // The 6 here is not superscript but it should be shifted into the
+    // configuration part of the assembled word, because the '‖'
+    // symbol introduces a configuration syllable.
+    let input = "‖6\n";
+    let program = assemble_source(input, Default::default()).expect("program is valid");
+    assert_eq!(program.chunks[0].words[0], u36!(0o6).shl(30));
+}
+
+#[test]
+fn test_double_pipe_config_symbolic_default_assignment() {
+    // Section 6-2.2 "SYMEX DEFINITON - TAGS - EQUALITIES - AUTOMATIC
+    // ASSIGNMENT" of the Users Handbook states that a symex used only
+    // as a configuration value which has no defintiion will be
+    // automatically assigned as zero.
+    //
+    // In our example here, the 42 octal should go in the address part
+    // of the word.
+    let input = "‖X 42\n";
+    let program = assemble_source(input, Default::default()).expect("program is valid");
+    assert_eq!(program.chunks[0].words[0], u36!(0o42));
+}

assembler/src/asmlib/eval.rs

@@ -223,6 +223,13 @@ impl SymbolContext {
         ]
     }
 
+    pub(crate) fn configuration() -> SymbolContext {
+        SymbolContext {
+            configuration: true,
+            ..Default::default()
+        }
+    }
+
     fn uses(span: Span) -> BTreeSet<OrderableSpan> {
         [OrderableSpan(span)].into_iter().collect()
     }

assembler/src/asmlib/lexer.rs

@@ -119,6 +119,7 @@ pub(crate) enum Token {
     Asterisk(Script),
 
     Pipe(Script),
+    DoublePipe(Script),
     ProperSuperset(Script),
     SubsetOf(Script),
     IdenticalTo(Script),
@@ -192,8 +193,9 @@ impl Display for Token {
             Token::Hash(script) => write_elevated(script, "#"),
             Token::Equals(script) => write_elevated(script, "="),
             Token::Pipe(script) => write_elevated(script, "|"),
+            Token::DoublePipe(script) => write_elevated(script, "‖"), // U+2016
             Token::ProperSuperset(script) => write_elevated(script, "⊃"), // U+2283
-            Token::SubsetOf(script) => write_elevated(script, "⊂"),       // U+2282
+            Token::SubsetOf(script) => write_elevated(script, "⊂"),   // U+2282
             Token::IdenticalTo(script) => write_elevated(script, "≡"),
             Token::Tilde(script) => write_elevated(script, "~"),
             Token::LessThan(script) => write_elevated(script, "<"),
@@ -478,9 +480,7 @@ fn tokenise_single_glyph(g: Elevated<&'static Glyph>) -> Option<Token> {
             todo!("Sigma (which is a symex terminator) does not yet have a token")
         }
         GlyphShape::Pipe => Some(Token::Pipe(script)),
-        GlyphShape::DoublePipe => {
-            todo!("double-pipe (which is a symex terminator) does not yet have a token")
-        }
+        GlyphShape::DoublePipe => Some(Token::DoublePipe(script)),
         GlyphShape::Solidus => Some(Token::Solidus(script)),
         GlyphShape::Times => Some(Token::Times(script)),
         GlyphShape::Hash => Some(Token::Hash(script)),

assembler/src/asmlib/parser.rs

@@ -212,6 +212,27 @@ where
     .labelled("arithmetic operator")
 }
 
+fn doublepipe_config_value<'a, I>() -> impl Parser<'a, I, InstructionFragment, Extra<'a>> + Clone
+where
+    I: Input<'a, Token = Tok, Span = Span> + ValueInput<'a>,
+{
+    // Spaces are not allowed within configuration values, so we only
+    // accept one symex syllable here.
+    let symbolic_config_value = symex::symex_syllable(Script::Normal)
+        .map_with(|name, extra| ConfigValue::Symbol(extra.span(), SymbolName::from(name)));
+    // The numeric literal of a config value must be in normal script,
+    // so ConfigValue::Literal directly contains an Unsigned36Bit
+    // value instead of using the LiteralValue type.
+    let literal_config_value = literal(Script::Normal)
+        .map_with(|literal, extra| ConfigValue::Literal(extra.span(), literal.value()));
+
+    // We try to parse the config syllable as a literal first, because
+    // symexes can also contain (and start with) digits.
+    just(Tok::DoublePipe(Script::Normal))
+        .ignore_then(choice((literal_config_value, symbolic_config_value)))
+        .map(|config| InstructionFragment::Config(config))
+}
+
 fn program_instruction_fragments<'srcbody, I>(
 ) -> impl Parser<'srcbody, I, Vec<InstructionFragment>, Extra<'srcbody>>
 where
@@ -292,6 +313,7 @@ where
             single_script_fragment(Script::Super),
             single_script_fragment(Script::Sub),
             just(Tok::Asterisk(Script::Normal)).to(InstructionFragment::DeferredAddressing),
+            doublepipe_config_value(),
         ))
         .repeated()
         .at_least(1)

assembler/src/asmlib/parser/tests.rs

@@ -1569,3 +1569,57 @@ fn test_asterisk_for_deferred_addressing() {
         ]
     );
 }
+
+#[test]
+fn test_double_pipe_config_symbolic() {
+    // The input "‖4" sets the configuration syllable of the
+    // instruction word to 4.  This is described in section 6-2.1 of
+    // the Users Handbook.  Spaces are not allowed in the
+    // configuration syllable, so "‖X Y" should be parsed as a
+    // configuration syllable X followed by the symbolic value Y
+    // (which would therefore go into the address portion of the
+    // instruction word).
+    let input_xy = "‖X Y";
+    let got = parse_successfully_with(input_xy, tagged_program_instruction(), no_state_setup);
+    let expected = TaggedProgramInstruction {
+        tag: None,
+        instruction: UntaggedProgramInstruction {
+            span: span(0..6),
+            holdbit: HoldBit::Unspecified,
+            parts: vec![
+                InstructionFragment::Config(ConfigValue::Symbol(
+                    span(3..4),
+                    SymbolName {
+                        canonical: "X".to_string(),
+                    },
+                )),
+                InstructionFragment::Arithmetic(ArithmeticExpression::from(Atom::Symbol(
+                    span(5..6),
+                    Script::Normal,
+                    SymbolName {
+                        canonical: "Y".to_string(),
+                    },
+                ))),
+            ],
+        },
+    };
+    assert_eq!(got, expected);
+}
+
+#[test]
+fn test_double_pipe_config_literal() {
+    let input = "‖10"; // 10 octal = 8 decimal.
+    let got = parse_successfully_with(input, tagged_program_instruction(), no_state_setup);
+    let expected = TaggedProgramInstruction {
+        tag: None,
+        instruction: UntaggedProgramInstruction {
+            span: span(0..5),
+            holdbit: HoldBit::Unspecified,
+            parts: vec![InstructionFragment::Config(ConfigValue::Literal(
+                span(3..5),
+                u36!(8),
+            ))],
+        },
+    };
+    assert_eq!(got, expected);
+}

assembler/src/asmlib/symtab.rs

@@ -246,8 +246,21 @@ impl SymbolTable {
                             .map(SymbolValue::Final)
                     }
                     SymbolDefinition::Undefined(context_union) => {
-                        match t.get_default_value(name, &span, &context_union) {
-                            Ok(value) => Ok(SymbolValue::Final(value)),
+                        dbg!(&name);
+                        match dbg!(t.get_default_value(name, &span, &context_union)) {
+                            Ok(value) => {
+                                eprintln!("now that a default value {value} has been assigned for {name}, we will insert this into the symbol table.");
+                                match t.define(
+                                    span,
+                                    name.clone(),
+                                    SymbolDefinition::DefaultAssigned(value, context_union),
+                                ) {
+                                    Err(e) => {
+                                        panic!("got a bad symbol definition error ({e}) on a previously undefined symbol, which should be impossible");
+                                    }
+                                    Ok(()) => Ok(SymbolValue::Final(value)),
+                                }
+                            }
                             Err(e) => Err(e),
                         }
                     }
@@ -495,6 +508,7 @@ impl SymbolLookup for SymbolTable {
 pub(crate) enum FinalSymbolType {
     Tag,
     Equality,
+    Default,
 }
 
 #[derive(Debug)]
@@ -532,12 +546,26 @@ impl FinalSymbolTable {
         self.definitions.entry(name).or_insert(def);
     }
 
-    pub(crate) fn check_all_defined(&self, symtab: &SymbolTable) {
-        for (name, definition) in symtab.definitions.iter() {
-            if !self.definitions.contains_key(name) {
-                panic!("symbol {name} appears in symbol table with definition {definition:?} but was not finalised in the final symbol table");
+    pub(crate) fn import_all_defined(&mut self, symtab: &SymbolTable) {
+        fn make_final_def(name: &SymbolName, def: &SymbolDefinition) -> FinalSymbolDefinition {
+            match def {
+                SymbolDefinition::DefaultAssigned(value, _context) => FinalSymbolDefinition {
+                    value: *value,
+                    representation: value.to_string(),
+                    sym_type: FinalSymbolType::Default,
+                },
+                SymbolDefinition::Undefined(_symbol_context) => unreachable!(),
+                _ => unimplemented!(
+                    "symbol table entry for {name} (with definition {def:?}) had not been copied into the final symbol table"
+                ),
             }
         }
+
+        for (name, definition) in symtab.definitions.iter() {
+            self.definitions
+                .entry(name.clone())
+                .or_insert_with(|| make_final_def(name, &definition.def));
+        }
     }
 }