BAX-59 (BAsic X-compiler for TI-59)

UN CROSS-COMPILATORE da BASIC DARTMOUTH a TI-59 S.O.A.

A CROSS-COMPILER from BASIC DARTMOUTH to TI-59 A.O.S.

 

Su un vecchio numero di TI-PPC Notes* (e precisamente il V9N4P19 di Luglio/Agosto 1984 e qui sotto riportato) ho letto tre-quattro anni fa una piccola notizia che riportava la disponibilità, per chi volesse, di avere una tesi di laurea di due studenti del "Naval Postgraduate School" di Monterey (California) che avevano implementato su un grande elaboratore IBM un cross-compilatore (scritto in Pascal) da Waterloo BASIC 2.0 a linguaggio SOA (AOS) della TI-59, con addirittura la possibilità di segmentare il programma su schede magnetiche se troppo lungo. Dopo una ricerca infruttuosa su Internet, casualmente ho trovato il PDF della tesi e l'ho scaricato: ho visto subito che non faceva al caso mio - troppo complesso: puntatori di puntatori e strutture dati pesantissime - e anche una riscrittura in Turbo Pascal non ha sortito effetto.

Ho così deciso di scrivere un compilatore ex novo (**), scegliendo bene il linguaggio "target": la scelta è caduta per motivi di semplicità sul Dartmouth BASIC (versione 1968 - con qualche piccola modifica) che, essendo appassionato di storia dell'informatica, stavo proprio studiando in quel periodo. Inoltre il prodotto doveva essere interfacciabile dall'esterno e quindi anche con il mio emulatore di TI-59

Il progetto BAX-59 (BAsic X-compiler for TI-59) è così partito ed il risultato finale è questo cross-compiler composto da due parti:

1) CC5.EXE è il cross-compiler vero e proprio: accetta in input un file .BAS e produce un file .SOA per, così dire, "grezzo";

2) OPT.EXE è un "ottimizzatore" che accetta in input il codice prodotto dal compilatore e produce un file .SOA migliorato in termini di occupazione di memoria rispetto al file precedente.

Lo schema qui sotto identifica il flusso dei dati di BAX-59.

  
Flusso dati di BAX-59

In pratica, come si può vedere, abbiamo tre passaggi - due per il cross-compiler e il terzo per l'ottimizzatore.

BAX-59, contrariamente al suo  antenato omonimo, non ha la possibilità di segmentare il programma .SOA se troppo esteso per la capacità di memoria della TI-59: ma, almeno sul mio emulatore, il meccanismo del "CROM Emulator" consente di ovviare totalmente a questa mancanza, come spiegato sul manuale di utilizzo.

Due file batch (BAX59.BAT e BAX59-64.BAT) consentono di automatizzare il processo di compilazione:

BAX59.BAT BAX59-64.BAT
@ECHO OFF
IF %1' == /?' GOTO :LISTA
IF %1' == ' GOTO :MSG
IF NOT EXIST %1.BAS EDIT %1.BAS
IF %2' == /M' EDIT %1.BAS
IF %2' == /m' EDIT %1.BAS
CLS
ECHO +--------------------------------------+
ECHO | BATCH FILE FOR COMPILING WITH BAX-59 |
ECHO +--------------------------------------+
ECHO ********************************************
ECHO *PASS ONE: COMPILE .BAS FILE [ IN OUTPUT .SOA FILE ] *
ECHO ********************************************
ECHO Press a key to continue
PAUSE>NUL
CC5 %1
ECHO %ERRORLEVEL%
IF ERRORLEVEL 1 GOTO :ERRORE
ECHO Press a key to continue
PAUSE>NUL
CLS
ECHO **********************************************
ECHO * PASS TWO: OPTIMIZE .SOA FILE [ IN OUTPUT .SOA FILE ] *
ECHO **********************************************
ECHO Press a key to continue
PAUSE>NUL
OPT %1
ECHO ******** COMPILATION FINISHED
GOTO :FINE
:LISTA
DIR /W *.BAS
GOTO :FINE
:MSG
ECHO ******** Must give a filename!
ECHO ******** Use BAX59 /? for a file list.
GOTO :FINE
:ERRORE
ECHO ******** Compilation Error(s)!
:FINE
 
