Mercurial > emacs
annotate lisp/emacs-lisp/smie.el @ 108894:ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
* lisp/emacs-lisp/smie.el (smie-indent-offset-after)
(smie-indent-forward-token, smie-indent-backward-token): New functions.
(smie-indent-after-keyword): Use them.
(smie-indent-fixindent): Only applies to the indentation of the BOL.
(smie-indent-keyword): Tweak the black magic.
(smie-indent-comment-continue): Strip comment-continue before use.
(smie-indent-functions): Indent comments before keywords.
author | Stefan Monnier <monnier@iro.umontreal.ca> |
---|---|
date | Sun, 06 Jun 2010 22:10:19 -0400 |
parents | c3cbf94d10f1 |
children | 68586a267c40 |
rev | line source |
---|---|
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
1 ;;; smie.el --- Simple Minded Indentation Engine |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
2 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
3 ;; Copyright (C) 2010 Free Software Foundation, Inc. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
4 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
5 ;; Author: Stefan Monnier <monnier@iro.umontreal.ca> |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
6 ;; Keywords: languages, lisp, internal, parsing, indentation |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
7 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
8 ;; This file is part of GNU Emacs. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
9 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
10 ;; GNU Emacs is free software; you can redistribute it and/or modify |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
11 ;; it under the terms of the GNU General Public License as published by |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
12 ;; the Free Software Foundation, either version 3 of the License, or |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
13 ;; (at your option) any later version. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
14 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
15 ;; GNU Emacs is distributed in the hope that it will be useful, |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
18 ;; GNU General Public License for more details. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
19 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
20 ;; You should have received a copy of the GNU General Public License |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
21 ;; along with this program. If not, see <http://www.gnu.org/licenses/>. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
22 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
23 ;;; Commentary: |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
24 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
25 ;; While working on the SML indentation code, the idea grew that maybe |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
26 ;; I could write something generic to do the same thing, and at the |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
27 ;; end of working on the SML code, I had a pretty good idea of what it |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
28 ;; could look like. That idea grew stronger after working on |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
29 ;; LaTeX indentation. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
30 ;; |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
31 ;; So at some point I decided to try it out, by writing a new |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
32 ;; indentation code for Coq while trying to keep most of the code |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
33 ;; "table driven", where only the tables are Coq-specific. The result |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
34 ;; (which was used for Beluga-mode as well) turned out to be based on |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
35 ;; something pretty close to an operator precedence parser. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
36 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
37 ;; So here is another rewrite, this time following the actual principles of |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
38 ;; operator precedence grammars. Why OPG? Even though they're among the |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
39 ;; weakest kinds of parsers, these parsers have some very desirable properties |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
40 ;; for Emacs: |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
41 ;; - most importantly for indentation, they work equally well in either |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
42 ;; direction, so you can use them to parse backward from the indentation |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
43 ;; point to learn the syntactic context; |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
44 ;; - they work locally, so there's no need to keep a cache of |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
45 ;; the parser's state; |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
46 ;; - because of that locality, indentation also works just fine when earlier |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
47 ;; parts of the buffer are syntactically incorrect since the indentation |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
48 ;; looks at "as little as possible" of the buffer make an indentation |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
49 ;; decision. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
50 ;; - they typically have no error handling and can't even detect a parsing |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
51 ;; error, so we don't have to worry about what to do in case of a syntax |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
52 ;; error because the parser just automatically does something. Better yet, |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
53 ;; we can afford to use a sloppy grammar. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
54 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
55 ;; The development (especially the parts building the 2D precedence |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
56 ;; tables and then computing the precedence levels from it) is largely |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
57 ;; inspired from page 187-194 of "Parsing techniques" by Dick Grune |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
58 ;; and Ceriel Jacobs (BookBody.pdf available at |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
59 ;; http://www.cs.vu.nl/~dick/PTAPG.html). |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
60 ;; |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
61 ;; OTOH we had to kill many chickens, read many coffee grounds, and practiced |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
62 ;; untold numbers of black magic spells. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
63 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
64 ;;; Code: |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
65 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
66 (eval-when-compile (require 'cl)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
67 |
108878
c3cbf94d10f1
* emacs-lisp/smie.el (comment-continue): Declare for byte-compiler.
Juanma Barranquero <lekktu@gmail.com>
parents:
108865
diff
changeset
|
68 (defvar comment-continue) |
c3cbf94d10f1
* emacs-lisp/smie.el (comment-continue): Declare for byte-compiler.
Juanma Barranquero <lekktu@gmail.com>
parents:
108865
diff
changeset
|
69 |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
70 ;;; Building precedence level tables from BNF specs. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
71 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
72 (defun smie-set-prec2tab (table x y val &optional override) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
73 (assert (and x y)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
74 (let* ((key (cons x y)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
75 (old (gethash key table))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
76 (if (and old (not (eq old val))) |
108766
2f547b05b620
* emacs-lisp/smie.el (smie-set-prec2tab): Check override before use.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108652
diff
changeset
|
77 (if (and override (gethash key override)) |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
78 ;; FIXME: The override is meant to resolve ambiguities, |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
79 ;; but it also hides real conflicts. It would be great to |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
80 ;; be able to distinguish the two cases so that overrides |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
81 ;; don't hide real conflicts. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
82 (puthash key (gethash key override) table) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
83 (display-warning 'smie (format "Conflict: %s %s/%s %s" x old val y))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
84 (puthash key val table)))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
85 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
86 (defun smie-precs-precedence-table (precs) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
87 "Compute a 2D precedence table from a list of precedences. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
88 PRECS should be a list, sorted by precedence (e.g. \"+\" will |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
89 come before \"*\"), of elements of the form \(left OP ...) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
90 or (right OP ...) or (nonassoc OP ...) or (assoc OP ...). All operators in |
108642
66f3c521df14
* emacs-lisp/smie.el: Fix typos in docstrings.
Juanma Barranquero <lekktu@gmail.com>
parents:
108632
diff
changeset
|
91 one of those elements share the same precedence level and associativity." |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
92 (let ((prec2-table (make-hash-table :test 'equal))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
93 (dolist (prec precs) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
94 (dolist (op (cdr prec)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
95 (let ((selfrule (cdr (assq (car prec) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
96 '((left . >) (right . <) (assoc . =)))))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
97 (when selfrule |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
98 (dolist (other-op (cdr prec)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
99 (smie-set-prec2tab prec2-table op other-op selfrule)))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
100 (let ((op1 '<) (op2 '>)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
101 (dolist (other-prec precs) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
102 (if (eq prec other-prec) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
103 (setq op1 '> op2 '<) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
104 (dolist (other-op (cdr other-prec)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
105 (smie-set-prec2tab prec2-table op other-op op2) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
106 (smie-set-prec2tab prec2-table other-op op op1))))))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
107 prec2-table)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
108 |
108766
2f547b05b620
* emacs-lisp/smie.el (smie-set-prec2tab): Check override before use.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108652
diff
changeset
|
109 (defun smie-merge-prec2s (&rest tables) |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
110 (if (null (cdr tables)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
111 (car tables) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
112 (let ((prec2 (make-hash-table :test 'equal))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
113 (dolist (table tables) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
114 (maphash (lambda (k v) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
115 (smie-set-prec2tab prec2 (car k) (cdr k) v)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
116 table)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
117 prec2))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
118 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
119 (defun smie-bnf-precedence-table (bnf &rest precs) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
120 (let ((nts (mapcar 'car bnf)) ;Non-terminals |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
121 (first-ops-table ()) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
122 (last-ops-table ()) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
123 (first-nts-table ()) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
124 (last-nts-table ()) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
125 (prec2 (make-hash-table :test 'equal)) |
108766
2f547b05b620
* emacs-lisp/smie.el (smie-set-prec2tab): Check override before use.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108652
diff
changeset
|
126 (override (apply 'smie-merge-prec2s |
2f547b05b620
* emacs-lisp/smie.el (smie-set-prec2tab): Check override before use.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108652
diff
changeset
|
127 (mapcar 'smie-precs-precedence-table precs))) |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
128 again) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
129 (dolist (rules bnf) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
130 (let ((nt (car rules)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
131 (last-ops ()) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
132 (first-ops ()) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
133 (last-nts ()) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
134 (first-nts ())) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
135 (dolist (rhs (cdr rules)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
136 (assert (consp rhs)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
137 (if (not (member (car rhs) nts)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
138 (pushnew (car rhs) first-ops) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
139 (pushnew (car rhs) first-nts) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
140 (when (consp (cdr rhs)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
141 ;; If the first is not an OP we add the second (which |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
142 ;; should be an OP if BNF is an "operator grammar"). |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
143 ;; Strictly speaking, this should only be done if the |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
144 ;; first is a non-terminal which can expand to a phrase |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
145 ;; without any OP in it, but checking doesn't seem worth |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
146 ;; the trouble, and it lets the writer of the BNF |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
147 ;; be a bit more sloppy by skipping uninteresting base |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
148 ;; cases which are terminals but not OPs. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
149 (assert (not (member (cadr rhs) nts))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
150 (pushnew (cadr rhs) first-ops))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
151 (let ((shr (reverse rhs))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
152 (if (not (member (car shr) nts)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
153 (pushnew (car shr) last-ops) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
154 (pushnew (car shr) last-nts) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
155 (when (consp (cdr shr)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
156 (assert (not (member (cadr shr) nts))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
157 (pushnew (cadr shr) last-ops))))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
158 (push (cons nt first-ops) first-ops-table) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
159 (push (cons nt last-ops) last-ops-table) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
160 (push (cons nt first-nts) first-nts-table) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
161 (push (cons nt last-nts) last-nts-table))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
162 ;; Compute all first-ops by propagating the initial ones we have |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
163 ;; now, according to first-nts. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
164 (setq again t) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
165 (while (prog1 again (setq again nil)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
166 (dolist (first-nts first-nts-table) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
167 (let* ((nt (pop first-nts)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
168 (first-ops (assoc nt first-ops-table))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
169 (dolist (first-nt first-nts) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
170 (dolist (op (cdr (assoc first-nt first-ops-table))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
171 (unless (member op first-ops) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
172 (setq again t) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
173 (push op (cdr first-ops)))))))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
174 ;; Same thing for last-ops. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
175 (setq again t) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
176 (while (prog1 again (setq again nil)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
177 (dolist (last-nts last-nts-table) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
178 (let* ((nt (pop last-nts)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
179 (last-ops (assoc nt last-ops-table))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
180 (dolist (last-nt last-nts) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
181 (dolist (op (cdr (assoc last-nt last-ops-table))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
182 (unless (member op last-ops) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
183 (setq again t) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
184 (push op (cdr last-ops)))))))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
185 ;; Now generate the 2D precedence table. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
186 (dolist (rules bnf) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
187 (dolist (rhs (cdr rules)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
188 (while (cdr rhs) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
189 (cond |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
190 ((member (car rhs) nts) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
191 (dolist (last (cdr (assoc (car rhs) last-ops-table))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
192 (smie-set-prec2tab prec2 last (cadr rhs) '> override))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
193 ((member (cadr rhs) nts) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
194 (dolist (first (cdr (assoc (cadr rhs) first-ops-table))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
195 (smie-set-prec2tab prec2 (car rhs) first '< override)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
196 (if (and (cddr rhs) (not (member (car (cddr rhs)) nts))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
197 (smie-set-prec2tab prec2 (car rhs) (car (cddr rhs)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
198 '= override))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
199 (t (smie-set-prec2tab prec2 (car rhs) (cadr rhs) '= override))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
200 (setq rhs (cdr rhs))))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
201 prec2)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
202 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
203 (defun smie-prec2-levels (prec2) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
204 "Take a 2D precedence table and turn it into an alist of precedence levels. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
205 PREC2 is a table as returned by `smie-precs-precedence-table' or |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
206 `smie-bnf-precedence-table'." |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
207 ;; For each operator, we create two "variables" (corresponding to |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
208 ;; the left and right precedence level), which are represented by |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
209 ;; cons cells. Those are the vary cons cells that appear in the |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
210 ;; final `table'. The value of each "variable" is kept in the `car'. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
211 (let ((table ()) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
212 (csts ()) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
213 (eqs ()) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
214 tmp x y) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
215 ;; From `prec2' we construct a list of constraints between |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
216 ;; variables (aka "precedence levels"). These can be either |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
217 ;; equality constraints (in `eqs') or `<' constraints (in `csts'). |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
218 (maphash (lambda (k v) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
219 (if (setq tmp (assoc (car k) table)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
220 (setq x (cddr tmp)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
221 (setq x (cons nil nil)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
222 (push (cons (car k) (cons nil x)) table)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
223 (if (setq tmp (assoc (cdr k) table)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
224 (setq y (cdr tmp)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
225 (setq y (cons nil (cons nil nil))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
226 (push (cons (cdr k) y) table)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
227 (ecase v |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
228 (= (push (cons x y) eqs)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
229 (< (push (cons x y) csts)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
230 (> (push (cons y x) csts)))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
231 prec2) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
232 ;; First process the equality constraints. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
233 (let ((eqs eqs)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
234 (while eqs |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
235 (let ((from (caar eqs)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
236 (to (cdar eqs))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
237 (setq eqs (cdr eqs)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
238 (if (eq to from) |
108766
2f547b05b620
* emacs-lisp/smie.el (smie-set-prec2tab): Check override before use.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108652
diff
changeset
|
239 nil ;Nothing to do. |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
240 (dolist (other-eq eqs) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
241 (if (eq from (cdr other-eq)) (setcdr other-eq to)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
242 (when (eq from (car other-eq)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
243 ;; This can happen because of `assoc' settings in precs |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
244 ;; or because of a rhs like ("op" foo "op"). |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
245 (setcar other-eq to))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
246 (dolist (cst csts) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
247 (if (eq from (cdr cst)) (setcdr cst to)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
248 (if (eq from (car cst)) (setcar cst to))))))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
249 ;; Then eliminate trivial constraints iteratively. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
250 (let ((i 0)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
251 (while csts |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
252 (let ((rhvs (mapcar 'cdr csts)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
253 (progress nil)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
254 (dolist (cst csts) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
255 (unless (memq (car cst) rhvs) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
256 (setq progress t) |
108649
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
257 ;; We could give each var in a given iteration the same value, |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
258 ;; but we can also give them arbitrarily different values. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
259 ;; Basically, these are vars between which there is no |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
260 ;; constraint (neither equality nor inequality), so |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
261 ;; anything will do. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
262 ;; We give them arbitrary values, which means that we |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
263 ;; replace the "no constraint" case with either > or < |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
264 ;; but not =. The reason we do that is so as to try and |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
265 ;; distinguish associative operators (which will have |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
266 ;; left = right). |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
267 (unless (caar cst) |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
268 (setcar (car cst) i) |
108649
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
269 (incf i)) |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
270 (setq csts (delq cst csts)))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
271 (unless progress |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
272 (error "Can't resolve the precedence table to precedence levels"))) |
108649
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
273 (incf i 10)) |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
274 ;; Propagate equalities back to their source. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
275 (dolist (eq (nreverse eqs)) |
108766
2f547b05b620
* emacs-lisp/smie.el (smie-set-prec2tab): Check override before use.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108652
diff
changeset
|
276 (assert (or (null (caar eq)) (eq (car eq) (cdr eq)))) |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
277 (setcar (car eq) (cadr eq))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
278 ;; Finally, fill in the remaining vars (which only appeared on the |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
279 ;; right side of the < constraints). |
108766
2f547b05b620
* emacs-lisp/smie.el (smie-set-prec2tab): Check override before use.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108652
diff
changeset
|
280 (dolist (x table) |
2f547b05b620
* emacs-lisp/smie.el (smie-set-prec2tab): Check override before use.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108652
diff
changeset
|
281 ;; When both sides are nil, it means this operator binds very |
2f547b05b620
* emacs-lisp/smie.el (smie-set-prec2tab): Check override before use.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108652
diff
changeset
|
282 ;; very tight, but it's still just an operator, so we give it |
2f547b05b620
* emacs-lisp/smie.el (smie-set-prec2tab): Check override before use.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108652
diff
changeset
|
283 ;; the highest precedence. |
2f547b05b620
* emacs-lisp/smie.el (smie-set-prec2tab): Check override before use.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108652
diff
changeset
|
284 ;; OTOH if only one side is nil, it usually means it's like an |
2f547b05b620
* emacs-lisp/smie.el (smie-set-prec2tab): Check override before use.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108652
diff
changeset
|
285 ;; open-paren, which is very important for indentation purposes, |
2f547b05b620
* emacs-lisp/smie.el (smie-set-prec2tab): Check override before use.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108652
diff
changeset
|
286 ;; so we keep it nil, to make it easier to recognize. |
2f547b05b620
* emacs-lisp/smie.el (smie-set-prec2tab): Check override before use.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108652
diff
changeset
|
287 (unless (or (nth 1 x) (nth 2 x)) |
2f547b05b620
* emacs-lisp/smie.el (smie-set-prec2tab): Check override before use.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108652
diff
changeset
|
288 (setf (nth 1 x) i) |
2f547b05b620
* emacs-lisp/smie.el (smie-set-prec2tab): Check override before use.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108652
diff
changeset
|
289 (setf (nth 2 x) i)))) |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
290 table)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
291 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
292 ;;; Parsing using a precedence level table. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
293 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
294 (defvar smie-op-levels 'unset |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
295 "List of token parsing info. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
296 Each element is of the form (TOKEN LEFT-LEVEL RIGHT-LEVEL). |
108894
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
297 Parsing is done using an operator precedence parser. |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
298 LEFT-LEVEL and RIGHT-LEVEL can be either numbers or nil, where nil |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
299 means that this operator does not bind on the corresponding side, |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
300 i.e. a LEFT-LEVEL of nil means this is a token that behaves somewhat like |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
301 an open-paren, whereas a RIGHT-LEVEL of nil would correspond to something |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
302 like a close-paren.") |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
303 |
108797
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
304 (defvar smie-forward-token-function 'smie-default-forward-token |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
305 "Function to scan forward for the next token. |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
306 Called with no argument should return a token and move to its end. |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
307 If no token is found, return nil or the empty string. |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
308 It can return nil when bumping into a parenthesis, which lets SMIE |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
309 use syntax-tables to handle them in efficient C code.") |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
310 |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
311 (defvar smie-backward-token-function 'smie-default-backward-token |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
312 "Function to scan backward the previous token. |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
313 Same calling convention as `smie-forward-token-function' except |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
314 it should move backward to the beginning of the previous token.") |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
315 |
108649
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
316 (defalias 'smie-op-left 'car) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
317 (defalias 'smie-op-right 'cadr) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
318 |
108797
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
319 (defun smie-default-backward-token () |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
320 (forward-comment (- (point))) |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
321 (buffer-substring (point) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
322 (progn (if (zerop (skip-syntax-backward ".")) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
323 (skip-syntax-backward "w_'")) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
324 (point)))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
325 |
108797
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
326 (defun smie-default-forward-token () |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
327 (forward-comment (point-max)) |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
328 (buffer-substring (point) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
329 (progn (if (zerop (skip-syntax-forward ".")) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
330 (skip-syntax-forward "w_'")) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
331 (point)))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
332 |
108649
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
333 (defun smie-associative-p (toklevels) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
334 ;; in "a + b + c" we want to stop at each +, but in |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
335 ;; "if a then b else c" we don't want to stop at each keyword. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
336 ;; To distinguish the two cases, we made smie-prec2-levels choose |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
337 ;; different levels for each part of "if a then b else c", so that |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
338 ;; by checking if the left-level is equal to the right level, we can |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
339 ;; figure out that it's an associative operator. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
340 ;; This is not 100% foolproof, tho, since a grammar like |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
341 ;; (exp ("A" exp "C") ("A" exp "B" exp "C")) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
342 ;; will cause "B" to have equal left and right levels, even though |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
343 ;; it is not an associative operator. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
344 ;; A better check would be the check the actual previous operator |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
345 ;; against this one to see if it's the same, but we'd have to change |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
346 ;; `levels' to keep a stack of operators rather than only levels. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
347 (eq (smie-op-left toklevels) (smie-op-right toklevels))) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
348 |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
349 (defun smie-next-sexp (next-token next-sexp op-forw op-back halfsexp) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
350 "Skip over one sexp. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
351 NEXT-TOKEN is a function of no argument that moves forward by one |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
352 token (after skipping comments if needed) and returns it. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
353 NEXT-SEXP is a lower-level function to skip one sexp. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
354 OP-FORW is the accessor to the forward level of the level data. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
355 OP-BACK is the accessor to the backward level of the level data. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
356 HALFSEXP if non-nil, means skip over a partial sexp if needed. I.e. if the |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
357 first token we see is an operator, skip over its left-hand-side argument. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
358 Possible return values: |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
359 (FORW-LEVEL POS TOKEN): we couldn't skip TOKEN because its back-level |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
360 is too high. FORW-LEVEL is the forw-level of TOKEN, |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
361 POS is its start position in the buffer. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
362 (t POS TOKEN): same thing when we bump on the wrong side of a paren. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
363 (nil POS TOKEN): we skipped over a paren-like pair. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
364 nil: we skipped over an identifier, matched parentheses, ..." |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
365 (catch 'return |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
366 (let ((levels ())) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
367 (while |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
368 (let* ((pos (point)) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
369 (token (funcall next-token)) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
370 (toklevels (cdr (assoc token smie-op-levels)))) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
371 |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
372 (cond |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
373 ((null toklevels) |
108797
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
374 (when (zerop (length token)) |
108649
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
375 (condition-case err |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
376 (progn (goto-char pos) (funcall next-sexp 1) nil) |
108652
79ce86edba9f
* emacs-lisp/smie.el (smie-next-sexp): Break inf-loop at BOB.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108649
diff
changeset
|
377 (scan-error (throw 'return (list t (caddr err))))) |
79ce86edba9f
* emacs-lisp/smie.el (smie-next-sexp): Break inf-loop at BOB.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108649
diff
changeset
|
378 (if (eq pos (point)) |
79ce86edba9f
* emacs-lisp/smie.el (smie-next-sexp): Break inf-loop at BOB.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108649
diff
changeset
|
379 ;; We did not move, so let's abort the loop. |
79ce86edba9f
* emacs-lisp/smie.el (smie-next-sexp): Break inf-loop at BOB.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108649
diff
changeset
|
380 (throw 'return (list t (point)))))) |
108649
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
381 ((null (funcall op-back toklevels)) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
382 ;; A token like a paren-close. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
383 (assert (funcall op-forw toklevels)) ;Otherwise, why mention it? |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
384 (push (funcall op-forw toklevels) levels)) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
385 (t |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
386 (while (and levels (< (funcall op-back toklevels) (car levels))) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
387 (setq levels (cdr levels))) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
388 (cond |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
389 ((null levels) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
390 (if (and halfsexp (funcall op-forw toklevels)) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
391 (push (funcall op-forw toklevels) levels) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
392 (throw 'return |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
393 (prog1 (list (or (car toklevels) t) (point) token) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
394 (goto-char pos))))) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
395 (t |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
396 (if (and levels (= (funcall op-back toklevels) (car levels))) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
397 (setq levels (cdr levels))) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
398 (cond |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
399 ((null levels) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
400 (cond |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
401 ((null (funcall op-forw toklevels)) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
402 (throw 'return (list nil (point) token))) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
403 ((smie-associative-p toklevels) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
404 (throw 'return |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
405 (prog1 (list (or (car toklevels) t) (point) token) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
406 (goto-char pos)))) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
407 ;; We just found a match to the previously pending operator |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
408 ;; but this new operator is still part of a larger RHS. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
409 ;; E.g. we're now looking at the "then" in |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
410 ;; "if a then b else c". So we have to keep parsing the |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
411 ;; rest of the construct. |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
412 (t (push (funcall op-forw toklevels) levels)))) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
413 (t |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
414 (if (funcall op-forw toklevels) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
415 (push (funcall op-forw toklevels) levels)))))))) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
416 levels) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
417 (setq halfsexp nil))))) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
418 |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
419 (defun smie-backward-sexp (&optional halfsexp) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
420 "Skip over one sexp. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
421 HALFSEXP if non-nil, means skip over a partial sexp if needed. I.e. if the |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
422 first token we see is an operator, skip over its left-hand-side argument. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
423 Possible return values: |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
424 (LEFT-LEVEL POS TOKEN): we couldn't skip TOKEN because its right-level |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
425 is too high. LEFT-LEVEL is the left-level of TOKEN, |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
426 POS is its start position in the buffer. |
108642
66f3c521df14
* emacs-lisp/smie.el: Fix typos in docstrings.
Juanma Barranquero <lekktu@gmail.com>
parents:
108632
diff
changeset
|
427 (t POS TOKEN): same thing but for an open-paren or the beginning of buffer. |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
428 (nil POS TOKEN): we skipped over a paren-like pair. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
429 nil: we skipped over an identifier, matched parentheses, ..." |
108649
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
430 (smie-next-sexp |
108797
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
431 (indirect-function smie-backward-token-function) |
108649
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
432 (indirect-function 'backward-sexp) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
433 (indirect-function 'smie-op-left) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
434 (indirect-function 'smie-op-right) |
108652
79ce86edba9f
* emacs-lisp/smie.el (smie-next-sexp): Break inf-loop at BOB.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108649
diff
changeset
|
435 halfsexp)) |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
436 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
437 (defun smie-forward-sexp (&optional halfsexp) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
438 "Skip over one sexp. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
439 HALFSEXP if non-nil, means skip over a partial sexp if needed. I.e. if the |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
440 first token we see is an operator, skip over its left-hand-side argument. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
441 Possible return values: |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
442 (RIGHT-LEVEL POS TOKEN): we couldn't skip TOKEN because its left-level |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
443 is too high. RIGHT-LEVEL is the right-level of TOKEN, |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
444 POS is its end position in the buffer. |
108642
66f3c521df14
* emacs-lisp/smie.el: Fix typos in docstrings.
Juanma Barranquero <lekktu@gmail.com>
parents:
108632
diff
changeset
|
445 (t POS TOKEN): same thing but for an open-paren or the beginning of buffer. |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
446 (nil POS TOKEN): we skipped over a paren-like pair. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
447 nil: we skipped over an identifier, matched parentheses, ..." |
108649
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
448 (smie-next-sexp |
108797
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
449 (indirect-function smie-forward-token-function) |
108649
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
450 (indirect-function 'forward-sexp) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
451 (indirect-function 'smie-op-right) |
c9e786f54683
Fix handling of non-associative equal levels.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108642
diff
changeset
|
452 (indirect-function 'smie-op-left) |
108652
79ce86edba9f
* emacs-lisp/smie.el (smie-next-sexp): Break inf-loop at BOB.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108649
diff
changeset
|
453 halfsexp)) |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
454 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
455 (defun smie-backward-sexp-command (&optional n) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
456 "Move backward through N logical elements." |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
457 (interactive "p") |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
458 (if (< n 0) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
459 (smie-forward-sexp-command (- n)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
460 (let ((forward-sexp-function nil)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
461 (while (> n 0) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
462 (decf n) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
463 (let ((pos (point)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
464 (res (smie-backward-sexp 'halfsexp))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
465 (if (and (car res) (= pos (point)) (not (bolp))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
466 (signal 'scan-error |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
467 (list "Containing expression ends prematurely" |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
468 (cadr res) (cadr res))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
469 nil)))))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
470 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
471 (defun smie-forward-sexp-command (&optional n) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
472 "Move forward through N logical elements." |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
473 (interactive "p") |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
474 (if (< n 0) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
475 (smie-backward-sexp-command (- n)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
476 (let ((forward-sexp-function nil)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
477 (while (> n 0) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
478 (decf n) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
479 (let ((pos (point)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
480 (res (smie-forward-sexp 'halfsexp))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
481 (if (and (car res) (= pos (point)) (not (bolp))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
482 (signal 'scan-error |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
483 (list "Containing expression ends prematurely" |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
484 (cadr res) (cadr res))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
485 nil)))))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
486 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
487 ;;; The indentation engine. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
488 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
489 (defcustom smie-indent-basic 4 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
490 "Basic amount of indentation." |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
491 :type 'integer) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
492 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
493 (defvar smie-indent-rules 'unset |
108864
f241d9fe71fe
* lisp/emacs-lisp/smie.el (smie-indent-calculate): Simplify and cleanup.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108797
diff
changeset
|
494 ;; TODO: For SML, we need more rule formats, so as to handle |
f241d9fe71fe
* lisp/emacs-lisp/smie.el (smie-indent-calculate): Simplify and cleanup.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108797
diff
changeset
|
495 ;; structure Foo = |
f241d9fe71fe
* lisp/emacs-lisp/smie.el (smie-indent-calculate): Simplify and cleanup.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108797
diff
changeset
|
496 ;; Bar (toto) |
f241d9fe71fe
* lisp/emacs-lisp/smie.el (smie-indent-calculate): Simplify and cleanup.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108797
diff
changeset
|
497 ;; and |
f241d9fe71fe
* lisp/emacs-lisp/smie.el (smie-indent-calculate): Simplify and cleanup.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108797
diff
changeset
|
498 ;; structure Foo = |
f241d9fe71fe
* lisp/emacs-lisp/smie.el (smie-indent-calculate): Simplify and cleanup.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108797
diff
changeset
|
499 ;; struct ... end |
f241d9fe71fe
* lisp/emacs-lisp/smie.el (smie-indent-calculate): Simplify and cleanup.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108797
diff
changeset
|
500 ;; I.e. the indentation after "=" depends on the parent ("structure") |
f241d9fe71fe
* lisp/emacs-lisp/smie.el (smie-indent-calculate): Simplify and cleanup.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108797
diff
changeset
|
501 ;; as well as on the following token ("struct"). |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
502 "Rules of the following form. |
108894
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
503 \(TOK . OFFSET-RULES) how to indent right after TOK. |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
504 \((T1 . T2) . OFFSET) how to indent token T2 w.r.t T1. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
505 \((t . TOK) . OFFSET) how to indent TOK with respect to its parent. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
506 \(list-intro . TOKENS) declare TOKENS as being followed by what may look like |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
507 a funcall but is just a sequence of expressions. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
508 \(t . OFFSET) basic indentation step. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
509 \(args . OFFSET) indentation of arguments. |
108894
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
510 |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
511 OFFSET-RULES is list of elements which can either be an integer (the offset to |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
512 use), or a cons of the form |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
513 \(:hanging . OFFSET-RULES) if TOK is hanging, use OFFSET-RULES. |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
514 \(:parent PARENT . OFFSET-RULES) if TOK's parent is PARENT, use OFFSET-RULES. |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
515 \(:next TOKEN . OFFSET-RULES) if TOK is followed by TOKEN, use OFFSET-RULES. |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
516 A nil offset defaults to `smie-indent-basic'.") |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
517 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
518 (defun smie-indent-hanging-p () |
108797
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
519 ;; A hanging keyword is one that's at the end of a line except it's not at |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
520 ;; the beginning of a line. |
108797
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
521 (and (save-excursion |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
522 (when (zerop (length (funcall smie-forward-token-function))) |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
523 ;; Could be an open-paren. |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
524 (forward-char 1)) |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
525 (skip-chars-forward " \t") |
d674108e8753
Provide hooks to use a different tokenizer in SMIE.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108766
diff
changeset
|
526 (eolp)) |
108864
f241d9fe71fe
* lisp/emacs-lisp/smie.el (smie-indent-calculate): Simplify and cleanup.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108797
diff
changeset
|
527 (not (smie-bolp)))) |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
528 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
529 (defun smie-bolp () |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
530 (save-excursion (skip-chars-backward " \t") (bolp))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
531 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
532 (defun smie-indent-offset (elem) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
533 (or (cdr (assq elem smie-indent-rules)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
534 (cdr (assq t smie-indent-rules)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
535 smie-indent-basic)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
536 |
108894
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
537 (defun smie-indent-offset-after (tokinfo after) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
538 ;; Presumes we're right before the token corresponding to `tokinfo' |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
539 ;; and `after' is the position that we're trying to indent. |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
540 (let ((rules (cdr tokinfo)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
541 parent next offset) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
542 (while (consp rules) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
543 (let ((rule (pop rules))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
544 (cond |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
545 ((not (consp rule)) (setq offset rule)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
546 ;; Using this `:hanging' is often "wrong", in that the hangingness |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
547 ;; of a keyword should usually not affect the indentation of the |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
548 ;; immediately following expression, but rather should affect the |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
549 ;; virtual indentation of that keyword (which in turn will affect not |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
550 ;; only indentation of the immediately following expression, but also |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
551 ;; other dependent expressions). |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
552 ;; But there are cases where it's useful: you may want to use it to |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
553 ;; make the indentation inside parentheses different depending on the |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
554 ;; hangingness of the open-paren, but without affecting the |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
555 ;; indentation of the paren-close. |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
556 ((eq (car rule) :hanging) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
557 (when (smie-indent-hanging-p) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
558 (setq rules (cdr rule)))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
559 ((eq (car rule) :next) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
560 (unless next |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
561 (save-excursion |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
562 (goto-char after) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
563 (setq next (funcall smie-forward-token-function)))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
564 (when (equal next (cadr rule)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
565 (setq rules (cddr rule)))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
566 ((eq (car rule) :parent) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
567 (unless parent |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
568 (save-excursion |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
569 (goto-char after) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
570 (setq parent (smie-backward-sexp 'halfsexp)))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
571 (when (equal (nth 2 parent) (cadr rule)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
572 (setq rules (cddr rule)))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
573 (t (error "Unknown rule %s for indentation after %s" |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
574 rule (car tokinfo)))))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
575 (or offset (smie-indent-offset t)))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
576 |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
577 (defun smie-indent-forward-token () |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
578 "Skip token forward and return it, along with its levels." |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
579 (let ((tok (funcall smie-forward-token-function))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
580 (cond |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
581 ((< 0 (length tok)) (assoc tok smie-op-levels)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
582 ((looking-at "\\s(") |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
583 (forward-char 1) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
584 (list (buffer-substring (1- (point)) (point)) nil 0))))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
585 |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
586 (defun smie-indent-backward-token () |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
587 "Skip token backward and return it, along with its levels." |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
588 (let ((tok (funcall smie-backward-token-function))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
589 (cond |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
590 ((< 0 (length tok)) (assoc tok smie-op-levels)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
591 ;; 4 == Open paren syntax. |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
592 ((eq 4 (syntax-class (syntax-after (1- (point))))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
593 (forward-char -1) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
594 (list (buffer-substring (point) (1+ (point))) nil 0))))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
595 |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
596 ;; FIXME: The `virtual' arg is fundamentally wrong: the virtual indent |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
597 ;; of a position should not depend on the caller, since it leads to situations |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
598 ;; where two dependent indentations get indented differently. |
108865
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
599 (defun smie-indent-virtual (virtual) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
600 "Compute the virtual indentation to use for point. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
601 This is used when we're not trying to indent point but just |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
602 need to compute the column at which point should be indented |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
603 in order to figure out the indentation of some other (further down) point. |
108865
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
604 VIRTUAL can take two different values: |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
605 - :bolp: means that the current indentation of point can be trusted |
108642
66f3c521df14
* emacs-lisp/smie.el: Fix typos in docstrings.
Juanma Barranquero <lekktu@gmail.com>
parents:
108632
diff
changeset
|
606 to be good only if it follows a line break. |
108865
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
607 - :not-hanging: means that the current indentation of point can be |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
608 trusted to be good except if the following token is hanging." |
108865
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
609 ;; Trust pre-existing indentation on other lines. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
610 (assert virtual) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
611 (if (if (eq virtual :not-hanging) (not (smie-indent-hanging-p)) (smie-bolp)) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
612 (current-column) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
613 (smie-indent-calculate))) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
614 |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
615 (defun smie-indent-fixindent () |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
616 ;; Obey the `fixindent' special comment. |
108894
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
617 (and (smie-bolp) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
618 (save-excursion |
108865
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
619 (comment-normalize-vars) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
620 (re-search-forward (concat comment-start-skip |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
621 "fixindent" |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
622 comment-end-skip) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
623 ;; 1+ to account for the \n comment termination. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
624 (1+ (line-end-position)) t)) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
625 (current-column))) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
626 |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
627 (defun smie-indent-bob () |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
628 ;; Start the file at column 0. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
629 (save-excursion |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
630 (forward-comment (- (point))) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
631 (if (bobp) 0))) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
632 |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
633 (defun smie-indent-close () |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
634 ;; Align close paren with opening paren. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
635 (save-excursion |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
636 ;; (forward-comment (point-max)) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
637 (when (looking-at "\\s)") |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
638 (while (not (zerop (skip-syntax-forward ")"))) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
639 (skip-chars-forward " \t")) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
640 (condition-case nil |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
641 (progn |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
642 (backward-sexp 1) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
643 (smie-indent-virtual :not-hanging)) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
644 (scan-error nil))))) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
645 |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
646 (defun smie-indent-keyword () |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
647 ;; Align closing token with the corresponding opening one. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
648 ;; (e.g. "of" with "case", or "in" with "let"). |
108894
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
649 ;; FIXME: This still looks too much like black magic!! |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
650 ;; FIXME: Rather than a bunch of rules like (PARENT . TOKEN), we |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
651 ;; want a single rule for TOKEN with different cases for each PARENT. |
108865
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
652 (save-excursion |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
653 (let* ((pos (point)) |
108894
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
654 (toklevels (smie-indent-forward-token)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
655 (token (pop toklevels))) |
108865
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
656 (when (car toklevels) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
657 (let ((res (smie-backward-sexp 'halfsexp)) tmp) |
108894
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
658 (cond |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
659 ((not (or (< (point) pos) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
660 (and (cadr res) (< (cadr res) pos)))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
661 ;; If we didn't move at all, that means we didn't really skip |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
662 ;; what we wanted. |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
663 nil) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
664 ((eq (car res) (car toklevels)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
665 ;; We bumped into a same-level operator. align with it. |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
666 (goto-char (cadr res)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
667 ;; Don't use (smie-indent-virtual :not-hanging) here, because we |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
668 ;; want to jump back over a sequence of same-level ops such as |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
669 ;; a -> b -> c |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
670 ;; -> d |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
671 ;; So as to align with the earliest appropriate place. |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
672 (smie-indent-virtual :bolp)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
673 ((equal token (save-excursion |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
674 (funcall smie-backward-token-function))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
675 ;; in cases such as "fn x => fn y => fn z =>", |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
676 ;; jump back to the very first fn. |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
677 ;; FIXME: should we only do that for special tokens like "=>"? |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
678 (smie-indent-virtual :bolp)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
679 ((setq tmp (assoc (cons (caddr res) token) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
680 smie-indent-rules)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
681 (goto-char (cadr res)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
682 (+ (cdr tmp) (smie-indent-virtual :not-hanging))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
683 ;; FIXME: The rules ((t . TOK) . OFFSET) either indent |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
684 ;; relative to "before the parent" or "after the parent", |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
685 ;; depending on details of the grammar. |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
686 ((null (car res)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
687 (assert (eq (point) (cadr res))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
688 (goto-char (cadr res)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
689 (+ (or (cdr (assoc (cons t token) smie-indent-rules)) 0) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
690 (smie-indent-virtual :not-hanging))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
691 ((smie-bolp) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
692 (+ (or (cdr (assoc (cons t token) smie-indent-rules)) 0) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
693 ;; FIXME: This is odd. Can't we make it use |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
694 ;; smie-indent-(calculate|virtual) somehow? |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
695 (smie-indent-after-keyword))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
696 (t |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
697 (+ (or (cdr (assoc (cons t token) smie-indent-rules)) 0) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
698 (current-column))))))))) |
108865
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
699 |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
700 (defun smie-indent-comment () |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
701 ;; Indentation of a comment. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
702 (and (looking-at comment-start-skip) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
703 (save-excursion |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
704 (forward-comment (point-max)) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
705 (skip-chars-forward " \t\r\n") |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
706 (smie-indent-calculate)))) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
707 |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
708 (defun smie-indent-comment-continue () |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
709 ;; indentation of comment-continue lines. |
108894
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
710 (let ((continue (comment-string-strip comment-continue t t))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
711 (and (< 0 (length continue)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
712 (looking-at (regexp-quote continue)) (nth 4 (syntax-ppss)) |
108865
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
713 (let ((ppss (syntax-ppss))) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
714 (save-excursion |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
715 (forward-line -1) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
716 (if (<= (point) (nth 8 ppss)) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
717 (progn (goto-char (1+ (nth 8 ppss))) (current-column)) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
718 (skip-chars-forward " \t") |
108894
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
719 (if (looking-at (regexp-quote continue)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
720 (current-column)))))))) |
108865
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
721 |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
722 (defun smie-indent-after-keyword () |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
723 ;; Indentation right after a special keyword. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
724 (save-excursion |
108894
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
725 (let* ((pos (point)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
726 (toklevel (smie-indent-backward-token)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
727 (tok (car toklevel)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
728 (tokinfo (assoc tok smie-indent-rules))) |
108865
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
729 (if (and toklevel (null (cadr toklevel)) (null tokinfo)) |
108894
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
730 (setq tokinfo (list (car toklevel)))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
731 ;; (if (and tokinfo (null toklevel)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
732 ;; (error "Token %S has indent rule but has no parsing info" tok)) |
108865
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
733 (when toklevel |
108894
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
734 (let ((offset |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
735 (cond |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
736 (tokinfo (smie-indent-offset-after tokinfo pos)) |
108865
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
737 ;; The default indentation after a keyword/operator |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
738 ;; is 0 for infix and t for prefix. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
739 ;; Using the BNF syntax, we could come up with |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
740 ;; better defaults, but we only have the |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
741 ;; precedence levels here. |
108894
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
742 ((null (cadr toklevel)) (smie-indent-offset t)) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
743 (t 0)))) |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
744 ;; For indentation after "(let" in SML-mode, we end up accumulating |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
745 ;; the offset of "(" and the offset of "let", so we use `min' to try |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
746 ;; and get it right either way. |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
747 (+ (min (smie-indent-virtual :bolp) (current-column)) offset)))))) |
108865
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
748 |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
749 (defun smie-indent-exps () |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
750 ;; Indentation of sequences of simple expressions without |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
751 ;; intervening keywords or operators. E.g. "a b c" or "g (balbla) f". |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
752 ;; Can be a list of expressions or a function call. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
753 ;; If it's a function call, the first element is special (it's the |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
754 ;; function). We distinguish function calls from mere lists of |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
755 ;; expressions based on whether the preceding token is listed in |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
756 ;; the `list-intro' entry of smie-indent-rules. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
757 ;; |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
758 ;; TODO: to indent Lisp code, we should add a way to specify |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
759 ;; particular indentation for particular args depending on the |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
760 ;; function (which would require always skipping back until the |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
761 ;; function). |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
762 ;; TODO: to indent C code, such as "if (...) {...}" we might need |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
763 ;; to add similar indentation hooks for particular positions, but |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
764 ;; based on the preceding token rather than based on the first exp. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
765 (save-excursion |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
766 (let ((positions nil) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
767 arg) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
768 (while (and (null (car (smie-backward-sexp))) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
769 (push (point) positions) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
770 (not (smie-bolp)))) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
771 (save-excursion |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
772 ;; Figure out if the atom we just skipped is an argument rather |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
773 ;; than a function. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
774 (setq arg (or (null (car (smie-backward-sexp))) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
775 (member (funcall smie-backward-token-function) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
776 (cdr (assoc 'list-intro smie-indent-rules)))))) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
777 (cond |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
778 ((null positions) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
779 ;; We're the first expression of the list. In that case, the |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
780 ;; indentation should be (have been) determined by its context. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
781 nil) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
782 (arg |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
783 ;; There's a previous element, and it's not special (it's not |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
784 ;; the function), so let's just align with that one. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
785 (goto-char (car positions)) |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
786 (current-column)) |
108865
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
787 ((cdr positions) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
788 ;; We skipped some args plus the function and bumped into something. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
789 ;; Align with the first arg. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
790 (goto-char (cadr positions)) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
791 (current-column)) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
792 (positions |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
793 ;; We're the first arg. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
794 (goto-char (car positions)) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
795 (+ (smie-indent-offset 'args) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
796 ;; We used to use (smie-indent-virtual :bolp), but that |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
797 ;; doesn't seem right since it might then indent args less than |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
798 ;; the function itself. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
799 (current-column))))))) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
800 |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
801 (defvar smie-indent-functions |
108894
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
802 '(smie-indent-fixindent smie-indent-bob smie-indent-close smie-indent-comment |
ca3bfaa18e56
Make (after keyword) indent-rules more flexible.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108878
diff
changeset
|
803 smie-indent-comment-continue smie-indent-keyword smie-indent-after-keyword |
108865
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
804 smie-indent-exps) |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
805 "Functions to compute the indentation. |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
806 Each function is called with no argument, shouldn't move point, and should |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
807 return either nil if it has no opinion, or an integer representing the column |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
808 to which that point should be aligned, if we were to reindent it.") |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
809 |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
810 (defun smie-indent-calculate () |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
811 "Compute the indentation to use for point." |
9d8fb76d6857
Split smie-indent-calculate into more manageable chunks.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
108864
diff
changeset
|
812 (run-hook-with-args-until-success 'smie-indent-functions)) |
108632
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
813 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
814 (defun smie-indent-line () |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
815 "Indent current line using the SMIE indentation engine." |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
816 (interactive) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
817 (let* ((savep (point)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
818 (indent (condition-case nil |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
819 (save-excursion |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
820 (forward-line 0) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
821 (skip-chars-forward " \t") |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
822 (if (>= (point) savep) (setq savep nil)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
823 (or (smie-indent-calculate) 0)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
824 (error 0)))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
825 (if (not (numberp indent)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
826 ;; If something funny is used (e.g. `noindent'), return it. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
827 indent |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
828 (if (< indent 0) (setq indent 0)) ;Just in case. |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
829 (if savep |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
830 (save-excursion (indent-line-to indent)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
831 (indent-line-to indent))))) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
832 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
833 ;;;###autoload |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
834 (defun smie-setup (op-levels indent-rules) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
835 (set (make-local-variable 'smie-indent-rules) indent-rules) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
836 (set (make-local-variable 'smie-op-levels) op-levels) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
837 (set (make-local-variable 'indent-line-function) 'smie-indent-line)) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
838 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
839 |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
840 (provide 'smie) |
d38b0dd2bdbe
Provide a simple generic indentation engine and use it for Prolog.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
diff
changeset
|
841 ;;; smie.el ends here |