ZXBS:

- Added txt2bas by Yoruguaman
- Laundh with custom autoexec.bas file

Author: Juan Segura

README.md

@@ -19,11 +19,11 @@ Have fun!
   - AdolFITO 
   - HashIron
   - SirRickster
+  - Yoruguaman
 - Testers:
   - AbenZaX
   - Pedro Tomás (Pere)
   - Jose Daniel Fernandez Santos (Fenix)
-  - Yoruguaman
 
 ## Credits
 - Icons from [SVG REPO](https://www.svgrepo.com/):

ZXBStudio/Common/Txt2Bas/BasConverter.cs

@@ -0,0 +1,254 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace ZXBasicStudio.Common.Txt2Bas
+{
+    /// <summary>
+    /// Converts plain text into tokenized Spectrum BASIC binary format.
+    /// Based on Yoruguaman work: https://github.com/Ultrahead/SpeccyNextTools
+    /// </summary>
+    internal class BasConverter
+    {
+        private readonly TokenMap _tokenMap;
+        private readonly List<string> _sortedKeys;
+
+        /// <summary>
+        /// The Auto-start line number. 
+        /// Defaults to 32768 (No Auto-start). 
+        /// Set only via the #autostart directive in the source file.
+        /// </summary>
+        public int AutoStartLine { get; private set; } = 32768;
+
+        /// <summary>
+        /// Initializes member variable fields of the <see cref="BasConverter"/> class.
+        /// </summary>
+        public BasConverter()
+        {
+            // 1. Initialize the TokenMap dictionary.
+            // 2. Create a list of keys sorted by Length Descending.
+            //    (This ensures greedy matching: e.g., "DEFPROC" is matched before "DEF").
+
+            _tokenMap = new TokenMap();
+            _sortedKeys = _tokenMap.Map.Keys
+                .OrderByDescending(k => k.Length)
+                .ToList();
+        }
+
+        /// <summary>
+        /// Reads a text file and converts it to a byte array of tokenized BASIC.
+        /// </summary>
+        /// <param name="textData">Text to convert</param>
+        /// <returns>Byte array representing the BASIC program.</returns>
+        public byte[] ConvertFile(string textData)
+        {
+            // 1. Read all lines from the source text file.
+            // 2. Initialize state variables (auto-line counter, output buffer).
+            // 3. Iterate through each line:
+            //    a. Skip whitespace-only lines (source code formatting).
+            //    b. Process directive (#autostart) then skip the line.
+            //    c. Skip all other lines starting with # (source code comments).
+            //    d. Parse explicit or implicit line numbers and tokenize content.
+            // 4. Return the aggregated binary data.
+
+            string[] lines = textData.Split(new[] { "\r\n", "\n" }, StringSplitOptions.None);
+            var output = new List<byte>();
+
+            int currentLineNum = 10;
+
+            foreach (string line in lines)
+            {
+                string text = line.Trim();
+
+                // 1. Skip Empty Lines completely (do not generate a BASIC line)
+                if (string.IsNullOrWhiteSpace(text)) continue;
+
+                // 2. Handle Lines starting with #
+                if (text.StartsWith("#"))
+                {
+                    // Check for directives
+                    if (text.StartsWith("#autostart", StringComparison.OrdinalIgnoreCase))
+                    {
+                        var parts = text.Split([' '], StringSplitOptions.RemoveEmptyEntries);
+                        if (parts.Length > 1 && int.TryParse(parts[1], out int autoStartVal))
+                        {
+                            AutoStartLine = autoStartVal;
+                        }
+                    }
+
+                    // Whether it was a directive or a comment, skip it in the output.
+                    continue;
+                }
+
+                // 3. Handle Standard Lines
+                int lineNum = currentLineNum;
+                string restOfLine = text;
+
+                Match match = Regex.Match(text, @"^(\d+)\s+(.*)");
+
+                if (match.Success)
+                {
+                    lineNum = int.Parse(match.Groups[1].Value);
+                    restOfLine = match.Groups[2].Value;
+                    currentLineNum = lineNum + 10;
+                }
+                else
+                {
+                    currentLineNum += 10;
+                }
+
+                byte[] lineBytes = ParseLine(lineNum, restOfLine);
+                output.AddRange(lineBytes);
+            }
+
+            return output.ToArray();
+        }
+
+        /// <summary>
+        /// Parses a single line of text into binary line format.
+        /// Structure: [LineNum(BE)] [Length(LE)] [Data...] [0x0D]
+        /// </summary>
+        /// <param name="lineNum">The line number.</param>
+        /// <param name="text">The text content of the line.</param>
+        /// <returns>A byte array representing the binary line.</returns>
+        private byte[] ParseLine(int lineNum, string text)
+        {
+            // 1. Iterate through the text character by character.
+            // 2. Detect and process String Literals (preserve exactly).
+            // 3. Detect and process Numbers (convert to ASCII + 5-byte hidden Sinclair format).
+            // 4. Detect and process SPECIAL COMMENT (';' after colon or at start).
+            // 5. Detect and process Keywords (Greedy Match against TokenMap):
+            //    a. If REM found, consume the rest of the line as a comment.
+            //    b. If other keyword found, strip immediately following whitespace.
+            // 6. Fallback: Add character as literal ASCII.
+            // 7. Append End-of-Line marker (0x0D).
+            // 8. Prepend the Line Header (Line Number + Length) and return the byte array.
+
+            List<byte> lineData = new List<byte>();
+
+            for (int i = 0; i < text.Length; i++)
+            {
+                // String Literals
+                if (text[i] == '"')
+                {
+                    int endQuote = text.IndexOf('"', i + 1);
+                    if (endQuote == -1) endQuote = text.Length;
+
+                    string literal = text.Substring(i, endQuote - i + 1);
+                    lineData.AddRange(Encoding.ASCII.GetBytes(literal));
+                    i = endQuote;
+                    continue;
+                }
+
+                // Numbers
+                if (char.IsDigit(text[i]) || (text[i] == '.' && i + 1 < text.Length && char.IsDigit(text[i + 1])))
+                {
+                    string numStr = "";
+                    int j = i;
+                    while (j < text.Length && (char.IsDigit(text[j]) || text[j] == '.'))
+                    {
+                        numStr += text[j];
+                        j++;
+                    }
+
+                    if (double.TryParse(numStr, out double val))
+                    {
+                        lineData.AddRange(Encoding.ASCII.GetBytes(numStr));
+                        lineData.Add(0x0E); // Hidden Marker
+                        lineData.AddRange(SinclairNumber.Pack(val));
+                        i = j - 1;
+                        continue;
+                    }
+                }
+
+                // COMMENT HANDLING: Strict check for ';comment' idiom
+                // Trigger: Semicolon at start of line OR Semicolon immediately preceded by Colon
+                if (text[i] == ';')
+                {
+                    bool isComment = false;
+
+                    // Look backwards skipping whitespace to find the context
+                    int back = i - 1;
+                    while (back >= 0 && text[back] == ' ') back--;
+
+                    if (back < 0) isComment = true; // Start of line
+                    else if (text[back] == ':') isComment = true; // Preceded by colon
+
+                    if (isComment)
+                    {
+                        // Consume the rest of the line as literal text (do not tokenize)
+                        string comment = text.Substring(i);
+                        lineData.AddRange(Encoding.ASCII.GetBytes(comment));
+                        i = text.Length;
+                        continue;
+                    }
+                }
+
+                // Keywords
+                bool matched = false;
+                foreach (string k in _sortedKeys)
+                {
+                    if (i + k.Length > text.Length) continue;
+
+                    if (string.Compare(text.Substring(i, k.Length), k, StringComparison.OrdinalIgnoreCase) != 0)
+                        continue;
+
+                    bool isAlphaToken = char.IsLetter(k[0]);
+                    bool prevCharValid = (i == 0) || !char.IsLetter(text[i - 1]);
+                    bool nextCharValid = (i + k.Length >= text.Length) || !char.IsLetterOrDigit(text[i + k.Length]);
+
+                    if (isAlphaToken && (!prevCharValid || !nextCharValid)) continue;
+
+                    byte token = _tokenMap.Map[k];
+                    lineData.Add(token);
+                    i += k.Length;
+                    matched = true;
+
+                    // REM handling
+                    if (token == 0xEA)
+                    {
+                        if (i < text.Length)
+                        {
+                            string comment = text.Substring(i);
+                            lineData.AddRange(Encoding.ASCII.GetBytes(comment));
+                            i = text.Length;
+                        }
+                    }
+                    else
+                    {
+                        // Strip trailing space
+                        while (i < text.Length && text[i] == ' ') i++;
+                    }
+
+                    i--;
+                    break;
+                }
+
+                if (matched) continue;
+
+                // Literal
+                lineData.Add((byte)text[i]);
+            }
+
+            lineData.Add(0x0D);
+
+            // Construct Line Header
+            List<byte> finalLine =
+            [
+                (byte)((lineNum >> 8) & 0xFF),
+                (byte)(lineNum & 0xFF)
+            ];
+
+            int length = lineData.Count;
+            finalLine.Add((byte)(length & 0xFF));
+            finalLine.Add((byte)((length >> 8) & 0xFF));
+
+            finalLine.AddRange(lineData);
+
+            return finalLine.ToArray();
+        }
+    }
+}

ZXBStudio/Common/Txt2Bas/Plus3Dos.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ZXBasicStudio.Common.Txt2Bas
+{
+    /// <summary>
+    /// Generates the 128-byte +3DOS Header required for Spectrum Next/Plus3 files.
+    /// Based on Yoruguaman work: https://github.com/Ultrahead/SpeccyNextTools
+    /// </summary>
+    internal static class Plus3Dos
+    {
+        /// <summary>
+        /// Creates a valid +3DOS header.
+        /// </summary>
+        /// <param name="basicLength">The length of the BASIC program data (excluding header).</param>
+        /// <param name="autoStartLine">The line number to auto-run (or 32768 for none).</param>
+        /// <returns>A 128-byte byte array containing the header.</returns>
+        public static byte[] CreateHeader(int basicLength, int autoStartLine)
+        {
+            // 1. Allocate a zero-filled 128-byte buffer.
+            // 2. Write the "PLUS3DOS" signature and Soft EOF (0x1A) to the start.
+            // 3. Set the Issue (1) and Version (0) bytes.
+            // 4. Calculate and write Total File Size (Header + BASIC Data) at offset 11.
+            // 5. Write BASIC-specific metadata (Type, Length, Vars Offset).
+            // 6. Set the Auto-start line (or 32768 if disabled).
+            // 7. Calculate the Checksum (Sum of bytes 0-126 modulo 256) and write it at byte 127.
+
+            byte[] header = new byte[128];
+            Array.Clear(header, 0, 128);
+
+            // Signature
+            byte[] sig = Encoding.ASCII.GetBytes("PLUS3DOS");
+            Array.Copy(sig, header, sig.Length);
+            header[8] = 0x1A;
+
+            // Version info
+            header[9] = 0x01;
+            header[10] = 0x00;
+
+            // Total File Size (Header + Data)
+            int totalFileSize = basicLength + 128;
+            BitConverter.GetBytes(totalFileSize).CopyTo(header, 11);
+
+            // BASIC Header Info
+            header[15] = 0x00; // Type: Program
+            BitConverter.GetBytes((ushort)basicLength).CopyTo(header, 16); // Length
+
+            // Auto-start
+            if (autoStartLine is >= 0 and < 32768)
+            {
+                BitConverter.GetBytes((ushort)autoStartLine).CopyTo(header, 18);
+            }
+            else
+            {
+                BitConverter.GetBytes((ushort)32768).CopyTo(header, 18);
+            }
+
+            // Vars Offset
+            BitConverter.GetBytes((ushort)basicLength).CopyTo(header, 20);
+
+            // Checksum
+            int sum = 0;
+            for (int i = 0; i < 127; i++) sum += header[i];
+            header[127] = (byte)(sum % 256);
+
+            return header;
+        }
+    }
+}

ZXBStudio/Common/Txt2Bas/SinclairNumber.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ZXBasicStudio.Common.Txt2Bas
+{
+    /// <summary>
+    /// Handles the 5-byte floating point format used by Sinclair BASIC.
+    /// Based on Yoruguaman work: https://github.com/Ultrahead/SpeccyNextTools
+    /// </summary>
+    internal static class SinclairNumber
+    {
+        /// <summary>
+        /// Packs a double into the 5-byte internal format.
+        /// Currently, supports integer format optimization (00 Sign LSB MSB 00).
+        /// </summary>
+        /// <param name="number">The number to pack.</param>
+        /// <returns>A 5-byte array representing the Sinclair number format.</returns>
+        public static byte[] Pack(double number)
+        {
+            // 1. Check if the number is a small integer (within +/- 65535).
+            // 2. If yes, create the integer format: 0x00, SignByte, LSB, MSB, 0x00.
+            // 3. If no, return empty zero bytes (full FP implementation omitted for brevity).
+
+            if (number % 1 == 0 && number is >= -65535 and <= 65535)
+            {
+                int val = (int)number;
+                byte sign = 0;
+
+                if (val < 0)
+                {
+                    sign = 0xFF;
+                    val = -val;
+                }
+
+                return [0x00, sign, (byte)(val & 0xFF), (byte)((val >> 8) & 0xFF), 0x00];
+            }
+
+            return "\0\0\0\0\0"u8.ToArray();
+        }
+    }
+}