lispdoc - results for char

(char string index)
Function: Given a string and a non-negative integer index less than the length of the string, returns the character object representing the character at that position in the string.
Example:
(defun name-of (piece) (char ".@O?" piece))
Mentioned in:
CLtL2 - 17.2. Array Access
CLtL2 - 17.4. Functions on Arrays of Bits
CLtL2 - 18.1. String Access
CLtL2 - 7.2. Generalized Variables
HyperSpec - Accessor CHAR, SCHAR
HyperSpec - Function CHAR=, CHAR/=, CHAR<, CHAR>, CHAR<=, CHAR>=, CHAR-EQUAL, CHAR-NOT-EQUAL, CHAR-LESSP, CHAR-GREATERP, CHAR-NOT-GREATERP, CHAR-NOT-LESSP
On Lisp - Macro Characters
PCL - string comparisons
(char= character &rest more-characters)
Function: Return T if all of the arguments are the same character.
Example:
(defun constituent (c)
  (and (graphic-char-p c) (not (char= c #\ ))))
Mentioned in:
CLtL2 - 13.2. Predicates on Characters
CLtL2 - 13.4. Character Conversions
CLtL2 - 22.2.1. Input from Character Streams
HyperSpec - Function CHAR=, CHAR/=, CHAR<, CHAR>, CHAR<=, CHAR>=, CHAR-EQUAL, CHAR-NOT-EQUAL, CHAR-LESSP, CHAR-GREATERP, CHAR-NOT-GREATERP, CHAR-NOT-LESSP
PCL - character comparisons
PCL - truth falsehood and equality
Successful Lisp - chapter17
(char> character &rest more-characters)
Function: Return T if the arguments are in strictly decreasing alphabetic order.
Example:
(defun unicode-string-p (string)
  "An implementation specific test for a unicode string."
  (declare (optimize speed (safety 0) (debug 0))
           (type simple-string string))
  (some #'(lambda (x) (char> x *char-marker*))
        string))
Mentioned in:
CLtL2 - 13.2. Predicates on Characters
PCL - character comparisons
Successful Lisp - chapter17
(char< character &rest more-characters)
Function: Return T if the arguments are in strictly increasing alphabetic order.
 Mentioned in:
CLtL2 - 13.2. Predicates on Characters
CLtL2 - 18.2. String Comparison
CLtL2 - 2.2.1. Standard Characters
PCL - character comparisons
Successful Lisp - chapter17
(char/= character &rest more-characters)
Function: Return T if no two of the arguments are the same character.
 Mentioned in:
CLtL2 - 13.2. Predicates on Characters
PCL - character comparisons
Successful Lisp - chapter17
(char>= character &rest more-characters)
Function: Return T if the arguments are in strictly non-increasing alphabetic order.
 Mentioned in:
CLtL2 - 13.2. Predicates on Characters
PCL - character comparisons
Successful Lisp - chapter17
(char<= character &rest more-characters)
Function: Return T if the arguments are in strictly non-decreasing alphabetic order.
 Mentioned in:
CLtL2 - 13.2. Predicates on Characters
PCL - character comparisons
Successful Lisp - chapter17
(char-int char)
Function: Return the integer code of CHAR. (In SBCL this is the same as CHAR-CODE, as there are no character bits or fonts.)
 Mentioned in:
CLtL2 - 13.2. Predicates on Characters
CLtL2 - 13.4. Character Conversions
CLtL2 - 4.8. Type Conversion Function
HyperSpec - Function CHAR-INT
(name-char name)
Function: Given an argument acceptable to STRING, NAME-CHAR returns a character whose name is that string, if one exists. Otherwise, NIL is returned.
 Mentioned in:
CLtL2 - 13.4. Character Conversions
HyperSpec - Function NAME-CHAR
base-char
Undocumented
 Mentioned in:
HyperSpec - Type BASE-CHAR
(code-char code)
Function: Return the character with the code CODE.
 Mentioned in:
CLtL2 - 13.3. Character Construction and Selection
HyperSpec - Function CODE-CHAR
PCL - primitive binary types
PCL - string types
PCL - strings in binary files
(read-char &optional (stream *standard-input*) (eof-error-p t) eof-value
 recursive-p)
Undocumented
Example:
(defun continue-p ()
  "Ask user if we should continue looking for solutions."
  (case (read-char)
    (#\; t)
    (#\. nil)
    (#\Newline (continue-p))
    (otherwise
     (format t
             " Type ; to see more or . to stop")
     (continue-p))))
Mentioned in:
CLtL2 - 21.1. Standard Streams
CLtL2 - 21.2. Creating New Streams
CLtL2 - 21.3. Operations on Streams
CLtL2 - 22.1.5. The Readtable
CLtL2 - 22.2.1. Input from Character Streams
CLtL2 - 23.2. Opening and Closing Files
CLtL2 - 23.3. Renaming, Deleting, and Other File Operations
CLtL2 - 29.1. Introduction
CLtL2 - A.2.1. Scanners
HyperSpec - Function READ-CHAR
PCL - bulk reads
PCL - other kinds of io
PCL - reading file data
Successful Lisp - chapter19
Successful Lisp - characters
(char-code char)
Function: Return the integer code of CHAR.
Example:
(defun char-el? (el)
  (let ((char-code (char-code el)))
    (and (>= char-code 0) (<= char-code 127))))
Mentioned in:
CLtL2 - 13.1 Character Attributes
CLtL2 - 13.3. Character Construction and Selection
CLtL2 - 13.4. Character Conversions
CLtL2 - 4.8. Type Conversion Function
HyperSpec - Function CHAR-CODE
PCL - implementing shoutcast
PCL - primitive binary types
PCL - string types
PCL - strings in binary files
(char-name char)
Function: Return the name (a STRING) for a CHARACTER object.
 Mentioned in:
CLtL2 - 13.4. Character Conversions
HyperSpec - Function CHAR-NAME
(peek-char &optional (peek-type nil) (stream *standard-input*) (eof-error-p t)
 eof-value recursive-p)
Undocumented
Example:
(defun skip-whitespace (stream)
  "Skip over XML whitespace in stream, return first non-whitespace
  character which was peeked but not read, return nil on eof"
  (loop
   (let ((char (peek-char nil stream nil nil)))
     (if (and char (whitespace-char-p char))
         (read-char stream)
         (return char)))))
Mentioned in:
CLtL2 - 21.2. Creating New Streams
CLtL2 - 22.2.1. Input from Character Streams
HyperSpec - Function PEEK-CHAR
PCL - extracting information from an id3 tag
Successful Lisp - chapter19
(digit-char weight &optional (radix 10))
Function: All arguments must be integers. Returns a character object that represents a digit of the given weight in the specified radix. Returns NIL if no such character exists.
 Mentioned in:
CLtL2 - 13.4. Character Conversions
HyperSpec - Function DIGIT-CHAR
(char-equal character &rest more-characters)
Function: Return T if all of the arguments are the same character. Case is ignored.
 Mentioned in:
CLtL2 - 13. Characters
CLtL2 - 13.2. Predicates on Characters
CLtL2 - 18.2. String Comparison
CLtL2 - 6.3. Equality Predicates
HyperSpec - Function CHAR=, CHAR/=, CHAR<, CHAR>, CHAR<=, CHAR>=, CHAR-EQUAL, CHAR-NOT-EQUAL, CHAR-LESSP, CHAR-GREATERP, CHAR-NOT-GREATERP, CHAR-NOT-LESSP
PCL - character comparisons
Successful Lisp - chapter17
(write-char character &optional (stream *standard-output*))
Undocumented
Example:
(defun emit-newline (ip)
  (write-char #\Newline (out ip))
  (setf (beginning-of-line-p ip) t))
Mentioned in:
CLtL2 - 21.1. Standard Streams
CLtL2 - 22.2.1. Input from Character Streams
CLtL2 - 22.3.1. Output to Character Streams
CLtL2 - 23.2. Opening and Closing Files
CLtL2 - 23.3. Renaming, Deleting, and Other File Operations
CLtL2 - 27.3. Dynamic Control of the Arrangement of Output
CLtL2 - A.2.5. Collectors
HyperSpec - Function WRITE-CHAR
PCL - file output
PCL - other kinds of io
Successful Lisp - chapter19
Successful Lisp - characters
(char-lessp character &rest more-characters)
Function: Return T if the arguments are in strictly increasing alphabetic order. Case is ignored.
 Mentioned in:
CLtL2 - 13. Characters
CLtL2 - 13.2. Predicates on Characters
CLtL2 - 14.5. Sorting and Merging
CLtL2 - 18.2. String Comparison
HyperSpec - Function CHAR=, CHAR/=, CHAR<, CHAR>, CHAR<=, CHAR>=, CHAR-EQUAL, CHAR-NOT-EQUAL, CHAR-LESSP, CHAR-GREATERP, CHAR-NOT-GREATERP, CHAR-NOT-LESSP
PCL - character comparisons
(char-upcase char)
Function: Return CHAR converted to upper-case if that is possible. Don't convert lowercase eszet (U+DF).
Example:
(defun iso-uc (char)
  "Returns upper case CHAR."
  (char-upcase char))
Mentioned in:
CLtL2 - 13. Characters
CLtL2 - 13.2. Predicates on Characters
CLtL2 - 13.4. Character Conversions
CLtL2 - 18.3. String Construction and Manipulation
HyperSpec - Function CHAR-UPCASE, CHAR-DOWNCASE
(unread-char character &optional (stream *standard-input*))
Undocumented
 Mentioned in:
CLtL2 - 21.2. Creating New Streams
CLtL2 - 22.1.1. What the Read Function Accepts
CLtL2 - 22.2.1. Input from Character Streams
HyperSpec - Function UNREAD-CHAR
PCL - extracting information from an id3 tag
Successful Lisp - chapter19
(char-downcase char)
Function: Return CHAR converted to lower-case if that is possible.
Example:
(defun iso-lc (char)
  "Returns lower case CHAR."
  (char-downcase char))
Mentioned in:
CLtL2 - 13. Characters
CLtL2 - 13.2. Predicates on Characters
CLtL2 - 13.4. Character Conversions
CLtL2 - 18.3. String Construction and Manipulation
HyperSpec - Function CHAR-UPCASE, CHAR-DOWNCASE
(char-greaterp character &rest more-characters)
Function: Return T if the arguments are in strictly decreasing alphabetic order. Case is ignored.
 Mentioned in:
CLtL2 - 13. Characters
CLtL2 - 13.2. Predicates on Characters
HyperSpec - Function CHAR=, CHAR/=, CHAR<, CHAR>, CHAR<=, CHAR>=, CHAR-EQUAL, CHAR-NOT-EQUAL, CHAR-LESSP, CHAR-GREATERP, CHAR-NOT-GREATERP, CHAR-NOT-LESSP
PCL - character comparisons
extended-char
Type: Type of CHARACTERs that aren't BASE-CHARs.
 Mentioned in:
HyperSpec - Type EXTENDED-CHAR
standard-char
Type: Type corresponding to the characters required by the standard.
 Mentioned in:
CLtL2 - 13. Characters
CLtL2 - 13.2. Predicates on Characters
CLtL2 - 2.15. Overlap, Inclusion, and Disjointness of Types
CLtL2 - 2.2. Characters
CLtL2 - 2.2.1. Standard Characters
CLtL2 - 6. Predicates
HyperSpec - Type STANDARD-CHAR
(digit-char-p char &optional (radix 10))
Function: If char is a digit in the specified radix, returns the fixnum for which that digit stands, else returns NIL.
 Mentioned in:
CLtL2 - 13.2. Predicates on Characters
CLtL2 - 13.4. Character Conversions
HyperSpec - Function DIGIT-CHAR-P
(alpha-char-p char)
Function: The argument must be a character object. ALPHA-CHAR-P returns T if the argument is an alphabetic character, A-Z or a-z; otherwise NIL.
 Mentioned in:
CLtL2 - 13. Characters
CLtL2 - 13.2. Predicates on Characters
CLtL2 - 13.4. Character Conversions
HyperSpec - Function ALPHA-CHAR-P
(chunga:peek-char* stream &optional eof-error-p eof-value)
Function: We're simulating PEEK-CHAR by reading a character and putting it into *CHAR-BUFFER*.
  
(chunga:read-char* stream &optional eof-error-p eof-value)
Function: The streams we're dealing with are all binary with element type (UNSIGNED-BYTE 8) and we're only interested in ISO-8859-1, so we use this to `simulate' READ-CHAR.
  
(chunga:assert-char stream expected-char)
Function: Reads the next character from STREAM and checks if it is the character EXPECTED-CHAR. Signals an error otherwise.
  
babel:unicode-char
Type: This character type can hold any characters whose CHAR-CODEs are less than UNICODE-CHAR-CODE-LIMIT.
  
(char-not-equal character &rest more-characters)
Function: Return T if no two of the arguments are the same character. Case is ignored.
 Mentioned in:
CLtL2 - 13. Characters
CLtL2 - 13.2. Predicates on Characters
HyperSpec - Function CHAR=, CHAR/=, CHAR<, CHAR>, CHAR<=, CHAR>=, CHAR-EQUAL, CHAR-NOT-EQUAL, CHAR-LESSP, CHAR-GREATERP, CHAR-NOT-GREATERP, CHAR-NOT-LESSP
PCL - character comparisons
Successful Lisp - chapter17
(char-not-lessp character &rest more-characters)
Function: Return T if the arguments are in strictly non-increasing alphabetic order. Case is ignored.
 Mentioned in:
CLtL2 - 13. Characters
CLtL2 - 13.2. Predicates on Characters
HyperSpec - Function CHAR=, CHAR/=, CHAR<, CHAR>, CHAR<=, CHAR>=, CHAR-EQUAL, CHAR-NOT-EQUAL, CHAR-LESSP, CHAR-GREATERP, CHAR-NOT-GREATERP, CHAR-NOT-LESSP
PCL - character comparisons
(graphic-char-p char)
Function: The argument must be a character object. GRAPHIC-CHAR-P returns T if the argument is a printing character (space through ~ in ASCII), otherwise returns NIL.
Example:
(defun constituent (c)
  (and (graphic-char-p c) (not (char= c #\ ))))
Mentioned in:
CLtL2 - 13. Characters
CLtL2 - 13.2. Predicates on Characters
CLtL2 - 13.4. Character Conversions
HyperSpec - Function GRAPHIC-CHAR-P
(standard-char-p char)
Function: The argument must be a character object. STANDARD-CHAR-P returns T if the argument is a standard character -- one of the 95 ASCII printing characters or <return>.
 Mentioned in:
CLtL2 - 13.2. Predicates on Characters
CLtL2 - 6. Predicates
CLtL2 - 6.2.2. Specific Data Type Predicates
HyperSpec - Function STANDARD-CHAR-P
char-code-limit
Variable: the upper exclusive bound on values produced by CHAR-CODE
 Mentioned in:
CLtL2 - 13.1 Character Attributes
CLtL2 - 13.3. Character Construction and Selection
HyperSpec - Constant Variable CHAR-CODE-LIMIT
(trivial-gray-streams:stream-read-char stream)
Function: Read one character from the stream. Return either a character object, or the symbol :EOF if the stream is at end-of-file. Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM must define a method for this function.
  
(trivial-gray-streams:stream-peek-char stream)
Function: This is used to implement PEEK-CHAR; this corresponds to PEEK-TYPE of NIL. It returns either a character or :EOF. The default method calls STREAM-READ-CHAR and STREAM-UNREAD-CHAR.
  
(trivial-gray-streams:stream-write-char stream character)
Function: Write CHARACTER to STREAM and return CHARACTER. Every subclass of FUNDAMENTAL-CHARACTER-OUTPUT-STREAM must have a method defined for this function.
  
(char-not-greaterp character &rest more-characters)
Function: Return T if the arguments are in strictly non-decreasing alphabetic order. Case is ignored.
 Mentioned in:
CLtL2 - 13. Characters
CLtL2 - 13.2. Predicates on Characters
HyperSpec - Function CHAR=, CHAR/=, CHAR<, CHAR>, CHAR<=, CHAR>=, CHAR-EQUAL, CHAR-NOT-EQUAL, CHAR-LESSP, CHAR-GREATERP, CHAR-NOT-GREATERP, CHAR-NOT-LESSP
PCL - character comparisons
(cl-who:escape-char char &key (test *escape-char-p*))
Function: Returns an escaped version of the character CHAR if CHAR satisfies the predicate TEST. Always returns a string.
  
(trivial-gray-streams:stream-unread-char stream character)
Function: Un-do the last call to STREAM-READ-CHAR, as in UNREAD-CHAR. Return NIL. Every subclass of FUNDAMENTAL-CHARACTER-INPUT-STREAM must define a method for this function.
  
(chunga:token-char-p char)
Function: Returns true if the Lisp character CHAR is a token constituent according to RFC 2616.
  
(md5:fill-block-char)
Function: Convert a complete 64 character input string segment starting from offset into the given 16 word MD5 block.
  
(read-char-no-hang &optional (stream *standard-input*) (eof-error-p t)
 eof-value recursive-p)
Undocumented
 Mentioned in:
CLtL2 - 22.2.1. Input from Character Streams
HyperSpec - Function READ-CHAR-NO-HANG
Successful Lisp - chapter19
(flexi-streams:char-length sequence &key (external-format latin1) (start 0)
 (end (length sequence)))
Function: Kind of the inverse of OCTET-LENGTH. Returns the length of the subsequence (of octets) of SEQUENCE from START to END in characters if decoded using the external format EXTERNAL-FORMAT. Note that this function doesn't check for the validity of the data in SEQUENCE. This function is optimized for the case of SEQUENCE being a vector. Don't use lists if you're in a hurry.
  
(set-syntax-from-char to-char from-char &optional (to-readtable *readtable*)
 (from-readtable nil))
Function: Causes the syntax of TO-CHAR to be the same as FROM-CHAR in the optional readtable (defaults to the current readtable). The FROM-TABLE defaults to the standard Lisp readtable when NIL.
 Mentioned in:
CLtL2 - 22.1.1. What the Read Function Accepts
CLtL2 - 22.1.5. The Readtable
HyperSpec - Function SET-SYNTAX-FROM-CHAR
(cl-who:escape-char-all char)
Function: Escapes characters which aren't in the 7-bit ASCII character set.
  
cl-who:*escape-char-p*
Variable: Used by ESCAPE-STRING to test whether a character should be escaped.
  
(cl-ppcre:quote-meta-chars string &key (start 0) (end (length string)))
Function: Quote, i.e. prefix with #\\, all non-word characters in STRING.
  
flexi-streams:*substitution-char*
Variable: If this value is not NIL, it should be a character which is used (as if by a USE-VALUE restart) whenever during reading an error of type FLEXI-STREAM-ENCODING-ERROR would have been signalled otherwise.
  
(babel:vector-size-in-chars vector &key (start 0) end (max -1 maxp)
 (errorp (not *suppress-character-coding-errors*))
 (encoding *default-character-encoding*))
Undocumented
  
(cl-who:escape-char-minimal char)
Function: Escapes only #<, #>, and #& characters.
  
cl-who:*attribute-quote-char*
Variable: Quote character for attributes.
  
babel:unicode-char-code-limit
Variable: An alias for CL:CHAR-CODE-LIMIT which might be lower than #x110000 on some Lisps.
  
(trivial-gray-streams:stream-read-char-no-hang stream)
Function: This is used to implement READ-CHAR-NO-HANG. It returns either a character, or NIL if no input is currently available, or :EOF if end-of-file is reached. The default method provided by FUNDAMENTAL-CHARACTER-INPUT-STREAM simply calls STREAM-READ-CHAR; this is sufficient for file streams, but interactive streams should define their own method.
  
cl-ppcre:*optimize-char-classes*
Variable: Whether character classes should be compiled into look-ups into O(1) data structures. This is usually fast but will be costly in terms of scanner creation time and might be costly in terms of size if *REGEX-CHAR-CODE-LIMIT* is high. This value will be used as the :KIND keyword argument to CREATE-OPTIMIZED-TEST-FUNCTION - see there for the possible non-NIL values.
  
cl-ppcre:*regex-char-code-limit*
Variable: The upper exclusive bound on the char-codes of characters which can occur in character classes. Change this value BEFORE creating scanners if you don't need the (full) Unicode support of implementations like AllegroCL, CLISP, LispWorks, or SBCL.
  
(cl-who:escape-char-iso-8859-1 char)
Function: Escapes characters that aren't defined in ISO-8859-9.
  
(cl-who:escape-char-minimal-plus-quotes char)
Function: Like ESCAPE-CHAR-MINIMAL but also escapes quotes.
  
(babel-encodings:enc-max-units-per-char object)
Undocumented