BASIC workspaces

Author: dfgordon

CHANGELOG.md

@@ -5,6 +5,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [4.3.0] - 2026-03-15
+
+### Fixes
+
+* smart copy fixes
+    - reconcile CP/M and Windows (`:` and `_` swapping)
+    - path parsing is a little smarter
+    - suppress a misleading warning
+* REM following ONERR GOTO no longer hangs the Applesoft server
+* move lines no longer adds new-lines to the end unnecessarily
+* where possible, line labels are gathered even if there is an error on the line
+
+### New Features
+
+* Applesoft and Integer BASIC expression evaluation
+* Workspace scan for Applesoft and Integer BASIC
+    - detects DOS or ProDOS CHAIN commands
+    - identifies CHAIN links between files
+    - analysis accounts for chained variables
+
 ## [4.2.0] - 2026-02-15
 
 ### Fixes

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "a2kit"
-version = "4.2.0"
+version = "4.3.0"
 edition = "2024"
 readme = "README.md"
 license = "MIT"

README.md

@@ -5,12 +5,13 @@ Command line interface and library for retro disk images, file systems, and lang
 * Designed to be scriptable
 * Language Servers - Applesoft, Integer BASIC, Merlin Assembly
     - deep analysis, tokenization, disassembly, adheres to [LSP](https://microsoft.github.io/language-server-protocol/)
-* File Systems - Apple DOS 3.2, Apple DOS 3.3, ProDOS, CP/M, Pascal, FAT (such as MS-DOS)
+* File Systems - Apple DOS 3.2, Apple DOS 3.3, ProDOS, CP/M, UCSD Pascal, FAT (such as MS-DOS)
     - full read and write access
-    - high or low level manipulations
-    - interface for handling sparse and random access files
+    - preservation of sparse structure
+    - conversion of source files to and from legacy formats
 * Disk Images - 2MG, D13, DO, DSK, IMD, IMG, NIB, PO, TD0, WOZ
     - create, read, and write with all types
+    - handles proprietary soft sector formats
 
 ## Documentation
 

src/bin/server-applesoft/main.rs

@@ -3,7 +3,7 @@
 //! Cargo will compile this to a standalone executable.
 //! 
 //! The a2kit library crate provides most of the analysis.
-//! The server activity is all in this file.
+//! The server activity is all in this module.
 
 use lsp_types as lsp;
 use lsp::{notification::Notification, request::Request};
@@ -14,9 +14,10 @@ use std::collections::VecDeque;
 use std::error::Error;
 use std::sync::{Arc,Mutex};
 use a2kit::lang::server::TOKEN_TYPES; // used if we register tokens on server side
-use a2kit::lang::server::Analysis;
+use a2kit::lang::server::{Analysis,Checkpoint};
 use a2kit::lang::applesoft;
 use a2kit::lang::applesoft::diagnostics::Analyzer;
+use a2kit::lang::applesoft::checkpoint::CheckpointManager;
 use a2kit::lang::disk_server::DiskServer;
 
 mod notification;
@@ -33,6 +34,12 @@ mod rpc_error {
     // pub const INTERNAL_ERROR: i32 = -32603;
 }
 
+enum WorkspaceScanMethod {
+    None,
+    UseCheckpoints,
+    FullUpdate,
+}
+
 #[derive(thiserror::Error,Debug)]
 enum ServerError {
     #[error("Parsing")]
@@ -43,7 +50,8 @@ struct AnalysisResult {
     uri: lsp::Uri,
     version: Option<i32>,
     diagnostics: Vec<lsp::Diagnostic>,
-    symbols: applesoft::Symbols
+    symbols: applesoft::Symbols,
+    workspace: applesoft::Workspace
 }
 
 /// Send log messages to the client.
@@ -97,16 +105,40 @@ fn parse_configuration(resp: lsp_server::Response) -> Result<applesoft::settings
     Err(Box::new(ServerError::Parsing))
 }
 
-fn launch_analysis_thread(analyzer: Arc<Mutex<Analyzer>>, doc: a2kit::lang::Document) -> std::thread::JoinHandle<Option<AnalysisResult>> {
+fn launch_analysis_thread(analyzer: Arc<Mutex<Analyzer>>, doc: a2kit::lang::Document, ws_scan: WorkspaceScanMethod, chks: &HashMap<String,CheckpointManager>) -> std::thread::JoinHandle<Option<AnalysisResult>> {
+    let checkpoints = match ws_scan {
+        WorkspaceScanMethod::FullUpdate => {
+            let mut ans = Vec::new();
+            for chk in chks.values() {
+                ans.push(chk.get_doc());
+            }
+            ans
+        },
+        _ => Vec::new()
+    };
     std::thread::spawn( move || {
         match analyzer.lock() {
             Ok(mut analyzer) => {
+                match ws_scan {
+                    WorkspaceScanMethod::None => {},
+                    WorkspaceScanMethod::UseCheckpoints => {
+                        match analyzer.rescan_workspace(false) {
+                            _ => {}
+                        }
+                    },
+                    WorkspaceScanMethod::FullUpdate => {
+                        match analyzer.rescan_workspace_and_update(checkpoints) {
+                            _ => {}
+                        }
+                    }
+                };
                 match analyzer.analyze(&doc) {
                     Ok(()) => Some(AnalysisResult {
                         uri: doc.uri.clone(),
                         version: doc.version,
                         diagnostics: analyzer.get_diags(&doc),
-                        symbols: analyzer.get_symbols()
+                        symbols: analyzer.get_symbols(),
+                        workspace: analyzer.get_workspace().clone()
                     }),
                     Err(_) => None
                 }
@@ -135,6 +167,7 @@ pub fn push_diagnostics(connection: &lsp_server::Connection,uri: lsp::Uri, versi
 
 struct Tools {
     config: applesoft::settings::Settings,
+    workspace: applesoft::Workspace,
     thread_handles: VecDeque<std::thread::JoinHandle<Option<AnalysisResult>>>,
     doc_chkpts: HashMap<String,applesoft::checkpoint::CheckpointManager>,
     analyzer: Arc<Mutex<applesoft::diagnostics::Analyzer>>,
@@ -150,6 +183,7 @@ impl Tools {
     pub fn new() -> Self {
         Self {
             config: applesoft::settings::Settings::new(),
+            workspace: applesoft::Workspace::new(),
             thread_handles: VecDeque::new(),
             doc_chkpts: HashMap::new(),
             analyzer: Arc::new(Mutex::new(Analyzer::new())),
@@ -194,6 +228,7 @@ fn main() -> Result<(), Box<dyn Error + Sync + Send>> {
                 ..lsp::CompletionOptions::default()
             }),
             document_symbol_provider: Some(lsp::OneOf::Left(true)),
+            workspace_symbol_provider: Some(lsp::OneOf::Left(true)),
             rename_provider: Some(lsp::OneOf::Left(true)),
             semantic_tokens_provider: match suppress_tokens {
                 true => None,
@@ -263,6 +298,18 @@ fn main() -> Result<(), Box<dyn Error + Sync + Send>> {
         Err(_) => logger(&connection,"could not request starting configuration")
     }
 
+    // Initial workspace scan
+    if let Some(folders) = params.workspace_folders {
+        let source_dirs = folders.iter().map(|f| f.uri.clone()).collect::<Vec<lsp::Uri>>();
+        //tools.hover_provider.set_workspace_folder(source_dirs.clone());
+        if let Ok(mut mutex) = tools.analyzer.lock() {
+            match mutex.init_workspace(source_dirs, Vec::new()) {
+                Ok(()) => {},
+                Err(e) => logger(&connection,&format!("initial workspace scan failed: {}",e))
+            }
+        }
+    }
+
     // Main loop
     loop {
 
@@ -271,8 +318,10 @@ fn main() -> Result<(), Box<dyn Error + Sync + Send>> {
             if oldest.is_finished() {
                 let done = tools.thread_handles.pop_front().unwrap();
                 if let Ok(Some(result)) = done.join() {
+                    tools.workspace = result.workspace;
                     if let Some(chkpt) = tools.doc_chkpts.get_mut(&result.uri.to_string()) {
                         chkpt.update_symbols(result.symbols);
+                        chkpt.update_ws_symbols(tools.workspace.borrow_ws_symbols().clone());
                         tools.hover_provider.use_shared_symbols(chkpt.shared_symbols());
                         tools.completion_provider.use_shared_symbols(chkpt.shared_symbols());
                     }

src/bin/server-applesoft/notification.rs

@@ -35,11 +35,31 @@ pub fn handle_notification(
                         uri: normalized_uri.clone(),
                         version: Some(params.text_document.version),
                         text: params.text_document.text
-                    }
+                    },
+                    crate::WorkspaceScanMethod::FullUpdate,
+                    &tools.doc_chkpts
                 );
                 tools.thread_handles.push_back(handle);
             }
         },
+        lsp::notification::DidSaveTextDocument::METHOD => {
+            if let Ok(params) = serde_json::from_value::<lsp::DidSaveTextDocumentParams>(note.params) {
+                let normalized_uri = normalize_client_uri(params.text_document.uri);
+                if let Some(text) = params.text {
+                    let handle = launch_analysis_thread(
+                        Arc::clone(&tools.analyzer),
+                        a2kit::lang::Document {
+                            uri: normalized_uri.clone(),
+                            version: None,
+                            text
+                        },
+                        crate::WorkspaceScanMethod::FullUpdate,
+                        &tools.doc_chkpts
+                    );
+                    tools.thread_handles.push_back(handle);
+                }
+            }
+        },
         lsp::notification::DidCloseTextDocument::METHOD => {
             if let Ok(params) = serde_json::from_value::<lsp::DidCloseTextDocumentParams>(note.params) {
                 let normalized_uri = normalize_client_uri(params.text_document.uri);
@@ -63,7 +83,9 @@ pub fn handle_notification(
                             uri: normalized_uri.clone(),
                             version: Some(params.text_document.version),
                             text: change.text
-                        }
+                        },
+                        crate::WorkspaceScanMethod::UseCheckpoints,
+                        &tools.doc_chkpts
                     );
                     tools.thread_handles.push_back(handle);
                 }

src/bin/server-applesoft/request.rs

@@ -71,6 +71,12 @@ pub fn handle_request(
         lsp::request::HoverRequest::METHOD => Checkpoint::hover_response(chkpts, &mut tools.hover_provider, req.clone(), &mut resp),
         lsp::request::Completion::METHOD => Checkpoint::completion_response(chkpts, &mut tools.completion_provider, req.clone(), &mut resp),
         lsp::request::SemanticTokensFullRequest::METHOD => Checkpoint::sem_tok_response(chkpts, &mut tools.highlighter, req.clone(), &mut resp),
+        lsp::request::WorkspaceSymbolRequest::METHOD => {
+            if let Ok(_params) = serde_json::from_value::<lsp::WorkspaceSymbolParams>(req.params) {
+                let ws_syms = tools.workspace.get_ws_symbols_for_client();
+                resp = lsp_server::Response::new_ok(req.id,ws_syms);
+            }
+        },
 
         lsp::request::Shutdown::METHOD => {
             logger(&connection,"shutdown request");
@@ -91,7 +97,9 @@ pub fn handle_request(
                                 if let Some(chk) = tools.doc_chkpts.get(&normalized_uri.to_string()) {
                                     let handle = crate::launch_analysis_thread(
                                         Arc::clone(&tools.analyzer),
-                                        chk.get_doc()
+                                        chk.get_doc(),
+                                        crate::WorkspaceScanMethod::UseCheckpoints,
+                                        &tools.doc_chkpts
                                     );
                                     tools.thread_handles.push_back(handle);
                                 }

src/bin/server-applesoft/response.rs

@@ -5,13 +5,15 @@ use std::sync::{Mutex,Arc};
 use a2kit::lang::applesoft;
 use a2kit::lang::server::Checkpoint;
 use a2kit::lang::applesoft::diagnostics::Analyzer;
+use a2kit::lang::applesoft::Workspace;
 use super::logger;
 
 pub fn handle_response(connection: &lsp_server::Connection, resp: lsp_server::Response, tools: &mut super::Tools) {
     match resp.id.to_string().as_str() {
         "\"applesoft-pull-config\"" => {
             match super::parse_configuration(resp) {
                 Ok(config) => {
+                    let mut workspace_data = Workspace::new();
                     tools.config = config.clone();
                     tools.hover_provider.set_config(config.clone());
                     tools.completion_provider.set_config(config.clone());
@@ -21,17 +23,24 @@ pub fn handle_response(connection: &lsp_server::Connection, resp: lsp_server::Re
                     // configure main analyzer
                     if let Ok(mut mutex) = tools.analyzer.lock() {
                         mutex.set_config(config.clone());
+                        if let Err(_) = mutex.rescan_workspace(false) {
+                            logger(&connection,"failed to rescan workspace after user changed settings");
+                        }
+                        workspace_data = mutex.get_workspace().clone();
                     }
 
                     // run through open documents and update
                     for (key,chkpt) in &tools.doc_chkpts {
                         let doc = chkpt.get_doc();
                         let mut loc_analyzer = Analyzer::new();
                         loc_analyzer.set_config(config.clone());
+                        loc_analyzer.set_workspace(workspace_data.clone());
                         logger(&connection,&format!("updated configuration for {}",key));
                         let handle = super::launch_analysis_thread(
                             Arc::new(Mutex::new(loc_analyzer)),
-                            doc
+                            doc,
+                            crate::WorkspaceScanMethod::None,
+                            &tools.doc_chkpts
                         );
                         tools.thread_handles.push_back(handle);
                     }