Problem 3—Interpreting Control Characters
Virtually all text-mode terminals are special-purpose computer systems,
including a serial port (for communication with a modem or another computer
system), a keyboard, a CRT, and of course, a microprocessor, some RAM, and a
control program in ROM. When a
character arrives at the terminal, either from the keyboard or the serial port,
the terminal's software classifies it as either a display character (which is
to be displayed on the CRT) or as a character that introduces a control
sequence. A control sequence is used to direct the terminal to do such things
as clear the screen, move the cursor in a specified manner, or perhaps change
fonts.
In this problem assume you are writing the software for a small terminal with
a 10-row, 10-column display (perhaps for a point-of-sale terminal). Rows and columns are numbered 0 through
9. The character that introduces a
control sequence is the circumflex. The
character (or in one case, the two characters) immediately following the
control sequence introducer will direct your software in performing its special
functions. Here is the complete list of
control sequences you will need to interpret:
^b: Move the cursor to the beginning of the
current line; the cursor row does not change
^c: Clear the entire screen; the cursor row and
column do not change
^d: Move the cursor down one row if possible;
the cursor column does not change
^e: Erase characters to the right of, and
including, the cursor column on the cursor's row; the cursor row and column do
not change
^h: Move the cursor to row 0, column 0; the
image on the screen is not changed
^i: Enter insert mode (see below)
^l: Move the cursor left one column, if
possible; the cursor row does not change
^o: Enter overwrite mode (see below)
^r: Move the cursor right one column, if
possible; the cursor row does not change
^u: Move the cursor up one row, if possible; the
cursor column does not change
^^: Write a circumflex at the current cursor
location exactly as if it was not a special character; this is subject to the
actions of the current mode (insert or overwrite)
^##: Move the cursor to the row and column
specified; # represents a decimal digit; the first # represents the new row
number, and the second # represents the new column number.
No illegal control sequences will ever be sent to the terminal. The cursor
cannot move outside the allowed screen locations (that is, between row 0,
column 0 and row 9, column 9). When a
normal character (not part of a control sequence) arrives at the terminal, it
is displayed on the terminal screen in a manner that depends on the terminal
mode. When the terminal is in overwrite mode (as it is when it is first turned
on), the received character replaces the character at the cursor's location.
But when the terminal is in insert mode, the characters to the right of and
including the cursor's location are shifted right one column, and the new
character is placed at the cursor's location; the character previously in the
rightmost column of the cursor's row is lost. Regardless of the mode, the
cursor is moved right one column, if possible.
INPUT
SPECIFICATION.
The input will contain
multiple tests of your terminal software.
Each test begins with a line containing an integer N followed by <EOLN>. Following this line there will be N
more lines of data, each character of which is to be treated as if it was
input, in the order read, to your terminal software. <EOLN> characters in the input are to be ignored,
but spaces in the input data are normal characters to be displayed on your
terminal. The last test will be
followed by a single line containing 0<EOLN>. No control sequence will be split between
two lines of the input data. No extra <EOLN>
will appear in the input file. At the
beginning of each test case you are to assume the terminal screen is clear
(that is, filled with spaces), that the terminal is in overwrite mode, and that
the cursor is in row 0, column 0 of the screen.
OUTPUT SPECIFICATION. The output cases should be processed in the order in which they appear in the input file. For each case, output the word “Case” followed by a space followed by the case number (these are numbered sequentially starting with 1) followed by <EOLN> and the screen image the way it would look at the end of processing the data in the test case. Enclose the screen image in a “box;” see the sample below for illustration of the required format.
SAMPLE INPUT.
7<EOLN>
This·is·bad^h^c<EOLN>
^05^^<EOLN>
^14/·\^d^b···/···\<EOLN>
^u^d^d^l^l^l^l^l^l^l^l^l<EOLN>
^r^r<·ACM·>^l^l^d/^b···\<EOLN>
^b^d····\·/<EOLN>
^d^l^lv<EOLN>
7<EOLN>
^i9^l8^l7^l6^l5^l4^l3^l2^l1^l0<EOLN>
^o^d^lThis·is·#1^d^bThis·is·#2<EOLN>
^d^bThis·is·#3^d^bThis·is·#4<EOLN>
^d^bThis·is·#5^d^bThis·is·#6<EOLN>
^d^bThis·is·#7^d^bThis·is·#8<EOLN>
^i^d^bThis·is·#9^d^bThis·is·#10<EOLN>
^54^e·Hello^d^l^l^l^lWorld<EOLN>
0<EOLN>
<EOF>
SAMPLE
OUTPUT.
Case·1<EOLN>
+----------+<EOLN>
|·····^····|<EOLN>
|····/·\···|<EOLN>
|···/···\··|<EOLN>
|··<·ACM·>·|<EOLN>
|···\···/··|<EOLN>
|····\·/···|<EOLN>
|·····v····|<EOLN>
|··········|<EOLN>
|··········|<EOLN>
|··········|<EOLN>
+----------+<EOLN>
Case·2<EOLN>
+----------+<EOLN>
|0123456789|<EOLN>
|This·is·#1|<EOLN>
|This·is·#2|<EOLN>
|This·is·#3|<EOLN>
|This·is·#4|<EOLN>
|This·Hello|<EOLN>
|This·World|<EOLN>
|This·is·#7|<EOLN>
|This·is·#8|<EOLN>
|This·is·#0|<EOLN>
+----------+<EOLN>
<EOF>