|  | Introduction |  |
| | AustroSpeed is a 2-pass 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/Programming |
| Release Date: | Unknown |
| Language: | German |
| Size: | 64K |
| Device Req.: | Disk only |
| Machine: | PAL & NTSC |
| Code Type: | AustroSpeed |
| Distribution: | Crack |
| Released by: | Digimat |
| Notes: | You may need AustroConv by SVS to fix the obtained compiled files. |
Download:
AustroSpeed Decompiled And Other Extras:
User Rating: 9.6/10 (6 votes) |  |
|
| |
| | 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.
The developer (programmer(s) and/or company) is unknown at this time.
AustroSpeed was also released for the C=64 and VIC-20. |
| |
| | Translation of the menu | |
| 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
A note about emulators:
in order to compile programs with AustroSpeed, be sure that full drive emulation is used. |
| |
| | 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.
-------------------
[#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
-------------------
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
$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
-------------------
$00: ???
$01: Greater than (>), compare two arguments from stack
$02: Equals (=), compare two arguments from stack
$03: ???
$04: Smaller than (<), compare two arguments from stack
$05: Not equals (<>), compare two arguments from stack
$06: ???
$07: Add two values in stack, also works for strings
$08: Subtract two values in stack
$09: Multiply two values in stack
$0A: Divide two values in stack
$0B: ???
$0C: AND
$0D: OR
$0E: Negate value in stack?
$0F: ???
$10: DIM (see example below)
$11: FOR
$12: FOR with STEP
$13: NEXT
$14: NEXT
$15: CLR
$16: ???
[arg1] [arg2] $17: POKE arg2, arg1
[arg] $18 $3A: SYS arg
$19 [hi] [lo]: GOTO absolute address ($15 $19 [hi] [lo]: RUN)
$1A [hi] [lo]: GOSUB absolute address
[arg] $1B: ON arg GOTO
$1C: ???
$1D: RETURN
$1E: ???
$1F: ???
$20: ???
[arg] $21: INT( arg )
$22-$2D: ???
[arg] $2E: PEEK( arg )
$2F: ???
$30: ???
[arg] $31: VAL( arg )
[arg] $32: ASC( arg )
[arg] $33: CHR$
[arg] $34: LEFT$
[arg] $35: RIGHT$
[arg] [arg] $36: MID$
$3C: PRINT from stack with ;
$3D: PRINT from stack with tab
$3E: PRINT from stack with newline
[arg] $40: PRINT SPC( arg )
$4E: NEW statement
$4F: END statement (also EOF)
$50 [$A0 ##] $53: INPUT [numeric variable ##]
$50 [$80-??] $53: INPUT [string variable #]
$52 [hi] [lo]: THEN GOTO absolute address
$5C [bytes] $3A: original, uncompiled BASIC tokens and arguments (e.g. SOUND, graphics commands, etc.)
[arg] $79: VOL arg
[$80-$9F]: Get value of variable [0-31] to stack
$A0 [var]: Get value of variable [var] to stack
$A4: Push array element value onto stack (see example below)
[$C0-$DF]: Assignment, variable [0-31] = value from stack
$E0 [var]: Assignment, variable [var] = value from stack
$E4: Assign value to array element = value from stack (see example below)
-------------
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.
-------------
Examples:
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"
PRINT "ABC" would be stored as
$EB $41 $42 $43 $3E
Data structure for pcode of DIMA(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: 15 DIMA(10) BA 10 01 41 00 00 07
25 DIMB(30) FE 10 01 42 00 00 09
10 DIMD(12,5) BC B5 10 02 44 00 00 07
Array Examples: Bx B0 E4 07: Assign value x from stack to first element of first array in the queue.
Bx B0 E4 09: Assign value x 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.
|
| |
Copyright © Plus/4 World Team, 2001-2009 |
Home 
Search 
