COMMODORE PLUS/4 WORLD
  Home  Search  Games  Tapes  Covers  Cheats  Maps  Software  New Stuff 
 Hall Of Fame  HVTC  Game Endings  Features  Solutions  Remakes  Publications  Magazines  Effects  Top List 
 Members  Groups  Plus/4 Encyclopedia  Hardware  Tools  Options  Forum 
Login
Introduction
AustroSpeed is a 2-pass (3-pass in overlay mode) BASIC compiler. It compiles BASIC programs to equivalent but more compact P-Code. The resulting programs are 3-5 times faster than the original.


Austrospeed Compiler
Title:Austrospeed Compiler
Category:Utility/BasicCompiler
Release Date:
Language:German
Size:64K
Device Req.:Disk only
Machine:PAL & NTSC
Code Type:AustroSpeed
Distribution:Crack
Released by:Digimat
Cracked by:The Raven
Additional Coded by:Z., Valentino (SVS)
Notes:You may need AustroConv by SVS to fix the obtained compiled file if it uses PEEK statements. "Austrosimple" is a special version that does not need any wedge or conversion.
  Download:
Download from Plus/4 World
Plus/4 World
Download from Rulez.org
Rulez.org
Download from Othersi.de
Othersi.de
  AustroSpeed decompiled and other extras:
Download from Plus/4 World
Plus/4 World
  Austrosimple:
Download from Plus/4 World
Plus/4 World
Download from Othersi.de
Othersi.de
User Rating: 9.4/10 (7 votes)
Austrospeed Compiler Screenshot


Derived Software
Austrospeed Compiler (English)


Publications
Review: Compute Mit SA 4/87 (Magazine/German) Page 4
Review: 64'er Sonderheft 14 (Magazine/German) Page 78


Origins
AustroSpeed has been confirmed to be a commercial release. The original apparently required a hardware key (dongle) to operate. The version we have is a crack by The (new) Raven. Compiled files containing PEEK/POKE statements need a crack file residing in memory. You can avoid this by using AustroConv utility written by SVS that fixes the compiled file.

The developer (programmer(s) and/or company) is unknown at this time.

AustroSpeed was also released for the C=64 and VIC-20.


Menu Translation
1. Single Floppy - RESUME only with line number
2. Dual Drive Floppy (means Device 8 Drive 0,1) - RESUME only with line number
3. 2 Disk Stations (means Device 8,9) - RESUME only with line number

4. Single Floppy - RESUME complete
5. Dual Drive Floppy (means Device 8 Drive 0,1) - RESUME complete
6. 2 Disk Stations (means Device 8,9) - RESUME complete


Description
Technical notes:
Compiled files will always add about 8Kb of machine language code. The compiled filename will be "c/(original_file_name)".
The compilation process also produces "p/*" and "z/*" files. While you can safely delete from the disk the "p/*" file, "z/*" on the contrary is useful for debugging. In fact it is a table file (Basic format) that allows the programmer to know the correspondance between source line-numbers and compiled error message referrals. For example if during compiling Austrospeed outputs "Syntax error at 22348" you have to search inside "z/*" file for line 22348 in order to know the original line-number in your Source. Then type "list 22300-" [return] and you see somethink like:
22300 8348
22310 8350
22330 8351
22348 8362 --> the wanted source line is 8362
*** Warning: the correspondence is not accurate, in the example you could find 22349 or 22352 instead of 22348, as prompted by compiler message.


A note about emulators:
in order to compile programs with AustroSpeed, be sure that full drive emulation is used (IEC drive emulation can be used only for input file).


