round out spot assembler

.github/workflows/rust.yml

@@ -68,7 +68,6 @@ jobs:
  - name: Compress
  run: |
  mkdir -p ./artifacts
- CLI=("a2kit")
  SERVERS=("server-applesoft" "server-integerbasic" "server-merlin")
  if [[ $OS =~ ^windows.*$ ]]; then
  EXE=".exe"
@@ -80,18 +79,11 @@ jobs:
  else
  TAG=$GITHUB_SHA
  fi
- cli_list="completions"
- for i in ${CLI[@]}; do
- mv ./target/$TARGET/release/${i}$EXE ./${i}$EXE
- cli_list+=" ${i}$EXE"
- done
- tar -czf ./artifacts/a2kit-$TARGET-$TAG.tar.gz $cli_list
- server_list=""
+ mv ./target/$TARGET/release/a2kit$EXE ./a2kit$EXE
+ tar -czf ./artifacts/a2kit-$TARGET-$TAG.tar.gz completions a2kit$EXE
  for i in ${SERVERS[@]}; do
- mv ./target/$TARGET/release/${i}$EXE ./${i}$EXE
- server_list+=" ${i}$EXE"
+ mv ./target/$TARGET/release/${i}$EXE ./artifacts/${i}-${TARGET}$EXE
  done
- tar -czf ./artifacts/server-$TARGET-$TAG.tar.gz $server_list
  - name: Archive artifact
  uses: actions/upload-artifact@v4
  with:

completions/_a2kit

@@ -412,6 +412,7 @@ _arguments "${_arguments_options[@]}" : \
 '--assembler+[assembler variant]:NAME:(m8 m16 m16+ m32)' \
 '-w+[workspace directory]:PATH: ' \
 '--workspace+[workspace directory]:PATH: ' \
+'--literals[assign values to disassembled hex labels]' \
 '-h[Print help]' \
 '--help[Print help]' \
 && ret=0

completions/_a2kit.ps1

