Bimbo72 wrote

I was wondering if it can be possible to readdress the save command to the audio and try to dump it in a wav within MEKA... at least to export programs from the emulator....

bsittler wrote

SC-3000 tapes use the same low-level encoding as MSX ones, and also the same baud rate. Thanks to this, most of the usual MSX tools work fine for processing them, including converting them to and from CAS format (for BIOS-only tapes) or TSX format (for all tapes).

MSX-compatible CAS format is a great representation for them when applicable because it allows simple file checksums to be used to check for identical tape contents / "good rips" of tapes, and it is also very compact and yet readable, with 1 byte of CAS being one encoded file or header byte on the tape.

Of course the type code bytes for file header blocks, file data blocks, etc. do differ between SC-3000 and MSX.

I needed to convert some tokenized BASIC from a file extracted from a CAS conversion of an SC-3000 file to ASCII for analysis but couldn't find a ready-made tool that did this, so I wrote one in (admittedly terrible) Python 3 using the information from this thread that converts tokenized BASIC bytes read from /dev/fd/0 to ASCII BASIC written out to /dev/fd/1

#!/usr/bin/env python3

# Converts SC-3000 tokenized BASIC from /dev/fd/0 to ASCII written to /dev/fd/1

import struct

def num2asc(num):
 ret, = struct.unpack('<L', bytes(tuple(num)))
 return str(ret)

def scbas2asc(byts, ofd):
 decoder = {
  (130): b"LIST",
  (131): b"LLIST",
  (132): b"AUTO",
  (133): b"DELETE",
  (134): b"RUN",
  (135): b"CONT",
  (136): b"LOAD",
  (137): b"SAVE",
  (138): b"VERIFY",
  (139): b"NEW",
  (140): b"RENUM",
  (144): b"REM",
  (145): b"PRINT",
  (146): b"LPRINT",
  (147): b"DATA",
  (148): b"DEF",
  (149): b"INPUT",
  (150): b"READ",
  (151): b"STOP",
  (152): b"END",
  (153): b"LET",
  (154): b"DIM",
  (155): b"FOR",
  (156): b"NEXT",
  (157): b"GOTO",
  (158): b"GOSUB",
  (159): b"GO",
  (160): b"ON",
  (161): b"RETURN",
  (162): b"ERASE",
  (163): b"CURSOR",
  (164): b"IF",
  (165): b"RESTORE",
  (166): b"SCREEN",
  (167): b"COLOR",
  (168): b"LINE",
  (169): b"SOUND",
  (170): b"BEEP",
  (171): b"CONSOLE",
  (172): b"CLS",
  (173): b"OUT",
  (174): b"CALL",
  (175): b"POKE",
  (176): b"PSET",
  (177): b"PRESET",
  (178): b"PAINT",
  (179): b"BLINE",
  (180): b"POSITION",
  (181): b"HCOPY",
  (182): b"SPRITE",
  (183): b"PATTERN",
  (184): b"CIRCLE",
  (185): b"BCIRCLE",
  (186): b"MAG",
  (187): b"VPOKE",
  (188): b"MOTOR",
  (192): b"^",
  (193): b"*",
  (194): b"/",
  (195): b"MOD",
  (196): b"+",
  (197): b"-",
  (198): b"<>",
  (199): b">=",
  (200): b"<=",
  (201): b">",
  (202): b"<",
  (203): b"=",
  (204): b"NOT",
  (205): b"AND",
  (206): b"OR",
  (207): b"XOR",
  (224): b"FN",
  (225): b"TO",
  (226): b"STEP",
  (227): b"THEN",
  (228): b"TAB",
  (229): b"SPC",
  (128, 128): b"ABS",
  (128, 129): b"RND",
  (128, 130): b"SIN",
  (128, 131): b"COS",
  (128, 132): b"TAN",
  (128, 133): b"ASN",
  (128, 134): b"ACS",
  (128, 135): b"ATN",
  (128, 136): b"LOG",
  (128, 137): b"LGT",
  (128, 138): b"LTW",
  (128, 139): b"EXP",
  (128, 140): b"RAD",
  (128, 141): b"DEG",
  (128, 142): b"PI",
  (128, 143): b"SQR",
  (128, 144): b"INT",
  (128, 145): b"SGN",
  (128, 146): b"ASC",
  (128, 147): b"LEN",
  (128, 148): b"VAL",
  (128, 149): b"PEEK",
  (128, 150): b"INP",
  (128, 151): b"FRE",
  (128, 152): b"VPEEK",
  (128, 153): b"STICK",
  (128, 154): b"STRIG",
  (128, 160): b"CHR$",
  (128, 161): b"HEX$",
  (128, 162): b"INKEY$",
  (128, 163): b"LEFT$",
  (128, 164): b"RIGHT$",
  (128, 165): b"MID$",
  (128, 166): b"STR$",
  (128, 167): b"TIME$",
 }
 esc = None
 in_quotes = False
 in_rem = False
 in_data = False
 lnum = []
 llen = None
 byt0 = None
 csum = 0
 for byt in byts:
  if byt0 is None:
    byt0 = byt
    assert byt0 == 0x17 # no idea why, but SC-3000 BASIC III starts with this byte
    continue
  csum += byt
  csum &= 0xFF
  if llen is None:
    llen = byt
    continue
  if len(lnum) < 4:
    lnum.append(byt)
    if len(lnum) == 4:
     ofd.write((num2asc(lnum) + ' ').encode('iso-8859-1'))
    continue
  llen -= 1
  if esc is not None:
    byt = (esc, byt)
    esc = None
  elif (byt == 128) and not (in_quotes or in_rem or in_data):
    esc = byt
    continue
  tok = None
  if not (in_quotes or in_rem or in_data):
   tok = decoder.get(byt)
  if tok is None:
   tok = bytes((byt,))
  if tok == b"REM":
   in_rem = True
  if tok == b"DATA":
   in_data = True
  if (tok == b':') and in_data and not in_quotes:
   in_data = False
  if (tok == b'"') and not in_rem:
   in_quotes = not in_quotes
  if tok == b'\r':
    ofd.write(b'\r\n')
    in_quotes = False
    in_rem = False
    in_data = False
    assert llen == -1, llen
    lnum = []
    llen = None
    continue
  ofd.write(tok)
 if llen is not None:
  if llen == 0 and len(lnum) < 4:
    assert csum == 0, 'ERROR: Checksum should always reach zero but it was: 0x%02X' % csum
    if len(lnum) > 1:
     assert lnum[1] == 0, 'ERROR: First pad byte should be zero but is was: 0x%02X' % lnum[1]
    if len(lnum) > 2:
     assert lnum[2] == 0, 'ERROR: Second pad byte should be zero but is was: 0x%02X' % lnum[2]
  else:
    assert llen == -1, llen
    assert False, 'ERROR: Missing end of program marker'

scbas2asc(open("/dev/fd/0", "rb").read(), open("/dev/fd/1", "wb"))

also entirely possible special bytes inside string literals or comments are totally broken by my lister

edit: updated to not expand tokens inside quoted strings

edit 2: also in remarks! added test files for the string/remark embedding cases

edit 3: also in data statements! added a test for that too