]> code.delx.au - gnu-emacs/blob - lisp/ansi-color.el
Merge from trunk
[gnu-emacs] / lisp / ansi-color.el
1 ;;; ansi-color.el --- translate ANSI escape sequences into faces
2
3 ;; Copyright (C) 1999-2012 Free Software Foundation, Inc.
4
5 ;; Author: Alex Schroeder <alex@gnu.org>
6 ;; Maintainer: Alex Schroeder <alex@gnu.org>
7 ;; Version: 3.4.2
8 ;; Keywords: comm processes terminals services
9
10 ;; This file is part of GNU Emacs.
11
12 ;; GNU Emacs is free software: you can redistribute it and/or modify
13 ;; it under the terms of the GNU General Public License as published by
14 ;; the Free Software Foundation, either version 3 of the License, or
15 ;; (at your option) any later version.
16
17 ;; GNU Emacs is distributed in the hope that it will be useful,
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ;; GNU General Public License for more details.
21
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
24
25 ;;; Commentary:
26
27 ;; This file provides a function that takes a string or a region
28 ;; containing Select Graphic Rendition (SGR) control sequences (formerly
29 ;; known as ANSI escape sequences) and tries to translate these into
30 ;; faces.
31 ;;
32 ;; This allows you to run ls --color=yes in shell-mode. It is now
33 ;; enabled by default; to disable it, set ansi-color-for-comint-mode
34 ;; to nil.
35 ;;
36 ;; Note that starting your shell from within Emacs might set the TERM
37 ;; environment variable. The new setting might disable the output of
38 ;; SGR control sequences. Using ls --color=yes forces ls to produce
39 ;; these.
40 ;;
41 ;; SGR control sequences are defined in section 3.8.117 of the ECMA-48
42 ;; standard (identical to ISO/IEC 6429), which is freely available as a
43 ;; PDF file <URL:http://www.ecma.ch/ecma1/STAND/ECMA-048.HTM>. The
44 ;; "Graphic Rendition Combination Mode (GRCM)" implemented is
45 ;; "cumulative mode" as defined in section 7.2.8. Cumulative mode means
46 ;; that whenever possible, SGR control sequences are combined (ie. blue
47 ;; and bold).
48
49 ;; The basic functions are:
50 ;;
51 ;; `ansi-color-apply' to colorize a string containing SGR control
52 ;; sequences.
53 ;;
54 ;; `ansi-color-filter-apply' to filter SGR control sequences from a
55 ;; string.
56 ;;
57 ;; `ansi-color-apply-on-region' to colorize a region containing SGR
58 ;; control sequences.
59 ;;
60 ;; `ansi-color-filter-region' to filter SGR control sequences from a
61 ;; region.
62
63 ;;; Thanks
64
65 ;; Georges Brun-Cottan <gbruncot@emc.com> for improving ansi-color.el
66 ;; substantially by adding the code needed to cope with arbitrary chunks
67 ;; of output and the filter functions.
68 ;;
69 ;; Markus Kuhn <Markus.Kuhn@cl.cam.ac.uk> for pointing me to ECMA-48.
70 ;;
71 ;; Stefan Monnier <foo@acm.com> for explaining obscure font-lock stuff and for
72 ;; code suggestions.
73
74 \f
75
76 ;;; Code:
77
78 (defvar comint-last-output-start)
79
80 ;; Customization
81
82 (defgroup ansi-colors nil
83 "Translating SGR control sequences to faces.
84 This translation effectively colorizes strings and regions based upon
85 SGR control sequences embedded in the text. SGR (Select Graphic
86 Rendition) control sequences are defined in section 3.8.117 of the
87 ECMA-48 standard \(identical to ISO/IEC 6429), which is freely available
88 as a PDF file <URL:http://www.ecma.ch/ecma1/STAND/ECMA-048.HTM>."
89 :version "21.1"
90 :group 'processes)
91
92 (defcustom ansi-color-faces-vector
93 [default bold default italic underline success warning error]
94 "Faces used for SGR control sequences determining a face.
95 This vector holds the faces used for SGR control sequence parameters 0
96 to 7.
97
98 Parameter Description Face used by default
99 0 default default
100 1 bold bold
101 2 faint default
102 3 italic italic
103 4 underlined underline
104 5 slowly blinking success
105 6 rapidly blinking warning
106 7 negative image error
107
108 Note that the symbol `default' is special: It will not be combined
109 with the current face.
110
111 This vector is used by `ansi-color-make-color-map' to create a color
112 map. This color map is stored in the variable `ansi-color-map'."
113 :type '(vector face face face face face face face face)
114 :set 'ansi-color-map-update
115 :initialize 'custom-initialize-default
116 :group 'ansi-colors)
117
118 (defcustom ansi-color-names-vector
119 ["black" "red" "green" "yellow" "blue" "magenta" "cyan" "white"]
120 "Colors used for SGR control sequences determining a color.
121 This vector holds the colors used for SGR control sequences parameters
122 30 to 37 \(foreground colors) and 40 to 47 (background colors).
123
124 Parameter Color
125 30 40 black
126 31 41 red
127 32 42 green
128 33 43 yellow
129 34 44 blue
130 35 45 magenta
131 36 46 cyan
132 37 47 white
133
134 This vector is used by `ansi-color-make-color-map' to create a color
135 map. This color map is stored in the variable `ansi-color-map'.
136
137 Each element may also be a cons cell where the car and cdr specify the
138 foreground and background colors, respectively."
139 :type '(vector (choice color (cons color color))
140 (choice color (cons color color))
141 (choice color (cons color color))
142 (choice color (cons color color))
143 (choice color (cons color color))
144 (choice color (cons color color))
145 (choice color (cons color color))
146 (choice color (cons color color)))
147 :set 'ansi-color-map-update
148 :initialize 'custom-initialize-default
149 :group 'ansi-colors)
150
151 (defconst ansi-color-regexp "\033\\[\\([0-9;]*m\\)"
152 "Regexp that matches SGR control sequences.")
153
154 (defconst ansi-color-drop-regexp
155 "\033\\[\\([ABCDsuK]\\|2J\\|=[0-9]+[hI]\\|[0-9;]*[Hf]\\)"
156 "Regexp that matches ANSI control sequences to silently drop.")
157
158 (defconst ansi-color-parameter-regexp "\\([0-9]*\\)[m;]"
159 "Regexp that matches SGR control sequence parameters.")
160
161
162 ;; Convenience functions for comint modes (eg. shell-mode)
163
164
165 (defcustom ansi-color-for-comint-mode t
166 "Determines what to do with comint output.
167 If nil, do nothing.
168 If the symbol `filter', then filter all SGR control sequences.
169 If anything else (such as t), then translate SGR control sequences
170 into text properties.
171
172 In order for this to have any effect, `ansi-color-process-output' must
173 be in `comint-output-filter-functions'.
174
175 This can be used to enable colorized ls --color=yes output
176 in shell buffers. You set this variable by calling one of:
177 \\[ansi-color-for-comint-mode-on]
178 \\[ansi-color-for-comint-mode-off]
179 \\[ansi-color-for-comint-mode-filter]"
180 :type '(choice (const :tag "Do nothing" nil)
181 (const :tag "Filter" filter)
182 (const :tag "Translate" t))
183 :group 'ansi-colors
184 :version "23.2")
185
186 (defvar ansi-color-apply-face-function 'ansi-color-apply-overlay-face
187 "Function for applying an Ansi Color face to text in a buffer.
188 This function should accept three arguments: BEG, END, and FACE,
189 and it should apply face FACE to the text between BEG and END.")
190
191 ;;;###autoload
192 (defun ansi-color-for-comint-mode-on ()
193 "Set `ansi-color-for-comint-mode' to t."
194 (interactive)
195 (setq ansi-color-for-comint-mode t))
196
197 (defun ansi-color-for-comint-mode-off ()
198 "Set `ansi-color-for-comint-mode' to nil."
199 (interactive)
200 (setq ansi-color-for-comint-mode nil))
201
202 (defun ansi-color-for-comint-mode-filter ()
203 "Set `ansi-color-for-comint-mode' to symbol `filter'."
204 (interactive)
205 (setq ansi-color-for-comint-mode 'filter))
206
207 ;;;###autoload
208 (defun ansi-color-process-output (ignored)
209 "Maybe translate SGR control sequences of comint output into text properties.
210
211 Depending on variable `ansi-color-for-comint-mode' the comint output is
212 either not processed, SGR control sequences are filtered using
213 `ansi-color-filter-region', or SGR control sequences are translated into
214 text properties using `ansi-color-apply-on-region'.
215
216 The comint output is assumed to lie between the marker
217 `comint-last-output-start' and the process-mark.
218
219 This is a good function to put in `comint-output-filter-functions'."
220 (let ((start-marker (if (and (markerp comint-last-output-start)
221 (eq (marker-buffer comint-last-output-start)
222 (current-buffer))
223 (marker-position comint-last-output-start))
224 comint-last-output-start
225 (point-min-marker)))
226 (end-marker (process-mark (get-buffer-process (current-buffer)))))
227 (cond ((eq ansi-color-for-comint-mode nil))
228 ((eq ansi-color-for-comint-mode 'filter)
229 (ansi-color-filter-region start-marker end-marker))
230 (t
231 (ansi-color-apply-on-region start-marker end-marker)))))
232
233 (defalias 'ansi-color-unfontify-region 'font-lock-default-unfontify-region)
234 (make-obsolete 'ansi-color-unfontify-region "not needed any more" "24.1")
235
236 ;; Working with strings
237 (defvar ansi-color-context nil
238 "Context saved between two calls to `ansi-color-apply'.
239 This is a list of the form (FACES FRAGMENT) or nil. FACES is a list of
240 faces the last call to `ansi-color-apply' ended with, and FRAGMENT is a
241 string starting with an escape sequence, possibly the start of a new
242 escape sequence.")
243 (make-variable-buffer-local 'ansi-color-context)
244
245 (defun ansi-color-filter-apply (string)
246 "Filter out all ANSI control sequences from STRING.
247
248 Every call to this function will set and use the buffer-local variable
249 `ansi-color-context' to save partial escape sequences. This information
250 will be used for the next call to `ansi-color-apply'. Set
251 `ansi-color-context' to nil if you don't want this.
252
253 This function can be added to `comint-preoutput-filter-functions'."
254 (let ((start 0) end result)
255 ;; if context was saved and is a string, prepend it
256 (if (cadr ansi-color-context)
257 (setq string (concat (cadr ansi-color-context) string)
258 ansi-color-context nil))
259 ;; find the next escape sequence
260 (while (setq end (string-match ansi-color-regexp string start))
261 (setq result (concat result (substring string start end))
262 start (match-end 0)))
263 ;; save context, add the remainder of the string to the result
264 (let (fragment)
265 (if (string-match "\033" string start)
266 (let ((pos (match-beginning 0)))
267 (setq fragment (substring string pos)
268 result (concat result (substring string start pos))))
269 (setq result (concat result (substring string start))))
270 (setq ansi-color-context (if fragment (list nil fragment))))
271 result))
272
273 (defun ansi-color-apply (string)
274 "Translates SGR control sequences into text properties.
275 Delete all other control sequences without processing them.
276
277 Applies SGR control sequences setting foreground and background colors
278 to STRING using text properties and returns the result. The colors used
279 are given in `ansi-color-faces-vector' and `ansi-color-names-vector'.
280 See function `ansi-color-apply-sequence' for details.
281
282 Every call to this function will set and use the buffer-local variable
283 `ansi-color-context' to save partial escape sequences and current face.
284 This information will be used for the next call to `ansi-color-apply'.
285 Set `ansi-color-context' to nil if you don't want this.
286
287 This function can be added to `comint-preoutput-filter-functions'."
288 (let ((face (car ansi-color-context))
289 (start 0) end escape-sequence result
290 colorized-substring)
291 ;; If context was saved and is a string, prepend it.
292 (if (cadr ansi-color-context)
293 (setq string (concat (cadr ansi-color-context) string)
294 ansi-color-context nil))
295 ;; Find the next escape sequence.
296 (while (setq end (string-match ansi-color-regexp string start))
297 (setq escape-sequence (match-string 1 string))
298 ;; Colorize the old block from start to end using old face.
299 (when face
300 (put-text-property start end 'font-lock-face face string))
301 (setq colorized-substring (substring string start end)
302 start (match-end 0))
303 ;; Eliminate unrecognized ANSI sequences.
304 (while (string-match ansi-color-drop-regexp colorized-substring)
305 (setq colorized-substring
306 (replace-match "" nil nil colorized-substring)))
307 (push colorized-substring result)
308 ;; Create new face, by applying escape sequence parameters.
309 (setq face (ansi-color-apply-sequence escape-sequence face)))
310 ;; if the rest of the string should have a face, put it there
311 (when face
312 (put-text-property start (length string) 'font-lock-face face string))
313 ;; save context, add the remainder of the string to the result
314 (let (fragment)
315 (if (string-match "\033" string start)
316 (let ((pos (match-beginning 0)))
317 (setq fragment (substring string pos))
318 (push (substring string start pos) result))
319 (push (substring string start) result))
320 (setq ansi-color-context (if (or face fragment) (list face fragment))))
321 (apply 'concat (nreverse result))))
322
323 ;; Working with regions
324
325 (defvar ansi-color-context-region nil
326 "Context saved between two calls to `ansi-color-apply-on-region'.
327 This is a list of the form (FACES MARKER) or nil. FACES is a list of
328 faces the last call to `ansi-color-apply-on-region' ended with, and
329 MARKER is a buffer position within an escape sequence or the last
330 position processed.")
331 (make-variable-buffer-local 'ansi-color-context-region)
332
333 (defun ansi-color-filter-region (begin end)
334 "Filter out all ANSI control sequences from region BEGIN to END.
335
336 Every call to this function will set and use the buffer-local variable
337 `ansi-color-context-region' to save position. This information will be
338 used for the next call to `ansi-color-apply-on-region'. Specifically,
339 it will override BEGIN, the start of the region. Set
340 `ansi-color-context-region' to nil if you don't want this."
341 (let ((end-marker (copy-marker end))
342 (start (or (cadr ansi-color-context-region) begin)))
343 (save-excursion
344 (goto-char start)
345 ;; Delete unrecognized escape sequences.
346 (while (re-search-forward ansi-color-drop-regexp end-marker t)
347 (replace-match ""))
348 (goto-char start)
349 ;; Delete SGR escape sequences.
350 (while (re-search-forward ansi-color-regexp end-marker t)
351 (replace-match ""))
352 ;; save context, add the remainder of the string to the result
353 (if (re-search-forward "\033" end-marker t)
354 (setq ansi-color-context-region (list nil (match-beginning 0)))
355 (setq ansi-color-context-region nil)))))
356
357 (defun ansi-color-apply-on-region (begin end)
358 "Translates SGR control sequences into overlays or extents.
359 Delete all other control sequences without processing them.
360
361 SGR control sequences are applied by setting foreground and
362 background colors to the text between BEGIN and END using
363 overlays. The colors used are given in `ansi-color-faces-vector'
364 and `ansi-color-names-vector'. See `ansi-color-apply-sequence'
365 for details.
366
367 Every call to this function will set and use the buffer-local variable
368 `ansi-color-context-region' to save position and current face. This
369 information will be used for the next call to
370 `ansi-color-apply-on-region'. Specifically, it will override BEGIN, the
371 start of the region and set the face with which to start. Set
372 `ansi-color-context-region' to nil if you don't want this."
373 (let ((face (car ansi-color-context-region))
374 (start-marker (or (cadr ansi-color-context-region)
375 (copy-marker begin)))
376 (end-marker (copy-marker end))
377 escape-sequence)
378 ;; First, eliminate unrecognized ANSI control sequences.
379 (save-excursion
380 (goto-char start-marker)
381 (while (re-search-forward ansi-color-drop-regexp end-marker t)
382 (replace-match "")))
383 (save-excursion
384 (goto-char start-marker)
385 ;; Find the next SGR sequence.
386 (while (re-search-forward ansi-color-regexp end-marker t)
387 ;; Colorize the old block from start to end using old face.
388 (funcall ansi-color-apply-face-function
389 start-marker (match-beginning 0)
390 face)
391 ;; store escape sequence and new start position
392 (setq escape-sequence (match-string 1)
393 start-marker (copy-marker (match-end 0)))
394 ;; delete the escape sequence
395 (replace-match "")
396 ;; create new face by applying all the parameters in the escape
397 ;; sequence
398 (setq face (ansi-color-apply-sequence escape-sequence face)))
399 ;; search for the possible start of a new escape sequence
400 (if (re-search-forward "\033" end-marker t)
401 (progn
402 ;; if the rest of the region should have a face, put it there
403 (funcall ansi-color-apply-face-function
404 start-marker (point) face)
405 ;; save face and point
406 (setq ansi-color-context-region
407 (list face (copy-marker (match-beginning 0)))))
408 ;; if the rest of the region should have a face, put it there
409 (funcall ansi-color-apply-face-function
410 start-marker end-marker face)
411 (setq ansi-color-context-region (if face (list face)))))))
412
413 (defun ansi-color-apply-overlay-face (beg end face)
414 "Make an overlay from BEG to END, and apply face FACE.
415 If FACE is nil, do nothing."
416 (when face
417 (ansi-color-set-extent-face
418 (ansi-color-make-extent beg end)
419 face)))
420
421 ;; This function helps you look for overlapping overlays. This is
422 ;; useful in comint-buffers. Overlapping overlays should not happen!
423 ;; A possible cause for bugs are the markers. If you create an overlay
424 ;; up to the end of the region, then that end might coincide with the
425 ;; process-mark. As text is added BEFORE the process-mark, the overlay
426 ;; will keep growing. Therefore, as more overlays are created later on,
427 ;; there will be TWO OR MORE overlays covering the buffer at that point.
428 ;; This function helps you check your buffer for these situations.
429 ; (defun ansi-color-debug-overlays ()
430 ; (interactive)
431 ; (let ((pos (point-min)))
432 ; (while (< pos (point-max))
433 ; (if (<= 2 (length (overlays-at pos)))
434 ; (progn
435 ; (goto-char pos)
436 ; (error "%d overlays at %d" (length (overlays-at pos)) pos))
437 ; (let (message-log-max)
438 ; (message "Reached %d." pos)))
439 ; (setq pos (next-overlay-change pos)))))
440
441 ;; Emacs/XEmacs compatibility layer
442
443 (defun ansi-color-make-face (property color)
444 "Return a face with PROPERTY set to COLOR.
445 PROPERTY can be either symbol `foreground' or symbol `background'.
446
447 For Emacs, we just return the cons cell \(PROPERTY . COLOR).
448 For XEmacs, we create a temporary face and return it."
449 (if (featurep 'xemacs)
450 (let ((face (make-face (intern (concat color "-" (symbol-name property)))
451 "Temporary face created by ansi-color."
452 t)))
453 (set-face-property face property color)
454 face)
455 (cond ((eq property 'foreground)
456 (cons 'foreground-color color))
457 ((eq property 'background)
458 (cons 'background-color color))
459 (t
460 (cons property color)))))
461
462 (defun ansi-color-make-extent (from to &optional object)
463 "Make an extent for the range [FROM, TO) in OBJECT.
464
465 OBJECT defaults to the current buffer. XEmacs uses `make-extent', Emacs
466 uses `make-overlay'. XEmacs can use a buffer or a string for OBJECT,
467 Emacs requires OBJECT to be a buffer."
468 (if (fboundp 'make-extent)
469 (make-extent from to object)
470 ;; In Emacs, the overlay might end at the process-mark in comint
471 ;; buffers. In that case, new text will be inserted before the
472 ;; process-mark, ie. inside the overlay (using insert-before-marks).
473 ;; In order to avoid this, we use the `insert-behind-hooks' overlay
474 ;; property to make sure it works.
475 (let ((overlay (make-overlay from to object)))
476 (overlay-put overlay 'modification-hooks '(ansi-color-freeze-overlay))
477 overlay)))
478
479 (defun ansi-color-freeze-overlay (overlay is-after begin end &optional len)
480 "Prevent OVERLAY from being extended.
481 This function can be used for the `modification-hooks' overlay
482 property."
483 ;; if stuff was inserted at the end of the overlay
484 (when (and is-after
485 (= 0 len)
486 (= end (overlay-end overlay)))
487 ;; reset the end of the overlay
488 (move-overlay overlay (overlay-start overlay) begin)))
489
490 (defun ansi-color-set-extent-face (extent face)
491 "Set the `face' property of EXTENT to FACE.
492 XEmacs uses `set-extent-face', Emacs uses `overlay-put'."
493 (if (featurep 'xemacs)
494 (set-extent-face extent face)
495 (overlay-put extent 'face face)))
496
497 ;; Helper functions
498
499 (defun ansi-color-apply-sequence (escape-sequence faces)
500 "Apply ESCAPE-SEQ to FACES and return the new list of faces.
501
502 ESCAPE-SEQ is an escape sequences parsed by `ansi-color-get-face'.
503
504 If the new faces start with the symbol `default', then the new
505 faces are returned. If the faces start with something else,
506 they are appended to the front of the FACES list, and the new
507 list of faces is returned.
508
509 If `ansi-color-get-face' returns nil, then we either got a
510 null-sequence, or we stumbled upon some garbage. In either
511 case we return nil."
512 (let ((new-faces (ansi-color-get-face escape-sequence)))
513 (cond ((null new-faces)
514 nil)
515 ((eq (car new-faces) 'default)
516 (cdr new-faces))
517 (t
518 ;; Like (append NEW-FACES FACES)
519 ;; but delete duplicates in FACES.
520 (let ((modified-faces (copy-sequence faces)))
521 (dolist (face (nreverse new-faces))
522 (setq modified-faces (delete face modified-faces))
523 (push face modified-faces))
524 modified-faces)))))
525
526 (defun ansi-color-make-color-map ()
527 "Creates a vector of face definitions and returns it.
528
529 The index into the vector is an ANSI code. See the documentation of
530 `ansi-color-map' for an example.
531
532 The face definitions are based upon the variables
533 `ansi-color-faces-vector' and `ansi-color-names-vector'."
534 (let ((ansi-color-map (make-vector 50 nil))
535 (index 0))
536 ;; miscellaneous attributes
537 (mapc
538 (function (lambda (e)
539 (aset ansi-color-map index e)
540 (setq index (1+ index)) ))
541 ansi-color-faces-vector)
542 ;; foreground attributes
543 (setq index 30)
544 (mapc
545 (function (lambda (e)
546 (aset ansi-color-map index
547 (ansi-color-make-face 'foreground
548 (if (consp e) (car e) e)))
549 (setq index (1+ index)) ))
550 ansi-color-names-vector)
551 ;; background attributes
552 (setq index 40)
553 (mapc
554 (function (lambda (e)
555 (aset ansi-color-map index
556 (ansi-color-make-face 'background
557 (if (consp e) (cdr e) e)))
558 (setq index (1+ index)) ))
559 ansi-color-names-vector)
560 ansi-color-map))
561
562 (defvar ansi-color-map (ansi-color-make-color-map)
563 "A brand new color map suitable for `ansi-color-get-face'.
564
565 The value of this variable is usually constructed by
566 `ansi-color-make-color-map'. The values in the array are such that the
567 numbers included in an SGR control sequences point to the correct
568 foreground or background colors.
569
570 Example: The sequence \033[34m specifies a blue foreground. Therefore:
571 (aref ansi-color-map 34)
572 => \(foreground-color . \"blue\")")
573
574 (defun ansi-color-map-update (symbol value)
575 "Update `ansi-color-map'.
576
577 Whenever the vectors used to construct `ansi-color-map' are changed,
578 this function is called. Therefore this function is listed as the :set
579 property of `ansi-color-faces-vector' and `ansi-color-names-vector'."
580 (set-default symbol value)
581 (setq ansi-color-map (ansi-color-make-color-map)))
582
583 (defun ansi-color-get-face-1 (ansi-code)
584 "Get face definition from `ansi-color-map'.
585 ANSI-CODE is used as an index into the vector."
586 (condition-case nil
587 (aref ansi-color-map ansi-code)
588 (args-out-of-range nil)))
589
590 (defun ansi-color-get-face (escape-seq)
591 "Create a new face by applying all the parameters in ESCAPE-SEQ.
592
593 Should any of the parameters result in the default face (usually this is
594 the parameter 0), then the effect of all previous parameters is canceled.
595
596 ESCAPE-SEQ is a SGR control sequences such as \\033[34m. The parameter
597 34 is used by `ansi-color-get-face-1' to return a face definition."
598 (let ((i 0)
599 f val)
600 (while (string-match ansi-color-parameter-regexp escape-seq i)
601 (setq i (match-end 0)
602 val (ansi-color-get-face-1
603 (string-to-number (match-string 1 escape-seq) 10)))
604 (cond ((not val))
605 ((eq val 'default)
606 (setq f (list val)))
607 (t
608 (unless (member val f)
609 (push val f)))))
610 f))
611
612 (provide 'ansi-color)
613
614 ;;; ansi-color.el ends here