Common Lisp the Language
2nd Edition
The predicate characterp may be used to determine whether any Lisp object is a character object.
[Function]
standard-char-p char
The argument char must be a character object. standard-char-p is true if the argument is a ``standard character '' that is an object of type standard-char.
Note that any character with a non-zero bits or font attribute is non-standard.
[Function]
graphic-char-p char
The argument char must be a character object. graphic-char-p is true if the argument is a ``graphic'' (printing) character and false if it is a ``non-graphic'' (formatting or control) character. Graphic characters have a standard textual representation as a single glyph such as A or * or =. By convention the space character is considered to be graphic. Of the standard characters all but #\Newline are graphic. The semi-standard characters #\Backspace #\Tab #\Rubout #\Linefeed #\Return and #\Page are not graphic.
Programs may assume that graphic characters of font 0 are all of the same width when printed for example for purposes of columnar formatting. (This does not prohibit the use of a variable-pitch font as font 0 but merely implies that every implementation of Common Lisp must provide some mode of operation in which font 0 is a fixed-pitch font.) Portable programs should assume that in general non-graphic characters and characters of other fonts may be of varying widths.
Any character with a non-zero bits attribute is non-graphic.
[Function]
string-char-p char
The argument char must be a character object.
string-char-p is true if char can be stored into
a string
and otherwise is false.
Any character that satisfies standard-char-p
also satisfies string-char-p; others may also.
X3J13 voted in March 1989 (CHARACTER-PROPOSAL)
to eliminate string-char-p.
[Function]
alpha-char-p char
The argument char must be a character object. alpha-char-p is true if the argument is an alphabetic character and otherwise is false.
If a character is alphabetic then it is perforce graphic. Therefore any character with a non-zero bits attribute cannot be alphabetic. Whether a character is alphabetic may depend on its font number.
Of the standard characters (as defined by standard-char-p) the letters A through Z and a through z are alphabetic.
[Function]
upper-case-p char
lower-case-p char
both-case-p char
The argument char must be a character object.
upper-case-p is true if the argument is an uppercase character and otherwise is false.
lower-case-p is true if the argument is a lowercase character and otherwise is false.
both-case-p is true if the argument is an uppercase character and there is a corresponding lowercase character (which can be obtained using char-downcase) or if the argument is a lowercase character and there is a corresponding uppercase character (which can be obtained using char-upcase).
If a character is either uppercase or lowercase it is necessarily alphabetic (and therefore is graphic and therefore has a zero bits attribute). However it is permissible in theory for an alphabetic character to be neither uppercase nor lowercase (in a non-Roman font for example).
Of the standard characters (as defined by standard-char-p) the letters A through Z are uppercase and a through z are lowercase.
[Function]
digit-char-p char &optional (radix 10)
The argument char must be a character object and radix must be a non-negative integer. If char is not a digit of the radix specified by radix then digit-char-p is false; otherwise it returns a non-negative integer that is the ``weight'' of char in that radix.
Digits are necessarily graphic characters.
Of the standard characters (as defined by standard-char-p) the characters 0 through 9 A through Z and a through z are digits. The weights of 0 through 9 are the integers 0 through 9 and of A through Z (and also a through z) are 10 through 35. digit-char-p returns the weight for one of these digits if and only if its weight is strictly less than radix. Thus for example the digits for radix 16 are
0 1 2 3 4 5 6 7 8 9 A B C D E F
Here is an example of the use of digit-char-p:
(defun convert-string-to-integer (str &optional (radix 10)) "Given a digit string and optional radix return an integer." (do ((j 0 (+ j 1)) (n 0 (+ (* n radix) (or (digit-char-p (char str j) radix) (error "Bad radix-~D digit: ~C" radix (char str j)))))) ((= j (length str)) n)))
[Function]
alphanumericp char
The argument char must be a character object. alphanumericp is true if char is either alphabetic or numeric. By definition
(alphanumericp x) == (or (alpha-char-p x) (not (null (digit-char-p x))))
Alphanumeric characters are therefore necessarily graphic (as defined by the predicate graphic-char-p).
Of the standard characters (as defined by standard-char-p) the characters 0 through 9 A through Z and a through z are alphanumeric.
[Function]
char= character &rest more-characters
char/= character &rest more-characters
char< character &rest more-characters
char> character &rest more-characters
char<= character &rest more-characters
char>= character &rest more-characters
The arguments must all be character objects. These functions compare the objects using the implementation-dependent total ordering on characters in a manner analogous to numeric comparisons by = and related functions.
The total ordering on characters is guaranteed to have the following properties:
A<B<C<D<E<F<G<H<I<J<K<L<M<N<O<P<Q<R<S<T<U<V<W<X<Y<Z to 0pta<b<c<d<e<f<g<h<i<j<k<l<m<n<o< p<q<r<s<t<u<v<w<x<y<z 0<1<2<3<4<5<6<7<8<9 either 9<A or Z<0 either 9<a or z<0
This implies that alphabetic ordering holds within each case (upper and lower) and that the digits as a group are not interleaved with letters. However the ordering or possible interleaving of uppercase letters and lowercase letters is unspecified. (Note that both the ASCII and the EBCDIC character sets conform to this specification. As it happens neither ordering interleaves uppercase and lowercase letters: in the ASCII ordering 9<A and Z<a whereas in the EBCDIC ordering z<A and Z<0.)
X3J13 voted in March 1989 (CHARACTER-PROPOSAL)
to replace the notion of bits and font attributes with
that of implementation-defined attributes.
The total ordering is not necessarily the same as the total ordering on the integers produced by applying char-int to the characters (although it is a reasonable implementation technique to use that ordering).
While alphabetic characters of a given case must be properly ordered they need not be contiguous; thus (char<= #\a x #\z) is not a valid way of determining whether or not x is a lowercase letter. That is why a separate lower-case-p predicate is provided.
(char= #\d #\d) is true. (char/= #\d #\d) is false. (char= #\d #\x) is false. (char/= #\d #\x) is true. (char= #\d #\D) is false. (char/= #\d #\D) is true. (char= #\d #\d #\d #\d) is true. (char/= #\d #\d #\d #\d) is false. (char= #\d #\d #\x #\d) is false. (char/= #\d #\d #\x #\d) is false. (char= #\d #\y #\x #\c) is false. (char/= #\d #\y #\x #\c) is true. (char= #\d #\c #\d) is false. (char/= #\d #\c #\d) is false. (char< #\d #\x) is true. (char<= #\d #\x) is true. (char< #\d #\d) is false. (char<= #\d #\d) is true. (char< #\a #\e #\y #\z) is true. (char<= #\a #\e #\y #\z) is true. (char< #\a #\e #\e #\y) is false. (char<= #\a #\e #\e #\y) is true. (char> #\e #\d) is true. (char>= #\e #\d) is true. (char> #\d #\c #\b #\a) is true. (char>= #\d #\c #\b #\a) is true. (char> #\d #\d #\c #\a) is false. (char>= #\d #\d #\c #\a) is true. (char> #\e #\d #\b #\c #\a) is false. (char>= #\e #\d #\b #\c #\a) is false. (char> #\z #\A) may be true or false. (char> #\Z #\a) may be true or false.
There is no requirement that (eq c1 c2) be true merely because (char= c1 c2) is true. While eq may distinguish two character objects that char= does not it is distinguishing them not as characters but in some sense on the basis of a lower-level implementation characteristic. (Of course if (eq c1 c2) is true then one may expect (char= c1 c2) to be true.) However eql and equal compare character objects in the same way that char= does.
[Function]
char-equal character &rest more-characters
char-not-equal character &rest more-characters
char-lessp character &rest more-characters
char-greaterp character &rest more-characters
char-not-greaterp character &rest more-characters
char-not-lessp character &rest more-characters
The predicate char-equal is like char=
and similarly
for the others
except according to a different ordering such that
differences of bits attributes and case are ignored
and font information is taken into account in an implementation-dependent
manner.
X3J13 voted in March 1989 (CHARACTER-PROPOSAL)
to replace the notion of bits and font attributes with
that of implementation-defined attributes. The effect
if any
of each such attribute on the behavior of
char-equal
char-not-equal
char-lessp
char-greaterp
char-not-greaterp
and char-not-lessp must be specified
as part of the definition of that attribute.
For the standard characters the ordering is such that A=a B=b and so on up to Z=z and furthermore either 9<A or Z<0. For example:
(char-equal #\A #\a) is true. (char= #\A #\a) is false. (char-equal #\A #\Control-A) is true.
The ordering may depend on the font information. For example
an implementation
might decree that (char-equal #\p #\p) be true
but that
(char-equal #\p #\pi) be false
(where #\pi is a
lowercase p in some font). Assuming italics to be in font 1
and the Greek alphabet in font 2
this is the same as saying that
(char-equal #0\p #1\p) may be true and at the same time
(char-equal #0\p #2\p) may be false.