CS 231: Introduction to Programming
Lab 7: More Programming Problems for the PC-231

Assigned: Fri 3 March 2000
Due: Friday 17 March 2000


This lab consists of a couple more exercises programming the PC-231 computer as described in the PC-231 Computer Supplement. As with the last lab, you will probably want to keep the Supplement open in a second window while you work.

The emphasis on this lab is on loops, that is, on programs which use the JUMP and JPIF commands to effect the controlled re-execution of a set of commands. By "controlled re-execution", I mean that one must always ask how it is that the loop will stop; JPIF is almost always the right way to do this. You should be sure you understand the sample programs which were developed in class that used the JPIF command, including the use of indirection through the jump registers.

Contents


Exercise #1: Translating omelette orders

Recall the omelette exercise from Lab 3, in which we explored several different ways of representing omelettes with various ingredients in digital form. Although the hexadecimal format was best for most situations, it probably isn't the easiest for most people to read.

Write a program which will read in numbers in hexadecimal format representing omellete orders and print out an ASCII version using the initial letters for the ingredients as given in Lab 3. Your program should read in hexadecimal numbers representing ingredients until it reads the sentinel value xFF. The program should print out the ASCII initials representing the same ingredients, in the same order.

You may choose whether you would like to read in all the ingredients first and then print out the results, or whether you would rather read them and print them alternately (i.e., read and print, one after another). As an example of how your program should work, if you type the following hexadecimal order in (perhaps on several lines, as prompted by the machine): 

	0  8  F  FF
then your program should type out the ASCII letters for asparagus, jack cheese and tomato (again, perhaps interspersed with other output from the machine): 
	A  J  T


Exercise #2: Translating uppercase to lowercase

In this exercise, we imagine that you are writing part of a larger program such as an e-mail client or word processor. As part of the conveniences provided for the user, you are to write a program which will convert text written in upper case (or mixed case) into lower case form. In actual practice, this conversion would be likely to be done "in-place" in memory; in order to make the demos a bit easier, we will instead translate the text character by character as it is read in from the user.

Your program, therefore, should read in successive ASCII inputs from the user, echoing them back in a possibly modified form. When an upper case letter is read, it should be echoed back out in lower case form (i.e., 'A' changes to 'a', 'B' to 'b', etc.). Letters already in lower case form should be echoed back out unchanged, as should spaces, punctuation, digits, etc. We will consider the exclamation point '!' as a special character which terminates the process; i.e., once this character is read, the program should shut down.

Hints and tips:

You will of course want to use ASCII READs and WRITEs for your program, along with appropriate tests for the kind of character input. Break the problem down into parts, and implement each one before you move on to the next. Some suggested stages: