Elementary Data Structures

Figure 10.2. A Histogram

If the precision is 2 and the origin is 1, then if i is in accumulator B, Z(i) can be loaded

The origin is 1 for Z in the segments (2) and (3). It seems obvious by now that for assembly language or C programming, an origin of 0 has a distinct advantage because the DECS instruction can be eliminated from segments (2) and (3) if Z has an origin of 0. Unless stated otherwise, we will assume an origin of 0 for all of our indexable data structures. Accessing the elements of vectors with higher precision is straightforward and left to the problems at the end of the chapter.

A histogram is implemented with a vector data structure. In a histogram, there are, say, 20 counters, numbered zero through nineteen. Initially all counters are zero. A stream of numbers arrives, each between zero and nineteen. As each number i arrives, counter i is incremented. This vector of counts is the histogram.

Figure 10.2 illustrates the first six counts of the histogram Z, An item "2" arrives, so counter 2 should be incremented. In C, if the vector is Z and the number "2" is in i, then z [i]++; increments the counter for number "2"; and, in assembly language, if this number "2" is in index register X, then the instruction in (4) will increment the

Histograms are useful in gathering statistics. We used them to "reverse engineer" a TV infrared remote control; the counts enabled us to determine how a "1" and a "0" were encoded as pulse widths and how commands were encoded into 1 's and O's. Note that the data structure is a vector. Counts are accessed in random order as items arrive.

A list is similar to a vector except that each element in the list may have a different precision. Lists are stored in memory in buffers just like vectors, successive elements in successive memory locations. Like a vector, there is an origin and a length and each element of the list can be accessed. However, you cannot access the ith element of a list by the simple arithmetic computation used for a vector. Consider the following example of a list L that consists of 30 bytes for*a person's name (ASCII), followed by 4 bytes for his or her Social Security number (in C, an unsigned long), followed by a 45-byte address (ASCII), and another 4 bytes for the person's telephone number (an unsigned long). This list then has four elements, which we can label LO,LI, L2, and L3, and

Figure 10.7. Subroutines for Pushing and Pulling B from the Top of the Deque

at the start of our program. If accumulator A contains the number of elements in the deque and if X and Y are the top and bottom pointers, we would initialize the deque with

Pushing and pulling bytes between B and the top of the deque could be done with the subroutines PSHTP and PLTP, shown in Figure 10.7. The index register X points to the top of the deque, while the index register Y points to the deque's bottom.

Similar subroutines can be written for pushing and pulling bytes between B and the bottom of the deque. In this example, if the first byte is pushed onto the top of the deque, it will go into location DEQUE, whereas, if pushed onto the bottom, it will go into location DEQUE+4 9. Accumulator A keeps count of the number of bytes in the deque and location ERROR is the beginning of the program segment that handles underflow and overflow in the deque.

Usually, you do not tie up two index registers and an accumulator to implement a deque as we have done above. The pointers to the top and bottom of the deque and the count of the number of elements in the deque can be kept in memory together with the buffer for the deque elements. The subroutines for this implementation are easy variations of those shown in Figure 10.7. (See the problems at the end of the chapter.)

A queue is a deque where elements can only be pushed on one end and pulled on the other. We can implement a queue exactly like a deque but now only allowing, say, pushing onto the top and pulling from the bottom. The queue is a far more common sequential structure -than the deque because the queue models requests waiting to be serviced on a first-in first-out basis. Another very common variation of the deque, which is close to the queue structure, is the shift register or first-in first-out buffer. The shift register is a full deque that only takes pushes onto the top, and each push on the top is

Figure 10.11. Flowchart for Scanning Tree

In C, the linkage can be by means of indexes into a table, which is a vector of structs. The following procedure is intially called as in scan ( 0 ) ;

typedef struct node{char c; unsigned char l,r; } node; node table[10]; void scan(unsigned char i)

{if(i!=0xff) {scan(table[i].l);outch(table[i].c);scan(table[i].r); }}

A similar approach is used in assembly language, in the subroutine shown in Figure 10.12. It simply implements the flowchart, with some modifications to improve static efficiency. First, index register X points to the Oth list, so that LINK can be input as a parameter in accumulator B. This link value is multiplied by three to get the address of the character of the list. That address, with one added, gets to get the link to the left successor, and that address, with two added, gets the link to the right successor. The subroutine computes the value 3 * LINK and saves this value on the stack. In processing the left successor, the saved value is recalled, and one is added. The number at this location, relative to X, is put in B, and the subroutine is called. To print the letter, the saved value is recalled, and the character at that location is passed to the subroutine DUTCH, which causes the character to be printed. The saved value is pulled from the stack (because this is the last time it is needed), and two is added. The number at this location relative to X is passed in B as the subroutine is called again. A minor twist is used in the last call to the subroutine. Rather than doing it in the obvious way, with a BSR SCAN followed by an RTS, we simply do a BRA SCAN.The BRA will call the subroutine, but the return from that subroutine will return to the caller of this subroutine. This is a technique that you can always use to improve dynamic efficiency. You are invited, of course, to try out this little program.

Generally, the direction port is written into before the port is used the first time and need not be written into again. However, one can change the direction port from time to time, PORTA and PORTS together, and their direction ports DDRA and DDRB together, can be treated as a 16-bit port because they occupy consecutive locations. Therefore, they can

be read from or written into using LDD and STD instructions. To make PORTAB an output port, we can write in assembly language:

Also, some of the 16 bits can be made input, and some can be output. In manner similar to how 8-bit ports are accessed in C, 16-bit ports can be declared in a header file that is #included in each program as follows:

int PORTAB@0, DDRAB@2;

To make PORTA and PORTS an output port, we can write: DDRAB = Oxf ff f; . Note that DDRAB is declared an int variable. Then, any time after that, to output an int variable i, high byte to PORTA and low byte to PORTS, we can write PORTAB = i;. Note that PORTAB is declared an int variable. To make PORTA and PORTS an input port, we write: DDRAB = 0;. Then, any time after that, to input PORTA (as high byte) and PORTB (as low byte) into an int variable i we can write i = PORTAB;. The ports A and B, or the combined port AB, can be made an input or output port and can be easily accessed in assembly language or in C.

As a simple example of the use of an input port, consider a home security system. See Figure 11.4a. Three switches, each attached to a different window, are normally closed. When any window opens, its switch opens, and the pull-up resistor makes PORTA's input high; otherwise the input is low. This signal is sensed in PORTA bit 0. The C program statement if (PORTA & 1) alarm(); will execute procedure alarm if any switch is opened. It is optimally programmed into assembly language as follows: