[assembler] Allow # in more symbolic contexts.

Section 6-2.8 explicitly describes '#' as a "special symex", so we now
allow this in more contexts where a symex is expected.  However, we
still do not allow it in some other contexts, such as origin and tag
definitions.

Author: youngman-g

assembler/src/asmlib/ast.rs

@@ -17,7 +17,7 @@ use crate::symtab::{LookupOperation, RcAllocator, RcBlock};
 use super::eval::{Evaluate, SymbolContext, SymbolDefinition, SymbolLookup, SymbolUse};
 use super::glyph;
 use super::state::NumeralMode;
-use super::symbol::SymbolName;
+use super::symbol::{SymbolName, SymbolOrHere};
 use super::symtab::SymbolTable;
 use super::types::{
     offset_from_origin, AssemblerFailure, BlockIdentifier, MachineLimitExceededFailure, Span,
@@ -36,6 +36,10 @@ impl LiteralValue {
         self.value << self.elevation.shift()
     }
 
+    pub(crate) fn unshifted_value(&self) -> Unsigned36Bit {
+        self.value
+    }
+
     #[cfg(test)]
     pub(crate) fn span(&self) -> &Span {
         &self.span
@@ -272,14 +276,15 @@ impl Evaluate for ArithmeticExpression {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum ConfigValue {
     Literal(Span, Unsigned36Bit),
-    Symbol(Span, SymbolName),
+    Symbol(Span, SymbolOrHere),
 }
 
 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((
+            ConfigValue::Symbol(_span, SymbolOrHere::Here) => None,
+            ConfigValue::Symbol(span, SymbolOrHere::Named(name)) => Some((
                 name.to_owned(),
                 *span,
                 SymbolUse::Reference(SymbolContext::configuration()),
@@ -299,7 +304,10 @@ impl Evaluate for ConfigValue {
     ) -> Result<Unsigned36Bit, SymbolLookupFailure> {
         match self {
             ConfigValue::Literal(_span, value) => Ok(*value),
-            ConfigValue::Symbol(span, name) => {
+            ConfigValue::Symbol(span, SymbolOrHere::Here) => {
+                Ok(Unsigned36Bit::from(target_address.get_address(span)?))
+            }
+            ConfigValue::Symbol(span, SymbolOrHere::Named(name)) => {
                 let context = SymbolContext::configuration();
                 match symtab.lookup_with_op(name, *span, target_address, rc_allocator, &context, op)
                 {
@@ -318,8 +326,7 @@ impl Evaluate for ConfigValue {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum Atom {
     Literal(LiteralValue),
-    Symbol(Span, Script, SymbolName),
-    Here(Script), // the special symbol '#'.
+    Symbol(Span, Script, SymbolOrHere),
     Parens(Script, Box<ArithmeticExpression>),
     RcRef(Span, Vec<InstructionFragment>),
 }
@@ -328,10 +335,10 @@ impl Atom {
     pub(crate) fn symbol_uses(&self) -> impl Iterator<Item = (SymbolName, Span, SymbolUse)> {
         let mut result = Vec::with_capacity(1);
         match self {
-            Atom::Literal(_) | Atom::Here(_) | Atom::RcRef(_, _) => (),
-            Atom::Symbol(span, script, symbol_name) => {
+            Atom::Literal(_) | Atom::RcRef(_, _) | Atom::Symbol(_, _, SymbolOrHere::Here) => (),
+            Atom::Symbol(span, script, SymbolOrHere::Named(name)) => {
                 result.push((
-                    symbol_name.clone(),
+                    name.clone(),
                     *span,
                     SymbolUse::Reference(SymbolContext::from((script, *span))),
                 ));
@@ -353,17 +360,12 @@ impl Evaluate for Atom {
         op: &mut LookupOperation,
     ) -> Result<Unsigned36Bit, SymbolLookupFailure> {
         match self {
-            Atom::Here(elevation) => match target_address {
-                HereValue::Address(addr) => {
-                    let value: Unsigned36Bit = (*addr).into();
-                    Ok(value.shl(elevation.shift()))
-                }
-                HereValue::NotAllowed => {
-                    todo!("# is not allowed in origins")
-                }
-            },
+            Atom::Symbol(span, elevation, SymbolOrHere::Here) => {
+                let value: Unsigned36Bit = target_address.get_address(span)?.into();
+                Ok(value.shl(elevation.shift()))
+            }
             Atom::Literal(literal) => Ok(literal.value()),
-            Atom::Symbol(span, elevation, name) => {
+            Atom::Symbol(span, elevation, SymbolOrHere::Named(name)) => {
                 let context = SymbolContext::from((elevation, *span));
                 match symtab.lookup_with_op(name, *span, target_address, rc_allocator, &context, op)
                 {
@@ -419,11 +421,13 @@ fn elevated_string<'a>(s: &'a str, elevation: &Script) -> Cow<'a, str> {
 impl std::fmt::Display for Atom {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
-            Atom::Here(Script::Super) => f.write_str("@super_hash@"),
-            Atom::Here(Script::Normal) => f.write_char('#'),
-            Atom::Here(Script::Sub) => f.write_str("@sub_hash@"),
+            Atom::Symbol(_span, elevation, SymbolOrHere::Here) => match elevation {
+                Script::Super => f.write_str("@super_hash@"),
+                Script::Normal => f.write_char('#'),
+                Script::Sub => f.write_str("@sub_hash@"),
+            },
             Atom::Literal(value) => value.fmt(f),
-            Atom::Symbol(_span, elevation, name) => {
+            Atom::Symbol(_span, elevation, SymbolOrHere::Named(name)) => {
                 elevated_string(&name.to_string(), elevation).fmt(f)
             }
             Atom::Parens(script, expr) => elevated_string(&expr.to_string(), script).fmt(f),

assembler/src/asmlib/driver/tests.rs

@@ -4,8 +4,8 @@ use std::{
 };
 
 use super::super::ast::{
-    ArithmeticExpression, Atom, HoldBit, InstructionFragment, LiteralValue, LocatedBlock,
-    ManuscriptBlock, PunchCommand, SourceFile, Statement, TaggedProgramInstruction,
+    ArithmeticExpression, Atom, ConfigValue, HoldBit, InstructionFragment, LiteralValue,
+    LocatedBlock, ManuscriptBlock, PunchCommand, SourceFile, Statement, TaggedProgramInstruction,
     UntaggedProgramInstruction,
 };
 use super::super::eval::{SymbolContext, SymbolLookup, SymbolValue};
@@ -209,7 +209,7 @@ fn test_metacommand_dec_changes_default_base() {
 fn test_assemble_octal_superscript_literal() {
     assemble_literal(
         "⁺³⁶\n", // 36, superscript
-        &InstructionFragment::from((span(0..8), Script::Super, Unsigned36Bit::from(0o36_u32))),
+        &InstructionFragment::Config(ConfigValue::Literal(span(0..8), u36!(0o36))),
     );
 }
 
@@ -257,10 +257,15 @@ fn test_normal_hash_value() {
 
 #[test]
 fn test_super_hash_value() {
-    let program =
-        assemble_source(concat!("1| @sup_hash@\n",), Default::default()).expect("program is valid");
+    let input = "1| @sup_hash@\n";
+    let program = assemble_source(input, Default::default()).expect("program is valid");
     assert_eq!(program.chunks[0].address, Address::from(u18!(0o1)));
-    assert_eq!(program.chunks[0].words[0], u36!(1).shl(30));
+    let got = program.chunks[0].words[0];
+    let expected = u36!(1).shl(30);
+    assert_eq!(
+        got, expected,
+        "input '{input}' assembled to {got} but we expected {expected}"
+    );
 }
 
 #[test]

assembler/src/asmlib/eval.rs

@@ -1,5 +1,5 @@
 use std::collections::BTreeSet;
-use std::fmt::{self, Debug, Display, Formatter};
+use std::fmt::{self, Debug, Display, Formatter, Write};
 
 use base::{
     charset::Script,
@@ -12,13 +12,16 @@ use super::ast::UntaggedProgramInstruction;
 use super::symbol::SymbolName;
 use super::symtab::RcAllocator;
 use super::types::{
-    AssemblerFailure, BlockIdentifier, MachineLimitExceededFailure, OrderableSpan, Span,
+    AssemblerFailure, BlockIdentifier, LineAndColumn, MachineLimitExceededFailure, OrderableSpan,
+    Span,
 };
 
 #[derive(Debug, PartialEq, Eq)]
 pub(crate) enum LookupTarget {
     Symbol(SymbolName, Span),
     MemRef(MemoryReference, Span),
+    /// Attempt to look up "here", that is, '#'.
+    Hash(Span),
 }
 
 impl From<(SymbolName, Span)> for LookupTarget {
@@ -36,14 +39,17 @@ impl From<(MemoryReference, Span)> for LookupTarget {
 impl LookupTarget {
     fn span(&self) -> &Span {
         match self {
-            LookupTarget::Symbol(_, span) | LookupTarget::MemRef(_, span) => span,
+            LookupTarget::Hash(span)
+            | LookupTarget::Symbol(_, span)
+            | LookupTarget::MemRef(_, span) => span,
         }
     }
 }
 
 impl Display for LookupTarget {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), fmt::Error> {
         match self {
+            LookupTarget::Hash(_) => f.write_char('#'),
             LookupTarget::Symbol(name, _) => {
                 write!(f, "symbol {name}")
             }
@@ -82,6 +88,7 @@ pub(crate) enum SymbolLookupFailureKind {
     Inconsistent(String),
     Loop { deps_in_order: Vec<SymbolName> },
     MachineLimitExceeded(MachineLimitExceededFailure),
+    HereIsNotAllowedHere,
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -106,34 +113,42 @@ impl Display for SymbolLookupFailure {
             SymbolLookupFailureKind::MachineLimitExceeded(fail) => {
                 write!(f, "machine limit exceeded: {fail}")
             }
+            SymbolLookupFailureKind::HereIsNotAllowedHere => {
+                f.write_str("'#' (representing the current address) is not allowed here")
+            }
         }
     }
 }
 
-impl From<SymbolLookupFailure> for AssemblerFailure {
-    fn from(f: SymbolLookupFailure) -> AssemblerFailure {
-        let symbol_desc: String = f.target.to_string();
-        let span: Span = *f.target.span();
-        match f.kind {
-            SymbolLookupFailureKind::MachineLimitExceeded(limit_exceeded) => {
-                AssemblerFailure::MachineLimitExceeded(limit_exceeded)
-            }
-            SymbolLookupFailureKind::Loop { deps_in_order } => {
-                let chain: String = deps_in_order
-                    .iter()
-                    .map(|dep| dep.to_string())
-                    .collect::<Vec<_>>()
-                    .join("->");
-                AssemblerFailure::InvalidProgram {
-                    span,
-                    msg: format!("definition of {symbol_desc} has a dependency loop ({chain})",),
-                }
-            }
-            SymbolLookupFailureKind::Inconsistent(msg) => AssemblerFailure::InvalidProgram {
+fn convert_symbol_lookup_failure_to_assembler_failure(
+    f: SymbolLookupFailure,
+    source_file_body: &str,
+) -> AssemblerFailure {
+    let symbol_desc: String = f.target.to_string();
+    let span: Span = *f.target.span();
+    match f.kind {
+        SymbolLookupFailureKind::HereIsNotAllowedHere => AssemblerFailure::SyntaxError {
+            location: LineAndColumn::from((source_file_body, &span)),
+            msg: f.to_string(),
+        },
+        SymbolLookupFailureKind::MachineLimitExceeded(limit_exceeded) => {
+            AssemblerFailure::MachineLimitExceeded(limit_exceeded)
+        }
+        SymbolLookupFailureKind::Loop { deps_in_order } => {
+            let chain: String = deps_in_order
+                .iter()
+                .map(|dep| dep.to_string())
+                .collect::<Vec<_>>()
+                .join("->");
+            AssemblerFailure::InvalidProgram {
                 span,
-                msg: format!("program is inconsistent: {msg}",),
-            },
+                msg: format!("definition of {symbol_desc} has a dependency loop ({chain})",),
+            }
         }
+        SymbolLookupFailureKind::Inconsistent(msg) => AssemblerFailure::InvalidProgram {
+            span,
+            msg: format!("program is inconsistent: {msg}",),
+        },
     }
 }
 
@@ -180,6 +195,18 @@ pub(crate) enum HereValue {
     NotAllowed,
 }
 
+impl HereValue {
+    pub(crate) fn get_address(&self, span: &Span) -> Result<Address, SymbolLookupFailure> {
+        match self {
+            HereValue::Address(addr) => Ok(*addr),
+            HereValue::NotAllowed => Err(SymbolLookupFailure {
+                target: LookupTarget::Hash(*span),
+                kind: SymbolLookupFailureKind::HereIsNotAllowedHere,
+            }),
+        }
+    }
+}
+
 pub(crate) trait Evaluate {
     fn evaluate<R: RcAllocator>(
         &self,