Skip to content
GitLab
Projects
Groups
Snippets
Help
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
Open sidebar
emacs
emacs
Commits
7840ced1
Commit
7840ced1
authored
Jul 21, 1999
by
Gerd Moellmann
Browse files
New file.
parent
a168702a
Changes
5
Expand all
Hide whitespace changes
Inline
Side-by-side
Showing
5 changed files
with
2110 additions
and
0 deletions
+2110
-0
lisp/gs.el
lisp/gs.el
+185
-0
lisp/image.el
lisp/image.el
+192
-0
lisp/jit-lock.el
lisp/jit-lock.el
+433
-0
lisp/tooltip.el
lisp/tooltip.el
+476
-0
src/sound.c
src/sound.c
+824
-0
No files found.
lisp/gs.el
0 → 100644
View file @
7840ced1
;;; 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
0 → 100644
View file @
7840ced1
;;; 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
0 → 100644
View file @
7840ced1
;;; 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.