Undo coding change, which screwed up somehow.
[emacs.git] / lisp / ansi-color.el
blob51421add42c0629e3d63a54f2d8156f8b7e03b6a
1 ;;; ansi-color.el --- translate ANSI escape sequences into faces
3 ;; Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
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
10 ;; This file is part of GNU Emacs.
12 ;; GNU Emacs is free software; you can redistribute it and/or modify it
13 ;; under the terms of the GNU General Public License as published by the
14 ;; Free Software Foundation; either version 2, or (at your option) any
15 ;; later version.
17 ;; GNU Emacs is distributed in the hope that it will be useful, but
18 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 ;; General Public License for more details.
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs; see the file COPYING. If not, write to the
24 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
25 ;; Boston, MA 02111-1307, USA.
27 ;;; Commentary:
29 ;; This file provides a function that takes a string or a region
30 ;; containing Select Graphic Rendition (SGR) control sequences (formerly
31 ;; known as ANSI escape sequences) and tries to translate these into
32 ;; faces.
34 ;; This allows you to run ls --color=yes in shell-mode. In order to
35 ;; test this, proceed as follows:
37 ;; 1. start a shell: M-x shell
38 ;; 2. load this file: M-x load-library RET ansi-color RET
39 ;; 3. activate ansi-color: M-x ansi-color-for-comint-mode-on
40 ;; 4. test ls --color=yes in the *shell* buffer
42 ;; Note that starting your shell from within Emacs might set the TERM
43 ;; environment variable. The new setting might disable the output of
44 ;; SGR control sequences. Using ls --color=yes forces ls to produce
45 ;; these.
47 ;; If you decide you like this, add the following to your .emacs file:
49 ;; (autoload 'ansi-color-for-comint-mode-on "ansi-color" nil t)
50 ;; (add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)
52 ;; SGR control sequences are defined in section 3.8.117 of the ECMA-48
53 ;; standard (identical to ISO/IEC 6429), which is freely available as a
54 ;; PDF file <URL:http://www.ecma.ch/ecma1/STAND/ECMA-048.HTM>. The
55 ;; "Graphic Rendition Combination Mode (GRCM)" implemented is
56 ;; "cumulative mode" as defined in section 7.2.8. Cumulative mode means
57 ;; that whenever possible, SGR control sequences are combined (ie. blue
58 ;; and bold).
60 ;; The basic functions are:
62 ;; `ansi-color-apply' to colorize a string containing SGR control
63 ;; sequences.
65 ;; `ansi-color-filter-apply' to filter SGR control sequences from a
66 ;; string.
68 ;; `ansi-color-apply-on-region' to colorize a region containing SGR
69 ;; control sequences.
71 ;; `ansi-color-filter-region' to filter SGR control sequences from a
72 ;; region.
74 ;;; Thanks
76 ;; Georges Brun-Cottan <gbruncot@emc.com> for improving ansi-color.el
77 ;; substantially by adding the code needed to cope with arbitrary chunks
78 ;; of output and the filter functions.
80 ;; Markus Kuhn <Markus.Kuhn@cl.cam.ac.uk> for pointing me to ECMA-48.
82 ;; Stefan Monnier <foo@acm.com> explaing obscure font-lock stuff and
83 ;; code suggestions.
87 ;;; Code:
89 ;; Customization
91 (defgroup ansi-colors nil
92 "Translating SGR control sequences to faces.
93 This translation effectively colorizes strings and regions based upon
94 SGR control sequences embedded in the text. SGR (Select Graphic
95 Rendition) control sequences are defined in section 3.8.117 of the
96 ECMA-48 standard \(identical to ISO/IEC 6429), which is freely available
97 as a PDF file <URL:http://www.ecma.ch/ecma1/STAND/ECMA-048.HTM>."
98 :version "21.1"
99 :group 'processes)
101 (defcustom ansi-color-faces-vector
102 [default bold default italic underline bold bold-italic modeline]
103 "Faces used for SGR control sequences determining a face.
104 This vector holds the faces used for SGR control sequence parameters 0
105 to 7.
107 Parameter Description Face used by default
108 0 default default
109 1 bold bold
110 2 faint default
111 3 italic italic
112 4 underlined underline
113 5 slowly blinking bold
114 6 rapidly blinking bold-italic
115 7 negative image modeline
117 Note that the symbol `default' is special: It will not be combined
118 with the current face.
120 This vector is used by `ansi-color-make-color-map' to create a color
121 map. This color map is stored in the variable `ansi-color-map'."
122 :type '(vector face face face face face face face face)
123 :set 'ansi-color-map-update
124 :initialize 'custom-initialize-default
125 :group 'ansi-colors)
127 (defcustom ansi-color-names-vector
128 ["black" "red" "green" "yellow" "blue" "magenta" "cyan" "white"]
129 "Colors used for SGR control sequences determining a color.
130 This vector holds the colors used for SGR control sequences parameters
131 30 to 37 \(foreground colors) and 40 to 47 (background colors).
133 Parameter Color
134 30 40 black
135 31 41 red
136 32 42 green
137 33 43 yellow
138 34 44 blue
139 35 45 magenta
140 36 46 cyan
141 37 47 white
143 This vector is used by `ansi-color-make-color-map' to create a color
144 map. This color map is stored in the variable `ansi-color-map'."
145 :type '(vector string string string string string string string string)
146 :set 'ansi-color-map-update
147 :initialize 'custom-initialize-default
148 :group 'ansi-colors)
150 (defconst ansi-color-regexp "\033\\[\\([0-9;]*\\)m"
151 "Regexp that matches SGR control sequences.")
153 (defconst ansi-color-parameter-regexp "\\([0-9]*\\)[m;]"
154 "Regexp that matches SGR control sequence parameters.")
157 ;; Convenience functions for comint modes (eg. shell-mode)
160 (defcustom ansi-color-for-comint-mode nil
161 "Determines what to do with comint output.
162 If nil, do nothing.
163 If the symbol `filter', then filter all SGR control sequences.
164 If anything else (such as t), then translate SGR control sequences
165 into text-properties.
167 In order for this to have any effect, `ansi-color-process-output' must
168 be in `comint-output-filter-functions'.
170 This can be used to enable colorized ls --color=yes output
171 in shell buffers. You set this variable by calling one of:
172 \\[ansi-color-for-comint-mode-on]
173 \\[ansi-color-for-comint-mode-off]
174 \\[ansi-color-for-comint-mode-filter]"
175 :type '(choice (const :tag "Do nothing" nil)
176 (const :tag "Filter" filter)
177 (const :tag "Translate" t))
178 :group 'ansi-colors)
180 ;;;###autoload
181 (defun ansi-color-for-comint-mode-on ()
182 "Set `ansi-color-for-comint-mode' to t."
183 (interactive)
184 (setq ansi-color-for-comint-mode t))
186 (defun ansi-color-for-comint-mode-off ()
187 "Set `ansi-color-for-comint-mode' to nil."
188 (interactive)
189 (setq ansi-color-for-comint-mode nil))
191 (defun ansi-color-for-comint-mode-filter ()
192 "Set `ansi-color-for-comint-mode' to symbol `filter'."
193 (interactive)
194 (setq ansi-color-for-comint-mode 'filter))
196 ;;;###autoload
197 (defun ansi-color-process-output (string)
198 "Maybe translate SGR control sequences of comint output into text-properties.
200 Depending on variable `ansi-color-for-comint-mode' the comint output is
201 either not processed, SGR control sequences are filtered using
202 `ansi-color-filter-region', or SGR control sequences are translated into
203 text-properties using `ansi-color-apply-on-region'.
205 The comint output is assumed to lie between the marker
206 `comint-last-output-start' and the process-mark.
208 This is a good function to put in `comint-output-filter-functions'."
209 (let ((start-marker (or comint-last-output-start
210 (point-min-marker)))
211 (end-marker (process-mark (get-buffer-process (current-buffer)))))
212 (cond ((eq ansi-color-for-comint-mode nil))
213 ((eq ansi-color-for-comint-mode 'filter)
214 (ansi-color-filter-region start-marker end-marker))
216 (ansi-color-apply-on-region start-marker end-marker)))))
218 (add-hook 'comint-output-filter-functions
219 'ansi-color-process-output)
222 ;; Alternative font-lock-unfontify-region-function for Emacs only
225 (eval-when-compile
226 ;; We use this to preserve or protect things when modifying text
227 ;; properties. Stolen from lazy-lock and font-lock. Ugly!!!
228 ;; Probably most of this is not needed?
229 (defmacro save-buffer-state (varlist &rest body)
230 "Bind variables according to VARLIST and eval BODY restoring buffer state."
231 (` (let* ((,@ (append varlist
232 '((modified (buffer-modified-p)) (buffer-undo-list t)
233 (inhibit-read-only t) (inhibit-point-motion-hooks t)
234 before-change-functions after-change-functions
235 deactivate-mark buffer-file-name buffer-file-truename))))
236 (,@ body)
237 (when (and (not modified) (buffer-modified-p))
238 (set-buffer-modified-p nil)))))
239 (put 'save-buffer-state 'lisp-indent-function 1))
241 (defun ansi-color-unfontify-region (beg end &rest xemacs-stuff)
242 "Replacement function for `font-lock-default-unfontify-region'.
244 As text-properties are implemented using extents in XEmacs, this
245 function is probably not needed. In Emacs, however, things are a bit
246 different: When font-lock is active in a buffer, you cannot simply add
247 face text-properties to the buffer. Font-lock will remove the face
248 text-property using `font-lock-unfontify-region-function'. If you want
249 to insert the strings returned by `ansi-color-apply' into such buffers,
250 you must set `font-lock-unfontify-region-function' to
251 `ansi-color-unfontify-region'. This function will not remove all face
252 text-properties unconditionally. It will keep the face text-properties
253 if the property `ansi-color' is set.
255 The region from BEG to END is unfontified. XEMACS-STUFF is ignored.
257 A possible way to install this would be:
259 \(add-hook 'font-lock-mode-hook
260 \(function (lambda ()
261 \(setq font-lock-unfontify-region-function
262 'ansi-color-unfontify-region))))"
263 ;; save-buffer-state is a macro in font-lock.el!
264 (save-buffer-state nil
265 (when (boundp 'font-lock-syntactic-keywords)
266 (remove-text-properties beg end '(syntax-table nil)))
267 ;; instead of just using (remove-text-properties beg end '(face
268 ;; nil)), we find regions with a non-nil face test-property, skip
269 ;; positions with the ansi-color property set, and remove the
270 ;; remaining face test-properties.
271 (while (setq beg (text-property-not-all beg end 'face nil))
272 (setq beg (or (text-property-not-all beg end 'ansi-color t) end))
273 (when (get-text-property beg 'face)
274 (let ((end-face (or (text-property-any beg end 'face nil)
275 end)))
276 (remove-text-properties beg end-face '(face nil))
277 (setq beg end-face))))))
279 ;; Working with strings
281 (defvar ansi-color-context nil
282 "Context saved between two calls to `ansi-color-apply'.
283 This is a list of the form (FACES FRAGMENT) or nil. FACES is a list of
284 faces the last call to `ansi-color-apply' ended with, and FRAGMENT is a
285 string starting with an escape sequence, possibly the start of a new
286 escape sequence.")
287 (make-variable-buffer-local 'ansi-color-context)
289 (defun ansi-color-filter-apply (string)
290 "Filter out all SGR control sequences from STRING.
292 Every call to this function will set and use the buffer-local variable
293 `ansi-color-context' to save partial escape sequences. This information
294 will be used for the next call to `ansi-color-apply'. Set
295 `ansi-color-context' to nil if you don't want this.
297 This function can be added to `comint-preoutput-filter-functions'."
298 (let ((start 0) end result)
299 ;; if context was saved and is a string, prepend it
300 (if (cadr ansi-color-context)
301 (setq string (concat (cadr ansi-color-context) string)
302 ansi-color-context nil))
303 ;; find the next escape sequence
304 (while (setq end (string-match ansi-color-regexp string start))
305 (setq result (concat result (substring string start end))
306 start (match-end 0)))
307 ;; save context, add the remainder of the string to the result
308 (let (fragment)
309 (if (string-match "\033" string start)
310 (let ((pos (match-beginning 0)))
311 (setq fragment (substring string pos)
312 result (concat result (substring string start pos))))
313 (setq result (concat result (substring string start))))
314 (if fragment
315 (setq ansi-color-context (list nil fragment))
316 (setq ansi-color-context nil)))
317 result))
319 (defun ansi-color-apply (string)
320 "Translates SGR control sequences into text-properties.
322 Applies SGR control sequences setting foreground and background colors
323 to STRING using text-properties and returns the result. The colors used
324 are given in `ansi-color-faces-vector' and `ansi-color-names-vector'.
325 See function `ansi-color-apply-sequence' for details.
327 Every call to this function will set and use the buffer-local variable
328 `ansi-color-context' to save partial escape sequences and current face.
329 This information will be used for the next call to `ansi-color-apply'.
330 Set `ansi-color-context' to nil if you don't want this.
332 This function can be added to `comint-preoutput-filter-functions'.
334 You cannot insert the strings returned into buffers using font-lock.
335 See `ansi-color-unfontify-region' for a way around this."
336 (let ((face (car ansi-color-context))
337 (start 0) end escape-sequence result)
338 ;; if context was saved and is a string, prepend it
339 (if (cadr ansi-color-context)
340 (setq string (concat (cadr ansi-color-context) string)
341 ansi-color-context nil))
342 ;; find the next escape sequence
343 (while (setq end (string-match ansi-color-regexp string start))
344 ;; store escape sequence
345 (setq escape-sequence (match-string 1 string))
346 ;; colorize the old block from start to end using old face
347 (when face
348 (put-text-property start end 'ansi-color t string)
349 (put-text-property start end 'face face string))
350 (setq result (concat result (substring string start end))
351 start (match-end 0))
352 ;; create new face by applying all the parameters in the escape
353 ;; sequence
354 (setq face (ansi-color-apply-sequence escape-sequence face)))
355 ;; if the rest of the string should have a face, put it there
356 (when face
357 (put-text-property start (length string) 'ansi-color t string)
358 (put-text-property start (length string) 'face face string))
359 ;; save context, add the remainder of the string to the result
360 (let (fragment)
361 (if (string-match "\033" string start)
362 (let ((pos (match-beginning 0)))
363 (setq fragment (substring string pos)
364 result (concat result (substring string start pos))))
365 (setq result (concat result (substring string start))))
366 (if (or face fragment)
367 (setq ansi-color-context (list face fragment))
368 (setq ansi-color-context nil)))
369 result))
371 ;; Working with regions
373 (defvar ansi-color-context-region nil
374 "Context saved between two calls to `ansi-color-apply-on-region'.
375 This is a list of the form (FACES MARKER) or nil. FACES is a list of
376 faces the last call to `ansi-color-apply-on-region' ended with, and
377 MARKER is a buffer position within an escape sequence or the last
378 position processed.")
379 (make-variable-buffer-local 'ansi-color-context-region)
381 (defun ansi-color-filter-region (begin end)
382 "Filter out all SGR control sequences from region BEGIN to END.
384 Every call to this function will set and use the buffer-local variable
385 `ansi-color-context-region' to save position. This information will be
386 used for the next call to `ansi-color-apply-on-region'. Specifically,
387 it will override BEGIN, the start of the region. Set
388 `ansi-color-context-region' to nil if you don't want this."
389 (let ((end-marker (copy-marker end))
390 (start (or (cadr ansi-color-context-region) begin)))
391 (save-excursion
392 (goto-char start)
393 ;; find the next escape sequence
394 (while (re-search-forward ansi-color-regexp end-marker t)
395 ;; delete the escape sequence
396 (replace-match ""))
397 ;; save context, add the remainder of the string to the result
398 (if (re-search-forward "\033" end-marker t)
399 (setq ansi-color-context-region (list nil (match-beginning 0)))
400 (setq ansi-color-context-region nil)))))
402 (defun ansi-color-apply-on-region (begin end)
403 "Translates SGR control sequences into overlays or extents.
405 Applies SGR control sequences setting foreground and background colors
406 to text in region between BEGIN and END using extents or overlays.
407 Emacs will use overlays, XEmacs will use extents. The colors used are
408 given in `ansi-color-faces-vector' and `ansi-color-names-vector'. See
409 function `ansi-color-apply-sequence' for details.
411 Every call to this function will set and use the buffer-local variable
412 `ansi-color-context-region' to save position and current face. This
413 information will be used for the next call to
414 `ansi-color-apply-on-region'. Specifically, it will override BEGIN, the
415 start of the region and set the face with which to start. Set
416 `ansi-color-context-region' to nil if you don't want this."
417 (let ((face (car ansi-color-context-region))
418 (start-marker (or (cadr ansi-color-context-region)
419 (copy-marker begin)))
420 (end-marker (copy-marker end))
421 escape-sequence)
422 (save-excursion
423 (goto-char start-marker)
424 ;; find the next escape sequence
425 (while (re-search-forward ansi-color-regexp end-marker t)
426 ;; colorize the old block from start to end using old face
427 (when face
428 (ansi-color-set-extent-face
429 (ansi-color-make-extent start-marker (match-beginning 0))
430 face))
431 ;; store escape sequence and new start position
432 (setq escape-sequence (match-string 1)
433 start-marker (copy-marker (match-end 0)))
434 ;; delete the escape sequence
435 (replace-match "")
436 ;; create new face by applying all the parameters in the escape
437 ;; sequence
438 (setq face (ansi-color-apply-sequence escape-sequence face)))
439 ;; search for the possible start of a new escape sequence
440 (if (re-search-forward "\033" end-marker t)
441 (progn
442 ;; if the rest of the region should have a face, put it there
443 (when face
444 (ansi-color-set-extent-face
445 (ansi-color-make-extent start-marker (point))
446 face))
447 ;; save face and point
448 (setq ansi-color-context-region
449 (list face (copy-marker (match-beginning 0)))))
450 ;; if the rest of the region should have a face, put it there
451 (if face
452 (progn
453 (ansi-color-set-extent-face
454 (ansi-color-make-extent start-marker end-marker)
455 face)
456 (setq ansi-color-context-region (list face)))
457 ;; reset context
458 (setq ansi-color-context-region nil))))))
460 ;; This function helps you look for overlapping overlays. This is
461 ;; usefull in comint-buffers. Overlapping overlays should not happen!
462 ;; A possible cause for bugs are the markers. If you create an overlay
463 ;; up to the end of the region, then that end might coincide with the
464 ;; process-mark. As text is added BEFORE the process-mark, the overlay
465 ;; will keep growing. Therefore, as more overlays are created later on,
466 ;; there will be TWO OR MORE overlays covering the buffer at that point.
467 ;; This function helps you check your buffer for these situations.
468 ; (defun ansi-color-debug-overlays ()
469 ; (interactive)
470 ; (let ((pos (point-min)))
471 ; (while (< pos (point-max))
472 ; (if (<= 2 (length (overlays-at pos)))
473 ; (progn
474 ; (goto-char pos)
475 ; (error "%d overlays at %d" (length (overlays-at pos)) pos))
476 ; (let (message-log-max)
477 ; (message "Reached %d." pos)))
478 ; (setq pos (next-overlay-change pos)))))
480 ;; Emacs/XEmacs compatibility layer
482 (defun ansi-color-make-face (property color)
483 "Return a face with PROPERTY set to COLOR.
484 PROPERTY can be either symbol `foreground' or symbol `background'.
486 For Emacs, we just return the cons cell \(PROPERTY . COLOR).
487 For XEmacs, we create a temporary face and return it."
488 (if (featurep 'xemacs)
489 (let ((face (make-face (intern (concat color "-" (symbol-name property)))
490 "Temporary face created by ansi-color."
491 t)))
492 (set-face-property face property color)
493 face)
494 (cond ((eq property 'foreground)
495 (cons 'foreground-color color))
496 ((eq property 'background)
497 (cons 'background-color color))
499 (cons property color)))))
501 (defun ansi-color-make-extent (from to &optional object)
502 "Make an extent for the range [FROM, TO) in OBJECT.
504 OBJECT defaults to the current buffer. XEmacs uses `make-extent', Emacs
505 uses `make-overlay'. XEmacs can use a buffer or a string for OBJECT,
506 Emacs requires OBJECT to be a buffer."
507 (if (functionp 'make-extent)
508 (make-extent from to object)
509 ;; In Emacs, the overlay might end at the process-mark in comint
510 ;; buffers. In that case, new text will be inserted before the
511 ;; process-mark, ie. inside the overlay (using insert-before-marks).
512 ;; In order to avoid this, we use the `insert-behind-hooks' overlay
513 ;; property to make sure it works.
514 (let ((overlay (make-overlay from to object)))
515 (overlay-put overlay 'modification-hooks '(ansi-color-freeze-overlay))
516 overlay)))
518 (defun ansi-color-freeze-overlay (overlay is-after begin end &optional len)
519 "Prevent OVERLAY from being extended.
520 This function can be used for the `modification-hooks' overlay
521 property."
522 ;; if stuff was inserted at the end of the overlay
523 (when (and is-after
524 (= 0 len)
525 (= end (overlay-end overlay)))
526 ;; reset the end of the overlay
527 (move-overlay overlay (overlay-start overlay) begin)))
529 (defun ansi-color-set-extent-face (extent face)
530 "Set the `face' property of EXTENT to FACE.
531 XEmacs uses `set-extent-face', Emacs uses `overlay-put'."
532 (if (functionp 'set-extent-face)
533 (set-extent-face extent face)
534 (overlay-put extent 'face face)))
536 ;; Helper functions
538 (defun ansi-color-apply-sequence (escape-sequence faces)
539 "Apply ESCAPE-SEQ to FACES and return the new list of faces.
541 ESCAPE-SEQ is an escape sequences parsed by `ansi-color-get-face'.
543 If the new faces start with the symbol `default', then the new
544 faces are returned. If the faces start with something else,
545 they are appended to the front of the FACES list, and the new
546 list of faces is returned.
548 If `ansi-color-get-face' returns nil, then we either got a
549 null-sequence, or we stumbled upon some garbage. In either
550 case we return nil."
551 (let ((new-faces (ansi-color-get-face escape-sequence)))
552 (cond ((null new-faces)
553 nil)
554 ((eq (car new-faces) 'default)
555 (cdr new-faces))
557 (append new-faces faces)))))
559 (defun ansi-color-make-color-map ()
560 "Creates a vector of face definitions and returns it.
562 The index into the vector is an ANSI code. See the documentation of
563 `ansi-color-map' for an example.
565 The face definitions are based upon the variables
566 `ansi-color-faces-vector' and `ansi-color-names-vector'."
567 (let ((ansi-color-map (make-vector 50 nil))
568 (index 0))
569 ;; miscellaneous attributes
570 (mapcar
571 (function (lambda (e)
572 (aset ansi-color-map index e)
573 (setq index (1+ index)) ))
574 ansi-color-faces-vector)
575 ;; foreground attributes
576 (setq index 30)
577 (mapcar
578 (function (lambda (e)
579 (aset ansi-color-map index
580 (ansi-color-make-face 'foreground e))
581 (setq index (1+ index)) ))
582 ansi-color-names-vector)
583 ;; background attributes
584 (setq index 40)
585 (mapcar
586 (function (lambda (e)
587 (aset ansi-color-map index
588 (ansi-color-make-face 'background e))
589 (setq index (1+ index)) ))
590 ansi-color-names-vector)
591 ansi-color-map))
593 (defvar ansi-color-map (ansi-color-make-color-map)
594 "A brand new color map suitable for `ansi-color-get-face'.
596 The value of this variable is usually constructed by
597 `ansi-color-make-color-map'. The values in the array are such that the
598 numbers included in an SGR control sequences point to the correct
599 foreground or background colors.
601 Example: The sequence \033[34m specifies a blue foreground. Therefore:
602 (aref ansi-color-map 34)
603 => \(foreground-color . \"blue\")")
605 (defun ansi-color-map-update (symbol value)
606 "Update `ansi-color-map'.
608 Whenever the vectors used to construct `ansi-color-map' are changed,
609 this function is called. Therefore this function is listed as the :set
610 property of `ansi-color-faces-vector' and `ansi-color-names-vector'."
611 (set-default symbol value)
612 (setq ansi-color-map (ansi-color-make-color-map)))
614 (defun ansi-color-get-face-1 (ansi-code)
615 "Get face definition from `ansi-color-map'.
616 ANSI-CODE is used as an index into the vector."
617 (condition-case nil
618 (aref ansi-color-map ansi-code)
619 ('args-out-of-range nil)))
621 (defun ansi-color-get-face (escape-seq)
622 "Create a new face by applying all the parameters in ESCAPE-SEQ.
624 Should any of the parameters result in the default face (usually this is
625 the parameter 0), then the effect of all previous parameters is cancelled.
627 ESCAPE-SEQ is a SGR control sequences such as \\033[34m. The parameter
628 34 is used by `ansi-color-get-face-1' to return a face definition."
629 (let ((ansi-color-r "[0-9][0-9]?")
630 (i 0)
631 f val)
632 (while (string-match ansi-color-r escape-seq i)
633 (setq i (match-end 0)
634 val (ansi-color-get-face-1
635 (string-to-int (match-string 0 escape-seq) 10)))
636 (cond ((not val))
637 ((eq val 'default)
638 (setq f (list val)))
640 (add-to-list 'f val))))
643 (provide 'ansi-color)
645 ;;; ansi-color.el ends here