Compiler Memory Map And Data Structure
The compiler itself and all compiled files have a fixed structure. The Runtime Interpreter begins at $1525 and ends at $2ef2. Next come six vectors (LB HB) that point to start of variables, start of arrays, end of arrays, start and end of data stmts.
Following the vectors is a system DIMZ*%() that defines a system array, Z*%(), which is used to locate individual arrays in RAM.
After the DIMZ*%() comes data statements.
The program pcode begins next,always with $15 and ends with $4f. After the $4f starts variables.
Then comes arrays. The first array in the array space is the system array Z*%().
The elements of this array give the offset from start of arrays to the first byte of each array in the prg.


AustroSpeed P-Code
This is the reverse engineered format of P-Code. Feel free to add to it.
-------------------------------------------------------------------------------------

----- COMPILED FILE STRUCTURE

Address Content

REAL TIME INTERPRETER

$1022 Jump table (High bytes) for P-code executing (JMP $1014,p-code) No jump table for P-Codes $00$0E (14 math operands)
$1094 Jump table (Low bytes) for P-code executing (JMP $1086,p-code) No jump table for P-Codes $00$0E (14 math operands)
$1525 Starts of Runtime Interpreter (RTI)
$2EF2 End of Runtime Interpreter (RTI)

EXECUTABLE SEGMENT (overlays are loaded from here)

$2EF3-$2EF4 Vector Start of variables l/h
$2EF5-$2EF6 Vector Start of arrays
$2EF7-$2EF8 ??? (same as previous one)
$2EF9-$2EFA Vector for array Z*() definition l/h (only if at least one array is present on source)
$2EFB-$2EFC Vector for start of Data area ($00 ate tail of each element)
$2EFD-$2EFE Vector for end of Data area+1 (Start of P-codes)
$2EFF-$2F05 System array (Z*) definition (only if at least one array is present on source) F4 10 01 DA AA 00 00 (F4=elements; 10=DIM P-code; 01=dimensions; DA AA =name Z*; 00 00 offset from start arrays area)
$2F06 ??? ($16)
$2F07 Data statements - Elements' format: [lenght ($FF=end area)] values $32 $00 Example: "ABC" = 03 41 42 43 32 00
$2F08- P-codes of user source (if it is not an overlay, first P-code is $15 = CLR)
$4F END stmt
(A38C) Variables
Arrays. First is Z*() containing the offset of each other array



---- NUMERIC CONSTANTS

