BASIC-ROM

From C64-Wiki
Jump to navigationJump to search
C64 BASIC-ROM chip of 1982,
Commodore Nr. 901226-01

The 8 KB memory region from 40960 to 49151 ($A000–$BFFF) contains the BASIC ROM of the C64. The BASIC interpreter itself resides entirely in ROM, mainly within $A000–$BFFF and a smaller section at $E000–$E4D2. To modify or patch any BASIC routines, these ROM areas must first be copied into RAM.

Commodore reused much of the original PET BASIC code almost unchanged, which is why the interpreter ended up scattered across several ROM blocks instead of being neatly grouped together.


Hex address Decimal address Description
$A000 40960 Basic cold start vector ($E394)
$A002 40962 Basic warm start vector ($E37B)
$A004 40964 Text "cbmbasic"
$A00C 40972 Addresses of the BASIC-commands -1 (END, FOR, NEXT, ... 35 addresses of 2 byte each)
$A052 41042 Addresses of the BASIC functions (SGN, INT, ABS, ... 23 addresses of 2 byte each)
$A080 41088 Hierarchy-codes and addresses of the operators -1 (10-times 1+2 Bytes)
$A09E 41118 BASIC key words as string in PETSCII; Bit 7 of the last character is set
$A129 41257 Keywords which have no action addresses - TAB(, TO, SPC(, ...; Bit 7 of the last character is set
$A140 41280 Keywords of the operands + - * etc.; also AND, OR as strings. Bit 7 of the last character is set
$A14D 41293 Keywords of the functions (SGN, INT, ABS, etc.) where bit 7 of the last character is set
$A19E 41374 Error messages (TOO MANY FILES, FILE OPEN, ... ); 29 messages where bit 7 of the last character is set
$A328 41768 Pointer-table to the error messages
$A364 41828 Messages of the interpreter (OK, ERROR IN, READY, BREAK)
$A38A 41866 Routine to search stack for FOR-NEXT and GOSUB
$A3B8 41912 Called at BASIC line insertion. Checks, if enough space available. After completion, $A3BF is executed
$A3BF 41919 Move bytes routine
$A3FB 41979 Check for space on stack
$A408 41992 Array area overflow check
$A435 42037 Output of error message ?OUT OF MEMORY
$A437 42039 Output of an error message, error number in X-register; uses vector in ($0300) to jump to $E38B
$A480 42112 Input waiting loop; uses vector in ($0302) to jump to basic warm start at $A483
$A49C 42140 Delete or Insert program lines and tokenize them
$A533 42291 Re-link BASIC program
$A560 42336 Input of a line via keyboard
$A579 42361 Token crunch -> text line to interpreter code; uses vector in ($0304) to get to $A57C
$A613 42515 Calculate start address of a program line
$A642 42562 BASIC command NEW
$A65E 42590 BASIC command CLR
$A68E 42638 Set program pointer to BASIC-start (loads $7A, $7B with $2B-1, $2C-1)
$A69C 42652 BASIC command LIST
$A717 42775 Convert BASIC code to clear text; uses vector (0306) to jump to $A71A
$A742 42818 BASIC-command FOR: Move 18 bytes to the stack 1) Pointer to the next instruction, 2) actual line number, 3) upper loop value, 4) step with (default value = 1), 5) name of the lop variable and 6) FOR-token.
$A7AE 42926 Interpreter loop, set up next statement for execution
$A7C4 42948 Check for program end
$A7E1 42977 execute BASIC command; uses vector ($0308) to point to $A7E4
$A7ED 42989 Executes BASIC keyword
$A81D 43037 BASIC command RESTORE: set data pointer at $41, $42 to the beginning of the actual basic text
$A82C 43052 BASIC command STOP (also END and program interruption)
$A82F 43055 BASIC command STOP
$A831 43057 BASIC command END
$A857 43095 BASIC command CONT
$A871 43121 BASIC command RUN
$A883 43139 BASIC command GOSUB: Move 5 bytes to the stack. 1) the pointer within CHRGET, 2) the actual line number, 3) token of GOSUB; after that, GOTO ($a8a0) will be called
$A8A0 43168 BASIC command GOTO
$A8D2 43218 BASIC command RETURN
$A8F8 43256 BASIC command DATA
$A906 43270 Find offset of the next separator
$A928 43304 BASIC command IF
$A93B 43323 BASIC command REM
$A94B 43339 BASIC command ON
$A96B 43371 Get decimal number (0...63999, usually a line number) from basic text into $14/$15
$A9A5 43429 BASIC command LET
$A9C4 43460 Value assignment of integer
$A9D6 43478 Value assignment of float
$A9D9 43481 Value assignment of string
$A9E3 43491 Assigns system variable TI$
$AA1D 43549 Check for digit in string, if so, continue with $AA27
$AA27 43559 Add PETSCII digit in string to float accumulator; Assumes C=0
$AA2C 43564 Value assignment to string variable (LET for strings)
$AA80 43648 BASIC command PRINT#
$AA86 43654 BASIC command CMD
$AA9A 43674 Part of the PRINT routine: Output string and continue with the handling of PRINT
$AAA0 43680 BASIC command PRINT
$AAB8 43704 Outputs variable; Numbers will be converted into string first
$AACA 43722 Append $00 as end indicator of string
$AAD7 43735 Outputs a CR/soft hyphenation (#$0D), followed by a line feed/newline (#$0A), if the channel number is 128
$AAF8 43768 TAB( (C=1) and SPC( (C=0)
$AB1E 43806 Output string: Output string, which is indicated by accu/Y reg, until 0 byte or quote is found
$AB3B 43835 Output of cursor right (or space if output not on screen)
$AB3F 43839 Output of a space character
$AB42 43842 Output of cursor right
$AB45 43845 Output of question mark (before error message)
$AB47 43847 Output of a PETSCII character, accu must contain PETSCII value
$AB4D 43853 Output error messages for read commands (INPUT / GET / READ)
$AB7B 43899 BASIC command GET
$ABA5 43941 BASIC command INPUT#
$ABBF 43967 BASIC command INPUT
$ABEA 44010 Get line into buffer
$ABF9 44025 Display input prompt
$AC06 44038 BASIC commands READ, GET and INPUT share this routine and will be distinguished by a flag in $11
$AC35 44085 Input routine for GET
$ACFC 44284 Messages ?EXTRA IGNORED and ?REDO FROM START, both followed by $0D (CR) and end of string $00.
$AD1D 44317 BASIC command NEXT
$AD61 44385 Check for valid loop
$AD8A 44426 FRMNUM: Get expression (FRMEVL) and check, if numeric
$AD9E 44446 FRMEVL: Analyzes any Basic formula expression and shows syntax errors. Set type flag $0D (Number: $00, string $FF). Sety

integer flag $0E (float: $00, integer: $80) puts values in FAC.

$AE83 44675 EVAL: Get next element of an expression; uses vector ($030A) to jump to $AE86
$AEA8 44712 Value for constant PI in 5 bytes float format
$AEF1 44785 Evaluates expression within brackets
$AEF7 44791 Check for closed bracket ")"
$AEFA 44794 Check for open bracket "("
$AEFD 44797 Check for comma
$AF08 44808 Outputs error message ?SYNTAX ERROR and returns to READY state
$AF0D 44813 Calculates NOT
$AF14 44820 Check for reserved variables. Set carry flag, if FAC points to ROM. This indicates the use of one of the reserved variables

TI$, TI, ST.

$AF28 44840 Get variable: Searches the variable list for one of the variables named in $45, $46
$AF48 44872 Reads clock counter and generate string, which contains TI$
$AFA7 44967 Calculate function: Determine type of function and evaluates it
$AFB1 44977 String function: check for open bracket, get expression (FRMEVL), checks for commas, get string.
$AFD1 45009 Analyze numeric function
$AFE6 45030 BASIC commands OR and AND, distinguished by flag $0B (= $FF at OR, $00 at AND).
$B016 45078 Comparison (<, =, > )
$B01B 45083 Numeric comparison
$B02E 45102 String comparison
$B081 45185 BASIC command DIM
$B08B 45195 Check if variable name is valid
$B0E7 45287 Searches variable in list, set variable pointer, create new variable, if name not found
$B113 45331 Check for character
$B11D 45341 Create variable
$B194 45460 Calculate pointer to first element of array
$B1A5 45477 Constant -32768 as float (5 bytes)
$B1AA 45482 Convert FAC to integer and save it to accu/Y reg
$B1B2 45490 Get positive integer from BASIC text
$B1BF 45503 Convert FAC to integer
$B1D1 45521 Get array variable from BASIC text
$B218 45592 Search for array name in pointer ($45, $46)
$B245 45637 Output error message ?BAD SUBSCRIPT
$B248 45640 Output error message ?ILLEGAL QUANTITY
$B24D 45645 Output error message ?REDIM\'D ARRAY
$B261 45665 Create array variable
$B30E 45838 Calculate address of a array element, set pointer ($47)
$B34C 45900 Calculate distance of given array element to the one which ($47) points to and write the result to X reg/Y reg
$B37D 45949 BASIC function FRE
$B391 45969 Convert 16-bit integer in accu/Y reg to float
$B39E 45982 BASIC function POS
$B3A2 45986 Convert the byte in Y reg to float and return it to FAC
$B3A6 45990 Check for direct mode: value $FF in flag $3A indicates direct mode
$B3AE 45998 Output error message ?UNDEF\'D FUNCTION
$B3B3 46003 BASIC command DEF FN
$B3E1 46049 Check syntax of FN
$B3F4 46068 BASIC function FN
$B465 46181 BASIC function STR$
$B475 46197 Make space for inserting into string
$B487 46215 Get string, pointer in accu/Y reg
$B4CA 46282 Store string pointer in descriptor stack
$B4F4 46324 Reserve space for string, length in accu
$B526 46374 Garbage Collection
$B606 46598 Searches in simple variables and arrays for a string which has to be saved by the next Garbage Collection interation.
$B63D 46653 Concatenates two strings
$B67A 46714 Move String to reserved area
$B6A3 46755 String management FRESTR
$B6DB 46811 Remove string pointer from descriptor stack
$B6EC 46828 BASIC function CHR$
$B700 46848 BASIC function LEFT$
$B72C 46892 BASIC function RIGHT$
$B737 46903 BASIC function MID$
$B761 46945 String parameter from stack: Get pointer for string descriptor and write it to $50, $51 and the length to accu (also X-reg)
$B77C 46972 BASIC function LEN
$B782 46978 Get string parameter (length in Y-reg), switch to numeric
$B78B 46987 BASIC function ASC
$B79B 47003 Read and evaluate expression from BASIC text; the 1 byte value is then stored in X-reg and in FAC+4
$B7AD 47021 BASIC function VAL
$B7EB 47083 GETADR and GETBYT: Get 16-bit integer (to $14, $15) and an 8 bit value (to X-reg) - e.g. parameter for WAIT and POKE.
$B7F7 47095 Converts FAC in 2-byte integer (scope 0 ... 65535) to $14, $15 and Y-Reg/accu
$B80D 47117 BASIC function PEEK
$B824 47140 BASIC command POKE
$B82D 47149 BASIC command WAIT
$B849 47177 FAC = FAC + 0,5; for rounding
$B850 47184 FAC = CONSTANT - FAC , accu and Y-register are pointing to CONSTANT (low and high byte)
$B853 47187 FAC = ARG - FAC
$B862 47202 Align exponent of FAC and ARG for addition
$B867 47207 FAC = CONSTANT (accu/Y reg) + FAC
$B86A 47210 FAC = ARG + FAC
$B947 47431 Invert mantissa of FAC
$B97E 47486 Output error message OVERFLOW
$B983 47491 Multiplies with one byte
$B9BC 47548 Constant 1.00 (table of constants in extended floating point format for LOG)
$B9C1 47553 Constant 03 (grade of polynome, then 4th coefficient)
$B9C2 47554 Constant 0.434255942 (1st coefficient)
$B9C7 47559 Constant 0.576584541 (2nd coefficient)
$B9CC 47564 Constant 0.961800759 (3rd coefficient)
$B9D1 47569 Constant 2.885390073 (4th coefficient)
$B9D6 47574 Constant 0.707106781 = 1/SQR(2)
$B9DB 47579 Constant 1.41421356 = SQR(2)
$B9E0 47584 Constant -0.5
$B9E5 47589 Constant 0.693147181 = LOG(2)
$B9EA 47594 BASIC-function LOG
$BA28 47656 FAC = constant (accu/Y reg) * FAC
$BA30 47664 FAC = ARG * FAC
$BA59 47705 Multiplies FAC with one byte and stores result to $26 .. $2A
$BA8C 47756 ARG = constant (accu/Y reg)
$BAB7 47799 Checks FAC and ARG
$BAE2 47842 FAC = FAC * 10
$BAF9 47865 Constant 10 as extended floating point format
$BAFE 47870 FAC = FAC / 10
$BB0F 47887 FAC = constant (accu/Y reg) / FAC
$BB14 47892 FAC = ARG / FAC
$BB8A 48010 Output error message ?DIVISION BY ZERO
$BBA2 48034 Transfer constant (accu/Y reg) to FAC
$BBC7 48071 FAC to accu #4 ($5C to $60)
$BBCA 48074 FAC to accu #3 ($57 to $5B)
$BBD0 48080 FAC to variable (the address, where $49 points to)
$BBFC 48124 ARG to FAC
$BC0C 48140 FAC (rounded) to ARG
$BC1B 48155 Rounds FAC
$BC2B 48171 Get sign of FAC: A=0 if FAC=0, A=1 if FAC positive, A=$FF if FAC negative
$BC39 48185 BASIC function SGN
$BC58 48216 BASIC function ABS
$BC5B 48219 Compare constant (accu/Y reg) with FAC: A=0 if equal, A=1 if FAC greater, A=$FF if FAC

smaller

$BC9B 48283 FAC to integer: converts FAC to 4-byte integer
$BCCC 48332 BASIC function INT
$BCF3 48371 Conversion PETSCII string to floating-point format
$BDB3 48563 Constant 9999999.9 (3 constants for float PETSCII conversion)
$BDB8 48568 Constant 99999999
$BDBD 48573 Constant 1000000000
$BDC2 48578 Output of "IN" and line number (from CURLIN $39, $3A)
$BDCD 48589 Output positive integer number in accu/X reg
$BDDD 48605 Convert FAC to PETSCII string which starts with $0100 and ends with $00. Start address in

accu/Y reg.

$BE68 48744 TI to string: convert TI to PETSCII string which starts with $0100 and ends with $00
$BF11 48913 Constant 0.5
$BF16 48918 Constant tables for integer PETSCII conversion
$BF3A 48954 Constant tables to convert TI to TI$
$BF71 49009 BASIC function SQR
$BF78 49016 Power function FAC = ARG to the power of constant (accu/Y reg)
$BF7B 49019 Power function FAC = ARG to the power of FAC
$BFB4 49076 Makes FAC negative
$BFBF 49087 Constant 1.44269504 = 1/LOG(2) (table of 8 constants to evaluate EXP - polynomal table)
$BFC4 49092 Constant 07: 7 = Grade of polynome (followed by 8 coefficient constants)
$BFC5 49093 Constant 2.14987637 E-5
$BFCA 49098 Constant 1.43523140 E-4
$BFCF 49103 Constant 1.34226348 E-3
$BFD4 49108 Constant 9.61401701 E-3
$BFD9 49113 Constant 5.55051269 E-2
$BFDE 49118 Constant 2.40226385 E-1
$BFE3 49123 Constant 6.93147186 E-1
$BFE8 49128 Constant 1.00000000
$BFED 49133 BASIC function EXP


Links[edit | edit source]

Retrieved from "https://www.c64-wiki.com/index.php?title=BASIC-ROM&oldid=45624"