emacs: lisp/emacs-lisp/smie.el comparison

comparison lisp/emacs-lisp/smie.el @ 111232:a9904c1962db

SMIE: change indent rules format, improve smie-setup. * lisp/emacs-lisp/smie.el (smie-precs-precedence-table) (smie-merge-prec2s, smie-bnf-precedence-table, smie-prec2-levels): Mark them pure so the tables gets built at compile time. (smie-bnf-precedence-table): Store the closer-alist in the table. (smie-prec2-levels): Preserve the closer-alist. (smie-blink-matching-open): Be more forgiving in case of indentation. (smie-hanging-p): Rename from smie-indent--hanging-p. (smie-bolp): Rename from smie-indent--bolp. (smie--parent, smie--after): New dynamic vars. (smie-parent-p, smie-next-p, smie-prev-p): New funs. (smie-indent-rules): Remove. (smie-indent--offset-rule): Remove fun. (smie-rules-function): New var. (smie-indent--rule): New fun. (smie-indent--offset, smie-indent-keyword, smie-indent-after-keyword) (smie-indent-exps): Use it. (smie-setup): Setup paren blinking; add keyword args for token functions; extract closer-alist from op-levels. (smie-indent-debug-log): Remove var. (smie-indent-debug): Remove fun. * lisp/progmodes/prolog.el (prolog-smie-indent-rules): Remove. (prolog-smie-rules): New fun to replace it. (prolog-mode-variables): Simplify. * lisp/progmodes/octave-mod.el (octave-smie-closer-alist): Remove, now that it's setup automatically. (octave-smie-indent-rules): Remove. (octave-smie-rules): New fun to replace it. (octave-mode): Simplify.

author	Stefan Monnier <monnier@iro.umontreal.ca>
date	Fri, 29 Oct 2010 15:20:28 -0400
parents	e544f6cc2447
children	0c36e585b866

comparison

equal deleted inserted replaced

-:d66d04803828
+:a9904c1962db
 ;; don't hide real conflicts.
 (puthash key (gethash key override) table)
 (display-warning 'smie (format "Conflict: %s %s/%s %s" x old val y)))
 (puthash key val table))))
+(put 'smie-precs-precedence-table 'pure t)
 (defun smie-precs-precedence-table (precs)
 "Compute a 2D precedence table from a list of precedences.
 PRECS should be a list, sorted by precedence (e.g. \"+\" will
 come before \"*\"), of elements of the form \(left OP ...)
 or (right OP ...) or (nonassoc OP ...) or (assoc OP ...).  All operators in
 (dolist (other-op (cdr other-prec))
 (smie-set-prec2tab prec2-table op other-op op2)
 (smie-set-prec2tab prec2-table other-op op op1)))))))
 prec2-table))
+(put 'smie-merge-prec2s 'pure t)
 (defun smie-merge-prec2s (&rest tables)
 (if (null (cdr tables))
 (car tables)
 (let ((prec2 (make-hash-table :test 'equal)))
 (dolist (table tables)
 (error "Conflicting values for %s property" k)
 (puthash k v prec2))))
 table))
 prec2)))
