$J4.95 ASSEMBLY LANGUAGE FOR KIDS lODORE 64 by WILLIAM B. SANDERS ASSEMBLY LANGUAGE FOR KIDS: COMMODORE 64 by William B. Sanders, Ph.D. San Diego State University Glicrocomscribe i\WT^ Literate Microcomputer Documentation 8982 Stimson Court San Diego, California 92129 619/484-3884 or 619/578-4588 Library of Congress Cataloging in Publication Data Sanders, William B. Assembly Language For Kids: Commodore 64 Includes index 1. Commodore 64 Computer 2. Assembly Language (Computer program language) I. Sanders, William B., 1944- II. Title: Assembly Language for Kids: Commodore 64 ISBN 0-931 145-00-7 © 1984 by William B. Sanders San Diego, California Manufactured in the United States of America All rights reserved. No part of this book may be reproduced by any means without the written permission of the author and publisher. Cover design by Dyna Pac Typesetting by GD Enterprises ASSEMBLY LANGUAGE FOR KIDS : COMMODORE 64 TABLE OF CONTENTS PREFACE VI CHAPTER 1: INTRODUCTION 1 What This Bookis About , 1 Who This Book is For 2 Why Use Assembly Language 3 Whatis An Assembler? 5 Machine and Assembly Language 6 Assemblers Covered in this Book 8 The Commodore 64 Macro Assembler Development System 8 Merlin Assembler 8 The Kids' Assembler (Included in the book) 9 Other Assemblers not Covered 9 BASIC and Assembly Language 10 Machine Subroutines from BASIC 13 Setting Up 17 CHAPTER2: USING AN ASSEMBLER 21 ASSEMBLERS IN GENERAL 21 The Standard Parts of An Assembler 23 I. Standard Editor/Assembler Format 27 USING THE KIDS' ASSEMBLER 29 Creating and Saving Programs 43 Special Conventions in Opcodes 47 Loading and Executing Programs 48 Some Examples 50 CHAPTER 3: THE MERLIN 64 ASSEMBLER 53 Using the Editor/ Assembler 53 Loading and Running Programs 67 THESOURCEROR 68 MERLIN'S MONITOR 70 Some Examples 70 CHAPTER 4: THE COMMODORE 64 MACRO ASSEMBLER DEVELOPMENT SYSTEM 73 THEPARTS 73 EDITOR64 74 Added Editing Functions on EDITOR64 79 ASSEMBLERS 80 LOADERS 82 THEMONITORS 83 SomeExamples 88 CHAPTER5: STRANGE NEW NUMBERS 91 Decimal, Binary and Hexadecimal Numbers 91 Going Between Number Systems 96 Using Conversion Charts 96 Conversion Programs 98 How Not To Worry About Numbers 101 CHAPTER 6: WHAT'S IN YOUR MICROPROCESSOR? . 103 What's a Register? 103 The Accumulator 104 The X and Y registers 105 . The Processor Status Register (Status Register) 105 NegativeFlag 106 overflow Flag 107 BreakFlag 107 DecimalFlag 107 II. InterruptFlag 107 Zero Flag 107 CarryFlag 108 StackPointer 108 Program Counter , , 110 Input/Output Port 110 CHAPTER7: MEMORY AND STORAGE 113 Line numbers and Addresses : A Comparison 113 ROM and RAM memory ..;..' 116 MINI-MONITOR 119 Backward Numbers : Low-Byte /High-Byte Storage 121 Bytes, Opcodes and Addressing Modes 123 SUMMARY 124 CHAPTER8: JUMPING IN 125 Where to Stick Your Programs 125 Auto-Placement With Kids' Assembler 125 ORG Pseudo-Opcode In Merlin . . 125 Commodore Assembler's * = function 126 Visiting Built-in Subroutines with JSR 126 Getting Out with RTS 128 Loading up with LDA 129 Implied, Immediate and Absolute Addressing Modes ... 1 32 Storing with STA 134 Storage in Empty, Unused RAM 134 Storage in "Soft-Switch" Addresses 135 Storageon Your Screen 140 SUMMARY 142 CHAPTER 9: USING THE X AND Y REGISTERS 143 How to use the X and Y Registers 143 Transfers With TAX, TAY, TXA and TYA 145 Incrementing and Decrementing with INX,INY,DEXandDEY 148 From X and Y to Memory with STX and STY 150 Addressing Modes with the X and Y Registers 153 Indexed Absolute Addressing 154 Indexed Indirect Addressing 157 Indirect Indexed Addressing 161 III. CHAPTER 10: LOOPS AND BRANCHES 165 Program Structure 165 Sequential 165 Loops 166 Branches 166 How BASIC Logic Works in Assembly Language 167 Looping to Save Programming Time 168 Indexing With Loops 172 NestedLoops 175 Branching Forward With JMP, BEQ and BNE 177 SUMMARY 181 CHAPTER 11: ADDING AND SUBTRACTING 183 Incrementing and Decrementing Memory : INC and DEC . . 1 83 Adding and Subtracting in the In the Accumulator: ADCandSBC 186 Using CLC and SEC 187 SUMMARY 191 CHAPTER 12: INTERACTING WITH ASSEMBLY LANGUAGE PROGRAMS 193 Introduction ; 193 Reading Input From the Keyboard 194 Joystick Control 203 The EOR instruction 205 Making Messages: ASC and .BYTE 221 Message Maker for Kids' Assembler 215 SUMMARY 218 CHAPTER 13: HOT GRAPHICS 218 Introduction 219 Low Resolution Graphics 220 Saving Plotted Lines 228 Animation 230 External Control of Movement 237 SUMMARY 246 CHAPTER 14: BLAZING SPRITES AND MONSTROUS SOUNDS 247 Sprite Graphics 247 Sprite Creation 251 IV. Sprite Building 260 Kids' Sprite Assembler 265 Full Horizontal Movement 272 Sprite Expansion 272 Assembly Sounds 274 SUMMARY 278 CHAPTER 15: DOWN THE ROAD 279 Introduction 279 Merging Subroutines 280 Appending With Merlin 280 Appending With Commodore EDITOR64 280 Appending and Inserting Subroutines 285 Getting to Know the Other Opcodes 289 Resources for Learning more About Assembly Language Programming on the Commodore 64 290 UserGroups 290 Reference Books 291 How-To Books 292 Magazines 293 You're On Your Own 294 APPENDICES 297 APPENDIX A: KIDS' ASSEMBLER 299 APPENDIX B: 6510 OPCODES 309 APPENDIX C: MEMORY MAP 1: DIAGRAM 315 APPENDIXD: MEMORY MAP 1: PLACES TO VISIT. . 317 APPENDIX E: BASIC TOKEN CHART 321 APPENDDC F: HEXADECIMAL-DECIMAL CONVERSION CHART 323 APPENDIX G: DECIMAL-HEXADECIMAL CONVERSION CHART 325 APPENDIX H: SCREEN STORAGE ADDRESS TABLE 327 APPENDIX I: COLOR STORAGE LOCATION TABLE 329 APPENDIX J: ASCII CODE 331 APPENDIX K: SCREEN STORAGE DISPLAY CODES . 333 INDEX 335 PREFACE Learning assembly language programming is a challenge not everyone will accept. It is not as easy to learn as BASIC, and it re- quires learning how to work an assembler as well as learning assembly language itself. Many who attempted to learn assembly language have been stopped by lack of an assembler, lack of instruc- tions on how to work an assembler or lack of instructions for learn- ing assembly language on the Commodore 64. If any one problem didn't prevent learning the language, the combination of problems did. Since these problems are real, I decided that it would be a good idea to create a book that provided solutions to all of these hurdles. First, the book would supply a simple assembler that would be in- structional as well as functional. Secondly, it would explain how to work the most popular assemblers for the Commodore 64, in- cluding the one provided in the book. Finally, the book would take assembly language a step at a time, explaining how to program using assembly language instructions. That's what this book does. As the title implies, this book was designed for kids. This doesn't mean the book is for children, but rather it's for kids who want to enjoy learning something. I would have never learned BASIC or assembly language if at some point I didn't start enjoying myself. The same principle applies here. If we try to have a good time while learning assembly language, it becomes an interesting challenge in- stead of boring work. There are lots of examples that show something about assembly language in a fun way. VI. ACKNOWLEDGEMENTS If ever there were a group of people who were willing to help an author, it's my Commodore computer club, the San Diego Pet Users Group. Jane Campbell, Don Johnson and Barbara Prouty answered plenty of questions and provided lots of ideas. Fellow authors, Guy Grotke, who wrote Intermediate Commodore 64, and David Miller, author of Commodore 64 Files, were equally helpful with information and suggestions. Eric Goez is responsible for teaching me most of what I know about assembly language pro- gramming. Roger Wagner, author of Assembly Lines: The Book, served as an excellent editor. My own kids, Billy and David, were guinea pigs whenever I could detach them from MTV. My wife Eli, as usual, was a good sport about the whole thing. Naturally, any fault with this book lies with the author, not with those who so will- ingly helped. VII. CHAPTER 1 INTRODUCTION What This Book Is About This book is about creating machine language programs with an assembler. So the first thing we will learn how to do is to use an assembler. If you do not have an assembler, I've included one in this book you can use. You will learn how to write assembly language with specific assemblers. We will go through their use step by step covering only their basic features. Most assemblers have advanced features you can use, but we will not be going into these aspects of assemblers. Once you are comfortable on this level, you can read more advanced books and documentation for special features of the various assemblers. If you already have an assembler, and you know how to use it, you can skip Chapters 2-4 since their sole purpose is to explain how to operate different assemblers. Secondly, this book will explain using assembly language coding procedures. There are many different operations you can perform with an assembler. In fact there are 151 different machine opcodes accessed by 56 assembly language opcodes. An opcode is an instruc- tion something like BASIC statements. However, we are not going to cover all the assembly language opcodes. Some opcodes involve complicated operations, and we're not going to get overly advanced 1 in this book. It is more important to learn how to use the fundamen- tal operations well and understand their use clearly than try and learn everything at once and not understand what you're doing. Nevertheless, when you are finished with this book, you will be able to write assembly language programs. Furthermore, we are only go- ing to deal with the Commodore 64. If you have a different com- puter, even a VIC 20, you should get a different book. Finally, we're going to have to spend some time on how your microprocessor handles code, different number systems and storage. To be honest, this isn't a lot of fun, but once we're through, you'll understand a lot more about your computer and how to han- dle machine and assembly language operations. This is all covered in Chapters 5-7. If you know about binary, hexadecimal and decimal number conversions and how the whole thing works in your microprocessor, skip these chapters. (There's no sense in spending time on something you already understand.) From Chapter 8 on, we start writing assembly language programs. Who This Book is For This book is for kids who want to begin programming in assembly language. You might want to know the difference between a general book for beginners and one for kids. In a lot of ways there is no difference, especially if this is your first venture into assembly language. However, we're not going to get too serious, and the em- phasis will be on having a good time learning assembly language programming instead of a comprehensive guide to professional pro- gramming. Also, we're going to play a lot with little routines that do crazy things to your Commodore 64 instead of writing programs for the sequential development of applications. This means we're not going to be getting into abstract structures and theories about microprocessors. Instead the emphasis will be on learning by doing. Most of the routines will display something to the screen so that you can see what's going on. This means we will be doing a lot with text and graphic displays and not so much with mathematical manipula- tions important for business applications. Besides, its more enter- taining to watch a sprite go screaming across the screen than adding up a column of numbers. As a warning to those of you who just got your Commodore 64, you should know that assembly language programming is a lot more difficult to master than BASIC. In fact, if you do not know how to program in BASIC, I would strongly recommend you learn it before tackling machine and assembly language. Many of the examples and explanations are based on the assumption that you have a work- ing knowledge of BASIC. There are several good books for kids learning BASIC, including KIDS TO KIDS ON THE COMMO- DORE 64 and KIDS AND THE COMMODORE 64, and you should read them before going on here. However, if you know how to program in BASIC, you're halfway to understanding machine language since you can transfer much of the BASIC programming logic to assembly language programming. Finally, since this book is designed for kids, you might expect to be talked to as adults tend to talk to kids. The last thing I want to do is to talk down to anyone. We'll go slowly and clearly, and we'll have some fun, but don't expect to be treated like a half-wit. Also, this book is not going to have a lot of tests to see if you got everything right. Books with little tests at the end of the chapters are fine if you like taking tests. You have enough tests in school; so you won't get any in this book. Instead we'll have lots of example pro- grams that explain and illustrate the use of various assembly language programming techniques. By using your own imagination and playing around with the various opcodes, you can learn more than by taking tests. Why Use Assembly Language? Most books on assembly and machine language explain the speed and compactness of machine code as the major reason to use it in- stead of BASIC. That's certainly true, but I like assembly language because you can really grab control of your Commodore 64, im- press your friends and make a fortune. If you have ever played a good arcade game, chances are it was written in machine language with an assembler. The sound and speed of movement just aren't possible with BASIC. If you ever shelled out money for such a game, who do you think is getting it? A good chunk of the money goes to the person who wrote the game program. Believe it not, I know kids who can retire when they graduate from high school with the money they've made programming with machine language. Several other kids I know have part-time jobs after school working for businesses requiring customized programs written with assemblers. They may not make a fortune, but they get paid better than the kids working in fast food joints and enjoy their work a heck of a lot more. Now don't expect to write a best-selling arcade game after you read this book or even get a paying job as a programmer, but you will get started, and even the best programmers had to start somewhere. Now if you're not interested in making money as a professional programmer, you can treat assembly language programming as an adventure game. The whole purpose of adventure games is to find a treasure hidden in a maze of caverns, tunnels, castles and dungeons. Believe me, once you enter the caverns of your Commodore 64's memory with its 64,000 caves of RAM plus all the tunnels of ROM, you'll need all your wits to save your neck. What's more, once you understand the memory, you will have all kinds of control even the best adventure games cannot provide. Finally, if you have any friends who know even a little assembly language programm- ing, you got to admit that you're impressed. Kids who can handle machine code have a certain magic about them that draws admiration. I admit it; it's fun to impress people and show off. You don't need any brass band or be a loud mouth with assembly language. Just crank up some code and let her rip. Assembly language programmers have style! 4 This book is not meant to disparage BASIC; I use BASIC all the time. It's quicker to write a program in BASIC and less difficult to de-bug. As we will see later in this chapter, one of the most useful applications of assembly language programs is to write subroutines for BASIC. So instead of abandoning BASIC altogether, you can use assembly language programs to enhance your BASIC programs. What is an Assembler? An assembler is a program that allows you to enter machine language using a standard set of "mnemonics." What?!! First we better explain what "mnemonics" are. Pronounced 'ni-mon-iks', mnemonics are aids to help remember something. All of the instruc- tions for your 6510 microprocessor are given with three letter mnemonics. For example, one commonly used instruction is 'LDA.' The mnemonic LDA stands for LoaD Accumulator. The machine language opcode for LDA in the immediate mode is the hexadecimal number $A9 or decimal 169. Since it's a lot easier to remember LDA instead of $A9 or 169 when you want to LoaD Ac- cumulator, programmers prefer using assemblers instead of enter- ing machine code directly. (In fact, a lot of machine code is entered with POKEs from BASIC. A POKE X.169, where 'X' is some ad- dress in memory, could very well be a machine language instruction from BASIC to perform an LDA.) Secondly, assemblers keep track of everything for you. When machine language is entered into your machine, you must use se- quential addresses for your instructions and values. Let's suppose you want to enter your machine language program in addresses 49152 to 49162 ($C000 - $C00A). Depending on what instructions, modes, values and addresses are used, more or less memory will be taken up. Instead of having to figure out all of these elements as you go along, the assembler does it for you. For example, if you use the LDA instruction in the immediate mode, you take up two addresses. However, if you use LDA in the absolute mode, you need three ad- dresses. Furthermore, while LDA in the immediate mode has a machine language value of $A9 (169 decimal), LDA in the absolute mode has a value of SAD (173 decimal.) This is all understood by your assembler, and you don't have to do anything other than give it the mnemonic instruction and mode to have it do what its supposed to do. If you do not understand everything just discussed, DON'T WORRY! Essentially, all that I'm trying to tell you is that an assembler makes programming in machine language a lot easier! You're not expected to grasp everything all at once, and what is unclear at this point will make a lot more sense as you start working with an assembler. The trick is to forge ahead and start working with an assembler and the programs and instructions in this book. You will remember when you started learning BASIC that everything was not clear until you started experimenting, learning special tricks and writing your own programs. The same is true with assembly language. Practice will lead to understanding. Machine and Assembly Language By now, you probably realize that assembly and machine language are two sides of the same coin. Assembly language uses mnemonic codes to enter numeric machine code. In addition, an assembler keeps track of everything needed for a machine program to execute. For example, let's look at three programs that all do the same thing. First, we'll look at how the program would be entered with an assembler, then we'll see what it looks in machine language, and then we'll see how it would be entered from BASIC directly into machine code. Each method ends up with the same result, and I'll let you decide what method is the most understandable and least dif- ficult. All the program does is to jump to a subroutine located inside your computer at hexadecimal address $E544 (58692 decimal) and then returns to BASIC. The subroutine clears your screen and puts the cursor into the upper left hand corner. Assembly Language ORG $C000 ; Begin storing program here JSR $E544 ; Jump to subroutine at $E544 RTS ; Return to BASIC Machine Language $C000 $20 $C001 $44 $C002 $E5 $C003 $60 BASIC 10 C = 58692 : REM DECIMAL VALUE FOR $E544 20 LB = C - INT(C/256) * 256 : REM LO-BYTE 30 HB = INT(C/256) : REM HI-BYTE 40 POKE 49152,32 : REM JSR 50 POKE 491 53, LB 60 POKE 49154.HB 70 POKE 49155,96 : REM RTS If you think the assembly language program is the simplest you're right! Even with the REM statements, it's difficult to know what's going on in the BASIC program, and at this stage of the game, the machine listing should make no sense at all! In the assembly pro- gram, all you have to do is to tell it where to start placing the code with the ORG directive (or some similar instruction, depending on the assembler), and then using the mnemonic codes, tell it what you want it to do. Since the program is very small, using only four ad- dresses or bytes, you can imagine how difficult it would be to enter everything in machine language or POKE it in with BASIC with longer programs. In magazine listings, you've probably seen BASIC listings with POKEs and then a mile of DATA statements with the values to be POKEd in. The programmer probably had to first write the program using an assembler and then "disassemble" it with PEEKs to get all those values. Just for fun, key in the BASIC program and RUN it. When you're finished enter: SYS 49152 Your screen will clear. Of course it's a lot easier to PRINT "{CLR/HOME}" from BASIC to do the same thing, but a pro- gram line in BASIC with the instruction to clear the screen and home the cursor takes up a lot more room in your computer's memory. Later in this chapter we'll compare the amount of memory used to see precisely how much more space is used by BASIC and why machine code is so much faster. ASSEMBLERS COVERED IN THIS BOOK Since learning how to use a specific assembler requires special in- structions, I decided to go into detail on the operations of certain ones that you may already have, are recommended or, if you don't have one, the one in this book. If you have an assembler and know how to use it, you can skip this section and Chapters 2-4. If, on the other hand, you bought an assembler not covered in this book but cannot figure out how to work it, take a look at Chapters 2-4, and your's may work in a similar manner to ones we discuss. If all else fails, you can always key in the Kids' Assembler in the book and use it. The Commodore 64 Macro Assembler Development System Chances are if you own an assembler already, you probably have the one made by Commodore. I found it to be difficult to under- stand, but once I got used to it, it works fine. You can edit, assemble and load your code. It also comes with a machine language monitor for entering assembly or machine language routines. However, it does take a lot of work to load all the different files necessary to do the different tasks required in writing assembly programs. In Chapter 4, we'll go through its use step by step so that you can use it effectively. The Merlin 64 Assembler This assembler is my own personal choice, and if you don't have an assembler and want to get a good quality one inexpensively, I would suggest this one. Roger Wagner Publishing has made a special deal for kids. In the back of this book, you will find a coupon for the Merlin 64 Assembler at a reduced cost. You can also find it in your local stores. 8 The Kids' Assembler In Chapter 2 and Appendix A there are BASIC listings for an assembler written especially for kids. (In Chapter 2, we go through the program in parts to see how it assembles code, and in the Appen- dix, the listing contains all of the instructions used by the 6510 microprocessor. For the time being, use the one in Chapter 2 since it deals with just those instructions we will be using.) Since I wrote this assembler, I can criticize it. It has a minimal editor, it uses non- standard opcodes, and because it is written in BASIC it is slow. However, it does have a certain amount of error trapping so that if you enter an illegal value or instruction, it will let you know right away. It also shows you where your code is going in decimal values. Furthermore, since you will key it in yourself, it will help you understand what's going on. Best of all, it's very simple to use, and it's free! Sooner or later, though, you will want to get a good assembler with an editor and monitor. Other Assemblers Not Covered in this Book There are several magazines that provide listings of machine language and BASIC assemblers. Magazines such as COMPUTE! 's GAZETTE and THE COMMANDER have had listings of assemblers, editors and monitors for the Commodore 64. Each assembler, like the ones discussed in this book, have their own uni- que characteristics and manner of handling assembler instructions. Likewise, several companies make commercial assembler/editors, but there are far too many to explain each one's use here. Since the documentation for these assemblers ranges from the fairly clear to the almost incomprehensible, you might have a problem under- standing how to use them. Therefore, I have provided a short sec- tion at the beginning of Chapter 2 entitled ' 'Assemblers in General' ' to give you a running start on their use. Actually, we will be dealing with entering code with "editors" in that section, but most assemblers have built-in editors so that when you run the assembler, you also have access to the editor. (The Commodore Editor64 and Assembler64 are separate co-resident files, however.) After reading that section, re-read the documentation with your assembler/editor and you can probably get everything going. BASIC and Assembly Language As we have seen, there are some connections between BASIC and assembly language. In fact, after going through a number of inter- pretive steps, the programs you write in BASIC are ultimately ex- ecuted in machine language. Since there are so many interpreta- tions, though, it takes longer to execute a BASIC program than one written in assembly language. Let's take a look at our little machine language program to clear the screen and one written in BASIC that does the same thing. JSR $E544 RTS 10 PRINT CHR$(147) ^Leave this in memory We used only four addresses for our machine language program. Address Opcode or Operand Hex Dec $C000 49152 $20 ■* Machine code for JSR $C001 491 53 $44 -* Low byte of jump address $C002 49154 $E5 ^High byte of jump address $C004 491 55 $60 ^Machine code for RTS Now, how do we examine the memory used by our BASIC pro- gram? The most simple way is to subtract the amount of free memory we have from the 3891 1 bytes that are free when we start up the Commodore 64. You remember the FRE(0) statement in BASIC. If you PRINT FRE(0) you will be presented with the amount of available memory. Since this is a negative number, we have to add it to 65536 to see how much memory is available. Then by subtracting that amount from 3891 1 we will find how much our one line program used. Therefore enter: PRINT 38911 - (65536+ FRE(0)) {RETURN} You should have gotten '17', the number of bytes used by the pro- gram. That's over four times the amount used by our assembly language program! 10 To actually see the code in your computer in a BASIC program, we will "disassemble" the BASIC code. In your Commodore 64, BASIC programs begin at location $800 (2048 decimal). To find the end of the BASIC program and the start of variables, we look at a 'pointer' at locations $2D-$2E (45-46 decimal). A pointer is pretty much what it implies - it points to an address. By PEEKing at the locations between 2048 and the address stored in the pointer to the end of the program, we should be able to see the entire BASIC pro- gram. So first, we have to find the end of the program. We do that by PEEKing the value stored in locations 45-46 using the following algorithm: PRINT PEEK(45) + PEEK(46) * 256 {RETURN} = = EVERYTHING IS BACKWARDS! = = Now if you're as smart as you look, you're probably wonder- ing why the heck we used that weird second PEEK. Why did we have to multiply it by 256 instead of just a regular PEEK? If you look at the machine code listing, you will see that when we jumped to the subroutine at $E544, the code was entered as $44 $E5 in two consecutive addresses. That's called low-byte, high- byte storage. Therefore, when we pull a number out of two consecutive storage address, we convert it to the correct decimal value by multiplying the high byte (the second address) by 256. Then by adding the high and low bytes, we get the cor- rect decimal number. You don't have to worry about understanding all of this now, but just remember that numbers are stored backwards! In Chapter 3, we'll explain more about this feature of your Commodore 64's memory. You should have gotten '2064'. After all, we know that the BASIC program used 17 bytes of memory and BASIC programs begin at 2048. Thus, 2048 = 17 - 1 = 2064. (Since the program uses ad- dresses 2048 to 2064 inclusive, we subtract 1 from used memory to get 2064.) Now, by PEEKing locations from 2048 to 2064 we can see our entire program. Enter the following: 11 FOR X = 2048 TO 2064 : PRINT X;PEEK(X) : NEXT X {RETURN} You get the following "disassembly": Byte# Address 1 2048 ^Beginning of BASIC 2 2049 14 3 2050 8 4 2051 10 -*l_ine number 5 2052 6 2053 1 53 ^ PRI NT statement 7 2054 32 ^Space 8 2055 199 ^CHR$ function 9 2056 40 -*Left parenthesis 10 2057 49 1 1 2058 52 m Mystery numbers 12 2059 55 13 2060 41 ** Right parenthesis 14 2061 15 2062 16 2063 17 2064 88 ^Beginning of variables Just look at all of that to clear the screen! When you key in a BASIC program, you automatically key in a machine language pro- gram as well. While it is less work for you to key in BASIC, it's a lot more work for your computer as you can see. When you key in a BASIC word, it is 'tokenized' into a machine code value. For example, we can see the token for PRINT to be 153. Likewise CHR$ is 199. The line number is there along with the left and right parenthesis, the space and some "mystery numbers" that are special codes for CHR$ values. (Appendix D has a complete listing of the BASIC tokens.) In the next section we'll do some tricks with these values that will give you power over BASIC that you never realized you had. At this point you should be convinced that machine code is more compact than BASIC as far as your computer is concerned. Fur- 12 thermore, you should be able to deduct that if there is less code for the computer to read, it can execute it faster. Finally, you should see that when you write BASIC you are also writing a machine language routine. Now that you know all of that, let's see how you can use lit- tle machine code routines in your BASIC programs. Machine Subroutines From BASIC An old saying among programmers is that 10% of a program takes 90% of the time. For example, if you have a sort routine in your program, most of the time spent by your computer is sorting the numbers or strings you enter. The actual sorting routine may on- ly take a few lines, but it is the routine that takes up the majority of your execution time. Since BASIC code can be entered very quickly compared with assembly code, a lot of programmers write machine language subroutines that can be called from a BASIC program using the SYS statement. In this way they can insert time-consuming routines, such as sorts, in machine code and speed up the slow part of the program without having to write the whole program in assembly language. What's more, you can put the machine code in one part of memory that will not interfere with the memory being used by BASIC. To see how this works, let's write a little machine code routine to change the color of your screen. We'll stick that in memory out of the way of BASIC and then call it from BASIC with SYS. You probably know that decimal address 53281 holds the code for your background color. By POKEing 53281 with values between 0-15 you can change its color. In assembly language to do that, we would store a value in that location. LDA#0 STA 53281 RTS The above routine loads the accumulator with the number 0, the code for a black background, and sticks it in 53281. We'll put that routine at addresses 49152-49157 with the following BASIC pro- gram. 13 10 BC = 53281 : REM ADDRESS OF BACKGROUND COLOR 20 LB = BC-INT(BC/256) * 256 : REM LOW BYTE 30 HB = INT(BC/256) : REM HIGH BYTE 40 POKE 49152,169 : REM LDA 50 POKE 49153,0 : REM BLACK COLOR CODE 60 POKE 49154,141 : REM STA 70 POKE 49155,LB : REM LOW BYTE ADRS 80 POKE 49156,HB : REM HIGH BYTE ADRS 90 POKE 49157,96 : REM RTS Now RUN the program and then enter NEW. The BASIC program is no longer in memory because you entered NEW. Just to be sure you got rid of it, enter LIST {RETURN}. (If you get a listing, better enter NEW {RETURN} again.) The NEW command got rid of the BASIC program beginning in memory location 2048. But since you put your machine code way up in 49152, your machine code should still be there. Now enter the following BASIC program that will use the machine language program. BASIC and machine language can run together. 10 PRINT CHR$(147) 20 INPUT "HIT RETURN TO SEE THE SCREEN GO BLACK";A$ 30 SYS 49152 40 PRINT "NOW IT'S BLACK!" 14 By the way, in case you didn't notice it, the BASIC program to enter machine code was pretty long. With an assembler, you'd just have the three lines to enter. So while BASIC in general is faster to program, it takes a lot more to write assembly language with a BASIC program than it does with an assembler. Some Tricks to Get Started To get off on the right foot, you should use your knowledge of machine language to do something impressive. In order to see a part of your new power, try the following. 10 GOTO 30 65535 PROGRAM WRITTEN BY ME 30 PRINT "TA DA!": END You can't do it. Right? As soon as you enter 65535 as a line number your Commodore 64 burps out a SYNTAX ERROR. Now try it again. 10 GOTO 3© 20 PROGRAM WRITTEN BY ME 30 PRINT "TA DA!": END Normally, you'd get a SYNTAX ERROR in Line 20 since it is in an illegal format. However, Line 10 jumps to Line 30 so there's no problem. Now, let's PEEK at locations 43-44 to find the beginning of the program, and list a screen of locations and their values. PRINT PEEK(43) + PEEK(44) * 256 {RETURN} We get 2049. (Actually BASIC programs begin at 2048, but the in- teresting stuff starts at 2049.) Now let's "disassemble" the first 20 addresses of the BASIC program in memory. FOR X = 2049 TO 2039 : PRI NT X; PEEK(X) : N EXT {RETURN} You'll see the following (assuming you entered the program exactly as listed - even including the spaces). 15 2049 10 2050 8 2051 10 < Line number low byte 2052 <4Line number high byte 2053 137 ^GOTO token 2054 32 ^Space 2055 51 2056 48 2057 2058 36 2059 8 2060 20 -«Line number low byte 2061 <4Line number high byte 2062 80 2963 82 2964 79 etc... Notice that address 2060 has the value of 20 for line number 20 . Right after that is a zero (0). Notice also that following the line number at address 2051, address 2052 has a zero (0). The zeros represent the high byte value for any line number. Now suppose we put the maximum value in the low byte and high byte addresses for Line 20 . (The maximum value for any single byte is 255 or hex value $FF.) Let's see what happens: POKE 2060,255 : POKE 2061,255 {RETURN} Go ahead and LIST your program. You now have the program with the "illegal" line number. It should now look as follows: 10 GOTO 30 65535 PROGRAM WRITTEN BY ME 30 PRINT "TA DA!" : END It will still RUN, but no matter how much you LIST it, it will not put the line numbers in numeric order. Also, unless you re-POKE the addresses storing the line number 65535, you can't get rid of line 65535. Go ahead and try. If you want to customize your programs and include a line with your name on it that most BASIC program- 16 mers cannot delete, use that little trick. The following is another ver- sion using the same trick. However, since we know the addresses storing the second line number, we can include a line in the program that will automatically change the line numbers. 10 GOTO 30 20 BY {YOUR NAME} 30 POKE 2060,255 : POKE 2061,255 40 PRINT CHR$(147) : LIST When you RUN the program you screen will clear and you will see, 10 GOTO 30 65535 BY {YOUR NAME} 30 POKE 2060,255 : POKE 2061,255 40 PRINT CHR$(147): LIST From the above, you should now be able to see that what is stored in RAM space addresses can be changed. However, you have to know something about how your BASIC or machine language pro- gram is stored in order to make changes. If you can make those changes, then you have taken the first step in machine language pro- gramming. That's because the great bulk of assembly and machine language prograrnrning is placing instructions and information into addresses and using addresses to keep track of your program's in- formation. Again, you probably don't understand everything at this point, but by practicing the examples and reading the explanations, things will soon come together. Also, by changing the examples and experimenting on your own, you will begin to understand how your computer works in your own terms. (Just for fun, why don't you see if you can change the little machine program that turned the background color of the screen to black. See if you can change it to different colors using values between 1-15. They're all listed at the end of this chapter.) SETTING UP Before you start using your assembler, be sure to make a back-up copy of it on a separate diskette or tape. There are a million ways to blow a disk or tape with machine code; so if you don't want to lose 17 your assembler, make a back-up copy of it. The two commercial assemblers discussed in this book, Commodore Assembler and the Merlin assembler, can be backed up. Be sure to put a copy of the assembler on your work disk and keep the master disk in a safe place. Likewise, with the Kids' Assembler be sure to make a back-up of the disk or tape you SAVE it on. If you don't feel like keying it in, there's a coupon in the back of this book that you can send in and get a copy on disk for $10. Whatever you do, though, make back- ups of your assembler. There are two versions of the Commodore 64 we'll classify as the "old" and "new". In the old version, it is possible to store a character in the screen memory area, and it will appear on your screen after the screen has been cleared. On the newer versions, you have to load both the color and character after a JSR $E544 (clear the screen and home cursor) to see the characters. The old version will work with either, but the new version requires the color. Therefore, all of our programs will be set up for the newer version, but will work on both the old and new versions. If you have a monitor, the default colors on your Commodore are not too clear. Therefore, both the Kids' Assembler and Merlin pre- sent your screen with a white background and border and black let- ters for better viewing. Since the default color of characters is white after a JSR $E544, a white on white display is invisible. Therefore, we will have to take care to keep the character colors straight. If you have a color TV or color monitor and prefer the default Commodore colors, or some other combination, you can change them by POKEing the following addresses with values, represented by the variable X, between 0-15. POKE 53281.X -^Background Color POKE 53280.X -* Border Color X's value can be from 0-15 18 The colors are: Black 4 Purple 8 Orange 12 Gray 1 1 White 5 Green 9 Brown 13 Light Green 2 Red 6 Blue 10 Light Red 14 Light Blue 3 Cyan 7 Yellow 11 Gray 1 15 Gray 3 This all may be familiar to you, but just in case you did not know about changing your screen colors, you do now. Now, let's get into assembly language! 19 20 CHAPTER 2 USING AN ASSEMBLER Assemblers in General When I encountered my first assembler, the greatest problem I had was figuring out how to use it. There was no documentation for it since it was a public domain version I got from my club. Later on someone came along with the documentation, and after I read it, I still didn't know how to work the darned thing! Finally I realized the problem with most assemblers and their documentation. THE DOCUMENTATION IS WRITTEN FOR PEOPLE WHO ALREADY KNOW ASSEMBLY LANGUAGE! For the kids (and adults) who do not know assembly language or other assemblers, it doesn't help to know that a whiz bang assembler has macro capabilities when you don't even know what a macro capability is. Therefore, to get started, we're going to demystify assemblers by exposing them for what they really are. As we briefly mentioned in Chapter 1 , all an assembler really does is to neatly and simply arrange machine language code. The code with which we work in assembly language can be broken down into three parts: 21 1. Addresses to store code. 2. Instructions to tell the computer what to do next. (Opcodes) 3. The exact location or mode relative to the instruc- tion. (Operands) To understand a little about what's going on with an assembler, let's look at what assembled (or compiled) code is compared with the assembler in- structions that made it get that way. (You remember our com- parisons between machine and assembly code in Chapter 1.) Compiler Compiled Machine Code HEX DECIMAL Address Code Address Code $C000 $20 49152 32 $C001 $44 49153 68 $C002 $E5 49154 229 $C003 $A9 49155 169 $C004 $A9 49155 8 $C005 $8D 49157 141 $C006 $21 49158 33 $C007 $D0 49159 208 $C008 $60 49160 96 Assembler Source Code Line# Opcode Operand 1 JSR $E544 2 LDA #8 3 STA $D021 4 RTS 22 We already know that assembly language is less mysterious than machine code, but let me give you an idea of everything the assembler did to compile the code. 1 . First, it looks at the opcode (the instruction) and the mode of the instruction and decides how many bytes it will take. For ex- ample, the instruction JSR (Jump to SubRoutine) takes up 3 bytes or addresses. The first byte is the machine opcode for JSR and the next two bytes are needed for the address ($E544). On the other hand, LDA in the immediate mode only needs two bytes and addresses; one for the operand and one for the value which has to be 255 ($FF) or less. The RTS opcode only takes a single byte or address. 2. Next, the assembler arranges the operands greater than 255 ($FF) and puts them in the lo-byte / high-byte configuration your computer uses. 3. Finally, it places these values all in memory in ascending order of addresses. ("Ascending" means from lower to higher addresses.) This is called the assembled or compiled code. The work of an assembler should not be very clear to you right now, but later on the clouds will begin to clear and you'll say, "Oh yeah! Now I get it." In the meantime, just think of an assembler as a "code arranger" to make writing machine language simpler. The Standard Parts of An Assembler An assembler package sometimes has several different files representing the different things an "assembler" does. Actually, the "assembler" is only a single part of what most people call "assemblers." Generally, we deal with "editors" and "assemblers" as different parts of a single tool, but usually you never "see" the assembler do its work. Instead, you will be working primarily with the editor. Now let's take a look at all the parts: EDITOR. The editor is used to enter what's called "source code." All of the mnemonic instructions, such as LDA and STA are accepted by the editor. When the source code is 23 assembled into machine code, it is called the "object code." In simple editors, such as the one in the Kids' Assembler, you can only enter source code. You can't edit it after its been entered. (It does have a good deal of error trapping so that if you enter illegal opcodes or operands, it will let you re-enter legal ones before continuing.) On more sophisticated editors, you can in- sert and edit lines, make global changes, move or copy big chunks of code and save and load source code. The Merlin Assembler and the Commodore 64 Assembler Development System have editors that can do some or all of those things plus more. When getting an "assembler", the real key to getting a good one or bad one lies in what you can do with the editor, not the assembler. ASSEMBLER. Since the assembler part of an assembler is pretty much invisible to the user, and they all do essentially the same thing - compile code for you in machine language - there's not a whole lot to say about how good or bad the ac- tual assembler is. However, since assemblers are so closely link- ed to the kind of editor one is using and how it handles code, in- visible differences become apparent in the editor. A one-pass assembler takes the opcodes and operands and orders them in- to machine code either as soon as you enter the information in the editor (as does the Kids Assembler) or when you finish your program. A two-pass assembler is used in just about all com- mercial assemblers for the Commodore 64. First, the two-pass assembler finds the addresses and offsets for the labels, and then on the second pass, compiles it into machine code. On the Merlin Assembler and Commodore 64 Macro Assembler Development System, you can use labels in your editor; therefore, using two passes, the labels are automatically turned into the correct addresses and offsets. On the Kids' Assembler, since the editor will not accept labels, it compiles as soon as the operand is entered. What this means for the user is that it's a heck of a lot easier to use a two-pass assembler since you can do more things simply with the editor. 24 ASSORTED OTHER PARTS 1. LOADERS and SAVERS. Some assemblers have the loaders built into the editor while others have separate files for loaders. Most commercial assemblers will load the source code from the editor. Object code (the compiled code that runs) is saved either as SEQ or PRG files on your disk. (Tapes only ac- cept object code as SEQ files or as DATA statements in PRG files.) If your object code is saved as a PRG file, you can load it from disk with LOAD "FILENAME", 8,1 and then SYS its beginning address to make it run. If saved as SEQ files, it is necessary to have a driver program to first load the file into memory and then SYS it. A good assembly package will allow you to load and save source code and object code. It is especial- ly important to have source code saved for developing larger programs with an assembler so that you can work on the pro- gram at different times. Likewise, it is far better to have your object code saved as a PRG file so that you can execute it without having to load a special loader program. The Kids' Assembler is good in that it saves object code as PRG files, but bad in that it saves the source code only as a SEQ file that can- not be reloaded into the editor. (That's why the programs in this book are relatively short!) The assembler by Commodore is good at saving source code that can be reloaded into the editor, but poor in that object code is saved as SEQ files requir- ing separate loader programs. The Merlin Assembler not only saves source code files, but it saves object code as PRG files. Furthermore, using the Sourceror program that comes on the Merlin Assembler disk, you can create source code from object code stored as PRG files. (That may not mean much to you now, but if you have a diskfull of object code saved with the Kids' Assembler, BELIEVE ME, you'll someday want the source code.) 2. MONITORS. Several assembler packages include monitors. (Monitors, in this instance, do not refer to the special TV sets for computers.) A monitor is a program that lets to examine, enter, change and execute machine code. In Chapter 1 we used a do-it-yourself BASIC monitor in examining the addresses 25 and code they contained. I didn't include a monitor in this book since I'm going to let you write your own! (There'll be plenty of tips on how to do it, though.) The Merlin and Com- modore assembler packages contain very good monitors. The Merlin monitor is especially useful since it is co-resident with the editor/assembler. 3. DISASSEMBLERS. Disassemblers take assembled code in memory and lists it in rudimentary mnemonic and machine code. For example, a disassembly of our program in this chapter might looks as follows: (All numbers are in hex- adecimal values.) C000 20 44 E5 JSR $E544 C003 A9 08 LDA #$08 C005 8D21D0 STA$D021 C008 60 RTS $60 Disassemblers are very useful to see the relationship between machine code and assembly code. Take a look at the dis- assembly above with the listings near the beginning of the chapter to see if you can find the connection. 4. OTHER GOODIES. Assembler packages have all kinds of enhancements to help you with your assembly code. Some have de-buggers to help you find mistakes in your code. These vary from the built-in error trapping in the Kids' Assembler to ones that will let you find structural problems in your code. Second- ly, source code generators are very helpful to examine how others have created object code, even ones created with dif- ferent assembler packages. The Sourceror in the Merlin Assembler package is one such helpful program. Finally, many assembler packages come with a set of source code files of useful routines. These routines are not only valuable for seeing how a certain operation works, but they can be incorporated into your own programs to save you the time of developing them yourself. 26 STANDARD EDITOR/ASSEMBLER FORMAT When you first start entering assembly language code, you'll do it from the editor. Just about all assemblers have four fields: 1. The label field. 2. The opcode field. 3. The operand field. 4. The comment field. The fields arranged from left to right look like this in your editor: LABEL OPCODE OPERAND COMMENT As you enter the code in each field, to the left of the label field, line numbers appear. These are something like BASIC line numbers, but they usually have increments of 1 instead of 10 as in BASIC. (These line numbers are not compiled!) A typical editor entry would look liking the following: LINE# LABEL OPCODE OPERAND COMMENT 1 LDX #$0 ; Load X register with 0. 2 START TXA ; Transfer contents of X to A 3 STA $400,X ; Store value in ad- dress $400 indexed byX 4 I NX ; Increment X 5 CMP #254 ; Compare A with 254 6 BNE START ; If A is not equal to 254 then go back to line labeled START 7 RTS As you can see, it is unnecessary to always use all fields. Many programmers do not use the comment field at all, while others use 27 several lines for nothing but comments. (Using the comment field is equivalent to using REM statements in BASIC.) However, just about every editor arranges its fields as they are above. Editor/ Assembler program writers have an idea of how to best put assembler packages together, and so there are differences that creep in using one package or another. Perhaps the biggest is in the use of "Pseudo-Opcodes." Pseudo-opcodes are instructions that are never compiled into object code. Instead, they tell the editor to do something with the code. Often, they are called "directives" to differentiate them from opcode "instructions." For example, ORG and EQU are two commonly used directives for defining the load location of a program and defining addresses with labels. For exam- ple the following is a common label definition you will see in listings: HOME EQU $E544 and instead of keying in, JSR $E544 the programmer can enter, JSR HOME If you plan to use an assembler package not discussed in the next three chapters, keep in mind what we have discussed here. In that way, if the documentation for your assembler is unclear, you can at least expect to find the fields we discussed above. Go back over your documentation and then go ahead to Chapter 8 and try out some of the example programs. If you can get them assembled and running, you can learn more about how to use your assembler as we go along comparing what's in the book with your documentation. You might also want to take a look at the way the Commodore assembler and the Merlin Assembler assemblers are used to help you understand your own. 28 USING THE KIDS' ASSEMBLER First off, if you have either the Merlin Assembler or the Com- modore 64 Macro Assembler Development System skip this chapter, and go on to the chapters covering the assembler you have. In fact, if you have any other assembler you know how to work, use it instead of this one. However, if you have been confused by your present assembler, the Kids' Assembler may help you get started. Most importantly, by keying in this assembler, you'll learn about what an assembler does. In Appendix A, there's a full blown version of the Kids' Assembler. The one in this section has fewer opcodes and it runs faster than the big one in Appendix A. I also included a routine to save source code in this chapter. It doesn't save the source code in a way you can re-use it, but you can read it. Also, I've broken it down into sections so that you can do a piece at a time. Once you key this in and get all the typing errors out, be sure and make a back-up of it on a separate tape or disk! ! ! There are two dif- ferent ending routines beginning in Line 760 . The first one is for disk users and the second is for tape users. Use only one or the other. (If you have a disk system and a cassette, just use the disk version.) By the way, feel free to modify the program any way you want. Okay, we're all set; so let's key in the first 15 lines and then see what they do. Kids' Assembler : C-64 10 POKE 53281,1 : POKE 53280,1 : PRINT CHR$(1 44) 20 GOSUB 4000 30X = 40 READ A : IF A = 255 THEN 60 50 READ B$ : READ C : X = X + 1 : GOTO 40 60 DIM DEC%(X),OPCODE$(X),BYTE%(X) 70 DIM AD(255),S$(255),C$(255) 80ER = X-1 90 RESTORE 100 FOR I = TO X-1 : READ DEC%(I) : READ OPCODE$(l) : READ BYTE%(I) 110 NEXT I 29 120 PRINT CHR$(146);CHR$(147) 130 PRINT "ADRS"; TAB(10);"OPCODE";TAB(25);"OPERAND" 140 FOR X= 1 TO 40 : PRINT CHR$(114); : NEXT 150 PRINT First the program sets the background and border colors to white and the characters to black in Line 10 . This is simply to make it easy for people using CRT monitors or black and white TV sets to see the screen. If you like the blue colors, leave the line out or POKE in your own colors. Line 20 goes to a header subroutine to give you something to look at while the array is being loaded between Lines 40-110. The variable ER in line 80 is used in the ERror trapping routine further on in the program. Line 30 just initializes the X variable. (This is optional but a generally good habit.) Line 120 turns off the inverse mode and clears the screen. Finally, Lines 120-150 make your editor header showing the opcode and operand fields along with the addresses where everything is going. It does not have a label field, comment field or lines numbers. The line numbers are replaced by the addresses to give you a clearer idea of what's go- ing on with the assembler. The variables and arrays defined are: X,l Counter Variables A,B$ & C Data viewer variables DEC%( ) Decimal value of machine opcode OPCODE$( ) Nmemonic opcode BYTE%( ) Number of bytes used by instruction AD,S$,C$ Array variables for source code This next block of code sets the starting address and asks for the opcode. Ififfl RFM **************************** 170 REM SET ADDRESS AND INPUT OPCODE 1810 RFM **************************** 190 SA = : PRINT "PRESS {RETURN} TO DEFAULT TO 49152" 200 N = 30 210 INPUT "STARTING ADDR";SA : IF SA = THEN SA = 49152 220BA = SA 230 PRINT SA;TAB(10) 240 INPUT OC$ : IF OC$ = "Q" THEN 760 250 C = 260 IF OG$ = OPCODE$(C) THEN D% = DEC%(C) : B% = BYTE%(C) : GOTO 290 270C = C+1 : IF C>ER THEN PRINT TAB(10);CHR$(18);"ERROR";CHR$(146) : GOTO 230 280 GOTO 260 290 IF B% = 1 THEN POKE SA,D% : SA = SA + 1 300 IF B% = 1 THEN S$(N) = OC$ : AD(N) = SA-1 : N = N + 1 : GOTO 230 The first thing this block does is to set the starting address. It defaults to 49152 ($C000) since that's a clear area of RAM. A lot of programmers use the cassette buffer at 828 ($033C) since it is free for disk users. Line 220 defines the constant BA to be the same as SA (starting address) since SA is used as an address variable, and we'll need the starting address later in the program. Lines 240 to 280 evaluate the opcode entered by the INPUT statement at Line 240 . It searches the arrays for a match in line 260 and gets the decimal value of the machine code and the number of bytes the instruction will use. Line 290 sees if the opcode only uses one byte, and if it does then it enters the machine opcode in the address and returns to line 230 for another opcode. Line 300 stores the source code informa- tion. The variables are: SA Variable address BA Constant to store beginning address OC$ Opcode entered D% Decimal value of current opcode B% Number of bytes used by current opcode C Counter variable 31 Now that we have the opcode entered, let's bring on the operand. ^1W REM ************* 320 REM ENTER OPERAND <VM| REM ************* 340 PRINT TAB(25); : PRINT CHR$(145); : INPUT OPR$ 350 AD(N) = SA : S$(N) = OC$ : C$(N) = OPR$ : N = N + 1 360 IF LEFT$(OPR$,1) < > "$" THEN OPER = VAL(OPR$) 370 IF LEFT$<OPR$,1) = "$" THEN GOSUB 490 380 IF OPER > 65535 THEN GOSUB 630 : OPER = 0: GOTO 340 390 IF OC$ = "BNE" OR OC$ = "BEQ" THEN GOSUB 700 400 IF OPER >255 AND B% < 3 THEN GOSUB 560: OPER = 0: GOTO 340 410 IF OPER > 255 THEN GOSUB 640 First, in Line 340, the INPUT line is tabbed over and up to the OPERAND field so you can see what you're supposed to enter. Next, Lines 360-410 check out the operand for all sorts of condi- tions: 360 If this is a decimal stick it in the variable OPER 370 If this is a hexadecimal number, go convert it 380 If this number is greater than 65535 go to the error routine and have the programmer try again 390 If there's a conditional branch in the opcode go find the branch offset 400 If the value is greater than 255 and it's only a 2 byte opcode, go to the error routine and have the program- mer try again. 410 If the value is over 255, go get it rearranged into the lo-byte / high-byte values. The new variables introduced are: OPR$ Hex or decimal operand in string OPER Numeric variable of operand 32 Once everything is all checked out and conversions are made after the operand is entered, the code is immediately compiled in the next routine. AO0\ RFM ************ 430 REM COMPILE CODE 440 REM ************ 450 IF B% = 2 THEN POKE SA,D% : SA = SA + 1 460 IF B% = 2 THEN POKE SA.OPER : SA = SA + 1 : OPER = 0: GOTO 230 470 POKE SA,D%: SA = SA + 1 480 POKE SA,LB : SA = SA + 1 : POKE SA.HB : SA = SA + 1 : OPER = : GOTO 230 The compile block shows you just what's going on with an assembler. It merely POKEs in machine code values for the mnemonic opcodes and operands and keeps the addresses straight. Lines 450-460 check for two byte opcodes, and then pops in their values at the next two addresses, resets the opcode value, increments the address, and then goes back to get the next opcode. Lines 470and 480 do the same thing for 3 byte opcodes using the LB flow byte) and HB (high byte) variable supplied in a subroutine further on in the program. (Line 410 in the previous block branched to the subroutine for the LB and HB variables.) The new variables, LB and HB will be discussed further on in the block where they are defined. At this point, go have a good stiff shot of root beer. (I did.) We've actually gone through the entire assembly process! From this point on, we will see the subroutines, DATA statements and ending block. They're crucial to the program, but the heart of the program is already keyed in. Now we're ready to start on the subroutines. The first one is a very good little one to make HEX-DECIMAL conversions in any program. (HINT# $FF : If you want to write your own monitor, this subroutine would be handy.) 33 490 REM ********************** 500 REM CONVERT HEX TO DECIMAL 510 REM ********************** 520H$=MID$(OPER$,2) 530 FOR L= 1 TO LEN(H$) : HD = ASC(MID$(H$,L,1)) 540OPER = OPER*16+HD-48 + ((HD>57)*7) 550 NEXT L: RETURN The heart of this subroutine is in Line 540. The loop between 530-550 converts the hexadecimal value in H$ to a decimal number that can be POKEd into memory in the compile subroutine. Line 520 simply strips the T off OPER$ and stores the substrong in H$. Next, we come to the double error trap for values over 255 ($FF) entered with 2 byte opcodes and any operand value over 65535 ($FFFF). 560 REM ********** 570 REM ERROR TRAP 580 REM ********** 590 PRINT CHR$(18);"ERROR-MUST BE LESS THAN 256" 600 FOR W = 1 TO 400 : NEXT W : PRINTCHR$(146); : PRINT CHR$(1 45) 610 FOR X= 1 TO 27 : PRINTCHR$(32); : NEXT 620 PRINT CHR$(157);CHR$(157);CHR$(145) : RETURN 630 PRINT CHR$(18);"VALUE OVER 65535 ($FFFF)";CHR$(146) : RETURN Error Trap 34 There's nothing fancy about this subroutine. It simply pops an er- ror message if you're over 255 (a little spiffy, I admit) and does the same thing in a 1 line subroutine in 630 if your operand exceeds 65535. Now the next subroutine is another one you could use in a monitor program. It takes any number over 255 and splits it into high and low bytes. P\A0) RFM ************************ 650 REM CONVERT TO 2 BYTE NUMBER fififfj RFM ************************ 670 LB = OPER-INT(OPER/256)*256 680 HB = OPER - INT(OPER/256) 690 RETURN The routines in 670 and 680 do all the work. They're simple but vital little formulas. See how these variables are compiled in Line 480. They created the following variables: LB Low byte - first address HB High byte - second address Now this next subroutine determines the operand value by com- paring two addresses. The value is the "branch offset" sending the program branching forward or backwards. 70)0) RFM ************* 710 REM BRANCH OFFSET 7?ff) RFM ************* 730 IF SA > OPER THEN OPER= 254-(SA-OPER) 740 IF SA < OPER THEN OPER= (OPER-SA)-2 750 RETURN Notice how the value has to be calculated differentiy depending on whether the address value (SA) is greater or lesser than the branch address (OPER). At this point, take a good look at your system. If you use a cassette to store your programs, skip this and go to the next block. If 35 you have a disk, this is the block you want. It gives you the options of saving your program, ending or going back to the beginning. The most valuable part of the routine is in Lines 890-970 . It contains the save-to-disk-as-a-program routine for your OBJECT CODE! Lines 980-1040 save the source code as a SEQ file. Disk Version Only 760 REM ************** 770 REM ENDING ROUTINE 7R0 REM ************** 790 NB = SA-BA 800 PRINT CHR$(147) 810 FOR X = 1 TO 5 : PRINT : NEXT 820 INPUT'SAVE PROGRAM(Y/N)";AN$ 830 IF AN$ = "Y" THEN 890 840 PRINT : PRINT : PRINT "PROGRAM IS";NB;"BYTES LONG" 850 PRINT "TO EXECUTE 'SYS'";BA : PRINT 860 INPUT "(B)EGIN AGAIN OR (E)ND";DE$ 870IFDE$ = "B"THEN120 880 PRINT : PRINT'END" : END 890 PRINT CHR$(147) : FOR X= 1 TO 5 : PRINT : NEXT 900 LB = BA-INT(BA/256)*256 : HB = INT(BA/256) 910 INPUT "ENTER FILE NAME";NW$:NF$ = NW$:NF$ = "0:" + NF$ + STR $(BA) + ",P,W" 920 OPEN2,8,2,NF$ 930 PRINT#2,CHR$(LB) + CHR$(HB) 940 FOR X = BA TO SA-1: OC = PEEK(X) 950 PRINT#2,CHR$(OC) 960 NEXT X 970 CLOSE2 980NF$ = "" 990NF$ = "0:" + NW$ + ",S,W" 36 1000 OPEN 9,8,9,NF$ 1010FORV = 0TON-1 1020 PRINT#9,AD(V),S$(V),C$(V) 1030 NEXT V 1040 CLOSE9 1050 GOTO 840 There's nothing fancy about the save, end or begin branches. However, our constant, BA is used to find the number of bytes in the program by subtracting it from SA, the last address entered + 1. The save-to-disk routine from 890-970 is one I got from Guy Grotke's book, The Intermediate Commodore 64. It stores the beginning address of your machine language program as part of the file in line 910. Therefore, when you LOAD "FILENAME" ,8,1 the program knows where to go. To help you remember that, I add- ed the starting address to the file name. Therefore, when you save a machine file, the name includes its load address and all you have to do once the program is loaded is to SYS that address. The new variables in this block are : NB Number of bytes in program X Counter variable AN$, DE$ Strings for INPUT branches NF$ Name of file to write to disk OC Decimal value of opcodes and operands If you just finished keying in the above block of the ENDING ROUTINE jump (JMP in mnemonic opcode) to the block, OP- CODE DATA. This following block is a repeat of the ENDING ROUTINE except it is for saving a sequential file of your program to tape instead of a PRG file to disk. Tape Version Only 7fiffl RFM ************** 770 REM ENDING ROUTINE 7Ml RFM ************** 790 NB = SA-BA 800 PRINT CHR$(147) 37 810 FOR X = 1 TO 5 : PRINT : NEXT 820 INPUT'SAVE PROGRAM(Y/N)";AN$ 830 IF AN$ = "Y" THEN 890 840 PRINT: PRINT: PRINT "PROGRAM IS";NB;"BYTES LONG" 850 PRINT "TO EXECUTE 'SYS"';BA : PRINT 860 INPUT "(B)EGIN AGAIN OR (E)ND";DE$ 870IFDE$ = "B"THEN120 880 PRINT : PRINT" END" : END 890 PRINT CHR$(147) : FOR X= 1 TO 5 : PRINT : NEXT 900 REM * * * TAPE SAVE * * * 910 INPUT "ENTER FILE NAME";NW$:NF$= NW$ 920OPEN21,1,1,NF$ 930 PRINT#21,BA 940 FOR X = BA TO SA-1 : OC = PEEK(X) 950 PRINT#21,OC 960 N EXT X 970 CLOSE21 980NF$ = "" 990NF$=NW$ + ".S" 1000 OPEN22,1,1,NF$ 1010FORV = 0TON-1 1020 PRINT#22,AD(V),S$(V),C$(V) 1030 NEXT V 1040 CLOSE22 1050 GOTO 840 The good news is that you can save machine language programs to tape, but the bad news is they are saved as SEQ files instead of PRG files. That means we will have to have a special "Loader" pro- gram for you tape users. We'll look at that later. For now, let's see what the above block does. First of all, there are decision branches in lines 820-880 . These just prompt you with questions about saving your program and whether you want to end or start over. Line 790 finds the number of bytes (NB) in your program to be used both in telling you how much memory you used and as a variable to be stored on your tape file. Line 920 begins the storage sequence of your program. Basically, this section OPENs a tape file, first stores the number of bytes in your program (Line 930), and then it PEEKs 38 at your machine language program in memory and stores the values on your tape. The loop in Lines 940-960 does this. The following variables were introduced in this block: NB Number of bytes in program X Counter variable AN$, DE$ Strings for INPUT branches NF$ Name of file to write to tape OC Decimal value of opcodes and operands Now this next section will have to be done very carefully. It has all of the information your assembler will use. Each DATA statement uses a separate line containing the following information: Decimal value of opcode Mnemonic for opcode Number of bytes used by opcode and mode The reason I put every set of DATA statements in a separate line was to help you debug typing errors and to see the relationship bet- ween machine opcode (the first number), mnemonic opcode (the string), and the number of bytes used by an operation (the second number). Also, you will get a preview of the special conventions this assembler uses in mnemonic opcodes. In most discussions of machine and assembly language programming, the machine opcode is given in hexadecimal values, but since your assembler is written in BASIC, it needs the decimal values to 'compile' the code into memory. OK, now take a deep breath and go ahead and key in this code. 2000 REM *********** 2010 REM OPCODE DATA 2020 REM *********** 2030 DATA 24,CLC,1 2040 DATA 32,JSR,3 2050 DATA 56,SEC,1 2060 DATA 73,EOR#,2 2070DATA76,JMP,3 2080 DATA 77,EOR,3 2090 DATA 96,RTS,1 39 2100 DATA 2110 DATA 2120 DATA 2130 DATA 2140 DATA 2150 DATA 2160 DATA 2170 DATA 2180 DATA 2190 DATA 2200 DATA 2210 DATA 2220 DATA 2230 DATA 2240 DATA 2250 DATA 2260 DATA 2270 DATA 2280 DATA 2290 DATA 2300 DATA 2310 DATA 2320 DATA 2330 DATA 2340 DATA 2350 DATA 2360 DATA 2370 DATA 2380 DATA 2390 DATA 2400 DATA 2410 DATA 2420 DATA 2430 DATA 2440 DATA 2450 DATA 2460 DATA 2470 DATA 2480 DATA 2490 DATA 105,ADC#,2 108,(JMP),3 109,ADC,3 121,ADC-Y,3 125,ADC-X,3 129,(STA-X),2 133,STA-Z,2 134,STX-Z,2 136,DEY,1 138,TXA,1 140,STY,3 141,STA,3 142,STX,3 145,(STA-Y),2 148,STY-X,2 152,TYA,1 157,STA-X,3 153,STA-Y,3 154.TXS.1 160,LDY#,2 161,(LDA-X),2 162,LDX#,2 164,LDY-Z,2 165,LDA-Z,2 166,LDX-Z,2 168,TAY,1 169,LDA#,2 170.TAX.1 172.LDY.3 173,LDA,3 174,LDX,3 177,(LDA-Y),2 185.LDA-Y.3 186,TSX,1 188,LDA-Y,3 189,LDA-X,3 190,LDX-Y,3 192,CPY#,2 193,(CMP-X),2 196,CPY-Z,2 There's a lot of DATA in here! 40 2500 DATA 197,CMP-Z,2 2510 DATA 198,DEC-Z,2 2520 DATA 200.INY.1 2530 DATA 201, CMP#,2 2540 DATA 202,DEX,1 2550 DATA 204,CPY,3 2560 DATA 205,CMP,3 2570 DATA 26,DEC,3 2580 DATA 208,BNE,2 2590 DATA 221 ,CMP-X,3 2600 DATA 222,DEC-X,3 2610 DATA 224,CPX#,2 2620 DATA 230,INC-Z,2 2630 DATA 232,INX,1 2640 DATA 233,SBC#,2 2650 DATA 234,NOP,1 2660 DATA 236.CPX.3 2670 DATA 237,SBC,3 2680 DATA 238,INC,3 2690 DATA 240,BEQ,2 2700 DATA 249,SBC-Y,3 2710 DATA 253,SBC-X,3 2720 DATA 254,INC-X,3 27*30) REM ************************ 2740 REM ADD ADDITIONAL DATA HERE 77^0) RFM ************************ 2760 DATA 255 It is important to have line 2760 be the LAST DATA statement entered. When your program READs 255 as a value, it knows that it is at the end of the DATA. Therefore, if you get ambitious and add additional opcode, move Line 2760 to the end of your new DATA statements. In the full program in Appendix A, you will find all of the DATA values for additional opcode. (Be careful in adding BCC, BCS, BMI, BVC and BVS. When used, their operands will have to be sent to the branch offset subroutine in beginning in line 700 . All you have to do is to add lines like 390 to initiate the branch. Use line numbers 391-399 for branch initiators with these branch opcodes 41 not included in this simplified version of the Kids' Assembler. The full assembler in Appendix A takes care of all of this for you, of course.) Finally, we get to the commercial in this last block. The header was included so that if you give a copy of the program to your friend, he or she will know where to find the documentation on how to use the assembler. If you ever had a program without the documentation, you know how frustrating it is to use the program. This is especially true with complex utilities like assemblers. Therefore, this last block is important. (Also, it's a get-rich-quick scheme to sell more books!) 4000 REM ****** 4010 REM HEADER 4020 REM ****** 4030 PRINT CHR$(1 47) 4040 CR$ = "(C) COPYRIGHT 1984" : NM$ = "BY WILLIAM B. SANDERS" 4050 BK$ = "ASSEMBLY LANGUAGE FOR KIDS" :CM$ = "COMMODORE 64" 4060 IS$ = "SEE" : F$ = "FOR DOCUMENTATION" 4070 H = 20-LEN(CR$)/2 : PRINT TAB(H);CR$ 4080 H = 20-LEN(NM$)/2 : PRINT TAB(H);NM$ 4090 PRINT: H = 20-LEN(IS$)/2 : PRINT TAB(H);IS$ : PRINT 4100 H = 20-LEN(BK$)/2 : PRINT TAB(H);BK$ :H = 20-LEN(CM$)/2: PRINT TAB(H);CM$ 4110 H = 20-LEN(NM$)/2 : PRINT TAB(H);NM$ : PRINT 4120 H = 20-LEN(F$)/2 : PRINT TAB(H);F$ 4130 LD$ = "LOADING ARRAY" : FOR X= 1 TO 10 : PRINT : NEXT : H = 20-LEN(LD$)/2 4140 PRINTTAB(H);CHR$(18);LD$ 4150 RETURN Phewwww! That sucker was long. Well, how many kids do you know who wrote their own assemblers? If you did all that work, you won't understand everything about assemblers and assembly language, but you'll be ahead of those who haven't. Congratula- tions! (Only real programmers write their own assemblers! ! !) Save 42 the program under the name "KIDS ASSEMBLER 1." We'll call the big one in Appendix A, "KIDS ASSEMBLER 2." CREATING AND SAVING PROGRAMS ON THE KIDS' ASSEMBLER Once you get all the typing errors out of your assembler, you're all set to crank it up. REMEMBER to make a back-up copy or two on separate disks or tapes. If you've done that, then LOAD "KIDS ASSEMBLER 1" and then enter RUN. The first thing you will see when you RUN the program is the following header: (C) COPYRIGHT 1984 BY WILLIAM B. SANDERS SEE ASSEMBLY LANGUAGE FOR KIDS: COMMODORE 64 BY WILLIAM B. SANDERS FOR DOCUMENTATION {LOADING ARRAY} The message stays there until the array is loaded and lets you know something is happening. After a few seconds your editor will pop up. It looks like the following: ADRS OPCODE OPERAND PRESS {RETURN} TO DEFAULT TO 49152 STARTING ADDR? At this point you are expected to enter a starting address for your program. If you just press the RETURN key, your program will automatically begin compiling at 49152 ($C000). Generally, this 43 area of RAM is free for machine language programs and I like to use it. If you do not use a cassette tape, the cassette buffer at 828 ($33Q is also a good place to use. Later on we'll discuss the various place where you can put your code. For now, just press the RETURN key. As soon as you do, your screen looks like this: ADRS OPCODE OPERAND PRESS {RETURN} TO DEFAULT TO 49152 STARTING ADDR? 49152 ? The prompt under the OPCODE field is waiting for you to enter an opcode. (What else?) Enter JSR and press RETURN. Now your screen looks like this: ADRS OPCODE OPERAND PRESS {RETURN} TO DEFAULT TO 49152 STARTING ADDR? 49152 ?JSR ? The prompt has jumped to the OPERAND field awaiting an operand. Now, you can either enter the operand as a decimal or hexadecimal number. If you choose to enter a decimal number, just key in the number. For hexadecimal numbers, though, first put in a dollar sign ($) and then the number. To get started, enter the value 58692 or $E544 and press RETURN. Both numbers are the same and have the same effect. The hexadecimal to decimal subroutine automatically changes $E544 to the decimal value 58692. It's a good habit to start thinking in terms of hexadecimal. After you've done that, you screen will appears as: ADRS OPCODE OPERAND PRESS {RETURN} TO DEFAULT TO 49152 STARTING ADDR? 49152 ? JSR ? $E544 49155 ? 44 You've successfully entered a line of assembly code, and your assembler is waiting for the next line. That's all there is to it! Some opcodes have no operands, but for the most part, you just enter the opcode and the operand. The last line of your code should be RTS to return control of your computer to BASIC once the program is executed with a SYS command. It's not a very powerful assembler, but it's easy to use and will catch many common errors that begin- ners make. You may be wondering about the address field on the left side of your screen. The first number was 49152 and the second is 49155. Shouldn't it be 49153? What the assembler is doing is showing you how much memory each opcode and operand is using. In the first line you used three addresses or bytes. One byte was used for the op- code and two bytes were used for the operand. Thus, addresses 49152, 49153 and 49154 have been used, and the next available ad- dress is 49155. This will help you see where your code is actually go- ing. OK, let's end the program with RTS and RETURN. Now your screen shows the following: ADRS OPCODE OPERAND PRESS {RETURN} TO DEFAULT TO 49152 STARTING ADDR? 49152 ? JSR ? $E544 49155 ? RTS 49156 ? Since the RTS opcode used only a single byte and requires no operand, you are now at address 49156. To end your work in the editor enter 'Q' for 'quit' and press RETURN. You screen will clear and you will be prompted with the following message: SAVE PROGRAM(Y/N)? Enter ' Y' and press RETURN and you will see the next message: ENTER FILE NAME? 45 Enter the file name CS (for Clear Screen, since that's what the program does) and press RETURN. Now you will see: ENTER FILE NAME? CS PROGRAM IS 4 BYTES LONG TO EXECUTE «SYS' 49152 (B)EGIN AGAIN OR (E)ND? If you press 'B' you will be immediately returned to the editor. Since we've already seen the editor, press 'E' and RETURN to end our little session with the Kids' Assembler. Your screen will look like this now: ENTER FILE NAME? CS PROGRAM IS 4 BYTES LONG TO EXECUTE 'SYS' 49152 (B)EGIN AGAIN OR (E)ND? {Press 'E'} END READY. You're back in BASIC control of your computer. If you enter, SYS 49152 and press RETURN your machine language program will execute. Go ahead and do it to see what happens. Now here's the really neat part about machine language. You have two programs in memory at the same time. The assembler is still in memory along with your little machine language program. Just enter RUN {RETURN} to execute your assembler. Since your BASIC program begins way down at 2048 ($800) and your machine program is way up at 49152 ($C000), they won't conflict. (Go tell your mother about that.) 46 SPECIAL CONVENTIONS IN OPCODES Perhaps the biggest single problem with the Kids' Assembler is its use of some non-standard opcodes notations. On the one hand, these conventions were used to help you understand exactly what a mnemonic opcode is in relationship to a machine language opcode. On the other hand, it is a heck of a lot easier to write a relatively short assembler in BASIC using the conventions I did! (Now you know the awful truth.) As we will see in Chapter 8, the 6510 has several different ad- dressing modes. On most assemblers, the modes are determined in the operand field. For example the following shows the instructions for loading the accumulator with a 5 in the immediate mode and ab- solute mode on most assemblers: OPCODE OPERAND LDA #5 -^-Immediate mode LDA 5 ^-Absolute mode The assembler can tell the first LDA instruction is in the immediate mode since there is a pound sign (#) before the 5 in the operand field. The second LDA instruction, however, is in the absolute mode. The first LDA tells the computer to load the value 5 into the accumulator. The second LDA, in the absolute mode, tells the com- puter to load the value from address 5 into the accumulator. What actually happens when the code is turned into machine language is that the machine opcode for the first LDA is stored as $A9 (169 decimal) and the second LDA is stored as SAD (173) decimal. Since the mnemonic opcode can be translated directly into a machine op- code, by having the addressing mode as part of the mnemonic op- code, you can better see the translation going on. Therefore, in the Kids' Assembler, you put the addressing mode as part of your op- code. Opcodes for the absolute, relative, and implied mode are ex- actiy the same as on standard assemblers, but for other modes the following conventions are used. (Don't worry about all the details of addressing modes now. Later on in the book, we'll tackle each one separately. Just take a look at the different conventions used.) 47 KIDS' ASSEMBLER OPCODE OPERAND LDA# 5 ■<- Immediate mode LDA 5 «*- Absolute mode As you can see, the absolute mode on the Kids' Assembler is the same as the standard ones. However, the pound sign (#) has been moved from the OPERAND field to the OPCODE field in the im- mediate mode. The following is a full list of conventions you can refer back to later when we cover the various addressing modes. LDA Absolute mode (standard) LDA# Immediate mode TXA Implied (standard) BNE Relative mode (standard) LDA-Z Zero page mode (J MP) Indirect LDA-X Indexed (LDA-X) Indexed indirect (LDA-Y) Indirect indexed Basically, the differences lay in where you put the special sym- bols. I tried to make them consistent with the standard ones, and simply place them with the opcode instead of the operand. LOADING AND EXECUTING PROGRAMS One of the best things about this assembler is the ease with which you can load and execute machine language programs. From disk all you do is to enter: LOAD "PROGRAM NAME 49152",8,1 You then SYS the numeric value attached to the file name your pro- gram will execute. The program is automatically loaded to the start address from which you saved the program. Also it will not disturb a BASIC program in memory. (Well almost, anyway.) 48 Getting your programs loaded from tape takes a special loader program. That's because it's stored as a SEQ file and you have to first read the file and then POKE the whole thing into memory. (The best way to solve this problem is to buy a disk drive.) It's no problem though with the following cassette machine language loader program. 10 PRINT CHR$(147) 20 INPUT "NAME OF FILE TO LOAD "; NF$ 30 INPUT "ADDRESS TO LOAD"; SA 40OPEN1,1,0,NF$ 50 INPUT#1,NB 60 FOR X = SA TO SA + (NB-1) 70 INPUT#1,CD 80 POKE SA.CD 90 NEXT X 100 CLOSE1 Then just SYS the beginning address you entered when prompted ADDRESS TO LOAD? READING SOURCE FILES Since a SEQ source file is saved with the object file in this version of the Kids' Assembler, you will need a program to read your source code. The first of the following two is for disk and the se- cond is for tape: SOURCE CODE READER DISK 10 PRINT CHR$(147) 20 INPUT "FILENAME ";NF$ 30NF$ = "0:"+ NF$ +",S,R" 40 OPEN9,8,9,NF$ 50 INPUT#9,A$ 60 PRINT A$ 70IFST = 0THEN50 80 CLOSE9 49 SOURCES CODE READER TAPE 10 PRINT CHR$(147):X = 20 INPUT "NAME OF SOURCE FILE ";NF$ : NF$=NF$ + ".S" 30OPEN22,1,0,NF$ 40 INPUT#22,A$,B$,C$ 50 PRINT A$,B$,C$ 60 A$ = "":B$ = "":C$ = "" 70IFST = 0THEN40 80 CLOSE22 The above programs will print your sources to the screen so that you can see how you programmed your object code. It cannot, un- fortunately, be loaded into your editor and reused. SOME EXAMPLES Before going on the Chapter 3, crank up your assembler for some test runs. This will give you further checks on typos in your pro- gram and show you that assembly language isn't impossible. ERROR TESTS ADRS OPCODE OPERAND 49152 ? XYX {ERROR} 49152 ? LDA# ? 500 <• Enter on second try {ERROR - MUST BE LESS THAN 256} 49154 ? LDA ? $FFFFA {VALUE OVER 65535 ($FFFF)} ? 828 49157 ? Q The above program just tested the error traps built into your assembler. There's nothing worth saving; so just go back to the beginning. 50 BACKGROUND, BORDER AND CHARACTER COLORS ADRS OPCODE OPERAND 49152 ?JSR ? $E544 49155 ?LDA# ?0 49157 ?STA ? $D021 49160 ?LDA# ?4 49162 ?STA ? $D020 49165 ?LDA# ?5 49167 ?JSR ? $E716 49170 ?RTS 49171 ?Q When you SYS 49152 after you've exited the assembler, your background will turn black, your border purple and your characters white. If it worked, go on to Chapter 5. If it didn't, try it again and make sure everything looks as it does above. If it still doesn't work, check your BASIC assembler program, especially the DATA in the opcode block. 51 52 CHAPTER 3 THE MERLIN 64 ASSEMBLER Using the Editor/ Assembler This is the best assembler I've seen for the Commodore 64. It only works with a disk system; so if you have cassette storage, you'll have to wait until you have a disk drive to use this one. First of all, make a back-up copy of the Merlin Assembler and put the original in a safe place. Using the back-up master, enter the following: LOAD "MERLIN",8 When it's loaded, enter RUN, press RETURN, and patiently wait while the program is cranked up. (It takes a while.) Remove your back-up master and put in your work disk. This should be a format- ted disk that you can afford to destroy. It is possible to accidentally write a machine code program that will cream your disk. (I do it all the time.) In fact, it's a good idea to have two work disks; one to keep in the drive while you're experimenting, and one on which to save your source and object code. 53 The program starts in the "Executive Mode." You will see the following on your screen: {MERLIN} By Glen Bredon C :Catalog L :Load source S :Save source A : Append file R :Read text file W :Write text file D : Drive change E :Enter ED/ASM O :Save object code G :Run program X :Disk command Q :Quit Drive: 8 Source: $0A00,$0A0 % From the Executive Mode, you can do a lot of house-keeping. The first thing to do is to initialize your work disk. Press X The prompt will then show: %Command: Just enter "i" and press RETURN. To see what's on the disk, press C for "Catalog." Your file direc- tory will appear on the screen. There's nothing more to do in the 54 Executive Mode for the time being; so hit RETURN and enter the Editor/ Assembler by pressing *E\ Your screen will look like this: Editor This is called the Command Mode. From here, you want to get into the Add/Insert Mode. This is where you begin writing your assembly language code. You can recognize it by the colon (:) prompt. To get to the point where you can start writing assembly programs, enter; :A {RETURN} As soon as you hit RETURN after entering the 'A' you're in the "Add Mode." It is in this mode where you will be doing most of your work. The number '1' will pop up, representing your first line number. Editor :A 1 As in most assemblers, Merlin has four fields: LABEL OPCODE OPERAND COMMENT Each time you hit the space bar, you go to the next field. For the most part, the OPCODE and OPERAND fields are the most im- portant. When we get to branches, the LABEL field becomes very important, and as we will see in later chapters, it is used extensively for defining special locations and addresses as well. In our examples in this chapter, we will show you how to use all four fields. To get started, though, just try the following little program using the OP- CODE and OPERAND fields: LN# LABEL OPCODE OPERAND COMMENT 1 JSR $E544 2 RTS 55 To enter the routine, enter the Add Mode, and as soon a the T appears do the following: Step 1: Press the space bar to jump to the OPCODE field and enter JSR. Step 2: Press the space bar again to jump to the OPERAND field and enter $E544. Now press the RETURN key to go to the next line. Step 3: When the '2' appears, press the space bar to jump to the OPCODE field and enter RTS. Step 4: Press RETURN twice. The first RETURN will take you to the next line number, and the second RETURN will take you out of the Add Mode and back in- to the Command Mode. Pressing RETURN twice without pressing any other key will always take you out of the Add Mode. The following shows how your screen should look now: Editor :A 1 JSR $E544 2 RTS 3^- At this point, all the information you need for your assembly language program is in the editor. In order to get in into a form you can execute as a program, you must assemble it. To do that, from the Command Mode, you enter, :ASM and press RETURN. You will be prompted, :ASM Update source (Y/N)? You do not want to update the source code; so you press 'N', and your code will be assembled. Your screen now looks as follows: 56 3^- :ASM Update source (Y/N)? Assembling 8000: 20 44E5 1 JSR $E54 4 8003: 2 RTS —End assembly, 4 bytes, Errors: Symbol table - alphabetic order Symbol table - numerical order If that's what your screen looks like, you've just successfully assembled your first program on Merlin. Next we will want to save the program to disk, get out of Merlin, and then see if the program runs. Before we do that, though, make a note of the first number in the assembled code. It is the hexadecimal value $8000, shown on your screen simply as 8000. This is the address where your object code (your assembled machine language program) will load. It's decimal value is 32768, and once your program is loaded, SYS 32768 will be used to execute it. Now press 'Q' for quit and you will be returned to the Executive Mode. The '%' prompt appears enter, %S Your screen will show: %Save: Be sure your work disk and not your master is in the drive and enter a file name ('clear' is a good name since that's what the program will do - clear your screen), and press RETURN. Your screen will show: %Save:clear Saving clears 57 After saving the file, your screen will clear and you will be back in the Executive Mode. Now, you have not saved anything that will execute. You have just saved the source code. (Merlin put the ' .s' on the end of your file name to distinguish it from the object code.) This file has all the information you entered in the editor, but it did not save the assembled code. To save what you assembled, called the "object code," enter 'O' after the 'W prompt. (Make sure that's an 'Oh' and not a 'Zero' .) When you do that your screen will look like this: %Object:clear Since you just saved the source code for a program named 'clear', Merlin assumed that the next file you want is an object code called 'clear' . You do and so just press RETURN without entering any file name. %Object:clear Saving clear.o Now you have saved both your source code and object code. When you look at your disk's directory with the 'C command, you will see a file named 'clear.s' and one named 'clear.o'. (Later when you're not using Merlin and have your keys set for upper case, the files will appear as 'CLEAR.S' and 'CLEAR.O'.) Now, before we leave Merlin, take a look at the right side of your screen. There you will see the addresses with your source and object codes. Source: $0A0,$0A10 Drive: 8 Object: $8000,$8004 In case you forgot to note the load address of your object code after you assembled it, it is supplied here for you. Let's get out of the Executive Mode and back to BASIC. Press 'Q' and when asked 'Do you really want to exit?', press 'Y' for "Yes." Your screen will clear and you will be notified that to re- enter Merlin use SYS 52000. 58 Once you're back in BASIC you can execute your program. When you entered ASM to assemble it in Merlin, it was placed in memory at location $8000 (32768). Therefore, if you SYS 32768 and press RETURN, your program will execute. Go ahead and try it. If you did everything right, your screen should clear. See how easy that was? EDITING YOUR SOURCE CODE WITH MERLIN 64 To get back into the editor/assembler, just enter, Use the editor to make changes SYS 52000 and press RETURN. You'll be returned to the Executive Mode in Merlin. Now, choose 'E' to enter the ED/ASSEM. As soon as you're in the Command Mode indicated by the colon (:) prompt, press 'L' and RETURN. Your source code should be there waiting for you. The 'L' (L)isted your program; so now you know one of the first editing commands. Whenever you want to see your source code in memory, just press *L' in the Command Mode. Now, let's take a look at the major editing commands. We'll start with a list of the most important ones, and then show you how to use them. EDITING COMMANDS L Lists source code A Enter editor at next available line number l# Insert code into line number # D# Delete line number # E# Edit line number # PORT# Selects printer as output port # 59 PRTR# Sends formatted listing to printer in port#. F Find a string in listing C Change string M Move lines of code R Move lines in one range to another section NEW Clears source code from memory L(ist). We've already seen how to list a source code with L. However, when your programs get longer, you may want to stop the listing to examine a certain section. Whenever you press the space bar during a listing, you can step through the listing one line at a time. To resume normal listing, press RETURN. A(dd). When we first started writing our program, we pressed 'A' from the command mode and got a 1. With your program in memory, press 'A' and you will be given the next available line number. Having used only 2 lines, if we now press 'A' we'll start at line 3. I(nsert)#. This command is used to (I)nsert lines between lines. With your 2 line program in memory, enter II {RETURN}. You will now be in line 1. Press the space bar and enter the following: ORG $C000 Press RETURN twice to get back to the Command Mode and press L to list your program. Now it looks like this 1 ORG $C000 2 JSR $E544 3 RTS The ORG instruction is a "pseudo-opcode." It is not assembled in- to object code, but instead it identifies the beginning address for your code. If you do not put an ORG in your program, it defaults to the beginning address $8000 . It should be the first line of code in your programs. As you learn programming in assembly language, you will be leaving out a lot of code, and it will be necessary to insert 60 code between line numbers. Therefore, you will be using the (I)nsert function a good deal. D(elete)#. This is really simple to use. You just enter D and the line or range of lines you want to get rid of and hit RETURN. Since we don't have any lines in our program to delete, let's stick some there to knock out. Do the following: -v^-iffc :A 4 0INK 5 BURP 6 CRASH Deleting unwanted code After you enter line 6, hit RETURN twice to get back to the Com- mand Mode. Lines 4, 5 and 6 are pretty worthless. List your pro- gram and you'll see them all there at the end of your listing. Now from the Command Mode, do the following: : D6 Press RETURN and press L to list your program. Line 6 has been (D)eleted. Now to delete a range of lines enter: :D4,5 Hit RETURN twice and list your program again. All of those dumb lines are gone. E(dit)#. To change a line, press E and the line number to edit from the command mode. Let's change our ORG from $C000 to $033C. Do the following: :E1 {RETURN} 1 ORG $C000 61 Press the space bar to jump to ORG and then using the right cursor key, move over the ORG and hit the space bar again. The cursor should be right on top of the dollar sign ($) of the $C000 . Move one space to the right with the cursor key and replace $C000 with $033C. Press RETURN and you're back in the Command Mode. While in the edit mode you can (I)sert and (D)elete characters with CTRL-I and CTRL-D. To try out these editing functions, let's edit Line 2. :E2 2 JSR $E544 Move the cursor over the 'S' in JSR and press CTRL-D. The 'S' will be deleted. Now to get the 'S' back between the 'J' and the 'R' put the cursor over the 'R' and press CTRL-I and enter 'S'. Experiment with inserting and deleting code since you'll be doing a lot of editing in assembly language programming. Here's a few more Edit Mode CTRL commands to use: CTRL-F Find a character CTRL-0 Like CTRL-I except it inserts control character CTRL-P This is really a neat command for putting a line of asterisks across your screen. Use it for your header blocks. If you hit the space bar and CTRL-P, you'll get asterisks (*) on either side of your line. STOP/RUN Gets out of the Edit mode without changing the line you've edited. CTRL-B Jumps to beginning of line CTRL-N Jumps to end of line CTRL-R Restores the line to its original state CTRL-A Erases the line from the cursor to the right PORT# PRTR#. If you have a printer hooked up to your Commodore-64, you can send output to it using either the PORT or PRTR commands. If you use PORT, specify it as PORT 2, PORT 4 or PORT 5. When you ASM your source code, you will be able to see all the in- formation about it printed on paper. This is useful for debugging 62 programs. To get it going, from the Command Mode, enter the following: :PORT4 Press RETURN and your output will be vectored to your printer. The PRTR command works almost the same as PORT but it for- mats the output to your printer to include page breaks. Since you really won't need this command until your programs are longer (over 60 lines or so), you'll either have to enter a big program or wait until you are more advanced. Here's an example format :PRTR 4 "MAY 8, 1990" 1 The string is your page header and the number at the end is your page number. The '4' refers to a channel to your printer port just like with the PORT command. F(ind). When you start having longer listing, this command is really handy. From the command mode, you enter something like, :F "JSR" press RETURN, and all lines with JSR in it will be listed to the screen. If you enter the range of lines before the string you're sear- ching for, just that range will be listed. :F 5,9"JSR" C(hange). This command is good for wholesale mistakes. For ex- ample let's say you have a program with JMP opcodes instead of JSR opcodes as you really wanted. With the change command, you can change all of the JMP's to JSR's from the Command Mode. Here's how to do it: :C "JMF'JSR" Take special note of how we used the quotation marks ("). There are three of them instead of four (two around each string.) When 63 you press RETURN, you will be asked whether you want Afll) or S(ome) of the strings changed. If you press 'A' for all, every single instance of the change will be made, while if you enter 'S' for some, you will be given a choice at each instance to make the change or not by entering 'Y* for "Yes you want the change" and RETURN if you do not want to change. You can change single lines or line ranges by putting a single line number or range (e.g. 4, 19) right after the C. Try it out with our little program in memory. :C "JSR"JMP" Press RETURN, and list the program. The JSR in line 1 is now JMP. To turn it back to JSR, from the Command Mode enter, :C "JMP'JSR" and press RETURN. COPY. Sometimes you will write some code and want it repeated elsewhere in your program. Instead of having to key it in again, you can use the COPY function to do it automatically. Try the follow- ing with our two-liner in memory (If you have a 3-line program in memory, get rid of the first line with Dl {RETURN} using the D(elete) function.) :COPY 1 TO 2 Press RETURN and list your source code. It will now look like this: 1 JSR $E544 2 JSR $E544 3RTS The COPY function placed Line 1 where Line 2 was and moved Line 2 to Line 3. You can also move code upwards. Let's put Line 3 in Line 1. :COPY 3 TO 1 64 Now your listing looks like this: 1 RTS 2 JSR $E544 3 JSR $E544 4 RTS You can also move a range of lines by specifying the range and the line where you want to insert the range. For example, :COPY 10,20 TO 33 will duplicate the range of lines from 10-20 where Line 33 is. You probably won't be using this function a lot at first, but it sure saves a lot of time when you do need it. MOVE. This function is just like COPY but it deletes the original line or range after it MOVEs it. This is handy when you find you have a line in the wrong order. To see how it works, using the D(elete) function, get rid of those lines in our program we added with the COPY function. (Dl {RETURN} and D2 {RETURN}). Now enter the following and press RETURN: MOVE 2 TO 1 When you list your program it now looks like this: 1 RTS 2 JSR $E544 Let's see if you can get it back to the original order using MOVE. (I'm not telling you how.) R(eplace) The R(eplace) command is something like the D(elete) command except it puts you into the Insert Mode in the line you are replacing after first deleting the line. For example, enter the follow- ing and hit RETURN: :R2 65 You will find yourself in Line 2. Hit the space bar and enter ABC as an opcode. (There's no such opcode is used simply for illustration.) When you list your program, it will look like this: 1 JSR $E544 2 ABC Now using the R(eplace) function, see if you can change the ABC back to RTS. Finally, there are some miscellaneous other editing functions of Merlin you should understand. If you have a program in memory and you want to get rid of it, just enter NEW as in BASIC from the Command Mode. To toggle upper and lower case while in the Add/Insert mode, press the F7 function key. (You don't want lower case characters in the Command Mode.) Finally, to convert decimal numbers to hexadecimal numbers or hexadecimal numbers to decimal numbers from the Command Mode just enter the number you want converted and press RETURN. For example to convert hex to decimal, preface your number with a dollar sign ($). Let's say your program loads at $C000 and you want to know what the SYS value is. Do the following: :$C000 {RETURN} 49152 = -16384 You can SYS either number 49152 or 16384 to run your machine language program after it's loaded into memory. To convert from decimal to hexadecimal try the following: :1234 $04D2 You'll find this function very useful in converting back and forth between hexadecimal and decimal values. 66 LOADING AND RUNNING PROGRAMS There are at least three ways to load and execute machine language programs created with Merlin. The easiest way is to LOAD the program from BASIC and then SYS the beginning ad- dress of your program. You have to use a special LOAD format, however. LOAD "MACHINE PROG",8,1 Normally when you LOAD a BASIC program, you just enter, LOAD "BASIC PROG",8 With machine programs, however, you have to add the ',1' after the '8' . The * , 1 ' tells the program where to load in memory. The on- ly problem with this method is remembering what the starting ad- dress of your program is. One trick I use when saving object code is to append the starting address to the end of the file name. So instead of just saving "MAC CODE", I'll name it "MAC CODE $C000" or "MAC CODE 49152" so that when I load it from BASIC I'll know what value to SYS. Another way to execute object code is from Merlin. From the Ex- ecutive Mode just choose 'G' for "Go!" and enter the object code file name when prompted with Run:. DO NOT put the '.o' extender on the name. Merlin does that automatically for you. The problem with this method is that you'll be popped back into the Executive Mode after the program executes. Also, if the code conflicts with the memory used by Merlin, you may crash! Finally, you can load the source code, and then using ASM from the editor, assemble your code. Then just exit Merlin and SYS your program. This is a good method when you're still working on a pro- gram, since you can de-bug it by re-entering Merlin and working on the source code. 67 THE SOURCEROR If you've been accumulating machine code programs on assemblers that do not save the source code, such as the Kids' Assembler or you have the object code but not the source code from a file, the Sourceror is going to be very valuable. It creates source code from object files, including labels! To crank up the Sourceror enter, LOAD "SOURCEROR.O",8,1 press RETURN and when the program is loaded enter, SYS 49152 You will be prompted with the following: Do you want an object file loaded? (Y/N): Take out your Merlin Master disk and put your work disk in the drive. Now press "Y" and when prompted, enter the name of your object file. Be sure to enter the full name, including any \o' ex- tender. Press RETURN and your program will be loaded. You will be told that start address and prompts what to do next. Make a note of the starting address of your program. Then you will be given a page of instructions of what to do. Enter the hexadecimal value of the beginning of your program and press the T key. (That's the lower case *L' .) For example, if your program begins at $C000 , you would enter the following: C000I Press RETURN and your program will be disassembled. Find the end of your program, usually by locating an RTS instruction, and enter the hexadecimal address below the last instruction in your program and press 'q' for quit. For example, let's say your RTS is 68 at address $C0D0 and the next line, $C0D1, looks like garbage, you would key in, C0d1q and press RETURN. The program will process your data and ask you for a file name. DO NOT add the '.s' extender to your file name since Sourceror does that automatically. You have just saved the source code for your object code! Now you can load and run Merlin and look at the source code in your editor. Once you load your Sourceror created source file in Merlin, list it. You will notice that some of the hexadecimal numbers are prefaced by an "H". This simply means they are (H)exadecimal numbers. Using your editor, replace the H's with a dollar sign and you're all ready to assemble it into a clear source file. You can add labels and comments if you want as well. The following shows what a source file might look like and how to change it. 1 ORG $C000 2 3 JSR HE544 4 STA HD021 5 RTS In lines 3 and 4, change the HE544 and HD021 to $E544 and $D021. When you're finished, your code should look like the following: 1 ORG $C000 2 3 JSR $E544 4 STA $D021 5 RTS Also, you might have some garbage at the end of your file. Just use the (D)elete function from the command mode to get rid of it. ASM your code and save it as a new source file. 69 MERLIN'S MONITOR To test run your assembled programs, the monitor in Merlin is quite handy. To enter the monitor from the Command Mode, enter, :MON and press RETURN. You will be given a '$' prompt to indicate you're in the monitor. All values are expected to be given in hex- adecimal. (The prompt will remind you of that.) The best way to use your monitor as a test bench is to leave out the ORG directive in any program you're testing. In this way, the default ORG of $8000 will be used and the monitor, editor, assembler and your code can be co-resident in memory. Once you have ASseMbled your source code, enter the monitor, key in, $8000g and press RETURN. (Remember the dollar sign ($) is the prompt; so you don't have to include it.) Your program will now execute. Once your program is debugged you can use any ORG you want by inserting it in your source code and re-ASseMbling it. You can do a lot more with the Merlin monitor, but our main purpose is to use it as a test bench. Take a look at your Merlin manual for its other uses. To get back into your Editor, enter Y and press RETURN. If you enter 'q' {RETURN} you'll be return- ed to the Executive Mode. SOME EXAMPLES To get you rolling, let's look at a couple simple examples.The first one just clears your screen and changes the printing characters from blue to black. Actually, it works about the same as using CHR$ codes to put things on your screen. 70 1 ORG $C000 2 JSR $E544 ;Jumps to clear routine 3 LDA #144 4 JSR $E716 ;Jumps to screen output 5 LDA #65 6 JSR $E716 7 LDA #66 8 JSR $E716 9 RTS ;Returns from subroutine to BASIC :ASM When you are finished assembling the program, enter 'Q' to return to the Executive Mode and then save both the source file and object file. When you load and execute the program it will print black letters, AB in the upper left hand corner of your screen. This next program changes your background color to black, your border to purple and prints white letters. There's a trick involved. Notice that Line 2 is blank. To get blank lines with Merlin, you have to hit the space bar once when you come to a new line and then RETURN. (If you just hit RETURN without the space bar, you'll go into the Command Mode.) 1 2 3 START ORG $C000 JSR $E544 4 LDA #0 ;Color code for black 5 STA $D021 ;Store in background 6 LDA #4 reg. ;Color code for 7 STA $D020 purple ;Store in border reg. 8 LDA #5 ; ASCI I control code for white letters 9 10 END JSR RTS $E716 ;Output to screen :ASM 71 You're not expected to know how this works, but you soon will. The START and END labels really don't do anything in this exam- ple, but later we'll see how easy they can make life in assembly language programming. 72 CHAPTER 4 THE COMMODORE 64 MACRO ASSEMBLER DEVELOPMENT SYSTEM THE PARTS To understand the Commodore assembler package, the first thing to understand is that it is in several parts. When you load one part, you do not necessarily have access to another. That is, you have to separately load the various files that make up the package. The major elements of the package include the following: 1. EDITOR64 2. ASSEMBLERS 3. CROSSREF64 4. LOLOADER64 5. HILOADER64 6. MONITOR$8000 7. MONITOR$C000 The disk version also includes the DOS WEDGE64, a disk operating system. The most relevant items are EDITOR64, ASSEMBLER64 and the two loader programs. We'll discuss their use in detail with only secondary attention to the other files. Since editing code works a lot like editing a BASIC program, it's a good idea to load the DOS WEDGE64 and use it just as you would when 73 programming in BASIC. The easiest way to do that is to LOAD "BOOT ALL",8 and then RUN it. EDITOR64 You write your assembly language programs in the EDITOR64 mode, save the source code to disk and then assemble the code with ASSEMBLE64. Since these two operations require two different files, we will treat their operation as two distinct events. To start, enter the following: LOAD "EDITOR64",8,1 {RETURN} SYS 49152 After you do that, your screen should look like this: COMMODORE 64 EDITOR V07282 (C) 1982 BY COMMODORE BUSINESS MACHINES READY. It looks like nothing has happened, but you are all set to start writing assembly language code. You do this by entering line numbers just as in BASIC. The four fields are: 1. Label 2. Opcode 3. Operand 4. Comment They are arranged as follows: LABEL OPCODE OPERAND ;COMMENT The COMMENT field is indicated with a semi-colon before the comment. Each time you want to go to a different field, you simply0press the space bar. We will use line numbers beginning with 10 and incremented by 10. This will give us room to insert code if we need it. To get started enter the following: AUTO 1© {RETURN} 74 Nothing will appear to happen at this point. Now, just start writing code beginning with line 10. 10 JSR $E544 Put two spaces after the line number and one space after JSR. As soon as your press RETURN, your screen should look like this: 10 JSR $E544 20 The new line number, 20, automatically pops up. You are in the LABEL field; so press the space bar to get into the OPCODE field and enter the following: 10 JSR $E544 20RTS You have just written a complete (but small) assembly language program. The first line jumps to a built-in subroutine to clear the screen and the second line returns you to BASIC. However, the Commodore assembler requires a special pseudo-opcode at the end of all programs, .END. So press RETURN and enter the following: 10 JSR $E544 20RTS 30 .END Now when your code is assembled with ASSEMBLER64, it will know the end of the program. However, it also needs the beginning of the program. Since the beginning should be at the beginning, we will insert a line just as we can do in BASIC. So enter the following line: 5* =$0000 15 -«Just press RETURN when you get the 15} 75 Now LIST your program and it should read: 5 *=$C000 10 JSR $E544 20RTS 30 .END READY. The asterisk (*) is the symbol used to define the starting address of your program. (Many assemblers use ORG as a psudeo-opcode in- stead of the asterisk.) The dollar sign ($) in front of the address in- dicates it is a hexadecimal value. You could have entered, 5 * =49152 if you wanted a decimal value. Next, since this still doesn't look very much like an assembly language program, let's format it. Just enter, FORMAT and press RETURN. Your program now appears as this: 5 * = $0000 10 JSR $E544 20 RTS 30 .END READY. As you write your code, it is a good idea to FORMAT it every now and then so that you can better see the separate fields. We have not put anything in the LABEL field yet, but if we did, the spaces bet- ween the line numbers and OPCODES would have our labels. Similarly, if you add a comment, it too will be formatted to the cor- rect field. Since we inserted our starting address for the code, our line numbers are out of whack. We can reNUMBER them with the NUMBER command. Do the following: 76 NUMBER5,10,10 {RETURN} After NUMBER the first number is the old start line, the second number is the new start line and the last number is the step size. So, since our old first number was 5, and we wanted our new first number to be 10 and we wanted our line numbers incremented by steps of 10, we used the 5,10,10 combination. Just remember the format for NUMBER as: NUMBER(Old start), (New start),(lncrement) I'd like to renumber please. Now when you LIST your program it looks like this: 10*=$C000 20 JSR $E544 30RTS 40 .END READY. = =MAKING A HEADER = = While you're learning assembly language, it might be a good idea for you to make a header that describes the dif- ferent fields for you. You could put in Line 1 something like the following: 1 LABEL OPCODE OPERAND ;COMMENT When you FORMAT your code, these fields will line up over your code to show you if you have your labels, opcodes, operands and comments in the correct places. Before you save your program to disk, just delete Line 1 so it will not be assembled and mess up your object code. 77 Now your program is all set to assemble into object code. (Object code is the machine language code that will run.) To do this you have to first put your source code (the code you just wrote) onto disk. Rather than using the SAVE command, you use PUT or CPUT. So let's try it. PUT "TESTIS" You can optionally include parameters for starting line, ending line, device number (the default is 8, your disk drive) and the secondary address. If you use CPUT instead of PUT, your file will be more compact on your disk. (Think of it as CompactPUT.) At this point you can assemble your program. You are finished with everything you have to do in the EDITOR64. However, let's look at the other editing features before we go on. For the most part, you edit assembly source code just as you would a BASIC program. Thus, there are no special editing com- mands for normal source code editing. However, there are some very useful added editing functions in EDITOR64. Let's look at them. = =DOS WEDGE64 HELPS A LOT= = It's a very good idea to load your DOS WEDGE64 when you're working in the editor. With it, you can look at your directory without destroying your program in memory. Thus when PUTting a file to disk, you can first look at the disk directory with > $ to see what file names are taken up already. When you GET a file from disk, you can check to see if the file name you want is on the disk. 78 Look at your directory to make sure your source code is saved as a SEQ file and then enter NEW to clear memory. Now, using the GET statement, we'll see how to load source code from your disk. Enter, GETTEST1.S" {RETURN} Your program will be loaded to disk, and you can LIST it. When you do, you'll see the following: 1000 * = $C000 1010 JSR $E544 1020 RTS 1030 .END READY. As you can see, your lines now start at 1000 instead of 10. Your editor automatically does this for you. (Don't ask me why.) Anyway, when you're working on source code, you can save a part of it and then re-load it with GET and continue your work. ADDED EDITING FUNCTIONS ON EDITOR64 CHANGE. Sometimes you will want to make a lot of changes in your program. To do this quickly with a single string, the CHANGE command is very helpful. Let's say you accidentally us- ed LAD instead of LDA. The CHANGE command would go through your program and change all instances of LAD to LDA. Using your program in memory, we'll change JSR to JMP. Do the following: CHANGE/JSR/JMP/ {RETURN} 1010 JMP $E544 The changed line pops up showing you that your JSR is now JMP. With just one change, it's probably just as easy to edit as you would in BASIC. However, when you have several opcodes, labels or other strings to change, you will really appreciate this function. 79 DELETE. This command would be handy with BASIC pro- grams. If you want to get rid of a range of lines, you just enter, for example, DELETE 1010-1030 {RETURN} and lines 1010-1030 will be deleted. This is very helpful when you find a way to tighten up your code and you want to get rid of extra lines. All you have to do is enter the first line to the last line of code you want DELETEd. FIND. When your programs get really long and you want to find a string, the FIND command is a big help. (If you DELETEd your lines in the above example, you better GET "TEST1.S" back into memory.) Enter, for instance, FIND "RTS" {RETURN} 1020 RTS Notice that the FIND command requires quotation marks around the string you are trying to find, while the CHANGE command does not want the quotation marks. Finally, if you want your EDITOR64 out of action, just enter KILL {RETURN}. You can get it back with SYS 49152. That's about it for editing. Remember, you edit most of your code just as you would a BASIC program. The added editing commands simply make it a lot easier for you. ASSEMBLERS Now that you have your source code saved as TEST1.S, you are ready to assemble it with ASSEMBLE64. To get started do the following: LOAD «<ASSEMBLER64",8 {RETURN} RUN {RETURN} 80 Unlike the EDITOR64, you do hot have to SYS an address to get it up. You just RUN it. As soon as you RUN the program you will see, CBM RESIDENT ASSEMBLER V080282 (C) 1982 BY COMMODORE BUSINESS MACHINES OBJECT FILE (CR OR D:NAME) Now BE CAREFUL here! You are asked to enter the name for the OBJECT file. You saved the SOURCE file to disk under the name TEST1.S, and you DO NOT want the same name for your OB- JECT file. Enter the name TESTl.O and hit RETURN. By using the extenders *.S' for source files and '.O' for object files, you won't get into as much trouble. Next you will be asked, HARD COPY (CR/Y OR N)? If you have your printer hooked up, enter Y or just press RETURN. If you do not have a printer hooked up and on-line enter N and press RETURN. Next you will be asked, CROSS REFERENCE (CR/NO OR Y)? You won't need a cross reference until you get into more com- plicated programs; so enter N or just RETURN. Now you will be asked the SOURCE file name. SOURCE FILE NAME? You saved your source file as TEST1 .S so enter that name and press RETURN. Your screen will show the following: PASS1 TESTIS PAGE 0001 LINE# LOC CODE LINE PASS2 81 00001 0000 * = $C000 00002 COOO 4 00003 CO03 20 44E5 JSR $E54 60 RTS 00004 .END ERRORS = 00000 END OF ASSEMBLY READY. If that's what you got, you correctly entered and saved your source code, assembled your object code and saved the object code to disk in a SEQ file. Look at your directory to make sure. You should see both "TEST1.S" and "TESTl.O". If you did not get that, then enter SYS 49152 to get back into the editor, GET your source code, make corrections and try it again. LOADERS One thing I'm not crazy about with this assembler is the way object code is loaded and executed. Most object code can be loaded with LOAD "FILE- NAME"^,! and then SYS the load address. However, since the files are stored as SEQ files instead of PRG files, that's not possible. (It is nice for cassette users though.) You have to load either LOLOADER64 or HI- LOADER64. If you load your program in higher memory loca- tions, such as we did at $C000 (49152), use the LOLOADER64 since it will place itself in a posi- tion that will not conflict with the code up in $C000. (It loads at $800). If your code is in a HILOADER LO LOADER 82 lower address, such as the cassette buffer at 828, then use the HILOADER64. To crank them up you have to use two different formats: LOAD "LOLOADER64",8,1 {RETURN} RUN {RETURN} LOAD "HIGHLOADER64",8,1 SYS 51200 Let's do it and see if our program works. Load the LOADER64 and RUN it. Your screen will look like this: LOLOAD.C64 V072772 (C) 1982 BY COMMODORE BUSINESS MACHINES HEX OFFSET (CR IF NONE)? {RETURN} OBJECT FILE NAME? TEST1.0 {RETURN} C000 C003 END OF LOAD READY. The HEX OFFSET refers to the number you want to add to your load address. If you wanted to load your program at $C200 and it was already at $C000, your HEX OFFSET would be $200. Just press RETURN since we want it to load at $C000 (49152). Enter the filename, TEST1 .0, press RETURN and you will see the begin- ning address of your program and the end of it (C000-C003). Now we're all set to give it a go. Hold your breath and enter, SYS 49152 If your screen clears and all you can now see is the READY, pro- mpt, your program works. If it locks up your screen, blows out the windows and sets your hair on fire, try again. THE MONITORS Like your loaders, the Commodore assembly language package comes with two monitors. MONITOR$8000 loads in the low por- 83 tion of RAM and MONITOR$C000 in the high portion. Load the monitor in the low portion of memory and we will use the high RAM for some examples. First of all, you may be wondering what a monitor is. Basically, a monitor is a device that allows you to examine and change your code in memory, usually in hexadecimal values. Monitors also enable you to disassemble machine language programs in memory and see the status of the various registers in your microprocessor. (We'll discuss registers in Chapter 6.) Your Commodore monitors can also be used as assemblers, AND they can save machine code as PRG files. This means that you can load these files directly from BASIC without having to use the loader programs. (Why didn't they do this with ASSEMBLERS?!) Therefore, if you want to assemble your code so that it can be stored as a PRG file, you can use the mini-assembler in your monitor to write assembly programs. First, LOAD "MONITOR$8000",8,1 and SYS 32768. When you first get into your monitor, you will see the following: 8* PC SR AC XR YR SP •803E 32 00 83 84 F6 The period (.) is your monitor prompt, awaiting your command. The PC, SR, etc. at the top refer to: 1. PC = Program counter 2. SR = Status register 3. AC = Accumulator 4. XR = X register 5. YR = Y register 6. SP = Stack pointer The values of the various registers is the number immediately below the initials. For example, the accumulator has '00' in it. When you 84 get to Chapter 6, you can use your monitor to examine these registers. For now, let's see how to assemble code in the monitor. The com- mand to enter assembly code is 'A' . Do the following to get started: .A C000 JSR $E544 {RETURN} As soon as you press RETURN your code is assembled and your line now looks as follows: .A C000 20 44 55 JSR $E544 .AC003 The numbers to the left of your mnemonic opcode and operand are the machine language opcode and operand. The next available ad- dress is C003, and so you're all set to enter more assembly code. FIRST hit the space bar and then enter the next line. After each RETURN, you have to hit the space bar first before entering your opcode. .A C000 20 44 55 JSR $E544 .A C003 LDA #$00 {RETURN} .A C005 STA $D021 {RETURN} .A C008 RTS {RETURN} Each time you hit return, the line you had just entered will insert the machine language code. When you're finished with the above pro- gram will look like this: .A C000 20 44 55 JSR $E544 .A C003 A9 00 LDA #$00 .A C005 8D 21 D0 STA $D021 .A C008 60 RTS .AC009 Compared to using EDITOR64, this is a little messy, and it assembles your code each time you hit return. You can edit your code, but inserting code between addresses is complicated. For the 85 time being, let's just see how to save a PRG file using the above pro- gram. To save a machine code program as a PRG file, simply press RETURN after you are finished to get the period (.) prompt without the 'A' and address. The 'S' command is used to S(ave) PRG programs to disk or tape. Use the following to save the above example: .S"MONPRG.O",08,C000,C009 {DISK} .S"MONPRG.O",01,C000,C009 {TAPE} The parameters after the file name include: 1. Device number; 01 for tape and 08 for disk. 2. Starting address. 3. Ending address plus 1. Notice in our little program that we started at SC000 and ended at $C008. Since $C008 + 1 = $C009, $C009 was our value used to Save the program. Until you become comfortable with adding in hexadecimal, just use the last address on the screen before you left the 'A' mode. To test your program from the monitor, you use the 'G' for "Go" command. Since our program began at $C000, we would enter, .G C000 {RETURN} You should have seen your screen clear and turn black. The little program simply loaded the value for black (0) into the address for the background color ($D021). To get back to the monitor, just key in SYS 32768. To see if your program really was saved as a PRG file, turn off your computer and disk drive and re-start it. Load your program as follows: LOAD "MONPRG.O",8,1 86 When you get your READY, prompt, key in: SYS 49152 {RETURN} If your program is correctly saved, it should immediately clear your screen and turn it black. That's a lot easier than using the LOLOADER or HILOADER programs to get your machine pro- gram in memory. = = CONVERTING YOUR EDITOR64 FILES = = If you want to convert your SEQ object code files created with EDITOR64 and ASSEMBLER64 into PRG files, you can do so (painstakingly) with the monitor. First, load your SEQ object program with LOLOADER or HILOADER depending on where your files loads. Then, load the corresponding monitor pro- gram. (MONITOR$8000 if LOLOADER and MONI- TOR$O000 if HILOADER.) Disassemble your object code using the D command and starting and ending ad- dress of your object file. For example, you would enter the following for our program: .D C000.C008 {RETURN} If you're not sure of the ending address, just disassemble your code a few addresses at a time until you find the end. Then using the S(ave) command from your monitor, save your program using '.OP' (for OBJECT PRG) as an ex- tender. Other Monitor Commands Beside the A, G and S commands, your monitors have several others as well. Here's a summary of them. L for L(oad). This re-loads PRG files created with monitor Save. Use the following format: 87 .L"FILENAME",DEVICE NUMBER The device number is usually 08 for disk and 01 for tape. .D for Disassemble). This disassembles code from a specified starting address to a specified ending address. For example, we could look at our illustration program with the following: .DC000C008 {RETURN} .M for M(emory dump). This is something like disassemble, but you are given the hexadecimal machine code in memory locations specified. For example, dump our example program to memory with the following: .M C000 C008 {RETURN} Compare it with what happened when you used the D com- mand. .R for R(egister Display). When you learn about registers in Chapter 6, you may want to see the status of the various registers. You just enter R and press RETURN. There are some other monitor commands we won't get into since they are used for larger programs than we will deal with in this book. Practice with the ones we've discussed to learn how machine code is stored in memory. SOME EXAMPLES O.K., crank up your EDITOR64 and let's see some examples. We'll use the comment and label fields. To get going enter AUTO 10 {RETURN}. 10 ;LABEL OP OR COI\ 20 *=$C000 ;LOAD ADRS 30 JSR $E544 40 LDA #0 50 STA $D021 60 LDA #5 70 STA $E716 80 RTS 90 .END 88 Our entire first line is a COMMENT. The semi-colon lets the assembler know that it is only source code that is not to be compil- ed. When you FORMAT your code, you can see if your assembly code lines up under the correct label. If it does not, edit the lines after LISTing them. Also while editing, turn off AUTO by just entering AUTO {RETURN}. The FORMATted listing should ap- pear as the following: 10 ;LABEL OP OR COMMENT 20 * = $C000 ;LOAD ADRS 30 JSR $E544 40 LDA#0 50 STA $D021 60 LDA#5 70 STA $E716 80 RTS 90 .END We did not use the LABEL field, but you can see the spaces where labels would be when FORMATted. By frequently FOR- MATting your code, you can check for the correct fields. Now PUT this on disk and assemble it, and then load and run it. It'll turn your screen black and your letters white. The next one turns your border purple and your background yellow. (It looks like your sister's first attempt applying make-up.) 10 ;LABEL OP OR COMMENT 20 * = $C000 ; LOAD ADRS 30 JSR $E544 40 LDA #4 ; PURPLE 50 STA $D020 ; BORDER ADRS 60 LDA #7 ;YELLOW 70 STA $D021 ;BACKGROUND ADRS 80 RTS 90 .END With more comments, you have a better idea of what's going on in the program. Later when we need labels, we'll see how they make loops very easy. Now, go on to the next chapter and take a look in- side your computer. 89 90 CHAPTER 5 STRANGE NEW NUMBERS DECIMAL, BINARY AND HEXADECIMAL NUMBERS If you've been following our examples, you probably noticed some funny numbers with dollar signs in front of them, like $E544 and $D021. Now with a perfectly good numbering system we all understand, why confuse matters with funny numbers called hex- adecimals? The reason lies in some even weirder numbers called "binary" and the workings of your microprocessor. To begin with, suppose instead of counting on our 10 fingers, we used just our two arms. After all, the 10 digits in our numbering system is based on our 10 fingers. Since we're used to our 10 fingers, our numbering system seems natural. However, our two arms are natural, and we could have just had to remember two digits instead of ten if we had counted with our arms instead of our fingers. Let's count from to 10 with our decimal numbering system and think about what's going on: 1 2 3 91 4 5 6 7 8 9 10 Everything is lined up fine until we get to 10 , and then we have to start all over again with our 10 digits (0-9) adding a zero onto our second digit. To keep things neat, let's add a zero before our first digit: 00 01 02 03 04 05 06 07 08 09 10 That's much better since our numbers are all lined up. Now all we did in this system is clear. With our 10 digits (0-9), we use all of them in our far right column, and when we run out, we simply tack on a 0(start over) and increment our second from right digit by 1. How would the same thing look with only two digits, and 1? 00 01 10 11 We ran out of digits pretty quick! Compare that with our decimal system: 92 ©0 00 01 01 10 02 11 03 In other words, using our arms instead of our fingers, we can only count to 3 before we run out of digits and have to add a third digit. Okay, so we can count by a two digit system instead of the ten digit system. But why? The reason lies in the way your computer really works. Basically it reads electrical currents as either being on or off. If a current is read as "ON" then it is read as "1." If it is read as "OFF" it is read as "0." Now if you think computers are pretty dumb, you're right. However, while they may be dumb, they're very fast. As a result, your Commodore 64 can interpret a bunch of 0's and l's into decimal numbers and strings and look like it's really smart. Your 6510 microprocessor is an 8 bit device. That means that it has 8 cells that read a current in each cell (bit) as being ON or OFF. Just about everything else in the computer is arranged to deal with those 8 bits in the microprocessor. Knowing this, we know that we can have a two digit numbering system 8 digits long. 7 6 5 4 3 2 10 10 10 10 1 - + - + - + - + The plus and minus signs underneath the values indicate whether the current is ON or OFF. The 8 values (7-0) above the digits repre- sent the way byte is arranged. Thus when we say that Bit 6 is ON, we know we're talking about the second bit from the left. Our two digit binary system can count from 00000000 to 11111111. In decimal, that's to 255 . However, since to 255 is an uneven system, computer programmers used a 16 digit system 93 numbered from $0 to $FF. To see why, let's break down our 8 bit number into two parts. Each part is called a "nibble". 7654 0101 3210 0101 Now, let's see how much we can pack into a two digit system with four places and put our decimal and hexadecimal numbers next to them. Binary numbers are often indicated with a percent sign; so let's include one here. Binary Decimal Hexadecimal %0000 0000 $0000 %0001 0001 $0001 %0010 0002 $0002 %0011 0003 $0003 %0100 0004 $0004 %0101 0005 $0005 %0110 0006 $0006 %0111 0007 $0007 %1000 0008 $0008 %1001 0009 $0009 %1010 0010^- $000A %1011 0011 $000 B %1100 0012 $000C %1101 0013 $000 D %1110 0014 $000 E %1111 0015 $000 F Now let's look again, but this time, we'll clear all the leading zeros from the hexadecimal values and leave out the decimal. Binary Hexadecimal %0000 $0 %0001 $1 %0010 $2 %0011 $3 %0100 $4 %0101 $5 94 %0110 $6 %0111 $7 A^^^BI %1000 $8 %1001 $9 %1010 $A $&§&*$ %1011 $B < %1100 $C ■OCTjOW ^^^^ %1101 $D ^Hib» "*^ %1110 $E %1111 $F Sweet $10 As you can better see, the hexadecimal numbering system can represent an entire nibble with a single digit. The decimal system has to start using 2 digits when the binary system counts to 10 10 . 1111 -^-Binary F -^-Hexadecimal Now since an 8 bit grouping, which is called a "byte", is compos- ed of two nibbles, we'll have to see what maximum number in hex- adecimal can be stored in a byte. 1111 1111 =11111111 $F $F =$FF 255 x 256 + 255 = 65535 Since there are over 64000 bytes in your Commodore 64, a number system that keeps track of what is in each byte with only two digits is more efficient than one that takes up to five digits, as would the case be with a decimal system. (By the way in case you didn't know, the "64" in Commodore 64 stands for 64 kilobytes. A kilobyte is 1024 bytes. Thus your Commodore has 64 x 1024 bytes of RAM.) At this point, no one expects you to understand everything about these weird numbering systems. Rather, all you should be able to grasp is the concept that its easier to use a maximum of two digits to represent what is in a byte than five. There are all sorts of conver- sion programs that will allow you to convert numbers into good old decimal numbers. Your assembler will do it automatically for you. 95 Later on when you've worked with hexadecimal and decimal numbers for a while, it will be a lot simpler. In the meantime, you can use decimal numbers in assembly programs if you want. To re-cap, here's what's going on in your computer and why hex- adecimal numbers are easier to use: 1. The processor interprets electrical currents as being ON or OFF 2. The ON/OFF configuration is stored in an 8 bit binary number or byte. 3. The 8 digit binary number is represented as a two digit hex- adecimal number. 4. When you look at a disassembly of machine programs, you see hexadecimal numbers representing values in bytes. GOING BETWEEN NUMBER SYSTEMS Using conversion charts Probably the best way to convert numbers when you're working with your computer is with number conversion charts. In this way, you can keep your computer free for programming and still make the conversion. In the Appendices, there are several charts which give addresses in both decimal and hexadecimal. In this way, you can quickly find an address, the token of a machine language op- code or other information in both decimal and hexadecimal. However, since the computer works with bytes, and each byte can only hold a value of $FF or 255 (actually 256 since you can enter values from 0-255), you have to make conversions on your own when the number is greater than 255. This will help you understand something about how the computer "thinks," and how you have to think in writing assembly language programming. Now since all the computer can stuff in a single byte is 255, how does your computer deal with numbers larger than 255? It has to use two bytes. One is called the high byte and the other is called the low byte. Let's look to see how 256 looks in a two byte, high byte- low byte configuration: 96 High Byte Low Byte 76543210 7654321© 00000001 00000000 ^-Binary $01 $00 -*-Hex 1 00 ^-Decimal By multiplying the decimal number in the high byte by 256, we can get the high byte value of our decimal number. Since the Low byte is zero in our example, we just add the high byte and low byte to get 256. The hexadecimal value doesn't have to be changed at all. We just tack on the two zeros in the low byte to the $1 in the high byte to get $100, the hexadecimal value of decimal 256. Now suppose in PEEKing at a couple of addresses we found a high byte-low byte value of the following: High Byte Low Byte 12 33 To determine what that is in hex is actually easier than determin- ing the decimal value of the combined number. Looking at a decimal-hex conversion chart, we find that the 12 is $0C and the 33 is $21 . The hex value is $0C21 . The decimal value is 256 x high byte + low byte. Thus, 12 x 256 + 33 = 3105, and now we know that $0C21 = 3105. We did that with only a conversion chart from 0-255 ($0-$FF). Now, how about going the other way? Let's say we have the hex number $ABCD. First, we divide it into high byte and low byte get- ting: High Byte Low Byte $AB $CD Our conversion chart shows us that $AB = 171 and $CD = 205. Now we have a decimal high byte of 171 and low byte of 205. We multiply 171 x 256 and then add 205 to get 43981. Your assembler takes care of these matters for you, but as you get further and fur- ther into machine and assembly language programming, you'll be looking up more and more numbers. 97 CONVERSION PROGRAMS Sometimes you will be planning out a program and want to look up values quickly. You won't be entering code on your computer, but instead planning a program on paper making a lot of conver- sions between hex and decimal. While the charts are handy, you want something a little simpler. (This is especially true if you want to POKE or PEEK values in BASIC.) The following program will do that for you. Pay special attention to the algorithms beginning in Lines 240 and 300. HEX/DEC DEC/HEX CONVERSION 10 PRINT CHR$(147) 20 INPUT "DEC OR HEX CONVERSION (D/H)Q = QUIT ";C$ 30IFC$ = "H"THEN200 40IFC$ = "Q"THENEND 50IFC$<> "D" THEN 2© 60HEX$ = "":N=0 70 INPUT "DECIMAL VALUE";N 8©HB=INT(N/256) 90LB=N-INT(N/256)*256 10©FORX=1TO2 110IFX=1 THEN N = HB 120IFX = 2THENN = LB 130 N% = INT(N/16) :GOSUB 310 140 N% = N-N%*16:GOSUB 310 150 IF X = 1 THEN H1$ = HEX$ : HEX$ = "" 160IFH1$ = "0"THENH1$ = "00" 170 NEXT 180HEX$=H1$ + HEX$ 190 HEX$ = "$" + HEX$ PRINT "HEX= "; HEX$: PRINT: GOTO 20 200H$ = "":DE = 210 INPUP'HEX VALUE ";H$ 220 GOSUB 250 230 PRINT "DECIMAL VALUE = ";DE 240 PRINT : GOTO 20 2^ff) RFM ********************** 98 260 REM CONVERT HEX TO DECIMAL 07C\ RFM ********************** 280 FOR L=1 TO LEN(H$) : HD = ASC(MID$(H$,L,1)) 290 DE = DE* 16 + HD-48 + ((HD > 57)*7) 300 NEXT L : RETURN *3i(n rfm ********************** 320 REM CONVERT DECIMAL TO HEX Wl\ RFM ********************** 340 HEX$ = HEX$ + CHR$(48 + N % + 7 * ABS(N % > 9)) 350 RETURN When you RUN the program, just choose 'H' to convert from hex- decimal and 'D' to convert from Decimal-hex. Binary-Hex-Decimal In converting between hex and decimal, we broke down the hex value into the high byte and low byte values. With binary conver- sions, we'll break 8 digit binary values into 4 bit nibbles. Each nib- ble converts into a single digit hex value. Then, by putting the hex values in each nibble together, we have a one byte hex value. Byte High Nibble Low Nibble 7654 0101 3210 1110 Going back in this chapter to our binary-hexadecimal comparison, we see that the high nibble's binary value of 0101 (or %0101 since High Nibble Low Nibble 99 binary values are indicated with a percent sign) is $5 and the low nibble value of %1 1 10 is $E. Thus, the final hex value is $5E. You can translate this into decimal by using the hex-decimal conversion. If you don't already know how to convert directly from binary to decimal, here's a simple way to do so. Take the byte as a unit and use the multiples above the specified bit. After finding the multiple value of each bit, add them all up to get your decimal value. 128 64 32 16 8 4 2 1 ^- Multiple 7 6 5 4 3 2 1 *«- Bit 1 10 10 1 •*- Binary number + 64 + + 4 + + 4 + + 1 =73 Decimal If you understand powers the bits can be understood as follows: 2 A 7 2 A 6 2 A 5 2 A 4 2 A 3 2 A 2 2 A 1 2 A ^- Power of two 7 6 5 4 3 2 1 ^-Bit Notice how the power of two corresponds with the bit number. That way you can remember the multiple simply by knowing the bit number. Thus instead of remembering that bit 5 is 32, you can remember it as 2 A 5 or "two to the fifth power." (On your Com- modore 64 the A is represented by the up-pointing arrow.) Knowing that, writing a little conversion program in BASIC should be a snap: 10PRINTCHR$(147) 20 INPUT "BINARY VALUE "; B$ 30 IF LEN(B$) <> 8 THEN 20 40 FOR X = TO 7 50 V$ = MID$(B$,X + 1, 1) 60 V = VAL(V$) : IF V < 1 THEN X=7: PRINT "BONG!":TD = 0:BV = 0:NEXT:GOTO 20 100 70 P = 7 - X 80IFV = 1 TH EN BV = 2tP: REM UPWARD ARROW KEY 90 TD = TD .+ BV 100BV = 110 NEXT X 120 PRINT "DECIMAL VALUE = "; TD 130 INPUT "ANOTHER(Y/N) ";AN$ 140 IF AN$ = "Y" THEN TD = : GOTO 20 (If you work with sprites, the above program will help you find their values quickly.) HOW NOT TO WORRY ABOUT NUMBERS Your assembler will accept just about any kind of numbers; so, if you know the correct number, you can enter it in either hex or decimal. As we go along we'll be discussing more and more hex- adecimal elements of programming in assembly language because it is easier than decimal. (If you don't think it's easier, just look at a batch of numbers with binary patterns. With fewer digits, the numbers get longer quicker!) At this point, though, do not be over- ly concerned. Why worry if you can enter your programs in either format. (Merlin and the Commodore assembler even accept binary numbers.) This chapter has just been a quick introduction to the number systems used in computers. As you need it, you can always come back and look up what you want. Don't try and attempt to be adept at converting numbers all at once. Using your charts and programs, you will gradually be able to see how to convert decimal into hex- adecimal and vice versa. In the meantime, just forge ahead and en- joy your computer. 101 102 CHAPTER 6 WHAT'S IN YOUR MICROPROCESSOR? The 65 10 contains seven registers, three of which we will be using a great deal and four others which you should begin to understand. We will be manipulating the A, X, and Y registers in our programs a lot, while the other registers will affect what we're doing to a more or less apparent degree. But to get started, let's begin with the no- tion of a register. WHAT'S A REGISTER? Essentially, a register is something that keeps track of something else. For example, stores keep track of the money they receive with a cash register. It records how much money went in and how much went out as change or refunds. Your major registers in your microcomputer are much simpler in that most of them can only count up to 255 ($FF) before they run out of room. In the last chapter, we saw that your computer operates in 8 bit chunks called "bytes." Most of the registers in your microcomputer also work in 8 bit bytes. 103 Since the registers can handle so little, you have to tell them everything you want them to do. Think of them as some not-too- bright friend who must be told everything. For example, let's say you ask your little brother, "Go get my baseball bat." That's all you need to say since you assume that he knows where the bat is. In BASIC you can do pretty much the same thing with statements such as GOTO, GOSUB and IF/THEN. BASIC and other high level languages are really smart compared to assembly language. With assembly language, you have to tell it everything you want. If your little brother was given instructions in assembly language, "Go get the bat," would become something like the following: 1. "Go into the house and up the stairs." 2. "At the top of the stairs, turn left and go into my room." 3. "In the room, go to the right wall where you will find a rack." 4. "On the rack is a baseball bat" 5. "Put the bat in your hand and take it out of the rack." 6. "Turn around and leave the room." 7. "Come down the stairs and out of the house." 8. "Come to me and hand me the bat." The reason you had to give this large set of instructions is because your little brother can only handle one byte at a time. (Once you give him the instructions, though, the little kid sure is fast!) The instructions in assembly language are similar to giving in- structions to someone who can only handle one small parcel at a time. The size and complexity of the instruction is dependent on the size of the register. Since most of the registers are eight bits, the in- structions must be relatively small. THE ACCUMULATOR The most important register is the accumulator or A register. Its contents are read by other registers, and it is used as a cross-roads in your machine. It performs addition and subtraction, logical opera- tions and is usually the register to send information to different memory locations. Several mnemonic opcodes refer to the Ac- 104 cumulator. For example, the instruction LDA LoaDs the Ac- cumulator (or A register) with some value, and STA STores what's in the Accumulator at some address. Many instructions check to see what's in the accumulator before taking action. Since it is an 8 bit register, the greatest number possible in the accumulator is 255 ($FF). THE X AND Y REGISTERS These two registers are also 8 bit ones. They can do most of the things the accumulator can do, but they're usually used as counters or "indexers." For example, the X or Y registers are often in- cremented something like FOR/NEXT loops. The contents of the register is used as an index or offset to an address. If the register value is "1" then "1" is added to a specified address. Thus, if you wanted to do something with a range of memory without having to keep entering the next memory location, incrementing the X or Y registers is a handy way of doing this. They can also be used for temporary storage, half-way houses and transfer points. In your mnemonic opcodes the letters X or Y are tip-offs that the instruc- tion does something with one of these registers. For example, INX increments the X register and TYA transfers the contents of the Y register to the accumulator. Both registers are 8 bit ones and can only hold a maximum value of 255 ($FF). THE PROCESSOR STATUS REGISTER (STATUS REGISTER) This register is really different from the A, X and Y registers. In fact, it is actually 7 little 1-bit registers packed into one 8 bit byte. (One bit is not used.) Called the T' or Status register, it is affected by what various opcodes do within a program. When we discuss branching and looping, we will see more clearly how it works. For now, let's take a look at its make-up. 7 6 5 4 3 2 10 ^-Bit N V * B D I Z C ^-Register 105 Before we see what the initials really stand for, here's a way to remember them in order: No Very Bright Dime Is Zero Cents Just remember "bright dimes" are worth ten cents, not zero cents. And what's half a dime? It's 5 cents. That'll help you remember bit #5 is not used. Before we look at the 1 bit registers, you should realize they all have only one of two condi- tions. You'll remember that a single bit can either be "0" or "1." If the register is "1", we say that it's Flag is Up or set. If the content of the bit is "0" then the Flag is Down or cleared. That's easy to remember since each individual 1-bit register can only be one or the other - set or cleared. (Remember when you clear out your drawer, it has "0" contents.) Negative Flag When the results of an operation is "negative" the flag is set. (That means there's a "1" in bit 7.) On positive results, the flag is cleared, meaning a "0" is in bit 7. Loading a register (A,X or Y) with a value of less than 128 will clear the N flag; loading a value of greater than 127 will set it. Thus, "negative" refers to values greater than 127 and "positive" to register values less than 128. (It has to do with "two's complement" math, which we will not cover in this book. In other words, don't worry about it.) 106 oVerflow Flag This is set in signed arithmetic operations and cleared with a special opcode. Don't worry about it for the time being, for at this stage it won't concern us. Break Flag If the last instruction was BRK this flag is set. This is another flag we will not be using much at first. Decimal Flag This flag is set and cleared for certain decimal operations with SED and CLD respectively. We will not be concerned with this flag as it is primarily used for determining the type of arithmetic the microprocessor is to use. Interrupt Flag This flag is set if there is a hardware interrupt. We won't be going into using this flag since it deals with hardware conditions in your machine. Zero Flag If the last result was a "0" then this flag is set. This flag will be used a lot by our branching instructions. The crazy thing about this flag is that if the last result in the accumulator was "0" then the flag is set which means there's a "1" in bit-1. So that this won't confuse you, just remember that when the last result was zero, the Z register gets all excited and waves a flag. Setting a flag 107 Carry Flag This flag is set when a carry/no-borrow condition arises. Other logical and math operations also will set this flag. You can use it for other things as well since there are opcodes for setting (SEC) and clearing (CLC) the C flag. By using other instructions that read the Carry flag, you can use it in various ways. At the beginning level of assembly language programming, many of the Status register conditions will not directly affect us. The big- gest problem encountered by beginners with the Status register is when some condition exists they accidentally created. Unexpected results may arise they do not understand. To avoid these unknown sources of problems, we will be very careful in not tackling some more advanced techniques affecting the Status register. However, as you start experimenting on your own (as you certainly should do!), you're going to have to go beyond the scope of this book for understanding all the possible circumstances leading to unwanted results. However, you should be aware that the Status register is one place to examine for the cause of unexpected results. STACK POINTER This register handles some important information that won't concern you directly at first but is critical to your program. The stack pointer holds the return address for subroutine jumps. In BASIC when your program executes a GOSUB, it needs something that will tell it where it jumped from. This is called the return ad- dress. With assembly language, you will be using JSR (Jump to SubRoutine) right away. The stack pointer tells the JSR where to return after it has made the jump. Thus, while all the programmer has to enter is JSR and everything will be handled automatically by the stack pointer, the stack pointer itself is crucial to program's operation. The stack itself is located in "Page 1" of your memory; locations $0100 - $01FF. (Page 2 is from $0200-$02FF, Page 3 from $0300-$03FF, etc.) The stack works like the spring loaded tray dispenser they have in cafeterias. As you remove each tray, a spring 108 underneath the trays pushes the next one up. If you put a tray on top of the stack, it will be the first one you take off. That means the Last In is the First Off. This is called a LIFO ar- rangement. IN 87 53 53 74 74 39 39 ♦ IH 87 Last In First Out Your stack starts putting values at address $01FF, the top of the stack. If you add another value, the stack pointer moves down to point to the next lowest address, $01FE. If you take one element off the stack, the stack pointer is moved up to point to $0 IFF. Since the stack stores two-byte addresses, such as $C004, usually we're deal- ing with two locations on the stack at a time. Thus, $0 IFF might be $C0 and $0 1FE, $04. By moving the stack pointer down to point to the most recently added value, the last value entered becomes the first released. (The "last hired" is "first fired.") As we said, you probably won't be doing much with the stack right away since the most important work of the stack is keeping return addresses. This is done automatically with JSR and other in- structions that require return addresses. However, assembly' language programmers often use the stack for temporary storage. The stack pointer, which tells the next available location on the stack, starts at $FF and works its way toward $00. In our above ex- ample, where the return address of $C004 is using stack locations $01FE and $01FF, the stack pointer points to $01FD as the next location on the stack. Stack $01 FF $C0 $01 FE $04 $01 FD Stack Pointer points here 109 Stack Pointer $FF $FE $FD <*- Low byte $01 <■ High byte is always $01 Because the stack pointer is an 8 bit register, the most it can hold is 255 or $FF. Since it needs a way to deal with values up to $0 IFF, it needs a high byte of $0 1 . To handle the high byte, $0 1 is always the high byte of the stack pointer. Thus, even with an empty stack with the pointer pointing to $01FF, the $FF is always combined with the high byte of $0 1 to arrive at $0 1 FF. In this way, the pointer can handle the entire stack with an 8 bit register. PROGRAM COUNTER The program register is a 16-bit register storing the next address to be executed in a program. As we will see in more detail in the next chapter in discussing your Commodore 64's memory, the program counter stores addresses in a Low-Byte, High-Byte configuration. The 16 bit register is actually two 8-bit registers arranged as follows: Program Counter Low Program Counter High 76543210 76543210 LO-BYTE HIGH-BYTE As each instruction is executed, the program counter is in- cremented to the next address where an instruction will be stored. In this way, your computer can execute instructions in the correct order. However, since this is done automatically, you don't have to worry about it. INPUT/OUTPUT PORT This port is located at locations $00 and $01 in your computer and is the principle difference between the 6510 and the 6502 microprocessors. It is used for directing input and output (I/O), 110 and other than suggesting that you stay out of those locations, we're not going to be dealing with this port at all. The $0 location is the data direction register, and $1 is the I/O port itself. SUMMARY It's easy to get tangled up in the registers if you try to do too much too soon. For the most part, your major operations will be with the accumulator, and the X and Y registers. Your program will be affected by the other registers, but as in BASIC where most of the computer's operation are taken care of for you, in assembly language programming, most of the registers take care of themselves. Thus, while its useful to know about the P register's flags, and we will be using instructions that rely on those flags, you don't have to actually "hand-set" the flags. Rather, you simply will be writing opcodes that take care of the flags for you. As you become more advanced, you will be making more direct use of the registers in your programs. To begin, though, you don't have to keep track of everything the registers are doing. So if you feel a bit lost right now, and you do not think you understand everything about the various registers that work with your microprocessor, don't worry. While assembly language pro- gramming requires that you give your computer more instructions, the bulk of what goes on is fairly automatic. Just remember to take things a step at a time when we get into writing actual assembly language programs. With practice and experimentation, what we have covered will become clearer. HI 112 CHAPTER 7 MEMORY AND STORAGE LINE NUMBERS AND ADDRESSES : A COMPARISON When you write a BASIC program, the line numbers you use are a point of reference. It doesn't matter whether you number your program 1,2,3,4,5,6, etc. or 10,20,30,40,50, etc. or even 1,10,32,1 13,2000. All you have to do is to make sure that the pro- gram statements are in order. In fact, the line numbers are simply a convenient way of ordering your statements so your program knows what comes next. Thus, the following BASIC programs all do the same thing despite the different line increments used: 10 PRINT CHR$(147) 20 FOR X = 1 TO 10 30PRINTX 40NEXTX 50 END 5 PRINT CHR$(147) 11 FORX = 1 TO 10 12 PRINT X 130 NEXT X 2000 END 113 1 PRINT CHR$(147) : FOR X = 1 TO 10 3 PRINT X : NEXT X 5 END Not only can we use any ordered (from lower to higher) line numbering system, we can put several statements in the same line. Your BASIC interpreter handles all the details for you. It assigns the BASIC tokens, knows what is a token and what is a value, and sticks the program in an area reserved for BASIC programs. With assembly language programming, the first decision you make is where to put your program. If you put it in the wrong place, it'll bomb. For example, if you want to execute your machine pro- gram from a BASIC program, you'd better not put your machine code in the area used by BASIC. Likewise there are other areas in your computer that will conflict with your program, or simply will not accept the code you enter. Once you decide where to put your program, you must use con- tiguous addresses. That means, if your last instruction used ad- dresses 49152, 49153 and 49154 ($C000-$C002), the next instruc- tion must begin at 49155 ($C003). You are not using numbers simp- ly as a way of ordering your commands as in BASIC, you are ac- tually stuffing information into addresses that will be executed se- quentially. FORTUNATELY, YOUR ASSEMBLER WILL KEEP TRACK OF THIS FOR YOU. All you have to do is to make sure that the area you're using is clear. So while it is imperative to have a clear spot in RAM to put your program, the addresses used from that point on will be handled by your assembler. What confuses most beginning assembly language programmers is the different ways that various assemblers handle this. Let's look at the three covered in this book to see how each deals with this. Kid's Assembler : No Line Numbers Since this assembler is meant to teach you about what's happen- ing to your code as you enter it, the actual addresses are given as you enter your opcodes and operands. The addresses are given in decimal values so that you can see how many bytes of memory each 114 instruction uses. For example, when using the Kid's Assembler you would see the following: ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDA# 49157 TAX 49158 STX $D021 etc. In the above example the first instruction used 3 bytes at addresses 49152, 49153 and 49154. Therefore, the next available address is 49155, which you can see in the second line. The next instruction used only 2 bytes, 49155 and 49156, and the third instruction, only a single byte. Thus, while the increments from one instruction to the next may be uneven, you can get a clear idea of where your code is being stored and how much memory is being used. Merlin64 When you use the editor in Merlin, you get line numbers in- cremented by one as you enter your program. This system makes it easier to keep track of everything, and since you can insert code be- tween the lines, you don't have to worry about having spaced be- tween line numbers. With the powerful editing features in Merlin64, you can manipulate and change your opcodes and operands. However, until you learn how many bytes each instruction uses in the different addressing modes, you won't know how much memory you used until you ASseMble your code. At that time you will see the actual addresses and the number of bytes you used. You don't have to worry about addresses, other than where to start plac- ing your code, since like the Kid's Assembler, this is automatically done for you. Commodore Development System When using EDITOR64, you should treat your line numbers the same way as you would a BASIC program. This is because you will need room to insert lines between line numbers. If you run out of 115 room between lines, you can reNUMBER your lines (fortunately) to insert code. These line numbers, however, are not the addresses you in which your code is stored. Rather, they simply represent the sequence in which your instructions will be assembled. Once you use your ASSEMBLE64 program, you can see the addresses where the code is stored. ROM AND RAM MEMORY If you don't already know it, there's an important difference be- tween ROM and RAM memory. Basically, ROM memory is "iron plated" and what is there, stays there. Your BASIC ROM, for ex- ample, is always the same no matter how many times you turn your computer on and off. (You can move ROM routines into RAM and change them in RAM. However, this has no effect on what's in ROM.) RAM, on the other hand, can be changed simply by enter- ing new values in the RAM addresses. You might imagine your computer's memory as a book with only some of the pages with print. Those pages with print have information that stays on those pages. It also has some blank pages where different material can be added or changed. The blank pages are like RAM and the printed pages like ROM. However, even with the blank pages, there are cer- tain ones that are reserved for certain things you will usually want on those pages. For example, while BASIC is in ROM, it loads into RAM in certain locations. You can change what has been put in RAM, but usually you leave it alone. That leaves certain other pages that are almost always blank, and you can write whatever you want in them. These are the pages we will use to store our assembly language programs. Your Commodore 64 can access more than 64,000 RAM ad- dresses, but we're going to concentrate on basic 64K RAM con- figuration. Some parts of this RAM are normally used for the in- formation stored in ROM. Thus, while we will refer to them as ROM areas, in fact, they can be used as RAM. (Think of these areas as having ROM routines loaded into them from the ROM chips.) First, lets look at a "map" of how your Commodore 64 defaults memory set-up. This will be used in our programming considera- tions even though some assemblers rearrange memory to provide more space for machine language programs. 116 STANDARD MEMORY ALLOCATION $E000-$FFFF 57344-65535 8K Kernal ROM $D000-$DFFF 53248-57343 4K I/O or Character ROM $C000-$CFFF 49152-53247 4KRAM $A000-$BFFF 40960-49151 BASIC ROM or ROM Plug-in $8000-$9FFF 32768-40959 8K RAM or ROM Plug-in $4000-$7FFF 16384-32767 16K RAM $0000-$3FFF 00000-16383 16K RAM First 32K At first glance, you might look at those two 16K blocks of RAM at the bottom and decide that's the place to store your machine code. As it happens, this is not the case. First of all, you won't be doing any programs that use 32,000 addresses for a while, and if you did, you'd run into the area where BASIC is stored as well as all kind of other things you don't want to crash into. 8K RAM or ROM Plug-in Right above the second block of RAM is an 8K block that is used either as RAM or a ROM plug-in. This is a good place to store your 117 programs if you don't use a ROM plug-in. However, you may want to write programs that others who do use plug-in ROMs will use. If you store your programs here, they may be over-ridden or conflict with a plug-in. For example, I have a plug-in utility program called "Vic-Tree." I use it all the time for easily accessing my disk and editing BASIC programs. If I have a machine code program in the area used by the "Vic-Tree", as soon as I initiate the ROM with SYS 32768, 1 blow out the machine code stored there. 8K BASIC ROM Area The next area of RAM, $A000-$BFFF, is where your BASIC ROM loads in. Programs stored here will conflict with your BASIC operations. Since you will often want to SYS a machine routine from a BASIC program, any code stored here will be wipe out your BASIC. 4KRAM Next, we come to a nice clean-looking 4K area of RAM beginning at $C000 (49152). This is the area I like to use the most since there's plenty of room to write programs, and it doesn't conflict with anything else. It's above the BASIC ROM area, out of the way of plug-ins, and very far away from where your BASIC in- struction storage begins ($800/2048). 4K I/O or Character ROM Leave this area alone for now since your characters are stored here or used for your I/O. 118 8KKernalROM This area is a good place to visit with JSR since it has so many useful subroutines you will want to use. However, if you store your program here, you'll conflict with the Kernal. Think of this area as a tool box. You build your program somewhere else but use all the tools in this area. Some nooks and crannies Now you may be thinking all you have is a crummy 4K for your programs. That's almost true if you want to use your BASIC and have room for plug-ins. However, there are some other places you can use while keeping all your other goodies in tact. Probably the favorite for assembly language programmers is the cassette buffer from $33C-$3FB (828-1019). That gives you only 192 bytes, but we're going to be using short routines to get started; so there's more than enough room here. The only problem is that if you have a cassette recorder, you'll crash into some routines used by the cassette. Likewise, there are little places you can find that are un- used or so little used that you're probably safe. For example, there are eight bytes available from $334-$33B, Sprites 13-15 from $3CF- $3FF as well as other little hidey holes. However, its not worth the bother to even worry about these locations until your programs get really big. By that time, though, you'll probably want a re- configuration of memory to use everything taken up by BASIC. For the time-being there's plenty of room to work in the 4K area of RAM. In fact, we'll be able to stick dozens of little routines there simultaneously that we can SYS from BASIC. After that, the 8K block of RAM beginning at $8000 is available unless you use a plug-in ROM a lot. (Merlin64 defaults to this area since the assembler/editor uses $C000. However, there's no problem in hav- ing your programs executed from the $C000-$CFFF area once Merlin is out of memory. We'll discuss this more a little later.) MINI-MONITOR To look at the contents of your ROM and RAM, monitors are handy. In previous chapters, I suggested you write your own 119 monitor, and I still think you should. However* to get you started on your monitor, the following "mini-monitor" examines the con- tents of your memory for you. Addresses and their contents are presented in hexadecimal and decimal. In this way, you can see where you have free RAM and where there is information stored. Also, as you start learning the hexadecimal machine opcode values, you can actually read the routines in your memory. In the next sec- tion we will be discussing the high-byte / low-byte arrangement of address storage, and this too you will be able to see. Moreover, since the mini-monitor is written in BASIC, it will be able to examine itself. Take a look at the code being stored beginning at address $800 (2048). MINI-MONITOR 10 PRINT CHR$(147) 20 PRINT "BEGINNING ADDRESS OR {RETURN} FOR NEXT" 30 INPUT'ADDRESS. PRESS 'Q' TO QUIT ";AD$ 40 IF AD$ = "Q" THEN END 50AD = VAL(AD$) 60 FOR K = AD TO AD+ 15: N = K 70HB = INT(N/256) 80 LB = N-INT(N/256)* 256 90FORX=1TO2 100IFX = 1THENN = HB 110IFX = 2THENN = LB 120 N% = INT(N/16) :GOSUB 250 130 N% = N-N%*16:GOSUB 250 140 IFX=1 THEN H1$=HEX$ : HEX$ = "" 150 IF H1$ = "0" THEN H1$ = "00" 160 NEXT 170HEX$=H1$+HEX$ 180 HEX$ = "$" + HEX$ :PRINT HEX$;"-";:HEX$ = "" 190 N = PEEK(K) 200 N% = INT(N/16) :GOSUB 250 210 N% = N-N%*16:GOSUB 250 220 PRINT HEX$;" ";K;"-";PEEK(K) : HEX$ = "" 230 NEXT 120 240 AD$= STR$(K) : GOTO 20 250 REM ********************** 260 REM CONVERT DECIMAL TO HEX 270 REM ********************** 280 HEX$ = HEX$ + CHR$(48 + N% + 7 * ABS(N% > 9)) 290 RETURN You enter your starting address in decimal. Once you've done that, just press RETURN to look at the next block of memory, or enter a new starting address. The hexadecimal and corresponding decimal values are displayed on the same line to help you get ac- quainted with going from one number system to the next. Since your mini-monitor simply looks at hex and decimal values, it isn't much of a monitor. See if you can change it to do some or all of the following: 1. Move blocks of code from one area to another. 2. Allow starting addresses to be entered as either decimal or hex- adecimal. 3. Change memory values. (A simple POKE subroutine will do that.) 4. Display mnemonic opcodes for machine opcode. (This is tricky since you have to distinguish opcodes from address values, but it can be done. The trick is in knowing the number of bytes each opcode uses.) This can also be used as a hex-decimal conversion program for converting useful Kernal addresses to decimal so that you can SYS them from BASIC. In fact, one of the first areas you will want to explore is from 57344-65535 ($E000-$FFFF). BACKWARD NUMBERS : LOW-BYTE / HIGH-BYTE STORAGE In discussing the numbering systems used in your computer, we arranged the high-byte and low-byte in the order we read a number. For example, a common subroutine in your kernal is at location 121 $E544. You've seen this in our example programs, and we'll be us- ing it a lot more. Broken down into a high-byte and low-byte, it would look like the following: HIGH BYTE $E5 LOW BYTE $44 However, your Commodore 64, along with other 6502 based microcomputers, store two-byte numbers in a low-byte / high-byte configuration. Therefore, in your computer's memory, it would look like this: LOW BYTE $44 HIGH BYTE $E5 Everything else is in the expected order, but addresses are stored backwards. For instance, the following instruction, JSR $E544 would be stored in three addresses as $0000 20 $0001 44 -4-Low byte $C002 E5 ^-High byte The '20' is the hexadecimal machine opcode for JSR. It's just where we would expect it to be since it is the first in our assembly instruction and is at the first address. However, the second or low byte, 44, of $E544 comes first, followed by the E5. If we had made our JSR to $22, our code would be arranged as follows: 44 122 $C000 20 $C001 22^- Low byte $C002 00 ■<- High byte And a JSR to $FF0 would look likes this: $C000 20 $C001 00 m- Low byte $C002 FF -*- High byte So if you see a number like the following: 1A 09 Just switch it so it is: 09 1A And you get $91A. BYTES, OPCODES AND ADDRESSING MODES We've discussed the fact that different opcodes use different amounts of memory, and the same mnemonic opcodes in different addressing modes use different numbers of bytes. As we get into the actual use of opcodes in the next chapter, you will be better able to see how this works. For now though, we should preview this a bit. The first thing to remember is that an opcode uses only 1, 2 or 3 bytes of program memory. Let's examine each in terms of bytes used. lByte The most economical opcodes are those using only a single byte. For example, we've seen RTS. It has no operand, and so it is said to be an implied opcode. (Implied addressing.) 123 2 Bytes Opcodes that can only handle 1 byte operands take up two bytes. One byte is for the opcode and the other for the operand. Any in- struction that can have a maximum operand value 255 ($FF) is a two byte instruction. For example, in the immediate mode, LDA can only have a maximum operand value of 255 ($FF). 3 Bytes Opcodes whose operand is a non-zero page address have three bytes. One byte is used for the opcode, one for the low-byte of the address and one for the high-byte. For example, LDA in the ab- solute addressing mode uses three bytes. SUMMARY As you practice and experiment, the material we have covered will become easier. In the next several chapters we will be putting to work the knowledge we have developed. Thus, what has been abstract will become concrete and give you a new level of understanding. You will make mistakes, but whereas an uninform- ed programmer does not understand why he made a mistake, you will. For example, you may accidentally load your program into $800 instead of $8000. Since $800 is the beginning of BASIC, any BASIC program you try to execute after loading a machine language routine in that location will bomb. Because you now know something about how memory works, you will be able to spot the problem and correct it. 124 CHAPTER 8 JUMPING IN WHERE TO STICK YOUR PROGRAMS Just in case you skipped our discussion of program placement, we'll quickly review both the procedure for assigning the starting address and the recommended places to start. Since each assembler is a little different in this regard, read the section that applies to the assembler you're using. Auto-Placement With Kids' Assembler If you're using the Kids' Assembler, the default starting address is 49152 ($C000.) When you enter the editor/assembler all you have to do is press RETURN, and your program is stored beginning at 49152. If you want another address, just enter the decimal value for the address and press RETURN. ORG Pseudo-Opcode In Merlin64 If you do not specify a beginning address with ORG in your first line; then it will default to $8000 (32768). This is fine if you do not use plug in ROMs, and you can test your programs while Merlin is still in memory if you use this address. However, if you want your 125 programs in $C000 or some other area outside of the plug-in ROM location, then use the following format: LABEL OPCODE OPERAND ;COMMENT ORG $C®00 This should be your first line of code in the programs we will be covering in this book. Once you're more advanced you can do more with ORG in different places in your program. Commodore Assembler's * = function If you use the Commodore EDITOR64, your first line should be * = to some clear area of memory. Since the default address is zero ($0000), you must begin your programs with the * = . LABEL OPCODE OPERAND ;COMMENT * = $C000 Since the Commodore 64 Macro Assembler Development System uses special loader programs to put your assembled code in- to memory, be careful in choosing your loader. Since our examples will stick with the 4K of RAM beginning at $C000 (49152), you should use the LOLOADER. It loads at $0800 . However, since the HILOADER loads at $C800 , which will be above our example pro- grams, you can use it as well. One final thing about the Commodore editor/assembler; you must end your programs with .END in the OPCODE field. Neither the Kids' Assembler or Merlin's Apprentice understands this pseudo-opcode; so only use it with the Commodore system. VISITING BUILT-IN SUBROUTINES WITH JSR. At the top of your memory is the Commodore-64 Kernal. A visit to the Kernal with the JSR instruction will execute the subroutine at the addresses specified in the operand and return to your program. For example, one subroutine we'll want to use is called CHROUT. 126 It outputs a character to a specified channel, usually the screen. The CHROUT routine is located at $FFD2 (65490). Likewise, at $E716 (58159), there is a subroutine to output the contents of the A register (accumulator) to the screen. Both subroutines can do the same thing, but each requires different preparation routines we will learn. In Appendix D there is an extended listing of Kernal subroutines. As we go along, we'll introduce some other handy subroutines that are built into your Commodore-64. The best way to envision the JSR instruction is as a GOSUB. However, unlike BASIC where you must write your own routines, the JSR goes to a built-in subroutine. (Of course you can JSR to subroutines you've written yourself, but that will come when you're more advanced.) For the time being, think of the JSR in terms of built-in subroutines that do all kinds of things for you. In fact, the JSR instruction is actually simpler than GOSUB since with BASIC GOSUBs you have to prepare your own subroutine. Just imagine a really nice person at Commodore who spent a lot of time writing complex subroutines for you to make assembly language program- ming easier. The following is a sampling of some handy subroutines to visit with JSR: HEX DECIMAL FUNCTION $E544 58692 $E566 58726 $E716 59159 $E891 59537 $E8E7 59624 $E9FF 59903 $FF9F 65439 $FFCF 65487 $FFD2 65490 $FFE4 65508 $FFF0 65520 Clear screen Home cursor Output to screen Perform RETURN Scroll screen Clear screen line SCNKEY-scan keyboard CHRIN-get char from input channel, usually keyboard CHROUT-output a character GETIN-get a character, usually from keyboard PLOT-set cursor location Most of the built-in subroutines expect some value in the ac- cumulator or some preparatory set of instructions. For example, a 127 JSR to $E516 (output to screen) sends whatever is in the A register (accumulator) to the screen. Other subroutines, such as CHROUT expects a channel defined by the CHKOUT subroutine, and in turn, CHKOUT expects the OPEN subroutine to prepare the channel. We'll get to these as we accumulate more instructions. To get you going, we'll do some simple JSR's to subroutines ex- pecting nothing. However, before we do that, we'd better look at RTS. GETTING OUT WITH RTS Probably the most frequent cause of Computer "lock-up" is the failure to end a routine with RTS. If you execute a machine language program from BASIC in either the immediate mode or from a program with SYS, control is taken over by your machine language program. The program executes instructions one address at a time. If there is not an instruction to tell the program to ReTurn from Subroutine (RTS) then it merrily goes on to the next address and instruction. This can be a real problem if the area where you're programming has "garbage" in it, either in the form of the rem- nants of another machine language program or other code that somehow got placed there. For example, the following might be a simple routine to clear the screen that forgot to include an RTS: $C000JSR $E544 Garbage from here on $C003 LDA #0 ^- Remnants from other program $C005STA $D021 $C008LDA #144 $C00AJSR $E716 More junk... Your JSR to $E544 sure cleared the screen for you, but the "gar- bage" turned your background and character color to black. So in- stead of having a nice clear screen and control over your computer, you have black on black with no visible cursor! Now that we have JSR and RTS, let's write some simple pro- grams: 128 LABEUADRS OPCODE OPERAND ;COMMENT ORG $C000 ;Merlin only * = $C000 ;Commodore only 49152 JSR $E544 49155 RTS .END ; Commodore only. After entering RTS on the Kids' Assembler, enter 'Q' for 'quit.' As our listings become more complex, we will have separate listings for the Kids' Assembler and a general listing for other assemblers. You will have to remember to include the ORG or *= pseudo-opcodes (or whatever your assembler uses to indicate the start address of your program) and to end it with .END on your Commodore assembler. With RTS, dear. How do we ^get back Ma? Now, you've seen that little program elsewhere in this book, and by now you should not only know how to clear your screen, but how to get back control of your computer once you've done that. Just to see if you understand the concept of JSR, see if you can write a program that will Home the cursor but not clear the screen. (HINT: Find the address of the Home cursor routine.) If you can do that, go on to the next section. LOADING UP WITH LDA Your accumulator is the work horse of assembly language pro- gramming. Its contents, which can be from $0-$FF (0-255), are used by other instructions. Furthermore, many of the built-in subroutines expect something in the accumulator. One way to get something into the accumulator is with the LDA (LoaD Ac- cumulator). For example, try the following little program: 129 LABEL GENERAL OPCODE OPERAND COMMENT ORG $C000 ; Merlin Assembler * = $C000 ; Commodore Assembler JSR $E544 ; Clear screen LDA #88 ; Load the ac- cumulator with the decimal value 88 JSR $E716 ; Output to screen RTS .END ; Commodore assembler KIDS' ASSEMBLER ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDA# 88 49157 JSR $E716 49160 RTS Note the the presence of the pound (#) sign right before the 88 (or at the end of the LDA in the Kids' Assembler.) That means the LDA is in the Immediate mode. The value in the operand is actually loaded into the accumulator. We'll discuss addressing modes more in a bit, but let's see what the program does. When you assemble and run the program, you will see an 'X' printed in the upper left hand corner of your screen. The "output to screen" subroutine at $E716 took the value in the accumulator, and placed it on the screen. Since the 88 is the ASCII value of the letter X, that's what was output to the screen. Appen- 130 dix J has a complete listing of the various values for your Com- modore Character Set. The following example loads different values into the ac- cumulator and prints my first name, "BILL". (Remember the ORG on Merlin and *= and .END on your Commodore Assemblers respectively.) GENERAL LABEL OPCODE OPERAND COMMENT JSR LDA JSR LDA JSR LDA JSR JSR RTS $E544 #66 $E716 #73 $E716 #76 $E716 $E716 B KIDS' ASSEMBLER ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDA# 66 49157 JSR $E716 49160 LDA# 73 49162 JSR $E716 49165 LDA# 76 49167 JSR $E716 49170 JSR $E716 49173 RTS 131 Now wait a minute! There are only three LDA's and yet the word BILL has four letters. What's going on? There is nothing in the program that af- fects the contents of the ac- cumulator. Some subroutines or other actions can scramble the accumulator, but generally what Loading the accumulator lda was last loaded with LDA stays there. Therefore, since BILL has two L's together, the value for the letter L (76) was still there after the first one had been output to the screen. To see if you understand everything so far, see if you can change the program to write your own name to the screen. IMPLIED, IMMEDIATE AND ABSOLUTE ADDRESSING MODES The program that printed a letter to your screen used three ad- dressing modes, implied, immediate and absolute. The implied mode occurs when no operand exists. RTS is in the implied address- ing mode. Instructions in the implied mode only take one byte of memory since all it needs is a single machine opcode. The immediate addressing mode is signaled by the pound sign (#), usually the first character in the operand. (As explained in Chapter 2, the Kids' Assembler attaches the addressing mode to the end of the opcode.) This means that the contents of the operand are loaded, stored, compared or in some other way acted upon by the operand. Thus, LDA #88 (or LDA# 88), took the value of the operand and put it in the accumulator. Operations in the immediate mode take two bytes; one for the opcode and one for the operand, which can be no larger than $FF (255). Finally, we used the absolute addressing mode with our JSR in- struction. The absolute addressing mode refers to the address in the operand, not its value. Since JSR only works in the absolute mode, we don't have to concern ourselves with it. However, LDA also has an absolute mode. If we had written, 132 LDA88 instead of loading the accumulator with the value 88, it would have loaded the accumulator with the value stored in address 88 ($58). If you want to see the difference in results, just remove the pound (#) sign from the operand (or the opcode in the Kids' Assembler.) Since locations 87-96 ($57-$60) are a miscellaneous numerical storage area, there's no telling what you'll get. (Go ahead and try it just for fun.) To summarize the addressing modes we've used so far, keep the following in mind: IMPLIED MODE. Uses single byte and no operand. IMMEDIATE MODE. Uses actual value in operand, either decimal or hexadecimal, and uses two bytes. ABSOLUTE MODE. Uses value in the address in operand. Three bytes of memory are used; one for the opcode, and one apiece for the low and high bytes of the address. = = A COMMON MISTAKE = = Sooner or later you will make the mistake of mixing up the immediate and absolute modes. You will put in LDA 200 when you meant to write LDA #200 (LDA# 200 on the Kids' Assembler.) Don't worry, it'll happen, believe me. Now that you know it will happen, you also know a common bug in assembly language programs. All you have to do is to add the pound (#) sign and your results will be what you expected in the first place. (Also, you'll wish you had an assembler package with a good editor!) At this point, we're starting to get somewhere. We've used assembly language commands interactively. That is, what we did with one opcode instruction, affected another. That wasn't too dif- ficult, was it? 133 STORING WITH STA In BASIC programming you define variables with statements such as; A = 45 In essence, you are storing the value 45 in a variable called A. In your machine language interpreted BASIC program, the variable A is an address in memory; so that whenever A is accessed, the con- tents of the address for A is accessed. In assembly language programming, you actually put a value into a certain address. Sometimes you will use an address that you know is empty and is simply a handy place to store a value to be used later in your program. Very often, though, you will store a value in an address that activates a process. This will either supply a value for a built-in subroutine or an address that stores a color or character on your screen. Let's look at each of these uses with the STA instruc- tion. In the absolute mode STA stores the accumulator's value in a specified address. For example, if you LDA with a value of 10, and then STA $33C, the value 10 will then be stored in location $33C. Storage in Empty, Unused RAM In planning an assembly language program, you not only have to plan for space for your program, you also have to plan for space for your variables. For example, if your program uses 30 bytes for the program itself, it may use another 30 bytes, or even more, for variable storage. For example, you may use the addresses from 49152-49181 ($C000-C01D) for your machine instructions and 49200-49230 to store your variables. Therefore, you need to plan for 60 bytes of memory. The following program loads (LDA) a value into the accumulator in the immediate addressing mode (#), stores the value at an unused address (STA), clears the accumulator by loading it with zero, (LDA #0), and then loads the accumulator from the absolute mode (LDA) from the address it first stored the 134 value. To show you what it did, it prints the character for the ASCII code in the accumulator with JSR $E716. LABEL GENERAL OPCODE OPERAND COMMENT {MERLIN ORG $C000} {COMMODORE * =$C000} JSR $E544 ;CLS LDA #$43 ; ASCII 'C STA $C050 LDA #$0 ; Immediate Mode LDA $C050 ; Absolute Mode JSR $E716 RTS {COMMODORE .END} ADRS KIDS' ASSEMBLER OPCODE OPERAND 49152 49155 49157 49160 49162 49165 49168 JSR LDA# STA LDA# LDA JSR RTS $E544 $43 $C050 $0 $C050 $E716 In the above example, we used only hexadecimal values in the operand. This was to show you that both the pound sign (#) and dollar sign ($) had to be included in the operand in standard assembler format. Before you run the program, see if you can guess the character to be printed to the screen. STORAGE IN 'SOFT-SWrrCH' ADDRESSES A 'soft-switch* is a switch that is activated by the software. In your Commodore 64, there are many such locations. For example, 135 the background color of your screen is determined by the value in 53281 ($D021). At the end of Chapter 1, we showed all of the values to be POKEd into 53281 to give you the desired background color on your TV or monitor. When you use a soft-switch address to STA a value, it is the same as POKEing that location in BASIC. For ex- ample, to turn your background to black, you would STA the ac- cumulator value in $D021 . The following little program shows you how: GENERAL LABEL OPCODE OPERAND COMMENT {MERLIN ORG $C000} {COMMODORE *=$C000} LDA #$0 STA $D021 RTS {COMMODORE .END} KIDS' ASSEMBLER ADRS OPCODE OPERAND 49152 LDA# $0 49154 STA $D021 49157 RTS There are a lot of pointers, flags and registers that can be treated as soft-switches, and simply with LDA and STA instructions, you can change them to what you want. The following is a list of some soft switches and pointers we will be using: (Later on we will deal with the many registers that affect your sprites and sound.) SOFT SWITCHES AND POINTERS HEX DECIMAL FUNCTION $2B-$2C 43-44 Start of BASIC $2D-$2E 45-46 Start of BASIC variables $286 646 Current character color 136 $28A 650 Repeat all keys if $80 $D020 53280 Border color 0-15 ($0-$F) $D021 53281 Background color 0, 0-15 ($0-$F) $D022 53282 Background color 1, 0-15 ($0-$F) $D023 53283 Background color 2, 0-15 ($0-$F) $D024 53284 Background color 3, 0-15 ($0-$F) Let's make a simple and practical program. In fact, let's make two. One will make all your keys repeat, and the other will turn off your key repeat. We'll store one program at 49152 and the other at 49200. When you SYS 49152, all your keys will repeat, and when you SYS 49200, the repeat will be turned off. These programs can be loaded simultaneously while you program in BASIC. You might want to turn on the repeat function if you're working with keyboard graphics and turn it off if you're working with text. Save the first program under the name ON and the second OFF. LABEL GENERAL - "ON" OPCODE OPERAND COMMENT {MERLIN} ORG $C000 {COMMODORE}* =$C000 LDA #$80 STA $28A RTS {COMMODORE} .END KIDS' ASSEMBLER - "ON' ADRS OPCODE OPERAND 49152 LDA# $80 49154 STA $28A 49157 RTS 137 GENERAL - "OFF" LABEL OPCODE OPERAND COMMENT {MERLIN} ORG $C030 {COMMODORE}* = $C030 LDA #$0 STA $28A RTS {COMMODORE}.END KIDS' ASSEMBLER - "OFF" ADRS OPCODE OPERAND 49200 LDA# $0 49202 STA $28A 49205 RTS When you want to use the programs, first load them into memory either with LOAD "PRG NAME",8,1 (for Merlin and Kids' Assembler files) or with the LOLOADER program for files created with the Commodore ASSEMBLER64. When you want your keys to repeat, just enter SYS 49152, and when you want to turn off the repeat function, enter SYS 49200. (Congratulations, you've just written your first utility programs in assembly language!) = = AUTO-LOADING MULTIPLE PROGRAMS = = When you load more than a single machine language PRG file from the immediate mode in BASIC, you have to enter NEW after each load. However, Guy Grotke, in his book Intermediate Commodore 64, shows a way to load as many programs as you want with a BASIC loader program. The essential problem with multi-loading from a BASIC program is that each time you load a file, the pointer goes back to the beginning of the BASIC pro- 138 gram. As a result, you get caught in an endless loop since the program will simply keep re-loading the first pro- gram. However, since the BASIC program preserves its variables, you can arrange things so that after loading the first program, it will go on to load the next one. For ex- ample, the following programs show how to load the ON and OFF files saved with Merlin's Apprentice and the Kids' Assembler: ON/OFF LOADER - MERLIN 10 IF X = THEN X = 1 : LOAD "ON.O",8,1 20 IF X = 1 THEN X = 2 : LOAD "OFF.O",8,1 ON/OFF LOADER • KIDS'S ASSEMBLER 10 IF X = THEN X = 1 : LOAD "ON 49152",8,1 20 IF X = 1 THEN X = 2 : LOAD "OFF 49200",8,1 What happens is that the first time through the program, the IF/THEN statement in line 10 is evaluated as 'true' and so the variable X is incremented by 1 and the first file is LOADed. After the LOAD, the program does not go to line 20, but because the pointers were reset by the first LOAD, it starts all over again. However, because X is now 1 instead of 0, Line 10 is ignored and the program proceeds to line 20, evaluates the IF/THEN statement as true, increments X by 1 and then LOADs the second pro- gram. By adding more lines and incrementing the X variable, you can LOAD as many PRG files as you want. (If you have the Commodore assembler package, you will have to write and save your programs as PRG files from one of the MONITOR programs. Otherwise, using ASSEMBLER64, your programs are saved as SEQ files and they will have to be loaded with LOLOADER or HILOADER 'by hand.') With that handy little program, whenever you want your repeat key utility programs in memory, just RUN the ON/OFF LOADER. 139 STORAGE ON YOUR SCREEN A final place to STA values is right on your screen! Your screen memory 40 x 25 matrix is located from 1024-2023 ($400-$7E7). Overlaying the screen memory on the same matrix is the Color Memory from 55296-56295 ($D800-$DBE7). Appendices H and I provide maps of screen and color addresses to make it easy for you to see where characters will be stored on the screen. When you store a character on the screen, you also have to store a color or you won't be able to see the character. (On the first Commodore 64's it was unnecessary to store the color to see the characters.) The color codes are the same as the ones for background and border colors, 0-15 ($0-$F), and the character codes are the ASCII values found in Appendix J. f? 1024/55296 To align the character and color, you use the offset 54272. By adding the offset to your screen memory address, you will have the correct address of your color under the character. For example, if you look at the Screen Memory Map in Appen- dix H, location 1484 is just about in the middle of the screen. Add 54272 + 1484 to get the correct color address of 55756. If you look at the Color Memory Map in Appendix I, you will see that value also to be about in the middle of your screen. The following shows you the correspondence between the screen and color memories: Screen & Color Storage 2023/56295 MC I Screen Color 1024 1025 1026 55296 55297 55298 140 1027 1028 55299 55300 2023 56295 Now, using LDA and STA, let's write a program that will put something on the screen. LABEL GENERAL OPCODE OPERAND COMMENT {MERLIN} ORG $C000 {COMMODORE} *=$C00B i JSR $E544 LDA #0 ; Black STA 55296 ; 1st Color Address LDA #88 STA 1024 ; 1st Char Address RTS {COMMODORE} .END ADRS KIDS' ASSEMBLER OPCODE OPERAND 49152 49155 49157 49160 49162 49165 JSR LDA# STA LDA# STA RTS $E544 55296 88 1024 We've used the decimal value 88 before, and when we printed it to the screen, we got an 'X.' This time, though, we get a 'spade' character. If you look in Appendix J, the Set 1 character for 88 is 141 the spade. Set 2 is the X. Thus, you learned that when you LDA a value and JSR $E716, the character printed is Set 2, but if you STA the value of the accumulator at a screen address, you get the character from Set 1. The color stored at the corresponding color address give the character its color, not the background. SUMMARY With just a few opcodes, we've already been able to output characters to the screen and even write a little utility program in assembly language. The JSR, RTS, LDA, and STA opcodes are heavily used in all assembly language programing, and so you're off to a roaring start. We also learned about three different addressing modes, and so in addition to the four opcodes, actually have an ad- ditional opcode since we learned to use LDA in the immediate and absolute modes. In the next chapter, we going to learn some new opcodes that will add power to your programming. Right now, what we're doing is equivalent to using a huge number of PRINT and POKE state- ments in BASIC. However, since we can access built-in subroutines with JSR, we're actually further along in assembly programming than we would be in learning BASIC. By taking each opcode a step at a time, we are able to do a lot with a little; so be patient and forge ahead! 142 CHAPTER 9 USING THE X AND Y REGISTERS HOW TO USE TO X AND Y REGISTERS In addition to your A register, you have two more heavily used registers called X and Y. Like the opcodes referring to the A registers that have an 'A' in their name, such as LDA and STA, op- codes with X and Y refer to the X and Y registers. For example, to load the X register, the opcode LDX is used. (Come on now, what would the LoaD the Y register be?) There are many uses of the X and Y registers, as there are for the accumulator. Some subroutines read the X and Y registers to calculate certain results. We saw in the last chapter how the "output to screen" subroutine at $E716 took the ASCII value stored in the accumlator and printed a character to the screen. Likewise the PLOT subroutine at $FFF0 reads the X and Y registers to plot the row and column position of the cursor. For example, if we wanted to move the cursor to the middle of the screen on a 40 by 25 matrix, we would want to specify a location of about 12/19. Let's see how we can use the X and Y registers to output the contents of the A register to the middle of the screen. 143 GENERAL LABEL OPCODE OPERANDCOMMENT {MERLIN ORG {COMMODORE *=$C000} JSR $E544 LDX #12 ; Row number LDY #19 ; Column number CLC ; Clear the C flag JSR $FFR) ; PLOT subroutine LDA #88 JSR $E716 ; Output to screen RTS {COMMODORE .END} KIDS' ASSEMBLER ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDX# 12 49157 LDY# 19 49159 CLC 49160 JSR $FFF0 49163 LDA# 88 49165 JSR $E716 49168 RTS First of all, we did something sneaky! We included an opcode not yet covered, CLC. The CLC instruction CLears the Carry flag. The reason we did that is because the PLOT subroutine at $FFF0 can be used to either read the X/Y position of the cursor or to set it. If the Carry flag is set; then it reads the X/Y position of the cursor and 144 store it in the X and Y registers. To set the position, the Carry flag must be cleared. We did that with CLC. Also notice where we used our LDA. We wanted to load the A register after the JSR to the PLOT subroutine. The reason for this is that the PLOT subroutine scrambles the A register. It doesn't do this to make life difficult for the programmer, but rather the subroutine itself uses the accumulator. Therefore if we LDA the ac- cumulator with our 88, to get an 'X' printed to our position PLOT- ted, after the JSR to $FFF0, we get what we want. The values for the X register with the PLOT subroutine at $FFF0 can be from 0-24 and the Y values from 0-79. Since the screen is made up of 25 rows (0-24) the X register values make a lot of sense. However, we know our screen has only 40 columns (0-39); so what happens when we have Y values from 40-79? I'm not going to tell you. You'll have to change the Y value in the above program to see for yourself! In addition to using the LDX and LDY instructions in the im- mediate addressing mode, it is also possible to use them in the ab- solute mode, just as we did with the LDA instruction. In fact, most of the same addressing modes of the LDA instruction also apply to the LDX and LDY instructions, but there are important exceptions we will see in a bit. TRANSFERS WITH TAX, TAY, TXA and TYA Transferring information be- tween the A register (accumu- lator) and the X and Y registers is handled by single byte instruc- tions. In looking at and remem- bering how to use TAX, TAY, TXA and TYA, remember you Transfer From-To. T from A to X: TAX T from A to Y: TAY T from X to A: TXA T from Y to A: TYA TAX 145 If we have the value 22 in the accumulator and issue a TAX in- struction, the contents of the accumulator are transferred to the X register. Now both the A register and the X registers would contain the value 22. None of the Transfer instructions affect the contents of the register from which the contents were transferred. In fact, rather than actually transferring contents, the Transfer instructions duplicate the contents in the target register. Therefore, you might want to think of the Transfer instructions as Duplicate instructions. Now, suppose you want to transfer the contents of the X register into the Y register. There is no TXY opcode. If you really think about it, though, I'll bet you can guess how to do it. (Think for a bit before going on. Think. Think. Think.) Okay, time's up. If you guessed you would transfer the X register to the accumulator with TXA and then using TAY, transfer the contents of the accumulator to the Y register, you're absolutely right. Thus, you will often see the following: TXA TAY Likewise, you can transfer the Y register to the X register using the TYA-TAX sequence. Let's take a look at a program that will show you some work with these registers. See if you can guess what will be printed on your screen before you SYS your program. GENERAL LABEL OPCODE OPERAND COMMENT {MERLIN ORG $C000} {COMMODORE *=$C000} JSR $E544 LDX #$54 TXA JSR $E716 LDX #$41 TXA STA 49200 146 LDY 49200 TYA JSR $E716 LDY #$58 TYA JSR $E716 RTS {COMMODORE .END} KIDS' ASSEMBLER ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDX# $54 49157 TXA 49158 JSR $E716 49161 LDX# $41 49163 TXA 49164 STA 49200 49167 LDY 49200 49170 TYA 49171 JSR $E716 49174 LDY# $58 49176 TYA 49177 JSR $E716 49180 RTS If you guessed the message is what transfers the contents of the accumulator to the X register, you got it right! We did a lot of un- necessary transferring, but it was more to help you see what's going on in your computer than an example of efficient programming. Let's see what happened. After clearing the screen, the X register was loaded in the im- mediate mode with $54 (84 decimal). That value was transferred to the accumulator and then output to the screen. Thus, we got our T.' 147 After that, we loaded the X register with $41 (65 decimal) and transferred it to the A register. Then the value was stored in address 49200 with the STA instruction. From the absolute mode we load- ed the value in 49200 into the Y register, and then transferred it to the A register and printed it to the screen. That's where we got the 'A.' Finally, the Y register was loaded with $58 (88 decimal), transfer- red to the accumulator with TYA and the output to the screen. This was how the 'X' was produced. At this point, it might seem that the transfer instructions do little more than complicate an otherwise simple process; however, as we go on, we will see how they can be very useful in programming. Our above example was just to give you some practice in using them. INCREMENTING AND DECREMENTING WITH INX, INY, DEX AND DEY. The incrementing and decrementing of the X and Y registers will play a crucial role in your programming later on. Here, we're only going to see what happens when the INX, INY, DEX or DEY in- struction occurs. Basically, when an INX or INY instruction is issued, + 1 is added to the X or Y register. With a DEX or DEY in- struction, 1 is subtracted from the X or Y register. By transferring the values of the X and Y registers to the accumulator and sending the results to the screen, we can graphically see what happens. GENERAL - DEX LABEL OPCODE OPERAND COMMENT {MERLIN ORG $C000} {COMMODORE *=$C000} JSR $E544 LDX #90 LDY #65 TXA 148 JSR $E716 ; Output to screen TYA JSR $E716 DEX ; Subtract 1 from X register TXA JSR $E716 INY ; Add 1 to Y register TYA JSR $E716 RTS {COMMODORE .END} KIDS' ASSEMBLER - DEX ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDX# 90 49157 LDY# 65 49159 TXA 49160 JSR $E716 49163 TYA 49164 JSR $E716 49167 DEX 49168 TXA 49169 JSR $E716 49172 INY 49173 TYA 49174 JSR $E716 49177 RTS You should have gotten the following on the upper left-hand cor- ner of your screen: ZAYB 149 The 90 is ASCII value for 'Z' and the 65, the value for 'A'. Since the X register was decremented, the next value would be 89, the ASCII value for the letter *Y\ Conversely, since the Y register was incremented, it went from 65 to 66 to produce the 'B'. FROM X AND Y TO MEMORY WITH SIX AND STY Rather than transferring the X and Y register values to the ac- cumulator, and then using STA, it is possible to directly store in memory with STX and STY. The three-byte instructions work in exactly the same way as STA except instead of storing the A register's contents, the X or Y register's contents are stored in the address specified in the operand. Thus, if you program, STY $C100 the contents of Y are stored in address $C100. Let's do something useful with our new knowledge. We'll write another utility program. This one will allow you to link two BASIC files together. As you know, as soon as you LOAD a BASIC pro- gram into memory, the current one is replaced by the one just LOADed. This is a real pain in the neck if you have a lot of subroutines you'd like to append to a program you're working on. For example, let's say that you have a handy sort routine stored in a file named SORT. The program you're working on in memory needs that program, but since you can't LOAD it without knocking out your current program, you have key in the whole darned SORT routine from scratch. Wouldn't it be nice if you could just append the SORT routine without having to re-key it in? In fact, wouldn't it be great if you could store all of your handy subroutines in separate files, and just load them up into the file in memory? In that way you could cut your BASIC programming time down considerably. The next two assembly programs will allow you to LOAD a BASIC file into memory and not destroy the contents of memory. It does this by tricking BASIC into believing that the LOAD ad- dress of the second program is the beginning of BASIC RAM. Ac- tually, it loads the program onto the end of the program in 150 memory. This is done simply by resetting the pointers showing the beginning of the BASIC program to the end of the program in memory. Then, a second machine language program resets the pointers to the actual beginning of BASIC thereby linking the two programs together. The only constraint on these two little utilities is that the second and subsequent programs you LOAD have to have higher line numbers than the ones they're loaded on top of. GENERAL - APPEND LABEL OPCODE OPERAND COMMENT {MERLIN ORG $C000} {COMMODORE *=$C000: \ LDX $2D DEX DEX STX $2B LDX $2E STX $2C RTS {COMMODORE .END} GENERAL - LINK LABEL OPCODE OPERAND COMMENT {MERLIN ORG {COMMODORE *=$C030} $C030} ; Note address change LDA #1 STA $2B LDA #8 STA $2C RTS {COMMODORE .END} 151 MULTI-LOADER PROGRAM (Merlin) 10 IF X = THEN X = 1 : LOAD "APPEND.O",8,1 20 IFX = 1 THEN X = 2 : LOAD "LINK.O",8,1 Since the addresses $2B-$2E are zero-page addresses, we need special opcodes on the Kids' Assembler. The "-Z" on the end of an opcode indicates a zero-page operation. Only two bytes are used in- stead of three. The Merlin and Commodore assemblers automatically recognize zero-page addresses and do not require special indicators. KIDS' ASSEMBLER - APPEND ADRS OPCODE OPERAND 49152 LDX-Z $2D 49154 DEX 49155 DEX 49156 STX-Z $2B 49158 LDX-Z $2E 49160 STX-Z $2C 49162 RTS KTOS' ASSEMBLER - LINK ADRS OPCODE OPERAND 49200 LDA#1 49202 STA-Z $2B 49204 LDA# 8 49206 STA-Z $2C 49208 RTS Note start adrs MULTI-LOADER PROGRAM (Kids' Assembler) 10IFX = 0THENX = 1: LOAD "APPEND 49152",8,1 20 IF X = 1 THEN X = 2 : LOAD "LINK 49200",8,1 152 To see how to use your new utilities, enter the following two BASIC programs, and SAVE each to disk or tape as PART 1 and PART 2: PARTI 10 REM PART 1 20 REM LOAD FIRST PART 2 30 REM PART 2 40 REM APPENDS TO PART 1 After you have a copy of both programs SAVEd, load your two machine files, APPEND and LINK, with the Multi-loader pro- gram. Next, LOAD "PART 1" and LIST the program. There should be just two lines, 10 and 20 . Now, SYS 49152. This will ac- tivate APPEND, and you can now LOAD "PART 2". When you LIST the program again, you will see line 10-40 all together as a single program. When you SYS 49200, the pointers will be reset, and the two programs will be treated as a single large program. The nice thing about machine language utility programs is that they will stay in memory while to work with your BASIC files. You can even RUN your BASIC programs without hurting them. In that way, you can load the utilities at the beginning a programming session and forget about them until they're needed to append and link BASIC files. ADDRESSING MODES WITH THE X AND Y REGISTERS In the next chapter, we will see how important the X and Y registers are in loops and branches. In fact, that is where their real utility lies, saving you a lot of time in programming. At this point, we will simply show you what the various addressing modes using the X and Y registers do. We have already seen that the immediate and absolute modes with LDX and LDY work the same as with LDA. However, we can 153 also do indexed addressing using the X and Y registers as offsets to our intended address. INDEXED ABSOLUTE ADDRESSING Basically, the way indexed addressing works with your programs is to add the value of the X or Y register to the address in the operand. For example, look at the following program: GENERAL LABEL OPCODE OPERAND COMMENT LDX#0 TXA STA $400,X ; Stores at $400 INX ; Add 1 to X TXA STA $400,X ; Store at $401 KIDS' ASSEMBLER ADRS OPCODE OPERAND 49152 LDX# TXA STA-X $400 INX TXA STA-X $400 The program simply loads the X register with , transfers the to the accumulator and then stores the in the specified address ($400) plus the value of the X register. So the first value is stored at $400 + , or $400 . Then the X register is incremented by 1 ; so now the value of X is 1 (0+1 = 1). That is transferred to the ac- cumulator and stored in $400 + X. Since X is now 1 , $400 + 1 = $401. Therefore, even though the address in the operand is still in- dicated as $400, it is actually $400 + contents of the X register as far as the computer is concerned. The following is the general for- mula of what occurs with indexed absolute addressing: 154 Indexed Absolute Addressing ADDRESS = ADDRESS + VALUE OF X OR Y REGISTER To see how we can put this to use, let's pick a location that we can see incremented. We know the screen addresses 1024-2023 ($400-7E7) make up our screen memory and 55296-56295 ($D800-DBE7) make up the color memory map. By using indexed addressing, we can place values in those locations simply by in- crementing X or Y and storing our values in the starting addresses offset by the X or Y registers. GENERAL • INDEXED ADDRESSING LABEL OPCODE OPERAND COMMENT {Merlin ORG $C000} {Commodore *=$C000} JSR $E544 LDA #4 STA $D021 ; Background color LDA #1 LDX #0 STA $D800,X ;Base color adrs + X STA $400,X ;Base screen adrs + X INX STA $D800,X STA $400,X INX STA D800.X STA $400,X RTS {Commodore: .END} 155 KIDS' ASSEMBLER - INDEXED ADDRESSING ADRS OPCODE OPERAND 49152 JSR $E544 LDA# 4 STA $D021 LDA# 1 LDX# STA-X $D800 STA-X $400 I NX STA-X $D800 STA-X $400 I NX STA-X $D800 STA-X $400 RTS The program clears the screen and turns the background color purple. The value 'l'is loaded into the accumulator and '0 ' into the X register. We will not be changing the value in the accumulator, but simply storing it in the screen and color memory areas so that we can see what's happening. The first storage location is at the base addresses of $D800 and $400. The X register is incremented, and the second STA is in $D80 1 and $40 1 . The X register is incremented once again, providing indexed addresses of $D802 and $402. Your screen results should be three white A's in the upper left hand cor- ner. With our current set of instructions, we could have provided the actual addresses ourselves and used a few less instructions. However, using indexed addressing, it is a little more convenient to use the X register to increment the base addresses. When we get to loops, you will really see the use of indexed addressing. Finally, we could have used the Y register as our index in exactly the same way. The next two addressing modes are a little hairy and will be in- troduced here just to show you how they work. They will be more 156 useful as you become more advanced. You might want to skip this last section and go on to the next chapter. INDEXED INDIRECT ADDRESSING (X Register Only) If you ever played pool, you probably know what a "bank shot" is. Instead of making your shot to send the ball directly into a pocket, you bounce it off the side first. Indexed indirect addressing is a type of "bank shot" used to check, set or obtain a value. The following illustrates the basic concept: ADDRESS = POINTER STORED IN ZERO PAGE + X REGISTER VALUE = LOCATION OF ADDRESS In zero page ($0-FF) a set of pointers are stored in 2 byte con- figurations. The low-byte is at the lower address and the high- byte is at the higher address. For example, let's say you have pointers stored in $FB-$FE (251-254). They have the follow- ing contents: $FB-$FC $AB $C0 $FD-$FE $D0 $C0 Indexed Indirect Shot The addresses are stored low-byte / high byte, therefore we are ac- tually looking at $C0AB and $C0D0. Note that the two addresses are not sequential. They do not have to be, but the pointers are se- quential. Therefore, since each pointer takes up two bytes, the in- dexing will have to be in steps of two. When indexed indirect addressing is used, you either fetch a value from the pointed-to address or store a value there. For example, let's say that $C0AB has the value 10 ($0A) and $C0D0 has 20($14). Using the format, or LDA ($FB,X) ^-General (LDA-X) $FB ^-Kids' Assembler 157 where X is the contents of the X register, you would load either the contents of $C0AB or $C0D0. Let's say the X register is '0'. The following would occur: LDA ($FB,X) $FB + = $FB -<- Get the address from $FB and $FC $FB = $AB $FC = $C0 Address to get value = $C0AB Contents of $C0AB = 10 Accumulator is loaded with 10 If the X register is incremented by 1, and indexed indirect ad- dressing is used, you'd be in trouble. That's because the pointer would show $FB + 1 to be the beginning of the two byte address. Thus, your load would be from, $FC = $C0 $FD = $D0 which points to $D0C0. That address is in the I/O, Color RAM or Character Generator area where you'd probably not be storing variables. Instead, you'd want to be sure you indexed by 2. Suppos- ing the value of the X register is 2, you'd get the following: LDX#2 LDA ($FB,X) $FB + 2 = $FD •*- Get the address from $FD and $FE $FD = $D0 $FE = $C0 Address to get value = $C0D0 Contents of $C0D0 = 20 Accumulator is loaded with 20 158 One of the reasons we won't be using this addressing mode much in this book is because it relies on a Zero-page address for its pointers. Since the Kids' Assembler is written in BASIC and all kinds of BASIC pointers are stored in zero-page, we'd be very limited in the areas we could use. Also, since we will want to use our machine language subroutines interactively with BASIC, we could easily bomb the BASIC program we're working with if we stored several pointers in zero-page. However, to give you a simple exam- ple of this type of addressing mode, try the following example: GENERAL INDEXED INDIRECT ADDRESSING LABEL OPCODE OPERANDCOMMENT {Merlin ORG $0000} {Commodore *=$C000} JSR $E544 LDY #65 ;Load Y with ASCII 'A' STY $0100 ;Store Y in $0100 LDA #$00 ;Low byte of target adrs. STA $FB ;Store in LB pointer adrs. LDA #$C1 ;High byte of target adrs. STA $FC ;Store in HB pointer adrs. LDX #$0 LDA ($FB,X) ; Indexed in- direct LDA JSR $E716 ;Output to screen RTS {Commodore .END} 159 = = ZERO-PAGE ADDRESSING = = Zero page addressing has special machine language op- codes that are not apparent in most assemblers. The STA instruction in the absolute mode has one opcode for non- zero page addressing and another for zero page address- ing. Thus, STA instructions for $100 and higher are in- terpreted as machine opcode $8D, but for locations of $0FF and lower, the machine opcode $85 is used. Zero- page addressing saves one byte compared with non-zero page addressing since the operand address is one byte ($FF or less.) Since the Kids' Assembler has a one-to-one correspondence between assembler opcode and machine opcode, it is necessary to have special opcodes indicating a zero-page operation, indicated by '-Z' extenders. This method was used on the Append and Link programs in this chapter already. KIDS' ASSEMBLER - INDEXED INDIRECT ADDRESSING ADRS OPCODE OPERAND 49152 JSR $E544 LDY# 65 STY $C100 LDA# $00 STA-Z $FB LDA# $01 STA-Z $FC LDX# $0 (LDA-X) $FB JSR $E716 RTS The above program is a pretty weird way to get a crummy 'A' printed to the screen. However, it shows what must be done to set up indexed indirect addressing. First, the target address must be 160 given a value to use. Second, the low and high byte of the target ad- dress must be stored in zero-page. Finally, the X Register must be given a value. After that is done, indexed indirect addressing is possible. When you begin using tables of numbers, you can use the X Register as an indirect pointer to the table. In the meantime, I wouldn't spend a lot of time trying to use this mode. INDIRECT INDEXED ADDRESSING (Y Register Only) The final addressing mode we will discuss in this chapter is in- direct indexed. Like the indexed indirect, indirect indexed address- ing uses a zero-page pointer. However, instead of using the X register, it uses the Y. Also, instead of pointing to a series of ad- dresses in zero-page, it points to a single address offset by the value of Y. This addressing mode is much easier to use since it involves only two bytes of zero-page. The following outlines the mode: ADDRESS = POINTER STORED IN ZERO PAGE + X REGISTER VALUE = LOCATION OF ADDRESS For example, let's say you have pointers stored in $FB-$FC (251-252). They have the following contents: $FB-$FC $D1 $C0 Stored in low-byte / high-byte configuration, the base target ad- dress is $C0D1. In the indirect indexed mode, the actual address would be $C0D1 + Y Register. Therefore, if the contents of the Y register were 4, the target address would be $C0D1 + 4 or $C0D5. For a table using sequential addresses, this method is useful for ac- cessing those addresses using Y as an offset. The format is, LDA ($FB),Y ^- General (LDA-Y) $FB -<- Kids' Assembler Let's take a look at an example that will take values from three consecutive two-byte addresses and print them to the screen. When you execute the program, 'ABC will appear in the upper left hand corner of your screen. 161 GENERAL INDIRECT INDEXED ADDRESSING LABEL OPCODE OPERANDCOMMENT {Merlin ORG $C000} {Commodore *=$C000} JSR $E544 LDX #$D1 ;Low byte target adrs. STX $FB ;Low byte pointer LDX #$C0 ;High byte target adrs. STX $FC ;High byte pointer LDX #65 ;ASCII A' STX $C0D1 ;Store in first target adrs. INX STX $C0D3 INX STX $C0D5 LDY #$0 ;Set Y to $0 LDA ($FB),Y JSR $E716 INY INY LDA ($FB),Y JSR $E716 INY INY LDA ($FB),Y JSR $E716 RTS {Commodore .END} 162 KIDS' ASSEMBLER - INDIRECT INDEXED ADDRESSING ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDX# $D1 49157 STX-Z $FB 49159 LDX# $C0 49161 STX-Z $FC 49163 LDX# 65 49165 STX $C0D1 49168 INX 49169 STX $C0D3 49172 INX $C0D3 49173 STX $C0D5 49176 LDY# $0 49178 (LDA-Y) $FB 49180 JSR $E716 49183 I NY $FB 49184 INY $E716 49185 (LDA-Y) $FB 49187 JSR $E716 49190 INY 49191 INY 49192 (LDA-Y) $FB 49194 JSR $E716 49197 RTS As we pointed out, you won't be using the indexed indirect and indirect indexed modes much at first. However, one of the best ways to learn assembly language programs is to look at other peo- ple's work. By knowing about these two modes of addressing, you'll be better able to understand what others are doing. In the meantime, though, don't worry about them. You won't need them much at the beginning level. 163 164 CHAPTER 10 LOOPS AND BRANCHES PROGRAM STRUCTURES At the first mention of program structure, a lot of people groan that it's enough just to get the program done and working without having to worry about "structured programming." That's true, and I certainly won't lecture on the merits of structured programm- ing except insofar as it makes life easier. All I want to do here is to explain the fundamental structures in all programming. There are only three! SEQUENTIAL So far, all we have dealt with in assembly programs is the se- quential arrangement of instruc- tions. Each instruction is ex- ecuted one-after-the-other. It's like climbing a ladder one rung at a time going in the same direc- tion. Sequence 165 LOOPS A loop is the second struc- ture. At a certain point in the program, the program goes back to an earlier part and does it all over again. Most loops have "escape clauses." That means that after executing the loop a given number of times or meeting some other condition, such as reading a keypress, it ex- its the loop and goes on to the next sequential instruction. You're familiar with the FOR/ NEXT loop in BASIC. BRANCHES A branch occurs when the program can take two or more courses of action. If one set of conditions is met, then the pro- gram jumps to one place in the Branch ' 1 i^ Decision ^ ' 1 Task X TaskY ' n ' program, and if another set of conditions is met; then it jumps to another. The IF/THEN statement and GOTO and GO- SUB statements in BASIC are example of branch structures. 166 That's all there is to structure in programming. (Well, almost.) It's painless, and as we will see, very important to make your job of programming easier. HOW BASIC LOGIC WORKS IN ASSEMBLY LANGUAGE Remember that the fundamental difference between BASIC and assembly language programming is that you have to provide more information in assembly language than you do in BASIC. Other- wise, both use the same structures and logic. We've already seen how sequential structure works in both types of programming. For example, to clear the screen and print the letter 'A' to the screen, the following two structures are used: Sequence BASIC 10 PRINT CHR$(147) 20 PRINT "A" Assembly JSR $E544 LDA #65 JSR $E716 RTS There's really not a lot of difference in the amount of work you have to do for either. However, to print 'ABC to the screen, there's a big difference in the effort involved in sequential programming: BASIC 10PRINTCHR$(147) 20 PRINT "ABC" 167 Assembly JSR $E544 LDA #65 JSR $E716 LDA #66 JSR $E716 LDA #67 JSR $E716 RTS With math programs there is even a bigger difference in the amount of work involved, but we'll get to that in the next chapter. For now, it is enough to see that sequential structures in BASIC take a lot less programming than in assembly language programm- ing. LOOPING TO SAVE PROGRAMMING TIME Let's say you wanted to print the alphabet to the screen. In BASIC you could do something like the following: 10 PRINT "A" 20 PRINT "B" 30 PRINT "C" etc. However, you'd probably use a loop and enter something like the following: 10 FOR X = 65 TO 90 : PRINT CHR$(X); : NEXT X You use the loop structure because it takes a lot less time to program and does the same thing as separate PRINT statements. In other words, it's a smarter way to structure your program. Now, if you can save steps in BASIC using loops, just think of what you can save in assembly programming! Remember, since you have to give a lot more instructions to get something done in 168 assembly language, if you could use those same instructions in a loop, you could do a lot more with less code. The question is, "How?" The best way to think of a loop in assembly language programming is as a "branch back." In BASIC when your program encounters a NEXT statement, it is really tell- ing the program to "branch back" to the FOR statement. Second- ly, there must be some kind of comparison or test to exit the loop; otherwise you'd be stuck in an endless loop. With the BASIC FOR/NEXT statement, the test is the top of the loop, (i.e., The last number in the FOR statement.) In summary, the loop would look as follows: 1. BEGIN LOOP 2. COMPARE FOR MATCH OR NO MATCH 3. IF NO MATCH GO BACK TO BEGINNING OF LOOP 4. OUT OF LOOP Let's look at that in a BASIC program using a GOTO loop and IF/THEN comparison to print the alphabet instead of the FOR/NEXT statements: 1© X = 65 : REM INITIALIZE X 20 PRINT CHR$(X) : REM BEGIN LOOP 30 X = X + 1 : REM INCREMENT X 40 IF X <> 90 THEN GOTO 20 : REM COMPARE AND LOOP 50 PRINT "ALL DONE" Now all we need are opcodes to Compare and Branch. For com- parison, we will use the following three: Compare OPCODES CMP Compare value with accumulator CPX Compare value with X register CPY Compare value with Y register Next, we need Branch opcodes. 169 Branch OPCODES BNE Branch not equal - <> BEQ Branch if equal - = Now, let's take a look at the equivalent assembly program to the last BASIC one: GENERAL - ALPHABET LOOP LABEL OPCODE OPERAND COMMENT {Merlin ORG $0000} {Commodore *=$C000} LOOP JSR $E544 LDX #65 initialize X with 65 - ASCII A TXA JSR $E716 INX ; Increment X CPX #91 ; Compare X with 91 BNE LOOP ; If X <>91 then branch back to LOOP RTS 170 KIDS' ASSEMBLER - ALPHABET LOOP ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDX# 65 49157 TXA 49158 JSR $E716 49161 INX 49162 CPX# 91 49164 BNE 49157 49166 RTS Now the first thing to notice in the programs is the different ways in which the branch was used. Generally, assemblers will have pro- visions for a LABEL field. In that field you can label your lines, with the label serving as an address. In the Kids' Assembler, since it has no label field, you have provide the address to the branch. (That's one of the reasons the Kids' Assembler gives you the ad- dresses as you program.) = = A BRANCH TOO FAR= = At this stage of the game, you won't be likely to try a branch that leaps more than a few addresses. If you do branch more than 128 bytes backwards or 127 forward, you'll get in trouble. All branch instructions are coded as branch offsets between 0-255 ($0-$FF) in machine code and not as addresses. That's why the branch instructions are only two bytes instead of three. There is a trick to branching further forward or backwards than 127 or - 128 by inserting a JMP instruction within the range of your branch. However, you won't need it for the pro- grams in this book. At the beginning of this chapter we looked at a program in assembly language that printed 'ABC to the screen. It took eight lines of code since we had to keep putting new values in the ac- 171 cumulator with LDA and then jumping to the screen output routine. In the last program, we printed all 26 letters of the alphabet also using eight lines. In other words, we were able to do almost nine times the output with the same amount of code. As you can see, using the loop structure saved us a lot of time. INDEXING WITH LOOPS In the Chapter 9, we examined indexed addressing with the X and Y registers. Using indexed addressing we saved a little programming time since we could increment our base address with X or Y and didn't have to figure it out every time we wanted to use the next ad- dress. With loops, however, we can really do a lot with indexed ad- dressing. Take a look at the following assembly program to see how we can send information to the sequential addresses of the screen very easily. LABEL OPCODE OPERANDCOMMENT {Merlin ORG $C000} {Commodore *=$C000} JSR $E544 LDX #0 LDY #1 START TYA STA 55296,X TXA STA 1024.X INX CPX #255 BNE START RTS {Commodore .END} 172 ADRS KIDS' ASSEMBLER OPCODE OPERAND 49152 JSR $E544 49155 LDX# 49158 LDY# 1 49161 TYA 49162 STA-X 55296 49165 TXA 49166 STA-X 1024 49169 INX 49170 CPX# 255 49173 BNE 49161 49175 RTS The loop allowed us to use the base address for the character and color screen, and indexing by X, store all 255 characters to the screen. Using the Y value, we did the same thing with the correspon- ding color addresses on the screen. The next programs we will examine, show us two things. First, after running the BASIC version of the program, you will see the in- credible speed of a machine language program that does exactly the same thing. Secondly, you will see how we can use several address bases within a loop to speed things up. Since the A,X and Y registers can only hold 255, by having offsets from the base ad- dresses, we can put these offsets in our program to access more than the base address + 255, indexed by the X register. (Be sure to run the BASIC program first, so that you can see what is happening on the screen.) BASIC - FILL SCREEN 10 PRINT CHR$(147) 20 FOR X = TO 249 30 POKE 55296 + X,X : POKE 55546 + X,X 40 POKE 55796 + X,X : POKE 56046 + X,X 60 POKE 1024 + X,X : POKE 1274 + X,X 70 POKE 1524 + X,X : POKE 1774 + X.X 80 NEXT 173 GENERAL - FILL SCREEN LABEL OPCODE OPERAND COMMENT {Merlin ORG $C000} {Commodore * = $C000} JSR $E544 LDX #0 LOOP TXA STA 55296.X ;Base color addrs. STA 55546.X STA 55796.X STA 56046.X STA 1024.X ;Base screen addrs. STA 1274.X STA 1524.X STA 1774.X INX CPX #250 ;Compare X value with 250 BNE LOOP RTS {Commodore .END KIDS' ASSEMBLER - FELL SCREEN ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDX# 49157 TXA 49158 STA-X 55296 49161 STA-X 55546 49164 STA-X 55796 49167 STA-X 56046 49170 STA-X 1024 49173 STA-X 1274 174 49176 STA-X 1524 49179 STA-X 1773 49182 INX 49183 CPX# 250 49185 BNE 49157 49187 RTS We used the value 250 for our test so that we could use four equal blocks to fill the 1000 addresses of our screen. Also notice that we used the same values for our color codes as the character codes. NESTED LOOPS In addition to using loops in assembly language just as you can in BASIC, so too can you use nested loops. Like regular loops, nested loops can save you a lot of programming time. For example, in our last program, we had to put four base addresses as offsets for the in- dexed addressing we were using to fill up the screen. The reason we had to do that was because of the 255 ($FF) limitation in the X register. If the X register could hold 1000, we could have been able to use a single base address for the character and color bases. Using a slightly different example, we will now look at a way to fill up your screen with printable characters using nested loops. Since the JSR $E716 routine outputs to screen in sequential order, as long as we JSR $E716 1000 times, we can fill the screen. Now we know that the X and Y registers are limited to 256 (0-255) before they burp and fall over, but by using both registers and nested loop- ing, we can get up to 256 x 256 ($FFFF) passes through a loop. Let's start with a BASIC program so we can leisurely watch it and then do the same with an assembled machine language program. Notice how in all cases, the second loop is inside the first loop. (We only used ASCII 33-127 to output since the others are color changers and screen scramblers.) 175 BASIC - NESTED LOOP 10 PRINT CHR$(147) 20 FOR Y = TO 9 : REM LOOP1 30 FOR X = 33 TO 127 : REM LOOP2 40 PRINT CHR$(X); 50 NEXT X : REM BRANCH TO LOOP2 60 NEXT Y : REM BRANCH TO LOOP1 GENERAL - NESTED LOOP LABEL OPCODE OPERAND COMMENT {Merlin ORG $C000} {Commodore * = JSR $E544 LDY #0 LOOP1 LDX #33 LOOP2 TXA JSR $E716 I NX CPX #127 BNE LOOP2 INY CPY #10 BNE LOOP1 RTS KIDS' ASSEMBLER - NESTED LOOP ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDY# 49157 LDX# 33 49159 TXA 49160 JSR $E716 49163 INX 176 49164 CPX# 127 49166 BNE 49159 49168 INY 49169 CPY# 10 49171 BNE 49157 49173 RTS You may have noticed the the program was a little slower than our last one. That was because the JSR $E7 16 takes more time than a simple STA. The JSR involves executing a subroutine and return- ing, while the STA is a single machine language instruction. BRANCHING FORWARD WITH JMP, BEQ AND BNE As we have seen with our loops, the branching that occurs is all backwards. You might ask, "Why jump forward? Why not com- plete a task, either with or without a loop and then go on to the next part of the program? ' ' The essence of good programming is what's called a "Top Down" structure. You begin at the beginning and proceed in an orderly, sequential fashion to the end of the program. Jumping all over the place is called "spaghetti" programming. Essentially, structured programming looks like the following: TASK1 ^CHECK^ ALL DONE? (YES/NO) - NO: GO BACK AND FINISH - YES: GO ON TO NEXT TASK TASK 2 ^CHECK^ ALL DONE? (YES/NO) - NO: GO BACK AND FINISH - YES: GO ON TO NEXT TASK TASK END ^CHECK^ ALL DONE? (YES/NO) - NO: GO BACK AND FINISH -YES: EXIT PROGRAM 177 '\ Unstructured program Using structured programm- ing techniques, you can save a lot of time and have your pro- grams run better. However, treat structured programming techniques as tools and not religion! The Top-Down struc- ture is important, but there are exceptions to its strict interpreta- tion. Every time you JSR to a subroutine, you leave the se- quential path, and there will be instances where a task is ac- complished in an unstructured fashion. Just remember though, the more structured your pro- gram the easier it is to write, run and debug. 1 TASK1 The following situation is a common one in assembly language programming: In TASK 1 , your program loops until the exit condition is met. Depending on the outcome of the loop, your program will branch to Path 1 or Path 2. If it goes to Path 1 , you do not want it to go through Path 2 as well. This is where the JMP instruc- tion comes in. If your program is to branch to Path 2, you can simply JMP, BEQ or BNE to Loop Task the beginning of Path 2. How- ever, if you take Path 1, you're probably going to have to take an unconditional jump using the JMP instruction. Look at the following program: ■o 178 In TASK 1, your program loops until the exit condition is met. Depending on the outcome of the loop, your program will branch to Path 1 or Path 2. If it goes to Path 1, you do not want it to go through Path 2 as well. This is where the JMP instruction comes in. If your program is to branch to Path 2, you can simply JMP, BEQ or BNE to the beginning of Path 2. However, if you take Path 1, you're probably going to have to take an unconditional jump using the JMP instruction. Look at the following program: LABEL OPCODE OPERAND COMMENT LDX #0 LOOP INX CPX $C200 ;Keep looping until X= con- tents of $C200 BNE LOOP CPX $8000 ;After loop is X= contents of $8000? BEQ PATH2 ;lf equal then PATH2 PATH1 INX TXA JSR $E716 JMP END ;Jump over PATH2 to end PATH2 DEX TXA JSR $E716 END RTS In the above program, locations $C200 and $8000 have variable values stored. The X register is incremented until it is equal to the contents of $C200. When X equals that amount, X is compared with the contents of $8000. If they're equal, the program takes PATH2; otherwise it takes PATH1. At the end of PATH1, it JuMPs over PATH2 to the END of the program. (The above pro- gram is hypothetical to illustrate a point. If you want to run it, pro- vide values for $C200 and $8000.) 179 In Chapter 12 when we discuss interacting with a program from the keyboard, you'll be using JMP and BEQ more frequently. In the meantime, let's look at a little program that uses both BEQ and JMP. GENERAL - BEQ AND JMP LABEL OPCODE OPERAND COMMENT {Merlin ORG $C000} {Commodore * = $C000} START END LDX #65 TXA JSR $E716 CMP #90 BEQ END INX JMP STAR1 RTS KIDS' ASSEMBLER ADRS OPCODE OPERAND 49152 LDX# 65 49154 TXA 49155 JSR $E716 49158 CMP# 90 All the program does is print the alphabet to your screen by in- crementing X until it reaches the value 90. We could have done the same thing with BNE and used less code, but it did allow us to place the INX after the comparison and branch instructions. The main point of the program was to illustrate how BEQ and JMP work. 180 SUMMARY The main point of this chapter was to show you ways to make assembly language programming easier. Just as in BASIC where you can cut down considerably on the amount of work you do by using loop structures, loops in assembly language save you a good deal of time as well. Perhaps the most important thing to remember is using loops with X and Y indexed addressing. The base address of a block of RAM can be accesses with a minimal amount of program code. Overall, you can think of the three structures in programming, sequential, loop and branch, in the same way you would in BASIC. In solving a programming problem, use the same structural tools you would in BASIC. The substitution is in the instructions you give; not the fundamental logic of those structures. In the next chapter, we will take a look at some additional instructions that can be used to structure your program and save you time. 181 182 CHAPTER 11 ADDING AND SUBTRACTING INCREMENTING AND DECREMENTING MEMORY : INC AND DEC We saw that we could increase or decrease the value of the X and Y registers with INX, INY, DEX and DEY. By using the X and Y registers, we could indirectly increase or decrease the value in memory. For example, the following program would increment the contents of location $C100 using the X register: LABEL START OPCODE OPERAND LDX #$0 STX $C100 INX CPX #$FF BNE START RTS That method works fine, and the same could be done with the Y register and decrementing values as well. However, there will be oc- casions when you will want to use the X or Y registers for something else while incrementing or decrementing values. For example, sup- pose you want to use the X register for an inside loop, the Y register 183 for an outside loop, incrementing both registers but you wanted to decrement the values in a series of addresses. The INC instruction simply increments the value of the target ad- dress by one in the absolute mode. For example, if location $C100 contained the value 5, INC $C100 would increment the value in $C100 to 6. Similarly, if DEC had been used, the value would be decreased by 1 to 4. To see how INC works, we'll write a program that will run through the alphabet for us. (Nothing new, but it shows us what's happening. Wait'll we get to graphics and use these instructions!) GENERAL - ABSOLUTE INC LABEL OPCODE OPERANDCOMMENT {Merlin ORG $0000} {Commodore *=$G000} LDA #64 STA $C100 INC $C100 LDA $C100 JSR $E716 CMP #90 BNE START RTS .END} KIDS' ASSEMBLER - ABSOLUTE INC ADRS OPCODE OPERAND 49152 LDA# 64 49154 STA $C100 49157 INC $C100 184 49160 LDA $C100 49163 JSR $E716 49166 CMP# 90 49168 BNE 49157 49170 RTS In the above example, we used INC in the absolute mode. Both INC and DEC opcodes can be used in the indexed addressing mode as well. For example, if we changed the above program, we could INCrement a whole series of addresses with $C100, as the base. Fill with INC LABEL GENERAL - INDEXED INC OPCODE OPERANDCOMMENT {Merlin ORG $C000} {Commodore * = $C000} LDX #0 LDA #64 STA $C100 START INC $C100,X LDA $C100,X JSR $E716 INX CPX #90 BNE START RTS {Commodore .END} KIDS' ASSEMBLER - INDEXED INC ADRS OPCODE OPERAND 49152 49154 49156 LDX# LDA# STA 64 $C100 185 49159 INC-X $C100 49162 LDA-X $C100 49165 JSR $E716 49168 I NX 49169 CPX# 90 49171 BNE 49159 49173 RTS The results of this program may surprise you. At first, you may have thought you'd get the alphabet printed to the screen and then stored in sequential addresses from $C100-$C11A (49408-49434). That would make a nice table, but that's not what we got. Instead, as you can see from the mess on your screen, after getting the 'A' as expected, the rest is garbage. The reason for that lies in the fact that we were changing the addresses and INCrementing each new ad- dress by 1 . Thus, while we stored the value 64 in $C100 and then in- cremented it by 1 to get 65 (the 'A' you saw on your screen), we then INCremented $C101, which was empty (or full of junk) by 1. That junk was sent to the accumulator and output to the screen. We'll need some new instructions to get what we need. (I'll bet you're smart enough to figure out how to get the alphabet stored in a table without any new instructions, though. Have the Y register help you out.) ADDING AND SUBTRACTING IN THE ACCUMULATOR : ADC AND SBC The ADC and SBC allow you to ADd to the accumulator with Carry or SuBtract from the accumulator with Carry. Instead of in- crementing or decrementing with transfers from the X or Y registers or memory, you can add and subtract as much as you want in just about all modes. The statement, ADC #09 adds + 9 what whatever is in the A register. In the absolute mode, ADC $C100 186 adds the contents of location $C100 to your accumulator. For ex- ample, the following program will print 'AZ' to your screen by adding 25 to the accumulator which already contains 65: GENERAL - INDEXED ADC LABEL OPCODE OPERAND COMMENT {Merlin ORG $C000} {Commodore * = $CO00} LDA #65 JSR $E716 ADC #25 JSR $E716 RTS {Commodore .END} KIDS' ASSEMBLER - INDEXED INC ADRS OPCODE OPERAND 49152 LDA# 65 49154 JSR $E716 49157 ADC# 25 49159 JSR $E716 49162 RTS USING CLC AND SEC With a single ADC instruction, we can make giant leaps instead of relying on a series of INX's, INY's or INC's. However, when we start to use a series of ADC's, it's necessary to clear the carry flag. (In fact it's a good idea whenever ADC is used.) To do that, you simply use the sequence shown in the following example: CLC ADC #$D3 187 The reason for clearing the carry flag (the C flag - remember NV SDIZC?) is because the carry flag may have been set by some other operation. When you ADd with Carry, you add the in- tended number along with the Carry if it is set. For example, a JSR to an output routine may set the carry flag. In the follow- ing program where the accumu- lator is incremented by two each time the program loops, the CLC instruction makes sure that the contents of the accumulator are incremented only by two and not two plus the carry. If you want to see the results without CLC, delete the CLC instruc- tion and place the START label in the ADC line. GENERAL - ADC BY TWO'S LABEL OPCODE OPERAND COMMENT {Merlin ORG $0000} {Commodore *=$C000} ******************************************** * * ADC BY TWO'S * * ******************************************** START JSR $E544 LDA #63 CLC ADC #2 JSR $E716 188 CMP BNE RTS {Commodore .END} #89 START KIDS' ASSEMBLER - ADC BY TWO'S ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDA# 63 49157 CLC 49158 ADC# 2 49160 JSR $E716 49163 CMP# 89 49165 BNE 49157 49167 RTS = = GETTING FANCY = = We used a box of stars (asterisks) in our general assembler program to show you how to give your source code a hot- shot header. On most assemblers, if the first character is a semi-colon, the entire line is read as a comment. It's sort of like having REM statements use entire lines for headers in BASIC programs. On the Merlin Apprentice assem- bler, you don't even need the semi-colon. If your first en- try is CTRL-P, you'll get a line of stars. If you hit the space bar and press CTRL-P the first and last spaces will get stars. It helps to have headers so that you can quickly see what the source code is for. This is especially true if you're working with a lot of different assembly language programs. It is also a good idea to put the date in the header so that you will know when you last worked on the program. With larger programs, you may make several versions, and the dates will keep you posted on which ver- sion you have in the editor. 189 Now, this next part is weird; so put down your root beer and listen up. When we want to ADC, it's important to clear the carry flag with CLC. However, when we subtract from the accumulator with SBC we want the carry flag set; so we use SEC to set the carry flag. The reason for this is that in subtraction, the set carry flag is treated as though no borrow is taken; just the reverse of ADC. What you're really doing is called "two's compliment" addition since that's the way your 65 10 can best handle subtraction. It sort of uses the carry flag to "add backwards." Rather than losing sleep over the process, just remember: SUBTRACT - SEC Use the format in the following example: SEC SBC #$08 Okay, we're all set to use subtract. We'll go backwards in the alphabet printing only every third character. In that way you can see how the process works. GENERAL - SBC BY THREE'S LABEL OPCODE OPERAND COMMENT {Merlin ORG $C000} {Commodore * = $C000} ******************************************** * * SBC BY THREE'S * * START JSR $E544 LDA #93 SEC ;Set the Carry SBC #3 ;Subtract 3 from the accumulator JSR $E716 CMP #66 190 BNE RTS {Commodore .END} START KIDS' ASSEMBLER - BY THREES ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDA# 93 49157 SEC 49158 SBC# 3 49160 MSR $E716 49163 CMP# 66 49165 BNE 49157 49167 RTS SUMMARY This has been a short chapter, but we learned some important new instructions for adding and subtracting numbers. We did not tackle the more difficult problems of dealing with numbers larger than 255 ($FF) since that gets a little hairy. If you want to add 2 + 2, stick with BASIC for the time being, and the same is even truer when dealing with multiplication and division. Larger numbers can be handled in assembly language using two addresses, and when you become more advanced, you'll learn either how to use JSR's to BASIC subroutines or how to write your own arithmetic programs. As you will see, we'll have our hands full just dealing with values a single register or address can handle. 191 192 CHAPTER 12 INTERACTING WITH ASSEMBLY LANGUAGE PROGRAMS Introduction Up to this point we've been concentrating on the fundamental in- struction set in 6510 assembly language. Everything we've done has been "locked" into the program. That is, we have no way outside of writing the actual program of affecting what course of action the program will take. When the program is SYSed, it takes a pre- determined course the user cannot influence while the program is running. What we've done so far is similar to programming in BASIC without INPUT or GET statements. In this chapter, we're going to turn our attention to some simple I/O (input/output) routines. These will give you some real programming power, and you won't have to learn any new opcodes. All commercial software "interacts" with the user. When you play an arcade game or use a word processor, your input affects what the program does. For example, in arcade games, the program takes its input from paddles or joysticks. If you press a button, your game fires a missile, and if you move the joystick to the left, your character moves to the left. Similarly, in word processing, your keyboard is the primary input device. Your program stores the in- 193 formation supplied by the keystrokes, and that information will be different depending on what keys you hit. Fortunately, there are several built-in routines for handling I/O, and while these routines may use some very complicated and sophisticated code, all you are going to have to do is to know when to JSR to these subroutines. There are a number of "formulas" you'll have to learn since jumping to these subroutines can affect other parts of your program, but these formulas are fairly simple and direct. Moreover, we will concentrate only on those subroutines that affect input from the keyboard, joysticks or game paddles. We will not deal with tape or disk I/O. Since we have already dealt ex- tensively with output in our examples of printing characters to the screen, most of this chapter will concentrate on input. READING INPUT FROM THE KEYBOARD Have you ever wondered what actually happens when you press a key? You know that your computer handles everything in binary configurations, and so if you press the 'K' key, a big 'K' doesn't go floating into your computer and up to the screen. We'll break down what happens when you press the letter 'K' to show you the path from the keyboard to your screen. 1. Scan the keyboard. 2. Get the character from the keyboard and put it in the A register 3. See if the key is null (no key has been pressed) 4. If the key is null, go back to Step 1 and scan again. 5. Print the character in the A register to the screen. Since we have sent ASCII characters from the A register to the screen by storing them on the screen or JSRing to an output routine, we already know how to do the last part. What we need is a routine to scan the keyboard and to get it from the keyboard to the ac- cumulator. To do that we will use Kernal routines, SCNKEY and GETIN. The SCNKEY subroutine is located at $FF9F (65439) and the GETIN routine at $FFE4 (65508). For output, instead of using 194 $E716, we'll use CHROUT (Character Out) at $FFD2 (65490). Thus, our sequence of subroutines will be: 1. SCNKEY - Scan the keyboard 2. GETIN - Put the key value in A register 3. CHROUT - Output the character to the screen Knowing that, we can try out a routine that will print characters to the screen based on keyboard input: = = LABEL YOUR SUBROUTINES = = With most assemblers, (not the Kids' Assembler, though) it is possible to define and label subroutines. Then when you want to use a subroutine, instead of doing a JSR to the specific address, the JSR is to the subroutine label. For example, instead of, JSR $E544 you can, JSR CLEAR This method is more descriptive and easier to remember than memorizing all the different addresses that contain the subroutines. Unfortunately the Kids' Assembler does not have a label field, but most other assemblers do. GENERAL - KEYBOARD TO SCREEN I/O LABEL OPCODE OPERAND COMMENT {Merlin ORG $C000} {Commodore *=$C000} {Commodore} CLEAR =$E544 SCNKEY =$FF9F 195 GETIN = $FFE4 CHROUT = $FFD2 {Merlin} CLEAR EQU $E544 SCNKEY EQU $FF9F GETIN EQU $FFE4 CHROUT EQU $FFD2 JSR CLEAR SCAN JSR SCNKEY ;Look to see if key is pressed JSR GETIN ;Put key value in accumulator BEQ SCAN ;Compare with zero JSR CHROUT ;lf not zero print to screen RTS {Commodore .END} <** KIDS' A SSEMBLER KEYBOARD TO SCREEN I/O + Scanning Keyboard ADRS OPCODE OPERAND 49152 JSR $E544 49155 JSR $FF9F 49158 JSR $FFE4 49161 BEQ 49155 49163 JSR $FFD2 49166 RTS 196 The program involves only two instructions, not counting the RTS. Comparing the code in the Kids' Assembler with the assemblers using labels, you can see how much clearer it is using labels. When we start doing more forward jumps and branches, the labels are almost indispensable. (Be sure to note the different ways that the Commodore assembler and Merlin handle labels.) Since the program only printed out a single character before end- ing, we didn't get a chance to do much. What we need is a program to keep reading the keyboard until a certain key is pressed to let us know it's time to quit. We'll write a program that prints the key pressed to the screen until RETURN is pressed. This will involve a double comparison. 1. Compare key with null 2. Compare key with RETURN. When you run this program, be sure to try out your CTRL keys was well as you regular keys. Turn on the RVS (reverse) and take it through its paces. (If you're smart and you're using a decent editor/assembler, instead of rewriting the whole thing from scratch, you'll just edit the last program to make this one. From this point on, especially when you're writing your own original programs, you will begin to see the severe disadvantages of the Kids' Assembler. Instead of blowing your money on an arcade game, next time you got a few bucks to spend, get a good assembler.) GENERAL - READ RETURN LABEL OPCODE OPERAND COMMENT {Merlin ORG $0000} {Commodore *=$C000} {Commodore} CLEAR = $E544 SON KEY = $FF9F GETIN = $FFE4 CHROUT = $FFD2 197 {Merlin} CLEAR EQU $E544 SCNKEY EQU $FF9F GETIN EQU $FFE4 CHROUT EQU $FFD2 JSR CLEAR SCAN JSR SCNKEY JSR GETIN BEQ SCAN CMP #$0D ;Compare with ASCII for RETURN (13) BEQ END ;Jump to end of program if RETURN is pressed JSR CHROUT JMP SCAN ^^^. END RTS h->^2h {Commodore .END} .' Label : J^flfc I Subroutines^ HI KIDS' ASSEMBLER - READ RETURN ADRS OPCODE OPERAND 49152 JSR $E544 49155 JSR $FF9F 49158 JSR $FFE4 49161 BEQ 49155 49163 CMP# $0D 49165 BEQ 49173 49167 JSR $FFD2 49170 JMP 49155 49173 RTS 198 Now we can see how we can have one of two branches using the keyboard. If we press any key other than RETURN, we'll get the character or the special effects, such as color change or reverse, on the screen. We loop through the SCAN very much like we'd use the GET statement in BASIC. 10 GET A$ : IF A$ = "" THEN 10 We just keep looping until we get something other than a null. Then, like BASIC, we use the IF/THEN logic to either print the character and go get another one or quit. The same thing in BASIC would look like the following: 10 GET A$ : IF A$ = "" THEN 10 20 IF A$ = CHR$(13) THEN END 30 PRINT A$: GOTO 10 Now that we have learned how to use IF/THEN logic with infor- mation from the keyboard and can branch in more than one direc- tion, let's use several branches. While we're at it, we'll also supply a prompt and do something other than just printing characters to the screen. A simple routine we already have used is changing the background color on the screen with a JSR to $D021. Instead of entering the color value, we'll enter a letter value for the color and have a subroutine supply the color value. (We're really getting hot.) First of all, how do we make a prompt? Since the prompts tell us what to do, they're very important in programs. In BASIC, using the GET statement, we simply use PRINT. For example, 10 PRINT "PRESS A KEY " 20 GET A$ : IF A$ = "" THEN 20 30 PRINT A$: GOTO 10 asks you to PRESS A KEY and then prints it to the screen. Since we know that whatever is in the accumulator will be printed to the screen with a JSR to CHROUT ($FFD2) all we have to do is to load up the accumulator with our prompt and print it to the 199 screen. We're going to change the color of the screen; so we'll use COLOR? as our prompt. Once we have the prompt, we can use our SCNKEY and GETIN subroutines to read the keyboard and put the results in the ac- cumulator. Now, since we want to change the background color, we will JSR to $D021. However, the background colors 0-15 re- quire CTRL keys, and we want to use regular keys. To keep it relatively simple, we'll just change to background colors to (R)ed or (G)reen. If 'R' is pressed, the background will turn red and 'G' will turn it green. Also, to get out of the program, RETURN will cause an exit. Otherwise, the program will do nothing. Thus, we will have branches on the following: 1. IF RETURN (ASCII = $©D or 13) is pressed THEN goto the end of the program. 2. IF an R (ASCII = 82) is pressed THEN put a 2 in loca- tion $D021. 3. IF an G (ASCII = 71) is pressed THEN put a 5 in loca- tion $D021. Using the labels END, RED and GREEN it is very simple to indicate where our branches are going and what they are do- ing. This is why the Kids' Assembler is difficult. You have to figure out the address to branch aheadbefore that address is on the screen. This means that you have to determine the number of bytes that will be used in the program lines so that you will have the right address on a forward branch. Using the LABEL field, however, all you have to do is to put in the label name in the operand, and when you get to the subroutine, use that label at the beginning of the line. (Using the Kids' Assembler, though, you'll really understand what's going on inside your machine. This will turn you into a "mean" assembly language programmer and make programming with a good assembler a snap.) 200 GENERAL - RED/GREEN BACKGROUND LABEL OPCODE OPERAND COMMENT {Merlin ORG $C000} {Commodore *=$C000} • * ; * RED/GREEN BACKGROUND . ****************************************** {Commodore} CLEAR = $E544 SCNKEY = $FF9F GETIN = $FFE4 CHROUT = $FFD2 BKGND = $D021 {Merlin} CLEAR EQU $E544 SCNKEY EQU $FF9F GETIN EQU $FFE4 CHROUT EQU $FFD2 BKGND EQU $D021 JSR CLEAR LDA #67 C JSR CHROUT LDA #79 JSR CHROUT LDA #76 L JSR CHROUT LDA #79 JSR CHROUT LDA #82 R JSR CHROUT LDA #63 ? JSR CHROUT LDA #0 Null the accumulator 201 SCAN JSR SCNKEY JSR GETIN BEQ SCAN CMP #$0D ;Was RETURN pressed BEQ END ;lf so, goto END CMP #82 ;WasR pressed? BEQ RED ;lf so, goto RED CMP #71 ;Was G pressed BEQ GREEN ;lf so, goto GREEN JMP SCAN ;lf none of the above, go get another key RED LDA #2 ;Color code for RED background STA BKGND JMP SCAN GREEN LDA #5 ;Color code for GREEN background STA BKGND JMP SCAN ;Go get another key END RTS {Commodore .END} KIDS' ASSEMBLER - RED/GREEN BACKGROUND ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDA# 67 49157 JSR $FFD2 49160 LDA# 79 49162 JSR $FFD2 49165 LDA# 76 202 49167 JSR $FFD2 49170 LDA# 79 49172 JSR $FFD2 49175 LDA# 82 49177 JSR $FFD2 49180 LDA# 63 49182 JSR $FFD2 49185 LDA# 49187 JSR $FF9F 49190 JSR $FFE4 49193 BEQ 49187 49195 CMP# $0D 49197 BEQ 49226 49199 CMP# 82 49201 BEQ 49210 49203 CMP# 71 49205 BEQ 49218 49207 JMP 49187 49210 LDA# 2 49212 STA $D021 49215 JMP 49187 49218 LDA# 5 49220 STA $D021 49223 JMP 49187 49226 RTS NOTICE: If you do not have a joystick, you can skip this next section. However, you may want to go over the part on using the EOR instruction. JOYSTICK CONTROL Using GETIN we can take the value of a keypress and put it in the accumulator. With the joystick however, we do not have a SCNKEY and GETIN routine. Therefore, we will have to build our own. We'll look at reading the joystick in Port 1 and fire button only. However, Port 2 is read in the same way as Port 1 except from a different address. Therefore, if you know how to read the joystick in Port 1, reading it Port 2 is essentially the same. For Port 1, we 203 read the value at address $DC01 (56321) and for Port 2, $DC00(56320). Let's now look to see what happens when you use the joystick and the register at $DC01. Register at $DC01 7 6 5 4 3 2 10 ^-Bit number XXXFRLDU ^-Switch read X = Unused by joystick F = Fire button R = Joystick right L = Joystick left D = Joystick down U = Joystick up Not pressed = 1 Pressed = For example, if the joystick is in a neutral position, all switches are read as "not pressed." Therefore, the register would look like the following: Register at $D< C01 7 6 5 XXX 4 F 3 R 2 L 1 D <+- Bit number U -*- Switch read 1 1 1 1 1 1 1 1 ^- Bit configuration for neutral That's simple enough to read since the register is filled up. We know a single 8 bit register can only hold 255 ($FF) so when the joystick is in neutral, the value read at $D0C1 is 255 or $FF. Now, let's take a look at what happens when we move the joystick to the left. 204 Register at $D' C01 7 6 5 XXX 4 F 3 R 2 1 L D -*-Bit number U ^-Switch read 1 1 1 1 1 1 1 <*- Bit configuration for left. When we press the joystick to the left, Bit #2 is turned off to give us the binary value, 111111011. Unless you're a lot better at reading binary numbers than I am, that's not easy to figure out. The value is 251 ($FB), but I had to do a lot of computations to get it. There's got to be a simpler way to read the $DC01 register. The EOR Instruction To make things easier for ourselves, we're going to learn a new instruction, EOR. This instruction is the mnemonic for "Exclusive OR." This instruction compares bits to see the differences. If there is a difference between two bits, you get a "1", and if there are no differences, you get "0." This serves to "mask" or "filter" values so that they can be handled easier. To see how it works, let's take our last example and see what it looks like EORed with $FF. Register at $DC01 7 6 5 XXX 4 F 3 R 2 L 1 D U ^-Bit number «*- Switch read 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 -^-Bit configuration for left. «*-$FF bit configuration 10 ^- EORed with $FF Now that's a lot easier to figure out. Instead of 251, we have a value of 4. Since bits 7,6 and 5 are not used, we can do relatively quick translations of binary to decimal or hex: 205 16 8 4 2 1 ^-Multiple if "on." 4 3 2 1 «4-Bit number F R L D U 1 1 1 1 1 1 1 1 1 ^-$FF 1 ^-EORed value Looking at the above example, what is the value when the joystick is to the right? If you think the value after EOR with $FF is 8 then you are right. If the fire button is pushed, what would the value be? It would be 16. With the joystick in neutral, we saw that the value was $FF or 255 - all eight bits have a "1". After EOR with $FF you would have the following: Register at $DC01 7 6 5 4 3 2 1 -*- Bit number X X X F R L D U •^-Switch read 11111111 -*• Bit configuration for left. 11111111 ^-$FFbit configuration 00 -*-EORed with $FF Now, neutral is "0", which is a lot easier to remember. . What happens when your joystick is at an angle, such as up-left? Well, let's just stick the numbers in and see what we get. 16 8 4 2 1 ^-Multiple if "on." 4 3 2 1 «*-Bit number F R L D U 110 10 11111 <*-$FF 10 1 ^-EORed value 206 A simple calculation shows that the up-left EORed $FF value to be 5. Thus, we can determine the "angle" values of the joystick in ad- dition to the up, down, left and right directions. You don't have to figure out these values every time you sit down to program, just use the following values as a quick look-up of the EORed joystick values. Joystick Values EORed with $FF • Neutral 1-Up 2 - Down 4 - Left 5 - Up Left 6 ■ Down Left 8 - Right 9 -Upright 10 - Down right 16 - Fire button pressed The following program will let you see the joystick values on your screen. Remembering that the neutral position is zero, we'll have to add 48 to that value to print the ASCII character "0" to the screen. (ASCII 48 = "0" character.) Thus, as you move your joystick around you will see the actual EORed number in the $DC01 register. By using LDA $D0C1 and then EORing the ac- cumulator value with $FF, we put the joystick value into the ac- cumulator. Then by using ADC #48 to add the decimal value 48 to the accumulator and CHROUT, we print it to the screen. GENERAL - JOYSTICK VALUES LABEL OPCODE OPERAND COMMENT {Merlin ORG $C000} {Commodore * = $C000} 207 . irirwiririririrwwww . * WWKWWWWWW1 cwwwwwwwww * . * . * JOYSTICK VALUES * * . ******************************************** {Commodore} JSTICK = $DC01 OFSET = $C100 CLEAR = $E544 FIRE = $C102 CHROUT = $FFD2 {Merlin} JSTICK EQU $DC01 OFSET EQU $C1O0 CLEAR EQU $E544 FIRE EQU $C102 CHROUT EQU $FFD2 JSR CLEAR LDA #$FF ;Value to EOR STA OFSET ;offset LDA #64 ;EORed value of fire button + 48 STA FIRE ;Store here for easy reference START LDA JSTICK ;Read joystick EOR OFSET ;EOR with $FF CLC ADC #48 ;Add 48 JSR CHROUT ;Print modified joystick value to screen CMP FIRE ;ls it the fire button? BEQ END ;lf it is, then quit 208 END {Commodore JMP RTS .END} START ;Go back and read the joystick. KIDS' ASSEMBLER - JOYSTICK VALUES ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDA# $FF 49157 STA $C100 49160 LDA# 64 49162 STA $C102 49165 LDA $DC01 49168 EOR $C100 49171 CLC 49172 ADC# 48 49174 JSR $FFD2 49177 CMP $C102 49180 BEQ 49185 49182 JMP 49165 49185 RTS We designed the program so that it would keep printing values to the screen, and your screen fills up with numbers, scrolling different values as you change the direction of the stick. To exit the program, you press the fire button on your joystick. Now that we can easily read the joystick, let's do something with it. In the next chapter we'll see how to move graphics and sprites with the joystick, but for now we'll just use it to change the background colors. This time, though, we will not use ADC for an offset to the ASCII code. Instead, we'll see what background colors are created with the different joystick positions. 209 GENERAL - JOYSTICK COLORS LABEL OPCODE OPERAND COMMENT {Merlin ORG $C000} {Commodore *=$C000} ******************************************** JOYSTICK COLORS ******************************************** {Commodore} JSTICK = $DC01 OFSET = $C100 CLEAR = $E544 FIRE = $C1002 {Merlin} JSTICK EQU $DC01 OFSET EQU $C100 CLEAR EQU $E544 FIRE EQU $C102 JSR CLEAR LDA #$FF ;Value to EOR STA OFSET ;EOR offset LDA #16 ;EORed value of fire button STA FIRE ;Store here for easy reference START LDA JSTICK ;Read joystick EOR OFSET ;EOR with $FF CMP FIRE ;Fire button pressed? 210 START END {Commodore LDA EOR CMP BEQ STA JMP RTS .END} JSTICK OFSET FIRE END $D021 START ;Read joystick OR with $FF ;Fire button pressed? ;lf it is then quit ;Put joystick value into background color register KIDS' ASSEMBLER - JOYSTICK COLOR ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDA# $FF 49157 STA $C100 49160 LDA# 16 49162 STA $C102 49165 LDA $DC01 49168 EOR $C100 49171 CMP $C102 49174 BEQ 49182 49176 STA $D021 49179 JMP 49165 49182 RTS Again, we used the fire button to exit the program. Unfortunate- ly, we're left with a black screen. You can change it by using ADC #1 so that instead of the neutral position being black, it will be white. MAKING MESSAGES : ASC and .BYTE At the beginning of this chapter we discussed creating prompts. As you may have noticed, it took a lot of code to put a simple pro- mpt like COLOR? on the screen. With most assemblers, there is an 211 easy way to do it using a pseudo-opcode called ASC, .BYTE or some similar pseudo-opcode. Since the Kids' Assembler does not have such codes, we'll write some simple BASIC programs that will allow you to do make prompts and other messages that can be ac- cessed with assembly language programs. The ASC and .BYTE instructions operate something like DATA statements in BASIC. The label in the line with the ASC or .BYTE directives serves as the beginning address for the word in the operand field. For example, the following shows the format for the Merlin and Commodore assemblers respectively, with the starting address being MSG: LABEL OPCODE OPERAND MSG ASC 'MERLIN' MSG .BYTE 'COMMODORE' The string in the operand takes up one byte for each character. Therefore, if MSG were address 49170, the string 'MERLIN' would take up 6 addresses (49170-49175) and the string 'COM- MODORE', 9 addresses, (49170-49178). Using the X register for an index, simply LDA with MSG indexed by X and print each character to the screen with JSR CHROUT. First, we'll look at .BYTE and ASC on the Commodore and Merlin assemblers respec- tively. Both work in the same way, but to avoid confusion, each will be used with a similar but separate example. Reading ASC& .BYTE LABEL COMMODORE - .BYTE OPCODE OPERAND COMMENT = $C000 212 ******************************************** * * .BYTE * * ******************************************** CLEAR = $E544 CHROUT =$FFD2 JSR CLEAR LDX #$0 READ LDA MSG.X ;Load one character JSR CHROUT ; Print to screen CPX #8 ;See if it is the length of message (0-8) BEQ END ;lf it is then end INX increment X to read next character JMP READ END RTS MSG .BYTE 'COMMODORE' .END LABEL MERLIN - ASC OPCODE OPERAND COMMENT ORG $C000 **************************************** ASC * * * * * * * * ******************************************** # 213 CLEAR EQU $E544 CHROUT EQU $FFD2 JSR CLEAR LDX #$0 READ LDA MSG,X JSR CHROUT CPX #5 BEQ END INX JMP READ END RTS MSG ASC 'MERLIN' Another way to read messages is with a "termination symbol." At the end of your message before the closing single quote mark, place a special symbol that is not likely to be part of the message. The pound sign (#) is a good one to use. Then, instead of having to count the characters, you can simply compare the value in the ac- cumulator with the ASCII value for the termination symbol. For example, instead of having, ASC 'MERLIN' we would put, ASC 'MERLIN*' In that way when ASCII 35, the value for the pound sign (#) is load- ed into the accumulator, your program branches out of the READ/PRINT routine. Take a look at the following example on Merlin to see how it works. MERLIN - ASC RELATIVE LABEL OPCODE OPERAND COMMENT ORG $C00O 214 ********************************************* * * ASC RELATIVE * * ********************************************* CLEAR EQU $E544 CHROUT EQU $FFD2 JSR CLEAR LDX #$0 READ LDA MSG,X ;Load one character from MSG CMP #35 ;ls it the pound sign yet? BEQ END ;lf so then end. v JSR CHROUT INX JMP READ END RTS MSG ASC 'MERLIN#' Using this method! you can easily create prompts and other messages to be output to the screen. Whenever you need the message, simply read it into the accumulator and throw it out to the screen. Using several descriptive labels, different messages can be accessed and printed depending on where your program branches. MESSAGE MAKER FOR KIDS' ASSEMBLER It's a pain in the neck to do a mile of LDA#'s and JSR $FFD2's on the Kids' Assembler to get a message out. Since the Kids' Assembler doesn't have ASC or .BYTE, the following BASIC pro- gram gives you a way to stick your message up in memory before you start writing an assembly language program. Essentially, it creates a table with the ASCII values of your message. Be sure to put the message somewhere out of the way of both your assembly language program and BASIC. If you're working up in the 49152 area, put the message table up around 49200 or 49300 for short programs or in 828 for longer programs if you're not using a 215 cassette. Note where you put your message, and then when you write an assembly language program, you simply read that area of memory for your message. The BASIC program automatically ends the message with ASCII 35, the value for a pound sign (#); so don't put any other pound signs in your message or prompt. A se- cond BASIC program checks your message for you. MESSAGE MAKER 10 PRINT CHR$(147) 20Y = 1 30 INPUT'STARTTABLE ";TS 40 INPUT'MESSAGE ";MS$ 50FORX = TSTOTS + LEN(MS$)-1 60S$=MID$(MS$,Y,1) 70 P = ASC(S$) 80 POKE X,P : Y = Y + 1 : NEXT 90 POKE X,35 MESSAGE CHECKER 10 INPUT'START ADDR ";SA 20 P= PEEK(SA) : IF PEEK(SA) = 35 THEN END 30 PRINT CHR$(P); : SA = SA + 1 : GOTO 20 To test this system, use 49200 as the start address for your message. (Write your name or something original like that.) Once you've checked to see the message is in place with your MESSAGE CHECKER program, enter the following and then execute it: KIDS' ASSEMBLER - MESSAGE READ/PRINT ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDX# 49157 LDA-X 49200 49160 CMP# 35 49162 BEQ 49171 49164 JSR $E716 216 49167 I NX 49168 JMP 49157 49171 RTS Now that you see the principle involved in making and storing ASCII messages to be retrieved from an assembly language pro- gram, we'll put together a BASIC program that will make it even easier. Rather than having to write a new message or prompt from our BASIC program every time we need one, why not write and save little "message tables" we can use whenever we need them. In that way, we can load the messages we're going to need into memory, just as we would any assembly language program. By keeping track of different start addresses for each message table and making sure they do not overlap, we can have a whole dictionary of useful messages and prompts. The following program will let you enter a message, and then it will save it. Each message will end with a "termination character", the pound sign (#), so that you can use the CMP# compare-and-branch routine we examined. In that way, you won't have to memorize the length of the message; only its star- ting address. MESSAGE MAKER/SAVER 10PRINTCHR$(147) 20Y=1 30 INPUT'START TABLE ";TS 40 INPUP'MESSAGE ";MS$ 50 FOR X = TS TO TS + LEN(MS$) - 1 60S$ = MID$(MS$,Y,1) 70 P = ASC(S$) 80POKEX,P:Y = Y+1 : NEXT 90 POKE X,35 100SA = TS:MN$=MS$ 110 MN$ = "0:" + MN$ + STR$(SA) + ",P,W" 120 LB = SA - INT(SA/256)*256 130HB=INT(SA/256) 140 OPEN2,8,2,MN$ 150 PRINT#2,CHR$(LB) + CHR$(HB) 160P=PEEK(SA) 217 170 PRINT#2,CHR$(P) 180 IF P = 35 THEN 200 190SA = SA + 1 : GOTO 160 200 CLOSE2 210 END SUMMARY This chapter has shown you how to write assembly language pro- grams that interact with the user. Using either the keyboard or joystick, the programs respond to the user's actions. Then, in turn, by outputting information to the user in the form of prompts and messages, the user knows what to do next. We spent most of our time with ASCII messages since they most clearly demonstrate what's going on in your program and computer. However, as we saw with changing the background colors, there's more we can do with the keyboard and joystick. In the next chapter, we will see how to manipulate all kinds of graphics with interactive programs. 218 CHAPTER 13 HOT GRAPHICS Introduction This chapter will be a lot of fun. From BASIC, you probably have found that a good deal of work with graphics involves POKEs and PEEKs. In other words, most of the really interesting graphics requires machine language programming from BASIC. As a result of having dealt with machine code and graphics already, you will find what we're doing in this chapter pretty familiar. However, in- stead of POKEing and PEEKing, we'll use our assembly language instructions to do much the same thing and do it a lot faster. We'll divide the chapter into two major sections: 1. Low resolution color and graphics 2. Animation In the first section, we'll examine color control and using and changing characters. Since we've already used a lot of examples with background, border and character colors, color control with assembly language will be familiar to you. We will see how by using various characters, we can create low resolution graphics. 219 The second section will cover animation. In BASIC you may have discovered that movement is often slow and jerky, but in assembly language you will actually have to slow down animated objects so that you can see them! We'll have a separate discussion of sprite animation in the next chapter. As an extra machine language related matter, we'll also see how to save a screen to disk as a PRG file. This will allow you to LOAD a screen directly from the disk without having to RUN or SYS The program. LOW RESOLUTION GRAPHICS Low resolution graphics are created using the characters on your keyboard. The pattern of those characters can be thought of as blocks appearing on your screen. Perhaps the best way to see one of these blocks is to print an inverse space to your screen. POKE 55296,1 : POKE 1024,224 That stores the color white in location 55296 and the inverse character for a SPACE in screen location 1024. By lining up the various blocks, changing their color to what you want, you can create low resolution figures. To get started, let's draw a couple of parallel lines in different colors: GENERAL LABEL OPCODE OPERAND COMMENT {Merlin ORG $C000} {Commodore * =$C00©} 220 ******************************************** LOW-RES LINES **.***************************************** {Commodore} BAR1 = 55416 BAR2 = 55496 LIN1 = 1144 LIN2 = 1224 CLEAR = $E544 {Merlin} BAR1 EQU 55416 BAR2 EQU 55496 LIN1 EQU 1144 LIN2 EQU 1224 CLEAR EQU $E544 JSR CLEAR LDX #$0 LDY #2 START LDA #224 STA LIN1.X ;1st line of spaces STA LIN2,X ;2nd line of spaces TYA STA BAR1,X ;1st color of line CLC ADC #5 ;Change color with ADC STA BAR2,X ;2nd color of line INX CPX #39 BNE START RTS 221 KIDS' ASSEMBLER ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDX# $0 49157 LDY# 2 49159 LDA# 224 49161 STA-X 1144 49164 STA-X 1224 49167 TYA 49168 STA-X 55416 49171 CLC 49172 ADC# 5 49174 STA-X 55496 49177 I NX 49178 CPX# 39 49180 BNE 49159 49182 RTS Fat Lines!! We used the X register to in- dex our beginning address to get a straight horizontal line. We started our first line in screen memory 1144 and our second one in 1224. For color, we started the corresponding color addresses at 55416 and 55496. By incrementing our X register from to 39, we were able to draw a line across the screen. Also notice how we used the Y register to get our first color. We never changed the value of Y, and so whenever the program encountered the TYA instruction, it kept putting a 2 (red color code) in the accumulator to be stored on the color screen address. To get the second color (2 + 5=7, color code for yellow), we used ADC. Of course, we could have simply put LDA #7, but that wouldn't have been as weird. 222 To draw different kinds of horizontal lines, try substituting dif- ferent characters for the space. Instead of 224, try 192, 195 226,239,246,248 and 249 to see what happens. Since horizontal lines are so simple, vertical lines ought to be a snap. Unfortunately, it doesn't work quite that way. With horizon- tal lines, we could run one all the way across the screen using the X register as an offset from the beginning address. However, with ver- tical lines, our address jumps from the top of the screen to the bot- tom are greater than 255. In fact, there is a difference of 40 between each address we will need. Look down the left side of your screen memory map. It looks like this: 1024 1064 1104 1144 1184 1224 1264 1304 1344 etc. As you can see, the X register would poop out before it got halfway down the screen. Therefore, we have to use more beginning offset addresses. We'll use five base addresses for both our characters and color. In that way we can stay well within our register limit of 255. GENERAL - VERTICAL LINES LABEL OPCODE OPERAND COMMENT {Merlin ORG $CO00} {Commodore * = $CO00} ******************************************** * * VERTICAL LINES * * ******************************************** 223 {Commodore} BAR1 = 55316 BAR2 = 55556 BAR3 = 55796 BAR4 = 56036 BAR5 = 56276 LIN1 = 1044 LIN2 = 1284 LIN3 = 1324 LIN4 = 1564 LIN5 = 1804 CLEAR = $E544 {Merlin} BAR1 EQU 55316 BAR2 EQU 55556 BAR3 EQU 55796 BAR4 EQU 56036 BAR5 EQU 56276 LIN1 EQU 1044 LIN2 EQU 1284 LIN3 EQU 1324 LIN4 EQU 1564 LIN5 EQU 1804 CLEAR EQU $E544 JSR CLEAR LDX #$0 START LDA #224 STA STA STA STA STA LDA LIN1,X LIN2.X LIN3,X LIN4,X LIN5,X #2 STA STA BAR1.X BAR2,X STA STA BAR3.X BAR4.X 224 INXR STA BAR5,> LDY #0 INX INY CPY #40 BNE INXR CPX #240 BNE START RTS KIDS' ASSEMBLER - VERTICAL LINES ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDX# $0 49157 LDA# 224 49159 STA-X 1044 49162 STA-X 1284 49165 STA-X 1324 49168 STA-X 1564 49171 STA-X 1804 49174 LDA# 2 49176 STA-X 55316 49179 STA-X 55556 49182 STA-X 55796 49185 STA-X 56036 49188 STA-X 56276 49191 LDY# 49193 INX 49194 INY 49195 CPY# 40 49197 BNE 49193 49199 CPX# 240 49201 BNE 49157 49203 RTS Another way to work with low resolution graphics is with your CHROUT routine. Instead of having to deal with both color and character screens, you can just deal with the characters. The screen 225 addresses make it handy to place blocks where you want them, but with CHROUT, you can use the PLOT subroutine to place your graphics. To see how this works, let's make a diagonal line. In using the PLOT subroutine, you have to be sure to LDA your character to be printed on the screen AFTER you PLOT. This is because the accumulator can be scrambled by the PLOT subrou- tine. Also, be sure to CLC before you JSR to PLOT ($FFF0), otherwise you may end up reading and not setting the plot location. (To read the plot location, you set the carry flag with SEC.) GENERAL - DIAGONAL LINES LABEL OPCODE OPERAND COMMENT {Merlin ORG $C000} {Commodore * = ! ******************************** **********, DIAGONAL PLOT ******************************************** {Commodore} CHROUT = $FFD2 CLEAR = $E544 PLOT = $FFF0 {Merlin} CHROUT EQU $FFD2 CLEAR EQU $E544 PLOT EQU $FFF0 JSR CLEAR LDX #0 LDY #0 LDA #18 ;Character for inverse. JSR CHROUT START CLC 226 JSR PLOT LDA #32 ;Character for space. JSR CHROUT INX ;Next row INY ;Next column CPX #25 ;ls it at the bottom row yet? BNE START ;lf not go back and do it again RTS KIDS' ASSEMBLER - DIAGONAL PLOT ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDX# 49157 LDY# 49159 LDA# 18 49161 JSR $FFD2 49164 CLC 49165 JSR $FFF0 49168 LDA# 32 49170 JSR $FFD2 49173 INX 49174 INY 49175 CPX# 25 49177 BNE 49164 49179 RTS Admittedly, low resolution graphics aren't much for detailed drawings, but they're a lot of fun. Change the background and border colors by inserting values between and 15 into $D021 and $D020 . (These are the routines we used in some of our previous ex- amples. The hexadecimal numbers are easier to remember than the decimal ones once you get used to them.) 227 One way to have finer resolution in low resolution graphics is to use characters that have the kinds of lines you want in your graphic display. For example, if you want to have a nice thin diagonal line in the DIAGONAL PLOT program above, just remove the lines that inverse the screen (LDA #1 8 and JSR CHROUT), and use the value 109 instead of 32 to output to the screen. ASCII 109 is a left-leaning angle. Put them together in a diagonal plot, and you will have a very straight line instead of the "staircase" we got. SAVING PLOTTED GRAPHICS When you draw low-resolution figures with the PLOT subroutine, you can save them as PRG files and load them directly to your screen. Actually, it takes a lot less disk space to save your graphics as machine language files and then load and SYS them, but there are some applications where you might want to "overlay" one set of graphics with another. Besides, it's interesting and useful to know. (You can save anything on the screen, actually, and so this method can be used to save text as well.) Essentially, what you do is to scan the entire screen, and then use the screen addresses (1024-2023) as your machine code file. Then when you LOAD "GRAPHICFILE",8,1 your graphic will be on the screen. Because your load address is the screen, it appears im- mediately without the necessity of having to SYS it. The following BASIC program is to be used in conjunction with a machine language program you have put in memory. For exam- ple, to save the DIAGONAL PLOT figure (not program) as a PRG file, you first load your program into memory like you would nor- mally do. However, instead of SYSing the program at this time, enter NEW and RETURN. Then LOAD and RUN the following program. It will first SYS the program in memory so that the only thing on your screen is the graphic figures. Then, it will treat the en- tire screen as a machine language program and put it on disk just as any other machine language program would be. They take up about four blocks of disk space compared to one block taken up by small assembly language programs such as DIAGONAL PLOT. Here's a summary of the steps to use: 228 Step 1 . Either write a machine language graphic program in your assembler or load one from disk. Step 2. Enter NEW and RETURN. Step 3. LOAD the SAVE PLOT program and RUN it. SAVE PLOT 10 INPUT "NAME OF FILE TO SAVE"; NF$ 20 NF$ = "0:" + NF$ + ",P,W" 30 INPUT "START ADDRESS";TER 40 SYSTER 50BA = 1024:EA = 2023 60 LB = BA-INT(BA/256)*256 70HB=INT(BA/256) 80 OPEN2,8,2,NF$ 90 PRINT#2,CHR$(LB) + CHR$(HB) 100FORX=BATOEA 110P=PEEK(X) 120 PRINT#2,CHR$(P) 130 NEXT 140 CLOSE2 Take a look at Line 40. You probably know that there's no such BASIC command as SYSTER (pronounced 'sister'), but there it is, and everything works fine. It's just a way to do weird things with your computer. Since the starting address of your machine program in memory is INPUT in the variable TER, what it actually does is to SYS the variable TER. Put them together, and there you have it. (If you think that's dumb, use the variable name BOOMBAH and see what happens.) Before we go on to the next section, you're probably wondering why we didn't use our program to save program files of graphics created with storage to the screen addresses instead of just ones created with the PLOT and CHROUT subroutines. Since most Commodore 64's require that a corresponding color be included when you STA an ASCII value in a screen address, we would have 229 had to have two files saved; one for the screen and one for the color. You can do it if you want, but it didn't seem to be worth the bother. ANIMATION Animation in assembly language requires some programming concentration, but it's so spectacular when you're finished, it's worth it. All animation is based on the illusion of drawing a figure in one place, erasing it, and drawing it in another place. It works just like cartoons in the movies. A figure is drawn, shown for an in- stant on the screen, and then it is removed (erased) and another figure is put in its place. Your computer makes animation very simple since it can create and erase figures in different places on the screen at high speeds. In fact, with assembly/machine language, it is often too fast. To see the difference in speed between a BASIC and assembly language program doing the same thing, look at try the following programs. BASIC ANIMATION 10 PRINT CHR$(147) 20 FOR X = 1 TO 10 : PRINT : NEXT 30 FOR X = 1 TO 39 : PRINT CHR$(113); : PRINT CHR$(157); CHR$(32); 40 NEXT 50PRINTCHR$(113) The ball really sails along in BASIC. A little flicker maybe, but it moves nicely. Try it in assembly language now. ♦NOTE: We used different beginning addresses for Merlin and the Commodore assemblers. The default ORG for Merlin is $8000, and if we use it, we can test assembled programs in the monitor before we save the program to disk. From the Edit Mode, enter MON {RETURN} and you will be in the monitor, indicated by a '$' prompt. To test the program, just enter 8000g. All values in the Merlin monitor are assumed to be hexadecimal. We have avoided the $8000 address for the beginning of your object code because you might be using a 230 plug-in ROM. However, as we get into more complex and longer programs, you'd better start using the Merlin monitor for debugging your programs. If you have a ROM installed, take it out before you start your assembly language program- ming with Merlin. If your program ORG is at $C000, it may interfere with Merlin or the monitor. GENERAL LABEL OPCODE OPERAND COMMENT {Merlin {Commodore ORG $8000} * = $C000 ******************************************** ANIMATION 1 * * ******************************************** {Commodore} CLEAR CHROUT PLOT EX WHY BALL SPACE = $E544 = $FFD2 = $FFF0 = $C200 = $C202 = $C204 = $C206 {Merlin} CLEAR CHROUT PLOT EX WHY BALL SPACE EQU EQU EQU EQU EQU EQU EQU $E544 $FFD2 $FFF0 $8200 $8202 $8204 $8206 231 START JSR CLEAR LDX #10 ;Set to row 10. STX EX LDY #0 ;Set to column 0. STY WHY LDA #113 ;ASCII value for ball STA BALL LDA #32 ;ASCII value for space STA SPACE LDX EX LDY WHY CLC JSR PLOT ;Plot the ball LDA BALL ;Load the ball JSR CHROUT ; Print the ball LDX EX ;Load X register with last row plot LDY WHY ;Load Y register with last column plot CLC JSR PLOT ;Plot the space LDA SPACE ;Load the space JSR CHROUT ; Erase the ball with the space INC WHY ; Increment the column value CO LDY WHY ;Load the Y register with the next column CPY #38 ;ls it near the last column BNE START ;lf not print and 232 erase another ball CLC JSR PLOT LDA BALL JSR CHROUT ;Put a ball on the screen so there's something left RTS KIDS' ASSEMBLER - ANIMATION 1 ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDX# 10 49157 STX $C200 49160 LDY# 49162 STY $C202 49165 LDA# 113 49167 STA $C204 49170 LDA# 32 49172 STA $C206 49175 LDX $C200 49178 LDY $C202 49181 CLC 49182 JSR $FFF0 49185 LDA $C204 49188 JSR $FFD2 49191 LDX $C200 49194 LDY $C202 49197 CLC 49198 JSR $FFF0 49201 LDA $C206 49204 JSR $FFD2 49207 INC $C202 49210 LDY $C202 49213 CPY# 38 49215 BNE 49175 233 49217 CLC 49218 JSR $FFF0 49221 LDA $C204 49224 JSR $FFD2 49227 RTS You may have thought you did something wrong. If all you saw was the ball on the right side of the screen after you SYSed the pro- gram, you keyed it in correctly. Animation is so fast in assembly/machine language that you can't see the movement unless you slow it down. To do that, we'll put in a PAUSE loop. In fact, we'll have to put in a nested PAUSE loop since even a loop of 255 won't slow the movement down enough. All the pause loop does is to run through an "empty loop" to slow down a program. In this case, we ran through the loop 2550 times. Edit ANIMATION 1 so that it includes the PAUSE loop in ANIMATION 2, and run the program again. Now you can see the ball move smoothly across the screen. To increase or decrease the speed of the ball, increase or decrease the CPY #$0A. GENERAL - ANIMATION 2 LABEL OPCODE OPERAND COMMENT {Merlin ORG $8000} {Commodore * = $C00O} ******************************************** * * ANIMATION 2 * * ******************************************** {Commodore} CLEAR =$E544 CHROUT =$FFD2 PLOT =$FFF0 EX =$C200 WHY =$C202 234 BALL = $C204 SPACE = $C206 {Merlin} CLEAR EQU $E544 CHROUT EQU $FFD2 PLOT EQU $FFF0 EX EQU $8200 WHY EQU $8202 BALL EQU $8204 SPACE EQU $8206 JSR CLEAR LDX #10 STX EX LDY #0 STY WHY LDA #113 STA BALL LDA #32 STA SPACE START LDX EX LDY WHY CLC JSR PLOT LDA BALL JSR CHROUT LDY #0 ;Begin pause loop. PAUSE1 LDX #0 PAUSE2 INX CPX #$FE BNE PAUSE2 INY CPY #$0A BNE PAUSE1 ;End pause loop. LDX EX LDY WHY CLC JSR PLOT 235 LDA SPACE JSR CHROUT INC WHY LDY WHY CPY #38 BNE START CLC JSR PLOT LDA BALL JSR CHROUT RTS KIDS' ASSEMBLER - ANIMATION 2 ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDX# 10 49157 STX $C200 49160 LDY# 49162 STY $C202 49165 LDA# 113 49167 STA $C204 49170 LDA# 32 49172 STA $C206 49175 LDX $C200 49178 LDY $C202 49181 CLC 49182 JSR $FFF0 49185 LDA $C204 49188 JSR $FFD2 49191 LDY# 49193 LDX# 49195 I NX 49196 CPX# $FE 49198 BNE 49195 49200 INY 49201 CPY# $0A 49203 BNE 49193 49205 LDX $C200 236 49208 LDY $C202 49211 CLC 49212 JSR $FFF0 49215 LDA $C206 49218 JSR $FFD2 49221 INC $C202 49224 LDY $C202 49227 CPY# 38 49229 BNE 49175 49231 CLC 49232 JSR $FFF0 49235 LDA $C204 49238 JSR $FFD2 49241 RTS That was a lot of work to get that crummy ball moving across the screen, and if you used the Kids' Assembler, you might be thinking the French Foreign Legion would be involve less pain. You might even be desperate enough to go back to BASIC. (God forbid!) On the other hand, if you used an assembler with a decent editor, all you had to do was to insert the eight lines for the PAUSE loop. If you have a birthday coming up, it's near Christmas or you have a half of ton of aluminum cans to take to the recycling center, think about getting a good assembler. EXTERNAL CONTROL OF MOVEMENT Now that we have seen how to move objects, let's see how to con- trol them with an external device. We'll use the joystick for our ex- amples, but you could do the same thing with the keyboard. Just substitute the SCNKEY and GETIN routines for the joystick ones in the following programs. The nice thing about using the PLOT subroutine in animation is that you can use the X and Y registers to place things on the screen in sequential locations. However, when you start moving all over the screen, PLOT can really scramble things, especially your brain. Therefore, we will begin using the ASCII code for your cursor con- trol. 237 CURSOR CONTROL CODES Up 145 $91 Down 17 $11 Left 157 $9D Right 29 $1D We'll use the CHROUT subroutine for moving both the cursor and the character. The trick is in remembering that CHROUT moves everything to the RIGHT. Therefore, when we move down, we actually move down and right with CHROUT. Therefore, we will have to make adjustments when we move in any other direction than right. To get started, we'll make a blinking cursor and move it around the screen. Again, note the different addresses used by Merlin and Commodore assemblers for the starting location. GENERAL - JOYSTICK CURSOR LABEL OPCODE OPERAND COMMENT {Merlin ORG $8000} {Commodore *- ! ******************************************** JOYSTICK CURSOR ******************************************** {Commodore} CLEAR JSTICK OFSET FIRE INVERSE NORMAL MARK CHROUT $E544 __.. :$DC01 J^g> ;$C200 $C202 $C204 :$C206 § :$C208 ^ :$FFD2 ■JOYSTICK 238 {Merlin} CLEAR EQU $E544 JSTICK EQU $DC01 BB8ET $8200 EORIE $8202 INVERSE EQU $8204 NORMAL EQU $8206 MARK EQU $8208 CHROUT EQU $FFD2 JSR CLEAR LDA #$FF OR value STA OFSET LDA #16 ;Fire button STA FIRE LDA #32 ;Space for the cursor STA MARK LDA #18 ;lnverse Code STA INVERSE LDA #146 ; Normal code STA NORMAL START LDA JSTICK EOR OFSET CMP #1 ;Joystlck up? BEQ UP CMP #2 ;Joystick down? BEQ DOWN CMP #4 ;Joystick left? BEQ LEFT CMP #8 ;Joystlck right? BEQ RIGHT CMP FIRE ;Fire button pressed? BEQ END ;lf so then end. CURSOR LDA MARK ;Load the space JSR CHROUT ;Print the space LDA #157 ;Load the left cursor 239 JSR CHROUT ;Back up LDA NORMAL JSR CHROUT ;Set normal LDA MARK JSR CHROUT LDA #157 ;Back up JSR CHROUT LDA INVERSE JSR CHROUT ;Set inverse JMP START ;Go do It again UP LDA #145 JMP PRINT ;Print up cursor DOWN LDA #17 JMP PRINT ; Print down cursor LEFT LDA #157 JMP PRINT ;Print left cursor RIGHT LDA #29 PRINT JSR CHROUT JMP CURSOR END RTS {Commodore .END} KIDS' ASSEMBLER • JOYSTICK CURSOR ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDA# $FF 49157 STA $C200 49160 LDA# 16 49162 STA $C202 49165 LDA# 32 49167 STA $C208 49170 LDA# 18 49172 STA $C204 49175 LDA# 146 49177 STA $C206 49180 LDA $DC01 49183 EOR $C200 240 49186 CMP# 1 49188 BEQ 49244 49190 CMP# 2 49192 BEQ 49249 49194 CMP# 4 49196 BEQ 49254 49198 CMP# 8 49200 BEQ 49259 49202 CMP $C202 49205 BEQ 49267 49207 LDA $C208 49210 JSR $FFD2 49213 LDA# 157 49215 JSR $FFD2 49218 LDA $C206 49221 JSR $FFD2 49224 LDA $C208 49227 JSR $FFD2 49230 LDA# 157 49232 JSR $FFD2 49235 LDA $0204 49238 JSR $FFD2 49241 JMP 49180 49244 LDA# 145 49246 JMP 49261 49249 LDA# 17 49251 JMP 49261 49254 LDA# 157 49256 JMP 49261 49259 LDA# 29 49261 JSR $FFD2 49264 JMP 49207 49267 RTS When you assemble and run this program, you will see a flashing cursor made by the SPACE character being turned normal and in- verse rapidly. When you move your joystick, the cursor will be wholly out of control, jumping clear across the screen with a quick movement of your joystick. Just as we saw with animation, 241 machine language is just too blasted fast. We'll have to slow it down with a delay loop to get single space control over it. Now that we have seen some general movement principles with our cursor, let's draw with the joystick. This is not "animated" movement in that what we draw is not erased and then re-drawn. However, very similar principles apply when controlling what hap- pens with graphics on the screen. We'll also add a couple of new tricks. First, we saw in the last program that we had to keep drawing and backing up. This required several LDA's and JSR's throughout the program. Since we know we're going to have to back up, why not make a subroutine that will do that. The subroutine will be accessed just like the built-in subroutines using JSR. However, since we're writing the subroutine as part of our own program, we have to in- clude an RTS to get back to our jump-off point. It works just like GOSUB and RETURN in BASIC. Second, we're going to put a pause loop in our "joystick scan" to slow things down a bit. In the last program, when you moved the joystick, the cursor hopped all the way across the screen. This was because the scan was so quick that it was able to read the direction of the joystick and jump to the subroutines several times before you could put it in neutral. (In fact, you may want to increase the pause loop we put in this program!) The program draws low resolution lines on the screen. To keep it simple and a little more flexible, we'll use the joystick LEFT to serve as an eraser. Therefore, if you move the joystick UP, DOWN or RIGHT, a line will be drawn. Move it left, and anything the cursor hits will be erased. GENERAL LABEL OPCODE OPERAND COMMENT {Merlin ORG {Commodore *=$C000} 242 . ************ . * . * . * ****************** JOYSTICK DRAW . ****************************** {Commodore} CLEAR = $E544 JSTICK = $DC01 OFSET = $C20 FIRE = $C202 INVERSE = $C204 NORMAL = $C206 MARK = $C208 CHROUT =$FFD2 {Merlin} CLEAR EQU $E544 JSTICK EQU $DC01 OFSET EQU $8200 FIRE EQU $8202 INVERSE EQU $8204 NORMAL EQU $8206 MARK EQU $8208 CHROUT EQU $FFD2 JSR CLEAR LDA #$FF STA OFSET LDA #16 STA FIRE LDA #32 STA MARK LDA #18 STA INVERSE LDA #146 STA NORMAL START LDA JSTICK EOR OFSET CMP #1 BEQ UP 243 LDA INVERSE JSR CHROUT LDX #0 ; Beg in pause loop PAUSE INX CPX #254 BNE PAUSE ;End pause loop JMP START UP JSR BACK LDA #145 JMP PRINT DOWN JSR BACK LDA #17 JMP PRINT LEFT LDA #157 JSR CHROUT JMP PRINT PRINT JSR CHROUT LDA MARK JSR CHROUT JMP CURSOR BACK LDA #157 ;Subroutine JSR CHROUT RTS END RTS {Commodore .END} KIDS' ASSEMBLER - JOYSTICK DRAW ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDA# $FF 49157 STA $C200 49160 LDA# 16 49162 STA $C0202 49165 LDA# 32 49167 STA $C208 49170 LDA# 18 49172 STA $C204 244 49175 LDA# 146 49177 STA $C206 49180 LDA $DC01 49183 EOR $C200 49186 CMP# 1 49188 BEQ 49247 49190 CMP# 2 49192 BEQ 49255 49194 CMP# 4 49196 BEQ 49263 49198 CMP# 8 49200 BEQ 49271 49202 CMP $00202 49205 BEQ 49289 49207 LDA $C208 49210 JSR $FFD2 49213 JSR 49285 49216 LDA $C206 49219 JSR $FFD2 49222 LDA $0208 49225 JSR $FFD2 49228 JSR 49285 49231 LDA $0204 49234 JSR $FFD2 49237 LDX# 49239 INX 49240 CPX# 254 49242 BNE 49239 49244 JMP 49180 49247 JSR 49285 49250 LDA# 145 49252 JMP 49271 49255 JSR 49285 49258 LDA# 17 49260 JMP 49271 49263 LDA# 157 49265 JSR $FFD2 49268 JMP 49271 49271 JSR $FFD2 49274 LDA $0208 245 49277 JSR $FFD2 49280 JMP 49207 49283 LDA# 157 49285 JSR $FFD2 49288 RTS 49289 RTS That was a long one! Be sure to note the two RTS instructions at the end of the program. The first one is to return to the program position that initiated the JSR. It works like RETURN. The second one is to return to BASIC and end the machine level program. Of course the RTS that returns to BASIC does not have to be at the end of the program, but it must be the last RTS encountered in the pro- gram flow. SUMMARY In this chapter we saw how to work with low resolution graphics and animation. However, we learned a few new tricks in assembly language programming, as well. We wrote our own subroutine that we JSRed and RTSed from and saw how to make delay loops. By combining previous skills, we even made a drawing program with the joystick. We did some work with color, but not a great deal. This was because we already know how to change the colors to anything we want from examples in previous chapters. Also, since we were do- ing a good deal of work with new concepts, more color may have been confusing. Besides, I wanted you to test some of your own skills in this area. Experiment with different border, background and character colors with the programs. You'll be surprised by the difference it makes. In the next chapter, we will examine sprite graphics and sound. There, we will combine new tricks with some of the those we learn- ed in this chapter. We will be learning the fundamentals of arcade game assembly language programming. 246 CHAPTER 14 BLAZING SPRITES AND MONSTROUS SOUNDS SPRUE GRAPHICS If you've worked with sprites in BASIC, you will find working with them in assembly language is easier! Since most of the set-up you had in BASIC involved POKEs and PEEKs, you were actually working with machine language. We all know that assembly language is simpler than machine language; so this ought to be a snap for you BASIC sprite programmers. For those of you who have not worked with sprites, we'll take it a step at a time. In case you don't know what a sprite is on the Commodore 64, let me explain. Basically, it is a 63 byte graphic image. Each byte is given a value to turn on a configuration of pixels; little dots on the screen. From our discussion of binary math and how the various registers look, let's take a look at a single byte. 7 6 5 4 3 2 10 10 11111 On Off Off On On On On On 247 On your screen, the above configuration would look something like the following if it were magnified: Each sprite is composed of three columns and 21 rows. Each row is made up of three bytes. Since each byte has 8 bits that can be turn- ed on or off, it is clearer to think of a sprite graphic as a 21 by 24 matrix of bits or pixels. Sprite Matrix Column 1 Column 2 Column 3 Row xxxxxxxx xxxxxxxx xxxxxxxx 1 xxxxxxxx xxxxxxxx xxxxxxxx 2 xxxxxxxx xxxxxxxx xxxxxxxx 3 xxxxxxxx xxxxxxxx xxxxxxxx 4 xxxxxxxx xxxxxxxx xxxxxxxx 5 xxxxxxxx xxxxxxxx xxxxxxxx 6 xxxxxxxx xxxxxxxx xxxxxxxx 7 xxxxxxxx xxxxxxxx xxxxxxxx 8 xxxxxxxx xxxxxxxx xxxxxxxx 9 xxxxxxxx xxxxxxxx xxxxxxxx 10 xxxxxxxx xxxxxxxx xxxxxxxx 11 xxxxxxxx xxxxxxxx xxxxxxxx 12 xxxxxxxx xxxxxxxx xxxxxxxx 13 xxxxxxxx xxxxxxxx xxxxxxxx 14 xxxxxxxx xxxxxxxx xxxxxxxx 15 xxxxxxxx xxxxxxxx xxxxxxxx 16 xxxxxxxx xxxxxxxx xxxxxxxx 17 xxxxxxxx xxxxxxxx xxxxxxxx 18 xxxxxxxx xxxxxxxx xxxxxxxx 19 xxxxxxxx xxxxxxxx xxxxxxxx 20 xxxxxxxx xxxxxxxx xxxxxxxx 21 In the above matrix, suppose that the 'x' marks represent a 0. If we turned on a pixel, it would be a ' + \ To draw a character, we just have to put little ' + ' marks in the shape we want. To keep it simple, we'll draw a cross: 248 Column 1 Column 2 Column 3 xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx ++++++++ ++++++++ ++++++++ ++++++++ ++++++++ xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx ++++++++ ++++++++ ++++++++ ++++++++ ++++++++ xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx Row 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 Next, to envision our cross as a set of l's and zero's, let's change the X's to 's and the + 's to l's. Column 1 Column 2 Column 3 11 11 11 11 11 11 11 11 11 11 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 oooooooo Row 1 2 3 4 5 6 7 8 9 10 249 00000000 11111111 00000000 11 oooooooo 11111111 00000000 12 00000000 11111111 00000000 13 00000000 11111111 00000000 14 00000000 11111111 00000000 15 00000000 11111111 00000000 16 00000000 11111111 00000000 17 oooooooo 11111111 oooooooo 18 00000000 11111111 oooooooo 19 oooooooo 11111111 00000000 20 00000000 11111111 00000000 21 To get our cross into the computer, we will have to change the binary values into decimal or hex so that we can put them into memory. (We could do it with binary numbers, but that would be impossible with the Kids' Assembler.) We know a byte with 00000000 is equal to and a byte with 1 1 1 1 1 1 1 1 is 255 or $FF. To arrange our cross in the correct sequential order, we move from left to right and top to bottom. In the column to the right of our figure, we'll place the decimal values. Column 1 Column 2 Column 3 Value 00000000 11111111 00000000 0,255,0 oooooooo 11111111 00000000 0,255,0 oooooooo 11111111 00000000 0,255,0 00000000 11111111 00000000 0,255,0 00000000 11111111 oooooooo 0,255,0 11111111 11111111 11111111 255,255,255 11111111 11111111 11111111 255,255,255 11111111 11111111 11111111 255,255,255 11111111 11111111 11111111 255,255,255 11111111 11111111 11111111 255,255,255 00000000 11111111 00000000 0,255,0 oooooooo 11111111 oooooooo 0,255,0 oooooooo 11111111 00000000 0,255,0 oooooooo 11111111 oooooooo 0,255,0 00000000 11111111 00000000 0,255,0 00000000 11111111 00000000 0,255,0 00000000 11111111 oooooooo 0,255,0 oooooooo 11111111 oooooooo 0,255,0 250 00000000 11111111 00000000 0,255,0 00000000 11111111 00000000 0,255,0 00000000 11111111 00000000 0,255,0 To place a sprite into memory, you begin with Row 1 Column 1 and move to Row 1 Column 2, Row 1 Column 3 , Row 2 Column 1 , Row 2 Column 2 etc. and place the values in sequential memory locations. (You snake along in other words.) Thus, in the first two rows, we would place the values into memory in the following order: Location Value Column Row #1 1 1 #2 255 2 1 #3 3 1 #4 1 2 #5 255 2 2 #6 3 2 Of course, you're not limited to values of or 255. Depending on the bit configuration, your sprite bytes can be any combination of values between and 255. For example, you might have a con- figuration that looks like the following: 00001111 00111100 1111000 15,60,240 00000111 00011000 1110000 7,24,224 00000011 01100110 1100000 3,102,192 Use the BINARY - DECIMAL conversion program in Chapter 5 to easily make the conversion from binary to decimal. Further on in this chapter we will write a "Sprite Assembler" in BASIC that will store your sprites and save them. Before that, though, we must first go over the procedure for getting sprites to work. SPRITE CREATION The only way to work with sprites and assembly language is to GET ORGANIZED! Programming sprites is actually quite simple 251 once you have everything set up in a simple sequence and know what registers to use. To begin, let's outline the basic sequence of programming sprites SIMPLE SPRITE SEQUENCE 1. Store block number into POINTER. 2. ENABLE Sprite 3. Store sprite COLOR in sprite color register 4. BUILD sprite and store it. 5. Set horizontal HIGH bit to 1 or©. 6. MOVE sprite The above sequence provides the order of events in your pro- gram. Assembly language uses the same sequence as BASIC; so there's nothing new about it. Now, let's look at each step closely. 1. Store Block Number into POINTER. We will be storing our sprites in available memory blocks of 63 bytes each. Therefore, we must find some 63 byte blocks we can use. Block Number Addresses: 11 704-767 $2C0-$2FF 13 832-895 $340-$37F 14 869-959 $380-$3BF 15 960-1023 $3C0-$3FF The block number refers to the number of 64 byte blocks (not 63 since 64 is evenly divided into 256) below the starting address. For example, Block is at addresses 0-63, Block 1 at 64-127 and so forth. Without rearranging memory, those four blocks are about as much as we can handle. Therefore, we can build four sprites. (With memory management, you can get up to eight sprites going.) Now that we know what a block number is, we must store that value in a register that points to the block in which we will store our 252 sprite. The pointer address begins at 2040 ($7F8). To get the correct pointer for our sprite, we add the sprite number to the base address. Sprite number POINTER Register Sprite 2040 $FF8 Sprite 1 2041 $FF9 Sprite 2 2042 $FFA Sprite 3 2043 $FFB Sprite 4 2044 $FFC Sprite 5 2045 $FFD Sprite 6 2046 $FFE Sprite 7 2047 $FFF For example, let's say we wanted to use block 13 (loca- tions 832-895) and Sprite 1. We would do the following: LDA STA #13 2041 That would do it. If you've worked with sprites in BASIC, it's just like POKE 2041,13. 2. ENABLE Sprite The register at $D015 (53269) is the ENABLE register for sprites. To enable a specific sprite, you load $D015 with the sprite value, not the sprite number. Sprite Pointer Sprite Number Sprite Value Sprite© 1 Sprite 1 2 Sprite2 4 253 Sprite 3 8 Sprite4 16 Sprites 32 Sprite6 64 Sprite7 128 To enable Sprite 2, you would do the following: LDA #4 STA $D015 REMEMBER, the value 4 is for Sprite 2, not Sprite 4. 3. Store Sprite COLOR in Sprite Color Register. Each sprite has a color value from 0-15 ($0-$F). The color values correspond to the standard colors we've used so far for background, border and character colors. Each sprite has its own color register beginning at $D027 (53287.) To determine which col- or register to use, just add the sprite number to the base address of $D0 27 (53287). Sprite Number Color Register Sprite $D027/53287 Sprite 1 $D028/53288 Sprite 2 $D029/53289 Sprite 3 $D02A/53290 Sprite 4 $D02B/53291 Sprite 5 $D02C/53292 Sprite 6 $D02D/53293 Sprite 7 $D02E/53294 For example, to store the color RED in Sprite 1 color register, simp- ly use the following: LDA #2 ;Value for color RED STA $D028 254 The process works just like storing the background color in $D021 except it turns the sprite color on instead of the background color. 4. BUILD Sprite At this stage, you load the sprite values (63 of them) into the block you stored in the pointer register in Step 1, For example, if you used Block 13, you would store the sprite values in locations 832-895 ($340-$37F). We will discuss the several ways sprites can be built and stored further on in this chapter. 5. Set horizontal HIGH bit to or 1. The register at $D0 10 holds the high byte for all sprite horizontal locations. If it is set to 1 then all horizontal (X) values are 256 or higher. If it is set to 0, all values are from 0-255. The horizontal screen for sprites is 320 dots wide. For the first 255 dots, the high byte is set to 0, and for 256 to 320, it must be set to 1 . For the time being, we'll be setting it to 0. LDA #0 STA $D010 Later we will discuss full horizontal movement. 6. MOVE Sprite To move your sprite, the X (horizontal) and Y (vertical) positions are set in register pairs beginning at $D000-$D000 1 (53248-53249). The first of the pair is the X position and the second is the Y posi- tion. Register Pair Sprite Number X Y Sprite $D000/53248 $D001/53249 Sprite 1 $D002/53250 $D003/53251 Sprite 2 $D004/53252 $D005/53253 Sprite 3 $D006/53254 $D007/53255 Sprite 4 $D008/53256 $D009/53257 255 Sprite 5 $D00A/53258 $D00B/53259 Sprite 6 $D00C/53260 $D00D/53261 Sprite 7 $D00E/53262 $D00F/53263 To move a sprite, the X and Y values of the corresponding registers are changed. The good thing about sprites is that you do not have to erase a sprite to move it. You simply change the X and Y values of the corresponding registers. For example, to move Sprite 1 across the screen horizontally at vertical location 100, you would use the following: LDX #0 LDY #100 STY $D003 MOVE STX $D002 INX CPX #255 BNE MOVE Of course, you can also change the value of the Y register to move vertically, or change both the X and Y values to move diagonally. At this point we have all of the basic information for making a sprite. For our first example, we will simply make a big block by fill- ing in our sprite area with 255 ($FF). We will then move our block across the screen. Since machine language is so fast, we will have to slow our sprite down with a pause loop. We will use Sprite for our first example since it uses the base addresses of all the registers. Also, we will use hexadecimal values for the registers since they are easier to remember. Most of them start with $D0, and you can think of them as "do" something or other. GENERAL - SPRITE ZERO STARTER LABEL OPCODE OPERAND COMMENT {Merlin ORG {Commodore * = $C000} 256 . * ********** ********** i************* * . * SPRITE ZERO STARTER * . ******************************************** {Commodore} SPRITE© = $7F8 ENABLE = $D015 COLOR© = $D©27 SPOX = $D000 SPOY = $D©01 MSBX = $D01© SHOUSE = $034© {Merlin} SPRITE© EQU $7F8 ENABLE EQU $D015 COLOR© EQU $D027 SPOX EQU $D000 SP©Y EQU $D001 MSBX EQU $D01© SHOUSE EQU $034© JSR $E544 LDA #$0D ; Block 13 or $0D STA SPRITE© ;Store it in pointer for Sprite © LDA #1 ;Sprite © enable value STA ENABLE ;Store it in enable register LDA #2 ;Color red STA COLOR© ;Color register for Sprite © LDX #© LDA #0 CLEANUP STA SHOUSE.X 257 BUILD MOVE PAUSE ;Store zeros in INX sprite area CPX #63 BNE CLEANUP LDX #0 LDA #$FF STA SHOUSE.X ;Fill up sprite area with $FF or 255 INX ;to make solid block CPX #63 BNE BUILD LDA #0 STA MSBX ;Store in MSBX to locate sprite in horizontal locations to LDX #0 255 only LDA #70 ;Vertical location STX SP0X ; Increment horizontal STA SP0Y location by X ;Y register stays at constant location of A LDY INY #0 register ; Delay loop. CPY #255 BNE PAUSE INX CPX #254 BNE MOVE RTS 258 KIDS' ASSEMBLER - SPRTTE-0 STARTER ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDA# $0D 49157 STA $7F8 49160 LDA# 1 49162 STA $D015 49165 LDA# 2 49167 STA $D027 49170 LDX# 49172 LDA# 49174 STA-X $0340 49177 INX 49178 CPX# 63 49180 BNE 49174 49182 LDX# 49184 LDA# $FF 49186 STA-X $0340 49189 INX 49190 CPX# 63 49192 BNE 49186 49194 LDA# 49196 STA $D010 49199 LDX# 49201 LDA# 70 49203 STX $D000 49206 STA $D001 49209 LDY# 49211 INY 49212 CPY# 255 49214 BNE 49211 49216 INX 49217 CPX# 254 49219 BNE 49203 49221 RTS If you're using the Kids' Assembler, you're at a disadvantage since you cannot define the descriptive variable names. However, 259 with the Merlin and the Commodore assemblers, it's a good idea to create a source code with all of the sprite registers defined and then save it to disk. In this way, when you're ready to work with sprites, all of your variables are defined and you can start with the creation and movement of your sprites with little effort. SPRITE BUILDING The most exacting process in sprite programming is building the sprites. We'll design and build a sprite (something more interesting than a cross or block) and examine the different ways your assembler can store the sprite in memory. We will use Block 13 (832-895) in all of our examples. Instead of using the Kids' Assembler, we'll write a Sprite Assembler that will be a lot easier for creating and stor- ing sprites. Our sprite will be called PLANET DESTROYER! Making sprites takes Patience... PLANET DESTROYER Column 1 Column 2 Column 3 Row xxxxxxxx XXXXXXXX xxxxxxxx 1 xxxxxxxx xxxxxxxx xxxxxxxx 2 xxxxxxxx xxxxxxxx xxxxxxxx 3 xxxxxxxx xxxxxxxx xxxxxxxx 4 xxxxxxxx xxxxxxxx xxxxxxxx 5 +XXXXXXX xxxxxxxx xxxxxxxx 6 + + +XXXXX xxxxxxxx xxxxxxxx 7 ++++++XX xxxxxxxx xxxxxxxx 8 ++++++++ +XXXXXXX xxxxxxxx 9 ++++++++ + + + + xxxx XXX + + + XX 10 XXX+ + + + + ++++++++ + + + +XXXX 11 XX+ + + + + + ++++++++ ++++++++ 12 260 XX++++++ ++++++++ ++++++++ 13 XXX+++++ ++++++++ + + + +XXXX 14 ++++++++ + + + +XXXX xxxxxxxx 15 ++++++++ +XXXXXXX xxxxxxxx 16 + + + + + +xx xxxxxxxx xxxxxxxx 17 + + +XXXXX xxxxxxxx xxxxxxxx 18 +XXXXXXX xxxxxxxx xxxxxxxx 19 xxxxxxxx xxxxxxxx xxxxxxxx 20 xxxxxxxx xxxxxxxx xxxxxxxx 21 PLANET DESTROYER Column 1 Column 2 Column 3 Row 00000000 00000000 00000000 1 0,0,0 00000000 00000000 00000000 2 0,0,0 00000000 00000000 00000000 3 0,0,0 00000000 00000000 00000000 4 0,0,0 00000000 00000000 00000000 5 0,0,0 100000000 00000000 0000000 6 128,0,0 1110000 00000000 00000000 7 224,0,0 11111100 00000000 00000000 8 252,0,0 11111111 10000000 00000000 9255,128,0 11111111 11110000 00011100 10 255,240,28 00011111 11111111 11110000 11 31,255,240 00111111 11111111 00111111 12 63,255,63 00111111 11111111 00111111 13 63,255,63 00011111 11111111 11110000 14 31,255,240 11111111 11110000 00000000 15 255,240,0 11111111 10000000 00000000 16 255,128,0 11111100 00000000 00000000 17 252,0,0 11100000 00000000 00000000 18 224,0,0 100000000 00000000 0000000 19 128,0,0 00000000 00000000 00000000 20 0,0,0 00000000 00000000 00000000 21 0,0,0 At this point we have all the values for our PLANET DESTROYER sprite. The most obvious (and tedious) way of get- ting those values into memory would be to do something like the following: 261 LDA #0 STA 832 LDA #0 STA 833 etc... With the Commodore and Merlin assemblers, a better way would be to define them with special pseudo-opcodes (directives). Remember when we used ASC to define strings? Well, you can also define numbers, except that you use DFB on Merlin and .BYTE on the Commodore EDITOR64. These directives work something like DATA statements. Each value is separated by a comma. For exam- ple, the following routine would read in the values in the line labeled DATA (any name will do). LDX #0 BUILD LDA DATA.X STA 832,X INX CPX #64 BNE BUILD {Commodore} DATA .BYTE 0,0,0,0,0,0,0 .BYTE 128,0,etc... {Merlin} DATA DFB 0,0,0,0,0,0,0 DFB 128,9,etc... Now let's type in our PLANET DESTROYER program and give it a test run. GENERAL - PLANET DESTROYER LABEL OPCODE OPERANDCOMMENT {Merlin ORG $8000} {Commodore *=$C000} 262 ******************************************** PLANET DESTROYER * * ,***************************************•******** {Commodore} SPRITE© ENABLE COLOR© SP0X SPOY MSBX SHOUSE {Merlin} SPRITE© ENABLE COLOR© SP0X SPCY MSBX SHOUSE CLEANUP = $7F8 = $D©15 = $D©27 = $D©0© = $D©01 = $D01© = $©34© EQU EQU EQU EQU EQU EQU EQU JSR LDA STA STA LDA STA LDA STA LDA STA LDX LDA STA INX CPX $7F8 $D©15 $D©27 $D0©1 $D01© $©34© $E544 #© ;Color for black $D©2© ; Border black $D©21 ;Background black #$©D SPRITE© #1 ENABLE #7 ;Yellow COLOR© #© SHOUSE.X #64 263 BNE CLEANUP LDX #0 BUILD LDA DATA,X ;Read DFB / .BYTE values one at a time STA SHOUSE,X ;Store in SpriteHOUSE INX CPX #63 BNE BUILD LDA #0 STA MSBX LDX #0 LDA #70 MOVE STX SP0X STA SP0Y LDY #0 PAUSE INY CPY #255 BNE PAUSE INX CPX #254 BNE MOVE JMP MOVE RTS ;Use .BYTE instead of DFB with Commodore DATA DFB 0,0,0,0,0,0,0,0,0 DFB 0,0,0,0,0,0,128,0,0 DFB 224,0,0,252,0,0 DFB 255,128,0 DFB 255,240,28 DFB 31,255,240 DFB 63,255,63 DFB 63,255,63 DFB 31,255,240 DFB 255,240,0 DFB 255,128,0 DFB 252,0,0 264 DFB 224,0,0 DFB 128,0,0 DFB 0,0,0,0,0,0 Notice that when using DFB and .BYTE directives, the label, DATA, is able to reference all of the values entered. This includes values in lines after the label. KIDS' SPRITE ASSEMBLER As you can imagine, building sprites with the Kids's Assembler would be a royal pain in the neck since it has no labels or DFB / .BYTE directives. Therefore, let's make a special assembler that will make it easy to enter sprite data and save the sprite to disk. Then, once you have your sprite made, you can load it up into memory without having to build it each time you want to use it. In this way you can create a whole library of sprites, and then just write the programs to enable and move the sprites. Since the Sprite Assembler is designed especially for sprites and not general assembly work, there are some special features about it. First, it takes data in groups of three. Each INPUT prompt expects three values separated by a comma. For example, you will be pro- mpted, ROW 5? and you should enter something like, ROW 5 ? 255,128,0 {RETURN} By using the method we have developed for calculating sprite values in the sprite matrix, it will be very simple to read sprites into memory. When the program starts, you will be expected to give one of four blocks. The block number, not the beginning address is to be entered. When the program is saved to disk, the block number is ap- pended to the file name so that later when you want to use that 265 sprite in a program, you will know the block number it uses. When you want the sprite in memory to be used by a program, you will load the sprite as follows: LOAD "FILENAME 13",8,1 Then when the program ac- cesses the data in Block 13, or whatever block it was saved in, it will find your sprite. Sprite Assembler Sprite Assembler 10 PRINT CHR$(147):R = 1 20 PRINT "STARTING ADDRESS AS BLOCK:" 30 PRINT "BLOCK 11: 704-767" 40 PRINT "BLOCK 13: 832-895" 50 PRINT "BLOCK 14: 896-959" 60 PRINT "BLOCK 15: 960-1023" 70 FOR X = 1 TO 39 80 PRINT CHR$(18);CHR$(32); : NEXT : PRINT 90 INPUT "BLOCK NUMBER";BL 100IFBL <> 11 ANDBL <>13ANDBL <> 14 ANDBL <> 15 THEN 90 110 SA = BL*64 120 FOR X = SA TO SA + 62 STEP 3 130 PRINT "ROW";R 140 INPUT A,B,C 150 IF A > 255 OR B > 255 OR C > 255 THEN 130 160 POKE X,A : POKE X + 1,B : POKE X + 2,C 170 R = R + 1 : NEXT 200 REM ************* 210 REM WRITE TO DISK OOQ\ RFM ************* 230 LB = SA- INT(SA/25^ * 256 266 240 HB = INT(SA/256) 250 INPUT "ENTER SPRITE NAME";SN$ 260 SN$ = "0:" + SN$ + STR$(BL) + ",P,W" 270 OPEN2,8,2,SN$ 280 PRINT#2,CHR$(LB) + CHR$(HB) 290 FOR V = SA TO SA + 62 : SC = PEEK(V) 300 PRINT#2,CHR$(SC) 310 NEXT V 320 CLOSE2 We should do the same thing for the other assemblers. After all, if we can save sprites as separate files, then we won't have to pro- gram around them. We can just load them into memory and then access them from any sprite program we write. The main thing to remember is that we have to use the available blocks of memory to store our sprites. Therefore the ORG must begin in one of those blocks. The following shows how to do this with Block 13. The same technique is used with the other blocks. Just change the ORG or * = address. GENERAL - SPRITE CREATOR 13 LABEL OPCODE OPERAND COMMENT {Merlin ORG $0340} {Commodore *=$0340} ******************************************** * * SPRITE CREATOR 13 * * ******************************************** {Commodore} SPRITE© =$7F8 ENABLE =$D015 COLOR0 = $D027 SP0X =$D0 SP0Y =$D001 MSBX =$D010 SHOUSE =$0340 267 {Merlin} SPRITE© EQU $7F8 ENABLE EQU $D015 COLOR© EQU $D027 SP0X EQU $D000 SP0Y EQU $D01 MSBX EQU $D010 SHOUSE EQU $0340 ******************************************** * * * Build Sprite * * ******************************************** BUILD LDX #0 LDA DATA.X ;Read DFB / .BYTE values one at a time STA SHOUSE.X ;Store in SpriteHOUSE INX CPX #63 BNE BUILD ******************************************** * * Sprite Data * * ******************************************** {Merlin} DATA DFB #,#,# ;Values for sprite {Commodore} DATA .BYTE #,#,# 268 All you have to do is to enter your sprite data after the DFB or .BYTE directives. When you're finished, save the object code to disk, and then using either the LOADER64 programs on the Com- modore or the LOAD "SPRITENAME.O",8,l sequence for the Merlin object file. = =THE WORM HAS TURNED= = The Sprite Assembler is so convenient, you may actually want to use it instead of your regular assembler, especially if you're using the Commodore assembler. This is because you can use the LOAD "FILENAME",8,1 se- quence to load sprites created with the Sprite Assembler. You can't do that with the Commodore system unless you create and save code with the monitor. So here's a case where the worm has turned and it's actually easier to use something from the Kids' system. Now that we have programs that will create sprites and save them for use, we will need to see how to access these sprites from within a program. We'll just modify our starter program to be a Sprite Tester. We can load a sprite from disk, and then run the following program to see if the sprite is what we thought it was. Notice that we have taken out the CLEANUP subroutine. This is because that would wipe out any sprite in memory we wanted to test. This tester is designed for sprites using Block 13, but it can be changed to test sprites in any block. Use the following sequence: 1. Create your sprite and save it to disk. 2. Load your sprite into memory as you would any other machine language program. 3. Load the SPRITE TESTER program into memory and SYS it. Your sprite should run across the screen for you. 269 GENERAL - SPRITE TESTER LABEL OPCODE OPERAND COMMENT {Merlin ORG $8000} { Commodore * = $C©0© } • ******* VHRWV1 . * . * . * rwwwwwwwwwwwwwirwww SPRITE TESTER . ************************ *'* * * * * {CommOodore} SPRITE© = $7F8 ENABLE = $D015 COLOR© = $D027 SP0X = $D00© SP0Y = $D©01 MSBX = $D©1© SHOUSE = $©34© {Merlin} SPRITE© EQU $7F8 ENABLE EQU $D015 COLOR© EQU $D027 SP©X EQU $D000 SP©Y EQU $D001 MSBX EQU $D©10 SHOUSE EQU $©34© JSR $E544 LDA #© STA $D©20 STA $D021 LDA #$©D STA SPRITE© LDA #1 STA ENABLE LDA #7 STA COLOR© LDX #© 270 MOVE PAUSE LDA #$00 STA MSBX LDA #70 STX SP0X STA SP0Y LDY #0 INY GPY #255 BNE PAUSE INX CPX #254 BNE MOVE RTS KIDS' ASSEMBLER - SPRITE TESTER ADRS OPCODE OPERAND 49152 JSR $E544 49155 LDA# 49157 STA $D021 49160 STA $D020 49163 LDA# $0D ^ItoBSk*. 49165 STA$7F8 Jnk 49168 49170 LDA# STA 1 $D015 Kw/y^^'^^ T tfSfflWBB 49173 LDA# 7 WW&i&wvWv 49175 STA $D027 ^Mffill w 49178 LDX# ^wMtifflW 49180 LDA# \IHBK7 49182 STA $D010 wKff/ 49185 LDA# 70 IMf 49187 STX $D000 j^Mii^t 49190 STA $D001 vr*mflMkW 49193 LDY# ^" 49195 INY Testing Sprite 49196 CPY# 255 49198 BNE 49195 49200 INX 49201 CPX# 254 271 49203 49205 BNE RTS 49187 FULL HORIZONTAL MOVEMENT So far, we have only moved part of the full horizontal move. In order to move our full horizontal width, we have to store a 1 in the MSBX register. That's easy enough. Just insert the following lines to the SPRITE TESTER program before the RTS and your sprite will move across the entire screen: MOVE2 PAUSE2 LDX #0 LDA #1 STA MSBX ;Set the high byte of X position LDA #70 ;Keep Y at 70 STX SP0X ;X position is now 255 + X STA SP0Y LDY #0 INY CPY #255 BNE PAUSE2 INX CPX #90 BNE MOVE2 When you test a sprite on the program now, it will go all the way across the screen. SPRITE EXPANSION A final aspect of sprite programming we will discuss is the expan- sion of sprites to double size. The registers at $D01D (53277) and $D0 17 (53271) control the X and Y sizes of the sprite. The sprites we have been using so far have been single width and height. By storing the Sprite Value in the respective registers, it is possible to expand the sprite to double width. The following sprite values are used: 272 Sprite Value Sprite 1 Sprite 1 2 Sprite 2 4 Sprite 3 8 Sprite 4 16 Sprite 5 32 Sprite 6 64 Sprite 7 128 It is fairly important to have a variable name for your X and Y expansion registers. This is so that you can add and subtract the sprite value to those registers to change the sprite size. If you're using multiple sprites, this becomes crucial. For example, if you store 1 in $D017 and $D01D, Sprite will be expanded. If you then STA 2 in the same registers so that Sprite 1 will be expanded, Sprite will be reset to normal size. The following shows how to change sprite size using multiple sprites. YXPAND EQU $D017 XXPAND EQU $D01D LDA #1 ;Sprite value stored in expansion registers STA YXPAND STA XXPAND LDA YXPAND CLC ADC #2 ;Add Sprite 1 value to registers STA YXPAND STA XXPAND Now if you want to return one or the other sprites to normal size, you simply subtract from the expansion registers. For example, to keep Sprite 1 at double size and return Sprite to normal, you would just SBC 1 from each register. 273 LDA XXPAND SEC SBC #1 STA YXPAND STA XXPAND There is still more to sprites than we have covered, but we have dealt with the major aspects of assembly language programming and sprites. The trick is to get organized with sprites. Then, it is simply a matter of following a series of steps. By using the keyboard and joystick subroutines we've developed, it is possible to control movement from these external devices. Since you should already know how to do that, I'll let you insert these subroutines yourself. ASSEMBLY SOUNDS Like sprite programming in BASIC, most sound programming is also done with POKEs and PEEKs. Therefore, it should not be at all difficult to do make all the sounds we want. The trick, as with sprites, is to organize everything into variables pertaining to the pro- per registers. We're going to look at the basic features of sound on your Com- modore 64. By making changes to the program we're going to write, you will be able to produce a whole lot of sound. By changing the variables, you will be able to make music, racket or the sound of a train rushing through your TV. Here, the trick is to see how to get your sounds working in assembly language. Other sources are available for getting all of the several aspects of your SID chip working. Just in case you have not worked with sound before, turn up the sound on your TV so you can hear what's going on. (If you have a monitor with no sound, you might as well skip this section.) On the most fundamental level, you computer deals with six registers to create sound. The duration of a sound is done with a delay loop that keeps everything going until the program nulls the sound registers by filling them with zeros. 274 1. Volume Control. The volume control register is at $D418 (54296). It can have a maximum value of $F (15). It controls how loud the sound will be. 2. Attack - Decay. This refers to how fast a sound reaches its maximum volume and falls from that volume. Its register is at $D405 (54277). The maximum value is 240. 3. Sustain - Release. The extent to which a sound is carried at a certain level before it is released is its sustain/release variable. The $D406 (54278) register holds it. Like attack/decay, its maximum value can be 240. 4. High and Low Frequency. The pitch of notes is determined by their high/low frequency. The low frequency register is at $D400and the height at $D401. 5. Waveform. Sounds can either be smooth or rough. The waveform determines how this will occur. There are four major waveforms we can use: a. Triangle =17 b. Sawtooth = 33 c. Pulse = 65 d. Noise = 129 To make a sound, we first store values in the registers. Then we simply "hold" a sound with a delay loop. Even a loop of 255 will give you a very short sound; so you may need nested loops, depen- ding on what sound you want. At the end of the delay loop, you will null the registers by storing zeros in them. GENERAL - ASSEMBLY SOUND LABEL OPCODE OPERAND COMMENT {Merlin ORG {Commodore * = $CO0O} 275 . * WTTWWWWWWWT [KKXKKKHKK H » W W H H W it H W » M W * . * ASSEMBLY SOUNDS * * . ******************************************** {Commodore} SIGVOL = $D418 t ATDCY1 = $D405 SUREL1 = $D406 VCREG1 = $D404 FREL01 = $D400 FREHI1 = $D401 {Merlin} SIGVOL EQU $D418 ATDCY1 EQU $D405 SUREL1 EQU $D406 VCREG1 EQU $D404 FREL01 EQU $D400 FREHI1 EQU $D401 LDA #15 STA SIGVOL ;Set volume to 15 LDA #128 STA ATDCY1 ;Set attack - decay to 128 STA SUREL1 ;Set sustain - release to 128 LDA #195 STA FREL01 ;Store 195 in the low frequency LDA #16 STA FREHI1 ;Store 16 in the high frequency LDA #17 STA VCREG1 LDY #0 SET LDX #0 PLAY I NX 276 CPX #255 ;Double delay loop to play sound BNE PLAY INY CPY #100 BNE SET LDA #0 ;Null registers with© STA VCREG1 STA ATDCY1 STA SUREL1 STA FREL01 STA FREHI1 RTS KIDS' ASSEMBLER - ASSEMBLY SOUNDS ADRS OPCODE OPERAND 49152 LDA# 15 49154 STA $D418 49157 LDA# 128 49159 STA $D405 49162 STA $D406 49165 LDA# 195 49167 STA $D400 49170 LDA# 16 49172 STA $D401 49175 LDA# 17 49177 STA $D404 49180 LDY# 49182 LDX# 49184 INX 49185 CPX# 255 49187 BNE 49184 49189 INY 49190 CPY# 100 49192 BNE 49182 49194 LDA# 277 49196 STA $D404 49199 STA $D405 49202 STA $D406 49205 STA $D400 49208 STA $D401 49211 RTS You should try changing everything from the size of the delay loop to the values stored in the registers. By doing so, you will discover the sounds you need and hear ones that will surprise you. Combine the sounds with your sprites and you'll have the makings of an arcade game! SUMMARY This chapter is important in that we used two special chips and sets of registers in your Commodore 64. With the VIC chip, we were able to access sprite graphics. This allowed us to produce and move special characters we can create ourselves. Secondly, we used the registers in the SID chip to create sound. The combination of these two sets of registers in single programs will let you do some very interesting things. In the next chapter, we'll look at some ex- amples. 278 CHAPTER 15 DOWN THE ROAD Introduction This last chapter is to help you go on in assembly language once you're finished here. Like any other language, programming or spoken, the real secret is to use it. If you study German in school, for example, and you never use it, you'll forget it. On the other hand, if you live in Germany and are constantly speaking German, soon you will become fluent. The same is true with assembly language. When you sit down to write a program, even in BASIC, ask yourself, "How could the same thing be done in assembly language?" You can start off with little subroutines to speed up your BASIC programs and work your way up to full blown pro- grams, all written with an assembler. Practice will make perfect, but you still have a lot of new opcodes to learn with which you can practice. We will look at some tricks to help you learn new opcodes. Finally, you're going to need more materials to study to learn assembly language. For the Commodore 64, there are some available materials that are highly recommended. We'll look at those so that you can keep progressing beyond this point. 279 MERGING SUBROUTINES Assembly language programming is best digested as a 50 course dinner. If you take just a little at a time, you will be able to consume everything. These little bites are best conceived as "subroutines." This actually involves writing little programs that do something as we have done in this book. Each little program, when merged with other little programs, becomes a big program. To see how to append programs, we will have to use the Merlin and Commodore assemblers as examples since they both can ap- pend programs and the Kids' Assembler cannot. That means, that you can load one source code into the editor and then tack on another source code to it. Appending With Merlin To append one source code to another, first load one source code using the "L" instruction from the EXECUTIVE MODE. Once the first file is loaded return to the EXECUTIVE MODE by press- ing 'Q' from the editor, and use the "A" option to append the se- cond file. Appending with Commodore EDITOR64 Once the editor is in memory, use the GET command to load the first file. All files loaded with GET begin at line 1000. List your program to see the highest line number. For example, let's say that the highest line number in your program is 1200. To append a pro- gram to the one in memory, use the GET command with the parameter for the first line number. That line number must be higher than 1200. For example, we'll append FILE 2 to FILE 1. 1. GET "FILE 1" {RETURN} 2. LIST {RETURN} Highest line number is 1200 3. GET "FILE 2",1210 Now FILE 2 would be appended to FILE 1. 280 To do something new with the programs we have developed in this book, let's append some. In the last chapter we made a "Planet Destroyer" sprite and "Assembly Sounds." Let's put those two together, edit them and see what we get. Load "Planet Destroyer" and then append "Assembly Sounds." We'll look at the program first and then explain what editing changes were made to make it. (We'll use the Merlin listing since the only difference is in the for- matting of EQUates, and with the large number of variables defin- ed, having two sets would be confusing.) GENERAL SLOW NOISY SPACE SPRITE LABEL OPCODE OPERAND COMMENT {Merlin ORG $0000} {Commodore *=$C000} ********************************************* * * NOISY SPRITE ROCKET * * ********************************************* SPRITE© EQU $7F8 ENABLE EQU $D015 COLOR0 EQU $D027 SP0X EQU $D000 SP0Y EQU $D001 MSBX EQU $D010 SHOUSE EQU $0340 SIGVOL EQU $D418 ATDCY1 EQU $D405 SUREL1 EQU $D406 VCREG1 EQU $D404 FREL01 EQU $D400 FREHI1 EQU $D401 HI EQU $C300 WHY EQU $C304 EX EQU $C306 281 ;SPRITE SUBROUTINE . ******************************************** JSR $E544 LDA #$©D STA SPRITE© LDA #1 STA ENABLE LDA #2 STA COLOR© LDX #© LDA #$©0 CLEANUP STA INX SHOUSE,X CPX #64 BNE CLEANUP LDX #© BUILD LDA DATA.X STA SHOUSE.X INX CPX #63 BNE BUILD LDA #© STA MSBX LDX #© STX EX LDA #70 STA WHY preserve "Y" MOVE STX SP©X LDA WHY STA SP0Y INC EX ; Increment X through EX LDX EX SOUND SUBROUTINE NO PAUSE LOOP SINCE THE SOUND SLOWS DOWN MOVEMENT ******************************************** LDA #1© STA HI 282 START LDA #15 STA SIGVOL LDA #128 STA ATDCY1 STA SUREL1 LDA HI STA FREL01 LDA HI STA FREHI1 LDA #17 STA VCREG1 LDY #0 SET LDX #0 PLAY INX CPX #20 BNE PLAY INY CPY #20 BNE SET LDA #0 STA VCREG1 STA ATDCY1 STA SUREL1 STA FREL01 STA FREHI1 INC HI LDA HI CMP #40 BNE START LDX EX CPX #254 BNE MOVE ;Back to Sprite ;END OF PROGRAM AND SPRITE DATA ********************************************* RTS DATA DFB 0,0,0,0,0,0,0,0,0 DFB 0,0,0,0,0,0,128,0,0 DFB 224,0,0,252,0,0 DFB 255,128,0 283 DFB 255,240,28 DFB 31,255,240 DFB 63,255,63 DFB 63,255,63 DFB 31,255,24© DFB 255,240,0 DFB 255,128,0 DFB 252,0,0 DFB 224,0,0 DFB 128,0,0 DFB 0,0,0,0,0,0 If you look at the sprite data, it's the same we used with the Planet Destroyer sprite. You can change it to any sprite configura- tion you want, and using your append features of your assembler, it is easy. The main changes we made were in the form of substitution. Instead of using the INX instruction to increment the horizontal position of the sprite, we stored the X position in the 'variable' (location) we called EX and incremented the value in EX. We also used a variable, WHY, to store the vertical position of the sprite. The reason we did that is because the X and Y registers were heavily used in producing our sound. Since the sound values were not directly related to the movement values of X and Y, we needed some way to preserve the X and Y values in movement. By only using the values in EX and WHY in the movement segment and resetting the X and Y registers in the sound portion of the program, we were able to keep everything moving and sounding the way we intended. While the actual movement mechanism in not tied to the sound, the speed of the movement is. If the various sizes of the loops in the sound segment of the program are shortened, the sound will change and so will the speed of the rocket. The way it is now, it makes a "space gurgle" and creeps along at a snail's pace. (Actually, it's sneaking up on a planet to destroy.) 284 Finally, you probably noticed that all of the EQUates are together at the beginning of the program. This was done with the MOVE function on Merlin. With the Commodore 64 Macro As- sembler Development System, you can do the same thing by chang- ing the line numbers of the equate ( = ) directives. Then, delete the old line numbers and everything is moved. APPENDING AND INSERTING SUBROUTINES In the above program, we essentially stuck two programs together; one on top of the other. Now, we'll do something a little more complex. We'll start the same way, though. First, load "Planet Destroyer" and then append "Joystick Draw." What we're going to do is to insert the joystick read subroutine inside the sprite routine. Take out the routine to increment the X register to move, and in its place put the joystick read subroutine. Then, change the JMPs to PRINT to JMPs to MOVE. Both the Merlin and Commodore editors have CHANGE commands you can use to do this quickly. We added another wrinkle to our joystick program. When the values in EX and WHY reach the limits of and 255, we don't want them to "turn over." Instead, we just have them jump to the routine that will increment them or decrement them so they stay within the registers' boundaries. Thus, when UP or LEFT is 0, the program will JMP to DOWN or RIGHT. Similarly, when DOWN or RIGHT reaches 255, the value is decremented by JMPs to UP and LEFT. LABEL OPCODE OPERAND COMMENT {Merlin ORG $C000} {Commodore *=$C000} ********************************************* * * JOYSTICK SPRITE * * ********************************************* 285 CLEAR EQU $E544 JSTICK EQU OFSET EQU $C300 FIRE EQU $C302 EX EQU $C304 WHY EQU $C306 SPRITE© EQU $7F8 ENABLE EQU $D015 COLOR© EQU $D027 SP0X EQU $D©00 SPOY EQU $D0©1 MSBX EQU $D010 SHOUSE EQU $©34© . ******************************** JSR CLEAR LDA #$0D STA SPRITE© LDA #1 STA ENABLE LDA #2 STA COLOR© LDX #© LDA #$00 CLEANUP STA SHOUSE.X INX CPX #64 BNE CLEANUP LDX #© BUILD LDA DATA.X STA SHOUSE.X INX CPX #63 BNE BUILD LDA #0 STA MSBX LDA #$FF STA OFSET LDA #16 $DC01 286 STA FIRE LDA #40 STA EX ;Starting X position of Sprite STA SP0X LDA #70 STA WHY ;Starting Y position of Sprite STA SPOY ;READ THE JOYSTICK . ******************************************** START PAUSE UP LDA JSTICK EOR OFSET CMP #1 BEQ UP CMP #2 BEQ DOWN CMP #4 BEQ LEFT CMP #8 BEQ RIGHT CMP FIRE BEQ END LDX #0 INX CPX #254 BNE PAUSE JMP START DEC WHY LDY WHY CPY #0 ;Check for adjustment BEQ DOWN 287 DOWN LEFT RIGHT END JMP MOVE ; Branch to MOVE subroutine INC WHY LDY WHY CPY #255 BEQ UP JMP MOVE DEC EX LDX EX CPX #0 BEQ JMP RIGHT MOVE INC EX LDX EX CPX #255 BEQ LEFT JMP MOVE RTS ;MOVEMENT OF SPRITE ******************************************** MOVE STX SP0X STY SP0Y LDX #0 M PAUSE INX CPX #254 BNE M PAUSE JMP START ;SPRITE DATA . ******************************************** DATA DFB 0,0,0,0,0,0,0,0,0 DFB 0,0,0,0,0,0,128,0,1 DFB 224,0,0,252,0,0 DFB 255,128,0 DFB 255,240,28 DFB 31,255,240 DFB 63,255,63 288 DFB 63,255,63 DFB 31,255,240 DFB 255,240,0 DFB 255,128,0 DFB 252,0,0 DFB 224,0,0 DFB 126,0,0 DFB 0,0,0,0,0,0 These two programs should give you an idea of how to merge two smaller routines into a single larger one. Now you can treat the larger routines as subroutines themselves. You have a subroutine that will move your sprites and create sound and one that will move sprites with your joystick. By appending different sprite data, ad- ding additional sprites, and appending other subroutines you can build larger programs. The trick is to build a library of subroutines, and instead of starting from scratch every time you sit down to pro- gram, you can start with a substantial amount of the work already done and debugged. This also points to the importance of getting a good assembler. While the Kids' Assembler is fine for learning assembly language programming and small programs, it becomes increasingly difficult to use as your programs increase. Starting all over each time you program is a waste of time, and in the long run you will not learn as much since more effort is used keying in old code than creating new code. GETTING TO KNOW THE OTHER OPCODES We've covered the most commonly used opcodes and addressing modes, but there are still more to learn and use. The best way to learn how to use new opcodes is to first isolate them, and then test them with simple programs. Often novice assembly language pro- grammers will insert a new opcode into a large program, and while it may or may not work, it is difficult to see why it did or did not. Usually the best way to see if an opcode does what you think it does is to put it into a routine that will put a value into the ac- cumulator. Then have that value sent to the screen. If the screen character is what you expect; then you can assume that the opcode did what you thought. In the listing in Appendix A, the Kids' 289 Assembler there has all of the opcodes for the 6510, and Appendix B has an alphabetical listing of all 6510 opcodes. A good book on 6502 opcodes (which are identical to the 6510opcodes) is: 6502 Assembly Language Programming By Lance A. Leventhal Berkeley, CA : Osborne/McGraw-Hill This book describes in technical detail what each code does. RESOURCES FOR LEARNING MORE ABOUT ASSEMBLY LANGUAGE PROGRAMMING ON THE COMMODORE 64 As more good assemblers are becoming available for the Com- modore 64, there should be more resources for learning assembly language programming. Most assembler manuals have very little about programming. They usually just explain how to use the assembler, more or less assuming you already know how to pro- gram. However, from what you know now, you should be able to understand what the assembler manuals are talking about and use them to some advantage. Since there are a wide variety of resources for learning assembly language, we'll divide them into several categories. First, we'll look at reference manuals. These are books used to look things up. Secondly, we'll see what other books there are on "how to" do assembly language programming. Third, we'll look at magazines you might read to either learn assembly language programming or see some examples of assembly language programs. Before all of that, though, we'll look at the best resource possible, Commodore 64 User Groups. USER GROUPS The most valuable tips, techniques and education you can receive for assembly language on the Commodore 64 is from a user group. These are people who own Commodore 64's and get together to share their common interest. These groups typically have several 290 members who are kids like yourself. (My group even has a lot of adults who are just like kids.) If you attend meetings in your area, not only will you meet other kids who have Commodore 64's, you can learn a lot about assembly language programming by just ask- ing. Now you may wonder why people are going to give you all of this free information. It's simple; assembly language programmers love to brag. I do it all the time. If someone asks about an assembly language procedure, nothing makes me feel better than being able to answer their question. If you know BASIC, you've probably ex- perienced the same thing. You can help someone by showing off! What could be better? Not only will you learn something, you'll make someone else feel very good about themselves. In addition to getting a wealth of information, you can also gain access to public domain (that means FREE!) software. Since a good deal of public domain software is written in assembly language, you can use assembly listing to see how others write assembly code on the Commodore 64. REFERENCE BOOKS There are two reference books no assembly language program- mer should be without. First, there is; Commodore 64 Programmer's Reference Guide Commodore Business Machines, Inc. And Howard W. Sams & Co., Inc. This book has all of the technical details you will need to work your Commodore 64. Most important is its description of the Kernal routines in your machine. Secondly, your assembly language programming will be greatly enhanced by the book, Mapping the Commodore 64 By Sheldon Leemon Greensboro, N.C. : COMPUTE! Publications, Inc., 1984 291 All of the built-in subroutines in your Commodore 64, along with substantial explanations of their use are contained in this book. It is well written, and there are several example programs in BASIC that illustrate how the various subroutines work. HOW-TO BOOKS There really are not a lot of books available for assembly language programming on the Commodore 64 right now. However, mere are three books you might want to examine for the transition from BASIC to machine/assembly language. The Intermediate Commodore 64 ByGuyGrotke Chatsworth, CA : Datamost, 1984 This book builds a bridge between BASIC and assembly language programming. Some of the more advanced aspects of graphics, files and basic assembly language procedures are explain- ed. There are a number of listings of assembly language routines and the appendix has all of the decimal and hexadecimal values for the 6510 opcodes. Commodore 64 Exposed By Bruce Bayley Melbourne, Australia: Melbourne House, 1983 Like the Intermediate Commodore 64, this is a "transition book" between BASIC and more advanced techniques. There are some assembly language listings, a good memory map and lots of good tips. Inside the Commodore 64 By Don French Cannon Falls, MN : French Silk This is actually the manual that accompanies the French Silk Assembler. More than most manuals, this one goes beyond just ex- plaining how to use the assembler. There are several example pro- 292 grams, an excellent memory map, and you can get it with the assembler or without. MAGAZINES The problem with most magazines for the Commodore 64 is that they create machine code with BASIC programs. As a result, their listings are in the form of READ/DATA statements that are POK- Ed into memory. You can't see the assembly opcodes, but rather you just get a pile of decimal machine codes. However, there are some assembly listings, and you can still learn something about machine language programs even if the listings are given in BASIC. With Merlin's Sourceror, you can create source code from the machine code generated with the BASIC programs in the magazines. Thus, with the right tools, you can extend your knowledge a good deal. The most likely source for actual assembly listings is in Com- mander magazine. Like most other magazines, this one will have machine code generated by BASIC programs, but it also has disassembled listings as well. Previous issues have contained series articles, such as "Explorations With Assembly Language" by Eric Giguere. You'll find plenty of new material just about every month in the Commander. A second source for machine code is in COMPUTE! 's Gazette. There's a regular series, "Machine Language For Beginners" by Richard Mansfield you will find useful. In previous articles, there have been assembly listings for various aspects of machine language techniques. Mansfield handles the material in small, clear chunks, and you can get a lot here. Third, RUN: The Commodore 64 & VIC 20 Magazine, has a number of programs and articles dealing with machine and assembly language programming. Several very sophisticated pro- grams can be found in this publication. Other magazines for the Commodore 64 are available as well. The best idea is to take a look at the various issues, including the three recommended above, and see if there are any articles or pro- 293 grams on assembly/machine language programming. An even bet- ter idea would be to write a letter to the editor of your favorite Com- modore 64 magazine and tell them you want to see more listings and articles on assembly language programming. YOU'RE ON YOUR OWN By this stage, you're well on your way to becoming a full-fledged assembly language programmer. If you've gotten this far, you're way ahead of where you were at the beginning. You should be able to write routines of your own creation with the more common op- codes and most addressing modes. What you do next is up to you. If nothing else, I hope to have conveyed the fundamentals of assembly language programming and given you enough confidence to experiment on your own. If you can do that; then you'll be able to go much further. Above all, assembly language programming should be an exciting challenge. Put another way, it should be plain fun. Before you know it, you'll wonder why anyone programs in BASIC. Now you can FLY. 294 295 296 APPENDICES APPENDIX A: KIDS' ASSEMBLER APPENDIX B: 6510 OPCODES APPENDIX C: MEMORY MAP 1: DIAGRAM APPENDIX D: MEMORY MAP 2: PLACES TO VISIT APPENDIX E: BASIC TOKEN CHART APPENDIX F: HEXADECIMAL-DECIMAL CONVERSION : . CHART APPENDIX G: DECIMAL-HEXADECIMAL CONVERSION CHART APPENDIX H: SCREEN STORAGE ADDRESS TABLE APPENDIX I: COLOR STORAGE LOCATION TABLE APPENDIX J: ASCII CODE APPENDIX K: SCREEN STORAGE DISPLAY CODES 297 298 APPENDIX A KIDS' ASSEMBLER This version of the Kids' Assembler has all opcodes for the 6510. There are two ENDING ROUTINES, one for disk and one for tape. The disk version is in the main listing between lines 740 and 960. If you are using a cassette, there is a second ENDING ROUTINE at the end of the main listing. 10 POKE 53281,1 : POKE 53280,1 : PRINTCHR$(144) 20PRINTCHR$(147) 30 DIM DEC%(151),OPCODE$(151),BYTE%(151) 40 GOSUB 2510 50 FOR I = TO 150 : READ DEC%(I) : READ OPCODE$(l) : READ BYTE%(I) 60 NEXT I 70 PRI NT CH R$(1 46);CH R$(1 47) 80 PRINT "ADRS"; TAB(10);"OPCODE";TAB(25);"OPERAND" 90 FOR X= 1 TO 40 : PRINT CHR$(114); : NEXT 100 PRINT 110) RFM **************************** 120 REM SET ADDRESS AND INPUT OPCODE 299 nin rfm **************************** 140 SA = : PRINT "PRESS {RETURN} TO DEFAULT TO 49152" 150 INPUT'STARTING ADDR";SA : IF SA = © THEN SA = 491 52 16©BA = SA 17© PRINT SA;TAB(1©)180 INPUT OC$ : IF OC$ = "Q" THEN 74© 190 C = 20© IF OC$ = OPCODE$(C) THEN D% = DEC%(C) : B% = BYTE%(C) : GOTO 23© 210C = C+1 : IF C = 152 THEN PRINT TAB(1©);CHR$(18);"ERROR";CHR$(146) : GOTO 17© 22© GOTO 2©© 230 IF B% = 1 THEN POKE SA,D%: SA = SA + 1 : GOTO 170 94(71 RFM ************* 250 REM ENTER OPERAND ORC\ RFM ************* 270 PRINT TAB(25);: PRINT CHR$(145);:INPUT OPR$ 280 IF LEFT$(OPR$,1) <> "$" THEN OPER = VAL(OPR$) 290 IF LEFT$(OPR$,1) = "$" THEN GOSUB 450 300 IF OPER > 65535 THEN GOSUB 590 : OPER = 0: GOTO 27© 310IFOC$ = "BNE"OROC$ = "BEQ" THEN GOSUB 660 320 IF OC$ = "BCC" OR OC$ = "BCS" THEN GOSUB 660 330 IF OC$ = "BPL" OR OC$ = "BMI" THEN GOSUB 660 34© IF 0C$ = "BVC" OR 0C$ = "BVS" THEN GOSUB 660 350 IF BF= 1 THEN BF = © : GOTO 27© 36© IF OPER > 255 AND B% < 3 THEN GOSUB 520: OPER = 0: GOTO 270 370 IF OPER > 255 THEN GOSUB 6©0 oqj» RFM ************ 390 REM COMPILE CODE 300 400 REM ************ 410 IF B% =2 THEN POKE SA,D% : SA = SA + 1 420 IF B% = 2 THEN POKE SA.OPER : SA = SA + 1 : OPER = 0: GOTO 170 430 POKE SA,D%: SA = SA + 1 440 POKE SA,LB : SA = SA + 1 : POKE SA,HB : SA = SA + 1 :OPER = 0: GOTO 170 450 REM ********************** 460 REM CONVERT HEX TO DECIMAL 470 REM ********************** 480H$=MID$(OPER$,2) 490 FOR L= 1 TO LEN(H$) : HD = ASC(MID$(H$,L,1)) 500OPER = OPER*16+HD-48 + ((HD> 57)*7) 510 NEXT L : RETURN 520 REM ********** 530 REM ERROR TRAP 540 REM ********** 550 PRINT CHR$(18);"ERROR- MUST BE LESS THAN 256" 560 FOR W = 1 TO 400 : NEXT W : PRINT CHR$(146); : PRINT CHR$(145)570 FOR X= 1 TO 27 : PRINT CHR$(32); : NEXT 580 PRINT CHR$(157);CHR$(157);CHR$(145) :RETURN 590 PRINT CHR$(18);"VALUE OVER 65535 ($FFFF)";CHR$(146) : RETURN 600 REM ************************ 610 REM CONVERT TO 2 BYTE NUMBER 620 REM ************************ 630 LB = OPER - 1 NT(OPER/256)* 256 640HB = INT(OPER/256) 650 RETURN fifi0 RFM ************* 670 REM BRANCH OFFSET 680 REM ************* 690IFSA> OPER AND SA - OPER > 128 THEN PRINT "BRANCH TOO FAR":BF=1:OPER = 0:RETURN 700IFSA> OPER AND OPER -SA > 127 THEN PRINT "BRANCH TOO FAR":BF = 1:OPER = 0:RETURN 301 710IFSA >OPERTHENOPER= 254 - (SA - OPER) 720IFSA < OPER THEN OPER = (OPER-SA)-2 730 RETURN ~7A0\ RFM ************** 750 REM ENDING ROUTINE 7fiffl RFM ************** 770 NB = SA-BA 780 PRINT CHR$(147) 790 FOR X= 1 TO 5 : PRINT : NEXT 800 INPUT'SAVE PROGRAM(Y/N)";AN$ 810IFAN$ = "Y"THEN870 820 PRINT : PRINT : PRINT "PROGRAM IS";NB;"BYTES LONG" 830 PRINT "TO EXECUTE 'SYS"';BA : PRINT 840 INPUT "(B)EGIN AGAIN OR (E)ND";DE$ 850IFDE$ = "B"THEN70 860 PRINT : PRINT'END" : END 870 PRINT CHR$(147) : FOR X= 1 TO 5 : PRINT : NEXT 880 LB = BA - INT(BA/256)*256 : HB = INT(BA/256) 890 INPUT "ENTER FILE NAME";NF$ :NF$ = "0:" + NF$ + STR$(BA) + ",P,W" 900 OPEN2,8,2,NF$ 910 PRINT#2,CHR$(LB) + CHR$(HB)920 FOR X= BA TOSA-1:OC=PEEK(X) 930 PRINT#2,CHR$(OC)940 NEXTX 950 CLOSE2 960 GOTO 820 Q7W RFM *********** 980 REM OPCODE DATA 990 REM *********** 1000 DATA 0,BRK,1 1010 DATA 1,(ORA-X),2 1020 DATA 5,ORA-Z,2 1030 DATA 6,ASL-Z,2 1040 DATA 8,PHP,1 1050 DATA 9,ORA#,2 1060 DATA 10,ASL-A,1 1070 DATA 13,ORA,3 1080 DATA 14,ASL,3 302 1090 DATA 16,BPL,2 1100 DATA 17,(0RA-Y),1 1110 DATA 21 ,0RA-ZX,2 1 1 20 DATA 22,ASL - ZX,2 1130 DATA 24,CLC,1 1140 DATA 25,ORA-Y,3 1150 DATA 29,ORA-X,3 1160 DATA 30,ASL-X,3 1170 DATA 32, JSR,3 1180 DATA 33,(AND-X),2 1190 DATA 36,BIT-Z,2 1200 DATA 37,AND-Z,2 1210 DATA 38,ROL-Z,2 1220 DATA 40,PLP,1 1230 DATA 41 ,AND#,2 1240 DATA 42,ROL-A,1 1250 DATA 44,BIT,3 1260 DATA 45,AND,3 1270 DATA 46,ROL,3 1280 DATA 48,BMI,2 1290 DATA 49,(AND- Y),2 1300 DATA 53,AND-ZX,2 1310 DATA 54,ROL-ZX,2 1320 DATA 56,SEC,1 1330 DATA 57,AND-Y,3 1340 DATA 61,AND-X,3 1350 DATA 62, R0L-X.3 1360 DATA 64,RTI,1 1370 DATA 65,(EOR-X),2 1380 DATA 69, E0R-Z,2 1390 DATA 70.LSR-Z.2 1400 DATA 72,PHA,1 1410 DATA 73,EOR#,2 1420 DATA 74,LSR-A,1 1430 DATA 76,JMP,3 1440 DATA 77,EOR,3 1450 DATA 78,LSR,3 1460 DATA 80,BVC,2 1470 DATA 81 ,(E0R-Y),2 1480 DATA 85.EOR - ZX,2 303 1490 DATA 86.LSR - ZX,2 1500 DATA 88,CLI,1 1510 DATA 89,EOR-Y,3 1520 DATA 93, EOR-X.3 1530 DATA 94,LSR-X,3 1540 DATA 96,RTS,1 1550 DATA 97,(ADC - X),2 1560 DATA 101, ADC -Z,2 1570 DATA 102,ROR-Z,2 1580 DATA 104.PLA.1 1590 DATA 105,ADC#,2 1600 DATA 1 06, ROR-A.1 1610 DATA 108,(JMP),3 1620 DATA 109,ADC,3 1630 DATA 110,ROR,3 1640 DATA 11 2,BVS,2 1650 DATA 113,(ADC-Y),2 1 660 DATA 1 1 7.ADC - ZX,2 1670 DATA 118,ROR-ZX,2 1680 DATA 120,SEI,1 1690 DATA 121, ADC -Y,3 1700 DATA 125, ADC -X,3 1710 DATA 126,ROR-X,3 1720 DATA 129,(STA-X),2 1730 DATA 132,STY-Z,2 1740 DATA 133,STA-Z,2 1750 DATA 134,STX-Z,2 1760 DATA 136,DEY,1 1770 DATA 138,TXA,1 1780 DATA 140,STY,3 1790 DATA 1 41 ,STA,3 1800 DATA 142,STX,3 1810 DATA 144,BCC,2 1820 DATA 145,(STA-Y),2 1830 DATA 148,STY-ZX,2 1840 DATA 149,STA-ZX,2 1850 DATA 150,STX-ZX,2 1860 DATA 152.TYA.1 1870 DATA 153.STA-Y.3 1880 DATA 154,TXS,1 304 1890 DATA 157,STA-X,3 1900 DATA 160,LDY#,2 1910 DATA 1 61 ,(LDA-X),2 1920 DATA 162,LDX#,2 1930 DATA 164,LDY-Z,2 1940 DATA 165.LDA-Z.2 1950 DATA 166,LDX-Z,2 1960 DATA 168,TAY,1 1970 DATA 169,LDA#,2 1980 DATA 170,TAX,1 1990 DATA 172,LDY,3 2000 DATA 173,LDA,3 2010 DATA 174,LDX,3 2020 DATA 176,BCS,2 2030 DATA 177,(LDA-Y),2 2040 DATA 180,LDY-ZX,2 2050 DATA 181,LDA-ZX,2 2060 DATA 182,LDX-ZY,2 2070 DATA 184,CLV,1 2080 DATA 185,LDA-Y,3 2090 DATA 186.TSX.1 2100 DATA 1 88, LDY-X,3 2110 DATA 1 89, LDA-X.3 2120 DATA 190,LDX-Y,3 2130 DATA 192,CPY#,2 2140 DATA 193,(CMP-X),2 2150 DATA 196,CPY-Z,2 2160 DATA 197,CMP-Z,2 2170 DATA 198,DEC-Z,2 2180 DATA 200,INY,1 2190 DATA 201,CMP#,2 2200 DATA 202,DEX,1 2210 DATA 204.CPY.3 2220 DATA 205,CMP,3 2230 DATA 206,DEC,3 2240 DATA 208,BNE,2 2250 DATA 209,(CMP- Y),2 2260 DATA 213,CMP-ZX,2 2270 DATA 214,DEC-ZX,2 2280 DATA 216,CLD,1 305 2290 DATA 217.CMP- Y,3 2300 DATA 221 ,CMP-X,3 2310 DATA 222,DEC-X,3 2320 DATA 224,CPX#,2 2330 DATA 225,(SBC - X),2 2340 DATA 228,CPX-Z,2 2350 DATA 229.SBC - Z,2 2360 DATA 230,INC-Z,2 2370 DATA 232,INX,1 2380 DATA 233,SBC#,2 2390 DATA 234.NOP.1 2400 DATA 236,CPX,3 2410 DATA 237,SBC,3 2420 DATA 238,INC,3 2430 DATA 240.BEQ.2 2440 DATA 241 ,(SBC - Y),2 2450 DATA 245,SBC - ZX,2 2460 DATA 246,INC-ZX,2 2470 DATA 248.SED.1 2480 DATA 249.SBC- Y,3 2490 DATA 253.SBC - X,3 2500 DATA 254,1 NC - X,3 2510 REM ****** 2520 REM HEADER 2530 REM ****** 2540 CR$ = "(C) COPYRIGHT 1984" : NM$= "BY WILLIAM B. SANDERS" 2550 BK$ = "ASSEMBLY LANGUAGE FOR KIDS:" :CM$ = "COMMODORE 64" 2560 IS$ = "SEE" : F$ = "FOR DOCUMENTATION" 2570 H = 20 - LEN(CR$)/2 : PRINT TAB(H);CR$ 2580 H = 20 - LEN(NM$)/2 : PRINT TAB(H);NM$ 2590 PRINT: H = 20 - LEN(IS$)/2 : PRINT TAB(H);IS$ PRINT 2600 H = 20 - LEN(BK$)/2 : PRINT TAB(H);BK$ :H = 20 - LEN(CM$)/2: PRINT TAB(H);CM$ 2610 H = 20 - LEN(NM$)/2 : PRINT TAB(H);NM$ : PRINT 2620 H = 20 - LEN(F$)/2 : PRINT TAB(H);F$ 2630 LD$ = "LOADING ARRAY" : FOR X = 1 TO 10 : 306 PRINT : NEXT : H = 20 - LEN(LD$)/2 2640 PRINT TAB(H);CHR$(18);LD$ 2650 RETURN CASSETTE ENDING ROUTINE 740 REM ************** 750 REM ENDING ROUTINE 760 REM ************** 770 NB = SA-BA 780 PRINT CHR$(147) 790 FOR X= 1 TO 5 : PRINT : NEXT 800 INPUP'SAVE PROGRAM(Y/N)";AN$ 810 IF AN$ = "Y" THEN 870 820 PRINT : PRINT : PRINT "PROGRAM IS";NB;"BYTES LONG" 830 PRINT "TO EXECUTE 'SYS"';BA : PRINT 840 INPUT "(B)EGIN AGAIN OR (E)ND";DE$ 850IFDE$ = "B"THEN70 860 PRINT : PRINP'END" : END 870 PRINT CHR$(147) : FOR X= 1 TO 5 : PRINT NEXT 880 REM *** TAPE SAVE *** 890 INPUT "ENTER FILE NAME";NF$ 900OPEN21,1,1,NF$ 910 PRINT#21,BA 920 FOR X = BA TO SA - 1 : OC = PEEK(X) 930 PRINT#21,OC 940 N EXT X 950 CLOSE21 960 GOTO 820 CASSETTE PROGRAM LOADER Since you cannot load from tape the same as you can from disk, a special loader program is required. Your assembled program is sav- ed as a SEQ file, and it must be read into memory and then POKEd into memory. The following program will do that for you and show you where it is loaded on the screen: 307 10 PRINT CHR$(147) : X = 20 INPUT "NAME OF FILE ";NF$ 30OPEN21,1,0,NF$ 40 INPUT#21,BA 50 INPUT#21,OC 60POKEBA + X,OC 70 PRINT BA + X.OC 80X = X + 1 90IFST = 0THEN50 100 CLOSE 21 308 APPENDIX B 6510 OPCODES Machine Mnemonic Addressing Opcodes Opcodes Mode Dec Hex 109 $6D ADC Absolute 125 $7D ADC Absolute.X 121 $79 ADC Absolute,Y 105 $69 ADC Immediate 097 $61 ADC (lndirect,X) 113 $71 ADC (lndirect),Y 101 $65 ADC Zero Page 117 $75 ADC Zero Page,X 045 $2D AND Absolute 061 $3D AND Absolute,X 057 $39 AND Absolute,Y 041 $29 AND Immediate 033 $21 AND (lndirect,X) 049 $31 AND (lndirect),Y 037 $25 AND Zero Page 053 $35 AND Zero Page,X 309 Machine Mnemonic Addressing Opcodes Opcodes Mode Dec Hex 014 $0E ASL Absolute 030 $1E ASL Absolute.X 010 $0A ASL Accumulator 006 $06 ASL Zero Page 022 $16 ASL Zero Page,X 144 $90 BCC Relative 176 $B0 BCS Relative 240 $F0 BEQ Relative 044 $2C BIT Absolute 036 $24 BIT Zero Page 048 $30 BMI Relative 208 $D0 BNE Relative 016 $10 BPL Relative 000 $00 BRK Implied 080 $50 BVC Relative 112 $70 BVS Relative 024 $18 CLC Implied 216 $D8 CLD Implied 088 $58 CLI Implied 184 $B8 CLV Implied 205 $CD CMP Absolute 221 $DD CMP Absolute.X 217 $D9 CMP Absolute, Y 201 $C9 CMP Immediate 193 $C1 CMP (IndirectX) 209 $D1 CMP (lndirect),Y 197 $C5 CMP Zero Page 213 $D5 CMP Zero Page,X 236 $EC CPX Absolute 224 $E0 CPX Immediate 228 $E4 CPX Zero Page 204 $CC CPY Absolute 192 $C0 CPY Immediate 196 $C4 CPY Zero Page 206 $CE DEC Absolute 222 $DE DEC Absolute.X 310 Machine Mnemonic Addressing Opcodes Opcodes Mode Dec Hex 198 $C6 DEC Zero Page 214 $D6 DEC Zero Page,X 202 $CA DEX Implied 136 $88 DEY Implied 077 $4D EOR Absolute 093 $5D EOR Absolute,X 089 $59 EOR Absolute,Y 073 $49 EOR Immediate 065 $41 EOR (IndirectX) 081 $51 EOR (lndirect),Y 069 $45 EOR Zero Page 085 $55 EOR Zero Page,X 238 $EE INC Absolute 254 $FE INC Absolute,X 230 $E6 INC Zero Page 246 $F6 INC Zero Page 232 $E8 I NX Implied 200 $C8 I NY Implied 076 $4C JMP Absolute 108 $6C JMP (Indirect) 032 $20 JSR Absolute 173 $AD LDA Absolute 189 $BD LDA Absolute,X 185 $B9 LDA Absolute,Y 169 $A9 LDA Immediate 161 $A1 LDA (lndirect,X) 177 $B1 LDA (lndirect),Y 165 $A5 LDA Zero Page 181 $B5 LDA Zero Page,X 174 $AE LDX Absolute 190 $BE LDX Absolute,Y 162 $A2 LDX Immediate 166 $A6 LDX Zero Page 182 $B6 LDX Zero Page,Y 172 $AC LDY Absolute 311 Machine Mnemonic Addressing Opcodes Opcodes Mode Dec Hex 188 SBC LDY Absolute.X 160 $A0 LDY Immediate 164 $A4 LDY Zero Page 180 $B4 LDY Zero Page,X 078 $4E LSR Absolute 094 $5E LSR Absolute.X 074 $4A LSR Accumulator 070 $46 LSR Zero Page 086 $56 LSR Zero Page.X 234 $EA NOP Implied 013 $0D ORA Absolute 029 $1D ORA Absolute.X 025 $19 ORA Absolute, Y 009 $09 ORA Immediate 001 $01 ORA (lndirect,X) 017 $11 ORA (lndirect),Y 005 $05 ORA Zero Page 021 $15 ORA Zero Page,X 072 $48 PHA Implied 008 $08 PHP Implied 104 $68 PLA Implied 040 $28 PLP Implied 046 $2E ROL Absolute 062 $3E ROL Absolute.X 042 $2A ROL Accumulator 038 $26 ROL Zero Page 054 $36 ROL Zero Page.X 110 $6E ROR Absolute 126 $7E ROR Absolute.X 106 $6A ROR Accumulator 102 $66 ROR Zero Page 118 $76 ROR Zero Page.X 064 $40 RTI Implied 096 $60 RTS Implied 237 $ED SBC Absolute 253 $FD SBC Absolute.X 312 Machine Mnemonic Addressing Opcodes Opcodes Mode Dec Hex 249 $F9 SBC Absolute.Y 233 $E9 SBC Immediate 225 $E1 SBC (lndirect,X) 241 $F1 SBC (Indirectj.Y 229 $E5 SBC Zero Page 245 $F5 SBC Zero Page,X 056 $38 SEC Implied 248 $F8 SED Implied 120 $78 SEI Implied 141 $8D STA Absolute 157 $9D STA Absolute,X 153 $99 STA Absolute, Y 129 $81 STA (lndirect,X) 145 $91 STA (Indirect).Y 133 $85 STA Zero Page 149 $95 STA Zero Page,X 142 $8E STX Absolute 134 $86 STX Zero Page 150 $96 STX Zero Page.Y 140 $8C STY Absolute 132 $84 STY Zero Page 148 $94 STY Zero Page,X 170 $AA TAX Implied 168 $A8 TAY Implied 186 $BA TSX Implied 138 $8A TXA Implied 154 $9A TXS Implied 152 $98 TYA Implied 313 314 APPENDIX C Memory Map 1 : Diagram $E000-$FFFF 57344-65535 8K Kernal ROM $D000-$DFFF 53248-57343 4K I/O or Character ROM $C000-$CFFF 49152-53247 4KRAM $A000-$BFFF 40960-49151 BASIC ROM or ROM Plug-in $8000-$9FFF 3276840959 8KRAM or ROM Plug-in 315 $4000-$7FFF 16K RAM 16384-32767 $0000-$3FFF 16K RAM 00000-16383 $0800 BASIC begins 2048 316 APPENDIX D MEMORY MAP 2 : Places to Visit This map has been abridged so that you can quickly look up the most-often used subroutines, pointers and free spaces you will be using in assembly language programs. All addresses are given in hexadecimal. Since there are fewer digits in hexadecimal numbers, these values are easier to memorize. (You gotta do it sooner or later.) Address What's There $©-$2A Misc. Flags and Pointers $2B-2C Pointer to beginning of BASIC $2D-$2E Pointer to start of variables / end of BASIC program $2F-$C4 Misc. BASIC flags, functions and pointers $C5 ASCII of last key pressed $C6 Number of characters in keyboard buffer $C7 Screen reverse: = off 18 = on 317 Address What's There $C8-$FA Misc. flags, functions and pointers $FB-$FE Free zero page addresses $FF-$280 Misc. flags, functions and pointers $281-$282 Beginning of BASIC memory $283-$284 Top of memory $285-$2BF Misc. flags, functions and pointers $2C0-$2FF Block 11 sprite area $300-$333 Misc. flags, functions and pointers $334-$33B Free space $33C-$3FB Cassette buffer- MACHINE LANGUAGE STORAGE $3FC-$3FF Free space $340-$37F Block 13 sprite area $380-3BF Block 14 sprite area $3C0-$3FF Block 15 sprite area $400-$7FF Screen memory 24 x 40 $7F8-$7FF Sprite pointers for data $800-$9FFF BASIC RAM $8000-$9FFF Plug in ROM or MACHINE LANGUGE STORAGE $A000-$BFFF BASIC ROM $C000-CFFF Free RAM - MACHINE LANGUAGE STORAGE $D000 Sprite X position $D001 Sprite Y position $D002 Sprite 1 X position $D003 Sprite 1 Y position $D004 Sprite 2 X position $D005 Sprite 2 Y position $D006 Sprite 3 X position $D007 Sprite 3 Y position $D008 Sprite 4 X position $D009 Sprite 4 Y position $D00A Sprite 5 X position $D00B Sprite 5 Y position $D00C Sprite 6 X position $D00D Sprite 6 Y position $D00E Sprite 7 X position 318 Address What's There $D00F Sprite 7 Y position $D010 High byte of sprite X position $D011-$D01F Misc. flags, functions and pointers $D020 Border color register $D021 Background color register $D022 Background color 1 register $D023 , Background color 2 register $D024 Background color 3 register $D025-$D026 Sprite muiti-color registers $D027-$D02E Sprite color registers $D400-$D418 Sound registers $D419 Game paddle 1 or 3 $D41A Game paddle 2 or 4 $D41B Random number generator $D41C-$DD0F Mis. registers $E000-$FFFF Kernal ROM $E544 Clear screen $E566 Home cursor in upper left hand corner $E716 Output to screen $E8E7 Scroll screen $FF9F SCNKEY - scan keyboard $FFCF CHRIN - input a character $FFD2 CHROUT - output a character $FFE4 GETIN - get a character $FFF0 PLOT - read or set X,Y postion of cursor 319 320 APPENDIX E BASIC TOKEN CHART Your Commodore 64 reads BASIC statements as tokenized codes. In a disassembled listing of a BASIC program, the following tokenized values can be found representing the BASIC statements. DEC HEX Keybd. DEC HEX Keybd. 128 $80 -END 165 $A5 - FN 129 $81 - FOR 166 $A6 - SPC( 130 $82 - NEXT 167 $A7- THEN 131 $83 - DATA 168 $A8 - NOT 132$84-INPUT# 169 $A9 - STEP 133 $85 - INPUT 170 $AA - + 134 $86 -DIM 171 $AB-- 135 $87 - READ 172 $AC-* 136 $88 - LET 173 $AD-/ 137 $89 - GOTO 174 $AE- 138$8A-RUN 175 $AF - AND 139 $8B - IF 176$B0-OR 140 $8C - RESTORE 177 $B1 - 141 $8D - GOSUB 178 $B2- = 321 DEC HEX Keybd. DEC HEX Keybd. 142 $8E - RETURN 179 $B3- 143$8F-REM 180 $B4 - SGN 144 $90 - STOP 181 $B5 - INT 145 $91 - ON 182 $B6 - ABS 146 $92 - WAIT 183 $B7 - USR 147 $93 - LOAD 184 $B8 - FRE 148 $94 - SAVE 185 $B9 - POS 149 $95 - VERIFY 186 $BA - SQR 150 $96 - DEF 187$BB-RND 151 $97 - POKE 188$BC-LOG 152 $98 - PRINT* 189 $BD - EXP 153 $99 -PRINT 190$BE-COS 154 $9A - CONT 191$BF-SIN 155 $9B - LIST 192 $C0 - TAN 156 $9C - CLR 193 $C1 - ATN 157 $9D - CMD 194 $C2- PEEK 158 $9E - SYS 195 $C3 - LEN 159 $9F - OPEN 196$C4-STR$ 160 $A0 - CLOSE 197 $C5 - VAL 161 $A1 - GET 198$C6-ASC 162 $A2 - NEW 199 $C7 - CHR$ 163 $A3 - TAB( 200 $C8 - LEFT$ 164 $A4 - TO 201$C9-RIGHT$ 202 $CA - MID$ 322 APPENDIX F HEXADECIMAL-DECIMAL CONVERSION HEX DEC HEX DEC HEX DEC HEX DEC HEX DEC 51 $66 = 102 $99 = 153 $CC = 204 52 $67 = 103 $9A = 154 $CD = 205 53 $68 = 104 $9B = 155 $CE = 206 54 $69 = 105 $9C = 156 $CF = 207 55 $6A = 106 $9D=157 $D0 = 208 56 $6B = 107 $9E=158 $D1=209 57 $6C=108 $9F=159 $D2 = 210 58 $6D = 109 $A0 = 160 $D3 = 21 1 59 $6E=110 $A1=161 $D4 = 212 60 $6F = 111 $A2 = 162 $D5 = 213 61 $70 = 112 $A3 = 163 $D6 = 214 62 $71 = 113 $A4=164 $D7 = 215, 63 $72 = 114 $A5=165 $D8 = 216 64 $73=115 $A6=166 $D9 = 217 65 $74 = 116 $A7=167 $DA = 218 66 $75=117 $A8=168 $DB = 219 67 $76 = 118 $A9 = 169 $DC = 220 68 $77 = 1 19 $AA = 1 70 $DD = 221 323 $00 = $33 = $01 = 1 $34 = $02 = 2 $35 = $03 = 3 $36 = $04 = 4 $37 = $05 = 5 $38 = $06 = 6 $39 = $07 = 7 $3A = $08 = 8 $3B = $09 = 9 $3C = $0A = 10 $3D = $0B = 11 $3E = $0C = 12 $3F = $0D = 13 $40 = $0E = 14 $41 = $0F = 15 $42 = $10 = 16 $43 = $11 = 17 $44 = HEX DEC HEX DEC HEX DEC HEX DEC HEX DEC $12 = $13 = $14 = $15 = $16 = $17 = $18 = $19 = $1A = $1B = $1C = $1D = $1E = $1F = $20 = $21 = $22 = $23 = $24 = $25 = $26 = $27 = $28 = $29 = $2A = $2B = $2C = $2D = $2E = $2F = $30 = $31 = $32 = $33 = 18 $45 = 19 $46 = 20 $47 = 21 $48 = 22 $49 = 23 $4A = 24 $4B = 25 $4C = 26 $4D = 27 $4E = 28 $4F = 29 $50 = 30 $51 = 31 $52 = 32 $53 = 33 $54 = 34 $55 = 35 $56 = 36 $57 = 37 $58 = 38 $59 = 39 $5A = 40 $5B = 41 $5C = 42 $5D = 43 $5E = 44 $5F = 45 $60 = 46 $61 = 47 $62 = 48 $63 = 49 $64 = 50 $65 = 51 $66 = 69 $78= 70 $79= 71 $7A: 72 $7B: 73 $7C: 74 $7D: 75 $7E= 76 $7F= 77 $80= 78 $81 = 79 $82= 80 $83= 81 $84= 82 $85= 83 $86= 84 $87= 85 $88= 86 $89= 87 $8A= 88 $8B: 89 $8C: 90 $8D: 91 $8E: 92 $8F: 93 $90: 94 $91= 95 $92: 96 $93= 97 $94: 98 $95= 99 $96= 100 $97: 101 $98: 102 $99: 120 $AB: 121 $AC: :122 $AD: :123 $AE: :124 $AF: :125 $B0= : 126 $B1 = =127 $B2= 128 $B3= 129 $B4= 130 $B5= 131 $B6: 132 $B7= 133 $B8= 134 $B9= 135 $BA = 136 $BB: 137 $BC: :138 $BD: :139 $BE: :140 $BF: = 141 $C0 = :142 $C1: =143 $C2: =144 $C3: :145 $C4: :146 $C5: :147 $C6: :148 $C7: :149 $C8= :150 $C9 = :151 $CA: :152 $CB: :153 $CC: 171 $DE = 222 172$DF = 223 173 $E0 = 224 174 $E1=225 175 $E2 = 226 176 $E3 = 227 177 $E4 = 228 178 $E5 = 229 179 $E6 = 230 180 $E7 = 231 181 $E8 = 232 182 $E9 = 233 183 $EA = 234 184 $EB = 235 185 $EC = 236 :186$ED = 237 = 187 $EE = 238 = 188 $EF = 239 = 189 $F0 = 240 = 190 $F1=241 = 191 $F2 = 242 :192 $F3 = 243 193 $F4 = 244 194 $F5 = 245 195 $F6 = 246 196 $F7 = 247 197 $F8 = 248 :198 $F9 = 249 ;199 $FA = 250 200 $FB = 251 201 $FC = 252 = 202$FD = 253 :203$FE = 254 :204$FF = 255 324 APPENDIX G DECIMAL-HEXADECIMAL CONVERSION CHART DEC HEX DEC HEX DEC HEX DEC HEX DEC HEX = $33 102 = $66 153 = $99 204 = $CC = $34 103 = $67 154 = $9A 2C5 = $CD = $35 104 = $68 155 = $9B 206 = $CE = $36 105 = $69 156 = $9C 207 = $CF = $37 106 = $6A 157 = $9D 208 = $D0 = $38 107 = $6B 158 = $9E 209 = $D1 = $39 108 = $6C 159 = $9F 210 = $D2 = $3A 1 09 = $6D 160 = $A0 21 1 = $D3 = $3B 110 = $6E 161=$A1 212 = $D4 = $3C 111=$6F 162 = $A2 213 = $D5 = $3D 112 = $70 163 = $A3 214 = $D6 = $3E 113 = $71 164 = $A4 215 = $D7 = $3F 114 = $72 165 = $A5 216 = $D8 = $40 115 = $73 166 = $A6 217 = $D9 = $41 116 = $74 167 = $A7 218 = $DA = $42 117 = $75 168 = $A8 219 = $DB = $43 118 = $76 169 = $A9 220 = $DC = $44 1 19 = $77 170 = $AA 221 = $DD 325 = $00 51 1 = $01 52 2 = $02 53 3 = $03 54 4 = $04 55 5 = $05 56 6 = $06 57 7 = $07 58 8 = $08 59 9 = $09 60 10 = $0A 61 11 = $0B 62 12 = $0C 63 13 = $0D 64 14 = $0E 65 15 = $0F 66 16 = $10 67 17 = $11 68 DEC HEX DEC HEX DEC HEX DEC HEX DEC HEX 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 :$12 69 = :$13 70 : :$14 71 = :$15 72 = :$16 73 : :$17 74 = :$18 75 = :$19 76 = $1A 77 = $1B 78 = $1C 79 = $1D 80 : :$1E 81 : :$1F 82 : :$20 83 : :$21 84 : = $22 85 : :$23 86 : :$24 87 : :$25 88 : :$26 89 : :$27 90 : =$28 91 : = $29 92 -. :$2A 93 = :$2B 94 : :$2C 95 : :$2D 96 : :$2E 97 : :$2F 98 : :$30 99 : =$31 100: :$32 101: :$33 102: :$45 120: :$46 121: =$47 122= :$48 123= :$49 124= $4A 125= $4B 126: $4C 127= $4D 128: :$4E 129: :$4F 130: :$50 131= :$51 132: :$52 133: :$53 134: =$54 135: :$55 136: :$56 137: :$57 138: =$58 139= :$59 140: :$5A 141: :$5B 142: :$5C 143: :$5D 144: :$5E 145: :$5F 146: =$60 147: :$61 148: :$62 149: :$63 150: :$64 151: =$65 152: :$66 153: :$78 171 =$79 172 $7A 173 $7B 174 $7C 175 $7D 176 :$7E 177 :$7F 178: :$80 179: =$81 180: :$82 181: :$83 182: :$84 183: :$85 184: =$86 185: :$87 186= :$88 187= :$89 188: :$8A 189: :$8B 190: :$8C 191: :$8D 192: :$8E 193 :$8F 194: :$90 195: :$91 196: :$92 197: :$93 198: =$94 199= :$95 200: :$96 201: :$97 202: :$98 203: :$99 204: = $AB222 = $DE = $AC223 = $DF = $AD 224 = $E0 = $AE 225 = $E1 = $AF 226 = $E2 = $B0 227 = $E3 = $B1 228 = $E4 = $B2 229 = $E5 = $B3 230 = $E6 $B4 231=$E7 $B5 232 = $E8 $B6 233 = $E9 $B7 234 = $EA $B8 235 = $EB $B9 236 = $EC = $BA237 = $ED = $BB 238 = $EE = $BC 239 = $EF = $BD 240 = $F0 = $BE 241=$F1 = $BF 242 = $F2 = $C0 243 = $F3 = $C1 244 = $F4 = $C2 245 = $F5 = $C3 246 = $F6 $C4 247 = $F7 $C5 248 = $F8 $C6 249 = $F9 $C7 250 = $FA $C8 251=$FB $C9 252 = $FC $CA253 = $FD $CB 254 = $FE $CC255 = $FF 326 APPENDIX H SCREEN STORAGE ADDRESS TABLE $400 $428 $450 $478 $4A0 $4C8 $4F0 $518 $540 $568 $598 $5B8 $5E0 $608 $830 $6A8 $6D0 $6F8 $720 $748 $770 $798 $7C0 1fl?4 1084 1104 1144 1184 1224 1264 1304 1344 1384 1424 1464 1504 1544 1584 1824 1864 1704 1744 1824 1904 1944 327 328 APPENDIX I COLOR STORAGE LOCATION TABLE $D8W 55296 $D828 55336 $D878 55416 $D8A0 55456 $D8C8 55496 $D8FB 55536 $D918 55576 $D94D 55616 $0968 55656 $D990 55696 $D9B8 55736 $D9Efl 55776 $DA08 55816 $DA3B 55856 $DA58 55896 $DA8fi 55936 $DAA8 55976 $DAM 561116 $DAF8 56856 $DB20 56696 $DB48 56136 $DB70 56176 $DB98 56216 329 330 APPENDIX J ASCH CODE These characters appear on the screen when sent from the ac- cumulator using the CHROUT subroutine or output to screen routines (JSR $E716). See APPENDIX K for screen codes that ap- pear when the code is output with STA to a screen address (1024-2023). All values to the left are the ASCII values, and all characters, symbols and descriptions to the right are screen displays 513 IKQ 153 Lt Green 204 □ 1 524 l®3 154 Lt Blue 205 S 2 535 I04Q 155 Gray 3 206 3 546 I05 156 Purple 207 □ 4 557 06 □ 157 CRSR left 208 [] 5 White 568 107 158 Yellow 209 H 6 57 9 I08D 159 Cyan 210 □ 7 58: 89 S 16© SPACE 211 H 8 Sh-CMD off59 ; 10 161 E 212 D 9Sh-CMDon60< 11 n 162 y 213 Q 1® 61 = 12 □ 163 n 214 13 11 62 > 113 ■ 164 G 215 O 331 12 63? 13 RETURN 64 @ 14 Lowercase 65 A 15 66 B 6 67 C 17 CRSR 68 D down 18 RVS on 69 E 19 Home 7© F CRSR 20 Delete 71 G 21 72 H 22 73 1 23 74 J 24 75 K 25 76 L 26 77 M 27 78 N 28 Red 79 O 29 CRSR right 80 P 30 Green 31 Blue 32 SPACE 33! 34" 35# 36$ 37% 38& 39' 40( 41) 42* 43 + 44, 45- 46. 47/ 480 491 502 81 Q 82 R 83S 84T 85U 86V 87 W 88X 89 Y 90Z 91 [ 92 £ 93 ] 94 t 95*- 96B 97 98D3 99H 10© B 101 □ 14 □ 15 16 D 17 Q 18 IE 19 O 20 B 21 a 22 H 23ffl 24 SD 25 m 26 H 27 s 28 29 Orange 30 31 32 33 f1 34 f3 3515 36 f7 37 f 2 38 f4 39 16 40 f8 165 G 166 B 167 □ 168 Q 169 B 170 [J 171 E 172 a 173 H 174 ED 175 U 176 El 177 H 178 H 179 m 180 D 181 C 182 Of 183 n 184 H 185 U 186 □ 187 H 188 [3 189 a 190 E 191 H 192 EB 41 Sh- RETURN 42 Uppercase193 B 43 194 [JJ 44 Black 195 g 45 CRSR up 196 F=] 46 RVS off 197 Q 47CLR/ 198 □ HOME 48 INST 199 □ 49 Brown 200 Q] 50LtRed 201 □ 51 Gray 1 202 Q 52 Gray 2 203 □ 216 B 217 O 218 B 219 EB 220 B 221 LH 222 223 H 224 SPACE 225 L 226 y 227 n 228 D 229 n 230 B 231 a 232 a 233 B 234 a 235 m 236 a 237 H 238 H 239 U 240 H 241 H 242 H 243 Bl 244 □ 245 C 246 a 247 n 248 n 249 Q 250 Q 251 £ 252 [J 253 E 254 E 255 [£ 332 APPENDIX K SCREEN STORAGE DISPLAY CODES When values are stored in addresses 1024-2023 ($400-$7E7) they will appear as the characters in this chart. The first set is upper case and full graphics (UC), and the second set (UC/LQ is upper case and lower case. If your keyboard is set to upper case and full graphics, you will get the characters in the first set, and if it is set to upper/lower case, you will get the second. Thus, any value that you STA (or STX or STY) in these addresses will show up on the screen as alphanumeric or graphic characters # UC UC/LC .# UC UC/LC # UC UC/LC # UC UC/LC # UC UC/LC @ @ 513 3 102 B HS 153 204 1 A a 52 4 4 103 □ 3 154 205 2B b 53 5 5 104 a $4 155 206 3C c 54 6 6 105 B. a 156 207 4D d 55 7 7 106 CI 3 157 208 5E e 568 8 107 m B 158 209 6F f 57 9 9 io8 a 1 159 210 7G g 58: : 109 E 3 160 211 8H h 59; i no ED 3 161 212 91 i 60 < < m U J 162 213 10 J J 61 = = n2 ca -d 163 214 333 # UC UC/LC # UC UC/LC # UC UC/LC # UC UC/LC # UC UC/LC 11 12 K L 13 M 14 N 15 16 O P 17 Q 18 R 19 20 21 22 S T U V 23 W 24 X Y Z k I m n o P q r s t u v w X y z 25 26 27 28 29 30 31 32 SPACE 33 ! ! 34 " " 35 # # 36 $ $ 37 % % 38 & & 40 41 42 * 43 4 44 , 45 - 46 . 47 / 48 49 1 50 2 ( ( ) ) 62 ► ► 63 ? ? 64 B B 65 H A 66 [D B 67 B 68 H 69 n 70 □ 1 2 81 82 □ 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 71 D G 72 [1 H 73 □ 1 74 U J 75 W K 76 D L 77 K M 78 N 79 □ 80 □ P 13 HH 14 sa 15 BIB] 16 CD 17 EC isoia 19 nc !2o n r 121 Bt- 122 QE 23. . i24H a i25H a I26E E 27 SB 28 - 255 reverse video of 0-127 Q R H s D T Q u (El v D w S x GO y H z m m B H E E y h n n D D □ □ 334 INDEX This INDEX covers the major references to various key terms. Many of the opcodes were used throughout the book in several pro- grams, but their only reference in the Index are to those places where pertinent information was introduced or elaborated. Terms in the Appendices are not in the Index but are located at the beginn- ing of the Appendices. A-B ABSOLUTE MODE 132-133, 184 ACCUMULATOR 104-105 ADC 186-189 ADDRESSING MODES 123 ANIMATION 230-237 APPEND 151-153, 280-290 ASC 21 1-215 ASCII 200, 237 ASSEMBLE SOURCE CODE 56 ASSEMBLERS 5, 21-26, 24 ASSEMBLER64 80-82 ASSEMBLY LANGUAGE 6-8 BASIC 10-15 BASIC LOGIC 167 BEQ 170, 177-181 BINARY NUMBERS 91-101 BNE 170, 177-181 BOOKS 291-293 BRANCH 166-167, 171, 177-181, 179 BREAK FLAG 107 .BYTE (directive) 21 1-215, 262, 269 BYTE 123-124 C-D CARRY FLAG 108 CHANGE 63, 79, 285 CHROUT 127, 195-197, 199, 225-227, 238 CLC 187-189,226 CMP 169 335 COLOR 200-201, 222 COLOR CODES 19 COMMODORE 64 MACRO ASSEMBLER 73-89 COPY 64-65 CPX 169 CPY 169 DEC 184 DECIMAL FLAG 107 DELETE 61 80 DEX 148-150 DEY 148-150 DFB 262, 264-265, 269 DISASSEMBLER 26 DOS WEDGE64 73,78 E-F EDITORS 23-24 EDITOR64 73-80, 280 EOR 205-207 FIELDS 27-28 FIND 80 FLAGS 105-108 FORMAT 76, 89 G-H GET 79 GETIN 127, 194-195 GRAPHICS 219-246 GROTKE-GUY 37, 138 HEADER 77 HEXADECIMAL NUMBERS 91-101 HIGH BYTE 35, 97, 121-123 HIGH NIBBLE 99 l-J IMMEDIATE MODE 132-133 IMPLIED MODE 132-133 INC 184-186 INDEXED ABSOLUTE MODE 154-156 INDEXED INDIRECT MODE 157-160 INDEXED MODE 172-177, 185 INDIRECT INDEXED MODE 161-163 INSERT 60, 285 INTERRUPT FLAG 107 INX 148-150 INY 148-150 JMP 177-181 JOYSTICK 193, 203-211, 237-246, 285 JSR 126-128, 198-199 K-L KERNAL 127 KEYBOARD 194-203 KIDS* ASSEMBLER 29-51 LABEL FIELD 27 LABELS 195 LDA 129-132 LINE NUMBERS 113-116 LIST 59 LOAD PROGRAM 36-38, 67, 79, 138-139 LOADERS 82-83 LOADERS AND SAVERS 25 LOADING PROGRAMS 48-50 LOOPS 166, 168-177, 178 LOW BYTE 35, 97, 121-123 LOW NIBBLE 99 LOW RESOLUTION GRAPHICS 220-228 M-N MACHINE LANGUAGE 6-8 MAGAZINES 293-294 MEMORY 116-119, 126, 134-142 MERGING SUBROUTINES 280-290 MERLIN64 ADD MODE 56 MERLIN64 COMMAND MODE 55 MERLIN64 EDITOR 55, 59-66 MERLIN64 EXECUTIVE MODE 54 MERLIN64 53-72 MESSAGE MAKER 215-217 MNEMONIC 5 MONITOR 25-26, 70, 83-88, 119-121 MOVE 65, 285 NEGATIVE FLAG 106 NESTED LOOPS 175-177 NUMBER CONVERSION 91-101 O-P OBJECT CODE 24 336 OPCODES 5, 22, 23, 30-31, 39-41, 47-48, 123-124, 289-290 OPCODE FIELD 44 OPERANDS 22, 23, 32 OPERAND FIELD 44 ORG 125-126 OVERFLOW FLAG 107 PEEK 11-12, 219, 247 PLOT 127, 225-229, 232, 237 POKE 16-17, 219, 247 PRG FILE 38, 37 PRINTER 62-63 PROCESSOR STATUS REGISTER 105-106 PROGRAM COUNTER 110 PUT 78 R-S RAM 44 REGISTERS 103-111 RENUMBER 76-77 REPLACE 65-66 SAVE CODE 78 SAVE FILE 57, 86 SAVE GRAPHICS 228-229 SAVE OBJECT CODE 58-59 SAVE SOURCE CODE 57 SBC 186, 190-191 SCNKEY 127, 194-195 SCREEN ADDRESSES 140-141 SEC 187, 190-191 SEQ FILE 36 SEQUENTIAL STRUCTURE 165 SOFT SWITCHES 135-137 SOUND 274-278 SOUND REGISTERS 275 SOURCE CODE 23 SOURCEROR 68-69 SPRITE & SOUND 84, 281-282 84 SPRITE ASSEMBLER 265-267 SPRITE COLOR 254 SPRITE CREATION 251-256 SPRITE ENABLE 253-254 SPRITE EXPANSION 272-274 SPRITE MATRIX 248 SPRITE MOVEMENT 255-256, 272 SPRITE POINTERS 253 SPRITE STORAGE 252 SPRITES 247-274 STA 134, 150 STACK POINTER 108-110 STRUCTURE 165-181 STX 150 STY 150 SUBROUTINES 13-15, 126-128 SYS 25, 37, 46, 59, 193, 228 T-U TAY146 TOKENS 12 TXA 146-148 TYA 146-148 TYPES OF ASSEMBLERS 8-9 USER GROUPS 290-291 x-z X REGISTER 105, 143-163, 172, 223 Y REGISTER 105, 143-163, 172, 222 ZERO FLAG 107 ZERO PAGE 160 337 Like printing your own money... SPECIAL 10 % REBATE OFFER Now that you have taken the first step toward learning how to program in assembly language, why not do yourself a favor and get Merlin 64, the best assembler available for the Commodore 64, and save a little money at the same time! Merlin 64 features includes nestable macros, assemble to disk, use of linked source files, over 35 psuedo opcodes, handy crossreference utilities, a powerful Editor, and a Monitor to move, compare, disassemble and dump blocks of memory. Merlin 64 also includes Sourceror, an easy to use disassembler that creates Merlin 64 source files for editing from binary programs. And here's the best part. We are making you "an offer you can't refuse!" That's right! We are offering to pay you to use Merlin 64. Merlin 64 will make your assembly language programming a breeze, and put some cash back into your pockets in the process. And, just like Merlin 64, the rebate is easy to use. Just fill out and send in this certificate to receive a "ONE TIME ONLY" 10% (ten percent) REBATE of the net purchase price (excluding state or local taxes) of Merlin 64. Just send us your original, itemized sales receipt or invoice (as proof of pur- chase) and the completed Software Registration Form enclosed in each package accompanied by this certificate and we'll write you a check! Your receipt will be returned to you along with your rebate check. For your protection, we recommend that you make a photocopy of the sales receipt prior to mailing. (Please print) NAME: ADDRESS:. CITY, STATE, ZIP: PHONE:* L_ Net Purchase Price $ Rebate Amount Due $ (Your Signature) OUR GUARANTEE Roger Wagner Publishing products carry the unconditional guarantee of satisfaction or your money back. Any product may be returned to place of purchase for complete refund or replacement within thirty (30) days of purchase if accompanied by the sales receipt or other proof of purchase. Roger Wagner Publishing P.O. Box 582, 10761-E Woodside Ave. Santee, CA 92071 PH: (619) 562-3670 Rebate offer and prices as of 8/1/84, subject to change without notice. = = KIDS' ASSEMBLER ON DISK = = ONLY $10 If you don't feel like keying in the Kids' Assembler, you can get it cheap from MICROCOMSCRIBE. There's nothing new on the disk that's not in the book, except it's an inexpensive way to save time keying in the assemblers, supporting programs and avoiding typos you might make. The compiled version of the Kids' Assembler runs a lot faster than the BASIC version. Here's what you get: KIDS ASSEMBLER1 KIDS ASSEMBLER2 KIDS ASSEMBLER1-C (Cassette) KIDS ASSEMBLER2-M (Compiled-Disk only) SOURCE READER-D (Disk) SOURCE READER-C (Cassette) CASSETTE LOADER (Cassette) HEX-DEC CONVERTER BINARY-DEC CONVERTER Fill out the following coupon: NAME ADDRESS CITY STATE ZIP Send coupon and $10 to: MICROCOMSCRIBE 8982 STIMSON COURT SAN DIEGO, CA 92129 (California residents add 6% sales tax. $10.60 total.) ONLY disks will be mailed. If you have a cassette system, be sure you can bor- row a disk drive to download the programs to your tape. (Better yet, save the ten bucks toward a purchase of a disk drive.) USER GROUPS and EDUCATIONAL INSTITUTIONS will receive special considerations. Write MICROCOMSCRIBE for details. % % % % % % OFFER EXPIRES 12/31/86 % % % % % % % % ASSEMBLY LANGUAGE FOR KIDS COMMODORE 64 by WILLIAM B. SANDERS LEARN ASSEMBLY LANGUAGE PROGRAMMING If you'd rather be one of the kids who writes professional quality arcade games than one who just plays them, learn machine/assembly language programming, WHAT COMPUTER? Everything in this book is for the Commo- dore 64. You'll get the right information for your computer; not everyone else's. WHO'S THIS BOOK FOR? If you know BASIC and want to learn the fastest language in programming; this book is for you. (If you're an adult, teli them you got it for your nephew in Borneo.) This is an elementary book for learning to use assemblers and assembly/ machine language programming on your Commodore 64. WHICH ASSEMBLER? Three assemblers are fully covered and most others for the Commodore 64 are compatible with all pro- grams. Commodore's assembler. The Commodore 64 Macro Assembler Development System, is clearly explained with lots of examples. The Merlin assembler is clearly explained with lots of examples. If you don't have an assembler, there's a simple-to-learn and use listing of the Kids' Assembler written in BASIC for you free in the book, The Kids' Assembler assembles programs for you, and it wiil help you learn about assembly/machine language programming. WHAT YOU GET - An Assembler and instructions on using the most popular Com- modore 64 assemblers. - Charts covering everything from hexadecimal - decimal conver- sions to BASIC tokens to 6510 opcodes. - Step-by-step clear explanations and clear examples of assembly language programming. - Practical utility programs in assembly/machine language you can write yourself (and understand!). - Amazing graphics, stupendous sprites, booming sounds, blinding speed, fame, fortune and a heck of a lot of fun. Written by, William B. Sanders, the author of the best-selling Ele- mentary Commodore 64; you will learn assembly language more simply than you thought possible. miorocomscribe literate Microcomputer Documentation ISBN 0—931145-00—7