@ECHO OFF
IF %1' == /?' GOTO :LISTA
IF %1' == ' GOTO :MSG
IF NOT EXIST %1.BAS EDIT %1.BAS
IF %2' == /M' EDIT %1.BAS
IF %2' == /m' EDIT %1.BAS
CLS
ECHO +-----------------------------------------------+
ECHO | BATCH FILE FOR COMPILING WITH BAX-59 (64 bit) |
ECHO +-----------------------------------------------+

ECHO ****************************************************
ECHO * PASS ONE: COMPILE .BAS FILE [ IN OUTPUT .SOA FILE ]
ECHO ****************************************************
ECHO Press a key to continue
PAUSE>NUL
CC5-64 %1
ECHO %ERRORLEVEL%
IF ERRORLEVEL 1 GOTO :ERRORE
ECHO Press a key to continue
PAUSE>NUL
CLS
ECHO ***************************************************
ECHO * PASS TWO: OPTIMIZE .SOA FILE [ IN OUTPUT .SOA FILE ]
ECHO ***************************************************
ECHO Press a key to continue
PAUSE>NUL
OPT-64 %1
ECHO ******** COMPILATION FINISHED
GOTO :FINE
:LISTA
DIR /W *.BAS
GOTO :FINE
:MSG
ECHO ******** Must give a filename!
ECHO ******** Use BAX59 /? for a file list.
GOTO :FINE
:ERRORE
ECHO ******** Compilation Error(s)!
:FINE
 

LE LIMITAZIONI DEL LINGUAGGIO


Le limitazioni rispetto al Dartmouth BASIC riguardano gli array che possono essere al massimo solo bidimensionali e le funzioni definite dall'utente che possono avere al massimo due argomenti. Non sono neppure implementate le istruzioni MAT che avrebbe portato qualsiasi traduzione, anche minima, oltre la portata della TI-59. Inoltre la manipolazione delle stringhe non è, ovviamente, completa.


Un esempio di sessione con il sistema DTSS (emulato in Windows)

Nella cartella BAX59 sono presenti, oltre alle due parti del cross-compiler, anche oltre 20 esempi con nome SAMPLExx che possono essere usati come guida per vedere come viene effettuata la traduzione.

Viene riportato come esempio il calcolo del massimo comun divisore (SAMPLE01.BAS) di due triple di numeri - con l'aggiunta di una funzione ed un array (nelle linee 5, 6, 7 e 102) che, chiaramente, non c'entrano con il M.C.D. stesso e sono stati introdotti solo a scopo di esempio.

                   Listato BASIC                             Traduzione in SOA                           Commento

5 DEF FNH(X) = 1 - X*X
6 DIM P(8)
7 INPUT Z
10 PRINT "A", "B", "C", "GCD"
15 FOR I = 1 TO 2
20 READ A, B, C
30 LET X = A
40 LET Y = B
50 GOSUB 200
60 LET X = G
70 LET Y = C
80 GOSUB 200
90 PRINT A, B, C, G
100 NEXT I
102 LET Q1 = FNH(5) * 3
105 GOTO 999
110 DATA 60, 90, 120
120 DATA 38456, 64872, 98765
200 LET Q = INT(X/Y)
210 LET R = X - Q*Y
220 IF R = 0 THEN 300
230 LET X = Y
240 LET Y = R
250 GOTO 200
300 LET G = Y
310 RETURN
999 END

LBL E' 14 STO 14
1 SUM 14 6 0 ST* 14
1 SUM 14 9 0 ST* 14
1 SUM 14 1 2 0 ST* 14
1 SUM 14 3 8 4 5 6 ST* 14
1 SUM 14 6 4 8 7 2 ST* 14
1 SUM 14 9 8 7 6 5 ST* 14
14 STO 14
RTN
LBL PRT ( CE + 21 ) STO 00 RTN
LBL ADV 29 STO 01 RTN

