lisp/ansi-color.el

   1 ;;; ansi-color.el --- translate ANSI escape sequences into faces
   2
   3 ;; Copyright (C) 1999, 2000, 2001  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 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.
  16 ;;
  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.
  21 ;;
  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.
  26
  27 ;;; Commentary:
  28
  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.
  33 ;;
  34 ;; This allows you to run ls --color=yes in shell-mode.  In order to
  35 ;; test this, proceed as follows:
  36 ;;
  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
  41 ;;
  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.
  46 ;;
  47 ;; If you decide you like this, add the following to your .emacs file:
  48 ;;
  49 ;; (autoload 'ansi-color-for-comint-mode-on "ansi-color" nil t)
  50 ;; (add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)
  51 ;;
  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).
  59
  60 ;; The basic functions are:
  61 ;;
  62 ;; `ansi-color-apply' to colorize a string containing SGR control
  63 ;; sequences.
  64 ;;
  65 ;; `ansi-color-filter-apply' to filter SGR control sequences from a
  66 ;; string.
  67 ;;
  68 ;; `ansi-color-apply-on-region' to colorize a region containing SGR
  69 ;; control sequences.
  70 ;;
  71 ;; `ansi-color-filter-region' to filter SGR control sequences from a
  72 ;; region.
  73
  74 ;;; Thanks
  75
  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.
  79 ;;
  80 ;; Markus Kuhn <Markus.Kuhn@cl.cam.ac.uk> for pointing me to ECMA-48.
  81 ;;
  82 ;; Stefan Monnier <foo@acm.com> explaing obscure font-lock stuff and
  83 ;; code suggestions.
  84
  85 \f
  86
  87 ;;; Code:
  88
  89 ;; Customization
  90
  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)
 100
 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.
 106
 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
 116
 117 Note that the symbol `default' is special: It will not be combined
 118 with the current face.
 119
 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)
 126
 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).
 132
 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
 142
 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)
 149
 150 (defconst ansi-color-regexp "\033\\[\\([0-9;]*\\)m"
 151   "Regexp that matches SGR control sequences.")
 152
 153 (defconst ansi-color-parameter-regexp "\\([0-9]*\\)[m;]"
 154   "Regexp that matches SGR control sequence parameters.")
 155
 156
 157 ;; Convenience functions for comint modes (eg. shell-mode)
 158
 159
 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.
 166
 167 In order for this to have any effect, `ansi-color-process-output' must
 168 be in `comint-output-filter-functions'.
 169
 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)
 179
 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))
 185
 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))
 190
 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))
 195
 196 ;;;###autoload
 197 (defun ansi-color-process-output (string)
 198   "Maybe translate SGR control sequences of comint output into text-properties.
 199
 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'.
 204
 205 The comint output is assumed to lie between the marker
 206 `comint-last-output-start' and the process-mark.
 207
 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))
 215           (t
 216            (ansi-color-apply-on-region start-marker end-marker)))))
 217
 218 (add-hook 'comint-output-filter-functions
 219           'ansi-color-process-output)
 220
 221
 222 ;; Alternative font-lock-unfontify-region-function for Emacs only
 223
 224
 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))
 240
 241 (defun ansi-color-unfontify-region (beg end &rest xemacs-stuff)
 242   "Replacement function for `font-lock-default-unfontify-region'.
 243
 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.
 254
 255 The region from BEG to END is unfontified.  XEMACS-STUFF is ignored.
 256
 257 A possible way to install this would be:
 258
 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))))))
 278
 279 ;; Working with strings
 280
 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)
 288
 289 (defun ansi-color-filter-apply (string)
 290   "Filter out all SGR control sequences from STRING.
 291
 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.
 296
 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))
 318
 319 (defun ansi-color-apply (string)
 320   "Translates SGR control sequences into text-properties.
 321
 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.
 326
 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.
 331
 332 This function can be added to `comint-preoutput-filter-functions'.
 333
 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))
 370
 371 ;; Working with regions
 372
 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)
 380
 381 (defun ansi-color-filter-region (begin end)
 382   "Filter out all SGR control sequences from region BEGIN to END.
 383
 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)))))
 401
 402 (defun ansi-color-apply-on-region (begin end)
 403   "Translates SGR control sequences into overlays or extents.
 404
 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.
 410
 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))))))
 459
 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)))))
 479
 480 ;; Emacs/XEmacs compatibility layer
 481
 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'.
 485
 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))
 498           (t
 499            (cons property color)))))
 500
 501 (defun ansi-color-make-extent (from to &optional object)
 502   "Make an extent for the range [FROM, TO) in OBJECT.
 503
 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)))
 517
 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)))
 528
 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)))
 535
 536 ;; Helper functions
 537
 538 (defun ansi-color-apply-sequence (escape-sequence faces)
 539   "Apply ESCAPE-SEQ to FACES and return the new list of faces.
 540
 541 ESCAPE-SEQ is an escape sequences parsed by `ansi-color-get-face'.
 542
 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.
 547
 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))
 556           (t
 557            (append new-faces faces)))))
 558
 559 (defun ansi-color-make-color-map ()
 560   "Creates a vector of face definitions and returns it.
 561
 562 The index into the vector is an ANSI code.  See the documentation of
 563 `ansi-color-map' for an example.
 564
 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))
 592
 593 (defvar ansi-color-map (ansi-color-make-color-map)
 594   "A brand new color map suitable for `ansi-color-get-face'.
 595
 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.
 600
 601 Example: The sequence \033[34m specifies a blue foreground.  Therefore:
 602      (aref ansi-color-map 34)
 603           => \(foreground-color . \"blue\")")
 604
 605 (defun ansi-color-map-update (symbol value)
 606   "Update `ansi-color-map'.
 607
 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)))
 613
 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)))
 620
 621 (defun ansi-color-get-face (escape-seq)
 622   "Create a new face by applying all the parameters in ESCAPE-SEQ.
 623
 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.
 626
 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)))
 639             (t
 640              (add-to-list 'f val))))
 641     f))
 642
 643 (provide 'ansi-color)
 644
 645 ;;; ansi-color.el ends here