Control character

From Free net encyclopedia

In computing, a control character or non-printing character, is a code point (a number) in a character set that does not in itself represent a written symbol. All entries in the ASCII table below 32 (technically the C0 control code set) are of this kind, including BEL (which is intended to cause an audible signal in the receiving terminal), SYN (which is a synchronization signal), and ENQ (a signal that is intended to trigger a response at the receiving end, to see if it is still present). The Unicode standard has added many new non-printing characters, for example the Zero-width non-joiner. The remainder of this article covers control codes in general and some codes that are in common use. For detailed tables of the C0 and C1 control codes used in ASCII and ISO-8859-n, please see their respective articles.

Contents 1 In ASCII 2 How control characters map to keyboards 3 The design purpose 3.1 Printing and Display control 3.2 Data structuring 3.3 Transmission control 3.4 Miscellaneous

In ASCII

The control characters in ASCII still in common use include

• 7 (bell), which may cause the device receiving it to emit a warning of some kind (usually audible)
• 8 (backspace), used either to erase the last character printed or to overprint it
• 9 (horizontal tab), moves the printing position some spaces to the right
• 10 (line feed), used as the end_of_line marker in most UNIX systems and variants
• 12 (form feed), to cause a printer to eject paper to the top of the next page
• 13 (carriage return), used as the end_of_line marker in Mac OS, OS-9, FLEX (and variants); CP/M-80 and its derivatives including DOS and Windows through the FAT-12, -16, and -32 file systems, and application layer protocols such as HTTP, all used the CR/LF character pair as an end_of_line marker, and
• 27 (escape).

Occasionally one might encounter modern uses of other codes such as code 4 (End of transmission) used to end a Unix shell session or PostScript printer transmission.

Code 27 (Escape) is a case worth elaborating. Even though many of these control characters are never used, the concept of sending device-control information intermixed with printable characters is so useful that device makers found a way to send hundreds of device instructions. Specifically, they used a series of multiple characters called a "control sequence" or "escape sequence". The mechanism was invented by Bob Bemer, the father of ASCII.

Typically code 27 was first sent to alert the device that the following characters were to be interpreted as a control sequence rather than as plain characters, then one or more characters would follow specifying some detailed action, after which the device would go back to interpreting characters normally. For example, the sequence of code 27, followed by the printable characters "[2;10H", would cause a Digital VT-102 terminal to move its cursor to the 10th cell of the 2nd line of the screen. Some standards exist for these sequences, notably ANSI X3.64 (1979), which was based on the behavior of VT-100 series terminals. But the number of non-standard variations in use is large, especially among printers, where technology has advanced far faster than any standards body can possibly keep even with.

How control characters map to keyboards

ASCII-based keyboards have a key labelled "Control" or "Ctrl" (sometimes referred to as "Cntl") which is used much like a shift key, being depressed in combination with another letter or symbol key. In this way the control key generates the code 64 places below the code for the (generally) uppercase letter it is pressed in combination with, producing one of the 32 ASCII control codes.

So, the octet code produced by a control key combination has the second from leftmost bit (the 2⁷th, i.e. the 64th, place bit) forced to zero and is otherwise the bit pattern generated when the control key is not one of those pressed. For example, pressing "control" and the letter "G" (code 71 in base 10, which is 01000111 in binary, a code which generally also requires the shift key be depressed), produces the code 7 (Bell, 7 in base 10, or 00000111 in binary). A key press combination that produces a code with 0 in the 64th place is unaffected should the control key be held down as well.

Keyboards also typically have a few single keys which produce control character codes. For example, the key labelled "Backspace" typically produces code 8, "Tab" code 9, "Enter" or "Return" code 13 (though some keyboards might produce code 10 for "Enter").

Modern keyboards have many keys that do not correspond to any ASCII printable or control character, for example cursor control arrows and word processing functions. These keyboards communicate these keys to the attached computer by one of three methods: appropriating some otherwise unused control character for the new use, using some encoding other than ASCII, or using multi-character control sequences. Keyboards attached to stand-alone personal computers typically use one (or both) of the first two methods. "Dumb" computer terminals typically use control sequences.

The design purpose

The control characters were designed fall into a few groups: printing and display control, data structuring, transmission control, and miscellaneous.

Printing and Display control

