(format "%s:%s (#x%04X%04X)"
type name (car code) (cdr code))))))
(let* ((charset (get-text-property pos 'charset))
- (coding (terminal-coding-system))
+ (coding (or (terminal-coding-system) 'us-ascii))
(encoded (encode-coding-char char coding charset)))
(if encoded
(encoded-string-description encoded coding)))))
(if (>= pos (point-max))
(error "No character follows specified position"))
(let* ((char (char-after pos))
- (charset (or (get-text-property pos 'charset) (char-charset char)))
+ (eight-bit-p (and (not enable-multibyte-characters) (>= char 128)))
+ (charset (if eight-bit-p 'eight-bit
+ (or (get-text-property pos 'charset) (char-charset char))))
(composition (find-composition pos nil nil t))
(component-chars nil)
(display-table (or (window-display-table)
(kill-buffer tmp-buf))))
item-list max-width code)
- (or (setq code (encode-char char charset))
- (setq charset (char-charset char)
- code (encode-char char charset)))
+ (if multibyte-p
+ (or (setq code (encode-char char charset))
+ (setq charset (char-charset char)
+ code (encode-char char charset)))
+ (setq code char))
+ (when composition
+ ;; When the composition is trivial (i.e. composed only with the
+ ;; current character itself without any alternate characters),
+ ;; we don't show the composition information. Otherwise, store
+ ;; two descriptive strings in the first two elments of
+ ;; COMPOSITION.
+ (or (catch 'tag
+ (let ((from (car composition))
+ (to (nth 1 composition))
+ (next (1+ pos))
+ (components (nth 2 composition))
+ ch)
+ (if (and (vectorp components) (vectorp (aref components 0)))
+ (let ((idx (- pos from))
+ (nglyphs (lgstring-glyph-len components))
+ (i 0) j glyph glyph-from)
+ ;; COMPONENTS is a gstring. Find a grapheme
+ ;; cluster containing the current character.
+ (while (and (< i nglyphs)
+ (setq glyph (lgstring-glyph components i))
+ (< (lglyph-to glyph) idx))
+ (setq i (1+ i)))
+ (if (or (not glyph) (= i nglyphs))
+ ;; The composition is broken.
+ (throw 'tag nil))
+ (setq glyph-from (lglyph-from glyph)
+ to (+ from (lglyph-to glyph) 1)
+ from (+ from glyph-from)
+ j i)
+ (while (and (< j nglyphs)
+ (setq glyph (lgstring-glyph components j))
+ (= (lglyph-from glyph) glyph-from))
+ (setq j (1+ j)))
+ (if (and (= i (1- j))
+ (setq glyph (lgstring-glyph components i))
+ (= char (lglyph-char glyph)))
+ ;; The composition is trivial.
+ (throw 'tag nil))
+ (nconc composition (list i (1- j))))
+ (dotimes (i (length components))
+ (if (integerp (setq ch (aref components i)))
+ (push (cons ch (describe-char-display pos ch))
+ component-chars)))
+ (setq component-chars (nreverse component-chars)))
+ (if (< from pos)
+ (if (< (1+ pos) to)
+ (setcar composition
+ (concat
+ " with the surrounding characters \""
+ (mapconcat 'describe-char-padded-string
+ (buffer-substring from pos) "")
+ "\" and \""
+ (mapconcat 'describe-char-padded-string
+ (buffer-substring (1+ pos) to) "")
+ "\""))
+ (setcar composition
+ (concat
+ " with the preceding character(s) \""
+ (mapconcat 'describe-char-padded-string
+ (buffer-substring from pos) "")
+ "\"")))
+ (if (< (1+ pos) to)
+ (setcar composition
+ (concat
+ " with the following character(s) \""
+ (mapconcat 'describe-char-padded-string
+ (buffer-substring (1+ pos) to) "")
+ "\""))
+ (setcar composition nil)))
+ (setcar (cdr composition)
+ (format "composed to form \"%s\" (see below)"
+ (buffer-substring from to)))))
+ (setq composition nil)))
+
(setq item-list
`(("character"
,(format "%s (%d, #o%o, #x%x)"
(internal-describe-syntax-value syntax)
(buffer-string))))
("category"
- ,@(let ((category-set (char-category-set char)))
- (if category-set
- (describe-char-categories category-set)
- '("-- none --"))))
+ ,@(if (not eight-bit-p)
+ (let ((category-set (char-category-set char)))
+ (if category-set
+ (describe-char-categories category-set)
+ '("-- none --")))))
("to input"
- ,@(let ((key-list (and (eq input-method-function
- 'quail-input-method)
- (quail-find-key char))))
- (if (consp key-list)
- (list "type"
- (mapconcat #'(lambda (x) (concat "\"" x "\""))
- key-list " or ")
- "with"
- `(insert-text-button
- ,current-input-method
- 'type 'help-input-method
- 'help-args '(,current-input-method))))))
+ ,@(if (not eight-bit-p)
+ (let ((key-list (and (eq input-method-function
+ 'quail-input-method)
+ (quail-find-key char))))
+ (if (consp key-list)
+ (list "type"
+ (mapconcat #'(lambda (x) (concat "\"" x "\""))
+ key-list " or ")
+ "with"
+ `(insert-text-button
+ ,current-input-method
+ 'type 'help-input-method
+ 'help-args '(,current-input-method)))))))
("buffer code"
- ,(encoded-string-description
- (string-as-unibyte (char-to-string char)) nil))
+ ,(if multibyte-p
+ (encoded-string-description
+ (string-as-unibyte (char-to-string char)) nil)
+ (format "#x%02X" char)))
("file code"
- ,@(let* ((coding buffer-file-coding-system)
- (encoded (encode-coding-char char coding charset)))
- (if encoded
- (list (encoded-string-description encoded coding)
- (format "(encoded by coding system %S)" coding))
- (list "not encodable by coding system"
- (symbol-name coding)))))
+ ,@(if multibyte-p
+ (let* ((coding buffer-file-coding-system)
+ (encoded (encode-coding-char char coding charset)))
+ (if encoded
+ (list (encoded-string-description encoded coding)
+ (format "(encoded by coding system %S)" coding))
+ (list "not encodable by coding system"
+ (symbol-name coding))))
+ (list (format "#x%02X" char))))
("display"
,(cond
(disp-vector
(format "?%c" (glyph-char (car x))))
disp-vector " ")))
(composition
- (let ((from (car composition))
- (to (nth 1 composition))
- (next (1+ pos))
- (components (nth 2 composition))
- ch)
- (setcar composition
- (and (< from pos) (buffer-substring from pos)))
- (setcar (cdr composition)
- (and (< next to) (buffer-substring next to)))
- (dotimes (i (length components))
- (if (integerp (setq ch (aref components i)))
- (push (cons ch (describe-char-display pos ch))
- component-chars)))
- (setq component-chars (nreverse component-chars))
- (format "composed to form \"%s\" (see below)"
- (buffer-substring from to))))
+ (cadr composition))
(t
(let ((display (describe-char-display pos char)))
(if (display-graphic-p (selected-frame))
`(insert-text-button
,(symbol-name face)
'type 'help-face 'help-args '(,face))))))
- ,@(let ((unicodedata (describe-char-unicode-data char)))
- (if unicodedata
- (cons (list "Unicode data" " ") unicodedata)))))
+ ,@(if (not eight-bit-p)
+ (let ((unicodedata (describe-char-unicode-data char)))
+ (if unicodedata
+ (cons (list "Unicode data" " ") unicodedata))))))
(setq max-width (apply #'max (mapcar #'(lambda (x)
(if (cadr x) (length (car x)) 0))
item-list)))
(when composition
(insert "\nComposed")
(if (car composition)
- (if (cadr composition)
- (insert " with the surrounding characters \""
- (mapconcat 'describe-char-padded-string
- (car composition) "")
- "\" and \""
- (mapconcat 'describe-char-padded-string
- (cadr composition) "")
- "\"")
- (insert " with the preceding character(s) \""
- (mapconcat 'describe-char-padded-string
- (car composition) "")
- "\""))
- (if (cadr composition)
- (insert " with the following character(s) \""
- (mapconcat 'describe-char-padded-string
- (cadr composition) "")
- "\"")))
+ (insert (car composition)))
(if (and (vectorp (nth 2 composition))
(vectorp (aref (nth 2 composition) 0)))
(let* ((gstring (nth 2 composition))
(font (lgstring-font gstring))
- (nglyphs (lgstring-glyph-len gstring))
- (i 0)
+ (from (nth 3 composition))
+ (to (nth 4 composition))
glyph)
- (if font
+ (if (fontp font)
(progn
(insert " using this font:\n "
(symbol-name (font-get font :type))
?:
(aref (query-font font) 0)
"\nby these glyphs:\n")
- (while (and (< i nglyphs)
- (setq glyph (lgstring-glyph gstring i)))
+ (while (and (<= from to)
+ (setq glyph (lgstring-glyph gstring from)))
(insert (format " %S\n" glyph))
- (setq i (1+ i))))
+ (setq from (1+ from))))
(insert " by these characters:\n")
- (while (and (< i nglyphs)
- (setq glyph (lgstring-glyph gstring i)))
+ (while (and (<= from to)
+ (setq glyph (lgstring-glyph gstring from)))
(insert (format " %c (#x%d)\n"
(lglyph-char glyph) (lglyph-char glyph)))
- (setq i (1+ i)))))
+ (setq from (1+ from)))))
(insert " by the rule:\n\t(")
(let ((first t))
(mapc (lambda (x)
(insert "\nSee the variable `reference-point-alist' for "
"the meaning of the rule.\n")))
- (insert (if (not describe-char-unidata-list)
- "\nCharacter code properties are not shown: "
- "\nCharacter code properties: "))
- (insert-text-button
- "customize what to show"
- 'action (lambda (&rest ignore)
- (customize-variable
- 'describe-char-unidata-list)))
- (insert "\n")
- (dolist (elt (if (eq describe-char-unidata-list t)
- (nreverse (mapcar 'car char-code-property-alist))
- describe-char-unidata-list))
- (let ((val (get-char-code-property char elt))
- description)
- (when val
- (setq description (char-code-property-description elt val))
- (insert (if description
- (format " %s: %s (%s)\n" elt val description)
- (format " %s: %s\n" elt val))))))
+ (unless eight-bit-p
+ (insert (if (not describe-char-unidata-list)
+ "\nCharacter code properties are not shown: "
+ "\nCharacter code properties: "))
+ (insert-text-button
+ "customize what to show"
+ 'action (lambda (&rest ignore)
+ (customize-variable
+ 'describe-char-unidata-list)))
+ (insert "\n")
+ (dolist (elt (if (eq describe-char-unidata-list t)
+ (nreverse (mapcar 'car char-code-property-alist))
+ describe-char-unidata-list))
+ (let ((val (get-char-code-property char elt))
+ description)
+ (when val
+ (setq description (char-code-property-description elt val))
+ (insert (if description
+ (format " %s: %s (%s)\n" elt val description)
+ (format " %s: %s\n" elt val)))))))
(if text-props-desc (insert text-props-desc))
(setq help-xref-stack-item (list 'help-insert-string (buffer-string)))