Common Lisp the Language, 2nd Edition


next up previous contents index
Next: Character Construction and Up: Characters Previous: Character Attributes

13.2. Predicates on Characters

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.

old_change_begin
[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.
old_change_end

change_begin
X3J13 voted in March 1989 (CHARACTER-PROPOSAL)   to eliminate string-char-p.
change_end


[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:

old_change_begin


old_change_end

change_begin
X3J13 voted in March 1989 (CHARACTER-PROPOSAL)   to replace the notion of bits and font attributes with that of implementation-defined attributes.


change_end

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

old_change_begin
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.
old_change_end

change_begin
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.
change_end

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.

old_change_begin
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.
old_change_end



next up previous contents index
Next: Character Construction and Up: Characters Previous: Character Attributes


AI.Repository@cs.cmu.edu