17359
|
1 ;;; scheme.el --- Scheme (and DSSSL) editing mode.
|
658
|
2
|
21133
|
3 ;; Copyright (C) 1986, 87, 88, 97, 1998 Free Software Foundation, Inc.
|
846
|
4
|
17976
|
5 ;; Author: Bill Rozas <jinx@martigny.ai.mit.edu>
|
20891
|
6 ;; Adapted-by: Dave Love <d.love@dl.ac.uk>
|
814
|
7 ;; Keywords: languages, lisp
|
807
|
8
|
65
|
9 ;; This file is part of GNU Emacs.
|
|
10
|
|
11 ;; GNU Emacs is free software; you can redistribute it and/or modify
|
|
12 ;; it under the terms of the GNU General Public License as published by
|
807
|
13 ;; the Free Software Foundation; either version 2, or (at your option)
|
65
|
14 ;; any later version.
|
|
15
|
|
16 ;; GNU Emacs is distributed in the hope that it will be useful,
|
|
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
19 ;; GNU General Public License for more details.
|
|
20
|
|
21 ;; You should have received a copy of the GNU General Public License
|
14169
|
22 ;; along with GNU Emacs; see the file COPYING. If not, write to the
|
|
23 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
24 ;; Boston, MA 02111-1307, USA.
|
65
|
25
|
807
|
26 ;;; Commentary:
|
65
|
27
|
17359
|
28 ;; The major mode for editing Scheme-type Lisp code, very similar to
|
|
29 ;; the Lisp mode documented in the Emacs manual. `dsssl-mode' is a
|
|
30 ;; variant of scheme-mode for editing DSSSL specifications for SGML
|
|
31 ;; documents. [As of Apr 1997, some pointers for DSSSL may be found,
|
|
32 ;; for instance, at <URL:http://www.sil.org/sgml/related.html#dsssl>.]
|
|
33 ;; All these Lisp-ish modes vary basically in details of the language
|
|
34 ;; syntax they highlight/indent/index, but dsssl-mode uses "^;;;" as
|
|
35 ;; the page-delimiter since ^L isn't normally a legal SGML character.
|
|
36 ;;
|
|
37 ;; For interacting with a Scheme interpreter See also `run-scheme' in
|
|
38 ;; the `cmuscheme' package and also the implementation-specific
|
|
39 ;; `xscheme' package.
|
65
|
40
|
20461
|
41 ;; Here's a recipe to generate a TAGS file for DSSSL, by the way:
|
|
42 ;; etags --lang=scheme --regex='/[ \t]*(\(mode\|element\)[ \t
|
|
43 ;; ]+\([^ \t(
|
|
44 ;; ]+\)/\2/' --regex='/[ \t]*(element[ \t
|
|
45 ;; ]*([^)]+[ \t
|
|
46 ;; ]+\([^)]+\)[ \t
|
|
47 ;; ]*)/\1/' --regex='/(declare[^ \t
|
|
48 ;; ]*[ \t
|
|
49 ;; ]+\([^ \t
|
|
50 ;; ]+\)/\1/' "$@"
|
|
51
|
807
|
52 ;;; Code:
|
65
|
53
|
17359
|
54 (require 'lisp-mode)
|
|
55
|
26938
|
56 (defvar scheme-mode-syntax-table nil)
|
65
|
57 (if (not scheme-mode-syntax-table)
|
|
58 (let ((i 0))
|
|
59 (setq scheme-mode-syntax-table (make-syntax-table))
|
|
60 (set-syntax-table scheme-mode-syntax-table)
|
|
61
|
|
62 ;; Default is atom-constituent.
|
|
63 (while (< i 256)
|
|
64 (modify-syntax-entry i "_ ")
|
|
65 (setq i (1+ i)))
|
|
66
|
|
67 ;; Word components.
|
|
68 (setq i ?0)
|
|
69 (while (<= i ?9)
|
|
70 (modify-syntax-entry i "w ")
|
|
71 (setq i (1+ i)))
|
|
72 (setq i ?A)
|
|
73 (while (<= i ?Z)
|
|
74 (modify-syntax-entry i "w ")
|
|
75 (setq i (1+ i)))
|
|
76 (setq i ?a)
|
|
77 (while (<= i ?z)
|
|
78 (modify-syntax-entry i "w ")
|
|
79 (setq i (1+ i)))
|
|
80
|
|
81 ;; Whitespace
|
|
82 (modify-syntax-entry ?\t " ")
|
|
83 (modify-syntax-entry ?\n "> ")
|
|
84 (modify-syntax-entry ?\f " ")
|
|
85 (modify-syntax-entry ?\r " ")
|
|
86 (modify-syntax-entry ? " ")
|
|
87
|
|
88 ;; These characters are delimiters but otherwise undefined.
|
|
89 ;; Brackets and braces balance for editing convenience.
|
17359
|
90 (modify-syntax-entry ?\[ "(] ")
|
|
91 (modify-syntax-entry ?\] ")[ ")
|
65
|
92 (modify-syntax-entry ?{ "(} ")
|
|
93 (modify-syntax-entry ?} "){ ")
|
|
94 (modify-syntax-entry ?\| " 23")
|
|
95
|
|
96 ;; Other atom delimiters
|
|
97 (modify-syntax-entry ?\( "() ")
|
|
98 (modify-syntax-entry ?\) ")( ")
|
|
99 (modify-syntax-entry ?\; "< ")
|
|
100 (modify-syntax-entry ?\" "\" ")
|
|
101 (modify-syntax-entry ?' " p")
|
|
102 (modify-syntax-entry ?` " p")
|
|
103
|
|
104 ;; Special characters
|
|
105 (modify-syntax-entry ?, "_ p")
|
|
106 (modify-syntax-entry ?@ "_ p")
|
|
107 (modify-syntax-entry ?# "_ p14")
|
|
108 (modify-syntax-entry ?\\ "\\ ")))
|
|
109
|
26938
|
110 (defvar scheme-mode-abbrev-table nil)
|
65
|
111 (define-abbrev-table 'scheme-mode-abbrev-table ())
|
|
112
|
17359
|
113 (defvar scheme-imenu-generic-expression
|
26938
|
114 '((nil
|
20891
|
115 "^(define\\(\\|-\\(generic\\(\\|-procedure\\)\\|method\\)\\)*\\s-+(?\\(\\sw+\\)" 4)
|
26938
|
116 ("Types"
|
20891
|
117 "^(define-class\\s-+(?\\(\\sw+\\)" 1)
|
21632
|
118 ("Macros"
|
20891
|
119 "^(\\(defmacro\\|define-macro\\|define-syntax\\)\\s-+(?\\(\\sw+\\)" 2))
|
17359
|
120 "Imenu generic expression for Scheme mode. See `imenu-generic-expression'.")
|
|
121
|
65
|
122 (defun scheme-mode-variables ()
|
|
123 (set-syntax-table scheme-mode-syntax-table)
|
|
124 (setq local-abbrev-table scheme-mode-abbrev-table)
|
|
125 (make-local-variable 'paragraph-start)
|
10892
0e6ae3605c92
(scheme-mode-variables): Remove ^ from paragraph-start & paragraph-separate.
Boris Goldowsky <boris@gnu.org>
diff
changeset
|
126 (setq paragraph-start (concat "$\\|" page-delimiter))
|
65
|
127 (make-local-variable 'paragraph-separate)
|
|
128 (setq paragraph-separate paragraph-start)
|
|
129 (make-local-variable 'paragraph-ignore-fill-prefix)
|
|
130 (setq paragraph-ignore-fill-prefix t)
|
17359
|
131 (make-local-variable 'fill-paragraph-function)
|
|
132 (setq fill-paragraph-function 'lisp-fill-paragraph)
|
|
133 ;; Adaptive fill mode gets in the way of auto-fill,
|
|
134 ;; and should make no difference for explicit fill
|
|
135 ;; because lisp-fill-paragraph should do the job.
|
|
136 (make-local-variable 'adaptive-fill-mode)
|
|
137 (setq adaptive-fill-mode nil)
|
20334
|
138 (make-local-variable 'normal-auto-fill-function)
|
|
139 (setq normal-auto-fill-function 'lisp-mode-auto-fill)
|
65
|
140 (make-local-variable 'indent-line-function)
|
17359
|
141 (setq indent-line-function 'lisp-indent-line)
|
9912
|
142 (make-local-variable 'parse-sexp-ignore-comments)
|
|
143 (setq parse-sexp-ignore-comments t)
|
17359
|
144 (make-local-variable 'outline-regexp)
|
|
145 (setq outline-regexp ";;; \\|(....")
|
65
|
146 (make-local-variable 'comment-start)
|
|
147 (setq comment-start ";")
|
|
148 (make-local-variable 'comment-start-skip)
|
15598
c5f04e0724ec
(scheme-mode-variables): Set comment-start-skip to ignore backslash-quoted
Miles Bader <miles@gnu.org>
diff
changeset
|
149 ;; Look within the line for a ; following an even number of backslashes
|
c5f04e0724ec
(scheme-mode-variables): Set comment-start-skip to ignore backslash-quoted
Miles Bader <miles@gnu.org>
diff
changeset
|
150 ;; after either a non-backslash or the line beginning.
|
c5f04e0724ec
(scheme-mode-variables): Set comment-start-skip to ignore backslash-quoted
Miles Bader <miles@gnu.org>
diff
changeset
|
151 (setq comment-start-skip "\\(\\(^\\|[^\\\\\n]\\)\\(\\\\\\\\\\)*\\);+[ \t]*")
|
65
|
152 (make-local-variable 'comment-column)
|
|
153 (setq comment-column 40)
|
2307
|
154 (make-local-variable 'comment-indent-function)
|
17359
|
155 (setq comment-indent-function 'lisp-comment-indent)
|
9179
|
156 (make-local-variable 'parse-sexp-ignore-comments)
|
|
157 (setq parse-sexp-ignore-comments t)
|
17359
|
158 (make-local-variable 'lisp-indent-function)
|
|
159 (set lisp-indent-function 'scheme-indent-function)
|
|
160 (setq mode-line-process '("" scheme-mode-line-process))
|
32375
|
161 (set (make-local-variable 'imenu-case-fold-search) t)
|
20459
|
162 (setq imenu-generic-expression scheme-imenu-generic-expression)
|
32375
|
163 (set (make-local-variable 'imenu-syntax-alist)
|
|
164 '(("+-*/.<>=?!$%_&~^:" . "w")))
|
26938
|
165 (make-local-variable 'font-lock-defaults)
|
21133
|
166 (setq font-lock-defaults
|
|
167 '((scheme-font-lock-keywords
|
|
168 scheme-font-lock-keywords-1 scheme-font-lock-keywords-2)
|
|
169 nil t (("+-*/.<>=!?$%_&~^:" . "w")) beginning-of-defun
|
|
170 (font-lock-mark-block-function . mark-defun))))
|
65
|
171
|
|
172 (defvar scheme-mode-line-process "")
|
|
173
|
33483
|
174 (defvar scheme-mode-map nil
|
|
175 "Keymap for Scheme mode.
|
|
176 All commands in `lisp-mode-shared-map' are inherited by this map.")
|
|
177
|
|
178 (unless scheme-mode-map
|
17359
|
179 (let ((map (make-sparse-keymap "Scheme")))
|
33483
|
180 (setq scheme-mode-map (make-sparse-keymap))
|
|
181 (set-keymap-parent scheme-mode-map lisp-mode-shared-map)
|
|
182 (define-key scheme-mode-map [menu-bar] (make-sparse-keymap))
|
|
183 (define-key scheme-mode-map [menu-bar scheme]
|
|
184 (cons "Scheme" map))
|
|
185 (define-key map [run-scheme] '("Run Inferior Scheme" . run-scheme))
|
|
186 (define-key map [uncomment-region]
|
|
187 '("Uncomment Out Region" . (lambda (beg end)
|
|
188 (interactive "r")
|
|
189 (comment-region beg end '(4)))))
|
|
190 (define-key map [comment-region] '("Comment Out Region" . comment-region))
|
|
191 (define-key map [indent-region] '("Indent Region" . indent-region))
|
|
192 (define-key map [indent-line] '("Indent Line" . lisp-indent-line))
|
|
193 (put 'comment-region 'menu-enable 'mark-active)
|
|
194 (put 'uncomment-region 'menu-enable 'mark-active)
|
|
195 (put 'indent-region 'menu-enable 'mark-active)))
|
17359
|
196
|
|
197 ;; Used by cmuscheme
|
65
|
198 (defun scheme-mode-commands (map)
|
18285
|
199 ;;(define-key map "\t" 'indent-for-tab-command) ; default
|
65
|
200 (define-key map "\177" 'backward-delete-char-untabify)
|
18285
|
201 (define-key map "\e\C-q" 'indent-sexp))
|
65
|
202
|
266
|
203 ;;;###autoload
|
65
|
204 (defun scheme-mode ()
|
|
205 "Major mode for editing Scheme code.
|
26938
|
206 Editing commands are similar to those of `lisp-mode'.
|
65
|
207
|
|
208 In addition, if an inferior Scheme process is running, some additional
|
|
209 commands will be defined, for evaluating expressions and controlling
|
|
210 the interpreter, and the state of the process will be displayed in the
|
|
211 modeline of all Scheme buffers. The names of commands that interact
|
32375
|
212 with the Scheme process start with \"xscheme-\" if you use the MIT
|
|
213 Scheme-specific `xscheme' package; for more information see the
|
|
214 documentation for `xscheme-interaction-mode'. Use \\[run-scheme] to
|
|
215 start an inferior Scheme using the more general `cmuscheme' package.
|
65
|
216
|
|
217 Commands:
|
|
218 Delete converts tabs to spaces as it moves back.
|
|
219 Blank lines separate paragraphs. Semicolons start comments.
|
|
220 \\{scheme-mode-map}
|
26938
|
221 Entry to this mode calls the value of `scheme-mode-hook'
|
65
|
222 if that value is non-nil."
|
|
223 (interactive)
|
|
224 (kill-all-local-variables)
|
|
225 (scheme-mode-initialize)
|
|
226 (scheme-mode-variables)
|
|
227 (run-hooks 'scheme-mode-hook))
|
|
228
|
|
229 (defun scheme-mode-initialize ()
|
|
230 (use-local-map scheme-mode-map)
|
|
231 (setq major-mode 'scheme-mode)
|
|
232 (setq mode-name "Scheme"))
|
|
233
|
18285
|
234 (defgroup scheme nil
|
|
235 "Editing Scheme code"
|
|
236 :group 'lisp)
|
|
237
|
|
238 (defcustom scheme-mit-dialect t
|
65
|
239 "If non-nil, scheme mode is specialized for MIT Scheme.
|
18285
|
240 Set this to nil if you normally use another dialect."
|
|
241 :type 'boolean
|
|
242 :group 'scheme)
|
17359
|
243
|
18285
|
244 (defcustom dsssl-sgml-declaration
|
17359
|
245 "<!DOCTYPE style-sheet PUBLIC \"-//James Clark//DTD DSSSL Style Sheet//EN\">
|
|
246 "
|
18285
|
247 "*An SGML declaration for the DSSSL file.
|
20461
|
248 If it is defined as a string this will be inserted into an empty buffer
|
26938
|
249 which is in `dsssl-mode'. It is typically James Clark's style-sheet
|
18285
|
250 doctype, as required for Jade."
|
26938
|
251 :type '(choice (string :tag "Specified string")
|
20461
|
252 (const :tag "None" :value nil))
|
|
253 :group 'scheme)
|
|
254
|
|
255 (defcustom scheme-mode-hook nil
|
26938
|
256 "Normal hook run when entering `scheme-mode'.
|
20461
|
257 See `run-hooks'."
|
|
258 :type 'hook
|
|
259 :group 'scheme)
|
|
260
|
|
261 (defcustom dsssl-mode-hook nil
|
26938
|
262 "Normal hook run when entering `dsssl-mode'.
|
20461
|
263 See `run-hooks'."
|
|
264 :type 'hook
|
18285
|
265 :group 'scheme)
|
65
|
266
|
33487
|
267 ;; This is shared by cmuscheme and xscheme.
|
|
268 (defcustom scheme-program-name "scheme"
|
|
269 "*Program invoked by the `run-scheme' command."
|
|
270 :type 'string
|
|
271 :group 'scheme)
|
|
272
|
17359
|
273 (defvar dsssl-imenu-generic-expression
|
|
274 ;; Perhaps this should also look for the style-sheet DTD tags. I'm
|
|
275 ;; not sure it's the best way to organize it; perhaps one type
|
|
276 ;; should be at the first level, though you don't see this anyhow if
|
|
277 ;; it gets split up.
|
26938
|
278 '(("Defines"
|
20891
|
279 "^(define\\s-+(?\\(\\sw+\\)" 1)
|
21632
|
280 ("Modes"
|
20891
|
281 "^\\s-*(mode\\s-+\\(\\(\\sw\\|\\s-\\)+\\)" 1)
|
21632
|
282 ("Elements"
|
17359
|
283 ;; (element foo ...) or (element (foo bar ...) ...)
|
17578
|
284 ;; Fixme: Perhaps it should do `root'.
|
20891
|
285 "^\\s-*(element\\s-+(?\\(\\(\\sw\\|\\s-\\)+\\))?" 1)
|
26938
|
286 ("Declarations"
|
20891
|
287 "^(declare\\(-\\sw+\\)+\\>\\s-+\\(\\sw+\\)" 2))
|
17359
|
288 "Imenu generic expression for DSSSL mode. See `imenu-generic-expression'.")
|
|
289
|
21133
|
290 (defconst scheme-font-lock-keywords-1
|
|
291 (eval-when-compile
|
|
292 (list
|
|
293 ;;
|
|
294 ;; Declarations. Hannes Haug <hannes.haug@student.uni-tuebingen.de> says
|
|
295 ;; this works for SOS, STklos, SCOOPS, Meroon and Tiny CLOS.
|
22709
|
296 (list (concat "(\\(define\\*?\\("
|
21133
|
297 ;; Function names.
|
22709
|
298 "\\(\\|-public\\|-method\\|-generic\\(-procedure\\)?\\)\\|"
|
21133
|
299 ;; Macro names, as variable names. A bit dubious, this.
|
32375
|
300 "\\(-syntax\\|-macro\\)\\|"
|
21133
|
301 ;; Class names.
|
|
302 "-class"
|
22709
|
303 ;; Guile modules.
|
|
304 "\\|-module"
|
21133
|
305 "\\)\\)\\>"
|
|
306 ;; Any whitespace and declared object.
|
|
307 "[ \t]*(?"
|
|
308 "\\(\\sw+\\)?")
|
|
309 '(1 font-lock-keyword-face)
|
|
310 '(6 (cond ((match-beginning 3) font-lock-function-name-face)
|
|
311 ((match-beginning 5) font-lock-variable-name-face)
|
|
312 (t font-lock-type-face))
|
|
313 nil t))
|
|
314 ))
|
|
315 "Subdued expressions to highlight in Scheme modes.")
|
|
316
|
|
317 (defconst scheme-font-lock-keywords-2
|
|
318 (append scheme-font-lock-keywords-1
|
|
319 (eval-when-compile
|
|
320 (list
|
|
321 ;;
|
|
322 ;; Control structures.
|
|
323 (cons
|
|
324 (concat
|
|
325 "(" (regexp-opt
|
|
326 '("begin" "call-with-current-continuation" "call/cc"
|
|
327 "call-with-input-file" "call-with-output-file" "case" "cond"
|
|
328 "do" "else" "for-each" "if" "lambda"
|
|
329 "let" "let*" "let-syntax" "letrec" "letrec-syntax"
|
|
330 ;; Hannes Haug <hannes.haug@student.uni-tuebingen.de> wants:
|
|
331 "and" "or" "delay"
|
|
332 ;; Stefan Monnier <stefan.monnier@epfl.ch> says don't bother:
|
|
333 ;;"quasiquote" "quote" "unquote" "unquote-splicing"
|
|
334 "map" "syntax" "syntax-rules") t)
|
|
335 "\\>") 1)
|
|
336 ;;
|
|
337 ;; David Fox <fox@graphics.cs.nyu.edu> for SOS/STklos class specifiers.
|
|
338 '("\\<<\\sw+>\\>" . font-lock-type-face)
|
|
339 ;;
|
|
340 ;; Scheme `:' keywords as builtins.
|
|
341 '("\\<:\\sw+\\>" . font-lock-builtin-face)
|
|
342 )))
|
|
343 "Gaudy expressions to highlight in Scheme modes.")
|
|
344
|
|
345 (defvar scheme-font-lock-keywords scheme-font-lock-keywords-1
|
|
346 "Default expressions to highlight in Scheme modes.")
|
|
347
|
17359
|
348 ;;;###autoload
|
|
349 (defun dsssl-mode ()
|
|
350 "Major mode for editing DSSSL code.
|
26938
|
351 Editing commands are similar to those of `lisp-mode'.
|
65
|
352
|
17359
|
353 Commands:
|
|
354 Delete converts tabs to spaces as it moves back.
|
|
355 Blank lines separate paragraphs. Semicolons start comments.
|
|
356 \\{scheme-mode-map}
|
21133
|
357 Entering this mode runs the hooks `scheme-mode-hook' and then
|
|
358 `dsssl-mode-hook' and inserts the value of `dsssl-sgml-declaration' if
|
|
359 that variable's value is a string."
|
17359
|
360 (interactive)
|
|
361 (kill-all-local-variables)
|
|
362 (use-local-map scheme-mode-map)
|
|
363 (scheme-mode-initialize)
|
|
364 (make-local-variable 'page-delimiter)
|
|
365 (setq page-delimiter "^;;;" ; ^L not valid SGML char
|
|
366 major-mode 'dsssl-mode
|
|
367 mode-name "DSSSL")
|
|
368 ;; Insert a suitable SGML declaration into an empty buffer.
|
|
369 (and (zerop (buffer-size))
|
17578
|
370 (stringp dsssl-sgml-declaration)
|
17359
|
371 (not buffer-read-only)
|
|
372 (insert dsssl-sgml-declaration))
|
|
373 (scheme-mode-variables)
|
21133
|
374 (setq font-lock-defaults '(dsssl-font-lock-keywords
|
|
375 nil t (("+-*/.<>=?$%_&~^:" . "w"))
|
|
376 beginning-of-defun
|
|
377 (font-lock-mark-block-function . mark-defun)))
|
32375
|
378 (set (make-local-variable 'imenu-case-fold-search) nil)
|
20459
|
379 (setq imenu-generic-expression dsssl-imenu-generic-expression)
|
32375
|
380 (set (make-local-variable 'imenu-syntax-alist)
|
|
381 '(("+-*/.<>=?$%_&~^:" . "w")))
|
21133
|
382 (run-hooks 'scheme-mode-hook)
|
|
383 (run-hooks 'dsssl-mode-hook))
|
17359
|
384
|
|
385 ;; Extra syntax for DSSSL. This isn't separated from Scheme, but
|
|
386 ;; shouldn't cause much trouble in scheme-mode.
|
|
387 (put 'element 'scheme-indent-function 1)
|
|
388 (put 'mode 'scheme-indent-function 1)
|
|
389 (put 'with-mode 'scheme-indent-function 1)
|
17402
|
390 (put 'make 'scheme-indent-function 1)
|
17578
|
391 (put 'style 'scheme-indent-function 1)
|
|
392 (put 'root 'scheme-indent-function 1)
|
17359
|
393
|
|
394 (defvar dsssl-font-lock-keywords
|
17578
|
395 (eval-when-compile
|
|
396 (list
|
|
397 ;; Similar to Scheme
|
|
398 (list "(\\(define\\(-\\w+\\)?\\)\\>[ ]*\\\((?\\)\\(\\sw+\\)\\>"
|
|
399 '(1 font-lock-keyword-face)
|
|
400 '(4 font-lock-function-name-face))
|
|
401 (cons
|
|
402 (concat "(\\("
|
|
403 ;; (make-regexp '("case" "cond" "else" "if" "lambda"
|
|
404 ;; "let" "let*" "letrec" "and" "or" "map" "with-mode"))
|
|
405 "and\\|c\\(ase\\|ond\\)\\|else\\|if\\|"
|
|
406 "l\\(ambda\\|et\\(\\|*\\|rec\\)\\)\\|map\\|or\\|with-mode"
|
|
407 "\\)\\>")
|
|
408 1)
|
|
409 ;; DSSSL syntax
|
|
410 '("(\\(element\\|mode\\|declare-\\w+\\)\\>[ ]*\\(\\sw+\\)"
|
|
411 (1 font-lock-keyword-face)
|
|
412 (2 font-lock-type-face))
|
|
413 '("(\\(element\\)\\>[ ]*(\\(\\S)+\\))"
|
|
414 (1 font-lock-keyword-face)
|
|
415 (2 font-lock-type-face))
|
20953
|
416 '("\\<\\sw+:\\>" . font-lock-constant-face) ; trailing `:' c.f. scheme
|
17578
|
417 ;; SGML markup (from sgml-mode) :
|
|
418 '("<\\([!?][-a-z0-9]+\\)" 1 font-lock-keyword-face)
|
|
419 '("<\\(/?[-a-z0-9]+\\)" 1 font-lock-function-name-face)))
|
17359
|
420 "Default expressions to highlight in DSSSL mode.")
|
|
421
|
65
|
422
|
17359
|
423 (defvar calculate-lisp-indent-last-sexp)
|
|
424
|
|
425 ;; Copied from lisp-indent-function, but with gets of
|
|
426 ;; scheme-indent-{function,hook}.
|
65
|
427 (defun scheme-indent-function (indent-point state)
|
|
428 (let ((normal-indent (current-column)))
|
17359
|
429 (goto-char (1+ (elt state 1)))
|
|
430 (parse-partial-sexp (point) calculate-lisp-indent-last-sexp 0 t)
|
|
431 (if (and (elt state 2)
|
|
432 (not (looking-at "\\sw\\|\\s_")))
|
|
433 ;; car of form doesn't seem to be a a symbol
|
|
434 (progn
|
|
435 (if (not (> (save-excursion (forward-line 1) (point))
|
|
436 calculate-lisp-indent-last-sexp))
|
|
437 (progn (goto-char calculate-lisp-indent-last-sexp)
|
|
438 (beginning-of-line)
|
|
439 (parse-partial-sexp (point)
|
|
440 calculate-lisp-indent-last-sexp 0 t)))
|
|
441 ;; Indent under the list or under the first sexp on the same
|
|
442 ;; line as calculate-lisp-indent-last-sexp. Note that first
|
|
443 ;; thing on that line has to be complete sexp since we are
|
|
444 ;; inside the innermost containing sexp.
|
|
445 (backward-prefix-chars)
|
|
446 (current-column))
|
|
447 (let ((function (buffer-substring (point)
|
|
448 (progn (forward-sexp 1) (point))))
|
|
449 method)
|
|
450 (setq method (or (get (intern-soft function) 'scheme-indent-function)
|
|
451 (get (intern-soft function) 'scheme-indent-hook)))
|
|
452 (cond ((or (eq method 'defun)
|
|
453 (and (null method)
|
|
454 (> (length function) 3)
|
|
455 (string-match "\\`def" function)))
|
|
456 (lisp-indent-defform state indent-point))
|
|
457 ((integerp method)
|
|
458 (lisp-indent-specform method state
|
|
459 indent-point normal-indent))
|
|
460 (method
|
20067
|
461 (funcall method state indent-point normal-indent)))))))
|
65
|
462
|
|
463
|
|
464 ;;; Let is different in Scheme
|
|
465
|
|
466 (defun would-be-symbol (string)
|
|
467 (not (string-equal (substring string 0 1) "(")))
|
|
468
|
|
469 (defun next-sexp-as-string ()
|
26938
|
470 ;; Assumes that it is protected by a save-excursion
|
65
|
471 (forward-sexp 1)
|
|
472 (let ((the-end (point)))
|
|
473 (backward-sexp 1)
|
|
474 (buffer-substring (point) the-end)))
|
|
475
|
|
476 ;; This is correct but too slow.
|
|
477 ;; The one below works almost always.
|
|
478 ;;(defun scheme-let-indent (state indent-point)
|
|
479 ;; (if (would-be-symbol (next-sexp-as-string))
|
|
480 ;; (scheme-indent-specform 2 state indent-point)
|
|
481 ;; (scheme-indent-specform 1 state indent-point)))
|
|
482
|
20067
|
483 (defun scheme-let-indent (state indent-point normal-indent)
|
65
|
484 (skip-chars-forward " \t")
|
6310
|
485 (if (looking-at "[-a-zA-Z0-9+*/?!@$%^&_:~]")
|
20067
|
486 (lisp-indent-specform 2 state indent-point normal-indent)
|
|
487 (lisp-indent-specform 1 state indent-point normal-indent)))
|
65
|
488
|
|
489 ;; (put 'begin 'scheme-indent-function 0), say, causes begin to be indented
|
|
490 ;; like defun if the first form is placed on the next line, otherwise
|
|
491 ;; it is indented like any other form (i.e. forms line up under first).
|
|
492
|
|
493 (put 'begin 'scheme-indent-function 0)
|
|
494 (put 'case 'scheme-indent-function 1)
|
|
495 (put 'delay 'scheme-indent-function 0)
|
|
496 (put 'do 'scheme-indent-function 2)
|
|
497 (put 'lambda 'scheme-indent-function 1)
|
|
498 (put 'let 'scheme-indent-function 'scheme-let-indent)
|
|
499 (put 'let* 'scheme-indent-function 1)
|
|
500 (put 'letrec 'scheme-indent-function 1)
|
20461
|
501 (put 'sequence 'scheme-indent-function 0) ; SICP, not r4rs
|
|
502 (put 'let-syntax 'scheme-indent-function 1)
|
|
503 (put 'letrec-syntax 'scheme-indent-function 1)
|
|
504 (put 'syntax-rules 'scheme-indent-function 1)
|
|
505
|
65
|
506
|
|
507 (put 'call-with-input-file 'scheme-indent-function 1)
|
|
508 (put 'with-input-from-file 'scheme-indent-function 1)
|
|
509 (put 'with-input-from-port 'scheme-indent-function 1)
|
|
510 (put 'call-with-output-file 'scheme-indent-function 1)
|
|
511 (put 'with-output-to-file 'scheme-indent-function 1)
|
|
512 (put 'with-output-to-port 'scheme-indent-function 1)
|
20461
|
513 (put 'call-with-values 'scheme-indent-function 1) ; r5rs?
|
|
514 (put 'dynamic-wind 'scheme-indent-function 3) ; r5rs?
|
65
|
515
|
|
516 ;;;; MIT Scheme specific indentation.
|
|
517
|
|
518 (if scheme-mit-dialect
|
|
519 (progn
|
|
520 (put 'fluid-let 'scheme-indent-function 1)
|
|
521 (put 'in-package 'scheme-indent-function 1)
|
|
522 (put 'local-declare 'scheme-indent-function 1)
|
|
523 (put 'macro 'scheme-indent-function 1)
|
|
524 (put 'make-environment 'scheme-indent-function 0)
|
|
525 (put 'named-lambda 'scheme-indent-function 1)
|
|
526 (put 'using-syntax 'scheme-indent-function 1)
|
|
527
|
|
528 (put 'with-input-from-string 'scheme-indent-function 1)
|
|
529 (put 'with-output-to-string 'scheme-indent-function 0)
|
|
530 (put 'with-values 'scheme-indent-function 1)
|
|
531
|
|
532 (put 'syntax-table-define 'scheme-indent-function 2)
|
|
533 (put 'list-transform-positive 'scheme-indent-function 1)
|
|
534 (put 'list-transform-negative 'scheme-indent-function 1)
|
|
535 (put 'list-search-positive 'scheme-indent-function 1)
|
|
536 (put 'list-search-negative 'scheme-indent-function 1)
|
|
537
|
|
538 (put 'access-components 'scheme-indent-function 1)
|
|
539 (put 'assignment-components 'scheme-indent-function 1)
|
|
540 (put 'combination-components 'scheme-indent-function 1)
|
|
541 (put 'comment-components 'scheme-indent-function 1)
|
|
542 (put 'conditional-components 'scheme-indent-function 1)
|
|
543 (put 'disjunction-components 'scheme-indent-function 1)
|
|
544 (put 'declaration-components 'scheme-indent-function 1)
|
|
545 (put 'definition-components 'scheme-indent-function 1)
|
|
546 (put 'delay-components 'scheme-indent-function 1)
|
|
547 (put 'in-package-components 'scheme-indent-function 1)
|
|
548 (put 'lambda-components 'scheme-indent-function 1)
|
|
549 (put 'lambda-components* 'scheme-indent-function 1)
|
|
550 (put 'lambda-components** 'scheme-indent-function 1)
|
|
551 (put 'open-block-components 'scheme-indent-function 1)
|
|
552 (put 'pathname-components 'scheme-indent-function 1)
|
|
553 (put 'procedure-components 'scheme-indent-function 1)
|
|
554 (put 'sequence-components 'scheme-indent-function 1)
|
|
555 (put 'unassigned\?-components 'scheme-indent-function 1)
|
|
556 (put 'unbound\?-components 'scheme-indent-function 1)
|
|
557 (put 'variable-components 'scheme-indent-function 1)))
|
584
|
558
|
|
559 (provide 'scheme)
|
658
|
560
|
|
561 ;;; scheme.el ends here
|