|  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: | 1985-05-06 | | Language: | German | | Size: | 64K | | Device Req.: | Disk only | | Machine: | PAL & NTSC | | Code Type: | AustroSpeed | | Distribution: | Commercial/TA | | Retail Price: | 149 DM | | Released by: | Digimat | | Cracked by: | The Raven | | Additional code by: | 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. WANTED: original version. |
Download: AustroSpeed decompiled and other extras:
Austrosimple:
CMS crack:
The Raven crack:
User Rating: 9.4/10 (7 votes)
|  |
|
| |
| | Releases | | Name | Released By | Release Date | Distribution | Product Code | Retail Price | Format | Package | Rarity | Notes | Owned |
| Original release | Digimat | 1985-05-06 | Commercial | | 149 DM | Disk | | Unspecified | | 0 |
| 1 found. |
| |
| | Additional Software Materials | 
Box Contents |
|
| |
| | 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 (using Basic format, then browsable by LIST command) that allows the programmer to know the correspondence 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 true line-number of your Sourcefile affected by the error. Then type "list 22300-" [return] and you see something 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; use the number equal or just greater than the searched one.
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 source files). |
| |
| | 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-2024 |
