Characters

In PSL a character is its ASCII code representation. Using numeric codes to represent characters leads to programs which are difficult to read. You are encouraged to use char to represent characters.

(char U:id): integer macro

This macro is part of the USEFUL module. The char macro returns the ASCII code which corresponds to the single character passed as an argument. Char will accept alias’s for characters. An alias is established by defining a charconst property on the property list of the alias. The value of this property should be the ASCII code of the character which is being aliased. The following alias’s are defined when the useful package is loaded.

NULL
BELL
BACKSPACE
TAB
LF	line feed
EOL	end of line
FF	form feed
CR	carriage return
EOF	end of file
ESCAPE	may be abbreviated ESC
SPACE	an alias is BLANK
RUBOUT	may be abbreviated RUB
DELETE	may be abbreviated DEL

By default, the PSL reader converts upper case alphabetic characters to lower case. This default is controlled by the value of the switch raise. A value of t indicates that the conversion should be done. Assuming raise is t, the expression (char a) refers to the character ”a”. The character ”A” is referenced by (char !A). The ”!” is used as an escape character, see chapter 12 for more information. The application of lower is said to modify the character. Lower is not a defined function but it does have the attribute char-prefix-function on its property list. The value of this property is a function which will modify the ASCII code of its argument. Modifiers are control and meta (the modifier cntrl is an abbreviation for control). The following example is a simplified definition of char.

    (defmacro char (u)
      (cond ((idp u) (or (get u 'charconst)
                         (id2int u)))
            ((digit-char u))
            ((and (pairp u)
                  (get (first u) 'char-prefix-function))
             (list (get (first u) 'char-prefix-function)
                   (list 'char (second u))))))

Notice that the digits have to be treated as a special case. The PSL reader converts a digit to a reference to a numeric constant. The definition of the alias space is

The USEFUL package also defines the read macro #. Read macros are explained in detail in chapter 12. When the reader encounters #, char is applied to the next character. If this next character is a lower case alphabetic character then it will be converted to upper case if the switch raise is set to t. If this next character is a read macro then it will be applied. Such a read macro should return an expression which is acceptable to char.

    1 lisp> #\a
    65
    2 lisp> #\‘(a b c)
    ⋆⋆⋆ Unknown character constant: ‘(BACKQUOTE (A B C))'
    0

Common LISP Functions on Characters

Common LISP provides a character data type in which every character object has three attributes: code, bits, and font. The bits attribute allows extra flags to be associated with a character. The font attribute permits a specification of the style of the glyphs (such as italics). PSL does not support nonzero bit and font attributes. Because of this, some of the Common LISP character functions described below have no affect or are not very useful as implemented in PSL. They are present for compatibility.

An argument to any of the following functions should make use of char or one of the two read macros #∕ and #\. Since a character in PSL is represented as its ASCII code it is possible to give a numeric argument to these functions. However, the use of numbers makes the code difficult to read and much less transportable. The read macro #\ is described in the discussion of char above. The read macro #/ returns the ASCII code of the next character. In contrast to #\, the switch raise is ignored and if the next character is a read macro it is not applied.

1 lisp> (eq (char (lower a)) #/a)
T
2 lisp> (eq (char (lower a)) #\a)
NIL
3 lisp> #/‘
96
4 lisp> #\‘
⋆⋆⋆ Unknown character constant: ‘(BACKQUOTE !^Z)'
0

(standard-charp C:character): boolean expr

Returns t if the argument is one of the 95 ASCII printing characters.

    1 lisp> (standard-charp (char a))
    T
    2 lisp> (standard-charp (char (control a)))
    NIL

(graphicp C:character): boolean expr

Returns t if C is a printable character and nil otherwise. Control and formatting characters are considered to be not printable. The space character is a printable character.

(string-charp C:character): boolean expr

Returns t if C is a character that can be an element of a string. Any character that satisfies standard-charp and graphicp also satisfies string-charp.

(alphap C:character): boolean expr

Returns t if C is an alphabetic character. Liter is an equivalent function.

(uppercasep C:character): boolean expr

Returns t if C is an upper case letter.

(lowercasep C:character): boolean expr

Returns t if C is a lower case letter.

(bothcasep C:character): boolean expr

In PSL this function is the same as alphap.

(digitp C:character): boolean expr

Returns t if C is a digit character (optional radix not supported). An equivalent function is digit

(alphanumericp C:character): boolean expr

Returns t if C is a digit or an alphabetic.

(char= C1:character C2:character): boolean expr

Returns t if C1 and C2 are the same in all three attributes.

(char-equal C1:character C2:character): boolean expr

Returns t if C1 and C2 are similar. Differences in case, bits, or font are ignored by this function.

(char< C1:character C2:character): boolean expr

Returns t if C1 is strictly less than C2.

(char> C1:character C2:character): boolean expr

Returns t if C1 is strictly greater than C2.

(char-lessp C1:character C2:character): boolean expr

Like char< but ignores differences in case, fonts, and bits.

(char-greaterp C1:character C2:character): boolean expr

Like char> but ignores differences in case, fonts, and bits.

(char-code C:character): character expr

Returns the code attribute of C. In PSL this function is an identity function.

(char-bits C:character): integer expr

Returns the bits attribute of C, which is always 0 in PSL.

(char-font C:character): integer expr

Returns the font attribute of C, which is always 0 in PSL.

(code-char I:integer): character,nil expr

The purpose of this function is to be able to construct a character by specifying the code, bits, and font. Because bits and font attributes are not used in PSL, code-char is an identity function.

(character C:character, string, id): character expr

Attempts to coerce C to be a character. If C is a character, C is returned. If C is a string, then the first character of the string is returned. If C is a symbol, the first character of the print name of the symbol is returned. Otherwise an error occurs.

(char-upcase C:character): character expr

If (lowercasep C) is true, then char-upcase returns the code of the upper case of C. Otherwise it returns the code of C.

(char-downcase C:character): character expr

If (uppercasep C) is true, then char-downcase returns the code of the lower case of C. Otherwise it returns the code of C.

(digit-char N:fixnum): integer expr

If N corresponds to a single digit then the character which represents that digit is returned. The Common LISP version will accept an optional radix argument, this function assumes a radix of ten. If N does not correspond to a single digit then nil is returned.

(char-int C:character): integer expr

Converts character to integer. This is the identity operation in PSL.

(int-char I:integer): character expr

Converts integer to character. This is the identity operation in PSL.

6.1 Characters

Common LISP Functions on Characters