1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
|
;;; mode-local.el --- Support for mode local facilities
;;
;; Copyright (C) 2004-2005, 2007-2015 Free Software Foundation, Inc.
;;
;; Author: David Ponce <david@dponce.com>
;; Maintainer: David Ponce <david@dponce.com>
;; Created: 27 Apr 2004
;; Keywords: syntax
;; 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 3 of the License, 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. If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;;
;; Each major mode will want to support a specific set of behaviors.
;; Usually generic behaviors that need just a little bit of local
;; specifics.
;;
;; This library permits the setting of override functions for tasks of
;; that nature, and also provides reasonable defaults.
;;
;; There are buffer local variables, and frame local variables.
;; This library gives the illusion of mode specific variables.
;;
;; You should use a mode-local variable or override to allow extension
;; only if you expect a mode author to provide that extension. If a
;; user might wish to customize a given variable or function then
;; the existing customization mechanism should be used.
;; To Do:
;; Allow customization of a variable for a specific mode?
;;
;; Add macro for defining the '-default' functionality.
;;; Code:
(eval-when-compile (require 'cl))
;;; Misc utilities
;;
(defun mode-local-map-file-buffers (function &optional predicate buffers)
"Run FUNCTION on every file buffer found.
FUNCTION does not have arguments; when it is entered `current-buffer'
is the currently selected file buffer.
If optional argument PREDICATE is non nil, only select file buffers
for which the function PREDICATE returns non-nil.
If optional argument BUFFERS is non-nil, it is a list of buffers to
walk through. It defaults to `buffer-list'."
(dolist (b (or buffers (buffer-list)))
(and (buffer-live-p b) (buffer-file-name b)
(with-current-buffer b
(when (or (not predicate) (funcall predicate))
(funcall function))))))
(defsubst get-mode-local-parent (mode)
"Return the mode parent of the major mode MODE.
Return nil if MODE has no parent."
(or (get mode 'mode-local-parent)
(get mode 'derived-mode-parent)))
;; FIXME doc (and function name) seems wrong.
;; Return a list of MODE and all its parent modes, if any.
;; Lists parent modes first.
(defun mode-local-equivalent-mode-p (mode)
"Is the major-mode in the current buffer equivalent to a mode in MODES."
(let ((modes nil))
(while mode
(setq modes (cons mode modes)
mode (get-mode-local-parent mode)))
modes))
(defun mode-local-map-mode-buffers (function modes)
"Run FUNCTION on every file buffer with major mode in MODES.
MODES can be a symbol or a list of symbols.
FUNCTION does not have arguments."
(or (listp modes) (setq modes (list modes)))
(mode-local-map-file-buffers
function #'(lambda ()
(let ((mm (mode-local-equivalent-mode-p major-mode))
(ans nil))
(while (and (not ans) mm)
(setq ans (memq (car mm) modes)
mm (cdr mm)) )
ans))))
;;; Hook machinery
;;
(defvar mode-local-init-hook nil
"Hook run after a new file buffer is created.
The current buffer is the newly created file buffer.")
(defvar mode-local-changed-mode-buffers nil
"List of buffers whose `major-mode' has changed recently.")
(defvar mode-local--init-mode nil)
(defsubst mode-local-initialized-p ()
"Return non-nil if mode local is initialized in current buffer.
That is, if the current `major-mode' is equal to the major mode for
which mode local bindings have been activated."
(eq mode-local--init-mode major-mode))
(defun mode-local-post-major-mode-change ()
"Initialize mode-local facilities.
This is run from `find-file-hook', and from `post-command-hook'
after changing the major mode."
(remove-hook 'post-command-hook 'mode-local-post-major-mode-change nil)
(let ((buffers mode-local-changed-mode-buffers))
(setq mode-local-changed-mode-buffers nil)
(mode-local-map-file-buffers
(lambda ()
;; Make sure variables are set up for this mode.
(activate-mode-local-bindings)
(run-hooks 'mode-local-init-hook))
(lambda ()
(not (mode-local-initialized-p)))
buffers)))
(defun mode-local-on-major-mode-change ()
"Function called in `change-major-mode-hook'."
(add-to-list 'mode-local-changed-mode-buffers (current-buffer))
(add-hook 'post-command-hook 'mode-local-post-major-mode-change t nil))
;;; Mode lineage
;;
(defsubst set-mode-local-parent (mode parent)
"Set parent of major mode MODE to PARENT mode.
To work properly, this function should be called after PARENT mode
local variables have been defined."
(put mode 'mode-local-parent parent)
;; Refresh mode bindings to get mode local variables inherited from
;; PARENT. To work properly, the following should be called after
;; PARENT mode local variables have been defined.
(mode-local-map-mode-buffers #'activate-mode-local-bindings mode))
(defmacro define-child-mode (mode parent &optional docstring)
"Make major mode MODE inherit behavior from PARENT mode.
DOCSTRING is optional and not used.
To work properly, this should be put after PARENT mode local variables
definition."
`(set-mode-local-parent ',mode ',parent))
(defun mode-local-use-bindings-p (this-mode desired-mode)
"Return non-nil if THIS-MODE can use bindings of DESIRED-MODE."
(let ((ans nil))
(while (and (not ans) this-mode)
(setq ans (eq this-mode desired-mode))
(setq this-mode (get-mode-local-parent this-mode)))
ans))
;;; Core bindings API
;;
(defvar mode-local-symbol-table nil
"Buffer local mode bindings.
These symbols provide a hook for a `major-mode' to specify specific
behaviors. Use the function `mode-local-bind' to define new bindings.")
(make-variable-buffer-local 'mode-local-symbol-table)
(defvar mode-local-active-mode nil
"Major mode in which bindings are active.")
(defsubst new-mode-local-bindings ()
"Return a new empty mode bindings symbol table."
(make-vector 13 0))
(defun mode-local-bind (bindings &optional plist mode)
"Define BINDINGS in the specified environment.
BINDINGS is a list of (VARIABLE . VALUE).
Optional argument PLIST is a property list each VARIABLE symbol will
be set to. The following properties have special meaning:
- `constant-flag' if non-nil, prevent to rebind variables.
- `mode-variable-flag' if non-nil, define mode variables.
- `override-flag' if non-nil, define override functions.
The `override-flag' and `mode-variable-flag' properties are mutually
exclusive.
If optional argument MODE is non-nil, it must be a major mode symbol.
BINDINGS will be defined globally for this major mode. If MODE is
nil, BINDINGS will be defined locally in the current buffer, in
variable `mode-local-symbol-table'. The later should be done in MODE
hook."
;; Check plist consistency
(and (plist-get plist 'mode-variable-flag)
(plist-get plist 'override-flag)
(error "Bindings can't be both overrides and mode variables"))
(let (table variable varname value binding)
(if mode
(progn
;; Install in given MODE symbol table. Create a new one if
;; needed.
(setq table (or (get mode 'mode-local-symbol-table)
(new-mode-local-bindings)))
(put mode 'mode-local-symbol-table table))
;; Fail if trying to bind mode variables in local context!
(if (plist-get plist 'mode-variable-flag)
(error "Mode required to bind mode variables"))
;; Install in buffer local symbol table. Create a new one if
;; needed.
(setq table (or mode-local-symbol-table
(setq mode-local-symbol-table
(new-mode-local-bindings)))))
(while bindings
(setq binding (car bindings)
bindings (cdr bindings)
varname (symbol-name (car binding))
value (cdr binding))
(if (setq variable (intern-soft varname table))
;; Binding already exists
;; Check rebind consistency
(cond
((equal (symbol-value variable) value)
;; Just ignore rebind with the same value.
)
((get variable 'constant-flag)
(error "Can't change the value of constant `%s'"
variable))
((and (get variable 'mode-variable-flag)
(plist-get plist 'override-flag))
(error "Can't rebind override `%s' as a mode variable"
variable))
((and (get variable 'override-flag)
(plist-get plist 'mode-variable-flag))
(error "Can't rebind mode variable `%s' as an override"
variable))
(t
;; Merge plist and assign new value
(setplist variable (append plist (symbol-plist variable)))
(set variable value)))
;; New binding
(setq variable (intern varname table))
;; Set new plist and assign initial value
(setplist variable plist)
(set variable value)))
;; Return the symbol table used
table))
(defsubst mode-local-symbol (symbol &optional mode)
"Return the mode local symbol bound with SYMBOL's name.
Return nil if the mode local symbol doesn't exist.
If optional argument MODE is nil, lookup first into locally bound
symbols, then in those bound in current `major-mode' and its parents.
If MODE is non-nil, lookup into symbols bound in that major mode and
its parents."
(let ((name (symbol-name symbol)) bind)
(or mode
(setq mode mode-local-active-mode)
(setq mode major-mode
bind (and mode-local-symbol-table
(intern-soft name mode-local-symbol-table))))
(while (and mode (not bind))
(or (and (get mode 'mode-local-symbol-table)
(setq bind (intern-soft
name (get mode 'mode-local-symbol-table))))
(setq mode (get-mode-local-parent mode))))
bind))
(defsubst mode-local-symbol-value (symbol &optional mode property)
"Return the value of the mode local symbol bound with SYMBOL's name.
If optional argument MODE is non-nil, restrict lookup to that mode and
its parents (see the function `mode-local-symbol' for more details).
If optional argument PROPERTY is non-nil the mode local symbol must
have that property set. Return nil if the symbol doesn't exist, or
doesn't have PROPERTY set."
(and (setq symbol (mode-local-symbol symbol mode))
(or (not property) (get symbol property))
(symbol-value symbol)))
;;; Mode local variables
;;
(defun activate-mode-local-bindings (&optional mode)
"Activate variables defined locally in MODE and its parents.
That is, copy mode local bindings into corresponding buffer local
variables.
If MODE is not specified it defaults to current `major-mode'.
Return the alist of buffer-local variables that have been changed.
Elements are (SYMBOL . PREVIOUS-VALUE), describing one variable."
;; Hack -
;; do not do this if we are inside set-auto-mode as we may be in
;; an initialization race condition.
(if (or (and (featurep 'emacs) (boundp 'keep-mode-if-same))
(and (featurep 'xemacs) (boundp 'just-from-file-name)))
;; We are inside set-auto-mode, as this is an argument that is
;; vaguely unique.
;; This will make sure that when everything is over, this will get
;; called and we won't be under set-auto-mode anymore.
(mode-local-on-major-mode-change)
;; Do the normal thing.
(let (modes table old-locals)
(unless mode
(set (make-local-variable 'mode-local--init-mode) major-mode)
(setq mode major-mode))
;; Get MODE's parents & MODE in the right order.
(while mode
(setq modes (cons mode modes)
mode (get-mode-local-parent mode)))
;; Activate mode bindings following parent modes order.
(dolist (mode modes)
(when (setq table (get mode 'mode-local-symbol-table))
(mapatoms
#'(lambda (var)
(when (get var 'mode-variable-flag)
(let ((v (intern (symbol-name var))))
;; Save the current buffer-local value of the
;; mode-local variable.
(and (local-variable-p v (current-buffer))
(push (cons v (symbol-value v)) old-locals))
(set (make-local-variable v) (symbol-value var)))))
table)))
old-locals)))
(defun deactivate-mode-local-bindings (&optional mode)
"Deactivate variables defined locally in MODE and its parents.
That is, kill buffer local variables set from the corresponding mode
local bindings.
If MODE is not specified it defaults to current `major-mode'."
(unless mode
(kill-local-variable 'mode-local--init-mode)
(setq mode major-mode))
(let (table)
(while mode
(when (setq table (get mode 'mode-local-symbol-table))
(mapatoms
#'(lambda (var)
(when (get var 'mode-variable-flag)
(kill-local-variable (intern (symbol-name var)))))
table))
(setq mode (get-mode-local-parent mode)))))
(defmacro with-mode-local-symbol (mode &rest body)
"With the local bindings of MODE symbol, evaluate BODY.
The current mode bindings are saved, BODY is evaluated, and the saved
bindings are restored, even in case of an abnormal exit.
Value is what BODY returns.
This is like `with-mode-local', except that MODE's value is used.
To use the symbol MODE (quoted), use `with-mode-local'."
(let ((old-mode (make-symbol "mode"))
(old-locals (make-symbol "old-locals"))
(new-mode (make-symbol "new-mode"))
(local (make-symbol "local")))
`(let ((,old-mode mode-local-active-mode)
(,old-locals nil)
(,new-mode ,mode)
)
(unwind-protect
(progn
(deactivate-mode-local-bindings ,old-mode)
(setq mode-local-active-mode ,new-mode)
;; Save the previous value of buffer-local variables
;; changed by `activate-mode-local-bindings'.
(setq ,old-locals (activate-mode-local-bindings ,new-mode))
,@body)
(deactivate-mode-local-bindings ,new-mode)
;; Restore the previous value of buffer-local variables.
(dolist (,local ,old-locals)
(set (car ,local) (cdr ,local)))
;; Restore the mode local variables.
(setq mode-local-active-mode ,old-mode)
(activate-mode-local-bindings ,old-mode)))))
(put 'with-mode-local-symbol 'lisp-indent-function 1)
(defmacro with-mode-local (mode &rest body)
"With the local bindings of MODE, evaluate BODY.
The current mode bindings are saved, BODY is evaluated, and the saved
bindings are restored, even in case of an abnormal exit.
Value is what BODY returns.
This is like `with-mode-local-symbol', except that MODE is quoted
and is not evaluated."
`(with-mode-local-symbol ',mode ,@body))
(put 'with-mode-local 'lisp-indent-function 1)
(defsubst mode-local-value (mode sym)
"Return the value of the MODE local variable SYM."
(or mode (error "Missing major mode symbol"))
(mode-local-symbol-value sym mode 'mode-variable-flag))
(defmacro setq-mode-local (mode &rest args)
"Assign new values to variables local in MODE.
MODE must be a major mode symbol.
ARGS is a list (SYM VAL SYM VAL ...).
The symbols SYM are variables; they are literal (not evaluated).
The values VAL are expressions; they are evaluated.
Set each SYM to the value of its VAL, locally in buffers already in
MODE, or in buffers switched to that mode.
Return the value of the last VAL."
(when args
(let (i ll bl sl tmp sym val)
(setq i 0)
(while args
(setq tmp (make-symbol (format "tmp%d" i))
i (1+ i)
sym (car args)
val (cadr args)
ll (cons (list tmp val) ll)
bl (cons `(cons ',sym ,tmp) bl)
sl (cons `(set (make-local-variable ',sym) ,tmp) sl)
args (cddr args)))
`(let* ,(nreverse ll)
;; Save mode bindings
(mode-local-bind (list ,@bl) '(mode-variable-flag t) ',mode)
;; Assign to local variables in all existing buffers in MODE
(mode-local-map-mode-buffers #'(lambda () ,@sl) ',mode)
;; Return the last value
,tmp)
)))
(defmacro defvar-mode-local (mode sym val &optional docstring)
"Define MODE local variable SYM with value VAL.
DOCSTRING is optional."
`(progn
(setq-mode-local ,mode ,sym ,val)
(put (mode-local-symbol ',sym ',mode)
'variable-documentation ,docstring)
',sym))
(put 'defvar-mode-local 'lisp-indent-function 'defun)
(defmacro defconst-mode-local (mode sym val &optional docstring)
"Define MODE local constant SYM with value VAL.
DOCSTRING is optional."
(let ((tmp (make-symbol "tmp")))
`(let (,tmp)
(setq-mode-local ,mode ,sym ,val)
(setq ,tmp (mode-local-symbol ',sym ',mode))
(put ,tmp 'constant-flag t)
(put ,tmp 'variable-documentation ,docstring)
',sym)))
(put 'defconst-mode-local 'lisp-indent-function 'defun)
;;; Function overloading
;;
(defun make-obsolete-overload (old new when)
"Mark OLD overload as obsoleted by NEW overload.
WHEN is a string describing the first release where it was made obsolete."
(put old 'overload-obsoleted-by new)
(put old 'overload-obsoleted-since when)
(put old 'mode-local-overload t)
(put new 'overload-obsolete old))
(defsubst overload-obsoleted-by (overload)
"Get the overload symbol obsoleted by OVERLOAD.
Return the obsolete symbol or nil if not found."
(get overload 'overload-obsolete))
(defsubst overload-that-obsolete (overload)
"Return the overload symbol that obsoletes OVERLOAD.
Return the symbol found or nil if OVERLOAD is not obsolete."
(get overload 'overload-obsoleted-by))
(defsubst fetch-overload (overload)
"Return the current OVERLOAD function, or nil if not found.
First, lookup for OVERLOAD into locally bound mode local symbols, then
in those bound in current `major-mode' and its parents."
(or (mode-local-symbol-value overload nil 'override-flag)
;; If an obsolete overload symbol exists, try it.
(and (overload-obsoleted-by overload)
(mode-local-symbol-value
(overload-obsoleted-by overload) nil 'override-flag))))
(defun mode-local--override (name args body)
"Return the form that handles overloading of function NAME.
ARGS are the arguments to the function.
BODY is code that would be run when there is no override defined. The
default is to call the function `NAME-default' with the appropriate
arguments.
See also the function `define-overload'."
(let* ((default (intern (format "%s-default" name)))
(overargs (delq '&rest (delq '&optional (copy-sequence args))))
(override (make-symbol "override")))
`(let ((,override (fetch-overload ',name)))
(if ,override
(funcall ,override ,@overargs)
,@(or body `((,default ,@overargs)))))
))
(defun mode-local--expand-overrides (name args body)
"Expand override forms that overload function NAME.
ARGS are the arguments to the function NAME.
BODY is code where override forms are searched for expansion.
Return result of expansion, or BODY if no expansion occurred.
See also the function `define-overload'."
(let ((forms body)
(ditto t)
form xbody)
(while forms
(setq form (car forms))
(cond
((atom form))
((eq (car form) :override)
(setq form (mode-local--override name args (cdr form))))
((eq (car form) :override-with-args)
(setq form (mode-local--override name (cadr form) (cddr form))))
((setq form (mode-local--expand-overrides name args form))))
(setq ditto (and ditto (eq (car forms) form))
xbody (cons form xbody)
forms (cdr forms)))
(if ditto body (nreverse xbody))))
(defun mode-local--overload-body (name args body)
"Return the code that implements overloading of function NAME.
ARGS are the arguments to the function NAME.
BODY specifies the overload code.
See also the function `define-overload'."
(let ((result (mode-local--expand-overrides name args body)))
(if (eq body result)
(list (mode-local--override name args body))
result)))
;;;###autoload
(put 'define-overloadable-function 'doc-string-elt 3)
(defmacro define-overloadable-function (name args docstring &rest body)
"Define a new function, as with `defun', which can be overloaded.
NAME is the name of the function to create.
ARGS are the arguments to the function.
DOCSTRING is a documentation string to describe the function. The
docstring will automatically have details about its overload symbol
appended to the end.
BODY is code that would be run when there is no override defined. The
default is to call the function `NAME-default' with the appropriate
arguments.
BODY can also include an override form that specifies which part of
BODY is specifically overridden. This permits to specify common code
run for both default and overridden implementations.
An override form is one of:
1. (:override [OVERBODY])
2. (:override-with-args OVERARGS [OVERBODY])
OVERBODY is the code that would be run when there is no override
defined. The default is to call the function `NAME-default' with the
appropriate arguments deduced from ARGS.
OVERARGS is a list of arguments passed to the override and
`NAME-default' function, in place of those deduced from ARGS."
(declare (doc-string 3))
`(eval-and-compile
(defun ,name ,args
,docstring
,@(mode-local--overload-body name args body))
(put ',name 'mode-local-overload t)))
(put :override-with-args 'lisp-indent-function 1)
(defalias 'define-overload 'define-overloadable-function)
(defsubst function-overload-p (symbol)
"Return non-nil if SYMBOL is a function which can be overloaded."
(and symbol (symbolp symbol) (get symbol 'mode-local-overload)))
(defmacro define-mode-local-override
(name mode args docstring &rest body)
"Define a mode specific override of the function overload NAME.
Has meaning only if NAME has been created with `define-overload'.
MODE is the major mode this override is being defined for.
ARGS are the function arguments, which should match those of the same
named function created with `define-overload'.
DOCSTRING is the documentation string.
BODY is the implementation of this function."
(let ((newname (intern (format "%s-%s" name mode))))
`(progn
(eval-and-compile
(defun ,newname ,args
,(format "%s\n\nOverride %s in `%s' buffers."
docstring name mode)
;; The body for this implementation
,@body)
;; For find-func to locate the definition of NEWNAME.
(put ',newname 'definition-name ',name))
(mode-local-bind '((,name . ,newname))
'(override-flag t)
',mode))
))
;;; Read/Query Support
(defun mode-local-read-function (prompt &optional initial hist default)
"Interactively read in the name of a mode-local function.
PROMPT, INITIAL, HIST, and DEFAULT are the same as for `completing-read'."
(completing-read prompt obarray 'function-overload-p t initial hist default))
;;; Help support
;;
(defun overload-docstring-extension (overload)
"Return the doc string that augments the description of OVERLOAD."
(let ((doc "\n\This function can be overloaded\
with `define-mode-local-override'.")
(sym (overload-obsoleted-by overload)))
(when sym
(setq doc (format "%s\nIt has made the overload `%s' obsolete since %s."
doc sym (get sym 'overload-obsoleted-since))))
(setq sym (overload-that-obsolete overload))
(when sym
(setq doc (format "%s\nThis overload is obsolete since %s;\nUse `%s' instead."
doc (get overload 'overload-obsoleted-since) sym)))
doc))
(defun mode-local-augment-function-help (symbol)
"Augment the *Help* buffer for SYMBOL.
SYMBOL is a function that can be overridden."
(with-current-buffer "*Help*"
(pop-to-buffer (current-buffer))
(goto-char (point-min))
(unless (re-search-forward "^$" nil t)
(goto-char (point-max))
(beginning-of-line)
(forward-line -1))
(let ((inhibit-read-only t))
(insert (overload-docstring-extension symbol) "\n")
;; NOTE TO SELF:
;; LIST ALL LOADED OVERRIDES FOR SYMBOL HERE
)))
;; Help for mode-local bindings.
(defun mode-local-print-binding (symbol)
"Print the SYMBOL binding."
(let ((value (symbol-value symbol)))
(princ (format "\n `%s' value is\n " symbol))
(if (and value (symbolp value))
(princ (format "`%s'" value))
(let ((pt (point)))
(pp value)
(save-excursion
(goto-char pt)
(indent-sexp))))
(or (bolp) (princ "\n"))))
(defun mode-local-print-bindings (table)
"Print bindings in TABLE."
(let (us ;; List of unspecified symbols
mc ;; List of mode local constants
mv ;; List of mode local variables
ov ;; List of overloaded functions
fo ;; List of final overloaded functions
)
;; Order symbols by type
(mapatoms
#'(lambda (s)
(add-to-list (cond
((get s 'mode-variable-flag)
(if (get s 'constant-flag) 'mc 'mv))
((get s 'override-flag)
(if (get s 'constant-flag) 'fo 'ov))
('us))
s))
table)
;; Print symbols by type
(when us
(princ "\n !! Unspecified symbols\n")
(mapc 'mode-local-print-binding us))
(when mc
(princ "\n ** Mode local constants\n")
(mapc 'mode-local-print-binding mc))
(when mv
(princ "\n ** Mode local variables\n")
(mapc 'mode-local-print-binding mv))
(when fo
(princ "\n ** Final overloaded functions\n")
(mapc 'mode-local-print-binding fo))
(when ov
(princ "\n ** Overloaded functions\n")
(mapc 'mode-local-print-binding ov))
))
(defun mode-local-describe-bindings-2 (buffer-or-mode)
"Display mode local bindings active in BUFFER-OR-MODE."
(let (table mode)
(princ "Mode local bindings active in ")
(cond
((bufferp buffer-or-mode)
(with-current-buffer buffer-or-mode
(setq table mode-local-symbol-table
mode major-mode))
(princ (format "%S\n" buffer-or-mode))
)
((symbolp buffer-or-mode)
(setq mode buffer-or-mode)
(princ (format "`%s'\n" buffer-or-mode))
)
((signal 'wrong-type-argument
(list 'buffer-or-mode buffer-or-mode))))
(when table
(princ "\n- Buffer local\n")
(mode-local-print-bindings table))
(while mode
(setq table (get mode 'mode-local-symbol-table))
(when table
(princ (format "\n- From `%s'\n" mode))
(mode-local-print-bindings table))
(setq mode (get-mode-local-parent mode)))))
(defun mode-local-describe-bindings-1 (buffer-or-mode &optional interactive-p)
"Display mode local bindings active in BUFFER-OR-MODE.
Optional argument INTERACTIVE-P is non-nil if the calling command was
invoked interactively."
(if (fboundp 'with-displaying-help-buffer)
;; XEmacs
(with-displaying-help-buffer
#'(lambda ()
(with-current-buffer standard-output
(mode-local-describe-bindings-2 buffer-or-mode)
(when (fboundp 'frob-help-extents)
(goto-char (point-min))
(frob-help-extents standard-output)))))
;; GNU Emacs
(when (fboundp 'help-setup-xref)
(help-setup-xref
(list 'mode-local-describe-bindings-1 buffer-or-mode)
interactive-p))
(with-output-to-temp-buffer (help-buffer) ; "*Help*"
(with-current-buffer standard-output
(mode-local-describe-bindings-2 buffer-or-mode)))))
(defun describe-mode-local-bindings (buffer)
"Display mode local bindings active in BUFFER."
(interactive "b")
(when (setq buffer (get-buffer buffer))
(mode-local-describe-bindings-1 buffer (called-interactively-p 'any))))
(defun describe-mode-local-bindings-in-mode (mode)
"Display mode local bindings active in MODE hierarchy."
(interactive
(list (completing-read
"Mode: " obarray
#'(lambda (s) (get s 'mode-local-symbol-table))
t (symbol-name major-mode))))
(when (setq mode (intern-soft mode))
(mode-local-describe-bindings-1 mode (called-interactively-p 'any))))
;; ;;; find-func support (Emacs 21.4, or perhaps 22.1)
;; ;;
;; (condition-case nil
;; ;; Try to get find-func so we can modify it.
;; (require 'find-func)
;; (error nil))
;; (when (boundp 'find-function-regexp)
;; (unless (string-match "ine-overload" find-function-regexp)
;; (if (string-match "(def\\\\(" find-function-regexp)
;; (let ((end (match-end 0))
;; )
;; (setq find-function-regexp
;; (concat (substring find-function-regexp 0 end)
;; "ine-overload\\|ine-mode-local-override\\|"
;; "ine-child-mode\\|"
;; (substring find-function-regexp end)))))))
;;; edebug support
;;
(defun mode-local-setup-edebug-specs ()
"Define edebug specification for mode local macros."
(def-edebug-spec setq-mode-local
(symbolp &rest symbolp form))
(def-edebug-spec defvar-mode-local
(&define symbolp name def-form [ &optional stringp ] ))
(def-edebug-spec defconst-mode-local
defvar-mode-local)
(def-edebug-spec define-overload
(&define name lambda-list stringp def-body))
(def-edebug-spec define-overloadable-function
(&define name lambda-list stringp def-body))
(def-edebug-spec define-mode-local-override
(&define name symbolp lambda-list stringp def-body)))
(add-hook 'edebug-setup-hook 'mode-local-setup-edebug-specs)
(add-hook 'find-file-hook 'mode-local-post-major-mode-change)
(add-hook 'change-major-mode-hook 'mode-local-on-major-mode-change)
(provide 'mode-local)
;;; mode-local.el ends here
|