New file.

lisp/gs.el

+;;; gs.el --- interface to Ghostscript
+
+;; Copyright (C) 1998 Free Software Foundation, Inc.
+
+;; Maintainer: FSF
+;; Keywords: internal
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary:
+
+;; This code is experimental.  Don't use it.
+
+;;; Code:
+
+(defvar gs-program "gs"
+  "The name of the Ghostscript interpreter.")
+
+
+(defvar gs-device "x11"
+  "The Ghostscript device to use to produce images.")
+
+
+(defvar gs-options 
+  '("-q"
+    ;"-dNOPAUSE"
+    "-dBATCH"
+    "-sDEVICE=<device>"
+    "<file>")
+  "List of command line arguments to pass to Ghostscript.
+Arguments may contain place-holders `<file>' for the name of the
+input file, and `<device>' for the device to use.")
+
+
+(defun gs-replace-in-string (string find repl)
+  "Return STRING with all occurrences of FIND replaced by REPL.
+FIND is a regular expression."
+  (while (string-match find string)
+    (setq string (replace-match repl nil t string)))
+  string)
+
+
+(defun gs-options (device file)
+  "Return a list of command line options with place-holders replaced.
+DEVICE is the value to substitute for the place-holder `<device>',
+FILE is the value to substitute for the place-holder `<file>'."
+  (mapcar #'(lambda (option)
+	      (setq option (gs-replace-in-string option "<device>" device)
+		    option (gs-replace-in-string option "<file>" file)))
+	  gs-options))
+  
+
+;; The GHOSTVIEW property (taken from gv 3.5.8).
+;; 
+;; Type:
+;;
+;; STRING
+;; 
+;; Parameters:
+;; 
+;; BPIXMAP ORIENT LLX LLY URX URY XDPI YDPI [LEFT BOTTOM TOP RIGHT]
+;; 
+;; Scanf format: "%d %d %d %d %d %d %f %f %d %d %d %d"
+;; 
+;; Explanation of parameters:
+;; 
+;; BPIXMAP: pixmap id of the backing pixmap for the window.  If no
+;; pixmap is to be used, this parameter should be zero.  This
+;; parameter must be zero when drawing on a pixmap.
+;; 
+;; ORIENT: orientation of the page.  The number represents clockwise
+;; rotation of the paper in degrees.  Permitted values are 0, 90, 180,
+;; 270.
+;; 
+;; LLX, LLY, URX, URY: Bounding box of the drawable.  The bounding box
+;; is specified in PostScript points in default user coordinates.
+;; 
+;; XDPI, YDPI: Resolution of window.  (This can be derived from the
+;; other parameters, but not without roundoff error.  These values are
+;; included to avoid this error.)
+;; 
+;; LEFT, BOTTOM, TOP, RIGHT: (optional) Margins around the window.
+;; The margins extend the imageable area beyond the boundaries of the
+;; window.  This is primarily used for popup zoom windows.  I have
+;; encountered several instances of PostScript programs that position
+;; themselves with respect to the imageable area.  The margins are
+;; specified in PostScript points.  If omitted, the margins are
+;; assumed to be 0.
+
+(defun gs-width-in-pt (frame pixel-width)
+  "Return, on FRAME, pixel width PIXEL-WIDTH tranlated to pt."
+  (let ((mm (* (float pixel-width)
+	       (/ (float (x-display-mm-width frame))
+		  (float (x-display-pixel-width frame))))))
+    (/ (* 25.4 mm) 72.0)))
+
+
+(defun gs-height-in-pt (frame pixel-height)
+  "Return, on FRAME, pixel height PIXEL-HEIGHT tranlated to pt."
+  (let ((mm (* (float pixel-height)
+	       (/ (float (x-display-mm-height frame))
+		  (float (x-display-pixel-height frame))))))
+    (/ (* 25.4 mm) 72.0)))
+	
+
+(defun gs-set-ghostview-window-prop (frame spec img-width img-height)
+  "Set the `GHOSTVIEW' window property of FRAME.
+SPEC is a GS image specification.  IMG-WIDTH is the width of the
+requested image, and IMG-HEIGHT is the height of the requested
+image in pixels."
+  (let* ((box (plist-get (cdr spec) :bounding-box))
+	 (llx (nth 0 box))
+	 (lly (nth 1 box))
+	 (urx (nth 2 box))
+	 (ury (nth 3 box))
+	 (rotation (or (plist-get (cdr spec) :rotate) 0))
+	 ;; The pixel width IMG-WIDTH of the pixmap gives the
+	 ;; dots, URX - LLX give the inch.
+	 (in-width (/ (- urx llx) 72.0))
+	 (in-height (/ (- ury lly) 72.0))
+	 (xdpi (/ img-width in-width))
+	 (ydpi (/ img-height in-height)))
+    (x-change-window-property "GHOSTVIEW"
+			      (format "0 %d %d %d %d %d %g %g"
+				      rotation llx lly urx ury xdpi ydpi)
+			      frame)))
+
+
+(defun gs-set-ghostview-colors-window-prop (frame pixel-colors)
+  "Set the `GHOSTVIEW_COLORS' environment variable depending on FRAME."
+  (let ((mode (cond ((x-display-color-p frame) "Color")
+		    ((x-display-grayscale-p frame) "Grayscale")
+		    (t "Monochrome"))))
+    (x-change-window-property "GHOSTVIEW_COLORS"
+			      (format "%s %s" mode pixel-colors))))
+	      
+
+;
+;;;###autoload
+(defun gs-load-image (frame spec img-width img-height window-and-pixmap-id
+			    pixel-colors)
+  "Load a PS image for display on FRAME.
+SPEC is an image specification, IMG-HEIGHT and IMG-WIDTH are width
+and height of the image in pixels.  WINDOW-AND-PIXMAP-ID is a string of
+the form \"WINDOW-ID PIXMAP-ID\".  Value is non-nil if successful."
+  (unwind-protect
+      (let ((file (plist-get (cdr spec) :file))
+	    gs)
+	(gs-set-ghostview-window-prop frame spec img-width img-height)
+	(gs-set-ghostview-colors-window-prop frame pixel-colors)
+	(setenv "GHOSTVIEW" window-and-pixmap-id)
+	(setq gs (apply 'start-process "gs" "*GS*" gs-program
+			(gs-options gs-device file)))
+	(process-kill-without-query gs)
+	gs)
+    nil))
+
+
+;(defun gs-put-tiger ()
+;  (let* ((ps-file "/usr/local/share/ghostscript/5.10/examples/tiger.ps")
+;	  (spec `(image :type ghostscript
+;			:pt-width 200 :pt-height 200
+;			:bounding-box (22 171 567 738)
+;			:file ,ps-file)))
+;    (put-text-property 1 2 'display spec)))
+;    
+
+(provide 'gs)
+
+;; gs.el ends here.

lisp/image.el

+;;; image.el --- image API
+
+;; Copyright (C) 1998 Free Software Foundation, Inc.
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary:
+
+;;; Code:
+
+(defconst image-type-regexps
+  '(("^/\\*.*XPM.\\*/" . xpm)
+    ("^P[1-6]" . pbm)
+    ("^GIF8" . gif)
+    ("JFIF" . jpeg)
+    ("^\211PNG\r\n" . png)
+    ("^#define" . xbm)
+    ("^\\(MM\0\\*\\)\\|\\(II\\*\0\\)" . tiff)
+    ("^%!PS" . ghostscript))
+  "Alist of (REGEXP . IMAGE-TYPE) pairs used to auto-detect image types.
+When the first bytes of an image file match REGEXP, it is assumed to
+be of image type IMAGE-TYPE.")
+
+
+;;;###autoload
+(defun image-type-from-file-header (file)
+  "Determine the type of image file FILE from its first few bytes.
+Value is a symbol specifying the image type, or nil if type cannot
+be determined."
+  (unless (file-name-directory file)
+    (setq file (concat data-directory file)))
+  (setq file (expand-file-name file))
+  (let ((header (with-temp-buffer
+		  (insert-file-contents-literally file nil 0 256)
+		  (buffer-string)))
+	(types image-type-regexps)
+	type)
+    (while (and types (null type))
+      (let ((regexp (car (car types)))
+	    (image-type (cdr (car types))))
+	(when (string-match regexp header)
+	  (setq type image-type))
+	(setq types (cdr types))))
+    type))
+
+
+;;;###autoload
+(defun image-type-available-p (type)
+  "Value is non-nil if image type TYPE is available.
+Image types are symbols like `xbm' or `jpeg'."
+  (not (null (memq type image-types))))
+
+
+;;;###autoload
+(defun create-image (file &optional type &rest props)
+  "Create an image which will be loaded from FILE.
+Optional TYPE is a symbol describing the image type.  If TYPE is omitted
+or nil, try to determine the image file type from its first few bytes.
+If that doesn't work, use FILE's extension.as image type.
+Optional PROPS are additional image attributes to assign to the image,
+like, e.g. `:heuristic-mask t'.
+Value is the image created, or nil if images of type TYPE are not supported."
+  (unless (stringp file)
+    (error "Invalid image file name %s" file))
+  (unless (or type
+	      (setq type (image-type-from-file-header file)))
+    (let ((extension (file-name-extension file)))
+      (unless extension
+	(error "Cannot determine image type"))
+      (setq type (intern extension))))
+  (unless (symbolp type)
+    (error "Invalid image type %s" type))
+  (when (image-type-available-p type)
+    (append (list 'image :type type :file file) props)))
+
+
+;;;###autoload
+(defun put-image (image pos &optional buffer area)
+  "Put image IMAGE in front of POS in BUFFER.
+IMAGE must be an image created with `create-image' or `defimage'.
+POS may be an integer or marker.
+BUFFER nil or omitted means use the current buffer.
+AREA is where to display the image.  AREA nil or omitted means
+display it in the text area, a value of `left-margin' means
+display it in the left marginal area, a value of `right-margin'
+means display it in the right marginal area.
+IMAGE is displayed by putting an overlay into BUFFER with a
+`before-string' that has a `display' property whose value is the
+image."
+  (unless buffer
+    (setq buffer (current-buffer)))
+  (unless (eq (car image) 'image)
+    (error "Not an image: %s" image))
+  (unless (or (null area) (memq area '(left-margin right-margin)))
+    (error "Invalid area %s" area))
+  (let ((overlay (make-overlay pos pos buffer))
+	(string (make-string 1 ?x))
+	(prop (if (null area) image (cons area image))))
+    (put-text-property 0 1 'display prop string)
+    (overlay-put overlay 'put-image t)
+    (overlay-put overlay 'before-string string)))
+
+
+;;;###autoload
+(defun insert-image (image &optional area)
+  "Insert IMAGE into current buffer at point.
+AREA is where to display the image.  AREA nil or omitted means
+display it in the text area, a value of `left-margin' means
+display it in the left marginal area, a value of `right-margin'
+means display it in the right marginal area.
+IMAGE is displayed by inserting an \"x\" into the current buffer
+having a `display' property whose value is the image."
+  (unless (eq (car image) 'image)
+    (error "Not an image: %s" image))
+  (unless (or (null area) (memq area '(left-margin right-margin)))
+    (error "Invalid area %s" area))
+  (insert "x")
+  (add-text-properties (1- (point)) (point)
+		       (list 'display (if (null area) image (cons area image))
+			     'rear-nonsticky (list 'display))))
+	
+
+;;;###autoload
+(defun remove-images (start end &optional buffer)
+  "Remove images between START and END in BUFFER.
+Remove only images that were put in BUFFER with calls to `put-image'.
+BUFFER nil or omitted means use the current buffer."
+  (unless buffer
+    (setq buffer (current-buffer)))
+  (let ((overlays (overlays-in start end)))
+    (while overlays
+      (let ((overlay (car overlays)))
+	(when (overlay-get overlay 'put-image)
+	  (delete-overlay overlay)
+	(setq overlays (cdr overlays)))))))
+
+
+;;;###autoload
+(defmacro defimage (symbol specs &optional doc)
+  "Define SYMBOL as an image.
+
+SPECS is a list of image specifications.  DOC is an optional
+documentation string.
+
+Each image specification in SPECS is a property list.  The contents of
+a specification are image type dependent.  All specifications must at
+least contain the properties `:type TYPE' and `:file FILE', where TYPE
+is a symbol specifying the image type, e.g. `xbm', and FILE is the
+file to load the image from.  The first image specification whose TYPE
+is supported, and FILE exists, is used to define SYMBOL.
+
+Example:
+
+   (defimage test-image ((:type xpm :file \"~/test1.xpm\")
+                         (:type xbm :file \"~/test1.xbm\")))"
+  (let (image)
+    (while (and specs (null image))
+      (let* ((spec (car specs))
+	     (type (plist-get spec :type))
+	     (file (plist-get spec :file)))
+	(when (and (image-type-available-p type) (stringp file))
+	  (setq file (expand-file-name file))
+	  (unless (file-name-absolute-p file)
+	    (setq file (concat data-directory "/" file)))
+	  (when (file-exists-p file)
+	    (setq image (cons 'image spec))))
+	(setq specs (cdr specs))))
+    `(defvar ,symbol ',image ,doc)))
+
+
+(provide 'image)
+
+  ;; image.el ends here.
+
+
+
+

lisp/jit-lock.el

+;;; jit-lock.el --- just-in-time fontification.
+
+;; Copyright (C) 1998 Free Software Foundation, Inc.
+
+;; Author: Gerd Moellmann <gerd@gnu.org>
+;; Keywords: faces files
+;; Version: 1.0
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary:
+
+;; Just-in-time fontification, triggered by C redisplay code.
+
+;;; Code:
+
+
+(require 'font-lock)
+
+(eval-when-compile
+  (defmacro with-buffer-prepared-for-font-lock (&rest body)
+    "Execute BODY in current buffer, overriding several variables.
+Preserves the `buffer-modified-p' state of the current buffer."
+    `(let ((modified (buffer-modified-p))
+	   (buffer-undo-list t)
+	   (inhibit-read-only t)
+	   (inhibit-point-motion-hooks t)
+	   before-change-functions
+	   after-change-functions
+	   deactivate-mark
+	   buffer-file-name
+	   buffer-file-truename)
+       ,@body
+       (set-buffer-modified-p modified))))
+  
+
+
+;;; Customization.
+
+(defcustom jit-lock-chunk-size 500
+  "*Font-lock chunks of this many characters, or smaller."
+  :type 'integer
+  :group 'jit-lock)
+
+
+(defcustom jit-lock-stealth-time 3
+  "*Time in seconds to wait before beginning stealth fontification.
+Stealth fontification occurs if there is no input within this time.
+If nil, means stealth fontification is never performed.
+
+The value of this variable is used when JIT Lock mode is turned on."
+  :type '(choice (const :tag "never" nil)
+		 (number :tag "seconds"))
+  :group 'jit-lock)
+
+
+(defcustom jit-lock-stealth-nice 0.125
+  "*Time in seconds to pause between chunks of stealth fontification.
+Each iteration of stealth fontification is separated by this amount of time,
+thus reducing the demand that stealth fontification makes on the system.
+If nil, means stealth fontification is never paused.
+To reduce machine load during stealth fontification, at the cost of stealth
+taking longer to fontify, you could increase the value of this variable.
+See also `jit-lock-stealth-load'."
+  :type '(choice (const :tag "never" nil)
+		 (number :tag "seconds"))	  
+  :group 'jit-lock)
+ 
+
+(defcustom jit-lock-stealth-load
+  (if (condition-case nil (load-average) (error)) 200)
+  "*Load in percentage above which stealth fontification is suspended.
+Stealth fontification pauses when the system short-term load average (as
+returned by the function `load-average' if supported) goes above this level,
+thus reducing the demand that stealth fontification makes on the system.
+If nil, means stealth fontification is never suspended.
+To reduce machine load during stealth fontification, at the cost of stealth
+taking longer to fontify, you could reduce the value of this variable.
+See also `jit-lock-stealth-nice'."
+  :type (if (condition-case nil (load-average) (error))
+	    '(choice (const :tag "never" nil)
+		     (integer :tag "load"))
+	  '(const :format "%t: unsupported\n" nil))
+  :group 'jit-lock)
+
+
+(defcustom jit-lock-stealth-verbose nil
+  "*If non-nil, means stealth fontification should show status messages."
+  :type 'boolean
+  :group 'jit-lock)
+
+
+(defcustom jit-lock-defer-contextually 'syntax-driven
+  "*If non-nil, means deferred fontification should be syntactically true.
+If nil, means deferred fontification occurs only on those lines modified.  This
+means where modification on a line causes syntactic change on subsequent lines,
+those subsequent lines are not refontified to reflect their new context.
+If t, means deferred fontification occurs on those lines modified and all
+subsequent lines.  This means those subsequent lines are refontified to reflect
+their new syntactic context, either immediately or when scrolling into them.
+If any other value, e.g., `syntax-driven', means deferred syntactically true
+fontification occurs only if syntactic fontification is performed using the
+buffer mode's syntax table, i.e., only if `font-lock-keywords-only' is nil.
+
+The value of this variable is used when JIT Lock mode is turned on."
+  :type '(choice (const :tag "never" nil)
+		 (const :tag "always" t)
+		 (other :tag "syntax-driven" syntax-driven))
+  :group 'jit-lock)
+
+
+
+;;; Variables that are not customizable.
+
+(defvar jit-lock-mode nil
+  "Non-nil means Just-in-time Lock mode is active.")
+(make-variable-buffer-local 'jit-lock-mode)
+
+
+(defvar jit-lock-first-unfontify-pos nil
+  "Consider text after this position as unfontified.")
+(make-variable-buffer-local 'jit-lock-first-unfontify-pos)
+
+
+(defvar jit-lock-stealth-timer nil
+  "Timer for stealth fontification in Just-in-time Lock mode.")
+
+
+
+;;; JIT lock mode
+
+;;;###autoload
+(defun jit-lock-mode (arg)
+  "Toggle Just-in-time Lock mode.
+With arg, turn Just-in-time Lock mode on if and only if arg is positive.
+Enable it automatically by customizing group `font-lock'.
+
+When Just-in-time Lock mode is enabled, fontification is different in the
+following ways:
+
+- Demand-driven buffer fontification triggered by Emacs C code.
+  This means initial fontification of the whole buffer does not occur.
+  Instead, fontification occurs when necessary, such as when scrolling
+  through the buffer would otherwise reveal unfontified areas.  This is
+  useful if buffer fontification is too slow for large buffers.
+
+- Stealthy buffer fontification if `jit-lock-stealth-time' is non-nil.
+  This means remaining unfontified areas of buffers are fontified if Emacs has
+  been idle for `jit-lock-stealth-time' seconds, while Emacs remains idle.
+  This is useful if any buffer has any deferred fontification.
+
+- Deferred context fontification if `jit-lock-defer-contextually' is
+  non-nil.  This means fontification updates the buffer corresponding to
+  true syntactic context, after `jit-lock-stealth-time' seconds of Emacs
+  idle time, while Emacs remains idle.  Otherwise, fontification occurs
+  on modified lines only, and subsequent lines can remain fontified
+  corresponding to previous syntactic contexts.  This is useful where
+  strings or comments span lines.
+
+Stealth fontification only occurs while the system remains unloaded.
+If the system load rises above `jit-lock-stealth-load' percent, stealth
+fontification is suspended.  Stealth fontification intensity is controlled via
+the variable `jit-lock-stealth-nice' and `jit-lock-stealth-lines'."
+  (interactive "P")
+  (setq jit-lock-mode (if arg
+			  (> (prefix-numeric-value arg) 0)
+			(not jit-lock-mode)))
+  (cond ((and jit-lock-mode
+	      (or (not (boundp 'font-lock-mode))
+		  (not font-lock-mode)))
+	 ;; If font-lock is not on, turn it on, with Just-in-time
+	 ;; Lock mode as support mode; font-lock will call us again.
+	 (let ((font-lock-support-mode 'jit-lock-mode))
+	   (font-lock-mode t)))
+
+	;; Turn Just-in-time Lock mode on.
+	(jit-lock-mode
+	 ;; Setting `font-lock-fontified' makes font-lock believe the
+	 ;; buffer is already fontified, so that it won't highlight
+	 ;; the whole buffer.
+	 (make-local-variable 'font-lock-fontified)
+	 (setq font-lock-fontified t)
+
+	 (setq jit-lock-first-unfontify-pos nil)
+	 
+	 ;; Install an idle timer for stealth fontification.
+	 (when (and jit-lock-stealth-time
+		    (null jit-lock-stealth-timer))
+	   (setq jit-lock-stealth-timer 
+		 (run-with-idle-timer jit-lock-stealth-time
+				      jit-lock-stealth-time
+				      'jit-lock-stealth-fontify)))
+
+	 ;; Add a hook for deferred contectual fontification.
+	 (when (or (eq jit-lock-defer-contextually 'always)
+		   (and (not (eq jit-lock-defer-contextually 'never))
+			(null font-lock-keywords-only)))
+	   (add-hook 'after-change-functions 'jit-lock-after-change))
+	 
+	 ;; Install the fontification hook.
+	 (add-hook 'fontification-functions 'jit-lock-function))
+
+	;; Turn Just-in-time Lock mode off.
+	(t
+	 ;; Cancel our idle timer.
+	 (when jit-lock-stealth-timer
+	   (cancel-timer jit-lock-stealth-timer)
+	   (setq jit-lock-stealth-timer nil))
+
+	 ;; Remove hooks.
+	 (remove-hook 'after-change-functions 'jit-lock-after-change)
+	 (remove-hook 'fontification-functions 'jit-lock-function))))
+
+
+;;;###autoload
+(defun turn-on-jit-lock ()
+  "Unconditionally turn on Just-in-time Lock mode."
+  (jit-lock-mode 1))
+
+
+
+;;; On demand fontification.
+
+(defun jit-lock-function (start)
+  "Fontify current buffer starting at position START.
+This function is added to `fontification-functions' when `jit-lock-mode'
+is active."
+  (when jit-lock-mode
+    (with-buffer-prepared-for-font-lock
+     (let ((end (min (point-max) (+ start jit-lock-chunk-size)))
+	   (parse-sexp-lookup-properties font-lock-syntactic-keywords)
+	   (old-syntax-table (syntax-table))
+	   (font-lock-beginning-of-syntax-function nil)
+	   next)
+       (when font-lock-syntax-table
+	 (set-syntax-table font-lock-syntax-table))
+       (save-excursion
+	 (save-restriction
+	   (widen)
+	   (save-match-data
+	     (condition-case error
+		 ;; Fontify chunks beginning at START.  The end of a
+		 ;; chunk is either `end', or the start of a region
+		 ;; before `end' that has already been fontified.