+(put 'smie-bnf-precedence-table 'pure t)
 (defun smie-bnf-precedence-table (bnf &rest precs)
 (let ((nts (mapcar 'car bnf))         ;Non-terminals
 (first-ops-table ())
 (last-ops-table ())
 (first-nts-table ())
 (t (smie-set-prec2tab prec2 (car rhs) (cadr rhs) '= override)))
 (setq rhs (cdr rhs)))))
 ;; Keep track of which tokens are openers/closer, so they can get a nil
 ;; precedence in smie-prec2-levels.
 (puthash :smie-open/close-alist (smie-bnf-classify bnf) prec2)
+(puthash :smie-closer-alist (smie-bnf-closer-alist bnf) prec2)
 prec2))
 ;; (defun smie-prec2-closer-alist (prec2 include-inners)
 ;;   "Build a closer-alist from a PREC2 table.
 ;; The return value is in the same form as `smie-closer-alist'.
 (mapconcat
 (lambda (elems) (mapconcat 'identity elems "="))
 (append names (list (car names)))
 " < ")))
+(put 'smie-prec2-levels 'pure t)
 (defun smie-prec2-levels (prec2)
 ;; FIXME: Rather than only return an alist of precedence levels, we should
 ;; also extract other useful data from it:
 ;; - better default indentation rules (i.e. non-zero indentation after inner
 ;;   keywords like the "in" of "let..in..end") for smie-indent-after-keyword.
 (incf i))                   ;See other (incf i) above.
 (unless (or (nth 2 x)
 (eq 'closer (cdr (assoc (car x) classification-table))))
 (setf (nth 2 x) i)
 (incf i)))))                ;See other (incf i) above.
+(let ((ca (gethash :smie-closer-alist prec2)))
+(when ca (push (cons :smie-closer-alist ca) table)))
 table))
 ;;; Parsing using a precedence level table.
 (defvar smie-op-levels 'unset
 (not (member (cons starter ender) smie-closer-alist))))))))
 (defun smie-blink-matching-open ()
 "Blink the matching opener when applicable.
 This uses SMIE's tables and is expected to be placed on `post-self-insert-hook'."
+(let ((pos (point))                   ;Position after the close token.
+token)
 (when (and blink-matching-paren
 smie-closer-alist                     ; Optimization.
-(eq (char-before) last-command-event) ; Sanity check.
+(or (eq (char-before) last-command-event) ;; Sanity check.
+(save-excursion
+(or (progn (skip-chars-backward " \t")
+(setq pos (point))
+(eq (char-before) last-command-event))
+(progn (skip-chars-backward " \n\t")
+(setq pos (point))
+(eq (char-before) last-command-event)))))
 (memq last-command-event smie-blink-matching-triggers)
 (not (nth 8 (syntax-ppss))))
 (save-excursion
-(let ((pos (point))
+(setq token (funcall smie-backward-token-function))
-(token (funcall smie-backward-token-function)))
 (when (and (eq (point) (1- pos))
 (= 1 (length token))
 (not (rassoc token smie-closer-alist)))
 ;; The trigger char is itself a token but is not one of the
 ;; closers (e.g. ?\; in Octave mode), so go back to the
 ;; previous token.
 (setq pos (point))
-(setq token (save-excursion
+(setq token (funcall smie-backward-token-function)))
-(funcall smie-backward-token-function))))
 (when (rassoc token smie-closer-alist)
 ;; We're after a close token.  Let's still make sure we
 ;; didn't skip a comment to find that token.
 (funcall smie-forward-token-function)
 (when (and (save-excursion
-;; Trigger can be SPC, or reindent.
+;; Skip the trigger char, if applicable.
-(skip-chars-forward " \n\t")
+(if (eq (char-after) last-command-event)
+(forward-char 1))
+(if (eq ?\n last-command-event)
+;; Skip any auto-indentation, if applicable.
+(skip-chars-forward " \t"))
 (>= (point) pos))
-;; If token ends with a trigger char, so don't blink for
+;; If token ends with a trigger char, don't blink for
 ;; anything else than this trigger char, lest we'd blink
 ;; both when inserting the trigger char and when
 ;; inserting a subsequent trigger char like SPC.
 (or (eq (point) pos)
 (not (memq (char-before)
 (defcustom smie-indent-basic 4
 "Basic amount of indentation."
 :type 'integer)
-(defvar smie-indent-rules 'unset
+(defvar smie-rules-function 'ignore
-;; TODO: For SML, we need more rule formats, so as to handle
+"Function providing the indentation rules.
-;;   structure Foo =
+It takes two arguments METHOD and ARG where the meaning of ARG
-;;      Bar (toto)
+and the expected return value depends on METHOD.
-;; and
+METHOD can be:
-;;   structure Foo =
+- :after, in which case ARG is a token and the function should return the
-;;   struct ... end
+OFFSET to use for indentation after ARG.
-;; I.e. the indentation after "=" depends on the parent ("structure")
+- :before, in which case ARG is a token and the function should return the
-;; as well as on the following token ("struct").
+OFFSET to use to indent ARG itself.
-"Rules of the following form.
+- :elem, in which case the function should return either:
-\((:before . TOK) . OFFSET-RULES)	how to indent TOK itself.
+- the offset to use to indent function arguments (ARG = `arg')
-\(TOK . OFFSET-RULES)	how to indent right after TOK.
+- the basic indentation step (ARG = `basic').
-\(list-intro . TOKENS)	declare TOKENS as being followed by what may look like
+- :list-intro, in which case ARG is a token and the function should return
-			  a funcall but is just a sequence of expressions.
+non-nil if TOKEN is followed by a list of expressions (not separated by any
-\(t . OFFSET)		basic indentation step.
+token) rather than an expression.
-\(args . OFFSET)		indentation of arguments.
-\((T1 . T2) OFFSET)	like ((:before . T2) (:parent T1 OFFSET)).
+When ARG is a token, the function is called with point just before that token.
+A return value of nil always means to fallback on the default behavior, so the
-OFFSET-RULES is a list of elements which can each either be:
+function should return nil for arguments it does not expect.
-\(:hanging . OFFSET-RULES)	if TOK is hanging, use OFFSET-RULES.
-\(:parent PARENT . OFFSET-RULES) if TOK's parent is PARENT, use OFFSET-RULES.
-\(:next TOKEN . OFFSET-RULES)	if TOK is followed by TOKEN, use OFFSET-RULES.
-\(:prev TOKEN . OFFSET-RULES)	if TOK is preceded by TOKEN, use
-\(:bolp . OFFSET-RULES)		If TOK is first on a line, use OFFSET-RULES.
-OFFSET				the offset to use.
-PARENT can be either the name of the parent or a list of such names.
 OFFSET can be of the form:
 `point'				align with the token.
 `parent'				align with the parent.
 NUMBER				offset by NUMBER.
 \(+ OFFSETS...)			use the sum of OFFSETS.
 VARIABLE			use the value of VARIABLE as offset.
-The precise meaning of `point' depends on various details: it can
+This function will often use some of the following functions designed
-either mean the position of the token we're indenting, or the
+specifically for it:
-position of its parent, or the position right after its parent.
+`smie-bolp', `smie-hanging-p', `smie-parent-p', `smie-next-p', `smie-prev-p'.")
-A nil offset for indentation after an opening token defaults
+(defun smie-hanging-p ()
-to `smie-indent-basic'.")
+"Return non-nil if the current token is \"hanging\".
+A hanging keyword is one that's at the end of a line except it's not at
-(defun smie-indent--hanging-p ()
+the beginning of a line."
-;; A hanging keyword is one that's at the end of a line except it's not at
+(and (not (smie-bolp))
-;; the beginning of a line.
+(save-excursion
-(and (save-excursion
 (when (zerop (length (funcall smie-forward-token-function)))
 ;; Could be an open-paren.
 (forward-char 1))
 (skip-chars-forward " \t")
-(eolp))
+(eolp))))
-(not (smie-indent--bolp))))
+(defun smie-bolp ()
-(defun smie-indent--bolp ()
+"Return non-nil if the current token is the first on the line."
 (save-excursion (skip-chars-backward " \t") (bolp)))
+(defvar smie--parent) (defvar smie--after) ;Dynamically scoped.
+(defun smie-parent-p (&rest parents)
+"Return non-nil if the current token's parent is among PARENTS.
+Only meaningful when called from within `smie-rules-function'."
+(member (nth 2 (or smie--parent
+(save-excursion
+(let* ((pos (point))
+(tok (funcall smie-forward-token-function)))
+(unless (cadr (assoc tok smie-op-levels))
+(goto-char pos))
+(setq smie--parent
+(smie-backward-sexp 'halfsexp))))))
+parents))
+(defun smie-next-p (&rest tokens)
+"Return non-nil if the next token is among TOKENS.
+Only meaningful when called from within `smie-rules-function'."
+(let ((next
+(save-excursion
+(unless smie--after
+(smie-indent-forward-token) (setq smie--after (point)))
+(goto-char smie--after)
+(smie-indent-forward-token))))
+(member (car next) tokens)))
+(defun smie-prev-p (&rest tokens)
+"Return non-nil if the previous token is among TOKENS."
+(let ((prev (save-excursion
+(smie-indent-backward-token))))
+(member (car prev) tokens)))
 (defun smie-indent--offset (elem)
-(or (cdr (assq elem smie-indent-rules))
+(or (funcall smie-rules-function :elem elem)
-(cdr (assq t smie-indent-rules))
+(if (not (eq elem 'basic))
+(funcall smie-rules-function :elem 'basic))
 smie-indent-basic))
-(defvar smie-indent-debug-log)
+(defun smie-indent--rule (kind token &optional after parent)
+(let ((smie--parent parent)
-(defun smie-indent--offset-rule (tokinfo &optional after parent)
+(smie--after after))
-"Apply the OFFSET-RULES in TOKINFO.
+(funcall smie-rules-function kind token)))
-Point is expected to be right in front of the token corresponding to TOKINFO.
-If computing the indentation after the token, then AFTER is the position
-after the token, otherwise it should be nil.
-PARENT if non-nil should be the parent info returned by `smie-backward-sexp'."
-(let ((rules (cdr tokinfo))
-next prev
-offset)
-(while (consp rules)
-(let ((rule (pop rules)))
-(cond
-((not (consp rule)) (setq offset rule))
-((eq (car rule) '+) (setq offset rule))
-((eq (car rule) :hanging)
-(when (smie-indent--hanging-p)
-(setq rules (cdr rule))))
-((eq (car rule) :bolp)
-(when (smie-indent--bolp)
-(setq rules (cdr rule))))
-((eq (car rule) :eolp)
-(unless after
-(error "Can't use :eolp in :before indentation rules"))
-(when (> after (line-end-position))
-(setq rules (cdr rule))))
-((eq (car rule) :prev)
-(unless prev
-(save-excursion
-(setq prev (smie-indent-backward-token))))
-(when (equal (car prev) (cadr rule))
-(setq rules (cddr rule))))
-((eq (car rule) :next)
-(unless next
-(unless after
-(error "Can't use :next in :before indentation rules"))
-(save-excursion
-(goto-char after)
-(setq next (smie-indent-forward-token))))
-(when (equal (car next) (cadr rule))
-(setq rules (cddr rule))))
-((eq (car rule) :parent)
-(unless parent
-(save-excursion
-(if after (goto-char after))
-(setq parent (smie-backward-sexp 'halfsexp))))
-(when (if (listp (cadr rule))
-(member (nth 2 parent) (cadr rule))
-(equal (nth 2 parent) (cadr rule)))
-(setq rules (cddr rule))))
-(t (error "Unknown rule %s for indentation of %s"
-rule (car tokinfo))))))
-;; If `offset' is not set yet, use `rules' to handle the case where
-;; the tokinfo uses the old-style ((PARENT . TOK). OFFSET).
-(unless offset (setq offset rules))
-(when (boundp 'smie-indent-debug-log)
-(push (list (point) offset tokinfo) smie-indent-debug-log))
-offset))
 (defun smie-indent--column (offset &optional base parent virtual-point)
 "Compute the actual column to use for a given OFFSET.
 BASE is the base position to use, and PARENT is the parent info, if any.
 If VIRTUAL-POINT is non-nil, then `point' is virtual."
 (unless parent
 (setq parent (or (smie-backward-sexp 'halfsexp) :notfound)))
 (if (consp parent) (goto-char (cadr parent)))
 (smie-indent-virtual))
 ((eq offset nil) nil)
+;; FIXME: would be good to get rid of this since smie-rules-function
+;; can usually do the lookup trivially, but in cases where
+;; smie-rules-function returns (+ point VAR) it's not nearly as trivial.
 ((and (symbolp offset) (boundp 'offset))
 (smie-indent--column (symbol-value offset) base parent virtual-point))
 (t (error "Unknown indentation offset %s" offset))))
 (defun smie-indent-forward-token ()
 "Compute the virtual indentation to use for point.
 This is used when we're not trying to indent point but just
 need to compute the column at which point should be indented
 in order to figure out the indentation of some other (further down) point."
 ;; Trust pre-existing indentation on other lines.
-(if (smie-indent--bolp) (current-column) (smie-indent-calculate)))
+(if (smie-bolp) (current-column) (smie-indent-calculate)))
 (defun smie-indent-fixindent ()
 ;; Obey the `fixindent' special comment.
-(and (smie-indent--bolp)
+(and (smie-bolp)
 (save-excursion
 (comment-normalize-vars)
 (re-search-forward (concat comment-start-skip
 "fixindent"
 comment-end-skip)
 (token (pop toklevels)))
 (if (null (car toklevels))
 (save-excursion
 (goto-char pos)
 ;; Different cases:
-;; - smie-indent--bolp: "indent according to others".
+;; - smie-bolp: "indent according to others".
 ;; - common hanging: "indent according to others".
 ;; - SML-let hanging: "indent like parent".
 ;; - if-after-else: "indent-like parent".
 ;; - middle-of-line: "trust current position".
 (cond
 ((null (cdr toklevels)) nil) ;Not a keyword.
-((smie-indent--bolp)
+((smie-bolp)
 ;; For an open-paren-like thingy at BOL, always indent only
 ;; based on other rules (typically smie-indent-after-keyword).
 nil)
 (t
 ;; We're only ever here for virtual-indent, which is why
 ;; we can use (current-column) as answer for `point'.
-(let* ((tokinfo (or (assoc (cons :before token)
+(let* ((offset (or (smie-indent--rule :before token)
-smie-indent-rules)
 ;; By default use point unless we're hanging.
-`((:before . ,token) (:hanging nil) point)))
+(unless (smie-hanging-p) 'point))))
-;; (after (prog1 (point) (goto-char pos)))
-(offset (smie-indent--offset-rule tokinfo)))
 (smie-indent--column offset)))))
 ;; FIXME: This still looks too much like black magic!!
-;; FIXME: Rather than a bunch of rules like (PARENT . TOKEN), we
-;; want a single rule for TOKEN with different cases for each PARENT.
 (let* ((parent (smie-backward-sexp 'halfsexp))
-(tokinfo
-(or (assoc (cons (caddr parent) token)
-smie-indent-rules)
-(assoc (cons :before token) smie-indent-rules)
-;; Default rule.
-`((:before . ,token)
-;; (:parent open 0)
-point)))
 (offset (save-excursion
 (goto-char pos)
-(smie-indent--offset-rule tokinfo nil parent))))
+(or (smie-indent--rule :before token nil parent)
+'point))))
 ;; Different behaviors:
 ;; - align with parent.
 ;; - parent + offset.
 ;; - after parent's column + offset (actually, after or before
 ;;   depending on where backward-sexp stopped).
 ;; maybe when an infix or close-paren is at the beginning
 ;; of a buffer.
 nil)
 ((eq (car parent) (car toklevels))
 ;; We bumped into a same-level operator. align with it.
-(if (and (smie-indent--bolp) (/= (point) pos)
+(if (and (smie-bolp) (/= (point) pos)
 (save-excursion
 (goto-char (goto-char (cadr parent)))
-(not (smie-indent--bolp)))
+(not (smie-bolp)))
 ;; Check the offset of `token' rather then its parent
 ;; because its parent may have used a special rule.  E.g.
 ;;    function foo;
 ;;      line2;
 ;;      line3;
 ;; want to jump back over a sequence of same-level ops such as
 ;;    a -> b -> c
 ;;    -> d
 ;; So as to align with the earliest appropriate place.
 (smie-indent-virtual)))
-(tokinfo
+(t
-(if (and (= (point) pos) (smie-indent--bolp)
+(if (and (= (point) pos) (smie-bolp)
 (or (eq offset 'point)
 (and (consp offset) (memq 'point offset))))
 ;; Since we started at BOL, we're not computing a virtual
 ;; indentation, and we're still at the starting point, so
 ;; we can't use `current-column' which would cause
 (defun smie-indent-comment ()
 "Compute indentation of a comment."
 ;; Don't do it for virtual indentations.  We should normally never be "in
 ;; front of a comment" when doing virtual-indentation anyway.  And if we are
 ;; (as can happen in octave-mode), moving forward can lead to inf-loops.
-(and (smie-indent--bolp)
+(and (smie-bolp)
 (let ((pos (point)))
 (save-excursion
 (beginning-of-line)
 (and (re-search-forward comment-start-skip (line-end-position) t)
 (eq pos (or (match-end 1) (match-beginning 0))))))
 (defun smie-indent-after-keyword ()
 ;; Indentation right after a special keyword.
 (save-excursion
 (let* ((pos (point))
 (toklevel (smie-indent-backward-token))
-(tok (car toklevel))
+(tok (car toklevel)))
-(tokinfo (assoc tok smie-indent-rules)))
-;; Set some default indent rules.
-(if (and toklevel (null (cadr toklevel)) (null tokinfo))
-(setq tokinfo (list (car toklevel))))
-;; (if (and tokinfo (null toklevel))
-;;     (error "Token %S has indent rule but has no parsing info" tok))
 (when toklevel
-(unless tokinfo
-;; The default indentation after a keyword/operator is 0 for
-;; infix and t for prefix.
-;; Using the BNF syntax, we could come up with better
-;; defaults, but we only have the precedence levels here.
-(setq tokinfo (list tok 'default-rule
-(if (cadr toklevel) 0 (smie-indent--offset t)))))
 (let ((offset
-(or (smie-indent--offset-rule tokinfo pos)
+(or (smie-indent--rule :after tok pos)
-(smie-indent--offset t))))
+;; The default indentation after a keyword/operator is
-(let ((before (point)))
+;; 0 for infix and t for prefix.
+(if (or (null (cadr toklevel))
+(rassoc tok smie-closer-alist))
+(smie-indent--offset 'basic) 0)))
+(before (point)))
 (goto-char pos)
-(smie-indent--column offset before)))))))
+(smie-indent--column offset before))))))
 (defun smie-indent-exps ()
 ;; Indentation of sequences of simple expressions without
 ;; intervening keywords or operators.  E.g. "a b c" or "g (balbla) f".
 ;; Can be a list of expressions or a function call.
 (save-excursion
 (let ((positions nil)
 arg)
 (while (and (null (car (smie-backward-sexp)))
 (push (point) positions)
-(not (smie-indent--bolp))))
+(not (smie-bolp))))
 (save-excursion
 ;; Figure out if the atom we just skipped is an argument rather
 ;; than a function.
-(setq arg (or (null (car (smie-backward-sexp)))
+(setq arg
-(member (funcall smie-backward-token-function)
+(or (null (car (smie-backward-sexp)))
-(cdr (assoc 'list-intro smie-indent-rules))))))
+(funcall smie-rules-function :list-intro
+(funcall smie-backward-token-function)))))
 (cond
 ((null positions)
 ;; We're the first expression of the list.  In that case, the
 ;; indentation should be (have been) determined by its context.
 nil)
 (if (< indent 0) (setq indent 0)) ;Just in case.
 (if savep
 (save-excursion (indent-line-to indent))
 (indent-line-to indent)))))
-(defun smie-indent-debug ()
+(defun smie-setup (op-levels rules-function &rest keywords)
-"Show the rules used to compute indentation of current line."
+"Setup SMIE navigation and indentation.
-(interactive)
+OP-LEVELS is a grammar table generated by `smie-prec2-levels'.
-(let ((smie-indent-debug-log '()))
+RULES-FUNCTION is a set of indentation rules for use on `smie-rules-function'.
-(smie-indent-calculate)
+KEYWORDS are additional arguments, which can use the following keywords:
-;; FIXME: please improve!
+- :forward-token FUN
-(message "%S" smie-indent-debug-log)))
+- :backward-token FUN"
+(set (make-local-variable 'smie-rules-function) rules-function)
-(defun smie-setup (op-levels indent-rules)
-(set (make-local-variable 'smie-indent-rules) indent-rules)
 (set (make-local-variable 'smie-op-levels) op-levels)
-(set (make-local-variable 'indent-line-function) 'smie-indent-line))
+(set (make-local-variable 'indent-line-function) 'smie-indent-line)
+(set (make-local-variable 'forward-sexp-function)
+'smie-forward-sexp-command)
+(while keywords
+(let ((k (pop keywords))
+(v (pop keywords)))
+(case k
+(:forward-token
+(set (make-local-variable 'smie-forward-token-function) v))
+(:backward-token
+(set (make-local-variable 'smie-backward-token-function) v))
+(t (message "smie-setup: ignoring unknown keyword %s" k)))))
+(let ((ca (cdr (assq :smie-closer-alist op-levels))))
+(when ca
+(set (make-local-variable 'smie-closer-alist) ca)
+;; Only needed for interactive calls to blink-matching-open.
+(set (make-local-variable 'blink-matching-check-function)
+#'smie-blink-matching-check)
+(add-hook 'post-self-insert-hook
+#'smie-blink-matching-open 'append 'local)
+(set (make-local-variable 'smie-blink-matching-triggers)
+(append smie-blink-matching-triggers
+;; Rather than wait for SPC to blink, try to blink as
+;; soon as we type the last char of a block ender.
+(let ((closers (sort (mapcar #'cdr smie-closer-alist)
+#'string-lessp))
+(triggers ())
+closer)
+(while (setq closer (pop closers))
+(unless (and closers
+;; FIXME: this eliminates prefixes of other
+;; closers, but we should probably elimnate
+;; prefixes of other keywords as well.
+(string-prefix-p closer (car closers)))
+(push (aref closer (1- (length closer))) triggers)))
+(delete-dups triggers)))))))
 (provide 'smie)
 ;;; smie.el ends here

Mercurial > emacs

comparison lisp/emacs-lisp/smie.el @ 111232:a9904c1962db