i86/mikeos-4.1.2/source/features/basic.asm

   1 ; ==================================================================
   2 ; MikeOS -- The Mike Operating System kernel
   3 ; Copyright (C) 2006 - 2011 MikeOS Developers -- see doc/LICENSE.TXT
   4 ;
   5 ; BASIC CODE INTERPRETER
   6 ; ==================================================================
   7
   8 ; ------------------------------------------------------------------
   9 ; Token types
  10
  11 %DEFINE VARIABLE 1
  12 %DEFINE STRING_VAR 2
  13 %DEFINE NUMBER 3
  14 %DEFINE STRING 4
  15 %DEFINE QUOTE 5
  16 %DEFINE CHAR 6
  17 %DEFINE UNKNOWN 7
  18 %DEFINE LABEL 8
  19
  20
  21 ; ------------------------------------------------------------------
  22 ; The BASIC interpreter execution starts here...
  23
  24 os_run_basic:
  25         mov word [orig_stack], sp               ; Save stack pointer -- we might jump to the
  26                                                 ; error printing code and quit in the middle
  27                                                 ; some nested loops, and we want to preserve
  28                                                 ; the stack
  29
  30         mov word [load_point], ax               ; AX was passed as starting location of code
  31
  32         mov word [prog], ax                     ; prog = pointer to current execution point in code
  33
  34         add bx, ax                              ; We were passed the .BAS byte size in BX
  35         dec bx
  36         dec bx
  37         mov word [prog_end], bx                 ; Make note of program end point
  38
  39
  40         call clear_ram                          ; Clear variables etc. from previous run
  41                                                 ; of a BASIC program
  42
  43
  44
  45 mainloop:
  46         call get_token                          ; Get a token from the start of the line
  47
  48         cmp ax, STRING                          ; Is the type a string of characters?
  49         je .keyword                             ; If so, let's see if it's a keyword to process
  50
  51         cmp ax, VARIABLE                        ; If it's a variable at the start of the line,
  52         je near assign                          ; this is an assign (eg "X = Y + 5")
  53
  54         cmp ax, STRING_VAR                      ; Same for a string variable (eg $1)
  55         je near assign
  56
  57         cmp ax, LABEL                           ; Don't need to do anything here - skip
  58         je mainloop
  59
  60         mov si, err_syntax                      ; Otherwise show an error and quit
  61         jmp error
  62
  63
  64 .keyword:
  65         mov si, token                           ; Start trying to match commands
  66
  67         mov di, alert_cmd
  68         call os_string_compare
  69         jc near do_alert
  70
  71         mov di, call_cmd
  72         call os_string_compare
  73         jc near do_call
  74
  75         mov di, cls_cmd
  76         call os_string_compare
  77         jc near do_cls
  78
  79         mov di, cursor_cmd
  80         call os_string_compare
  81         jc near do_cursor
  82
  83         mov di, curschar_cmd
  84         call os_string_compare
  85         jc near do_curschar
  86
  87         mov di, end_cmd
  88         call os_string_compare
  89         jc near do_end
  90
  91         mov di, for_cmd
  92         call os_string_compare
  93         jc near do_for
  94
  95         mov di, getkey_cmd
  96         call os_string_compare
  97         jc near do_getkey
  98
  99         mov di, gosub_cmd
 100         call os_string_compare
 101         jc near do_gosub
 102
 103         mov di, goto_cmd
 104         call os_string_compare
 105         jc near do_goto
 106
 107         mov di, input_cmd
 108         call os_string_compare
 109         jc near do_input
 110
 111         mov di, if_cmd
 112         call os_string_compare
 113         jc near do_if
 114
 115         mov di, load_cmd
 116         call os_string_compare
 117         jc near do_load
 118
 119         mov di, move_cmd
 120         call os_string_compare
 121         jc near do_move
 122
 123         mov di, next_cmd
 124         call os_string_compare
 125         jc near do_next
 126
 127         mov di, pause_cmd
 128         call os_string_compare
 129         jc near do_pause
 130
 131         mov di, peek_cmd
 132         call os_string_compare
 133         jc near do_peek
 134
 135         mov di, poke_cmd
 136         call os_string_compare
 137         jc near do_poke
 138
 139         mov di, port_cmd
 140         call os_string_compare
 141         jc near do_port
 142
 143         mov di, print_cmd
 144         call os_string_compare
 145         jc near do_print
 146
 147         mov di, rand_cmd
 148         call os_string_compare
 149         jc near do_rand
 150
 151         mov di, rem_cmd
 152         call os_string_compare
 153         jc near do_rem
 154
 155         mov di, return_cmd
 156         call os_string_compare
 157         jc near do_return
 158
 159         mov di, save_cmd
 160         call os_string_compare
 161         jc near do_save
 162
 163         mov di, serial_cmd
 164         call os_string_compare
 165         jc near do_serial
 166
 167         mov di, sound_cmd
 168         call os_string_compare
 169         jc near do_sound
 170
 171         mov di, waitkey_cmd
 172         call os_string_compare
 173         jc near do_waitkey
 174
 175         mov si, err_cmd_unknown                 ; Command not found?
 176         jmp error
 177
 178
 179 ; ------------------------------------------------------------------
 180 ; CLEAR RAM
 181
 182 clear_ram:
 183         mov al, 0
 184
 185         mov di, variables
 186         mov cx, 52
 187         rep stosb
 188
 189         mov di, for_variables
 190         mov cx, 52
 191         rep stosb
 192
 193         mov di, for_code_points
 194         mov cx, 52
 195         rep stosb
 196
 197         mov byte [gosub_depth], 0
 198
 199         mov di, gosub_points
 200         mov cx, 20
 201         rep stosb
 202
 203         mov di, string_vars
 204         mov cx, 1024
 205         rep stosb
 206
 207         ret
 208
 209
 210 ; ------------------------------------------------------------------
 211 ; ASSIGNMENT
 212
 213 assign:
 214         cmp ax, VARIABLE                        ; Are we starting with a number var?
 215         je .do_num_var
 216
 217         mov di, string_vars                     ; Otherwise it's a string var
 218         mov ax, 128
 219         mul bx                                  ; (BX = string number, passed back from get_token)
 220         add di, ax
 221
 222         push di
 223
 224         call get_token
 225         mov byte al, [token]
 226         cmp al, '='
 227         jne near .error
 228
 229         call get_token
 230         cmp ax, QUOTE
 231         je .second_is_quote
 232
 233         cmp ax, STRING_VAR
 234         jne near .error
 235
 236         mov si, string_vars                     ; Otherwise it's a string var
 237         mov ax, 128
 238         mul bx                                  ; (BX = string number, passed back from get_token)
 239         add si, ax
 240
 241         pop di
 242         call os_string_copy
 243
 244         jmp mainloop
 245
 246
 247 .second_is_quote:
 248         mov si, token
 249         pop di
 250         call os_string_copy
 251
 252         jmp mainloop
 253
 254
 255 .do_num_var:
 256         mov ax, 0
 257         mov byte al, [token]
 258         mov byte [.tmp], al
 259
 260         call get_token
 261         mov byte al, [token]
 262         cmp al, '='
 263         jne near .error
 264
 265         call get_token
 266         cmp ax, NUMBER
 267         je .second_is_num
 268
 269         cmp ax, VARIABLE
 270         je .second_is_variable
 271
 272         cmp ax, STRING
 273         je near .second_is_string
 274
 275         cmp ax, UNKNOWN
 276         jne near .error
 277
 278         mov byte al, [token]                    ; Address of string var?
 279         cmp al, '&'
 280         jne near .error
 281
 282         call get_token                          ; Let's see if there's a string var
 283         cmp ax, STRING_VAR
 284         jne near .error
 285
 286         mov di, string_vars
 287         mov ax, 128
 288         mul bx
 289         add di, ax
 290
 291         mov bx, di
 292
 293         mov byte al, [.tmp]
 294         call set_var
 295
 296         jmp mainloop
 297
 298
 299 .second_is_variable:
 300         mov ax, 0
 301         mov byte al, [token]
 302
 303         call get_var
 304         mov bx, ax
 305         mov byte al, [.tmp]
 306         call set_var
 307
 308         jmp .check_for_more
 309
 310
 311 .second_is_num:
 312         mov si, token
 313         call os_string_to_int
 314
 315         mov bx, ax                              ; Number to insert in variable table
 316
 317         mov ax, 0
 318         mov byte al, [.tmp]
 319
 320         call set_var
 321
 322
 323         ; The assignment could be simply "X = 5" etc. Or it could be
 324         ; "X = Y + 5" -- ie more complicated. So here we check to see if
 325         ; there's a delimiter...
 326
 327 .check_for_more:
 328         mov word ax, [prog]                     ; Save code location in case there's no delimiter
 329         mov word [.tmp_loc], ax
 330
 331         call get_token                          ; Any more to deal with in this assignment?
 332         mov byte al, [token]
 333         cmp al, '+'
 334         je .theres_more
 335         cmp al, '-'
 336         je .theres_more
 337         cmp al, '*'
 338         je .theres_more
 339         cmp al, '/'
 340         je .theres_more
 341         cmp al, '%'
 342         je .theres_more
 343
 344         mov word ax, [.tmp_loc]                 ; Not a delimiter, so step back before the token
 345         mov word [prog], ax                     ; that we just grabbed
 346
 347         jmp mainloop                            ; And go back to the code interpreter!
 348
 349
 350 .theres_more:
 351         mov byte [.delim], al
 352
 353         call get_token
 354         cmp ax, VARIABLE
 355         je .handle_variable
 356
 357         mov si, token
 358         call os_string_to_int
 359         mov bx, ax
 360
 361         mov ax, 0
 362         mov byte al, [.tmp]
 363
 364         call get_var                            ; This also points SI at right place in variable table
 365
 366         cmp byte [.delim], '+'
 367         jne .not_plus
 368
 369         add ax, bx
 370         jmp .finish
 371
 372 .not_plus:
 373         cmp byte [.delim], '-'
 374         jne .not_minus
 375
 376         sub ax, bx
 377         jmp .finish
 378
 379 .not_minus:
 380         cmp byte [.delim], '*'
 381         jne .not_times
 382
 383         mul bx
 384         jmp .finish
 385
 386 .not_times:
 387         cmp byte [.delim], '/'
 388         jne .not_divide
 389
 390         mov dx, 0
 391         div bx
 392         jmp .finish
 393
 394 .not_divide:
 395         mov dx, 0
 396         div bx
 397         mov ax, dx                              ; Get remainder
 398
 399 .finish:
 400         mov bx, ax
 401         mov byte al, [.tmp]
 402         call set_var
 403
 404         jmp .check_for_more
 405
 406
 407 .handle_variable:
 408         mov ax, 0
 409         mov byte al, [token]
 410
 411         call get_var
 412
 413         mov bx, ax
 414
 415         mov ax, 0
 416         mov byte al, [.tmp]
 417
 418         call get_var
 419
 420         cmp byte [.delim], '+'
 421         jne .vnot_plus
 422
 423         add ax, bx
 424         jmp .vfinish
 425
 426 .vnot_plus:
 427         cmp byte [.delim], '-'
 428         jne .vnot_minus
 429
 430         sub ax, bx
 431         jmp .vfinish
 432
 433 .vnot_minus:
 434         cmp byte [.delim], '*'
 435         jne .vnot_times
 436
 437         mul bx
 438         jmp .vfinish
 439
 440 .vnot_times:
 441         cmp byte [.delim], '/'
 442         jne .vnot_divide
 443
 444         mov dx, 0
 445         div bx
 446         jmp .finish
 447
 448 .vnot_divide:
 449         mov dx, 0
 450         div bx
 451         mov ax, dx                              ; Get remainder
 452
 453 .vfinish:
 454         mov bx, ax
 455         mov byte al, [.tmp]
 456         call set_var
 457
 458         jmp .check_for_more
 459
 460
 461 .second_is_string:
 462         mov di, token
 463         mov si, progstart_keyword
 464         call os_string_compare
 465         je .is_progstart
 466
 467         mov si, ramstart_keyword
 468         call os_string_compare
 469         je .is_ramstart
 470
 471         jmp .error
 472
 473 .is_progstart:
 474         mov ax, 0
 475         mov byte al, [.tmp]
 476
 477         mov word bx, [load_point]
 478         call set_var
 479
 480         jmp mainloop
 481
 482
 483
 484 .is_ramstart:
 485         mov ax, 0
 486         mov byte al, [.tmp]
 487
 488         mov word bx, [prog_end]
 489         inc bx
 490         inc bx
 491         inc bx
 492         call set_var
 493
 494         jmp mainloop
 495
 496
 497 .error:
 498         mov si, err_syntax
 499         jmp error
 500
 501
 502         .tmp            db 0
 503         .tmp_loc        dw 0
 504         .delim          db 0
 505
 506
 507 ; ==================================================================
 508 ; SPECIFIC COMMAND CODE STARTS HERE
 509
 510 ; ------------------------------------------------------------------
 511 ; ALERT
 512
 513 do_alert:
 514         call get_token
 515
 516         cmp ax, QUOTE
 517         je .is_quote
 518
 519         mov si, err_syntax
 520         jmp error
 521
 522 .is_quote:
 523         mov ax, token                           ; First string for alert box
 524         mov bx, 0                               ; Others are blank
 525         mov cx, 0
 526         mov dx, 0                               ; One-choice box
 527         call os_dialog_box
 528         jmp mainloop
 529
 530
 531 ; ------------------------------------------------------------------
 532 ; CALL
 533
 534 do_call:
 535         call get_token
 536         cmp ax, NUMBER
 537         je .is_number
 538
 539         mov ax, 0
 540         mov byte al, [token]
 541         call get_var
 542         jmp .execute_call
 543
 544 .is_number:
 545         mov si, token
 546         call os_string_to_int
 547
 548 .execute_call:
 549         mov bx, 0
 550         mov cx, 0
 551         mov dx, 0
 552         mov di, 0
 553         mov si, 0
 554
 555         call ax
 556
 557         jmp mainloop
 558
 559
 560
 561 ; ------------------------------------------------------------------
 562 ; CLS
 563
 564 do_cls:
 565         call os_clear_screen
 566         jmp mainloop
 567
 568
 569 ; ------------------------------------------------------------------
 570 ; CURSOR
 571
 572 do_cursor:
 573         call get_token
 574
 575         mov si, token
 576         mov di, .on_str
 577         call os_string_compare
 578         jc .turn_on
 579
 580         mov si, token
 581         mov di, .off_str
 582         call os_string_compare
 583         jc .turn_off
 584
 585         mov si, err_syntax
 586         jmp error
 587
 588 .turn_on:
 589         call os_show_cursor
 590         jmp mainloop
 591
 592 .turn_off:
 593         call os_hide_cursor
 594         jmp mainloop
 595
 596
 597         .on_str db "ON", 0
 598         .off_str db "OFF", 0
 599
 600
 601 ; ------------------------------------------------------------------
 602 ; CURSCHAR
 603
 604 do_curschar:
 605         call get_token
 606
 607         cmp ax, VARIABLE
 608         je .is_ok
 609
 610         mov si, err_syntax
 611         jmp error
 612
 613 .is_ok:
 614         mov ax, 0
 615         mov byte al, [token]
 616
 617         push ax                         ; Store variable we're going to use
 618
 619         mov ah, 08h
 620         mov bx, 0
 621         int 10h                         ; Get char at current cursor location
 622
 623         mov bx, 0                       ; We only want the lower byte (the char, not attribute)
 624         mov bl, al
 625
 626         pop ax                          ; Get the variable back
 627
 628         call set_var                    ; And store the value
 629
 630         jmp mainloop
 631
 632
 633 ; ------------------------------------------------------------------
 634 ; END
 635
 636 do_end:
 637         mov word sp, [orig_stack]
 638         ret
 639
 640
 641 ; ------------------------------------------------------------------
 642 ; FOR
 643
 644 do_for:
 645         call get_token                          ; Get the variable we're using in this loop
 646
 647         cmp ax, VARIABLE
 648         jne near .error
 649
 650         mov ax, 0
 651         mov byte al, [token]
 652         mov byte [.tmp_var], al                 ; Store it in a temporary location for now
 653
 654         call get_token
 655
 656         mov ax, 0                               ; Check it's followed up with '='
 657         mov byte al, [token]
 658         cmp al, '='
 659         jne .error
 660
 661         call get_token                          ; Next we want a number
 662
 663         cmp ax, NUMBER
 664         jne .error
 665
 666         mov si, token                           ; Convert it
 667         call os_string_to_int
 668
 669
 670         ; At this stage, we've read something like "FOR X = 1"
 671         ; so let's store that 1 in the variable table
 672
 673         mov bx, ax
 674         mov ax, 0
 675         mov byte al, [.tmp_var]
 676         call set_var
 677
 678
 679         call get_token                          ; Next we're looking for "TO"
 680
 681         cmp ax, STRING
 682         jne .error
 683
 684         mov ax, token
 685         call os_string_uppercase
 686
 687         mov si, token
 688         mov di, .to_string
 689         call os_string_compare
 690         jnc .error
 691
 692
 693         ; So now we're at "FOR X = 1 TO"
 694
 695         call get_token
 696
 697         cmp ax, NUMBER
 698         jne .error
 699
 700         mov si, token                                   ; Get target number
 701         call os_string_to_int
 702
 703         mov bx, ax
 704
 705         mov ax, 0
 706         mov byte al, [.tmp_var]
 707
 708         sub al, 65                                      ; Store target number in table
 709         mov di, for_variables
 710         add di, ax
 711         add di, ax
 712         mov ax, bx
 713         stosw
 714
 715
 716         ; So we've got the variable, assigned it the starting number, and put into
 717         ; our table the limit it should reach. But we also need to store the point in
 718         ; code after the FOR line we should return to if NEXT X doesn't complete the loop...
 719
 720         mov ax, 0
 721         mov byte al, [.tmp_var]
 722
 723         sub al, 65                                      ; Store code position to return to in table
 724         mov di, for_code_points
 725         add di, ax
 726         add di, ax
 727         mov word ax, [prog]
 728         stosw
 729
 730         jmp mainloop
 731
 732
 733 .error:
 734         mov si, err_syntax
 735         jmp error
 736
 737
 738         .tmp_var        db 0
 739         .to_string      db 'TO', 0
 740
 741
 742 ; ------------------------------------------------------------------
 743 ; GETKEY
 744
 745 do_getkey:
 746         call get_token
 747         cmp ax, VARIABLE
 748         je .is_variable
 749
 750         mov si, err_syntax
 751         jmp error
 752
 753 .is_variable:
 754         mov ax, 0
 755         mov byte al, [token]
 756
 757         push ax
 758
 759         call os_check_for_key
 760
 761         mov bx, 0
 762         mov bl, al
 763
 764         pop ax
 765
 766         call set_var
 767
 768         jmp mainloop
 769
 770
 771 ; ------------------------------------------------------------------
 772 ; GOSUB
 773
 774 do_gosub:
 775         call get_token                          ; Get the number (label)
 776
 777         cmp ax, STRING
 778         je .is_ok
 779
 780         mov si, err_goto_notlabel
 781         jmp error
 782
 783 .is_ok:
 784         mov si, token                           ; Back up this label
 785         mov di, .tmp_token
 786         call os_string_copy
 787
 788         mov ax, .tmp_token
 789         call os_string_length
 790
 791         mov di, .tmp_token                      ; Add ':' char to end for searching
 792         add di, ax
 793         mov al, ':'
 794         stosb
 795         mov al, 0
 796         stosb
 797
 798
 799         inc byte [gosub_depth]
 800
 801         mov ax, 0
 802         mov byte al, [gosub_depth]              ; Get current GOSUB nest level
 803
 804         cmp al, 9
 805         jle .within_limit
 806
 807         mov si, err_nest_limit
 808         jmp error
 809
 810
 811 .within_limit:
 812         mov di, gosub_points                    ; Move into our table of pointers
 813         add di, ax                              ; Table is words (not bytes)
 814         add di, ax
 815         mov word ax, [prog]
 816         stosw                                   ; Store current location before jump
 817
 818
 819         mov word ax, [load_point]
 820         mov word [prog], ax                     ; Return to start of program to find label
 821
 822 .loop:
 823         call get_token
 824
 825         cmp ax, LABEL
 826         jne .line_loop
 827
 828         mov si, token
 829         mov di, .tmp_token
 830         call os_string_compare
 831         jc mainloop
 832
 833
 834 .line_loop:                                     ; Go to end of line
 835         mov word si, [prog]
 836         mov byte al, [si]
 837         inc word [prog]
 838         cmp al, 10
 839         jne .line_loop
 840
 841         mov word ax, [prog]
 842         mov word bx, [prog_end]
 843         cmp ax, bx
 844         jg .past_end
 845
 846         jmp .loop
 847
 848
 849 .past_end:
 850         mov si, err_label_notfound
 851         jmp error
 852
 853
 854         .tmp_token      times 30 db 0
 855
 856
 857 ; ------------------------------------------------------------------
 858 ; GOTO
 859
 860 do_goto:
 861         call get_token                          ; Get the next token
 862
 863         cmp ax, STRING
 864         je .is_ok
 865
 866         mov si, err_goto_notlabel
 867         jmp error
 868
 869 .is_ok:
 870         mov si, token                           ; Back up this label
 871         mov di, .tmp_token
 872         call os_string_copy
 873
 874         mov ax, .tmp_token
 875         call os_string_length
 876
 877         mov di, .tmp_token                      ; Add ':' char to end for searching
 878         add di, ax
 879         mov al, ':'
 880         stosb
 881         mov al, 0
 882         stosb
 883
 884         mov word ax, [load_point]
 885         mov word [prog], ax                     ; Return to start of program to find label
 886
 887 .loop:
 888         call get_token
 889
 890         cmp ax, LABEL
 891         jne .line_loop
 892
 893         mov si, token
 894         mov di, .tmp_token
 895         call os_string_compare
 896         jc mainloop
 897
 898 .line_loop:                                     ; Go to end of line
 899         mov word si, [prog]
 900         mov byte al, [si]
 901         inc word [prog]
 902
 903         cmp al, 10
 904         jne .line_loop
 905
 906         mov word ax, [prog]
 907         mov word bx, [prog_end]
 908         cmp ax, bx
 909         jg .past_end
 910
 911         jmp .loop
 912
 913 .past_end:
 914         mov si, err_label_notfound
 915         jmp error
 916
 917
 918         .tmp_token times        30 db 0
 919
 920
 921 ; ------------------------------------------------------------------
 922 ; IF
 923
 924 do_if:
 925         call get_token
 926
 927         cmp ax, VARIABLE                        ; If can only be followed by a variable
 928         je .num_var
 929
 930         cmp ax, STRING_VAR
 931         je near .string_var
 932
 933         mov si, err_syntax
 934         jmp error
 935
 936 .num_var:
 937         mov ax, 0
 938         mov byte al, [token]
 939         call get_var
 940
 941         mov dx, ax                              ; Store value of first part of comparison
 942
 943         call get_token                          ; Get the delimiter
 944         mov byte al, [token]
 945         cmp al, '='
 946         je .equals
 947         cmp al, '>'
 948         je .greater
 949         cmp al, '<'
 950         je .less
 951
 952         mov si, err_syntax                      ; If not one of the above, error out
 953         jmp error
 954
 955 .equals:
 956         call get_token                          ; Is this 'X = Y' (equals another variable?)
 957
 958         cmp ax, CHAR
 959         je .equals_char
 960
 961         mov byte al, [token]
 962         call is_letter
 963         jc .equals_var
 964
 965         mov si, token                           ; Otherwise it's, eg 'X = 1' (a number)
 966         call os_string_to_int
 967
 968         cmp ax, dx                              ; On to the THEN bit if 'X = num' matches
 969         je near .on_to_then
 970
 971         jmp .finish_line                        ; Otherwise skip the rest of the line
 972
 973
 974 .equals_char:
 975         mov ax, 0
 976         mov byte al, [token]
 977
 978         cmp ax, dx
 979         je near .on_to_then
 980
 981         jmp .finish_line
 982
 983
 984 .equals_var:
 985         mov ax, 0
 986         mov byte al, [token]
 987
 988         call get_var
 989
 990         cmp ax, dx                              ; Do the variables match?
 991         je near .on_to_then                             ; On to the THEN bit if so
 992
 993         jmp .finish_line                        ; Otherwise skip the rest of the line
 994
 995
 996 .greater:
 997         call get_token                          ; Greater than a variable or number?
 998         mov byte al, [token]
 999         call is_letter
