ASSEMBLY LANGUAGE PROGRAMMING

PART NINE: WRITING ARBITRARY MEMORY


     Last time I presented routines to read bytes from
arbitrary memroy locations. This time, I fill in the
blanks for writing to arbitrary memory locations. With
these routines, we now have a cookbook which contains all
the code necessary to access the entire memory space of
the CoCo3.

     Now is probably a good time to consider some
efficiency issues. It should be noted that this is by no
means the most efficient means of doing exactly this.
However, if your application has no speed requirements,
it will probably suffice. If, however, speed is critical,
you should probably use techniques demonstrated in this
series to write your own from scratch using much more
efficient algorithms.

     I will also note here, again, that none of the code
thus far presented has been tested. I am reasonably
certain that it will work, but that is based on sheer
logic, not any concrete tests. I could easily have made a
typo or other sort of error. As noted last time, it could
be a learning experience for you if something doesn't
work the way you expected it to. I have personally
learned much more from debugging someone else's code than
I ever did by debugging my own. As always, let me know if
you find a bug. (Include the fix as well.)

     One thing you might take on yourself is to make the
various read/write functions set the flags according to the
way regular load/store would. That may involve modifying a
large amount of code, but it should be possible. If anyone
should succeed in so doing, I would be interested in
receiving the code.

     Also, you can reach me with ideas, contributions, or
other correspondence via the internet at
astlew@bigfoot.com. I'm sure most of you have internet
connectivity by now. Next time, I hope we can actually
use some of these routines to actually do something.
(That's where any bugs will start to show up.)

    'Till next time.