[#EN#]: Literal numbers are encoded to one or more bytes:
$B0-$BF: 0-15
$F0-$FF: 16-31
$A6 [byte]: 32-255
$A7 [byte1] [byte2]: byte1*256+byte2 = -$8000+$7FFF
$A8 [byte1] [byte2] [byte3] [byte4] [byte5]: = Commodore 5 byte floating point number format


---- STRINGS

Literal strings are encoded depending on their length:
$E7 [len] [len*chars]: String of 8 or more chars
$E8: Literal empty string ("")
$E9 [char]: String of 1 char
$EA [2*char]: String of 2 chars
$EB [3*char]: String of 3 chars Example: A$="ABC" would be stored as: $EB $41 $42 $43 $C0 = Literal string of 3 chars, followed by the chars, followed by "assign to variable position 0"
$EC [4*char]: String of 4 chars
$ED [5*char]: String of 5 chars
$EE [6*char]: String of 6 chars
$EF [7*char]: String of 7 chars
For $E8 - $EF the number of characters is embedded in the lower four bits.
Just AND the lower four bits with binary 7.


---- P-CODES

Code Command Syntax / notes RTI entry RTI exit (to Main Loop)

$00 ??? $1782
$01 > Greater than (>), compare two arguments from stack $1782
$02 = Equals (=), compare two arguments from stack $1782
$03 ??? $1782
$04 < Smaller than (<), compare two arguments from stack $1782
$05 <> Not equals (<>), compare two arguments from stack $1782
$06 ??? $1782
$07 + Add two values in stack, also works for strings $1782
$08 - Subtract two values in stack $1782
$09 * Multiply two values in stack $1782
$0A / Divide two values in stack $1782
$0B ??? $1782
$0C AND $1782
$0D OR $1782
$0E NOT Negate value in FPA1 $1782 $1832
$0F ??? (FPA1) $1832

$10 DIM (see example below) $28E1 $1823
$11 FOR $25FF $1816
$12 FOR (with STEP) see example below $25ED $1816
$13 NEXT $26B5 $1816
$14 NEXT NEXT (?) $2695 $1816
$15 CRL $1516 $1836
$16 ??? (reload $39,$3A from $50,$51) $1589 $1816
$17 POKE [arg1] [arg2] $17: POKE arg2, arg1 $2310 $1816
$18 SYS [arg] $18 $3A: SYS arg $2330 $180E
$19 GOTO / RUN $19 [hi] [lo]: GOTO absolute address ($15 $19 [hi] [lo]: RUN) $27D4 $1836
$1A GOSUB $1A [hi] [lo]: GOSUB absolute address $27C7 $1836 Push on stack return address (current +2) + $8D
$1B ON GOTO [arg] $1B: ON arg GOTO $278E $1823
$1C ??? $278E $1823
$1D RETURN $27F0 $1836
$1E ??? $154E $1816
$1F ??? $2833 $1826

$20 $204B $1830
$21 INT() [arg] $21: INT( arg ) $202E $1832
$22 ??? $201B $1832
$23 ??? $1FFE $1830
$24 FRE() $1FFE $1830
$25..$2D ??? $1FFE $1830
$2E PEEK [arg] $2E: PEEK( arg ) $206A $1832
$2F ??? $2087 $1830

$30 $30: ??? $20F4 $1832
$31 VAL [arg] $31: VAL( arg ) $20BA $1832
$32 ASC() [arg] $32: ASC( arg ) $1FCB $1830
$33 CHR$() [arg] $33: CHR$ $211A $1832
$34 LEFT$() [arg] $34: LEFT$ $222A $1832
$35 RIGHT$() [arg] $35: RIGHT$ $222A $1832
$36 MID$() [arg] [arg] $36: MID$ $21F7 $1832
$37 ??? $2853 $1832
$38 ??? $2890 $1832
$39 $2803 $1836
$3A ??? (get next byte to parse) $1832 $1836
$3B ??? $2405 $1832
$3C PRINT; PRINT from stack with ; $23CD $1816/1832
$3D PRINT TAB() PRINT from stack with tab $23CD $1816/1833
$3E PRINT [arg] PRINT from stack with newline $23CD $1816/1834 Example: PRINT "ABC" would be stored as: $EB $41 $42 $43 $3E
$3F ??? $2446 $1816

$40 PRINT SPC() [arg] $40: PRINT SPC( arg ) $2412 $1816/1832
$41 ??? $2412 $1816/1833
$42 ??? $2460 $1832
$43 ??? $23C0 $1832
$44 ??? $2460 $1832
$45 ??? $2458 $1816
$46 ??? $2812 $1816/1832
$47 ??? $175B (jump to Basic execute)
$48 ??? $215F $1830
$49 STOP STOP statement $17F5 $1836
$4A ??? $2345
$4B ??? $2345
$4C ??? $2310
$4D GETKEY [XX] $4D: GETKEY [variable] $2179 XX is code of GET (from $80 to $9F) including destination variable
$4E NEW NEW statement $17F8
$4F END END statement (also EOF) $17FB

$50 (a) INPUT $50 [$A0 ##] $53: INPUT [numeric variable ##] $249C
$50 (b) INPUT $50 [$80-??] $53: INPUT [string variable #] $249C ?
$51 ??? $24E9
$52 THEN GOTO $52 [hi] [lo]: THEN GOTO absolute address $2776
$53 ??? $24A9
$54 ??? $25AB
$55 ??? $24A9
$56 ??? $1751
$57 ??? $24E9
$58 ??? $281C $1832
$59 ??? $161B JMP (0300)
$5A ??? $2761 $1826
$5B ??? $1615 $1816
$5C Not compiled BASIC commands $5C $hh [BASIC arguments] of statement (e.g. SOUND, COLOR, graphics commands, etc.) $2D8E $180E These Basic commands are not compiled and will be executed by standard interpreter (not Austro RTI)
$5D LOAD relocating flag, device,"filename",$5D,$03(?) $2998 $1816 ex.: LOAD "MAIN*",d%,1 = $B1 (1) $91 (d%) $ED (following string 5 chars long) "MAIN*" $5D $03
$5E ??? Save? $299A $1816
$5F ??? Verify? $2997 $1816
$60 ??? $2A4A $1816
$61 ??? $2489 $1816
$62..$6A ??? $2A93 $1816
$6B..$6D ??? $1FFE $1830
$6E ??? $2CC5 $1830
$6F ??? $1FFE $1830
$70 ??? $1FFE $1830
$71 ??? $2BFD $1830
$72 ??? Error handler $2BE0 $1816
$73 ??? $2BA0 $1836
$74 TRAP $74[hb][lb] TRAP[arg] ***Warning: execution bugged!** $2D33 $1823
$75 ??? $2D17 $1830
$76 RESUME $76[hb][lb] RESUME[arg] $2D6E $1836
$77 ??? $2CF5 $1816
$78 ??? $2D66 $180E
$79 VOL [arg] $79: VOL [arg] $160C $1816
$7A ??? $2BF0 $1816
$7B ??? $2CAD $1816
$7C ??? $2C3B $1830
$7D ??? $2D17 $1830
$7E ??? $2D6E $1836
$7F ??? $2BF5 $1816

$80..$9F GET Get value of variable [0-31] to stack $18CE
$A0 $A0 [var]: Get value of variable [var] to stack $18CE
$A1..$A3 ??? $18CE
$A4 Push array element value onto stack (see example below) $18CE
$A5..$BF ??? $18CE
$C0..$DF Assignment, to variable [0-31] = value from stack $184D Example: A$="ABC" would be stored as: $EB $41 $42 $43 $C0 = Literal string of 3 chars, followed by the chars, followed by "assign to variable 0"
$E0 $E0 [var]: Assignment, to variable [var] = value from stack $18B5
$E1..$E3 ??? $19FB
$E4 Assign a value to array element = value from stack (see example below) $1BBA
$E5 ??? $1BBA
$E6..$EF ??? $18CE


FOR loops:

[assignment, to initialize loop variable] [arg, end of loop value] [get value of loop variable] $11 [loop] [get value of loop variable] $14
[assignment, to initialize loop variable] [arg, end of loop value] [arg, step] [get value of loop variable] $12 [loop] [get value of loop variable] $14

The compiler seems to always use [arg] $A0 [var] way of getting the loop variable's value. However, for the first 32 variables, this could be [arg] [$80-$9F] (see above), which can save 2 bytes from each loop.




DIM structure:

Data structure for P-code of DIM A(10): BA 10 01 41 00 00 07.
BA = encoded literal number 10; 10 = DIM; 01 = # dimensions of the array; 41 00 = two byte variable ID. Here 41 00 = "A"; 00 07 = HB LB offset from start of arrays to look up the offset from start of arrays to actual location of "A" - a double offset string.

Further examples: 25 DIM B(30) FE 10 01 42 00 00 09
10 DIM D(12,5) BC B5 10 02 44 00 00 07

Array Examples: B0 Bx E4 07: Push value Bx onto stack. Assign value Bx from stack to first element of first array in the queue.
B0 Bx E4 09: Push value Bx onto stack. Assign value Bx from stack to first element of second array in the queue.
B1 A4 07 3E: Push second element of first array onto stack and print from stack.
B2 A4 0B 3E: push third element of third array onto stack and print from stack.

(Last update: 11/05/2013 SVS)

Copyright © Plus/4 World Team, 2001-2017