@@ -342,6 +342,7 @@ Register-ArgumentCompleter -Native -CommandName 'a2kit' -ScriptBlock {
  [CompletionResult]::new('--assembler', 'assembler', [CompletionResultType]::ParameterName, 'assembler variant')
  [CompletionResult]::new('-w', 'w', [CompletionResultType]::ParameterName, 'workspace directory')
  [CompletionResult]::new('--workspace', 'workspace', [CompletionResultType]::ParameterName, 'workspace directory')
+ [CompletionResult]::new('--literals', 'literals', [CompletionResultType]::ParameterName, 'assign values to disassembled hex labels')
  [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help')
  [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help')
  break

completions/a2kit.bash

@@ -192,7 +192,7 @@ _a2kit() {
  return 0
  ;;
  a2kit__asm)
- opts="-a -w -h --assembler --workspace --help"
+ opts="-a -w -h --assembler --workspace --literals --help"
  if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
  COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
  return 0

completions/a2kit.elv

@@ -311,6 +311,7 @@ set edit:completion:arg-completer[a2kit] = {|@words|
  cand --assembler 'assembler variant'
  cand -w 'workspace directory'
  cand --workspace 'workspace directory'
+ cand --literals 'assign values to disassembled hex labels'
  cand -h 'Print help'
  cand --help 'Print help'
  }

completions/a2kit.fish

@@ -163,6 +163,7 @@ complete -c a2kit -n "__fish_a2kit_using_subcommand dtok" -s t -l type -d 'type
 complete -c a2kit -n "__fish_a2kit_using_subcommand dtok" -s h -l help -d 'Print help'
 complete -c a2kit -n "__fish_a2kit_using_subcommand asm" -s a -l assembler -d 'assembler variant' -r -f -a "{m8\t'',m16\t'',m16+\t'',m32\t''}"
 complete -c a2kit -n "__fish_a2kit_using_subcommand asm" -s w -l workspace -d 'workspace directory' -r
+complete -c a2kit -n "__fish_a2kit_using_subcommand asm" -l literals -d 'assign values to disassembled hex labels'
 complete -c a2kit -n "__fish_a2kit_using_subcommand asm" -s h -l help -d 'Print help'
 complete -c a2kit -n "__fish_a2kit_using_subcommand dasm" -s p -l proc -d 'processor target' -r -f -a "{6502\t'',65c02\t'',65802\t'',65816\t''}"
 complete -c a2kit -n "__fish_a2kit_using_subcommand dasm" -l mx -d 'MX status bits' -r -f -a "{00\t'',01\t'',10\t'',11\t''}"

src/bin/server-merlin/request.rs

@@ -7,7 +7,7 @@ use serde_json;
 use std::collections::HashMap;
 use std::sync::Arc;
 use a2kit::lang::server::{Checkpoint, Tokens};
-use a2kit::lang::{normalize_client_uri,normalize_client_uri_str,disk_server};
+use a2kit::lang::{disk_server, merlin, normalize_client_uri, normalize_client_uri_str};
 use a2kit::lang::merlin::formatter;
 use a2kit::lang::merlin::disassembly::DasmRange;
 use a2kit::lang::merlin::ProcessorType;
@@ -235,8 +235,9 @@ pub fn handle_request(
  if let (Ok(program),Ok(uri),Ok(beg),Ok(end)) = (prog_res,uri_res,beg_res,end_res) {
  let normalized_uri = normalize_client_uri_str(&uri).expect("could not parse URI");
  if let Some(chk) = tools.doc_chkpts.get(&normalized_uri.to_string()) {
- tools.assembler.use_shared_symbols(chk.shared_symbols());
- resp = match tools.assembler.spot_assemble(program, beg, end) {
+ let dasm_symbols = merlin::assembly::Assembler::dasm_symbols(chk.shared_symbols());
+ tools.assembler.use_shared_symbols(Arc::new(dasm_symbols));
+ resp = match tools.assembler.spot_assemble(program, beg, end, None) {
  Ok(img) => {
  let dasm = tools.disassembler.disassemble_as_data(&img);
  lsp_server::Response::new_ok(req.id,dasm)

src/cli.rs

@@ -313,18 +313,18 @@ Detokenize from image: `a2kit get -f prog -t atok -d myimg.dsk | a2kit detokeniz
  main_cmd = main_cmd.subcommand(
  Command::new("tree")
  .arg(
- arg!(-d --dimg <PATH> "path to disk image")
+ Arg::new("dimg").short('d').long("dimg").help("path to disk image").value_name("PATH")
  .value_hint(ValueHint::FilePath)
  .required(false),
  )
- .arg(arg!(--meta "include metadata").action(ArgAction::SetTrue))
+ .arg(Arg::new("meta").long("meta").help("include metadata").action(ArgAction::SetTrue))
  .about("write directory tree as a JSON string to stdout")
  .after_help(IN_HELP),
  );
  main_cmd = main_cmd.subcommand(
  Command::new("stat")
  .arg(
- arg!(-d --dimg <PATH> "path to disk image")
+ Arg::new("dimg").short('d').long("dimg").help("path to disk image").value_name("PATH")
  .value_hint(ValueHint::FilePath)
  .required(false),
  )
@@ -334,7 +334,7 @@ Detokenize from image: `a2kit get -f prog -t atok -d myimg.dsk | a2kit detokeniz
  main_cmd = main_cmd.subcommand(
  Command::new("geometry")
  .arg(
- arg!(-d --dimg <PATH> "path to disk image")
+ Arg::new("dimg").short('d').long("dimg").help("path to disk image").value_name("PATH")
  .value_hint(ValueHint::FilePath)
  .required(false),
  )
@@ -377,6 +377,9 @@ Detokenize from image: `a2kit get -f prog -t atok -d myimg.dsk | a2kit detokeniz
  Arg::new("workspace").short('w').long("workspace").help("workspace directory").value_name("PATH")
  .required(false)
  )
+ .arg(
+ Arg::new("literals").long("literals").help("assign values to disassembled hex labels").action(ArgAction::SetTrue)
+ )
  .about("read from stdin, assemble, write to stdout")
  .after_help("At present this is limited, it will error out if program counter or symbol value cannot be determined.")
  );

src/lang/merlin/assembly.rs

@@ -1,11 +1,37 @@
-//! Assembler for any Merlin version.
+//! # Assembler for any Merlin version.
 //! 
-//! Currently we provide only "spot assembly," which is useful
-//! for overriding the disassembler's preference for code over data. This operates
-//! on lines where neither the program counter nor the symbol values are needed, and makes
-//! an assumption that labels of the form `_XXXX` are hex strings giving a literal address.
+//! Currently we provide only "spot assembly," which is useful for re-assembling sections
+//! of code as data after disassembly.
 //! 
-//! If assembly fails an error should be returned gracefully.
+//! The spot assembler is designed to work under conditions where the program counter and/or
+//! symbol information are not necessarily known, i.e., it will proceed as far as it can
+//! under these conditions. It will acquire the program counter from ORG or symbol data if possible.
+//! 
+//! ## Scope
+//! 
+//! The assembler handles the full 65816 instruction set. It handles all data and string pseudo-operations.
+//! It handles any valid Merlin expression, assuming symbol values can be resolved. It handles all Merlin
+//! prefix and suffix modifiers. It responds to the MX pseudo-operation based on processor target.
+//! 
+//! The following pseudo-operations are not handled and will yield an error:
+//! 
+//! * Includes (PUT, USE)
+//! * Macros (MAC, PMC, EOM)
+//! * Modules (REL, EXT, EXD, ENT)
+//! * Control (IF, DO, ELSE, FIN, LUP, --^, END, DUM, DEND, CHK, ERR)
+//! * Assignment (EQU, VAR)
+//! 
+//! The following pseudo-operations are silently ignored: AST, CAS, CYC, DSK, EXP, KBD, LST, LSTDO, OBJ, PAG, PAU, SAV, SKP, TR, TTL, TYP, XC.
+//! 
+//! ## Configuration and Symbols
+//! 
+//! The assembler can be configured using `set_config`, but `use_shared_symbols` is more important.
+//! In particular, the processor target and assembler variant are packaged within `merlin::Symbols`, and these
+//! will take precedence, since they reflect the configuration at the time the symbols were generated. For this
+//! reason XC is ignored.
+//! 
+//! If symbol values are available, the spot-assembler will use them. It does not calculate symbol values, but it does
+//! check them against the program counter.
 
 use std::sync::Arc;
 use super::settings::Settings;
@@ -17,7 +43,7 @@ use crate::lang::merlin::{Operation,ProcessorType};
 use crate::lang::{node_radix, node_text, Navigation, Navigate};
 use crate::{STDRESULT,DYNERR};
 
-const IGNORED_PSOPS: [&str;16] = ["ast", "cas", "cyc", "dsk", "exp", "kbd", "lst", "lstdo", "obj", "pag", "pau", "sav", "skp", "tr", "ttl", "typ"];
+const IGNORED_PSOPS: [&str;17] = ["ast", "cas", "cyc", "dsk", "exp", "kbd", "lst", "lstdo", "obj", "pag", "pau", "sav", "skp", "tr", "ttl", "typ", "xc"];
 
 /// closely parallels Merlin 8/16 error messages
 #[derive(Error,Debug)]
@@ -52,7 +78,7 @@ pub enum Error {
  ForwardRef,
  #[error("illegal relative address")]
  IllegalRelAddr,
- #[error("latest pass changed value")]
+ #[error("label value changed unexpectedly")]
  Misalignment,
  #[error("nesting too deep")]
  Nesting,
@@ -441,11 +467,26 @@ impl Assembler {
  self.code.append(&mut ans);
  Ok(())
  }
+ /// Assign values to labels with textual form `_XXXX...`, where X is a hex digit.
+ /// The text is assumed to give the value, as is the case after disassembly.
+ /// The returned symbols are generally turned into a new Arc pointer that is fed into the assembler.
+ pub fn dasm_symbols(symbols: Arc<Symbols>) -> Symbols {
+ let mut ans = symbols.as_ref().clone();
+ for (txt,sym) in &mut ans.globals {
+ if txt.starts_with("_") {
+ if let Ok(val) = u32::from_str_radix(&txt[1..], 16) {
+ sym.value = Some(val as i64);
+ }
+ }
+ }
+ ans
+ }
  /// Try to assemble lines in a circumstance where the symbol values and program counter
  /// are not necessarily known. The spot assembler will proceed as far as it can with
  /// whatever information is available, and error out if it hits something that cannot
  /// be handled (e.g. a relative branch with unknown PC).
- pub fn spot_assemble(&mut self, txt: String, beg: isize, end: isize) -> Result<Vec<u8>,DYNERR> {
+ pub fn spot_assemble(&mut self, txt: String, beg: isize, end: isize, pc: Option<usize>) -> Result<Vec<u8>,DYNERR> {
+ self.pc = pc;
  self.code = Vec::new();
  self.row = 0;
  for line in txt.lines() {
@@ -473,13 +514,38 @@ impl Assembler {
 
 impl Navigate for Assembler {
  fn visit(&mut self,curs: &tree_sitter::TreeCursor) -> Result<Navigation,DYNERR> {
- if ["macro_call","program_counter","comment","heading"].contains(&curs.node().kind()) {
+ if curs.node().kind() == "macro_call" {
+ log::error!("macro calls are not supported");
  return Err(Box::new(Error::CannotAssemble));
  }
  if curs.node().has_error() {
  return Err(Box::new(Error::Syntax));
  }
 
+ // If no program counter, initialize using the first label definition with a value.
+ // (this is useful for assembling data following disassembly)
+ // Check subsequent label definitions with values for misalignment.
+ if curs.node().kind()=="label_def" {
+ let txt = node_text(&curs.node(), &self.line);
+ if let Some(sym) = self.symbols.globals.get(&txt) {
+ if sym.flags & super::symbol_flags::EXT > 0 {
+ return Ok(Navigation::GotoSibling);
+ }
+ if let Some(val) = sym.value {
+ if let Some(pc) = self.pc {
+ if val != pc as i64 {
+ log::error!("label value is {} but PC is {}",val,pc);
+ return Err(Box::new(Error::Misalignment));
+ }
+ } else {
+ log::debug!("set program counter to {}",val);
+ self.pc = Some(usize::try_from(val)?);
+ }
+ }
+ return Ok(Navigation::GotoSibling);
+ }
+ }
+
  if curs.node().kind().starts_with("op_") {
  let txt = node_text(&curs.node(), &self.line);
  if let Some(op) = self.op_handbook.get(&txt) {
@@ -497,6 +563,9 @@ impl Navigate for Assembler {
  let src = self.code.pop().unwrap();
  self.code.push(dst);
  self.code.push(src);
+ if let Some(pc) = self.pc.as_mut() {
+ *pc += 3;
+ }
  return Ok(Navigation::Exit);
  }
  return Err(Box::new(Error::Syntax));
@@ -526,6 +595,9 @@ impl Navigate for Assembler {
  for mode in op.modes {
  if ["accum","impl","s"].contains(&mode.mnemonic.as_str()) {
  self.code.push(mode.code as u8);
+ if let Some(pc) = self.pc.as_mut() {
+ *pc += 1;
+ }
  return Ok(Navigation::Exit);
  }
  }
@@ -543,18 +615,36 @@ impl Navigate for Assembler {
  match arg.kind() {
  "arg_mx" => {
  if let Some(child) = arg.named_child(0) {
- // TODO: should we allow prefixes here?
  match self.eval_expr(&child,&self.line) {
  Ok(val) => {
  self.m8bit = val & 0b10 > 0;
  self.x8bit = val & 0b01 > 0;
+ if self.symbols.processor == ProcessorType::_6502 || self.symbols.processor == ProcessorType::_65c02 {
+ if !self.m8bit || !self.x8bit {
+ return Err(Box::new(Error::BadAddressMode))
+ }
+ }
  return Ok(Navigation::Exit); 
  },
  Err(e) => return Err(e)
  }
  }
  return Err(Box::new(Error::Syntax));
  },
+ "arg_org" => {
+ if self.code.len() > 0 {
+ return Err(Box::new(Error::BadOrg));
+ }
+ if let Some(child) = arg.named_child(0) {
+ match self.eval_expr(&child,&self.line) {
+ Ok(val) => {
+ log::debug!("set program counter to {}",val);
+ self.pc = Some(usize::try_from(val)?);
+ },
+ Err(e) => return Err(e)
+ }
+ }
+ },
  "arg_asc" => {
  if let Some(child) = arg.named_child(0) {
  if child.kind() == "num_str_prefix" {
@@ -631,6 +721,9 @@ impl Navigate for Assembler {
  "arg_hex" => {
  let txt = node_text(&arg, &self.line).replace(",","");
  let mut hex = hex::decode(&txt)?;
+ if let Some(pc) = self.pc.as_mut() {
+ *pc += hex.len();
+ }
  self.code.append(&mut hex);
  return Ok(Navigation::Exit);
  },
@@ -640,7 +733,15 @@ impl Navigate for Assembler {
  let mut maybe_reps: Option<usize> = None;
  while let Some(child) = iter.next() {
  if child.kind() == "new_page" {
- return Err(Box::new(Error::CannotAssemble));
+ if let Some(pc) = self.pc {
+ let page_boundary = 256 * (pc / 256 + 1);
+ if page_boundary - pc == 256 {
+ return Ok(Navigation::Exit);
+ }
+ maybe_reps = Some(page_boundary - pc);
+ } else {
+ return Err(Box::new(Error::UnresolvedProgramCounter));
+ }
  } else if child.kind() == "data" {
  let val = self.eval_data(&child, 1, false)?;
  if let Some(reps) = maybe_reps {
@@ -655,6 +756,11 @@ impl Navigate for Assembler {
  return Err(Box::new(Error::Syntax));
  }
  }
+ if arg.named_child_count() == 1 && maybe_reps.is_some() {
+ for _i in 0..maybe_reps.unwrap() {
+ self.push_data(0,1,false);
+ }
+ }
  return Ok(Navigation::Exit);
  }
  _ => return Err(Box::new(Error::CannotAssemble))

src/lang/merlin/diagnostics/labels.rs

@@ -316,7 +316,7 @@ pub fn visit_verify(curs: &TreeCursor, ctx: &mut Context, ws: &Workspace, symbol
  push(rng, "macro substitution variable referenced outside macro", lsp::DiagnosticSeverity::ERROR);
  } else if child.is_some() && node.kind()=="label_def" {
  let ck = child.unwrap().kind();
- if ck == "global_label" {
+ if ck == "global_label" && !in_macro {
  ctx.enter_scope(&txt,symbols);
  } else if ck=="local_label" {
  if let Some(next) = node.next_named_sibling() {