[assembler] Emit a pipe after an origin specification in the listing.

Author: youngman-g

assembler/src/asmlib/ast.rs

@@ -777,6 +777,14 @@ impl Ord for Origin {
             (Origin::Literal(_, _), Origin::Symbolic(_, _)) => Ordering::Less,
             (Origin::Symbolic(_, _), Origin::Literal(_, _)) => Ordering::Greater,
         }
+        .then_with(|| {
+            let my_span = self.span();
+            let their_span = other.span();
+            my_span
+                .start
+                .cmp(&their_span.start)
+                .then_with(|| my_span.end.cmp(&their_span.end))
+        })
     }
 }
 

assembler/src/asmlib/driver.rs

@@ -473,7 +473,6 @@ fn assemble_pass3(
             // tag (6-2.2).
             let span = origin.span();
             listing.push_line(ListingLine {
-                origin: Some(origin),
                 span: Some(span),
                 rc_source: None,
                 content: None,
@@ -511,7 +510,6 @@ fn assemble_pass3(
             );
 
             listing.push_rc_line(ListingLine {
-                origin: None,
                 span: None,
                 rc_source: Some(rc_source.clone()),
                 content: Some((address, *word)),

assembler/src/asmlib/eval.rs

@@ -752,7 +752,6 @@ impl InstructionSequence {
             match instruction.evaluate(&here, symtab, rc_updater, &mut op) {
                 Ok(word) => {
                     listing.push_line(ListingLine {
-                        origin: None,
                         span: Some(instruction.span),
                         rc_source: None,
                         content: Some((address, word)),

assembler/src/asmlib/listing.rs

@@ -1,6 +1,5 @@
 use std::fmt::Display;
 
-use super::ast::Origin;
 use super::span::Span;
 use super::span::{extract_prefix, extract_span};
 use super::symtab::FinalSymbolTable;
@@ -34,7 +33,6 @@ impl Listing {
 
 #[derive(Debug)]
 pub(super) struct ListingLine {
-    pub(super) origin: Option<Origin>,
     pub(super) span: Option<Span>,
     pub(super) rc_source: Option<RcWordSource>,
     pub(super) content: Option<(Address, Unsigned36Bit)>,
@@ -56,10 +54,6 @@ fn write_address(f: &mut std::fmt::Formatter<'_>, addr: &Address) -> std::fmt::R
 
 impl Display for ListingLineWithBody<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if let Some(origin) = self.line.origin.as_ref() {
-            writeln!(f, "{origin}| ** origin")?;
-        }
-
         match self.line.rc_source.as_ref() {
             Some(RcWordSource::DefaultAssignment(_, name)) => {
                 write!(f, "{name:10}-> ")?;

assembler/src/asmlib/parser.rs

@@ -1246,6 +1246,7 @@ where
                 I: Input<'a, Token = Tok, Span = Span> + ValueInput<'a>,
             {
                 literal(Script::Normal)
+                    .then_ignore(just(Tok::Pipe(Script::Normal)))
                     .try_map(|lit, span| match Address::try_from(lit.value()) {
                         Ok(addr) => Ok(Origin::Literal(span, addr)),
                         Err(e) => Err(Rich::custom(span, format!("not a valid address: {e}"))),
@@ -1259,14 +1260,14 @@ where
                 I: Input<'a, Token = Tok, Span = Span> + ValueInput<'a>,
             {
                 named_symbol(SymexSyllableRule::Multiple, Script::Normal)
+                    .then_ignore(just(Tok::Pipe(Script::Normal)))
                     .map_with(|name, extra| Origin::Symbolic(extra.span(), name))
                     .labelled("symbolic address expression")
             }
 
             // An origin specification is an expression followed by a
             // (normal-case) pipe symbol.
             choice((literal_address_expression(), symbolic_address_expression()))
-                .then_ignore(just(Tok::Pipe(Script::Normal)))
                 .labelled("origin specification")
         }
 

assembler/src/asmlib/parser/tests.rs

@@ -790,7 +790,7 @@ fn test_manuscript_with_origin() {
         SourceFile {
             punch: None,
             blocks: vec![ManuscriptBlock {
-                origin: Some(Origin::Literal(span(0..3), Address::new(u18!(0o100)))),
+                origin: Some(Origin::Literal(span(0..5), Address::new(u18!(0o100)))),
                 statements: vec![TaggedProgramInstruction::single(
                     notags(),
                     HoldBit::Unspecified,
@@ -1172,7 +1172,7 @@ fn test_assignment_origin() {
         SourceFile {
             punch: None,
             blocks: vec![ManuscriptBlock {
-                origin: Some(Origin::Literal(span(9..13), Address::new(u18!(0o1000)))),
+                origin: Some(Origin::Literal(span(9..14), Address::new(u18!(0o1000)))),
                 statements: vec![TaggedProgramInstruction::single(
                     Vec::new(),
                     HoldBit::Unspecified,
@@ -1192,6 +1192,35 @@ fn test_assignment_origin() {
     );
 }
 
+#[test]
+fn test_symbolic_origin() {
+    const INPUT: &str = concat!("BEGIN|2\n",);
+    let tree = parse_successfully_with(INPUT, source_file(), no_state_setup);
+    assert_eq!(
+        tree,
+        SourceFile {
+            punch: None,
+            blocks: vec![ManuscriptBlock {
+                // One of the key things to check here is that the pipe
+                // symbol is included in the origin's span.  We do
+                // this in order to include the pipe symbol in the
+                // output listing.
+                origin: Some(Origin::Symbolic(span(0..6), SymbolName::from("BEGIN"))),
+                statements: vec![TaggedProgramInstruction::single(
+                    Vec::new(),
+                    HoldBit::Unspecified,
+                    span(6..7),
+                    span(6..7),
+                    InstructionFragment::from((span(6..7), Script::Normal, u36!(2),))
+                )]
+                .into(),
+            }],
+            equalities: Default::default(),
+            macros: Default::default(),
+        }
+    );
+}
+
 #[test]
 fn test_metacommand_decimal() {
     assert_eq!(