1000         jc .greater_var
1001
1002         mov si, token                           ; Must be a number here...
1003         call os_string_to_int
1004
1005         cmp ax, dx
1006         jl near .on_to_then
1007
1008         jmp .finish_line
1009
1010 .greater_var:                                   ; Variable in this case
1011         mov ax, 0
1012         mov byte al, [token]
1013
1014         call get_var
1015
1016         cmp ax, dx                              ; Make the comparison!
1017         jl .on_to_then
1018
1019         jmp .finish_line
1020
1021 .less:
1022         call get_token
1023         mov byte al, [token]
1024         call is_letter
1025         jc .less_var
1026
1027         mov si, token
1028         call os_string_to_int
1029
1030         cmp ax, dx
1031         jg .on_to_then
1032
1033         jmp .finish_line
1034
1035 .less_var:
1036         mov ax, 0
1037         mov byte al, [token]
1038
1039         call get_var
1040
1041         cmp ax, dx
1042         jg .on_to_then
1043
1044         jmp .finish_line
1045
1046
1047
1048 .string_var:
1049         mov byte [.tmp_string_var], bl
1050
1051         call get_token
1052
1053         mov byte al, [token]
1054         cmp al, '='
1055         jne .error
1056
1057         call get_token
1058         cmp ax, STRING_VAR
1059         je .second_is_string_var
1060
1061         cmp ax, QUOTE
1062         jne .error
1063
1064         mov si, string_vars
1065         mov ax, 128
1066         mul bx
1067         add si, ax
1068         mov di, token
1069         call os_string_compare
1070         je .on_to_then
1071
1072         jmp .finish_line
1073
1074
1075 .second_is_string_var:
1076         mov si, string_vars
1077         mov ax, 128
1078         mul bx
1079         add si, ax
1080
1081         mov di, string_vars
1082         mov bx, 0
1083         mov byte bl, [.tmp_string_var]
1084         mov ax, 128
1085         mul bx
1086         add di, ax
1087
1088         call os_string_compare
1089         jc .on_to_then
1090
1091         jmp .finish_line
1092
1093
1094 .on_to_then:
1095         call get_token
1096
1097         mov si, token
1098         mov di, then_keyword
1099         call os_string_compare
1100
1101         jc .then_present
1102
1103         mov si, err_syntax
1104         jmp error
1105
1106 .then_present:                          ; Continue rest of line like any other command!
1107         jmp mainloop
1108
1109
1110 .finish_line:                           ; IF wasn't fulfilled, so skip rest of line
1111         mov word si, [prog]
1112         mov byte al, [si]
1113         inc word [prog]
1114         cmp al, 10
1115         jne .finish_line
1116
1117         jmp mainloop
1118
1119
1120 .error:
1121         mov si, err_syntax
1122         jmp error
1123
1124
1125         .tmp_string_var         db 0
1126
1127
1128 ; ------------------------------------------------------------------
1129 ; INPUT
1130
1131 do_input:
1132         mov al, 0                               ; Clear string from previous usage
1133         mov di, .tmpstring
1134         mov cx, 128
1135         rep stosb
1136
1137         call get_token
1138
1139         cmp ax, VARIABLE                        ; We can only INPUT to variables!
1140         je .number_var
1141
1142         cmp ax, STRING_VAR
1143         je .string_var
1144
1145         mov si, err_syntax
1146         jmp error
1147
1148 .number_var:
1149         mov ax, .tmpstring                      ; Get input from the user
1150         call os_input_string
1151
1152         mov ax, .tmpstring
1153         call os_string_length
1154         cmp ax, 0
1155         jne .char_entered
1156
1157         mov byte [.tmpstring], '0'              ; If enter hit, fill variable with zero
1158         mov byte [.tmpstring + 1], 0
1159
1160 .char_entered:
1161         mov si, .tmpstring                      ; Convert to integer format
1162         call os_string_to_int
1163         mov bx, ax
1164
1165         mov ax, 0
1166         mov byte al, [token]                    ; Get the variable where we're storing it...
1167         call set_var                            ; ...and store it!
1168
1169         call os_print_newline
1170
1171         jmp mainloop
1172
1173
1174 .string_var:
1175         push bx
1176
1177         mov ax, .tmpstring
1178         call os_input_string
1179
1180         mov si, .tmpstring
1181         mov di, string_vars
1182
1183         pop bx
1184
1185         mov ax, 128
1186         mul bx
1187
1188         add di, ax
1189         call os_string_copy
1190
1191         call os_print_newline
1192
1193         jmp mainloop
1194
1195
1196         .tmpstring      times 128 db 0
1197
1198
1199 ; ------------------------------------------------------------------
1200 ; LOAD
1201
1202 do_load:
1203         call get_token
1204         cmp ax, QUOTE
1205         je .is_quote
1206
1207         cmp ax, STRING_VAR
1208         jne .error
1209
1210         mov si, string_vars
1211         mov ax, 128
1212         mul bx
1213         add si, ax
1214         jmp .get_position
1215
1216 .is_quote:
1217         mov si, token
1218
1219 .get_position:
1220         mov ax, si
1221         call os_file_exists
1222         jc .file_not_exists
1223
1224         mov dx, ax                      ; Store for now
1225
1226         call get_token
1227
1228         cmp ax, VARIABLE
1229         je .second_is_var
1230
1231         cmp ax, NUMBER
1232         jne .error
1233
1234         mov si, token
1235         call os_string_to_int
1236
1237 .load_part:
1238         mov cx, ax
1239
1240         mov ax, dx
1241
1242         call os_load_file
1243
1244         mov ax, 0
1245         mov byte al, 'S'
1246         call set_var
1247
1248         mov ax, 0
1249         mov byte al, 'R'
1250         mov bx, 0
1251         call set_var
1252
1253         jmp mainloop
1254
1255
1256 .second_is_var:
1257         mov ax, 0
1258         mov byte al, [token]
1259         call get_var
1260         jmp .load_part
1261
1262
1263 .file_not_exists:
1264         mov ax, 0
1265         mov byte al, 'R'
1266         mov bx, 1
1267         call set_var
1268
1269         call get_token                          ; Skip past the loading point -- unnecessary now
1270
1271         jmp mainloop
1272
1273
1274 .error:
1275         mov si, err_syntax
1276         jmp error
1277
1278
1279 ; ------------------------------------------------------------------
1280 ; MOVE
1281
1282 do_move:
1283         call get_token
1284
1285         cmp ax, VARIABLE
1286         je .first_is_var
1287
1288         mov si, token
1289         call os_string_to_int
1290         mov dl, al
1291         jmp .onto_second
1292
1293 .first_is_var:
1294         mov ax, 0
1295         mov byte al, [token]
1296         call get_var
1297         mov dl, al
1298
1299 .onto_second:
1300         call get_token
1301
1302         cmp ax, VARIABLE
1303         je .second_is_var
1304
1305         mov si, token
1306         call os_string_to_int
1307         mov dh, al
1308         jmp .finish
1309
1310 .second_is_var:
1311         mov ax, 0
1312         mov byte al, [token]
1313         call get_var
1314         mov dh, al
1315
1316 .finish:
1317         call os_move_cursor
1318
1319         jmp mainloop
1320
1321
1322 ; ------------------------------------------------------------------
1323 ; NEXT
1324
1325 do_next:
1326         call get_token
1327
1328         cmp ax, VARIABLE                        ; NEXT must be followed by a variable
1329         jne .error
1330
1331         mov ax, 0
1332         mov byte al, [token]
1333         call get_var
1334
1335         inc ax                                  ; NEXT increments the variable, of course!
1336
1337         mov bx, ax
1338
1339         mov ax, 0
1340         mov byte al, [token]
1341
1342         sub al, 65
1343         mov si, for_variables
1344         add si, ax
1345         add si, ax
1346         lodsw                                   ; Get the target number from the table
1347
1348         inc ax                                  ; (Make the loop inclusive of target number)
1349         cmp ax, bx                              ; Do the variable and target match?
1350         je .loop_finished
1351
1352         mov ax, 0                               ; If not, store the updated variable
1353         mov byte al, [token]
1354         call set_var
1355
1356         mov ax, 0                               ; Find the code point and go back
1357         mov byte al, [token]
1358         sub al, 65
1359         mov si, for_code_points
1360         add si, ax
1361         add si, ax
1362         lodsw
1363
1364         mov word [prog], ax
1365         jmp mainloop
1366
1367
1368 .loop_finished:
1369         jmp mainloop
1370
1371 .error:
1372         mov si, err_syntax
1373         jmp error
1374
1375
1376 ; ------------------------------------------------------------------
1377 ; PAUSE
1378
1379 do_pause:
1380         call get_token
1381
1382         cmp ax, VARIABLE
1383         je .is_var
1384
1385         mov si, token
1386         call os_string_to_int
1387         jmp .finish
1388
1389 .is_var:
1390         mov ax, 0
1391         mov byte al, [token]
1392         call get_var
1393
1394 .finish:
1395         call os_pause
1396         jmp mainloop
1397
1398
1399 ; ------------------------------------------------------------------
1400 ; PEEK
1401
1402 do_peek:
1403         call get_token
1404
1405         cmp ax, VARIABLE
1406         jne .error
1407
1408         mov ax, 0
1409         mov byte al, [token]
1410         mov byte [.tmp_var], al
1411
1412         call get_token
1413
1414         cmp ax, VARIABLE
1415         je .dereference
1416
1417         cmp ax, NUMBER
1418         jne .error
1419
1420         mov si, token
1421         call os_string_to_int
1422
1423 .store:
1424         mov si, ax
1425         mov bx, 0
1426         mov byte bl, [si]
1427         mov ax, 0
1428         mov byte al, [.tmp_var]
1429         call set_var
1430
1431         jmp mainloop
1432
1433 .dereference:
1434         mov byte al, [token]
1435         call get_var
1436         jmp .store
1437
1438 .error:
1439         mov si, err_syntax
1440         jmp error
1441
1442
1443         .tmp_var        db 0
1444
1445
1446 ; ------------------------------------------------------------------
1447 ; POKE
1448
1449 do_poke:
1450         call get_token
1451
1452         cmp ax, VARIABLE
1453         je .first_is_var
1454
1455         cmp ax, NUMBER
1456         jne .error
1457
1458         mov si, token
1459         call os_string_to_int
1460
1461         cmp ax, 255
1462         jg .error
1463
1464         mov byte [.first_value], al
1465         jmp .onto_second
1466
1467
1468 .first_is_var:
1469         mov ax, 0
1470         mov byte al, [token]
1471         call get_var
1472
1473         mov byte [.first_value], al
1474
1475 .onto_second:
1476         call get_token
1477
1478         cmp ax, VARIABLE
1479         je .second_is_var
1480
1481         cmp ax, NUMBER
1482         jne .error
1483
1484         mov si, token
1485         call os_string_to_int
1486
1487 .got_value:
1488         mov di, ax
1489         mov ax, 0
1490         mov byte al, [.first_value]
1491         mov byte [di], al
1492
1493         jmp mainloop
1494
1495 .second_is_var:
1496         mov ax, 0
1497         mov byte al, [token]
1498         call get_var
1499         jmp .got_value
1500
1501 .error:
1502         mov si, err_syntax
1503         jmp error
1504
1505
1506         .first_value    db 0
1507
1508
1509 ; ------------------------------------------------------------------
1510 ; PORT
1511
1512 do_port:
1513         call get_token
1514         mov si, token
1515
1516         mov di, .out_cmd
1517         call os_string_compare
1518         jc .do_out_cmd
1519
1520         mov di, .in_cmd
1521         call os_string_compare
1522         jc .do_in_cmd
1523
1524         jmp .error
1525
1526
1527 .do_out_cmd:
1528         call get_token
1529         cmp ax, NUMBER
1530         jne .error
1531
1532         mov si, token
1533         call os_string_to_int           ; Now AX = port number
1534         mov dx, ax
1535
1536         call get_token
1537         cmp ax, NUMBER
1538         je .out_is_num
1539
1540         cmp ax, VARIABLE
1541         je .out_is_var
1542
1543         jmp .error
1544
1545 .out_is_num:
1546         mov si, token
1547         call os_string_to_int
1548         call os_port_byte_out
1549         jmp mainloop
1550
1551 .out_is_var:
1552         mov ax, 0
1553         mov byte al, [token]
1554         call get_var
1555
1556         call os_port_byte_out
1557         jmp mainloop
1558
1559
1560 .do_in_cmd:
1561         call get_token
1562         cmp ax, NUMBER
1563         jne .error
1564
1565         mov si, token
1566         call os_string_to_int
1567         mov dx, ax
1568
1569         call get_token
1570         cmp ax, VARIABLE
1571         jne .error
1572
1573         mov byte cl, [token]
1574
1575         call os_port_byte_in
1576         mov bx, 0
1577         mov bl, al
1578
1579         mov al, cl
1580         call set_var
1581
1582         jmp mainloop
1583
1584
1585 .error:
1586         mov si, err_syntax
1587         jmp error
1588
1589
1590         .out_cmd        db "OUT", 0
1591         .in_cmd         db "IN", 0
1592
1593
1594 ; ------------------------------------------------------------------
1595 ; PRINT
1596
1597 do_print:
1598         call get_token                          ; Get part after PRINT
1599
1600         cmp ax, QUOTE                           ; What type is it?
1601         je .print_quote
1602
1603         cmp ax, VARIABLE                        ; Numerical variable (eg X)
1604         je .print_var
1605
1606         cmp ax, STRING_VAR                      ; String variable (eg $1)
1607         je .print_string_var
1608
1609         cmp ax, STRING                          ; Special keyword (eg CHR or HEX)
1610         je .print_keyword
1611
1612         mov si, err_print_type                  ; We only print quoted strings and vars!
1613         jmp error
1614
1615
1616 .print_var:
1617         mov ax, 0
1618         mov byte al, [token]
1619         call get_var                            ; Get its value
1620
1621         call os_int_to_string                   ; Convert to string
1622         mov si, ax
1623         call os_print_string
1624
1625         jmp .newline_or_not
1626
1627
1628 .print_quote:                                   ; If it's quoted text, print it
1629         mov si, token
1630         call os_print_string
1631
1632         jmp .newline_or_not
1633
1634
1635 .print_string_var:
1636         mov si, string_vars
1637         mov ax, 128
1638         mul bx
1639         add si, ax
1640         call os_print_string
1641
1642         jmp .newline_or_not
1643
1644
1645 .print_keyword:
1646         mov si, token
1647         mov di, chr_keyword
1648         call os_string_compare
1649         jc .is_chr
1650
1651         mov di, hex_keyword
1652         call os_string_compare
1653         jc .is_hex
1654
1655         mov si, err_syntax
1656         jmp error
1657
1658 .is_chr:
1659         call get_token
1660
1661         cmp ax, VARIABLE
1662         jne .error
1663
1664         mov ax, 0
1665         mov byte al, [token]
1666         call get_var
1667
1668         mov ah, 0Eh
1669         int 10h
1670
1671         jmp .newline_or_not
1672
1673
1674 .is_hex:
1675         call get_token
1676
1677         cmp ax, VARIABLE
1678         jne .error
1679
1680         mov ax, 0
1681         mov byte al, [token]
1682         call get_var
1683
1684         call os_print_2hex
1685
1686         jmp .newline_or_not
1687
1688 .error:
1689         mov si, err_syntax
1690         jmp error
1691
1692
1693
1694 .newline_or_not:
1695         ; We want to see if the command ends with ';' -- which means that
1696         ; we shouldn't print a newline after it finishes. So we store the
1697         ; current program location to pop ahead and see if there's the ';'
1698         ; character -- otherwise we put the program location back and resume
1699         ; the main loop
1700
1701         mov word ax, [prog]
1702         mov word [.tmp_loc], ax
1703
1704         call get_token
1705         cmp ax, UNKNOWN
1706         jne .ignore
1707
1708         mov ax, 0
1709         mov al, [token]
1710         cmp al, ';'
1711         jne .ignore
1712
1713         jmp mainloop                            ; And go back to interpreting the code!
1714
1715 .ignore:
1716         call os_print_newline
1717
1718         mov word ax, [.tmp_loc]
1719         mov word [prog], ax
1720
1721         jmp mainloop
1722
1723
1724         .tmp_loc        dw 0
1725
1726
1727 ; ------------------------------------------------------------------
1728 ; RAND
1729
1730 do_rand:
1731         call get_token
1732         cmp ax, VARIABLE
1733         jne .error
1734
1735         mov byte al, [token]
1736         mov byte [.tmp], al
1737
1738         call get_token
1739         cmp ax, NUMBER
1740         jne .error
1741
1742         mov si, token
1743         call os_string_to_int
1744         mov word [.num1], ax
1745
1746         call get_token
1747         cmp ax, NUMBER
1748         jne .error
1749
1750         mov si, token
1751         call os_string_to_int
1752         mov word [.num2], ax
1753
1754         mov word ax, [.num1]
1755         mov word bx, [.num2]
1756         call os_get_random
1757
1758         mov bx, cx
1759         mov ax, 0
1760         mov byte al, [.tmp]
1761         call set_var
1762
1763         jmp mainloop
1764
1765
1766         .tmp    db 0
1767         .num1   dw 0
1768         .num2   dw 0
1769
1770
1771 .error:
1772         mov si, err_syntax
1773         jmp error
1774
1775
1776 ; ------------------------------------------------------------------
1777 ; REM
1778
1779 do_rem:
1780         mov word si, [prog]
1781         mov byte al, [si]
1782         inc word [prog]
1783         cmp al, 10                      ; Find end of line after REM
1784         jne do_rem
1785
1786         jmp mainloop
1787
1788
1789 ; ------------------------------------------------------------------
1790 ; RETURN
1791
1792 do_return:
1793         mov ax, 0
1794         mov byte al, [gosub_depth]
1795         cmp al, 0
1796         jne .is_ok
1797
1798         mov si, err_return
1799         jmp error
1800
1801 .is_ok:
1802         mov si, gosub_points
1803         add si, ax                              ; Table is words (not bytes)
1804         add si, ax
1805         lodsw
1806         mov word [prog], ax
1807         dec byte [gosub_depth]
1808
1809         jmp mainloop
1810
1811
1812 ; ------------------------------------------------------------------
1813 ; SAVE
1814
1815 do_save:
1816         call get_token
1817         cmp ax, QUOTE
1818         je .is_quote
1819
1820         cmp ax, STRING_VAR
1821         jne near .error
1822
1823         mov si, string_vars
1824         mov ax, 128
1825         mul bx
1826         add si, ax
1827         jmp .get_position
1828
1829 .is_quote:
1830         mov si, token
1831
1832 .get_position:
1833         mov di, .tmp_filename
1834         call os_string_copy
1835
1836         call get_token
1837
1838         cmp ax, VARIABLE
1839         je .second_is_var
1840
1841         cmp ax, NUMBER
1842         jne .error
1843
1844         mov si, token
1845         call os_string_to_int
1846
1847 .set_data_loc:
1848         mov word [.data_loc], ax
1849
1850         call get_token
1851
1852         cmp ax, VARIABLE
1853         je .third_is_var
1854
1855         cmp ax, NUMBER
1856         jne .error
1857
1858         mov si, token
1859         call os_string_to_int
1860
1861 .set_data_size:
1862         mov word [.data_size], ax
1863
1864
1865         mov word ax, .tmp_filename
1866         mov word bx, [.data_loc]
1867         mov word cx, [.data_size]
1868
1869         call os_write_file
1870         jc .save_failure
1871
1872         mov ax, 0
1873         mov byte al, 'R'
1874         mov bx, 0
1875         call set_var
1876
1877         jmp mainloop
1878
1879
1880 .second_is_var:
1881         mov ax, 0
1882         mov byte al, [token]
1883         call get_var
1884         jmp .set_data_loc
1885
1886
1887 .third_is_var:
1888         mov ax, 0
1889         mov byte al, [token]
1890         call get_var
1891         jmp .set_data_size
1892
1893
1894 .save_failure:
1895         mov ax, 0
1896         mov byte al, 'R'
1897         mov bx, 1
1898         call set_var
1899
1900         jmp mainloop
1901
1902 .error:
1903         mov si, err_syntax
1904         jmp error
1905
1906
1907         .filename_loc   dw 0
1908         .data_loc       dw 0
1909         .data_size      dw 0
1910
1911         .tmp_filename   times 15 db 0
1912
1913
1914 ; ------------------------------------------------------------------
1915 ; SERIAL
1916
1917 do_serial:
1918         call get_token
1919         mov si, token
1920
1921         mov di, .on_cmd
1922         call os_string_compare
1923         jc .do_on_cmd
1924
1925         mov di, .send_cmd
1926         call os_string_compare
1927         jc .do_send_cmd
1928
1929         mov di, .rec_cmd
1930         call os_string_compare
1931         jc .do_rec_cmd
1932
1933         jmp .error
1934
1935 .do_on_cmd:
1936         call get_token
1937         cmp ax, NUMBER
1938         je .do_on_cmd_ok
1939         jmp .error
1940
1941 .do_on_cmd_ok:
1942         mov si, token
1943         call os_string_to_int
1944         cmp ax, 1200
1945         je .on_cmd_slow_mode
1946         cmp ax, 9600
1947         je .on_cmd_fast_mode
1948
1949         jmp .error
1950
1951 .on_cmd_fast_mode:
1952         mov ax, 0
1953         call os_serial_port_enable
1954         jmp mainloop
1955
1956 .on_cmd_slow_mode:
1957         mov ax, 1
1958         call os_serial_port_enable
1959         jmp mainloop
1960
1961
1962 .do_send_cmd:
1963         call get_token
1964         cmp ax, NUMBER
1965         je .send_number
1966
1967         cmp ax, VARIABLE
1968         je .send_variable
1969
1970         jmp .error
1971
1972 .send_number:
1973         mov si, token
1974         call os_string_to_int
1975         call os_send_via_serial
1976         jmp mainloop
1977
1978 .send_variable:
1979         mov ax, 0
1980         mov byte al, [token]
1981         call get_var
1982         call os_send_via_serial
1983         jmp mainloop
1984
1985
1986 .do_rec_cmd:
1987         call get_token
1988         cmp ax, VARIABLE
1989         jne .error
1990
1991         mov byte al, [token]
1992
1993         mov cx, 0
1994         mov cl, al
1995         call os_get_via_serial
1996
1997         mov bx, 0
1998         mov bl, al
1999         mov al, cl
2000         call set_var
2001
2002         jmp mainloop
2003
2004
2005 .error:
2006         mov si, err_syntax
2007         jmp error
2008
2009
2010         .on_cmd         db "ON", 0
2011         .send_cmd       db "SEND", 0
2012         .rec_cmd        db "REC", 0
2013
2014
2015 ; ------------------------------------------------------------------
2016 ; SOUND
2017
2018 do_sound:
2019         call get_token
2020
2021         cmp ax, VARIABLE
2022         je .first_is_var
2023
2024         mov si, token
2025         call os_string_to_int
2026         jmp .done_first
2027
2028 .first_is_var:
2029         mov ax, 0
2030         mov byte al, [token]
2031         call get_var
2032
2033 .done_first:
2034         call os_speaker_tone
2035
2036         call get_token
2037
2038         cmp ax, VARIABLE
2039         je .second_is_var
2040
2041         mov si, token
2042         call os_string_to_int
2043         jmp .finish
2044
2045 .second_is_var:
2046         mov ax, 0
2047         mov byte al, [token]
2048         call get_var
2049
2050 .finish:
2051         call os_pause
2052         call os_speaker_off
2053
2054         jmp mainloop
2055
2056
2057 ; ------------------------------------------------------------------
2058 ; WAITKEY
2059
2060 do_waitkey:
2061         call get_token
2062         cmp ax, VARIABLE
2063         je .is_variable
2064
2065         mov si, err_syntax
2066         jmp error
2067
2068 .is_variable:
2069         mov ax, 0
2070         mov byte al, [token]
2071
2072         push ax
2073
2074         call os_wait_for_key
2075
2076         cmp ax, 48E0h
2077         je .up_pressed
2078
2079         cmp ax, 50E0h
2080         je .down_pressed
2081
2082         cmp ax, 4BE0h
2083         je .left_pressed
2084
2085         cmp ax, 4DE0h
2086         je .right_pressed
2087
2088 .store:
2089         mov bx, 0
2090         mov bl, al
2091
2092         pop ax
2093
2094         call set_var
2095
2096         jmp mainloop
2097
2098
2099 .up_pressed:
2100         mov ax, 1
2101         jmp .store
2102
2103 .down_pressed:
2104         mov ax, 2
2105         jmp .store
2106
2107 .left_pressed:
2108         mov ax, 3
2109         jmp .store
2110
2111 .right_pressed:
2112         mov ax, 4
2113         jmp .store
2114
2115
2116 ; ==================================================================
2117 ; INTERNAL ROUTINES FOR INTERPRETER
2118
2119 ; ------------------------------------------------------------------
2120 ; Get value of variable character specified in AL (eg 'A')
2121
2122 get_var:
2123         sub al, 65
2124         mov si, variables
2125         add si, ax
2126         add si, ax
2127         lodsw
2128         ret
2129
2130
2131 ; ------------------------------------------------------------------
2132 ; Set value of variable character specified in AL (eg 'A')
2133 ; with number specified in BX
2134
2135 set_var:
2136         mov ah, 0
2137         sub al, 65                              ; Remove ASCII codes before 'A'
2138
2139         mov di, variables                       ; Find position in table (of words)
2140         add di, ax
2141         add di, ax
2142         mov ax, bx
2143         stosw
2144         ret
2145
2146
2147 ; ------------------------------------------------------------------
2148 ; Get token from current position in prog
2149
2150 get_token:
2151         mov word si, [prog]
2152         lodsb
2153
2154         cmp al, 10
2155         je .newline
2156
2157         cmp al, ' '
2158         je .newline
2159
2160         call is_number
2161         jc get_number_token
2162
2163         cmp al, '"'
2164         je get_quote_token
2165
2166         cmp al, 39                      ; Quote mark (')
2167         je get_char_token
2168
2169         cmp al, '$'
2170         je near get_string_var_token
2171
2172         jmp get_string_token
2173
2174
2175 .newline:
2176         inc word [prog]
2177         jmp get_token
2178
2179
2180
2181 get_number_token:
2182         mov word si, [prog]
2183         mov di, token
2184
2185 .loop:
2186         lodsb
2187         cmp al, 10
2188         je .done
2189         cmp al, ' '
2190         je .done
2191         call is_number
2192         jc .fine
2193
2194         mov si, err_char_in_num
2195         jmp error
2196
2197 .fine:
2198         stosb
2199         inc word [prog]
2200         jmp .loop
2201
2202 .done:
2203         mov al, 0                       ; Zero-terminate the token
2204         stosb
2205
2206         mov ax, NUMBER                  ; Pass back the token type
2207         ret
2208
2209
2210 get_char_token:
2211         inc word [prog]                 ; Move past first quote (')
2212
2213         mov word si, [prog]
2214         lodsb
2215
2216         mov byte [token], al
2217
2218         lodsb
2219         cmp al, 39                      ; Needs to finish with another quote
2220         je .is_ok
2221
2222         mov si, err_quote_term
2223         jmp error
2224
2225 .is_ok:
2226         inc word [prog]
2227         inc word [prog]
2228
2229         mov ax, CHAR
2230         ret
2231
2232
2233 get_quote_token:
2234         inc word [prog]                 ; Move past first quote (") char
2235         mov word si, [prog]
2236         mov di, token
2237 .loop:
2238         lodsb
2239         cmp al, '"'
2240         je .done
2241         cmp al, 10
2242         je .error
2243         stosb
2244         inc word [prog]
2245         jmp .loop
2246
2247 .done:
2248         mov al, 0                       ; Zero-terminate the token
2249         stosb
2250         inc word [prog]                 ; Move past final quote
2251
2252         mov ax, QUOTE                   ; Pass back token type
2253         ret
2254
2255 .error:
2256         mov si, err_quote_term
2257         jmp error
2258
2259
2260 get_string_var_token:
2261         lodsb
2262         mov bx, 0                       ; If it's a string var, pass number of string in BX
2263         mov bl, al
2264         sub bl, 49
2265
2266         inc word [prog]
2267         inc word [prog]
2268
2269         mov ax, STRING_VAR
2270         ret
2271
2272
2273 get_string_token:
2274         mov word si, [prog]
2275         mov di, token
2276 .loop:
2277         lodsb
2278         cmp al, 10
2279         je .done
2280         cmp al, ' '
2281         je .done
2282         stosb
2283         inc word [prog]
2284         jmp .loop
2285 .done:
2286         mov al, 0                       ; Zero-terminate the token
2287         stosb
2288
2289         mov ax, token
2290         call os_string_uppercase
2291
2292         mov ax, token
2293         call os_string_length           ; How long was the token?
2294         cmp ax, 1                       ; If 1 char, it's a variable or delimiter
2295         je .is_not_string
2296
2297         mov si, token                   ; If the token ends with ':', it's a label
2298         add si, ax
2299         dec si
2300         lodsb
2301         cmp al, ':'
2302         je .is_label
2303
2304         mov ax, STRING                  ; Otherwise it's a general string of characters
2305         ret
2306
2307 .is_label:
2308         mov ax, LABEL
2309         ret
2310
2311
2312 .is_not_string:
2313         mov byte al, [token]
2314         call is_letter
2315         jc .is_var
2316
2317         mov ax, UNKNOWN
2318         ret
2319
2320 .is_var:
2321         mov ax, VARIABLE                ; Otherwise probably a variable
2322         ret
2323
2324
2325 ; ------------------------------------------------------------------
2326 ; Set carry flag if AL contains ASCII number
2327
2328 is_number:
2329         cmp al, 48
2330         jl .not_number
2331         cmp al, 57
2332         jg .not_number
2333         stc
2334         ret
2335 .not_number:
2336         clc
2337         ret
2338
2339
2340 ; ------------------------------------------------------------------
2341 ; Set carry flag if AL contains ASCII letter
2342
2343 is_letter:
2344         cmp al, 65
2345         jl .not_letter
2346         cmp al, 90
2347         jg .not_letter
2348         stc
2349         ret
2350
2351 .not_letter:
2352         clc
2353         ret
2354
2355
2356 ; ------------------------------------------------------------------
2357 ; Print error message and quit out
2358
2359 error:
2360         call os_print_newline
2361         call os_print_string            ; Print error message
2362         call os_print_newline
2363
2364         mov word sp, [orig_stack]       ; Restore the stack to as it was when BASIC started
2365
2366         ret                             ; And finish
2367
2368
2369         ; Error messages text...
2370
2371         err_char_in_num         db "Error: unexpected character in number", 0
2372         err_quote_term          db "Error: quoted string or character not terminated correctly", 0
2373         err_print_type          db "Error: PRINT command not followed by quoted text or variable", 0
2374         err_cmd_unknown         db "Error: unknown command", 0
2375         err_goto_notlabel       db "Error: GOTO or GOSUB not followed by label", 0
2376         err_label_notfound      db "Error: GOTO or GOSUB label not found", 0
2377         err_return              db "Error: RETURN without GOSUB", 0
2378         err_nest_limit          db "Error: FOR or GOSUB nest limit exceeded", 0
2379         err_next                db "Error: NEXT without FOR", 0
2380         err_syntax              db "Error: syntax error", 0
2381
2382
2383
2384 ; ==================================================================
2385 ; DATA SECTION
2386
2387         orig_stack              dw 0            ; Original stack location when BASIC started
2388
2389         prog                    dw 0            ; Pointer to current location in BASIC code
2390         prog_end                dw 0            ; Pointer to final byte of BASIC code
2391
2392         load_point              dw 0
2393
2394         token_type              db 0            ; Type of last token read (eg NUMBER, VARIABLE)
2395         token                   times 255 db 0  ; Storage space for the token
2396
2397         variables               times 26 dw 0   ; Storage space for variables A to Z
2398         for_variables           times 26 dw 0   ; Storage for FOR loops
2399         for_code_points         times 26 dw 0   ; Storage for code positions where FOR loops start
2400
2401         alert_cmd               db "ALERT", 0
2402         call_cmd                db "CALL", 0
2403         cls_cmd                 db "CLS", 0
2404         cursor_cmd              db "CURSOR", 0
2405         curschar_cmd            db "CURSCHAR", 0
2406         end_cmd                 db "END", 0
2407         for_cmd                 db "FOR", 0
2408         gosub_cmd               db "GOSUB", 0
2409         goto_cmd                db "GOTO", 0
2410         getkey_cmd              db "GETKEY", 0
2411         if_cmd                  db "IF", 0
2412         input_cmd               db "INPUT", 0
2413         load_cmd                db "LOAD", 0
2414         move_cmd                db "MOVE", 0
2415         next_cmd                db "NEXT", 0
2416         pause_cmd               db "PAUSE", 0
2417         peek_cmd                db "PEEK", 0
2418         poke_cmd                db "POKE", 0
2419         port_cmd                db "PORT", 0
2420         print_cmd               db "PRINT", 0
2421         rem_cmd                 db "REM", 0
2422         rand_cmd                db "RAND", 0
2423         return_cmd              db "RETURN", 0
2424         save_cmd                db "SAVE", 0
2425         serial_cmd              db "SERIAL", 0
2426         sound_cmd               db "SOUND", 0
2427         waitkey_cmd             db "WAITKEY", 0
2428
2429         then_keyword            db "THEN", 0
2430         chr_keyword             db "CHR", 0
2431         hex_keyword             db "HEX", 0
2432
2433         progstart_keyword       db "PROGSTART", 0
2434         ramstart_keyword        db "RAMSTART", 0
2435
2436         gosub_depth             db 0
2437         gosub_points            times 10 dw 0   ; Points in code to RETURN to
2438
2439         string_vars             times 1024 db 0 ; 8 * 128 byte strings
2440
2441
2442 ; ------------------------------------------------------------------
2443