{BASIC line #5}
LBL A
STO 2 ( 1 - RCL 2 * RCL 2 ) RTN

{BASIC line #6}
LBL B
NOP

{BASIC line #7}
R/S STO 4

{BASIC line #10}
1 3 OP 1 OP 05
1 4 OP 1 OP 05
1 5 OP 1 OP 05
2 2 1 5 1 6 OP 1 OP 05

{BASIC line #15}
1 STO 5

{BASIC line #20}
LBL C
1 SUM 14 RC* 14 STO 6
1 SUM 14 RC* 14 STO 7
1 SUM 14 RC* 14 STO 8

{BASIC line #30}
( RCL 6 ) STO 3

{BASIC line #40}
( RCL 7 ) STO 9

{BASIC line #50}
SBR D

{BASIC line #60}
( RCL 10 ) STO 3

{BASIC line #70}
( RCL 8 ) STO 9

{BASIC line #80}
SBR D

{BASIC line #90}
( RCL 6 ) PRT
( RCL 7 ) PRT
( RCL 8 ) PRT
( RCL 10 ) PRT

{BASIC line #100}
1 SUM 5 RCL 5 X:T 3 GE C

{BASIC line #102}
( ( 5 ) SBR A * 3 ) STO 11

{BASIC line #105}
GTO A'

{BASIC line #110}
NOP

{BASIC line #120}
NOP

{BASIC line #200}
LBL D
( ( RCL 3 / RCL 9 ) INT ) STO 12

{BASIC line #210}
( RCL 3 - RCL 12 * RCL 9 ) STO 13

{BASIC line #220}
0 X:T RCL 13 EQ E

{BASIC line #230}
( RCL 9 ) STO 3

{BASIC line #240}
( RCL 13 ) STO 9

{BASIC line #250}
GTO D

{BASIC line #300}
LBL E
( RCL 9 ) STO 10

{BASIC line #310}
RTN

{BASIC line #999}
LBL A'
R/S

memorizza i DATA della linea 120








istruzioni di libreria - solo per eventuali array e funzioni

inizio traduzione vera e propria




DATA: vedi inizio traduzione



variabile Z in R04







ciclo FOR (ripetuto 2 volte)




variabili A, B e C in R06,R07 e R08



prima calcola M.C.D tra A e B: li  assegna a X e Y - in pratica un passaggio parametri esplicito in ingresso  per la SUB




esegue SUB per calcolo effettivo
la SUB restituisce G=MCD(A,B)

seconda parte: calcola MCD tra G e C col solito passaggio parametri






stampa il risultato






fa il NEXT I














calcolo MCD con l'algoritmo di Euclide

BAX-59 è scritto, al solito, in Quick Basic 4.5 (ma con una lieve modifica è compilabile anche con Basic PDS 7.1) e quindi è a 16 bit: contrariamente alla mia abitudine tutti i messaggi del cross-compiler e i documenti relativi sono in inglese. Da Novembre 2015 è disponibile pure la versione a 32/64 bit compilata sotto QB64.

            BAX-59 versione 5 (anche a 32/64 bit).


E' disponibile anche la versione finale di BAX-59 (la numero 5 con, finalmente, un manuale d'uso) che introduce l'utilizzo dei flag e corregge alcune piccole inesattezze. La fase di ottimizzazione ora produce direttamente il file .SOA pronto per l'importazione nel mio emulatore di TI-59.

Nel link per il download sotto riportato è presente solo la release 5 del cross-compiler sia nella versione a 16 bit che in quella a 32/64 bit, senza il codice sorgente.

    Download BAX59 compiler (5.0) (compreso il manuale - user's guide included)

BAX-59 has all messages and documentation in English.
(source code is NOT included)

Nota: La versione 4 del compilatore non è più supportata.

NOTE

(**) In rete ho trovato altri due prodotti "concorrenti" di BAX-59 entrambi francesi ma che presentano dei decisi punti deboli: il primo è una specie di Macro-Assembler mascherato da linguaggio ad alto livello (ma perché imparare un Macro Assembler per programmare di nuovo in Assembler - quello della TI-59?) con un'ottima documentazione, il secondo, più interessante, propone un linguaggio ad alto livello, simile al C chiamato T, ed un codice sorgente da far compilare sulla propria piattaforma: non riuscito ad ottenere un eseguibile ed ogni contatto con l'autore è andato a vuoto. Bel sito dal punto di vista grafico ma manca qualsiasi documentazione utile, quindi in conclusione una completa delusione. Per chi fosse interessato basta cercare su Google "TI 59 COMPILER" per avere più informazioni su questi prodotti.

(*) TI-PPC Notes è lo splendido bollettino pubblicato da un gruppo di utenti, situato vicino a Washington, delle calcolatrici Texas Instruments tra il 1980 e il 1991: da www.rskey.org ho potuto scaricare tutte le annate, le ho stampate e rilegate.

HOME