Printing control characters were first used to control the physical mechanism of a printers, the earliest output device. The carriage return character, when sent to such a device, causes it to put the character at the edge of the paper at which writing begins (it may, or may not, also move the printing position to the next line). The line feed character causes the device to put the printing position on the next line. It may (or may not), depending on the device and its configuration, also move the printing position to the start of the next line (whichever direction is first -- left in Western languages and right in Hebrew and Arabic). The vertical and horizontal tab characters cause the output device to move the printing position to the next tab stop in the direction of reading. The form feed character starts a new sheet of paper. The backspace character moves the printing position one character space backwards. On printers, this is most often used so the printer can overprint characters to make other, not normally available characters. On terminals and other electronic output devices there are often software (or hardware) configuration choices which will allow a destruct backspace (ie, a BS, SP, BS sequence) which erases, or a non-destructive one which does not. The shift in and shift out characters selected alternate character sets, fonts, underlining or other printing modes. Escape sequences were often used to do the same thing.

With the advent of computer terminals that did not physically print on paper and so offered more flexibility regarding screen placement, erasure, and so forth, printing control codes were adapted. Form feeds, for example, usually cleared the screen, there being no new paper page to move to. More complex escape sequences were developed to take advantage of the flexibility of the new terminals, and indeed of newer printers. The concept of a control character had always been somewhat limiting, and was extremely so when used with new, much more flexible, hardware. Control sequences (sometimes implemented as escape sequences) could match the new flexibility and power and became the standard method. Though there were, and remain, a large variety of standard sequences to choose from.

Data structuring

The separators (group, record, etc) were made to structure data, usually on a tape, in order to simulate punch cards. End of media warns that the tape (or whatever) is ending.

Transmission control

The transmission control characters were intended to structure a data stream and manage retransmission or graceful failure as needed in the face of transmission errors.

The start of header was to mark a non-data section of a data stream -- the part of a stream containing addresses and other housekeeping data. The start_of_text character marked the end of the header, and the start of the textual part of a stream. The end_of_text character marked the end of the data of a message. A widely used convention is to make the two characters preceding end_of_text a checksum or CRC for error detection purposes.

The escape character was intended to be a marker of a binary (ie, non text character) value in a data stream that might otherwise be interpretable as a control character. For example, the value for binary 27 would be Escape Escape.

The substitute character was intended to request a translation of the next character from a printable character to another value, usually by setting bit 5 to zero. This is handy because some media (such as sheets of paper produced by typewriters) can only transmit printable characters.

The cancel character signalled that the previous element should be discarded. The negative acknowledge character is a definite flag for, usually, noting that reception was a problem, and often, that the current element should be sent again. The acknowledge characters is normally used as a flag to indicate no problem detected with current element.

When a transmission medium is half duplex (that is, it can only transmit in one direction at a time), there is usually a master station that can transmit at any time, and one or more slave stations that transmit when they have permission. The enquiry character is generally used by a master station to ask a slave station to send its next message. A slave station indicates that it has completed its transmission by sending the end_of_transmission character.

The device control codes were originally generic, to be implemented as necessary by each device. However, a universal need in data transmission is to request the sender to stop transmitting when a receiver can't take more data right now. Digital Equipment Corporation invented a convention which used 19, (the device control 3 character, also known as control S, or "X-OFF") to "S"top transmission, and 17, (the device control 1 character, aka control Q, or "X-ON") to start transmission. It has become so widely used that most don't realize it is not part of official ASCII. This technique, however implemented, avoids additional wires in the data cable devoted only to transmission management, which saves money. A sensible protocol for the use such transmission flow control signals must be used to avoid potential deadlock conditions, however.

The data link escape character was intended to be a signal to the other end of a data link to end the current session.

Miscellaneous

Many of the ASCII control characters were designed for devices of the time that are not often seen today. For example, code 22, "Synchronous idle", was originally sent by synchronous modems (which have to send data constantly) when there was no actual data to send. (Modern systems typically use a start bit to announce the beginning of a transmitted word.)

Code 0, null, is a special case. In paper tape, it is the case when there are no holes. It's convenient to treat this as a fill character without meaning otherwise.

Code 127 is likewise a special case. Its code is all-bits-on in binary, which essentially erased a character cell on a paper tape when overpunched. Paper tape was a common storage medium when ASCII was developed with a computing history dating back to WWII code breaking equipment at Bletchley Park. Paper tape became obsolete in the 1970s, so this clever aspect of ASCII rarely saw any use. Some systems (such as the original Apples) converted it to a backspace. But because its code is in the range occupied by other printable characters, and because it had no official assigned glyph, many computer equipment vendors used it as an additional printable character (often an all-black "box" character useful for erasing text by overprinting with ink).

Many file systems do not allow control characters in the file names as they may have reserved functions.de:Steuerzeichen eo:Reg-signo it:Carattere di controllo ru:Управляющие символы zh:控制字符