8 Building A Program Using what we've learned so far, and adding a couple of new techniques, let's build a useful program. This example will demonstrate many of the techniques we've discussed and will also show some of the thought processes involved in writing ML. Among the computer's more impressive talents is searching. It can run through a mass of information and find something very quickly. We can write an ML routine which looks through any area of memory to find matches with anything else. If your BASIC doesn't have a FIND command or its equivalent, this could come in handy. Based on an idea by Michael Erperstorfer published in COMPUTE! Magazine, this ML program will report the line numbers of all the matches it finds. Safe Havens Before we go through some typical ML program-building methods, let's clear up the "where do I put it?" question. ML can't just be dropped anywhere in memory. When the Simple Assembler asks "Starting Address?", you can't give it any address you want to. RAM is used in many ways. There is always the possibility that a BASIC program might be residing in part of it (if you are combining ML with a BASIC program). Or BASIC might use part of RAM to store arrays or variables. During execution, these variables might write (POKE) into the area that you placed your ML program, destroying it. Also, the operating system, the disk operating system, cassette/disk loads, printers - they all use parts of RAM for their activities. There are other things going on in the computer beside your hard-won ML program. Obviously, you can't put your ML into ROM addresses. That's impossible. Nothing can be POKEd into those addresses. The 64 is an exception to this. You can POKE into ROM areas because a RAM exists beneath the ROM. Refer to the Programmer's Reference Guide or see Jim Butterfield's article on 64 architecture (COMPUTE! Magazine, January 1983) for details. Where to put ML? There are some fairly safe areas. If you are using Applesoft in ROM, 768 to 1023 ($0300 to $03FF) is safe. Atari's page six, 1536 to 1791 ($0600 to $06FF) is good. The 64 and VIC's cassette buffer at 828 to 1019 ($033C to $03FB) are good if you are not LOADing or SAVEing from tape. The PET/CBM makes provision for a second cassette unit. In theory, it would be attached to the computer to allow you to update files or make copies of programs from Cassette #1 to Cassette #2. In practice, no one has mentioned finding a use for a second cassette drive. It is just as easy to use a single cassette for anything that a second cassette could do. As a result, the buffer (temporary holding area) for bytes streaming in from the second cassette unit is very safe indeed. No bytes ever flow in from the phantom unit so it is a perfect place to put ML. The "storage problem" can be solved by knowing the free zones, or creating space by changing the computer's understanding of the start or end of BASIC programs. When BASIC is running, it will set up arrays and strings in RAM memory. Knowing where a BASIC program ends is not enough. It will use additional RAM. Sometimes it puts the strings just after the program itself. Sometimes it builds them down from the "top of memory," the highest RAM address. Where are you going to hide your ML routine if you want to use it along with a BASIC program? How are you going to keep BASIC from overwriting the ML code? Misleading The Computer If the ML is a short program you can stash it into the safe areas listed above. Because these safe areas are only a couple of hundred bytes long, and because so many ML routines want to use that area, it can become crowded. Worse yet, we've been putting the word "safe" in quotes because it just isn't all that reliable. Apple uses the "safe" place for high-res work, for example. The alternative is to deceive the computer into thinking that its RAM is smaller than it really is. This is the real solution. Your ML will be truly safe if your computer doesn't even suspect the existence of set-aside RAM. It will leave the safe area alone because you've told it that it has less RAM than it really does. Nothing can overwrite your ML program after you misdirect your computer's operating system about the size of its RAM memory. There are two bytes in zero page which tell the computer the highest RAM address. You just change those bytes to point to a lower address. These crucial bytes are 55 and 56 ($37,38) in the 64 and VIC. They are 52,53 ($34,35) in PET/CBM Upgrade and 4.0 BASIC. In the PET with Original ROM BASIC, they are 134,135 ($86,87). The Apple uses 115,116 ($73,74), and you lower the Top-of-BASIC pointer just as you do in Commodore machines. The Atari does something similar, but with the bottom of RAM. It is easier with the Atari to store ML just below BASIC than above it. Bump up the "lomem" pointer to make some space for your ML. It's convenient to start ML programs which are too long to fit into page six ($0600-06FF) at $11700 and then put this address into lomem. The LSB and MSB are reversed, of course, as the 6502 requires its pointers to be like this: `$02E7 00 $02E8 1F` $02E7,8 is Atari's low memory pointer. You should set up this pointer (LDA $00, STA $02E7, LDA #$117, STA $02E8) as part of your ML program. Following that pointer setup, JMP $A000 which initializes BASIC. If you are not combining ML with a BASIC program, these preliminary steps are not necessary. Safe Atari zero page locations include $00-04, $CB-D0, $D4-D9 (if floating point numbers are not being used); $0400 (the printer and cassette buffer), $0500-05717 (free), $0580-05FF (if floating point and the Editor are not being used), $0600-06FF (free) are also safe. No other RAM from $0700 (Disk Operating System) to $9FFF or $BFFF is protected from BASIC. To repeat: address pointers such as these are stored in LSB, MSB order. That is, the more significant byte comes second (this is the reverse of normal, but the 6502 requires it of address pointers). For example, $8000, divided between two bytes in a pointer, would look like this: `0073 00 0074 80` As we mentioned earlier, this odd reversal is a peculiarity of the 6502 that you just have to get used to. Anyway, you can lower the computer's opinion of the top-of-RAM-memory, thereby making a safe place for your ML, by changing the MSB. If you need one page (256 bytes): POKE 116, PEEK (116)-1 (Apple). For four pages (1024 bytes) on the Upgrade and 4.0 PETs: POKE 53, PEEK (53) -4. Then your BA or start of assembling could begin at (Top-of-RAM-255 or Top-of-RAM-1023, respectively. You don't have to worry much about the LSB here. It's usually zero. If not, take that into account when planning where to begin storage of your object code. Program 8-1. PET Search (4.0 BACIC Version).
`` | `0010` | `; SEARCH THROUGH BASIC`
`` | `0015` | `; PET 4.0 VERSION`
`` | `0016` | `;-----------------------------------------------------`
`` | `0017` | `; -0- DEFINE VARIABLES BY GIVING THEM LABELS.`
`` | `0018` | `;` | ``
`` | `0020` | `L1L` | `.DE $BA ;STORE THESE IN`
`` | `0030` | `L2L` | `.DE $BC ;UNUSED ZERO PG AREA`
`` | `0040` | `FOUND` | `.DE $36`
`` | `0050` | `BASIC` | `.DE $0400`
`` | `0060` | `PRINT` | `.DE $FFD2 ; PRINT A CHAR.`
`` | `0070` | `PLINE` | `.DE $CF7F ; PRINT LINE#`
`` | `0100` | `` | `.BA $0360 ; 2ND CASSETTE BUFFER`
`` | `0110` | `` | `.OS`
`` | `0120` | `;------------------------------------------------------`
`` | `0121` | `; -0- INITIALIZE POINTERS.`
`` | `0130` | `;` | ``
`` | `0140` | `` | `;`
`0360- AD 01 04` | `0150` | `` | `LDA BASIC+1 ;GET ADDR OF NEXT`
`0363- 85 BA` | `0160` | `` | `STA *L1L ;BASIC LINE`
`0365- AD 02 04` | `0170` | `` | `LDA BASIC+2`
`0368- 85 BB` | `0180` | `` | `STA *L1L+l`
`` | `0181` | `;------------------------------------------------------`
`` | `0182` | `; -0- SUBROUTINE TO CHECK FOR 2 ZEROS. IF WE DON'T`
`` | `0183` | `; FIND THEM, WE ARE NOT AT THE END OF THE PROGRAM.`
`` | `0184` | `;` | ``
`036A- A0 00` | `0190` | `READLINE` | `LDY #$00`
`036C- Bl BA` | `0200` | `` | `LDA (L1L),Y`
`036E- D0 06` | `0210` | `` | `BNE GO.ON ; NOT END OF LINE`
`0370- C8` | `0220` | `` | `INY`
`0371- Bl BA` | `0230` | `` | `LDA (L1L),Y ; 00 00 = END OF PROG.`
`0373- D0 01` | `0240` | `` | `BNE GO.ON`
`0375- 60` | `0250` | `END` | `RTS ;RETURN TO BASIC`
`` | `0251` | `;------------------------------------------------------`
`` | `0252` | `; -0- SUBROUTINE TO UPDATE POINTERS TO THE NEXT LINE`
`` | `0253` | `; AND STORE THE CURRENT LINE NUMBER IN CASE WE`
`` | `0254` | `; FIND A MATCH AND NEED TO PRINT THE LINE #.`
`` | `0255` | `; ALSO, WE ADD 4 TO THE CURRENT LINE POINTER SO THAT`
`` | `0256` | `; WE ARE PAST THE LINE # AND "POINTER-TO-NEXT-LINE"`
`` | `0257` | `; INFORMATION. WE ARE THEN POINTING AT THE 1ST CHAR.`
`` | `0258` | `; IN THE CURRENT LINE AND CAN COMPARE IT TO THE SAMPLE.`
`` | `0259` | `;`
`0376- A0 00` | `0260` | `GO.ON` | `LDY #$00`
`0378- Bl BA` | `0270` | `` | `LDA (L1L),Y ; GET NEXT LINE`
`037A- 85 BC` | `0280` | `` | `STA *L2L ; ADDRESS AND`
`037C- C8` | `0290` | `` | `INY ; STORE IT IN L2L`
`037D- Bl BA` | `0300` | `` | `LDA (L1L),Y`
`037F- 85 BD` | `0310` | `` | `STA *L2L+1`
`0381- C8` | `0320` | `` | `INY`
`0382- B1 BA` | `0330` | `` | `LDA (L1L),Y ; PUT LINE #`
`0384- 85 36` | `0340` | `` | `STA *FOUND ; IN STORAGE TOO`
`0386- C8` | `0350` | `` | `INY ; IN CASE IT`
`0387- Bl BA` | `0360` | `` | `LDA (L1L),Y ; NEEDS TO BE`
`0389- 85 37` | `0370` | `` | `STA *FOUND+l ;PRINTED OUT LATER`
`038B- A5 BA` | `0380` | `` | `LDA *L1L`
`038D- 18` | `0390` | `` | `CLC ; MOVE FORWARD TO 1ST`
`038E- 69 04` | `0400` | `` | `ADC #$04 ; PART OF BASIC TEXT`
`0390- 85 BA` | `0410` | `` | `STA *L1L ; (PAST LINE # AND`
`0392- A5 BB` | `0420` | `` | `LDA *L1L+1 ; OF NEXT LINE)`
`0394- 69 00` | `0430` | `` | `ADC #$00`
`0396- 85 BB` | `0440` | `` | `STA *L1L+1`
`` | `0441` | `;------------------------------------------------------`
`` | `0442` | `; -0- SUBROUTINE TO CHECK FOR ZERO (LINE IS FINISHED?)`
`` | `0443` | `; AND THEN CHECK 1ST CHARACTER IN BASIC LINE AGAINST`
`` | `0444` | `; 1ST CHARACTER IN SAMPLE STRING AT LINE 0:. IF THE`
`` | `0445` | `; 1ST CHARACTERS MATCH, WE MOVE TO A FULL STRING`
`` | `0446` | `; COMPARISON IN THE SUBROUTINE CALLED "SAME." IF 1ST`
`` | `0447` | `; CHARS. DON'T MATCH, WE RAISE THE "Y" COUNTER AND`
`` | `0448` | `; CHECK FOR A MATCH IN THE 2ND CHAR. OF THE CURRENT`
`` | `0449` | `; BASIC LINE'S TEXT.`
`` | `0450` | `;`
`0398- A0 00` | `0451` | `` | `LDY #$00`
`039A- Bl BA` | `0460` | `LOOP` | `LDA (L1L),Y`
`039C- F0 1C` | `0470` | `` | `BEQ STOPLINE ; ZERO = LINE FINISHED`
`039E- CD 06 04` | `0480` | `` | `CMP BASIC+6 ; SAME AS 1ST SAMPLE CHAR?`
`03Al- F0 04` | `0490` | `` | `BEQ SAME ; YES? CHECK WHOLE STRING`
`03A3- C8` | `0500` | `` | `INY ; NO? CONTINUE SEARCH`
`03A4- 4C 9A 03` | `0510` | `` | `JMP LOOP`
`` | `0511` | `;------------------------------------------------------`
`` | `0512` | `; -0- SUBROUTINE TO LOOK AT EACH CHARACTER IN BOTH THE`
`` | `0513` | `; SAMPLE (LINE 0) AND THE TARGET (CURRENT LINE) TO`
`` | `0514` | `; SEE IF THERE IS A PERFECT MATCH. Y KEEPS TRACK OF`
`` | `0515` | `; TARGET. X INDEXES SAMPLE. IF WE FIND A MISMATCH`
`` | `0516` | `; BEFORE A LINE-END ZERO, WE FALL THROUGH TO LINE`
`` | `0517` | `; 590 AND JUMP BACK UP TO 460 WHERE WE CONTINUE ON`
`` | `0518` | `; LOOKING FOR 1ST CHAR MATCHES IN THE CURRENT LINE.`
`` | `0519` | `;` | ``
`03A7- A2 00` | `0520` | `SAME` | `LDX #$00 ;COMPARE SAMPLE TO`
`03A9- E8` | `0530` | `COMPARE` | `INX ;TARGET`
`03AA- C8` | `0540` | `` | `INY`
`03AB- BD 06 04` | `0550` | `` | `LDA BASIC+6,X`
`03AE- F0 07` | `0560` | `` | `BEQ PERFECT ; LINE ENDS SO PRINT`
`03B0- D1 BA` | `0570` | `` | `CMP (L1L),Y`
`03B2- F0 F5` | `0580` | `` | `BEQ COMPARE ; CONTINUE COMPARE`
`03B4- 4C 9A` | `0590` | `` | `JMP LOOP ;NO MATCH`
`03B7- 20 C5 03` | `0600` | `PERFECT` | `JSR PRINTOUT`
`` | `0601` | `;------------------------------------------------------`
`` | `0602` | `; -0- SUBROUTINE TO REPLACE "CURRENT LINE" POINTER`
`` | `0603` | `; WITH THE "NEXT LINE" POINTER WE SAVED IN THE SUBROUT`
`` | `0604` | `; STARTING AT LINE 260.`
`` | `0605` | `; THEN JUMP BACK. TO THE START WITH THE CHECK FOR THE`
`` | `0606` | `; END-OF-PROGRAM DOUBLE ZERO. THIS IS THE LAST SUBROUT`
`` | `0607` | `; IN THE MAIN LOOP OF THE PROGRAM`
`` | `0608` | `;` | ``
`03BA- A5 BC` | `0610` | `STOPLINE` | `LDA *L2L ;TRANSFER NEXT LINE`
`03BC- 85 BA` | `0620` | `` | `STA *L1L ; ADDRESS POINTER TO`
`03BE- A5 BD` | `0630` | `` | `LDA *L2L+1 ; CURRENT LINE POINTER`
`03C0- 85 BB` | `0640` | `` | `STA *L1L+l ; TO GET READY TO READ`
`03C2- 4C 6A 03` | `0650` | `` | `JMP READLINE ;THE NEXT LINE.`
`` | `0651` | `;------------------------------------------------------`
`` | `0652` | `; -0- SUBROUTINE TO PRINT OUT A BASIC LINE NUMBER.`
`` | `0653` | `; IN MICROSOFT IT TAKES THE NUMBER STORED IN $36,37`
`` | `0654` | `; AND THE ROM ROUTINE PRINTS THE NUMBER AT THE NEXT`
`` | `0655` | `; CURSOR POSITION ON SCREEN. THEN WE PRINT A BLANK`
`` | `0656` | `; SPACE AND RETURN TO LINE 610 TO CONTINUE ON WITH`
`` | `0657` | `; THE MAIN LOOP AND FIND MORE MATCHES.`
`` | `0658` | `;` | ``
`03C5- 20 7F CF` | `0660` | `PRINTOUT` | `JSR PLINE ; ROM ROUTINE PRINTS`
`` | `0661` | `` | `; A LINE NUMBER FROM THE VALUES FOUND`
`` | `0662` | `` | `; IN "FOUND" ($36,37)`
`03C8- A9 20` | `0670` | `` | `LDA #$20 ;PRINT A BLANK`
`03CA- 20 D2 FF` | `0680` | `` | `JSR PRINT ; SPACE BETWEEN #S`
`03CD- 60` | `0690` | `` | `RTS`
`` | `0691` | `;------------------------------------------------------`
`` | `0692` | `;` | ``
`` | `0700` | `` | `.EN`
`--- LABEL FILE: ---`
`BASIC =0400` | `COMPARE =03A9` | `END =0375`
`FOUND =0036` | `GO.ON =0376` | `L1L =00BA`
`L2L =00BC` | `LOOP =039A` | `PERFECT =03B7`
`PLINE =CF7F` | `PRINT =FFD2` | `PRINTOUT =03C5`
`READLINE =036A` | `SAME =03A7` | `STOPLINE =03BA`
Building The Code Now we return to the subject at hand - building an ML program. Some people find it easiest to mentally break a task down into several smaller problems and then weave them into a complete program. That's how we'll look at our search program. (See Program 8-1.) For this exercise, we can follow the PET/CBM 4.0 BASIC version to see how it is constructed. All the versions (except Atari's) are essentially the same, as we will see in a minute. The only differences are in the locations in zero page where addresses are temporarily stored, the "start-of-BASIC RAM" address, the routines to print a character and to print a line number, and the RAM where it's safe to store the ML program itself. In other words, change the defined variables between lines 20 and 100 in Program 8-1 and you can use the program on another computer. We will build our ML program in pieces and then tie them all together at the end. The first phase, as always, is the initialization. We set up the variables and fill in the pointers. Lines 20 and 30 define two, two-byte zero page pointers. L1L is going to point at the address of the BASIC line we are currently searching through. L2L points to the starting address of the line following it. Microsoft BASIC stores four important bytes just prior to the start of the code in a BASIC line. Take a look at Figure 8-1. The first two bytes contain the address of the next line in the BASIC program. The second two bytes hold the line number. The end of a BASIC line is signaled by a zero. Zero does not stand for anything in the ASCII code or for any BASIC command. If there are three zeros in a row, this means that we have located the "top," the end of the BASIC program. (The structure of Atari BASIC is significantly different. See Figure 8-2.) But back to our examination of the ML program. In line 40 is a definition of the zero page location which holds a two-byte number that Microsoft BASIC looks at when it is going to print a line number on the screen. We will want to store line numbers in this location as we come upon them during the execution of our ML search program. Each line number will temporarily sit waiting in case a match is found. If a match is found, the program will JSR to the BASIC ROM routine we're calling "PLINE," as defined in line 70. It will need the "current line number" to print to the screen. Line 50 establishes that BASIC RAM starts at $0400 and line 60 gives the address of the "print the character in the accumulator" ROM routine. Line 100 says to put the object code into the PET's (all BASIC versions) second cassette buffer, a traditional "safe" RAM area to store short ML programs. These safe areas are not used by BASIC, the operating system (OS), or, generally, by monitors or assemblers. If you are working with an assembler or monitor, however, and keep finding that your object code has been messed up - suspect that your ML creating program (the monitor or assembler) is using part of your "safe" place. They consider it safe too. If this should happen, you'll have to find a better location. Refer to Program 8-1 to follow the logic of constructing our Microsoft search program. The search is initiated by typing in line zero followed by the item we want to locate. It might be that we are interested in removing all REM statements from a program to shorten it. We would type 0:REM and hit RETURN to enter this into the BASIC program. Then we would start the search by a SYS to the starting address of the ML program. In the PET 4.0 version of Program 8-1, it would be SYS 864 (hex $0360). By entering the "sample" string or command into the BASIC program as line zero, we solve two problems. First, if it is a string, it will be stored as the ASCII code for that string, just as BASIC stores strings. If it is a keyword like REM, it will be translated into the "tokenized," one-byte representation of the keyword, just as BASIC stores keywords. The second problem this solves is that our sample is located in a known area of RAM. By looking at Figure 8-1, you can tell that the sample's starting address is always the start of BASIC plus six. In Program 8-1 that means 0406 (see line 550). |
Set Up The Pointers We will have to get the address of the next line in the BASIC program we are searching. And then we need to store it while we look through the current line. The way that BASIC lines are arranged, we come upon the link to the next line's address and the line number before we see any BASIC code itself. Therefore, the first order of business is to put the address of the next line into LIL. Lines 150 through 180 take the link found in start-of-BASIC RAM (plus one) and move it to the storage pointer "L1L." Next, lines 190 to 250 check to see if we have reached the end of the BASIC program. It would be the end if we had found two zeros in a row as the pointer to the next line's address. If it is the end, the RTS sends us back to BASIC mode. The subroutine in lines 260 through 440 saves the pointer to the following line's address and also the current line number. Note the double-byte addition in lines 390-440. Recall that we CLC before any addition. If adding four to the LSB (line 400) results in a carry, we want to be sure that the MSB goes up by one during the add-with-carry in line 430. It might seem to make no sense to add a zero in that line. What's the point? The addition is with carry; in other words, if the carry flag has been set up by the addition of four to the LSB in line 400, then the MSB will go up by one. The carry will make this happen. First Characters It's better to just compare the first character in a word against each byte in the searched memory than to try to compare the entire sample word. If you are looking for MEM, you don't want to stop at each byte in memory and see if M-E-M starts there. Just look for M's. When you come upon a M, then go through the full string comparison. If line 490 finds a first-character match, it transfers the program to "SAME" (line 520) which will do the entire comparison. On the other hand, if the routine starting at line 451 comes upon a zero (line 470), it knows that the BASIC line has ended (they all end with zero. It then goes down to "STOPLINE" (line 610) which puts the "next line" address pointer into the "current line" pointer and the whole process of reading a new BASIC line begins anew. If, however, a perfect match was found (line 560 found a zero at the end of the 0:REM line, showing that we had come to the end of the sample string) - we go to "PERFECT" and it makes a JSR to print out the line number (line 660). That subroutine bounces back (RTS) to "STOPLINE" which replaces the "current line" (L1L) pointer with the "next line" pointer (L2L). Then we JMP back to "READLINE" which, once again, pays very close attention to zeros to see if the whole BASIC program has ended with double zeros. We have returned to the start of the main loop of this ML program. This sounds more complicated than it is. If you've followed this so far, you can see that there is enormous flexibility in constructing ML programs. If you want to put the "STOPLINE" segment earlier than the "SAME" subroutine - go ahead. It is quite common to see a structure like this: `INITIALIZATION LDA #15 STA $83 MAIN LOOP START JSR 1 JSR 2 JSR 3 BEQ START` (until some index runs out) `RTS` (to BASIC) `SUBROUTINES 1 2` (each ends with RTS back to the MAIN LOOP) `3 DATA Table 1 Table 2 Table 3` The Atari FIND Utility The second source listing, Program 8-2, adds a FIND command to Atari BASIC. You access it with the USR command. It is written to assemble in page six (1536 or $0600) and is an example of a full-blown assembly. You'll need the assembler/ editor cartridge to type it in. After you've entered it, enter "ASM" to assemble it into memory. After it is finished, use the SAVE command to store the object (executable ML) code on tape or disk. Use: `SAVE#C: > 0600,067E` for tape `SAVE#D:FIND.OBJ < 0600 067E` for disk You can then put the BASIC cartridge in and enter the machine language with the BASIC loader program, or with the L command of DOS. Using FIND from BASIC is simple. Say you want to search a master string, A$ for the substring "hello". If B$ contains "hello", the USR call would look like: `POS=USR (1536,ADR(A$),LEN(A$),ADR(B$),LEN(B$) )` POS will contain the position of the match. It will be a memory location within the ADRress of A$. To get the character position within A$, just use POS-ADR(A$)+1. If the substring (B$) is not found, POS will be zero. It's easy to add commands like this to Atari BASIC. Also see "Getting The Most Out Of USR" in the November 1982 issue of COMPUTE! Magazine (p. 100). 64, Apple, & VIC Versions Versions of the search routine for the Commodore 64 and VIC-20 and the Apple II are provided as BASIC loader programs. Remember from Chapter 2 that a loader is a BASIC program which POKEs a machine language program (stored in DATA statements) into memory. Once you have entered and run the BASIC programs, you can examine the ML programs using a disassembler. (See Appendix D.) These versions are similar to the PET Version outlined in Program 8-1. The characters to be searched for are typed in line 0. To start the search in the 64 version (Program 8-3), type SYS 40800. Use CALL 768 to activate the Apple version (Program 8-4). The VIC version (Program 8-5) is activated with SYS 828. As your skills improve, you will likely begin to appreciate, and finally embrace, the extraordinary freedom that ML confers on the programmer. Learning it can seem fraught with obscurity and rules. It can even look menacing. But there are flights you will soon be taking through your computer. Work at it. Try things. Learn how to find your errors. It's not circular - there will be considerable advances in your understanding. One day, you might be able to sit down and say that you can combine BASIC with ML and do pretty much anything you want to do with your machine. Program 8-2.
`` | `0100` | `;========================;`
`` | `0110` | `; FIND Utility ;`
`` | `0120` | `; Substring Search ;`
`` | `0130` | `; for Atari BASIC ;`
`` | `0140` | `; Completely relocatable ;`
`` | `0150` | `;========================;`
`` | `0160` | `;`
`` | `0170` | `;`
`` | `0180` | `;Variables in zero page for speed`
`` | `0190` | `;`
`00CB` | `0200` | `SADRL` | `=$CB ;Address`
`00CC` | `0210` | `SADRH` | `=$CC ;of search`
`00CD` | `0220` | `SLENL` | `=$CD ;Length of`
`00CE` | `0230` | `SLENH` | `=$CE ;search space`
`` | `0240` | `;` | ``
`00CF` | `0250` | `FNDL` | `=$CF ;Search address`
`00D0` | `0260` | `FNDH` | `=$D0 ;and`
`00D1` | `0270` | `FNDLEN` | `=$Dl ;length 0280 ;`
`` | `0280` | `;` | ``
`00D2` | `0290` | `FIRSTCHAR` | `=$D2`
`00D3` | `0300` | `SINDEX` | `=$D3`
`00D4` | `0310` | `FR0` | `=$D4 ;Return`
`00D6` | `0320` | `FINDEX` | `=$D6 ;Source index`
`00D7` | `0330` | `TADRL` | `=$D7 ;Temp addr`
`00D8` | `0340` | `TADRH` | `=$D8`
`00D9` | `0350` | `ENDLOOP` | `=D9`
`` | `0360` | `;`
`` | `0370` | `;Syntax documentation`
`` | `0380` | `;`
`` | `0390` | `;FIND:Find Text`
`` | `0400` | `;X=USR(FIND,A,B,C,D)`
`` | `0410` | `;FIND:Address of utility (1536)`
`` | `0420` | `;A: Where to start search`
`` | `0430` | `;B: Where to quit searching`
`` | `0440` | `;C: Search string address`
`` | `0450` | `;D: Length of search string`
`` | `0460` | `;X: Position found (=0 if no match)`
`0000` | `0470` | `` | `*= $0600`
`` | `0480` | `;------------------------------------`
`` | `0490` | `;This portion sets up the parameters`
`` | `0500` | `;for the search by pulling the values`
`` | `0510` | `;passed by BASIC off the stack`
`` | `0520` | `;`
`` | `0530` | `FIND` | ``
`0600 68` | `0540` | `` | `PLA ;Count byte`
`0601 68` | `0550` | `` | `PLA ;hi byte, Source start`
`0602 85CC` | `0560` | `` | `STA SADRH`
`0604 68` | `0570` | `` | `PLA ;lo byte, Source start`
`0605 85CB` | `0580` | `` | `STA SADRL`
`0607 68` | `0590` | `` | `PLA ;hi byte, Source end`
`0608 85CE` | `0600` | `` | `STA SLENH`
`060A 68` | `0610` | `` | `PLA ;lo byte, Source end`
`060B 85CD` | `0620` | `` | `STA SLENL`
`060D 68` | `0630` | `` | `PLA ;hi byte, Search string`
`060E 85D0` | `0640` | `` | `STA FNDH`
`0610 68` | `0650` | `` | `PLA ;lo byte, Search string`
`0611 85CF` | `0660` | `` | `STA FNDL`
`0613 68` | `0670` | `` | `PLA ;hi byte, Search length`
`` | `0680` | `;Ignore it`
`0614 68` | `0690` | `` | `PLA ;lo byte, Search length`
`0615 85D1` | `0700` | `` | `STA FNDLEN`
`` | `0710` | `;`
`` | `0720` | `;--------------------------`
`` | `0730` | `;This is the main loop. We`
`` | `0740` | `;search through the search space`
`` | `0750` | `;looking for the first character`
`` | `0760` | `;of the search string. We`
`` | `0770` | `;look through entire 256-byte`
`` | `0780` | `;blocks. If the first character`
`` | `0790` | `;is found, we exit to a full`
`` | `0800` | `;string comparison routine.`
`` | `0810` | `;`
`` | `0820` | `;If the string is never found,`
`` | `0830` | `;we just return a zero to BASIC`
`` | `0840` | `;`
`0617 A000` | `0850` | `` | `LDY #0`
`0619 BlCF` | `0860` | `` | `LDA (FNDL),Y ;Set up first`
`061B 85D2` | `0870` | `` | `STA FIRSTCHAR ;comparison`
`` | `0880` | `;` | ``
`061D A6CE` | `0890` | `` | `LDX SLENH ;Less than 255`
`061F F018` | `0900` | `` | `BEQ SHORT ;bytes?`
`` | `0910` | `NXTSRCH` | ``
`0621 A9FF` | `0920` | `` | `LDA #255 ;Select end`
`` | `0930` | `SEARCH2` | ``
`0623 85D9` | `0940` | `` | `STA ENDLOOP`
`0625 A000` | `0950` | `` | `LDY #0`
`` | `0960` | `SEARCHLOOP` | ``
`0627 BlCB` | `0970` | `` | `LDA (SADRL),Y`
`0629 C5D2` | `0980` | `` | `CMP FIRSTCHAR ;Found a match?`
`062B F017` | `0990` | `` | `BEQ FOUND1 ;yes`
`` | `1000` | `NOTFOUND` | ``
`062D C8` | `1010` | `` | `INY ;no`
`062E C4D9` | `1020` | `` | `CPY ENDLOOP`
`0630 D0F5` | `1030` | `` | `BNE SEARCHLOOP ;continue`
`` | `1040` | `;` | ``
`0632 E6CC` | `1050` | `` | `INC SADRH ;Next block`
`0634 CA` | `1060` | `` | `DEX ;Done?`
`0635 3006` | `1070` | `` | `BMI EXIT ;yes`
`0637 D0E8` | `1080` | `` | `BNE NXTSRCH ;nope`
`` | `1090` | `SHORT` | ``
`0639 A5CD` | `1100` | `` | `LDA SLENL ;Set up last`
`063B D0E6` | `1110` | `` | `BNE SEARCH2 ;scan`
`` | `1120` | `EXIT` | ``
`063D A900` | `1130` | `` | `LDA #0 ;return`
`063F 85D4` | `1140` | `` | `STA FRO ;=0`
`0641 85D5` | `1150` | `` | `STA FRO+1 ;?no strin`
`0643 60` | `1160` | `` | `RTS ;found`
`` | `1170` | `;` | ``
`` | `1180` | `;------------------------------`
`` | `1190` | `;Here is where we check for a`
`` | `1200` | `;full match, starting with the`
`` | `1210` | `;second character of the search string`
`` | `1220` | `;We have to use two "pseudo" registers`
`` | `1230` | `;in memory, since the same Y register`
`` | `1240` | `;is needed to access both areas of memory`
`` | `1250` | `;(search space and search string)`
`` | `1260` | `;` | ``
`` | `1270` | `FOUND 1` | ``
`0644 84D4` | `1280` | `` | `STY FRO ;Save Y`
`0646 84D3` | `1290` | `` | `STY SINDEX ;Source index`
`0648 A001` | `1300` | `` | `LDY #1`
`064A 84D6` | `1310` | `` | `STY FINDEX ;Find index`
`` | `1320` | `;` | ``
`` | `1330` | `;We use a temporary address, since we don't want`
`` | `1340` | `;to change the address in SADR (so we can continue the`
`` | `1350` | `;search if no match found)`
`` | `1360` | `;` | ``
`064C A5CB` | `1370` | `` | `LDA SADRL ;Copy to`
`064E 85D7` | `1380` | `` | `STA TADRL ;temp addr`
`0650 A5CC` | `1390` | `` | `LDA SADRH`
`0652 85D8` | `1400` | `` | `STA TADRH`
`` | `1410` | `;` | ``
`` | `1420` | `CONTSRCH` | ``
`` | `1430` | `;` | ``
`` | `1440` | `;As long as each character matches, we`
`` | `1450` | `;continue to compare until we get a failed comparison`
`` | `1460` | `;or reach the end of the search string,`
`` | `1470` | `;which indicates a match`
`` | `1480` | `;` | ``
`0654 A4D6` | `1490` | `` | `LDY FINDEX`
`0656 C4D1` | `1500` | `` | `CPY FNDLEN ;Past end?`
`0658 F016` | `1510` | `` | `BEQ FOUND2 ;yes-matchl`
`065A BlCF` | `1520` | `` | `LDA (FNDL),Y ;Character n`
`065C E6D6` | `1530` | `` | `INC FINDEX ;no, increment`
`065E A4D3` | `1540` | `` | `LDY SINDEX ;Compare to`
`0660 C8` | `1550` | `` | `INY ;source`
`0661 D002` | `1560` | `` | `BNE SKIPINC ;Hit page bound?`
`0663 E6D8` | `1570` | `` | `INC TADRH`
`` | `1580` | `SKIPINC` | ``
`0665 84D3` | `1590` | `` | `STY SINDEX ;Update`
`0667 DlD7` | `1600` | `` | `CMP (TADRL),Y ;equal so far?`
`0669 F0E9` | `1610` | `` | `BEQ CONTSRCH ;yes, continue`
`` | `1620` | `;Comparison failure,`
`` | `1630` | `;Return to main loop`
`066B A4D4` | `1640` | `` | `LDY FRO`
`066D 18` | `1650` | `` | `CLC ;Used in place`
`066E 90BD` | `1660` | `` | `BCC NOTFOUND ;of JMP (relocatable)`
`` | `1670` | `;` | ``
`` | `1680` | `;Match!`
`` | `1690` | `;Return address in FRO to BASIC`
`` | `1700` | `FOUND2` | ``
`0670 18` | `1710` | `` | `CLC`
`0671 A5D4` | `1720` | `` | `LDA FRO`
`0673 65CB` | `1730` | `` | `ADC SADRL`
`0675 85D4` | `1740` | `` | `STA FRO`
`0677 A5CC` | `1750` | `` | `LDA SADRH`
`0679 6900` | `1760` | `` | `ADC #0`
`067B 85D5` | `1770` | `` | `STA FRO+1`
`067D 60` | `1780` | `` | `RTS`
`` | `1790` | `` | ``
`067E` | `1800` | `` | `.END`
`=00CB SADRL =00CC SADRH =00CD SLENL =00CE SLENH =00CF FNDL =00D0 FNDH =00Dl FNDLEN =00D2 FIRSTCHAR =OOD3 SINDEX =00D4 FRO =00D6 FINDEX =00D7 TADRL =00D8 TADRH =00D9 ENDLOOP 0600 FIND 0639 SHORT 0621 NXTSRCH 0623 SEARCH2 0627 SEARCHLOOP 0644 FOUND1 062D NOTFOUND 063D EXIT 0654 CONTSRCH 0670 FOUND2 0665 SKIPINC` Program 8-3. 64 Search BASIC Loader. `799 X=PEEK(55):POKE55,X-1:REM PROTECT ML 800 FOR ADRES=40800TO40913:READ DATTA: POKE ADRES,DATTA:NEXT ADRES 900 PRINT"SYS40800 TO ACTIVATE" 4096 DATA 162, 0, 173, 1, 8, 133 4102 DATA 165, 173, 2, 8, 133, 166 4108 DATA 160, 0, 177, 165, 208, 6 4114 DATA 200, 177, 165, 208, 1, 96 4120 DATA 160, 0, 177, 165, 141, 167 4126 DATA 0, 200, 177, 165, 141, 168 4132 DATA 0, 200, 177, 165, 133, 57 4138 DATA 200, 177, 165, 133, 58, 165 4144 DATA 165, 24, 105, 4, 133, 165 4150 DATA 165, 166, 105, 0, 133, 166 4156 DATA 160, 0, 177, 165, 240, 28 4162 DATA 205, 6, 8, 240, 4, 200 4168 DATA 76, 158, 159, 162, 0, 232 4174 DATA 200, 189, 6, 8, 240, 7 4180 DATA 209, 165, 240, 245, 76, 158 4186 DATA 159, 32, 201, 159, 165, 167 4192 DATA 133, 165, 165, 168, 133, 166 4198 DATA 76, 108, 159, 32, 201, 189 4204 DATA 169, 32, 32, 210, 255, 96 READY.` Program 8-4. Apple Version. `700 FOR AD=768TO900: READ DA:POKE A D,DA:NEXT AD 768 DATA169,76,141,245,3,169 774 DATA16,141,246,3,169,3 780 DATA141,247,3,96,162,0 786 DATA173,1,8,133,1,173 792 DATA2,8,133,2,160,0 798 DATA177,1,208,6,200,177 804 DATA1,208,1,96,160,0 810 DATA177,1,133,3,200,177 816 DATA1,133,4,200,177,1 822 DATA133,117,200,177,1,133 828 DATA118,165,1,24,105,4 834 DATA133,1,165,2,105,0 840 DATA133,2,160,0,177,1 846 DATA240,28,205,6,8,240 852 DATA4,200,76,76,3,162 858 DATA0,232,200,189,6,8 864 DATA240,7,209,1,240,245 870 DATA76,76,3,'76,119,3 876 DATA165,3,133,1,165,4 882 DATA133,2,76,28,3,169 888 DATA163,32,237,253,32,32 894 DATA237,169,160,32,237,253 900 DATA76,108,3` Program 8-5. VIC-20 Search BASIC Loader. `800 FOR ADRES=828TO941:READ DATTA:POKE ADR ES,DATTA:NEXT ADRES 810 PRINT"SYS 828 TO ACTIVATE" 828 DATA 162, 0, 173, 1, 16, 133 834 DATA 187, 173, 2, 16, 133, 188 840 DATA 160, 0, 177, 187, 208, 6 846 DATA 200, 177, 187, 208, 1, 96 852 DATA 160, 0, 177, 187, 141, 190 858 DATA 0, 200, 177, 187, 141, 191 864 DATA 0, 200, 177, 187, 133, 57 870 DATA 200, 177, 187, 133, 58, 165 876 DATA 187, 24, 105, 4, 133, 187 882 DATA 165, 188, 105, 0, 133, 188 888 DATA 160, 0, 177, 187, 240, 28 894 DATA 205, 6, 16, 240, 4, 200 900 DATA 76, 122, 3, 162, 0, 232 906 DATA 200, 189, 6, 16, 240, 7 912 DATA 209, 187, 240, 245, 76, 122 918 DATA 3, 32, 165, 3, 165, 190 924 DATA 133, 187, 165, 191, 133, 188 930 DATA 76, 72, 3, 32, 194, 221 936 DATA 169, 32, 32, 210, 255, 96` Return to Table of Contents | Previous Chapter | Next Chapter |