mirror of https://github.com/Chizi123/.emacs.d.git

Chizi123
2018-11-21 e75a20334813452c6912c090d70a0de2c805f94d
commit | author | age
5cb5f7 1 ;;; yasnippet.el --- Yet another snippet extension for Emacs.
C 2
3 ;; Copyright (C) 2008-2018 Free Software Foundation, Inc.
4 ;; Authors: pluskid <pluskid@gmail.com>,
5 ;;          João Távora <joaotavora@gmail.com>,
6 ;;          Noam Postavsky <npostavs@gmail.com>
7 ;; Maintainer: Noam Postavsky <npostavs@gmail.com>
8 ;; Version: 0.13.0
9 ;; Package-Version: 20181015.1212
10 ;; X-URL: http://github.com/joaotavora/yasnippet
11 ;; Keywords: convenience, emulation
12 ;; URL: http://github.com/joaotavora/yasnippet
13 ;; Package-Requires: ((cl-lib "0.5"))
14 ;; EmacsWiki: YaSnippetMode
15
16 ;; This program is free software: you can redistribute it and/or modify
17 ;; it under the terms of the GNU General Public License as published by
18 ;; the Free Software Foundation, either version 3 of the License, or
19 ;; (at your option) any later version.
20
21 ;; This program is distributed in the hope that it will be useful,
22 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
23 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24 ;; GNU General Public License for more details.
25
26 ;; You should have received a copy of the GNU General Public License
27 ;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
28
29 ;;; Commentary:
30 ;;
31 ;;   Basic steps to setup:
32 ;;
33 ;;    (add-to-list 'load-path
34 ;;                 "~/path-to-yasnippet")
35 ;;    (require 'yasnippet)
36 ;;    (yas-global-mode 1)
37 ;;
38 ;;
39 ;;   Interesting variables are:
40 ;;
41 ;;       `yas-snippet-dirs'
42 ;;
43 ;;           The directory where user-created snippets are to be
44 ;;           stored.  Can also be a list of directories.  In that case,
45 ;;           when used for bulk (re)loading of snippets (at startup or
46 ;;           via `yas-reload-all'), directories appearing earlier in
47 ;;           the list override other dir's snippets.  Also, the first
48 ;;           directory is taken as the default for storing the user's
49 ;;           new snippets.
50 ;;
51 ;;           The deprecated `yas/root-directory' aliases this variable
52 ;;           for backward-compatibility.
53 ;;
54 ;;
55 ;;   Major commands are:
56 ;;
57 ;;       M-x yas-expand
58 ;;
59 ;;           Try to expand snippets before point.  In `yas-minor-mode',
60 ;;           this is normally bound to TAB, but you can customize it in
61 ;;           `yas-minor-mode-map'.
62 ;;
63 ;;       M-x yas-load-directory
64 ;;
65 ;;           Prompts you for a directory hierarchy of snippets to load.
66 ;;
67 ;;       M-x yas-activate-extra-mode
68 ;;
69 ;;           Prompts you for an extra mode to add snippets for in the
70 ;;           current buffer.
71 ;;
72 ;;       M-x yas-insert-snippet
73 ;;
74 ;;           Prompts you for possible snippet expansion if that is
75 ;;           possible according to buffer-local and snippet-local
76 ;;           expansion conditions.  With prefix argument, ignore these
77 ;;           conditions.
78 ;;
79 ;;       M-x yas-visit-snippet-file
80 ;;
81 ;;           Prompts you for possible snippet expansions like
82 ;;           `yas-insert-snippet', but instead of expanding it, takes
83 ;;           you directly to the snippet definition's file, if it
84 ;;           exists.
85 ;;
86 ;;       M-x yas-new-snippet
87 ;;
88 ;;           Lets you create a new snippet file in the correct
89 ;;           subdirectory of `yas-snippet-dirs', according to the
90 ;;           active major mode.
91 ;;
92 ;;       M-x yas-load-snippet-buffer
93 ;;
94 ;;           When editing a snippet, this loads the snippet.  This is
95 ;;           bound to "C-c C-c" while in the `snippet-mode' editing
96 ;;           mode.
97 ;;
98 ;;       M-x yas-tryout-snippet
99 ;;
100 ;;           When editing a snippet, this opens a new empty buffer,
101 ;;           sets it to the appropriate major mode and inserts the
102 ;;           snippet there, so you can see what it looks like.  This is
103 ;;           bound to "C-c C-t" while in `snippet-mode'.
104 ;;
105 ;;       M-x yas-describe-tables
106 ;;
107 ;;           Lists known snippets in a separate buffer.  User is
108 ;;           prompted as to whether only the currently active tables
109 ;;           are to be displayed, or all the tables for all major
110 ;;           modes.
111 ;;
112 ;;   If you have `dropdown-list' installed, you can optionally use it
113 ;;   as the preferred "prompting method", putting in your .emacs file,
114 ;;   for example:
115 ;;
116 ;;       (require 'dropdown-list)
117 ;;       (setq yas-prompt-functions '(yas-dropdown-prompt
118 ;;                                    yas-ido-prompt
119 ;;                                    yas-completing-prompt))
120 ;;
121 ;;   Also check out the customization group
122 ;;
123 ;;        M-x customize-group RET yasnippet RET
124 ;;
125 ;;   If you use the customization group to set variables
126 ;;   `yas-snippet-dirs' or `yas-global-mode', make sure the path to
127 ;;   "yasnippet.el" is present in the `load-path' *before* the
128 ;;   `custom-set-variables' is executed in your .emacs file.
129 ;;
130 ;;   For more information and detailed usage, refer to the project page:
131 ;;      http://github.com/joaotavora/yasnippet
132
133 ;;; Code:
134
135 (require 'cl-lib)
136 (require 'eldoc) ; Needed for 24.
137 (declare-function cl-progv-after "cl-extra") ; Needed for 23.4.
138 (require 'easymenu)
139 (require 'help-mode)
140
141 (defvar yas--editing-template)
142 (defvar yas--guessed-modes)
143 (defvar yas--indent-original-column)
144 (defvar yas--scheduled-jit-loads)
145 (defvar yas-keymap)
146 (defvar yas-selected-text)
147 (defvar yas-verbosity)
148 (defvar yas--current-template)
149
150
151 ;;; User customizable variables
152
153 (defgroup yasnippet nil
154   "Yet Another Snippet extension"
155   :prefix "yas-"
156   :group 'editing)
157
158 (defconst yas--loaddir
159   (file-name-directory (or load-file-name buffer-file-name))
160   "Directory that yasnippet was loaded from.")
161
162 (defconst yas-installed-snippets-dir (expand-file-name "snippets" yas--loaddir))
163 (make-obsolete-variable 'yas-installed-snippets-dir "\
164 Yasnippet no longer comes with installed snippets" "0.13")
165
166 (defconst yas--default-user-snippets-dir
167   (expand-file-name "snippets" user-emacs-directory))
168
169 (defcustom yas-snippet-dirs (list yas--default-user-snippets-dir)
170   "List of top-level snippet directories.
171
172 Each element, a string or a symbol whose value is a string,
173 designates a top-level directory where per-mode snippet
174 directories can be found.
175
176 Elements appearing earlier in the list override later elements'
177 snippets.
178
179 The first directory is taken as the default for storing snippet's
180 created with `yas-new-snippet'. "
181   :type '(choice (directory :tag "Single directory")
182                  (repeat :tag "List of directories"
183                          (choice (directory) (variable))))
184   :set #'(lambda (symbol new)
185            (let ((old (and (boundp symbol)
186                            (symbol-value symbol))))
187              (set-default symbol new)
188              (unless (or (not (fboundp 'yas-reload-all))
189                          (equal old new))
190                (yas-reload-all)))))
191
192 (defun yas-snippet-dirs ()
193   "Return variable `yas-snippet-dirs' as list of strings."
194   (cl-loop for e in (if (listp yas-snippet-dirs)
195                         yas-snippet-dirs
196                       (list yas-snippet-dirs))
197            collect
198            (cond ((stringp e) e)
199                  ((and (symbolp e)
200                        (boundp e)
201                        (stringp (symbol-value e)))
202                   (symbol-value e))
203                  (t
204                   (error "[yas] invalid element %s in `yas-snippet-dirs'" e)))))
205
206 (defcustom yas-new-snippet-default "\
207 # -*- mode: snippet -*-
208 # name: $1
209 # key: ${2:${1:$(yas--key-from-desc yas-text)}}
210 # --
211 $0`(yas-escape-text yas-selected-text)`"
212   "Default snippet to use when creating a new snippet.
213 If nil, don't use any snippet."
214   :type 'string)
215
216 (defcustom yas-prompt-functions '(yas-dropdown-prompt
217                                   yas-completing-prompt
218                                   yas-maybe-ido-prompt
219                                   yas-no-prompt)
220   "Functions to prompt for keys, templates, etc interactively.
221
222 These functions are called with the following arguments:
223
224 - PROMPT: A string to prompt the user
225
226 - CHOICES: a list of strings or objects.
227
228 - optional DISPLAY-FN : A function that, when applied to each of
229 the objects in CHOICES will return a string.
230
231 The return value of any function you put here should be one of
232 the objects in CHOICES, properly formatted with DISPLAY-FN (if
233 that is passed).
234
235 - To signal that your particular style of prompting is
236 unavailable at the moment, you can also have the function return
237 nil.
238
239 - To signal that the user quit the prompting process, you can
240 signal `quit' with
241
242     (signal \\='quit \"user quit!\")"
243   :type '(repeat function))
244
245 (defcustom yas-indent-line 'auto
246   "Controls indenting applied to a recent snippet expansion.
247
248 The following values are possible:
249
250 - `fixed' Indent the snippet to the current column;
251
252 - `auto' Indent each line of the snippet with `indent-according-to-mode'
253
254 Every other value means don't apply any snippet-side indentation
255 after expansion (the manual per-line \"$>\" indentation still
256 applies)."
257   :type '(choice (const :tag "Nothing"  nothing)
258                  (const :tag "Fixed"    fixed)
259                  (const :tag "Auto"     auto)))
260
261 (defcustom yas-also-auto-indent-first-line nil
262   "Non-nil means also auto indent first line according to mode.
263
264 Naturally this is only valid when `yas-indent-line' is `auto'."
265   :type 'boolean)
266
267 (defcustom yas-also-indent-empty-lines nil
268   "Non-nil means also indent empty lines according to mode."
269   :type 'boolean)
270
271 (defcustom yas-snippet-revival t
272   "Non-nil means re-activate snippet fields after undo/redo."
273   :type 'boolean)
274
275 (defcustom yas-triggers-in-field nil
276   "If non-nil, allow stacked expansions (snippets inside snippets).
277
278 Otherwise `yas-next-field-or-maybe-expand' just moves on to the
279 next field"
280   :type 'boolean)
281
282 (defcustom yas-fallback-behavior 'return-nil
283   "This option is obsolete.
284 Now that the conditional keybinding `yas-maybe-expand' is
285 available, there's no more need for it."
286   :type '(choice (const :tag "Call previous command"  call-other-command)
287                  (const :tag "Do nothing"             return-nil)))
288
289 (make-obsolete-variable
290  'yas-fallback-behavior
291  "For `call-other-command' behavior bind to the conditional
292 command value `yas-maybe-expand', for `return-nil' behavior bind
293 directly to `yas-expand'."
294  "0.12")
295
296 (defcustom yas-choose-keys-first nil
297   "If non-nil, prompt for snippet key first, then for template.
298
299 Otherwise prompts for all possible snippet names.
300
301 This affects `yas-insert-snippet' and `yas-visit-snippet-file'."
302   :type 'boolean)
303
304 (defcustom yas-choose-tables-first nil
305   "If non-nil, and multiple eligible snippet tables, prompts user for tables first.
306
307 Otherwise, user chooses between the merging together of all
308 eligible tables.
309
310 This affects `yas-insert-snippet', `yas-visit-snippet-file'"
311   :type 'boolean)
312
313 (defcustom yas-use-menu 'abbreviate
314   "Display a YASnippet menu in the menu bar.
315
316 When non-nil, submenus for each snippet table will be listed
317 under the menu \"Yasnippet\".
318
319 - If set to `abbreviate', only the current major-mode
320 menu and the modes set in `yas--extra-modes' are listed.
321
322 - If set to `full', every submenu is listed
323
324 - If set to nil, hide the menu.
325
326 Any other non-nil value, every submenu is listed."
327   :type '(choice (const :tag "Full"  full)
328                  (const :tag "Abbreviate" abbreviate)
329                  (const :tag "No menu" nil)))
330
331 (defcustom yas-trigger-symbol (or (and (eq window-system 'mac)
332                                        (ignore-errors
333                                          (char-to-string ?\x21E5))) ;; little ->| sign
334                                   " =>")
335   "The text that will be used in menu to represent the trigger."
336   :type 'string)
337
338 (defcustom yas-wrap-around-region nil
339   "What to insert for snippet's $0 field.
340
341 If set to a character, insert contents of corresponding register.
342 If non-nil insert region contents.  This can be overridden on a
343 per-snippet basis.  A value of `cua' is considered equivalent to
344 `?0' for backwards compatibility."
345   :type '(choice (character :tag "Insert from register")
346                  (const t :tag "Insert region contents")
347                  (const nil :tag "Don't insert anything")
348                  (const cua))) ; backwards compat
349
350 (defcustom yas-good-grace t
351   "If non-nil, don't raise errors in elisp evaluation.
352
353 This affects both the inline elisp in snippets and the hook
354 variables such as `yas-after-exit-snippet-hook'.
355
356 If this variable's value is `inline', an error string \"[yas]
357 error\" is returned instead of raising the error.  If this
358 variable's value is `hooks', a message is output to according to
359 `yas-verbosity-level'.  If this variable's value is t, both are
360 active."
361   :type 'boolean)
362
363 (defcustom yas-visit-from-menu nil
364   "If non-nil visit snippets's files from menu, instead of expanding them.
365
366 This can only work when snippets are loaded from files."
367   :type 'boolean)
368
369 (defcustom yas-expand-only-for-last-commands nil
370   "List of `last-command' values to restrict tab-triggering to, or nil.
371
372 Leave this set at nil (the default) to be able to trigger an
373 expansion simply by placing the cursor after a valid tab trigger,
374 using whichever commands.
375
376 Optionally, set this to something like (self-insert-command) if
377 you to wish restrict expansion to only happen when the last
378 letter of the snippet tab trigger was typed immediately before
379 the trigger key itself."
380   :type '(repeat function))
381
382 (defcustom yas-alias-to-yas/prefix-p t
383   "If non-nil make aliases for the old style yas/ prefixed symbols.
384 It must be set to nil before loading yasnippet to take effect."
385   :type 'boolean
386   :group 'yasnippet)
387
388 ;; Only two faces, and one of them shouldn't even be used...
389 ;;
390 (defface yas-field-highlight-face
391   '((t (:inherit 'region)))
392   "The face used to highlight the currently active field of a snippet")
393
394 (defface yas--field-debug-face
395   '()
396   "The face used for debugging some overlays normally hidden")
397
398
399 ;;; User-visible variables
400
401 (defconst yas-maybe-skip-and-clear-field
402   '(menu-item "" yas-skip-and-clear-field
403               :filter yas--maybe-clear-field-filter)
404   "A conditional key definition.
405 This can be used as a key definition in keymaps to bind a key to
406 `yas-skip-and-clear-field' only when at the beginning of an
407 unmodified snippet field.")
408
409 (defconst yas-maybe-clear-field
410     '(menu-item "" yas-clear-field
411                 :filter yas--maybe-clear-field-filter)
412     "A conditional key definition.
413 This can be used as a key definition in keymaps to bind a key to
414 `yas-clear-field' only when at the beginning of an
415 unmodified snippet field.")
416
417 (defvar yas-keymap  (let ((map (make-sparse-keymap)))
418                       (define-key map [(tab)]       'yas-next-field-or-maybe-expand)
419                       (define-key map (kbd "TAB")   'yas-next-field-or-maybe-expand)
420                       (define-key map [(shift tab)] 'yas-prev-field)
421                       (define-key map [backtab]     'yas-prev-field)
422                       (define-key map (kbd "C-g")   'yas-abort-snippet)
423                       (define-key map (kbd "C-d")   yas-maybe-skip-and-clear-field)
424                       (define-key map (kbd "DEL")   yas-maybe-clear-field)
425                       map)
426   "The active keymap while a snippet expansion is in progress.")
427
428 (defvar yas-key-syntaxes (list #'yas-try-key-from-whitespace
429                                "w_.()" "w_." "w_" "w")
430   "Syntaxes and functions to help look for trigger keys before point.
431
432 Each element in this list specifies how to skip buffer positions
433 backwards and look for the start of a trigger key.
434
435 Each element can be either a string or a function receiving the
436 original point as an argument. A string element is simply passed
437 to `skip-syntax-backward' whereas a function element is called
438 with no arguments and should also place point before the original
439 position.
440
441 The string between the resulting buffer position and the original
442 point is matched against the trigger keys in the active snippet
443 tables.
444
445 If no expandable snippets are found, the next element is the list
446 is tried, unless a function element returned the symbol `again',
447 in which case it is called again from the previous position and
448 may once more reposition point.
449
450 For example, if `yas-key-syntaxes' has the value (\"w\" \"w_\"),
451 trigger keys composed exclusively of \"word\"-syntax characters
452 are looked for first. Failing that, longer keys composed of
453 \"word\" or \"symbol\" syntax are looked for. Therefore,
454 triggering after
455
456 foo-barbaz
457
458 will, according to the \"w\" element first try \"barbaz\". If
459 that isn't a trigger key, \"foo-barbaz\" is tried, respecting the
460 second \"w_\" element. Notice that even if \"baz\" is a trigger
461 key for an active snippet, it won't be expanded, unless a
462 function is added to `yas-key-syntaxes' that eventually places
463 point between \"bar\" and \"baz\".
464
465 See also Info node `(elisp) Syntax Descriptors'.")
466
467 (defvar yas-after-exit-snippet-hook
468   '()
469   "Hooks to run after a snippet exited.
470
471 The hooks will be run in an environment where some variables bound to
472 proper values:
473
474 `yas-snippet-beg' : The beginning of the region of the snippet.
475
476 `yas-snippet-end' : Similar to beg.
477
478 Attention: These hooks are not run when exiting nested/stacked snippet expansion!")
479
480 (defvar yas-before-expand-snippet-hook
481   '()
482   "Hooks to run just before expanding a snippet.")
483
484 (defconst yas-not-string-or-comment-condition
485   '(if (and (let ((ppss (syntax-ppss)))
486               (or (nth 3 ppss) (nth 4 ppss)))
487             (memq this-command '(yas-expand yas-expand-from-trigger-key
488                                             yas-expand-from-keymap)))
489        '(require-snippet-condition . force-in-comment)
490      t)
491   "Disables snippet expansion in strings and comments.
492 To use, set `yas-buffer-local-condition' to this value.")
493
494 (defcustom yas-buffer-local-condition t
495   "Snippet expanding condition.
496
497 This variable is a Lisp form which is evaluated every time a
498 snippet expansion is attempted:
499
500     * If it evaluates to nil, no snippets can be expanded.
501
502     * If it evaluates to the a cons (require-snippet-condition
503       . REQUIREMENT)
504
505        * Snippets bearing no \"# condition:\" directive are not
506          considered
507
508        * Snippets bearing conditions that evaluate to nil (or
509          produce an error) won't be considered.
510
511        * If the snippet has a condition that evaluates to non-nil
512          RESULT:
513
514           * If REQUIREMENT is t, the snippet is considered
515
516           * If REQUIREMENT is `eq' RESULT, the snippet is
517             considered
518
519           * Otherwise, the snippet is not considered.
520
521     * If it evaluates to the symbol `always', all snippets are
522       considered for expansion, regardless of any conditions.
523
524     * If it evaluates to t or some other non-nil value
525
526        * Snippet bearing no conditions, or conditions that
527          evaluate to non-nil, are considered for expansion.
528
529        * Otherwise, the snippet is not considered.
530
531 Here's an example preventing snippets from being expanded from
532 inside comments, in `python-mode' only, with the exception of
533 snippets returning the symbol `force-in-comment' in their
534 conditions.
535
536  (add-hook \\='python-mode-hook
537            (lambda ()
538               (setq yas-buffer-local-condition
539                     \\='(if (python-syntax-comment-or-string-p)
540                          \\='(require-snippet-condition . force-in-comment)
541                        t))))"
542   :type
543   `(choice
544     (const :tag "Disable snippet expansion inside strings and comments"
545            ,yas-not-string-or-comment-condition)
546     (const :tag "Expand all snippets regardless of conditions" always)
547     (const :tag "Expand snippets unless their condition is nil" t)
548     (const :tag "Disable all snippet expansion" nil)
549     sexp))
550
551 (defcustom yas-overlay-priority 100
552   "Priority to use for yasnippets overlays.
553 This is useful to control whether snippet navigation bindings
554 override bindings from other packages (e.g., `company-mode')."
555   :type 'integer)
556
557
558 ;;; Internal variables
559
560 (defconst yas--version "0.13.0")
561
562 (defvar yas--menu-table (make-hash-table)
563   "A hash table of MAJOR-MODE symbols to menu keymaps.")
564
565 (defvar yas--escaped-characters
566   '(?\\ ?` ?\" ?' ?$ ?} ?{ ?\( ?\))
567   "List of characters which *might* need to be escaped.")
568
569 (defconst yas--field-regexp
570   "${\\([0-9]+:\\)?\\([^}]*\\)}"
571   "A regexp to *almost* recognize a field.")
572
573 (defconst yas--multi-dollar-lisp-expression-regexp
574   "$+[ \t\n]*\\(([^)]*)\\)"
575   "A regexp to *almost* recognize a \"$(...)\" expression.")
576
577 (defconst yas--backquote-lisp-expression-regexp
578   "`\\([^`]*\\)`"
579   "A regexp to recognize a \"\\=`lisp-expression\\=`\" expression." )
580
581 (defconst yas--transform-mirror-regexp
582   "${\\(?:\\([0-9]+\\):\\)?$\\([ \t\n]*([^}]*\\)"
583   "A regexp to *almost* recognize a mirror with a transform.")
584
585 (defconst yas--simple-mirror-regexp
586   "$\\([0-9]+\\)"
587   "A regexp to recognize a simple mirror.")
588
589 (defvar yas--snippet-id-seed 0
590   "Contains the next id for a snippet.")
591
592 (defvar yas--original-auto-fill-function nil
593   "The original value of `auto-fill-function'.")
594 (make-variable-buffer-local 'yas--original-auto-fill-function)
595
596 (defvar yas--watch-auto-fill-backtrace nil)
597
598 (defun yas--watch-auto-fill (sym newval op _where)
599   (when (and (or (and (eq sym 'yas--original-auto-fill-function)
600                       (null newval)
601                       (eq auto-fill-function 'yas--auto-fill))
602                  (and (eq sym 'auto-fill-function)
603                       (eq newval 'yas--auto-fill)
604                       (null yas--original-auto-fill-function)))
605              (null yas--watch-auto-fill-backtrace)
606              (fboundp 'backtrace-frames) ; Suppress compiler warning.
607              ;; If we're about to change `auto-fill-function' too,
608              ;; it's okay (probably).
609              (not (and (eq op 'makunbound)
610                        (not (eq (default-value 'auto-fill-function) 'yas--auto-fill))
611                        (cl-member 'kill-all-local-variables
612                                   (backtrace-frames 'yas--watch-auto-fill)
613                                   :key (lambda (frame) (nth 1 frame))))))
614     (setq yas--watch-auto-fill-backtrace
615           (backtrace-frames 'yas--watch-auto-fill))))
616
617 ;; Try to get more info on #873/919 (this only works for Emacs 26+).
618 (when (fboundp 'add-variable-watcher)
619   (add-variable-watcher 'yas--original-auto-fill-function
620                         #'yas--watch-auto-fill)
621   (add-variable-watcher 'auto-fill-function
622                         #'yas--watch-auto-fill))
623
624 (defun yas--snippet-next-id ()
625   (let ((id yas--snippet-id-seed))
626     (cl-incf yas--snippet-id-seed)
627     id))
628
629
630 ;;; Minor mode stuff
631
632 (defvar yas--minor-mode-menu nil
633   "Holds the YASnippet menu.")
634
635 (defvar yas--condition-cache-timestamp nil)
636
637 (defun yas-maybe-expand-abbrev-key-filter (cmd)
638   "Return CMD if there is an expandable snippet at point.
639 This function is useful as a `:filter' to a conditional key
640 definition."
641   (when (let ((yas--condition-cache-timestamp (current-time)))
642           (yas--templates-for-key-at-point))
643     cmd))
644
645 (define-obsolete-function-alias 'yas--maybe-expand-key-filter
646   #'yas-maybe-expand-abbrev-key-filter "0.14")
647
648 (defconst yas-maybe-expand
649   '(menu-item "" yas-expand :filter yas-maybe-expand-abbrev-key-filter)
650   "A conditional key definition.
651 This can be used as a key definition in keymaps to bind a key to
652 `yas-expand' only when there is a snippet available to be
653 expanded.")
654
655 (defvar yas-minor-mode-map
656   (let ((map (make-sparse-keymap)))
657     (define-key map [(tab)]     yas-maybe-expand)
658     (define-key map (kbd "TAB") yas-maybe-expand)
659     (define-key map "\C-c&\C-s" 'yas-insert-snippet)
660     (define-key map "\C-c&\C-n" 'yas-new-snippet)
661     (define-key map "\C-c&\C-v" 'yas-visit-snippet-file)
662     map)
663   "The keymap used when `yas-minor-mode' is active.")
664
665 (easy-menu-define yas--minor-mode-menu
666       yas-minor-mode-map
667       "Menu used when `yas-minor-mode' is active."
668   '("YASnippet" :visible yas-use-menu
669     "----"
670     ["Expand trigger" yas-expand
671      :help "Possibly expand tab trigger before point"]
672     ["Insert at point..." yas-insert-snippet
673      :help "Prompt for an expandable snippet and expand it at point"]
674     ["New snippet..." yas-new-snippet
675      :help "Create a new snippet in an appropriate directory"]
676     ["Visit snippet file..." yas-visit-snippet-file
677      :help "Prompt for an expandable snippet and find its file"]
678     "----"
679     ("Snippet menu behaviour"
680      ["Visit snippets" (setq yas-visit-from-menu t)
681       :help "Visit snippets from the menu"
682       :active t :style radio   :selected yas-visit-from-menu]
683      ["Expand snippets" (setq yas-visit-from-menu nil)
684       :help "Expand snippets from the menu"
685       :active t :style radio :selected (not yas-visit-from-menu)]
686      "----"
687      ["Show all known modes" (setq yas-use-menu 'full)
688       :help "Show one snippet submenu for each loaded table"
689       :active t :style radio   :selected (eq yas-use-menu 'full)]
690      ["Abbreviate according to current mode" (setq yas-use-menu 'abbreviate)
691       :help "Show only snippet submenus for the current active modes"
692       :active t :style radio   :selected (eq yas-use-menu 'abbreviate)])
693     ("Indenting"
694      ["Auto" (setq yas-indent-line 'auto)
695       :help "Indent each line of the snippet with `indent-according-to-mode'"
696       :active t :style radio   :selected (eq yas-indent-line 'auto)]
697      ["Fixed" (setq yas-indent-line 'fixed)
698       :help "Indent the snippet to the current column"
699       :active t :style radio   :selected (eq yas-indent-line 'fixed)]
700      ["None" (setq yas-indent-line 'none)
701       :help "Don't apply any particular snippet indentation after expansion"
702       :active t :style radio   :selected (not (member yas-indent-line '(fixed auto)))]
703      "----"
704      ["Also auto indent first line" (setq yas-also-auto-indent-first-line
705                                           (not yas-also-auto-indent-first-line))
706       :help "When auto-indenting also, auto indent the first line menu"
707       :active (eq yas-indent-line 'auto)
708       :style toggle :selected yas-also-auto-indent-first-line]
709      )
710     ("Prompting method"
711      ["System X-widget" (setq yas-prompt-functions
712                               (cons #'yas-x-prompt
713                                     (remove #'yas-x-prompt
714                                             yas-prompt-functions)))
715       :help "Use your windowing system's (gtk, mac, windows, etc...) default menu"
716       :active t :style radio   :selected (eq (car yas-prompt-functions)
717                                              #'yas-x-prompt)]
718      ["Dropdown-list" (setq yas-prompt-functions
719                             (cons #'yas-dropdown-prompt
720                                   (remove #'yas-dropdown-prompt
721                                           yas-prompt-functions)))
722       :help "Use a special dropdown list"
723       :active t :style radio   :selected (eq (car yas-prompt-functions)
724                                              #'yas-dropdown-prompt)]
725      ["Ido" (setq yas-prompt-functions
726                   (cons #'yas-ido-prompt
727                         (remove #'yas-ido-prompt
728                                 yas-prompt-functions)))
729       :help "Use an ido-style minibuffer prompt"
730       :active t :style radio   :selected (eq (car yas-prompt-functions)
731                                              #'yas-ido-prompt)]
732      ["Completing read" (setq yas-prompt-functions
733                               (cons #'yas-completing-prompt
734                                     (remove #'yas-completing-prompt
735                                             yas-prompt-functions)))
736       :help "Use a normal minibuffer prompt"
737       :active t :style radio   :selected (eq (car yas-prompt-functions)
738                                              #'yas-completing-prompt)]
739      )
740     ("Misc"
741      ["Wrap region in exit marker"
742       (setq yas-wrap-around-region
743             (not yas-wrap-around-region))
744       :help "If non-nil automatically wrap the selected text in the $0 snippet exit"
745       :style toggle :selected yas-wrap-around-region]
746      ["Allow stacked expansions "
747       (setq yas-triggers-in-field
748             (not yas-triggers-in-field))
749       :help "If non-nil allow snippets to be triggered inside other snippet fields"
750       :style toggle :selected yas-triggers-in-field]
751      ["Revive snippets on undo "
752       (setq yas-snippet-revival
753             (not yas-snippet-revival))
754       :help "If non-nil allow snippets to become active again after undo"
755       :style toggle :selected yas-snippet-revival]
756      ["Good grace "
757       (setq yas-good-grace
758             (not yas-good-grace))
759       :help "If non-nil don't raise errors in bad embedded elisp in snippets"
760       :style toggle :selected yas-good-grace]
761      )
762     "----"
763     ["Load snippets..."  yas-load-directory
764      :help "Load snippets from a specific directory"]
765     ["Reload everything" yas-reload-all
766      :help "Cleanup stuff, reload snippets, rebuild menus"]
767     ["About"            yas-about
768      :help "Display some information about YASnippet"]))
769
770 (defvar yas--extra-modes nil
771   "An internal list of modes for which to also lookup snippets.
772
773 This variable probably makes more sense as buffer-local, so
774 ensure your use `make-local-variable' when you set it.")
775 (define-obsolete-variable-alias 'yas-extra-modes 'yas--extra-modes "0.9.1")
776
777 (defvar yas--tables (make-hash-table)
778   "A hash table of mode symbols to `yas--table' objects.")
779
780 (defvar yas--parents (make-hash-table)
781   "A hash table of mode symbols do lists of direct parent mode symbols.
782
783 This list is populated when reading the \".yas-parents\" files
784 found when traversing snippet directories with
785 `yas-load-directory'.
786
787 There might be additional parenting information stored in the
788 `derived-mode-parent' property of some mode symbols, but that is
789 not recorded here.")
790
791 (defvar yas--direct-keymaps (list)
792   "Keymap alist supporting direct snippet keybindings.
793
794 This variable is placed in `emulation-mode-map-alists'.
795
796 Its elements looks like (TABLE-NAME . KEYMAP).  They're
797 instantiated on `yas-reload-all' but KEYMAP is added to only when
798 loading snippets.  `yas--direct-TABLE-NAME' is then a variable
799 set buffer-locally when entering `yas-minor-mode'.  KEYMAP binds
800 all defined direct keybindings to `yas-maybe-expand-from-keymap'
801 which decides on the snippet to expand.")
802
803 (defun yas-direct-keymaps-reload ()
804   "Force reload the direct keybinding for active snippet tables."
805   (interactive)
806   (setq yas--direct-keymaps nil)
807   (maphash #'(lambda (name table)
808                (push (cons (intern (format "yas--direct-%s" name))
809                            (yas--table-direct-keymap table))
810                      yas--direct-keymaps))
811            yas--tables))
812
813 (defun yas--modes-to-activate (&optional mode)
814   "Compute list of mode symbols that are active for `yas-expand' and friends."
815   (defvar yas--dfs)        ;We rely on dynbind.  We could use `letrec' instead!
816   (let* ((explored (if mode (list mode) ; Building up list in reverse.
817                      (cons major-mode (reverse yas--extra-modes))))
818          (yas--dfs
819           (lambda (mode)
820             (cl-loop for neighbour
821                      in (cl-list* (or (get mode 'derived-mode-parent)
822                                       ;; Consider `fundamental-mode'
823                                       ;; as ultimate ancestor.
824                                       'fundamental-mode)
825                                   ;; NOTE: `fboundp' check is redundant
826                                   ;; since Emacs 24.4.
827                                   (and (fboundp mode) (symbol-function mode))
828                                   (gethash mode yas--parents))
829                      when (and neighbour
830                                (not (memq neighbour explored))
831                                (symbolp neighbour))
832                      do (push neighbour explored)
833                      (funcall yas--dfs neighbour)))))
834     (mapc yas--dfs explored)
835     (nreverse explored)))
836
837 (defvar yas-minor-mode-hook nil
838   "Hook run when `yas-minor-mode' is turned on.")
839
840 (defun yas--auto-fill-wrapper ()
841   (when (and auto-fill-function
842              (not (eq auto-fill-function #'yas--auto-fill)))
843     (setq yas--original-auto-fill-function auto-fill-function)
844     (setq auto-fill-function #'yas--auto-fill)))
845
846 ;;;###autoload
847 (define-minor-mode yas-minor-mode
848   "Toggle YASnippet mode.
849
850 When YASnippet mode is enabled, `yas-expand', normally bound to
851 the TAB key, expands snippets of code depending on the major
852 mode.
853
854 With no argument, this command toggles the mode.
855 positive prefix argument turns on the mode.
856 Negative prefix argument turns off the mode.
857
858 Key bindings:
859 \\{yas-minor-mode-map}"
860   :lighter " yas" ;; The indicator for the mode line.
861   (cond ((and yas-minor-mode (featurep 'yasnippet))
862          ;; Install the direct keymaps in `emulation-mode-map-alists'
863          ;; (we use `add-hook' even though it's not technically a hook,
864          ;; but it works). Then define variables named after modes to
865          ;; index `yas--direct-keymaps'.
866          ;;
867          ;; Also install the post-command-hook.
868          ;;
869          (cl-pushnew 'yas--direct-keymaps emulation-mode-map-alists)
870          (add-hook 'post-command-hook #'yas--post-command-handler nil t)
871          ;; Set the `yas--direct-%s' vars for direct keymap expansion
872          ;;
873          (dolist (mode (yas--modes-to-activate))
874            (let ((name (intern (format "yas--direct-%s" mode))))
875              (set-default name nil)
876              (set (make-local-variable name) t)))
877          ;; Perform JIT loads
878          (yas--load-pending-jits)
879          ;; Install auto-fill handler.
880          (yas--auto-fill-wrapper)       ; Now...
881          (add-hook 'auto-fill-mode-hook #'yas--auto-fill-wrapper)) ; or later.
882         (t
883          ;; Uninstall the direct keymaps, post-command hook, and
884          ;; auto-fill handler.
885          (remove-hook 'post-command-hook #'yas--post-command-handler t)
886          (remove-hook 'auto-fill-mode-hook #'yas--auto-fill-wrapper)
887          (when (local-variable-p 'yas--original-auto-fill-function)
888            (setq auto-fill-function yas--original-auto-fill-function))
889          (setq emulation-mode-map-alists
890                (remove 'yas--direct-keymaps emulation-mode-map-alists)))))
891
892 (defun yas-activate-extra-mode (mode)
893   "Activates the snippets for the given `mode' in the buffer.
894
895 The function can be called in the hook of a minor mode to
896 activate snippets associated with that mode."
897   (interactive
898    (let (modes
899          symbol)
900      (maphash (lambda (k _)
901                 (setq modes (cons (list k) modes)))
902               yas--parents)
903      (setq symbol (completing-read
904                    "Activate mode: " modes nil t))
905      (list
906       (when (not (string= "" symbol))
907         (intern symbol)))))
908   (when mode
909     (add-to-list (make-local-variable 'yas--extra-modes) mode)
910     (yas--load-pending-jits)))
911
912 (defun yas-deactivate-extra-mode (mode)
913   "Deactivates the snippets for the given `mode' in the buffer."
914   (interactive
915    (list (intern
916           (completing-read
917            "Deactivate mode: " (mapcar #'list yas--extra-modes) nil t))))
918   (set (make-local-variable 'yas--extra-modes)
919        (remove mode
920                yas--extra-modes)))
921
922 (define-obsolete-variable-alias 'yas-dont-activate
923   'yas-dont-activate-functions "0.9.2")
924 (defvar yas-dont-activate-functions (list #'minibufferp)
925   "Special hook to control which buffers `yas-global-mode' affects.
926 Functions are called with no argument, and should return non-nil to prevent
927 `yas-global-mode' from enabling yasnippet in this buffer.
928
929 In Emacsen < 24, this variable is buffer-local.  Because
930 `yas-minor-mode-on' is called by `yas-global-mode' after
931 executing the buffer's major mode hook, setting this variable
932 there is an effective way to define exceptions to the \"global\"
933 activation behaviour.
934
935 In Emacsen >= 24, only the global value is used.  To define
936 per-mode exceptions to the \"global\" activation behaviour, call
937 `yas-minor-mode' with a negative argument directily in the major
938 mode's hook.")
939 (unless (> emacs-major-version 23)
940   (with-no-warnings
941     (make-variable-buffer-local 'yas-dont-activate)))
942
943
944 (defun yas-minor-mode-on ()
945   "Turn on YASnippet minor mode.
946
947 Honour `yas-dont-activate-functions', which see."
948   (interactive)
949   (unless (or
950            ;; The old behavior used for Emacs<24 was to set
951            ;; `yas-dont-activate-functions' to t buffer-locally.
952            (not (or (listp yas-dont-activate-functions)
953                     (functionp yas-dont-activate-functions)))
954            (run-hook-with-args-until-success 'yas-dont-activate-functions))
955     (yas-minor-mode 1)))
956
957 ;;;###autoload
958 (define-globalized-minor-mode yas-global-mode yas-minor-mode yas-minor-mode-on)
959
960 (defun yas--global-mode-reload-with-jit-maybe ()
961   "Run `yas-reload-all' when `yas-global-mode' is on."
962   (when yas-global-mode (yas-reload-all)))
963
964 (add-hook 'yas-global-mode-hook #'yas--global-mode-reload-with-jit-maybe)
965
966
967 ;;; Major mode stuff
968
969 (defvar yas--font-lock-keywords
970   (append '(("^#.*$" . font-lock-comment-face))
971           (with-temp-buffer
972             (let ((prog-mode-hook nil)
973                   (emacs-lisp-mode-hook nil))
974               (ignore-errors (emacs-lisp-mode)))
975             (font-lock-set-defaults)
976             (if (eq t (car-safe font-lock-keywords))
977                 ;; They're "compiled", so extract the source.
978                 (cadr font-lock-keywords)
979               font-lock-keywords))
980           '(("\\$\\([0-9]+\\)"
981              (0 font-lock-keyword-face)
982              (1 font-lock-string-face t))
983             ("\\${\\([0-9]+\\):?"
984              (0 font-lock-keyword-face)
985              (1 font-lock-warning-face t))
986             ("\\(\\$(\\)" 1 font-lock-preprocessor-face)
987             ("}"
988              (0 font-lock-keyword-face)))))
989
990 (defvar snippet-mode-map
991   (let ((map (make-sparse-keymap)))
992     (easy-menu-define nil
993       map
994       "Menu used when snippet-mode is active."
995       (cons "Snippet"
996             (mapcar #'(lambda (ent)
997                         (when (nth 2 ent)
998                           (define-key map (nth 2 ent) (nth 1 ent)))
999                         (vector (nth 0 ent) (nth 1 ent) t))
1000                     '(("Load this snippet" yas-load-snippet-buffer "\C-c\C-l")
1001                       ("Load and quit window" yas-load-snippet-buffer-and-close "\C-c\C-c")
1002                       ("Try out this snippet" yas-tryout-snippet "\C-c\C-t")))))
1003     map)
1004   "The keymap used when `snippet-mode' is active.")
1005
1006
1007
1008 ;;;###autoload(autoload 'snippet-mode "yasnippet" "A mode for editing yasnippets" t nil)
1009 (eval-and-compile
1010   (if (fboundp 'prog-mode)
1011       ;; `prog-mode' is new in 24.1.
1012       (define-derived-mode snippet-mode prog-mode "Snippet"
1013         "A mode for editing yasnippets"
1014         (setq font-lock-defaults '(yas--font-lock-keywords))
1015         (set (make-local-variable 'require-final-newline) nil)
1016         (set (make-local-variable 'comment-start) "#")
1017         (set (make-local-variable 'comment-start-skip) "#+[\t ]*")
1018         (add-hook 'after-save-hook #'yas-maybe-load-snippet-buffer nil t))
1019     (define-derived-mode snippet-mode fundamental-mode "Snippet"
1020       "A mode for editing yasnippets"
1021       (setq font-lock-defaults '(yas--font-lock-keywords))
1022       (set (make-local-variable 'require-final-newline) nil)
1023       (set (make-local-variable 'comment-start) "#")
1024       (set (make-local-variable 'comment-start-skip) "#+[\t ]*")
1025       (add-hook 'after-save-hook #'yas-maybe-load-snippet-buffer nil t))))
1026
1027 (defun yas-snippet-mode-buffer-p ()
1028   "Return non-nil if current buffer should be in `snippet-mode'.
1029 Meaning it's visiting a file under one of the mode directories in
1030 `yas-snippet-dirs'."
1031   (when buffer-file-name
1032     (cl-member buffer-file-name (yas-snippet-dirs)
1033                :test #'file-in-directory-p)))
1034
1035 ;; We're abusing `magic-fallback-mode-alist' here because
1036 ;; `auto-mode-alist' doesn't support function matchers.
1037 (add-to-list 'magic-fallback-mode-alist
1038              `(yas-snippet-mode-buffer-p . snippet-mode))
1039
1040
1041 ;;; Internal structs for template management
1042
1043 (cl-defstruct (yas--template
1044                (:constructor yas--make-template)
1045                ;; Handles `yas-define-snippets' format, plus the
1046                ;; initial TABLE argument.
1047                (:constructor
1048                 yas--define-snippets-2
1049                 (table
1050                  key content
1051                  &optional xname condition group
1052                  expand-env load-file xkeybinding xuuid save-file
1053                  &aux
1054                  (name (or xname
1055                            ;; A little redundant: we always get a name
1056                            ;; from `yas--parse-template' except when
1057                            ;; there isn't a file.
1058                            (and load-file (file-name-nondirectory load-file))
1059                            (and save-file (file-name-nondirectory save-file))
1060                            key))
1061                  (keybinding (yas--read-keybinding xkeybinding))
1062                  (uuid (or xuuid name))
1063                  (old (gethash uuid (yas--table-uuidhash table)))
1064                  (menu-binding-pair
1065                   (and old (yas--template-menu-binding-pair old)))
1066                  (perm-group
1067                   (and old (yas--template-perm-group old))))))
1068   "A template for a snippet."
1069   key
1070   content
1071   name
1072   condition
1073   expand-env
1074   load-file
1075   save-file
1076   keybinding
1077   uuid
1078   menu-binding-pair
1079   group      ;; as dictated by the #group: directive or .yas-make-groups
1080   perm-group ;; as dictated by `yas-define-menu'
1081   table
1082   )
1083
1084 (cl-defstruct (yas--table (:constructor yas--make-snippet-table (name)))
1085   "A table to store snippets for a particular mode.
1086
1087 Has the following fields:
1088
1089 `yas--table-name'
1090
1091   A symbol name normally corresponding to a major mode, but can
1092   also be a pseudo major-mode to be used in
1093   `yas-activate-extra-mode', for example.
1094
1095 `yas--table-hash'
1096
1097   A hash table (KEY . NAMEHASH), known as the \"keyhash\". KEY is
1098   a string or a vector, where the former is the snippet's trigger
1099   and the latter means it's a direct keybinding. NAMEHASH is yet
1100   another hash of (NAME . TEMPLATE) where NAME is the snippet's
1101   name and TEMPLATE is a `yas--template' object.
1102
1103 `yas--table-direct-keymap'
1104
1105   A keymap for the snippets in this table that have direct
1106   keybindings. This is kept in sync with the keyhash, i.e., all
1107   the elements of the keyhash that are vectors appear here as
1108   bindings to `yas-maybe-expand-from-keymap'.
1109
1110 `yas--table-uuidhash'
1111
1112   A hash table mapping snippets uuid's to the same `yas--template'
1113   objects. A snippet uuid defaults to the snippet's name."
1114   name
1115   (hash (make-hash-table :test 'equal))
1116   (uuidhash (make-hash-table :test 'equal))
1117   (parents nil)
1118   (direct-keymap (make-sparse-keymap)))
1119
1120 (defun yas--get-template-by-uuid (mode uuid)
1121   "Find the snippet template in MODE by its UUID."
1122   (let* ((table (gethash mode yas--tables mode)))
1123     (when table
1124       (gethash uuid (yas--table-uuidhash table)))))
1125
1126 ;; Apropos storing/updating in TABLE, this works in two steps:
1127 ;;
1128 ;; 1. `yas--remove-template-by-uuid' removes any
1129 ;;    keyhash-namehash-template mappings from TABLE, grabbing the
1130 ;;    snippet by its uuid. Also removes mappings from TABLE's
1131 ;;    `yas--table-direct-keymap' (FIXME: and should probably take care
1132 ;;    of potentially stale menu bindings right?.)
1133 ;;
1134 ;; 2. `yas--add-template' adds this all over again.
1135 ;;
1136 ;;    Create a new or add to an existing keyhash-namehash mapping.
1137 ;;
1138 ;;  For reference on understanding this, consider three snippet
1139 ;;  definitions:
1140 ;;
1141 ;;  A:   # name: The Foo
1142 ;;       # key: foo
1143 ;;       # binding: C-c M-l
1144 ;;
1145 ;;  B:   # name: Mrs Foo
1146 ;;       # key: foo
1147 ;;
1148 ;;  C:   # name: The Bar
1149 ;;       # binding: C-c M-l
1150 ;;
1151 ;;  D:   # name: Baz
1152 ;;       # key: baz
1153 ;;
1154 ;;  keyhash       namehashes(3)      yas--template structs(4)
1155 ;;  -----------------------------------------------------
1156 ;;                                            __________
1157 ;;                                           /          \
1158 ;;  "foo"      --->  "The Foo" --->  [yas--template A]   |
1159 ;;                   "Mrs Foo" --->  [yas--template B]   |
1160 ;;                                                      |
1161 ;;  [C-c M-l]  --->  "The Foo" -------------------------/
1162 ;;                   "The Bar" --->  [yas--template C]
1163 ;;
1164 ;;  "baz"      --->  "Baz"     --->  [yas--template D]
1165 ;;
1166 ;; Additionally, since uuid defaults to the name, we have a
1167 ;; `yas--table-uuidhash' for TABLE
1168 ;;
1169 ;; uuidhash       yas--template structs
1170 ;; -------------------------------
1171 ;; "The Foo" ---> [yas--template A]
1172 ;; "Mrs Foo" ---> [yas--template B]
1173 ;; "The Bar" ---> [yas--template C]
1174 ;; "Baz"     ---> [yas--template D]
1175 ;;
1176 ;; FIXME: the more I look at this data-structure the more I think I'm
1177 ;; stupid. There has to be an easier way (but beware lots of code
1178 ;; depends on this).
1179 ;;
1180 (defun yas--remove-template-by-uuid (table uuid)
1181   "Remove from TABLE a template identified by UUID."
1182   (let ((template (gethash uuid (yas--table-uuidhash table))))
1183     (when template
1184       (let* ((name                (yas--template-name template))
1185              (empty-keys          nil))
1186         ;; Remove the name from each of the targeted namehashes
1187         ;;
1188         (maphash #'(lambda (k v)
1189                      (let ((template (gethash name v)))
1190                        (when (and template
1191                                   (equal uuid (yas--template-uuid template)))
1192                          (remhash name v)
1193                          (when (zerop (hash-table-count v))
1194                            (push k empty-keys)))))
1195                  (yas--table-hash table))
1196         ;; Remove the namehash themselves if they've become empty
1197         ;;
1198         (dolist (key empty-keys)
1199           (when (vectorp key)
1200             (define-key (yas--table-direct-keymap table) key nil))
1201           (remhash key (yas--table-hash table)))
1202
1203         ;; Finally, remove the uuid from the uuidhash
1204         ;;
1205         (remhash uuid (yas--table-uuidhash table))))))
1206
1207 (defconst yas-maybe-expand-from-keymap
1208   '(menu-item "" yas-expand-from-keymap
1209               :filter yas--maybe-expand-from-keymap-filter))
1210
1211 (defun yas--add-template (table template)
1212   "Store in TABLE the snippet template TEMPLATE.
1213
1214 KEY can be a string (trigger key) of a vector (direct
1215 keybinding)."
1216   (let ((name (yas--template-name template))
1217         (key (yas--template-key template))
1218         (keybinding (yas--template-keybinding template))
1219         (_menu-binding-pair (yas--template-menu-binding-pair-get-create template)))
1220     (dolist (k (remove nil (list key keybinding)))
1221       (puthash name
1222                template
1223                (or (gethash k
1224                             (yas--table-hash table))
1225                    (puthash k
1226                             (make-hash-table :test 'equal)
1227                             (yas--table-hash table))))
1228       (when (vectorp k)
1229         (define-key (yas--table-direct-keymap table) k yas-maybe-expand-from-keymap)))
1230
1231     ;; Update TABLE's `yas--table-uuidhash'
1232     (puthash (yas--template-uuid template)
1233              template
1234              (yas--table-uuidhash table))))
1235
1236 (defun yas--update-template (table template)
1237   "Add or update TEMPLATE in TABLE.
1238
1239 Also takes care of adding and updating to the associated menu.
1240 Return TEMPLATE."
1241   ;; Remove from table by uuid
1242   ;;
1243   (yas--remove-template-by-uuid table (yas--template-uuid template))
1244   ;; Add to table again
1245   ;;
1246   (yas--add-template table template)
1247   ;; Take care of the menu
1248   ;;
1249   (yas--update-template-menu table template)
1250   template)
1251
1252 (defun yas--update-template-menu (table template)
1253   "Update every menu-related for TEMPLATE."
1254   (let ((menu-binding-pair (yas--template-menu-binding-pair-get-create template))
1255         (key (yas--template-key template))
1256         (keybinding (yas--template-keybinding template)))
1257     ;; The snippet might have changed name or keys, so update
1258     ;; user-visible strings
1259     ;;
1260     (unless (eq (cdr menu-binding-pair) :none)
1261       ;; the menu item name
1262       ;;
1263       (setf (cl-cadar menu-binding-pair) (yas--template-name template))
1264       ;; the :keys information (also visible to the user)
1265       (setf (cl-getf (cdr (car menu-binding-pair)) :keys)
1266             (or (and keybinding (key-description keybinding))
1267                 (and key (concat key yas-trigger-symbol))))))
1268   (unless (yas--template-menu-managed-by-yas-define-menu template)
1269     (let ((menu-keymap
1270            (yas--menu-keymap-get-create (yas--table-mode table)
1271                                         (mapcar #'yas--table-mode
1272                                                 (yas--table-parents table))))
1273           (group (yas--template-group template)))
1274       ;; Remove from menu keymap
1275       ;;
1276       (cl-assert menu-keymap)
1277       (yas--delete-from-keymap menu-keymap (yas--template-uuid template))
1278
1279       ;; Add necessary subgroups as necessary.
1280       ;;
1281       (dolist (subgroup group)
1282         (let ((subgroup-keymap (lookup-key menu-keymap (vector (make-symbol subgroup)))))
1283           (unless (and subgroup-keymap
1284                        (keymapp subgroup-keymap))
1285             (setq subgroup-keymap (make-sparse-keymap))
1286             (define-key menu-keymap (vector (make-symbol subgroup))
1287               `(menu-item ,subgroup ,subgroup-keymap)))
1288           (setq menu-keymap subgroup-keymap)))
1289
1290       ;; Add this entry to the keymap
1291       ;;
1292       (define-key menu-keymap
1293         (vector (make-symbol (yas--template-uuid template)))
1294         (car (yas--template-menu-binding-pair template))))))
1295
1296 (defun yas--namehash-templates-alist (namehash)
1297   "Return NAMEHASH as an alist."
1298   (let (alist)
1299     (maphash #'(lambda (k v)
1300                  (push (cons k v) alist))
1301              namehash)
1302     alist))
1303
1304 (defun yas--fetch (table key)
1305   "Fetch templates in TABLE by KEY.
1306
1307 Return a list of cons (NAME . TEMPLATE) where NAME is a
1308 string and TEMPLATE is a `yas--template' structure."
1309   (let* ((keyhash (yas--table-hash table))
1310          (namehash (and keyhash (gethash key keyhash))))
1311     (when namehash
1312       (yas--filter-templates-by-condition (yas--namehash-templates-alist namehash)))))
1313
1314
1315 ;;; Filtering/condition logic
1316
1317 (defun yas--eval-condition (condition)
1318   (condition-case err
1319       (save-excursion
1320         (save-restriction
1321           (save-match-data
1322             (eval condition))))
1323     (error (progn
1324              (yas--message 1 "Error in condition evaluation: %s" (error-message-string err))
1325              nil))))
1326
1327
1328 (defun yas--filter-templates-by-condition (templates)
1329   "Filter the templates using the applicable condition.
1330
1331 TEMPLATES is a list of cons (NAME . TEMPLATE) where NAME is a
1332 string and TEMPLATE is a `yas--template' structure.
1333
1334 This function implements the rules described in
1335 `yas-buffer-local-condition'.  See that variables documentation."
1336   (let ((requirement (yas--require-template-specific-condition-p)))
1337     (if (eq requirement 'always)
1338         templates
1339       (cl-remove-if-not (lambda (pair)
1340                           (yas--template-can-expand-p
1341                            (yas--template-condition (cdr pair)) requirement))
1342                         templates))))
1343
1344 (defun yas--require-template-specific-condition-p ()
1345   "Decide if this buffer requests/requires snippet-specific
1346 conditions to filter out potential expansions."
1347   (if (eq 'always yas-buffer-local-condition)
1348       'always
1349     (let ((local-condition (or (and (consp yas-buffer-local-condition)
1350                                     (yas--eval-condition yas-buffer-local-condition))
1351                                yas-buffer-local-condition)))
1352       (when local-condition
1353         (if (eq local-condition t)
1354             t
1355           (and (consp local-condition)
1356                (eq 'require-snippet-condition (car local-condition))
1357                (symbolp (cdr local-condition))
1358                (cdr local-condition)))))))
1359
1360 (defun yas--template-can-expand-p (condition requirement)
1361   "Evaluate CONDITION and REQUIREMENT and return a boolean."
1362   (let* ((result (or (null condition)
1363                      (yas--eval-condition condition))))
1364     (cond ((eq requirement t)
1365            result)
1366           (t
1367            (eq requirement result)))))
1368
1369 (defun yas--table-templates (table)
1370   (when table
1371     (let ((acc (list)))
1372       (maphash #'(lambda (_key namehash)
1373                    (maphash #'(lambda (name template)
1374                                 (push (cons name template) acc))
1375                             namehash))
1376                (yas--table-hash table))
1377       (yas--filter-templates-by-condition acc))))
1378
1379 (defun yas--templates-for-key-at-point ()
1380   "Find `yas--template' objects for any trigger keys preceding point.
1381 Returns (TEMPLATES START END). This function respects
1382 `yas-key-syntaxes', which see."
1383   (save-excursion
1384     (let ((original (point))
1385           (methods yas-key-syntaxes)
1386           (templates)
1387           (method))
1388       (while (and methods
1389                   (not templates))
1390         (unless (eq method (car methods))
1391           ;; TRICKY: `eq'-ness test means we can only be here if
1392           ;; `method' is a function that returned `again', and hence
1393           ;; don't revert back to original position as per
1394           ;; `yas-key-syntaxes'.
1395           (goto-char original))
1396         (setq method (car methods))
1397         (cond ((stringp method)
1398                (skip-syntax-backward method)
1399                (setq methods (cdr methods)))
1400               ((functionp method)
1401                (unless (eq (funcall method original)
1402                            'again)
1403                  (setq methods (cdr methods))))
1404               (t
1405                (setq methods (cdr methods))
1406                (yas--warning "Invalid element `%s' in `yas-key-syntaxes'" method)))
1407         (let ((possible-key (buffer-substring-no-properties (point) original)))
1408           (save-excursion
1409             (goto-char original)
1410             (setq templates
1411                   (cl-mapcan (lambda (table)
1412                                (yas--fetch table possible-key))
1413                              (yas--get-snippet-tables))))))
1414       (when templates
1415         (list templates (point) original)))))
1416
1417 (defun yas--table-all-keys (table)
1418   "Get trigger keys of all active snippets in TABLE."
1419   (let ((acc))
1420     (maphash #'(lambda (key namehash)
1421                  (when (yas--filter-templates-by-condition (yas--namehash-templates-alist namehash))
1422                    (push key acc)))
1423              (yas--table-hash table))
1424     acc))
1425
1426 (defun yas--table-mode (table)
1427   (intern (yas--table-name table)))
1428
1429
1430 ;;; Internal functions and macros:
1431
1432 (defun yas--remove-misc-free-from-undo (old-undo-list)
1433   "Tries to work around Emacs Bug#30931.
1434 Helper function for `yas--save-restriction-and-widen'."
1435   ;; If Bug#30931 is unfixed, we get (#<Lisp_Misc_Free> . INTEGER)
1436   ;; entries in the undo list.  If we call `type-of' on the
1437   ;; Lisp_Misc_Free object then Emacs aborts, so try to find it by
1438   ;; checking that its type is none of the expected ones.
1439   (when (consp buffer-undo-list)
1440     (let* ((prev buffer-undo-list)
1441            (undo-list prev))
1442       (while (and (consp undo-list)
1443                   ;; Only check new entries.
1444                   (not (eq undo-list old-undo-list)))
1445         (let ((entry (pop undo-list)))
1446           (when (consp entry)
1447             (let ((head (car entry)))
1448               (unless (or (stringp head)
1449                           (markerp head)
1450                           (integerp head)
1451                           (symbolp head)
1452                           (not (integerp (cdr entry))))
1453                 ;; (message "removing misc free %S" entry)
1454                 (setcdr prev undo-list)))))
1455         (setq prev undo-list)))))
1456
1457 (defmacro yas--save-restriction-and-widen (&rest body)
1458   "Equivalent to (save-restriction (widen) BODY).
1459 Also tries to work around Emacs Bug#30931."
1460   (declare (debug (body)) (indent 0))
1461   ;; Disable garbage collection, since it could cause an abort.
1462   `(let ((gc-cons-threshold most-positive-fixnum)
1463          (old-undo-list buffer-undo-list))
1464      (prog1 (save-restriction
1465               (widen)
1466               ,@body)
1467        (yas--remove-misc-free-from-undo old-undo-list))))
1468
1469 (defun yas--eval-for-string (form)
1470   "Evaluate FORM and convert the result to string."
1471   (let ((debug-on-error (and (not (memq yas-good-grace '(t inline)))
1472                              debug-on-error)))
1473     (condition-case oops
1474         (save-excursion
1475           (yas--save-restriction-and-widen
1476             (save-match-data
1477               (let ((result (eval form)))
1478                 (when result
1479                   (format "%s" result))))))
1480       ((debug error) (cdr oops)))))
1481
1482 (defun yas--eval-for-effect (form)
1483   (yas--safely-call-fun (apply-partially #'eval form)))
1484
1485 (defun yas--read-lisp (string &optional nil-on-error)
1486   "Read STRING as a elisp expression and return it.
1487
1488 In case STRING in an invalid expression and NIL-ON-ERROR is nil,
1489 return an expression that when evaluated will issue an error."
1490   (condition-case err
1491       (read string)
1492     (error (and (not nil-on-error)
1493                 `(error (error-message-string ,err))))))
1494
1495 (defun yas--read-keybinding (keybinding)
1496   "Read KEYBINDING as a snippet keybinding, return a vector."
1497   (when (and keybinding
1498              (not (string-match "keybinding" keybinding)))
1499     (condition-case err
1500         (let ((res (or (and (string-match "^\\[.*\\]$" keybinding)
1501                             (read keybinding))
1502                        (read-kbd-macro keybinding 'need-vector))))
1503           res)
1504       (error
1505        (yas--message 2 "warning: keybinding \"%s\" invalid since %s."
1506                 keybinding (error-message-string err))
1507        nil))))
1508
1509 (defun yas--table-get-create (mode)
1510   "Get or create the snippet table corresponding to MODE."
1511   (let ((table (gethash mode
1512                         yas--tables)))
1513     (unless table
1514       (setq table (yas--make-snippet-table (symbol-name mode)))
1515       (puthash mode table yas--tables)
1516       (push (cons (intern (format "yas--direct-%s" mode))
1517                   (yas--table-direct-keymap table))
1518             yas--direct-keymaps))
1519     table))
1520
1521 (defun yas--get-snippet-tables (&optional mode)
1522   "Get snippet tables for MODE.
1523
1524 MODE defaults to the current buffer's `major-mode'.
1525
1526 Return a list of `yas--table' objects.  The list of modes to
1527 consider is returned by `yas--modes-to-activate'"
1528   (remove nil
1529           (mapcar #'(lambda (name)
1530                       (gethash name yas--tables))
1531                   (yas--modes-to-activate mode))))
1532
1533 (defun yas--menu-keymap-get-create (mode &optional parents)
1534   "Get or create the menu keymap for MODE and its PARENTS.
1535
1536 This may very well create a plethora of menu keymaps and arrange
1537 them all in `yas--menu-table'"
1538   (let* ((menu-keymap (or (gethash mode yas--menu-table)
1539                           (puthash mode (make-sparse-keymap) yas--menu-table))))
1540     (mapc #'yas--menu-keymap-get-create parents)
1541     (define-key yas--minor-mode-menu (vector mode)
1542         `(menu-item ,(symbol-name mode) ,menu-keymap
1543                     :visible (yas--show-menu-p ',mode)))
1544     menu-keymap))
1545
1546
1547 ;;; Template-related and snippet loading functions
1548
1549 (defun yas--parse-template (&optional file)
1550   "Parse the template in the current buffer.
1551
1552 Optional FILE is the absolute file name of the file being
1553 parsed.
1554
1555 Optional GROUP is the group where the template is to go,
1556 otherwise we attempt to calculate it from FILE.
1557
1558 Return a snippet-definition, i.e. a list
1559
1560  (KEY TEMPLATE NAME CONDITION GROUP VARS LOAD-FILE KEYBINDING UUID)
1561
1562 If the buffer contains a line of \"# --\" then the contents above
1563 this line are ignored. Directives can set most of these with the syntax:
1564
1565 # directive-name : directive-value
1566
1567 Here's a list of currently recognized directives:
1568
1569  * type
1570  * name
1571  * contributor
1572  * condition
1573  * group
1574  * key
1575  * expand-env
1576  * binding
1577  * uuid"
1578   (goto-char (point-min))
1579   (let* ((type 'snippet)
1580          (name (and file
1581                     (file-name-nondirectory file)))
1582          (key nil)
1583          template
1584          bound
1585          condition
1586          (group (and file
1587                      (yas--calculate-group file)))
1588          expand-env
1589          binding
1590          uuid)
1591     (if (re-search-forward "^# --\\s-*\n" nil t)
1592         (progn (setq template
1593                      (buffer-substring-no-properties (point)
1594                                                      (point-max)))
1595                (setq bound (point))
1596                (goto-char (point-min))
1597                (while (re-search-forward "^# *\\([^ ]+?\\) *: *\\(.*?\\)[[:space:]]*$" bound t)
1598                  (when (string= "uuid" (match-string-no-properties 1))
1599                    (setq uuid (match-string-no-properties 2)))
1600                  (when (string= "type" (match-string-no-properties 1))
1601                    (setq type (if (string= "command" (match-string-no-properties 2))
1602                                   'command
1603                                 'snippet)))
1604                  (when (string= "key" (match-string-no-properties 1))
1605                    (setq key (match-string-no-properties 2)))
1606                  (when (string= "name" (match-string-no-properties 1))
1607                    (setq name (match-string-no-properties 2)))
1608                  (when (string= "condition" (match-string-no-properties 1))
1609                    (setq condition (yas--read-lisp (match-string-no-properties 2))))
1610                  (when (string= "group" (match-string-no-properties 1))
1611                    (setq group (match-string-no-properties 2)))
1612                  (when (string= "expand-env" (match-string-no-properties 1))
1613                    (setq expand-env (yas--read-lisp (match-string-no-properties 2)
1614                                                    'nil-on-error)))
1615                  (when (string= "binding" (match-string-no-properties 1))
1616                    (setq binding (match-string-no-properties 2)))))
1617       (setq template
1618             (buffer-substring-no-properties (point-min) (point-max))))
1619     (unless (or key binding)
1620       (setq key (and file (file-name-nondirectory file))))
1621     (when (eq type 'command)
1622       (setq template (yas--read-lisp (concat "(progn" template ")"))))
1623     (when group
1624       (setq group (split-string group "\\.")))
1625     (list key template name condition group expand-env file binding uuid)))
1626
1627 (defun yas--calculate-group (file)
1628   "Calculate the group for snippet file path FILE."
1629   (let* ((dominating-dir (locate-dominating-file file
1630                                                  ".yas-make-groups"))
1631          (extra-path (and dominating-dir
1632                           (file-relative-name file dominating-dir)))
1633          (extra-dir (and extra-path
1634                          (file-name-directory extra-path)))
1635          (group (and extra-dir
1636                      (replace-regexp-in-string "/"
1637                                                "."
1638                                                (directory-file-name extra-dir)))))
1639     group))
1640
1641 (defun yas--subdirs (directory &optional filep)
1642   "Return subdirs or files of DIRECTORY according to FILEP."
1643   (cl-remove-if (lambda (file)
1644                   (or (string-match "\\`\\."
1645                                     (file-name-nondirectory file))
1646                       (string-match "\\`#.*#\\'"
1647                                     (file-name-nondirectory file))
1648                       (string-match "~\\'"
1649                                     (file-name-nondirectory file))
1650                       (if filep
1651                           (file-directory-p file)
1652                         (not (file-directory-p file)))))
1653                 (directory-files directory t)))
1654
1655 (defun yas--make-menu-binding (template)
1656   (let ((mode (yas--table-mode (yas--template-table template))))
1657     `(lambda () (interactive) (yas--expand-or-visit-from-menu ',mode ,(yas--template-uuid template)))))
1658
1659 (defun yas--expand-or-visit-from-menu (mode uuid)
1660   (let* ((table (yas--table-get-create mode))
1661          (yas--current-template (and table
1662                                     (gethash uuid (yas--table-uuidhash table)))))
1663     (when yas--current-template
1664       (if yas-visit-from-menu
1665           (yas--visit-snippet-file-1 yas--current-template)
1666         (let ((where (if (region-active-p)
1667                          (cons (region-beginning) (region-end))
1668                        (cons (point) (point)))))
1669           (yas-expand-snippet (yas--template-content yas--current-template)
1670                               (car where)
1671                               (cdr where)
1672                               (yas--template-expand-env yas--current-template)))))))
1673
1674 (defun yas--key-from-desc (text)
1675   "Return a yasnippet key from a description string TEXT."
1676   (replace-regexp-in-string "\\(\\w+\\).*" "\\1" text))
1677
1678
1679 ;;; Popping up for keys and templates
1680
1681 (defun yas--prompt-for-template (templates &optional prompt)
1682   "Interactively choose a template from the list TEMPLATES.
1683
1684 TEMPLATES is a list of `yas--template'.
1685
1686 Optional PROMPT sets the prompt to use."
1687   (when templates
1688     (setq templates
1689           (sort templates #'(lambda (t1 t2)
1690                               (< (length (yas--template-name t1))
1691                                  (length (yas--template-name t2))))))
1692     (cl-some (lambda (fn)
1693                (funcall fn (or prompt "Choose a snippet: ")
1694                         templates
1695                         #'yas--template-name))
1696              yas-prompt-functions)))
1697
1698 (defun yas--prompt-for-keys (keys &optional prompt)
1699   "Interactively choose a template key from the list KEYS.
1700
1701 Optional PROMPT sets the prompt to use."
1702   (when keys
1703     (cl-some (lambda (fn)
1704                (funcall fn (or prompt "Choose a snippet key: ") keys))
1705              yas-prompt-functions)))
1706
1707 (defun yas--prompt-for-table (tables &optional prompt)
1708   "Interactively choose a table from the list TABLES.
1709
1710 Optional PROMPT sets the prompt to use."
1711   (when tables
1712     (cl-some (lambda (fn)
1713                (funcall fn (or prompt "Choose a snippet table: ")
1714                         tables
1715                         #'yas--table-name))
1716              yas-prompt-functions)))
1717
1718 (defun yas-x-prompt (prompt choices &optional display-fn)
1719   "Display choices in a x-window prompt."
1720   (when (and window-system choices)
1721     ;; Let window position be recalculated to ensure that
1722     ;; `posn-at-point' returns non-nil.
1723     (redisplay)
1724     (or
1725      (x-popup-menu
1726       (if (fboundp 'posn-at-point)
1727           (let ((x-y (posn-x-y (posn-at-point (point)))))
1728             (list (list (+ (car x-y) 10)
1729                         (+ (cdr x-y) 20))
1730                   (selected-window)))
1731         t)
1732       `(,prompt ("title"
1733                  ,@(cl-mapcar (lambda (c d) `(,(concat "   " d) . ,c))
1734                               choices
1735                               (if display-fn (mapcar display-fn choices)
1736                                 choices)))))
1737      (keyboard-quit))))
1738
1739 (defun yas-maybe-ido-prompt (prompt choices &optional display-fn)
1740   (when (bound-and-true-p ido-mode)
1741     (yas-ido-prompt prompt choices display-fn)))
1742
1743 (defun yas-ido-prompt (prompt choices &optional display-fn)
1744   (require 'ido)
1745   (yas-completing-prompt prompt choices display-fn #'ido-completing-read))
1746
1747 (defun yas-dropdown-prompt (_prompt choices &optional display-fn)
1748   (when (fboundp 'dropdown-list)
1749     (let* ((formatted-choices
1750             (if display-fn (mapcar display-fn choices) choices))
1751            (n (dropdown-list formatted-choices)))
1752       (if n (nth n choices)
1753         (keyboard-quit)))))
1754
1755 (defun yas-completing-prompt (prompt choices &optional display-fn completion-fn)
1756   (let* ((formatted-choices
1757           (if display-fn (mapcar display-fn choices) choices))
1758          (chosen (funcall (or completion-fn #'completing-read)
1759                           prompt formatted-choices
1760                           nil 'require-match nil nil)))
1761     (if (eq choices formatted-choices)
1762         chosen
1763       (nth (or (cl-position chosen formatted-choices :test #'string=) 0)
1764            choices))))
1765
1766 (defun yas-no-prompt (_prompt choices &optional _display-fn)
1767   (cl-first choices))
1768
1769
1770 ;;; Defining snippets
1771 ;; This consists of creating and registering `yas--template' objects in the
1772 ;; correct tables.
1773 ;;
1774
1775 (defvar yas--creating-compiled-snippets nil)
1776
1777 (defun yas--define-snippets-1 (snippet snippet-table)
1778   "Helper for `yas-define-snippets'."
1779   ;; Update the appropriate table.  Also takes care of adding the
1780   ;; key indicators in the templates menu entry, if any.
1781   (yas--update-template
1782    snippet-table (apply #'yas--define-snippets-2 snippet-table snippet)))
1783
1784 (defun yas-define-snippets (mode snippets)
1785   "Define SNIPPETS for MODE.
1786
1787 SNIPPETS is a list of snippet definitions, each taking the
1788 following form
1789
1790  (KEY TEMPLATE NAME CONDITION GROUP EXPAND-ENV LOAD-FILE KEYBINDING UUID SAVE-FILE)
1791
1792 Within these, only KEY and TEMPLATE are actually mandatory.
1793
1794 TEMPLATE might be a Lisp form or a string, depending on whether
1795 this is a snippet or a snippet-command.
1796
1797 CONDITION, EXPAND-ENV and KEYBINDING are Lisp forms, they have
1798 been `yas--read-lisp'-ed and will eventually be
1799 `yas--eval-for-string'-ed.
1800
1801 The remaining elements are strings.
1802
1803 FILE is probably of very little use if you're programatically
1804 defining snippets.
1805
1806 UUID is the snippet's \"unique-id\". Loading a second snippet
1807 file with the same uuid would replace the previous snippet.
1808
1809 You can use `yas--parse-template' to return such lists based on
1810 the current buffers contents."
1811   (if yas--creating-compiled-snippets
1812       (let ((print-length nil))
1813         (insert ";;; Snippet definitions:\n;;;\n")
1814         (dolist (snippet snippets)
1815           ;; Fill in missing elements with nil.
1816           (setq snippet (append snippet (make-list (- 10 (length snippet)) nil)))
1817           ;; Move LOAD-FILE to SAVE-FILE because we will load from the
1818           ;; compiled file, not LOAD-FILE.
1819           (let ((load-file (nth 6 snippet)))
1820             (setcar (nthcdr 6 snippet) nil)
1821             (setcar (nthcdr 9 snippet) load-file)))
1822         (insert (pp-to-string
1823                  `(yas-define-snippets ',mode ',snippets)))
1824         (insert "\n\n"))
1825     ;; Normal case.
1826     (let ((snippet-table (yas--table-get-create mode))
1827           (template nil))
1828       (dolist (snippet snippets)
1829         (setq template (yas--define-snippets-1 snippet
1830                                                snippet-table)))
1831       template)))
1832
1833
1834 ;;; Loading snippets from files
1835
1836 (defun yas--template-get-file (template)
1837   "Return TEMPLATE's LOAD-FILE or SAVE-FILE."
1838   (or (yas--template-load-file template)
1839       (let ((file (yas--template-save-file template)))
1840         (when file
1841           (yas--message 3 "%s has no load file, using save file, %s, instead."
1842                         (yas--template-name template) file))
1843         file)))
1844
1845 (defun yas--load-yas-setup-file (file)
1846   (if (not yas--creating-compiled-snippets)
1847       ;; Normal case.
1848       (load file 'noerror (<= yas-verbosity 4))
1849     (let ((elfile (concat file ".el")))
1850       (when (file-exists-p elfile)
1851         (insert ";;; contents of the .yas-setup.el support file:\n;;;\n")
1852         (insert-file-contents elfile)
1853         (goto-char (point-max))))))
1854
1855 (defun yas--define-parents (mode parents)
1856   "Add PARENTS to the list of MODE's parents."
1857   (puthash mode (cl-remove-duplicates
1858                  (append parents
1859                          (gethash mode yas--parents)))
1860            yas--parents))
1861
1862 (defun yas-load-directory (top-level-dir &optional use-jit interactive)
1863   "Load snippets in directory hierarchy TOP-LEVEL-DIR.
1864
1865 Below TOP-LEVEL-DIR each directory should be a mode name.
1866
1867 With prefix argument USE-JIT do jit-loading of snippets."
1868   (interactive
1869    (list (read-directory-name "Select the root directory: " nil nil t)
1870          current-prefix-arg t))
1871   (unless yas-snippet-dirs
1872     (setq yas-snippet-dirs top-level-dir))
1873   (let ((impatient-buffers))
1874     (dolist (dir (yas--subdirs top-level-dir))
1875       (let* ((major-mode-and-parents (yas--compute-major-mode-and-parents
1876                                       (concat dir "/dummy")))
1877              (mode-sym (car major-mode-and-parents))
1878              (parents (cdr major-mode-and-parents)))
1879         ;; Attention: The parents and the menus are already defined
1880         ;; here, even if the snippets are later jit-loaded.
1881         ;;
1882         ;; * We need to know the parents at this point since entering a
1883         ;;   given mode should jit load for its parents
1884         ;;   immediately. This could be reviewed, the parents could be
1885         ;;   discovered just-in-time-as well
1886         ;;
1887         ;; * We need to create the menus here to support the `full'
1888         ;;   option to `yas-use-menu' (all known snippet menus are shown to the user)
1889         ;;
1890         (yas--define-parents mode-sym parents)
1891         (yas--menu-keymap-get-create mode-sym)
1892         (let ((fun (apply-partially #'yas--load-directory-1 dir mode-sym)))
1893           (if use-jit
1894               (yas--schedule-jit mode-sym fun)
1895             (funcall fun)))
1896         ;; Look for buffers that are already in `mode-sym', and so
1897         ;; need the new snippets immediately...
1898         ;;
1899         (when use-jit
1900           (cl-loop for buffer in (buffer-list)
1901                    do (with-current-buffer buffer
1902                         (when (eq major-mode mode-sym)
1903                           (yas--message 4 "Discovered there was already %s in %s" buffer mode-sym)
1904                           (push buffer impatient-buffers)))))))
1905     ;; ...after TOP-LEVEL-DIR has been completely loaded, call
1906     ;; `yas--load-pending-jits' in these impatient buffers.
1907     ;;
1908     (cl-loop for buffer in impatient-buffers
1909              do (with-current-buffer buffer (yas--load-pending-jits))))
1910   (when interactive
1911     (yas--message 3 "Loaded snippets from %s." top-level-dir)))
1912
1913 (defun yas--load-directory-1 (directory mode-sym)
1914   "Recursively load snippet templates from DIRECTORY."
1915   (if yas--creating-compiled-snippets
1916       (let ((output-file (expand-file-name ".yas-compiled-snippets.el"
1917                                            directory)))
1918         (with-temp-file output-file
1919           (insert (format ";;; Compiled snippets and support files for `%s'\n"
1920                           mode-sym))
1921           (yas--load-directory-2 directory mode-sym)
1922           (insert (format ";;; Do not edit! File generated at %s\n"
1923                           (current-time-string)))))
1924     ;; Normal case.
1925     (unless (file-exists-p (expand-file-name ".yas-skip" directory))
1926       (unless (and (load (expand-file-name ".yas-compiled-snippets" directory) 'noerror (<= yas-verbosity 3))
1927                    (progn (yas--message 4 "Loaded compiled snippets from %s" directory) t))
1928         (yas--message 4 "Loading snippet files from %s" directory)
1929         (yas--load-directory-2 directory mode-sym)))))
1930
1931 (defun yas--load-directory-2 (directory mode-sym)
1932   ;; Load .yas-setup.el files wherever we find them
1933   ;;
1934   (yas--load-yas-setup-file (expand-file-name ".yas-setup" directory))
1935   (let* ((default-directory directory)
1936          (snippet-defs nil))
1937     ;; load the snippet files
1938     ;;
1939     (with-temp-buffer
1940       (dolist (file (yas--subdirs directory 'no-subdirs-just-files))
1941         (when (file-readable-p file)
1942           ;; Erase the buffer instead of passing non-nil REPLACE to
1943           ;; `insert-file-contents' (avoids Emacs bug #23659).
1944           (erase-buffer)
1945           (insert-file-contents file)
1946           (push (yas--parse-template file)
1947                 snippet-defs))))
1948     (when snippet-defs
1949       (yas-define-snippets mode-sym
1950                            snippet-defs))
1951     ;; now recurse to a lower level
1952     ;;
1953     (dolist (subdir (yas--subdirs directory))
1954       (yas--load-directory-2 subdir
1955                             mode-sym))))
1956
1957 (defun yas--load-snippet-dirs (&optional nojit)
1958   "Reload the directories listed in `yas-snippet-dirs' or
1959 prompt the user to select one."
1960   (let (errors)
1961     (if (null yas-snippet-dirs)
1962         (call-interactively 'yas-load-directory)
1963       (when (member yas--default-user-snippets-dir yas-snippet-dirs)
1964         (make-directory yas--default-user-snippets-dir t))
1965       (dolist (directory (reverse (yas-snippet-dirs)))
1966         (cond ((file-directory-p directory)
1967                (yas-load-directory directory (not nojit))
1968                (if nojit
1969                    (yas--message 4 "Loaded %s" directory)
1970                  (yas--message 4 "Prepared just-in-time loading for %s" directory)))
1971               (t
1972                (push (yas--message 1 "Check your `yas-snippet-dirs': %s is not a directory" directory) errors)))))
1973     errors))
1974
1975 (defun yas-reload-all (&optional no-jit interactive)
1976   "Reload all snippets and rebuild the YASnippet menu.
1977
1978 When NO-JIT is non-nil force immediate reload of all known
1979 snippets under `yas-snippet-dirs', otherwise use just-in-time
1980 loading.
1981
1982 When called interactively, use just-in-time loading when given a
1983 prefix argument."
1984   (interactive (list (not current-prefix-arg) t))
1985   (catch 'abort
1986     (let ((errors)
1987           (snippet-editing-buffers
1988            (cl-remove-if-not (lambda (buffer)
1989                                (with-current-buffer buffer
1990                                  yas--editing-template))
1991                              (buffer-list))))
1992       ;; Warn if there are buffers visiting snippets, since reloading will break
1993       ;; any on-line editing of those buffers.
1994       ;;
1995       (when snippet-editing-buffers
1996           (if interactive
1997               (if (y-or-n-p "Some buffers editing live snippets, close them and proceed with reload? ")
1998                   (mapc #'kill-buffer snippet-editing-buffers)
1999                 (yas--message 1 "Aborted reload...")
2000                 (throw 'abort nil))
2001             ;; in a non-interactive use, at least set
2002             ;; `yas--editing-template' to nil, make it guess it next time around
2003             (mapc #'(lambda (buffer)
2004                       (with-current-buffer buffer
2005                         (kill-local-variable 'yas--editing-template)))
2006                   (buffer-list))))
2007
2008       ;; Empty all snippet tables and parenting info
2009       ;;
2010       (setq yas--tables (make-hash-table))
2011       (setq yas--parents (make-hash-table))
2012
2013       ;; Before killing `yas--menu-table' use its keys to cleanup the
2014       ;; mode menu parts of `yas--minor-mode-menu' (thus also cleaning
2015       ;; up `yas-minor-mode-map', which points to it)
2016       ;;
2017       (maphash #'(lambda (menu-symbol _keymap)
2018                    (define-key yas--minor-mode-menu (vector menu-symbol) nil))
2019                yas--menu-table)
2020       ;; Now empty `yas--menu-table' as well
2021       (setq yas--menu-table (make-hash-table))
2022
2023       ;; Cancel all pending 'yas--scheduled-jit-loads'
2024       ;;
2025       (setq yas--scheduled-jit-loads (make-hash-table))
2026
2027       ;; Reload the directories listed in `yas-snippet-dirs' or prompt
2028       ;; the user to select one.
2029       ;;
2030       (setq errors (yas--load-snippet-dirs no-jit))
2031       ;; Reload the direct keybindings
2032       ;;
2033       (yas-direct-keymaps-reload)
2034
2035       (run-hooks 'yas-after-reload-hook)
2036       (let ((no-snippets
2037              (cl-every (lambda (table) (= (hash-table-count table) 0))
2038                        (list yas--scheduled-jit-loads
2039                              yas--parents yas--tables))))
2040         (yas--message (if (or no-snippets errors) 2 3)
2041                       (if no-jit "Snippets loaded %s."
2042                         "Prepared just-in-time loading of snippets %s.")
2043                       (cond (errors
2044                              "with some errors.  Check *Messages*")
2045                             (no-snippets
2046                              "(but no snippets found)")
2047                             (t
2048                              "successfully")))))))
2049
2050 (defvar yas-after-reload-hook nil
2051   "Hooks run after `yas-reload-all'.")
2052
2053 (defun yas--load-pending-jits ()
2054   (dolist (mode (yas--modes-to-activate))
2055     (let ((funs (reverse (gethash mode yas--scheduled-jit-loads))))
2056       ;; must reverse to maintain coherence with `yas-snippet-dirs'
2057       (dolist (fun funs)
2058         (yas--message 4 "Loading for `%s', just-in-time: %s!" mode fun)
2059         (funcall fun))
2060       (remhash mode yas--scheduled-jit-loads))))
2061
2062 (defun yas-escape-text (text)
2063   "Escape TEXT for snippet."
2064   (when text
2065     (replace-regexp-in-string "[\\$]" "\\\\\\&" text)))
2066
2067
2068 ;;; Snippet compilation function
2069
2070 (defun yas-compile-directory (top-level-dir)
2071   "Create .yas-compiled-snippets.el files under subdirs of TOP-LEVEL-DIR.
2072
2073 This works by stubbing a few functions, then calling
2074 `yas-load-directory'."
2075   (interactive "DTop level snippet directory?")
2076   (let ((yas--creating-compiled-snippets t))
2077     (yas-load-directory top-level-dir nil)))
2078
2079 (defun yas-recompile-all ()
2080   "Compile every dir in `yas-snippet-dirs'."
2081   (interactive)
2082   (mapc #'yas-compile-directory (yas-snippet-dirs)))
2083
2084
2085 ;;; JIT loading
2086 ;;;
2087
2088 (defvar yas--scheduled-jit-loads (make-hash-table)
2089   "Alist of mode-symbols to forms to be evaled when `yas-minor-mode' kicks in.")
2090
2091 (defun yas--schedule-jit (mode fun)
2092   (push fun (gethash mode yas--scheduled-jit-loads)))
2093
2094
2095
2096 ;;; Some user level functions
2097
2098 (defun yas-about ()
2099   (interactive)
2100   (message "yasnippet (version %s) -- pluskid/joaotavora/npostavs"
2101            (or (ignore-errors (car (let ((default-directory yas--loaddir))
2102                                      (process-lines "git" "describe"
2103                                                     "--tags" "--dirty"))))
2104                (when (and (featurep 'package)
2105                           (fboundp 'package-desc-version)
2106                           (fboundp 'package-version-join))
2107                  (defvar package-alist)
2108                  (ignore-errors
2109                    (let* ((yas-pkg (cdr (assq 'yasnippet package-alist)))
2110                           (version (package-version-join
2111                                     (package-desc-version (car yas-pkg)))))
2112                      ;; Special case for MELPA's bogus version numbers.
2113                      (if (string-match "\\`20..[01][0-9][0-3][0-9][.][0-9]\\{3,4\\}\\'"
2114                                        version)
2115                          (concat yas--version "-snapshot" version)
2116                        version))))
2117                yas--version)))
2118
2119
2120 ;;; Apropos snippet menu:
2121 ;;
2122 ;; The snippet menu keymaps are stored by mode in hash table called
2123 ;; `yas--menu-table'. They are linked to the main menu in
2124 ;; `yas--menu-keymap-get-create' and are initially created empty,
2125 ;; reflecting the table hierarchy.
2126 ;;
2127 ;; They can be populated in two mutually exclusive ways: (1) by
2128 ;; reading `yas--template-group', which in turn is populated by the "#
2129 ;; group:" directives of the snippets or the ".yas-make-groups" file
2130 ;; or (2) by using a separate `yas-define-menu' call, which declares a
2131 ;; menu structure based on snippets uuids.
2132 ;;
2133 ;; Both situations are handled in `yas--update-template-menu', which
2134 ;; uses the predicate `yas--template-menu-managed-by-yas-define-menu'
2135 ;; that can tell between the two situations.
2136 ;;
2137 ;; Note:
2138 ;;
2139 ;; * if `yas-define-menu' is used it must run before
2140 ;;   `yas-define-snippets' and the UUIDS must match, otherwise we get
2141 ;;   duplicate entries. The `yas--template' objects are created in
2142 ;;   `yas-define-menu', holding nothing but the menu entry,
2143 ;;   represented by a pair of ((menu-item NAME :keys KEYS) TYPE) and
2144 ;;   stored in `yas--template-menu-binding-pair'.  The (menu-item ...)
2145 ;;   part is then stored in the menu keymap itself which make the item
2146 ;;   appear to the user.  These limitations could probably be revised.
2147 ;;
2148 ;; * The `yas--template-perm-group' slot is only used in
2149 ;;   `yas-describe-tables'.
2150 ;;
2151 (defun yas--template-menu-binding-pair-get-create (template &optional type)
2152   "Get TEMPLATE's menu binding or assign it a new one.
2153
2154 TYPE may be `:stay', signaling this menu binding should be
2155 static in the menu."
2156   (or (yas--template-menu-binding-pair template)
2157       (let (;; (key (yas--template-key template))
2158             ;; (keybinding (yas--template-keybinding template))
2159             )
2160         (setf (yas--template-menu-binding-pair template)
2161               (cons `(menu-item ,(or (yas--template-name template)
2162                                      (yas--template-uuid template))
2163                                 ,(yas--make-menu-binding template)
2164                                 :keys ,nil)
2165                     type)))))
2166 (defun yas--template-menu-managed-by-yas-define-menu (template)
2167   "Non-nil if TEMPLATE's menu entry was included in a `yas-define-menu' call."
2168   (cdr (yas--template-menu-binding-pair template)))
2169
2170
2171 (defun yas--show-menu-p (mode)
2172   (cond ((eq yas-use-menu 'abbreviate)
2173          (cl-find mode
2174                   (mapcar #'yas--table-mode
2175                           (yas--get-snippet-tables))))
2176         (yas-use-menu t)))
2177
2178 (defun yas--delete-from-keymap (keymap uuid)
2179   "Recursively delete items with UUID from KEYMAP and its submenus."
2180
2181   ;; XXX: This used to skip any submenus named \"parent mode\"
2182   ;;
2183   ;; First of all, recursively enter submenus, i.e. the tree is
2184   ;; searched depth first so that stale submenus can be found in the
2185   ;; higher passes.
2186   ;;
2187   (mapc #'(lambda (item)
2188             (when (and (consp (cdr-safe item))
2189                        (keymapp (nth 2 (cdr item))))
2190               (yas--delete-from-keymap (nth 2 (cdr item)) uuid)))
2191         (cdr keymap))
2192   ;; Set the uuid entry to nil
2193   ;;
2194   (define-key keymap (vector (make-symbol uuid)) nil)
2195   ;; Destructively modify keymap
2196   ;;
2197   (setcdr keymap (cl-delete-if (lambda (item)
2198                                  (cond ((not (listp item)) nil)
2199                                        ((null (cdr item)))
2200                                        ((and (keymapp (nth 2 (cdr item)))
2201                                              (null (cdr (nth 2 (cdr item))))))))
2202                                (cdr keymap))))
2203
2204 (defun yas-define-menu (mode menu &optional omit-items)
2205   "Define a snippet menu for MODE according to MENU, omitting OMIT-ITEMS.
2206
2207 MENU is a list, its elements can be:
2208
2209 - (yas-item UUID) : Creates an entry the snippet identified with
2210   UUID.  The menu entry for a snippet thus identified is
2211   permanent, i.e. it will never move (be reordered) in the menu.
2212
2213 - (yas-separator) : Creates a separator
2214
2215 - (yas-submenu NAME SUBMENU) : Creates a submenu with NAME,
2216   SUBMENU has the same form as MENU.  NAME is also added to the
2217   list of groups of the snippets defined thereafter.
2218
2219 OMIT-ITEMS is a list of snippet uuids that will always be
2220 omitted from MODE's menu, even if they're manually loaded."
2221   (let* ((table (yas--table-get-create mode))
2222          (hash (yas--table-uuidhash table)))
2223     (yas--define-menu-1 table
2224                         (yas--menu-keymap-get-create mode)
2225                         menu
2226                         hash)
2227     (dolist (uuid omit-items)
2228       (let ((template (or (gethash uuid hash)
2229                           (puthash uuid
2230                                    (yas--make-template :table table
2231                                                        :uuid uuid)
2232                                    hash))))
2233         (setf (yas--template-menu-binding-pair template) (cons nil :none))))))
2234
2235 (defun yas--define-menu-1 (table menu-keymap menu uuidhash &optional group-list)
2236   "Helper for `yas-define-menu'."
2237   (cl-loop
2238    for (type name submenu) in (reverse menu)
2239    collect (cond
2240             ((or (eq type 'yas-item)
2241                  (and yas-alias-to-yas/prefix-p
2242                       (eq type 'yas/item)))
2243              (let ((template (or (gethash name uuidhash)
2244                                  (puthash name
2245                                           (yas--make-template
2246                                            :table table
2247                                            :perm-group group-list
2248                                            :uuid name)
2249                                           uuidhash))))
2250                (car (yas--template-menu-binding-pair-get-create
2251                      template :stay))))
2252             ((or (eq type 'yas-submenu)
2253                  (and yas-alias-to-yas/prefix-p
2254                       (eq type 'yas/submenu)))
2255              (let ((subkeymap (make-sparse-keymap)))
2256                (yas--define-menu-1 table subkeymap submenu uuidhash
2257                                    (append group-list (list name)))
2258                `(menu-item ,name ,subkeymap)))
2259             ((or (eq type 'yas-separator)
2260                  (and yas-alias-to-yas/prefix-p
2261                       (eq type 'yas/separator)))
2262              '(menu-item "----"))
2263             (t (yas--message 1 "Don't know anything about menu entry %s" type)
2264                nil))
2265    into menu-entries
2266    finally do (push (apply #'vector menu-entries) (cdr menu-keymap))))
2267
2268 (defun yas--define (mode key template &optional name condition group)
2269   "Define a snippet.  Expanding KEY into TEMPLATE.
2270
2271 NAME is a description to this template.  Also update the menu if
2272 `yas-use-menu' is t.  CONDITION is the condition attached to
2273 this snippet.  If you attach a condition to a snippet, then it
2274 will only be expanded when the condition evaluated to non-nil."
2275   (yas-define-snippets mode
2276                        (list (list key template name condition group))))
2277
2278 (defun yas-hippie-try-expand (first-time?)
2279   "Integrate with hippie expand.
2280
2281 Just put this function in `hippie-expand-try-functions-list'."
2282   (when yas-minor-mode
2283     (if (not first-time?)
2284         (let ((yas-fallback-behavior 'return-nil))
2285           (yas-expand))
2286       (undo 1)
2287       nil)))
2288
2289
2290 ;;; Apropos condition-cache:
2291 ;;;
2292 ;;;
2293 ;;;
2294 ;;;
2295 (defmacro yas-define-condition-cache (func doc &rest body)
2296   "Define a function FUNC with doc DOC and body BODY.
2297 BODY is executed at most once every snippet expansion attempt, to check
2298 expansion conditions.
2299
2300 It doesn't make any sense to call FUNC programatically."
2301   `(defun ,func () ,(if (and doc
2302                              (stringp doc))
2303                         (concat doc
2304 "\n\nFor use in snippets' conditions. Within each
2305 snippet-expansion routine like `yas-expand', computes actual
2306 value for the first time then always returns a cached value.")
2307                       (setq body (cons doc body))
2308                       nil)
2309      (let ((timestamp-and-value (get ',func 'yas--condition-cache)))
2310        (if (equal (car timestamp-and-value) yas--condition-cache-timestamp)
2311            (cdr timestamp-and-value)
2312          (let ((new-value (progn
2313                             ,@body
2314                             )))
2315            (put ',func 'yas--condition-cache (cons yas--condition-cache-timestamp new-value))
2316            new-value)))))
2317
2318 (defalias 'yas-expand 'yas-expand-from-trigger-key)
2319 (defun yas-expand-from-trigger-key (&optional field)
2320   "Expand a snippet before point.
2321
2322 If no snippet expansion is possible, fall back to the behaviour
2323 defined in `yas-fallback-behavior'.
2324
2325 Optional argument FIELD is for non-interactive use and is an
2326 object satisfying `yas--field-p' to restrict the expansion to."
2327   (interactive)
2328   (setq yas--condition-cache-timestamp (current-time))
2329   (let (templates-and-pos)
2330     (unless (and yas-expand-only-for-last-commands
2331                  (not (member last-command yas-expand-only-for-last-commands)))
2332       (setq templates-and-pos (if field
2333                                   (save-restriction
2334                                     (narrow-to-region (yas--field-start field)
2335                                                       (yas--field-end field))
2336                                     (yas--templates-for-key-at-point))
2337                                 (yas--templates-for-key-at-point))))
2338     (if templates-and-pos
2339         (yas--expand-or-prompt-for-template
2340          (nth 0 templates-and-pos)
2341          ;; Delete snippet key and active region when expanding.
2342          (min (if (use-region-p) (region-beginning) most-positive-fixnum)
2343               (nth 1 templates-and-pos))
2344          (max (if (use-region-p) (region-end) most-negative-fixnum)
2345               (nth 2 templates-and-pos)))
2346       (yas--fallback))))
2347
2348 (defun yas--maybe-expand-from-keymap-filter (cmd)
2349   (let* ((yas--condition-cache-timestamp (current-time))
2350          (vec (cl-subseq (this-command-keys-vector)
2351                          (if current-prefix-arg
2352                              (length (this-command-keys))
2353                            0)))
2354          (templates (cl-mapcan (lambda (table)
2355                                  (yas--fetch table vec))
2356                                (yas--get-snippet-tables))))
2357     (if templates (or cmd templates))))
2358
2359 (defun yas-expand-from-keymap ()
2360   "Directly expand some snippets, searching `yas--direct-keymaps'."
2361   (interactive)
2362   (setq yas--condition-cache-timestamp (current-time))
2363   (let* ((templates (yas--maybe-expand-from-keymap-filter nil)))
2364     (when templates
2365       (yas--expand-or-prompt-for-template templates))))
2366
2367 (defun yas--expand-or-prompt-for-template (templates &optional start end)
2368   "Expand one of TEMPLATES from START to END.
2369
2370 Prompt the user if TEMPLATES has more than one element, else
2371 expand immediately.  Common gateway for
2372 `yas-expand-from-trigger-key' and `yas-expand-from-keymap'."
2373   (let ((yas--current-template (or (and (cl-rest templates) ;; more than one
2374                                         (yas--prompt-for-template (mapcar #'cdr templates)))
2375                                    (cdar templates))))
2376     (when yas--current-template
2377       (yas-expand-snippet (yas--template-content yas--current-template)
2378                           start
2379                           end
2380                           (yas--template-expand-env yas--current-template)))))
2381
2382 ;; Apropos the trigger key and the fallback binding:
2383 ;;
2384 ;; When `yas-minor-mode-map' binds <tab>, that correctly overrides
2385 ;; org-mode's <tab>, for example and searching for fallbacks correctly
2386 ;; returns `org-cycle'. However, most other modes bind "TAB". TODO,
2387 ;; improve this explanation.
2388 ;;
2389 (defun yas--fallback ()
2390   "Fallback after expansion has failed.
2391
2392 Common gateway for `yas-expand-from-trigger-key' and
2393 `yas-expand-from-keymap'."
2394   (cond ((eq yas-fallback-behavior 'return-nil)
2395          ;; return nil
2396          nil)
2397         ((eq yas-fallback-behavior 'yas--fallback)
2398          (error (concat "yasnippet fallback loop!\n"
2399                         "This can happen when you bind `yas-expand' "
2400                         "outside of the `yas-minor-mode-map'.")))
2401         ((eq yas-fallback-behavior 'call-other-command)
2402          (let* ((yas-fallback-behavior 'yas--fallback)
2403                 ;; Also bind `yas-minor-mode' to prevent fallback
2404                 ;; loops when other extensions use mechanisms similar
2405                 ;; to `yas--keybinding-beyond-yasnippet'. (github #525
2406                 ;; and #526)
2407                 ;;
2408                 (yas-minor-mode nil)
2409                 (beyond-yasnippet (yas--keybinding-beyond-yasnippet)))
2410            (yas--message 4 "Falling back to %s"  beyond-yasnippet)
2411            (cl-assert (or (null beyond-yasnippet) (commandp beyond-yasnippet)))
2412            (setq this-command beyond-yasnippet)
2413            (when beyond-yasnippet
2414              (call-interactively beyond-yasnippet))))
2415         ((and (listp yas-fallback-behavior)
2416               (cdr yas-fallback-behavior)
2417               (eq 'apply (car yas-fallback-behavior)))
2418          (let ((command-or-fn (cadr yas-fallback-behavior))
2419                (args (cddr yas-fallback-behavior))
2420                (yas-fallback-behavior 'yas--fallback)
2421                (yas-minor-mode nil))
2422            (if args
2423                (apply command-or-fn args)
2424              (when (commandp command-or-fn)
2425                (setq this-command command-or-fn)
2426                (call-interactively command-or-fn)))))
2427         (t
2428          ;; also return nil if all the other fallbacks have failed
2429          nil)))
2430
2431 (defun yas--keybinding-beyond-yasnippet ()
2432   "Get current keys's binding as if YASsnippet didn't exist."
2433   (let* ((yas-minor-mode nil)
2434          (yas--direct-keymaps nil)
2435          (keys (this-single-command-keys)))
2436     (or (key-binding keys t)
2437         (key-binding (yas--fallback-translate-input keys) t))))
2438
2439 (defun yas--fallback-translate-input (keys)
2440   "Emulate `read-key-sequence', at least what I think it does.
2441
2442 Keys should be an untranslated key vector.  Returns a translated
2443 vector of keys.  FIXME not thoroughly tested."
2444   (let ((retval [])
2445         (i 0))
2446     (while (< i (length keys))
2447       (let ((j i)
2448             (translated local-function-key-map))
2449         (while (and (< j (length keys))
2450                     translated
2451                     (keymapp translated))
2452           (setq translated (cdr (assoc (aref keys j) (remove 'keymap translated)))
2453                 j (1+ j)))
2454         (setq retval (vconcat retval (cond ((symbolp translated)
2455                                             `[,translated])
2456                                            ((vectorp translated)
2457                                             translated)
2458                                            (t
2459                                             (substring keys i j)))))
2460         (setq i j)))
2461     retval))
2462
2463
2464 ;;; Utils for snippet development:
2465
2466 (defun yas--all-templates (tables)
2467   "Get `yas--template' objects in TABLES, applicable for buffer and point.
2468
2469 Honours `yas-choose-tables-first', `yas-choose-keys-first' and
2470 `yas-buffer-local-condition'"
2471   (when yas-choose-tables-first
2472     (setq tables (list (yas--prompt-for-table tables))))
2473   (mapcar #'cdr
2474           (if yas-choose-keys-first
2475               (let ((key (yas--prompt-for-keys
2476                           (cl-mapcan #'yas--table-all-keys tables))))
2477                 (when key
2478                   (cl-mapcan (lambda (table)
2479                                (yas--fetch table key))
2480                              tables)))
2481             (cl-remove-duplicates (cl-mapcan #'yas--table-templates tables)
2482                                   :test #'equal))))
2483
2484 (defun yas--lookup-snippet-1 (name mode)
2485   "Get the snippet called NAME in MODE's tables."
2486   (let ((yas-choose-tables-first nil)   ; avoid prompts
2487         (yas-choose-keys-first nil))
2488     (cl-find name (yas--all-templates
2489                    (yas--get-snippet-tables mode))
2490              :key #'yas--template-name :test #'string=)))
2491
2492 (defun yas-lookup-snippet (name &optional mode noerror)
2493   "Get the snippet named NAME in MODE's tables.
2494
2495 MODE defaults to the current buffer's `major-mode'.  If NOERROR
2496 is non-nil, then don't signal an error if there isn't any snippet
2497 called NAME.
2498
2499 Honours `yas-buffer-local-condition'."
2500   (cond
2501    ((yas--lookup-snippet-1 name mode))
2502    (noerror nil)
2503    (t (error "No snippet named: %s" name))))
2504
2505 (defun yas-insert-snippet (&optional no-condition)
2506   "Choose a snippet to expand, pop-up a list of choices according
2507 to `yas-prompt-functions'.
2508
2509 With prefix argument NO-CONDITION, bypass filtering of snippets
2510 by condition."
2511   (interactive "P")
2512   (setq yas--condition-cache-timestamp (current-time))
2513   (let* ((yas-buffer-local-condition (or (and no-condition
2514                                               'always)
2515                                          yas-buffer-local-condition))
2516          (templates (yas--all-templates (yas--get-snippet-tables)))
2517          (yas--current-template (and templates
2518                                     (or (and (cl-rest templates) ;; more than one template for same key
2519                                              (yas--prompt-for-template templates))
2520                                         (car templates))))
2521          (where (if (region-active-p)
2522                     (cons (region-beginning) (region-end))
2523                   (cons (point) (point)))))
2524     (if yas--current-template
2525         (yas-expand-snippet (yas--template-content yas--current-template)
2526                             (car where)
2527                             (cdr where)
2528                             (yas--template-expand-env yas--current-template))
2529       (yas--message 1 "No snippets can be inserted here!"))))
2530
2531 (defun yas-visit-snippet-file ()
2532   "Choose a snippet to edit, selection like `yas-insert-snippet'.
2533
2534 Only success if selected snippet was loaded from a file.  Put the
2535 visited file in `snippet-mode'."
2536   (interactive)
2537   (let* ((yas-buffer-local-condition 'always)
2538          (templates (yas--all-templates (yas--get-snippet-tables)))
2539          (template (and templates
2540                         (or (yas--prompt-for-template templates
2541                                                      "Choose a snippet template to edit: ")
2542                             (car templates)))))
2543
2544     (if template
2545         (yas--visit-snippet-file-1 template)
2546       (message "No snippets tables active!"))))
2547
2548 (defun yas--visit-snippet-file-1 (template)
2549   "Helper for `yas-visit-snippet-file'."
2550   (let ((file (yas--template-get-file template)))
2551     (cond ((and file (file-readable-p file))
2552            (find-file-other-window file)
2553            (snippet-mode)
2554            (set (make-local-variable 'yas--editing-template) template))
2555           (file
2556            (message "Original file %s no longer exists!" file))
2557           (t
2558            (switch-to-buffer (format "*%s*"(yas--template-name template)))
2559            (let ((type 'snippet))
2560              (when (listp (yas--template-content template))
2561                (insert (format "# type: command\n"))
2562                (setq type 'command))
2563              (insert (format "# key: %s\n" (yas--template-key template)))
2564              (insert (format "# name: %s\n" (yas--template-name template)))
2565              (when (yas--template-keybinding template)
2566                (insert (format "# binding: %s\n" (yas--template-keybinding template))))
2567              (when (yas--template-expand-env template)
2568                (insert (format "# expand-env: %s\n" (yas--template-expand-env template))))
2569              (when (yas--template-condition template)
2570                (insert (format "# condition: %s\n" (yas--template-condition template))))
2571              (insert "# --\n")
2572              (insert (if (eq type 'command)
2573                          (pp-to-string (yas--template-content template))
2574                        (yas--template-content template))))
2575            (snippet-mode)
2576            (set (make-local-variable 'yas--editing-template) template)
2577            (set (make-local-variable 'default-directory)
2578                 (car (cdr (car (yas--guess-snippet-directories (yas--template-table template))))))))))
2579
2580 (defun yas--guess-snippet-directories-1 (table)
2581   "Guess possible snippet subdirectories for TABLE."
2582   (cons (file-name-as-directory (yas--table-name table))
2583         (cl-mapcan #'yas--guess-snippet-directories-1
2584                    (yas--table-parents table))))
2585
2586 (defun yas--guess-snippet-directories (&optional table)
2587   "Try to guess suitable directories based on the current active
2588 tables (or optional TABLE).
2589
2590 Returns a list of elements (TABLE . DIRS) where TABLE is a
2591 `yas--table' object and DIRS is a list of all possible directories
2592 where snippets of table might exist."
2593   (let ((main-dir (car (or (yas-snippet-dirs)
2594                            (setq yas-snippet-dirs
2595                                  (list yas--default-user-snippets-dir)))))
2596         (tables (if table (list table)
2597                   (yas--get-snippet-tables))))
2598     ;; HACK! the snippet table created here is actually registered!
2599     (unless table
2600       ;; The major mode is probably the best guess, put it first.
2601       (let ((major-mode-table (yas--table-get-create major-mode)))
2602         (cl-callf2 delq major-mode-table tables)
2603         (push major-mode-table tables)))
2604
2605     (mapcar #'(lambda (table)
2606                 (cons table
2607                       (mapcar #'(lambda (subdir)
2608                                   (expand-file-name subdir main-dir))
2609                               (yas--guess-snippet-directories-1 table))))
2610             tables)))
2611
2612 (defun yas--make-directory-maybe (table-and-dirs &optional main-table-string)
2613   "Return a dir inside TABLE-AND-DIRS, prompts for creation if none exists."
2614   (or (cl-some (lambda (dir) (when (file-directory-p dir) dir))
2615                (cdr table-and-dirs))
2616       (let ((candidate (cl-first (cdr table-and-dirs))))
2617         (unless (file-writable-p (file-name-directory candidate))
2618           (error (yas--format "%s is not writable." candidate)))
2619         (if (y-or-n-p (format "Guessed directory (%s) for%s%s table \"%s\" does not exist! Create? "
2620                               candidate
2621                               (if (gethash (yas--table-mode (car table-and-dirs))
2622                                            yas--tables)
2623                                   ""
2624                                 " brand new")
2625                               (or main-table-string
2626                                   "")
2627                               (yas--table-name (car table-and-dirs))))
2628             (progn
2629               (make-directory candidate 'also-make-parents)
2630               ;; create the .yas-parents file here...
2631               candidate)))))
2632
2633 ;; NOTE: Using the traditional "*new snippet*" stops whitespace mode
2634 ;; from activating (it doesn't like the leading "*").
2635 (defconst yas-new-snippet-buffer-name "+new-snippet+")
2636
2637 (defun yas-new-snippet (&optional no-template)
2638   "Pops a new buffer for writing a snippet.
2639
2640 Expands a snippet-writing snippet, unless the optional prefix arg
2641 NO-TEMPLATE is non-nil."
2642   (interactive "P")
2643   (let ((guessed-directories (yas--guess-snippet-directories))
2644         (yas-selected-text (or yas-selected-text
2645                                (and (region-active-p)
2646                                     (buffer-substring-no-properties
2647                                      (region-beginning) (region-end))))))
2648
2649     (switch-to-buffer yas-new-snippet-buffer-name)
2650     (erase-buffer)
2651     (kill-all-local-variables)
2652     (snippet-mode)
2653     (yas-minor-mode 1)
2654     (set (make-local-variable 'yas--guessed-modes)
2655          (mapcar (lambda (d) (yas--table-mode (car d)))
2656                  guessed-directories))
2657     (set (make-local-variable 'default-directory)
2658          (car (cdr (car guessed-directories))))
2659     (if (and (not no-template) yas-new-snippet-default)
2660         (yas-expand-snippet yas-new-snippet-default))))
2661
2662 (defun yas--compute-major-mode-and-parents (file)
2663   "Given FILE, find the nearest snippet directory for a given mode.
2664
2665 Returns a list (MODE-SYM PARENTS), the mode's symbol and a list
2666 representing one or more of the mode's parents.
2667
2668 Note that MODE-SYM need not be the symbol of a real major mode,
2669 neither do the elements of PARENTS."
2670   (let* ((file-dir (and file
2671                         (directory-file-name
2672                          (or (cl-some (lambda (special)
2673                                         (locate-dominating-file file special))
2674                                       '(".yas-setup.el"
2675                                         ".yas-make-groups"
2676                                         ".yas-parents"))
2677                              (directory-file-name (file-name-directory file))))))
2678          (parents-file-name (concat file-dir "/.yas-parents"))
2679          (major-mode-name (and file-dir
2680                                (file-name-nondirectory file-dir)))
2681          (major-mode-sym (or (and major-mode-name
2682                                   (intern major-mode-name))))
2683          (parents (when (file-readable-p parents-file-name)
2684                          (mapcar #'intern
2685                                  (split-string
2686                                   (with-temp-buffer
2687                                     (insert-file-contents parents-file-name)
2688                                     (buffer-substring-no-properties (point-min)
2689                                                                     (point-max))))))))
2690     (when major-mode-sym
2691       (cons major-mode-sym (remove major-mode-sym parents)))))
2692
2693 (defvar yas--editing-template nil
2694   "Supporting variable for `yas-load-snippet-buffer' and `yas--visit-snippet'.")
2695
2696 (defvar yas--current-template nil
2697   "Holds the current template being expanded into a snippet.")
2698
2699 (defvar yas--guessed-modes nil
2700   "List of guessed modes supporting `yas-load-snippet-buffer'.")
2701
2702 (defun yas--read-table ()
2703   "Ask user for a snippet table, help with some guessing."
2704   (let ((prompt (if (and (featurep 'ido)
2705                          ido-mode)
2706                     'ido-completing-read 'completing-read)))
2707     (unless yas--guessed-modes
2708       (set (make-local-variable 'yas--guessed-modes)
2709            (or (yas--compute-major-mode-and-parents buffer-file-name))))
2710     (intern
2711      (funcall prompt (format "Choose or enter a table (yas guesses %s): "
2712                              (if yas--guessed-modes
2713                                  (cl-first yas--guessed-modes)
2714                                "nothing"))
2715               (mapcar #'symbol-name yas--guessed-modes)
2716               nil
2717               nil
2718               nil
2719               nil
2720               (if (cl-first yas--guessed-modes)
2721                   (symbol-name (cl-first yas--guessed-modes)))))))
2722
2723 (defun yas-load-snippet-buffer (table &optional interactive)
2724   "Parse and load current buffer's snippet definition into TABLE.
2725 TABLE is a symbol name passed to `yas--table-get-create'.  When
2726 called interactively, prompt for the table name.
2727 Return the `yas--template' object created"
2728   (interactive (list (yas--read-table) t))
2729   (cond
2730    ;;  We have `yas--editing-template', this buffer's content comes from a
2731    ;;  template which is already loaded and neatly positioned,...
2732    ;;
2733    (yas--editing-template
2734     (yas--define-snippets-1 (yas--parse-template (yas--template-load-file yas--editing-template))
2735                            (yas--template-table yas--editing-template)))
2736    ;; Try to use `yas--guessed-modes'. If we don't have that use the
2737    ;; value from `yas--compute-major-mode-and-parents'
2738    ;;
2739    (t
2740     (unless yas--guessed-modes
2741       (set (make-local-variable 'yas--guessed-modes) (or (yas--compute-major-mode-and-parents buffer-file-name))))
2742     (let* ((table (yas--table-get-create table)))
2743       (set (make-local-variable 'yas--editing-template)
2744            (yas--define-snippets-1 (yas--parse-template buffer-file-name)
2745                                   table)))))
2746   (when interactive
2747     (yas--message 3 "Snippet \"%s\" loaded for %s."
2748                   (yas--template-name yas--editing-template)
2749                   (yas--table-name (yas--template-table yas--editing-template))))
2750   yas--editing-template)
2751
2752 (defun yas-maybe-load-snippet-buffer ()
2753   "Added to `after-save-hook' in `snippet-mode'."
2754   (let* ((mode (intern (file-name-sans-extension
2755                         (file-name-nondirectory
2756                          (directory-file-name default-directory)))))
2757          (current-snippet
2758           (apply #'yas--define-snippets-2 (yas--table-get-create mode)
2759                  (yas--parse-template buffer-file-name)))
2760          (uuid (yas--template-uuid current-snippet)))
2761     (unless (equal current-snippet
2762                    (if uuid (yas--get-template-by-uuid mode uuid)
2763                      (yas--lookup-snippet-1
2764                       (yas--template-name current-snippet) mode)))
2765       (yas-load-snippet-buffer mode t))))
2766
2767 (defun yas-load-snippet-buffer-and-close (table &optional kill)
2768   "Load and save the snippet, then `quit-window' if saved.
2769 Loading is performed by `yas-load-snippet-buffer'.  If the
2770 snippet is new, ask the user whether (and where) to save it.  If
2771 the snippet already has a file, just save it.
2772
2773 The prefix argument KILL is passed to `quit-window'.
2774
2775 Don't use this from a Lisp program, call `yas-load-snippet-buffer'
2776 and `kill-buffer' instead."
2777   (interactive (list (yas--read-table) current-prefix-arg))
2778   (let ((template (yas-load-snippet-buffer table t)))
2779     (when (and (buffer-modified-p)
2780                (y-or-n-p
2781                 (format "[yas] Loaded for %s. Also save snippet buffer?"
2782                         (yas--table-name (yas--template-table template)))))
2783       (let ((default-directory (car (cdr (car (yas--guess-snippet-directories
2784                                                (yas--template-table template))))))
2785             (default-file-name (yas--template-name template)))
2786         (unless (or buffer-file-name (not default-file-name))
2787           (setq buffer-file-name
2788                 (read-file-name "File to save snippet in: "
2789                                 nil nil nil default-file-name))
2790           (rename-buffer (file-name-nondirectory buffer-file-name) t))
2791         (save-buffer)))
2792     (quit-window kill)))
2793
2794 (declare-function yas-debug-snippets "yasnippet-debug")
2795
2796 (defun yas-tryout-snippet (&optional debug)
2797   "Test current buffer's snippet template in other buffer.
2798 DEBUG is for debugging the YASnippet engine itself."
2799   (interactive "P")
2800   (let* ((major-mode-and-parent (yas--compute-major-mode-and-parents buffer-file-name))
2801          (parsed (yas--parse-template))
2802          (test-mode (or (and (car major-mode-and-parent)
2803                              (fboundp (car major-mode-and-parent))
2804                              (car major-mode-and-parent))
2805                         (cl-first yas--guessed-modes)
2806                         (intern (read-from-minibuffer (yas--format "Please input a mode: ")))))
2807          (yas--current-template
2808           (and parsed
2809                (fboundp test-mode)
2810                (yas--make-template :table       nil ;; no tables for ephemeral snippets
2811                                    :key         (nth 0 parsed)
2812                                    :content     (nth 1 parsed)
2813                                    :name        (nth 2 parsed)
2814                                    :expand-env  (nth 5 parsed)))))
2815     (cond (yas--current-template
2816            (let ((buffer-name (format "*testing snippet: %s*" (yas--template-name yas--current-template))))
2817              (kill-buffer (get-buffer-create buffer-name))
2818              (switch-to-buffer (get-buffer-create buffer-name))
2819              (setq buffer-undo-list nil)
2820              (condition-case nil (funcall test-mode) (error nil))
2821          (yas-minor-mode 1)
2822              (setq buffer-read-only nil)
2823              (yas-expand-snippet (yas--template-content yas--current-template)
2824                                  (point-min)
2825                                  (point-max)
2826                                  (yas--template-expand-env yas--current-template))
2827              (when (and debug
2828                         (require 'yasnippet-debug nil t))
2829                (yas-debug-snippets "*YASnippet trace*" 'snippet-navigation)
2830                (display-buffer "*YASnippet trace*"))))
2831           (t
2832            (yas--message 1 "Cannot test snippet for unknown major mode")))))
2833
2834 (defun yas-active-keys ()
2835   "Return all active trigger keys for current buffer and point."
2836   (cl-remove-duplicates
2837    (cl-remove-if-not #'stringp (cl-mapcan #'yas--table-all-keys
2838                                           (yas--get-snippet-tables)))
2839    :test #'string=))
2840
2841 (defun yas--template-fine-group (template)
2842   (car (last (or (yas--template-group template)
2843                  (yas--template-perm-group template)))))
2844
2845 (defun yas-describe-table-by-namehash ()
2846   "Display snippet tables by NAMEHASH."
2847   (interactive)
2848   (with-current-buffer (get-buffer-create "*YASnippet Tables by NAMEHASH*")
2849     (let ((inhibit-read-only t))
2850       (erase-buffer)
2851       (insert "YASnippet tables by NAMEHASH: \n")
2852       (maphash
2853        (lambda (_mode table)
2854          (insert (format "\nSnippet table `%s':\n\n" (yas--table-name table)))
2855          (maphash
2856           (lambda (key _v)
2857             (insert (format "   key %s maps snippets: %s\n" key
2858                             (let ((names))
2859                               (maphash #'(lambda (k _v)
2860                                            (push k names))
2861                                        (gethash key (yas--table-hash table)))
2862                               names))))
2863           (yas--table-hash table)))
2864        yas--tables))
2865     (view-mode +1)
2866     (goto-char 1)
2867     (display-buffer (current-buffer))))
2868
2869 (defun yas-describe-tables (&optional with-nonactive)
2870   "Display snippets for each table."
2871   (interactive "P")
2872   (let ((original-buffer (current-buffer))
2873         (tables (yas--get-snippet-tables)))
2874    (with-current-buffer (get-buffer-create "*YASnippet Tables*")
2875      (let ((inhibit-read-only t))
2876        (when with-nonactive
2877          (maphash #'(lambda (_k v)
2878                       (cl-pushnew v tables))
2879                   yas--tables))
2880        (erase-buffer)
2881        (insert "YASnippet tables:\n")
2882        (dolist (table tables)
2883          (yas--describe-pretty-table table original-buffer))
2884        (yas--create-snippet-xrefs))
2885      (help-mode)
2886      (goto-char 1)
2887      (display-buffer (current-buffer)))))
2888
2889 (defun yas--describe-pretty-table (table &optional original-buffer)
2890   (insert (format "\nSnippet table `%s'"
2891                   (yas--table-name table)))
2892   (if (yas--table-parents table)
2893       (insert (format " parents: %s\n"
2894                       (mapcar #'yas--table-name
2895                               (yas--table-parents table))))
2896     (insert "\n"))
2897   (insert (make-string 100 ?-) "\n")
2898   (insert "group                   state name                                    key             binding\n")
2899   (let ((groups-hash (make-hash-table :test #'equal)))
2900     (maphash #'(lambda (_k v)
2901                  (let ((group (or (yas--template-fine-group v)
2902                                   "(top level)")))
2903                    (when (yas--template-name v)
2904                      (puthash group
2905                               (cons v (gethash group groups-hash))
2906                               groups-hash))))
2907              (yas--table-uuidhash table))
2908     (maphash
2909      #'(lambda (group templates)
2910          (setq group (truncate-string-to-width group 25 0 ?  "..."))
2911          (insert (make-string 100 ?-) "\n")
2912          (dolist (p templates)
2913            (let* ((name (truncate-string-to-width (propertize (format "\\\\snippet `%s'" (yas--template-name p))
2914                                                               'yasnippet p)
2915                                                   50 0 ? "..."))
2916                   (group (prog1 group
2917                            (setq group (make-string (length group) ? ))))
2918                   (condition-string (let ((condition (yas--template-condition p)))
2919                                       (if (and condition
2920                                                original-buffer)
2921                                           (with-current-buffer original-buffer
2922                                             (if (yas--eval-condition condition)
2923                                                 "(y)"
2924                                               "(s)"))
2925                                         "(a)")))
2926                   (key-description-string (key-description (yas--template-keybinding p)))
2927                   (template-key-padding (if (string= key-description-string "") nil ? )))
2928              (insert group " "
2929                      condition-string " "
2930                      name (if (string-match "\\.\\.\\.$" name)
2931                               "'" " ")
2932                      " "
2933                      (truncate-string-to-width (or (yas--template-key p) "")
2934                                                15 0 template-key-padding "...")
2935                      (or template-key-padding "")
2936                      (truncate-string-to-width key-description-string
2937                                                15 0 nil "...")
2938                      "\n"))))
2939      groups-hash)))
2940
2941
2942
2943 ;;; User convenience functions, for using in `yas-key-syntaxes'
2944
2945 (defun yas-try-key-from-whitespace (_start-point)
2946   "As `yas-key-syntaxes' element, look for whitespace delimited key.
2947
2948 A newline will be considered whitespace even if the mode syntax
2949 marks it as something else (typically comment ender)."
2950   (skip-chars-backward "^[:space:]\n"))
2951
2952 (defun yas-shortest-key-until-whitespace (_start-point)
2953   "Like `yas-longest-key-from-whitespace' but take the shortest key."
2954   (when (/= (skip-chars-backward "^[:space:]\n" (1- (point))) 0)
2955     'again))
2956
2957 (defun yas-longest-key-from-whitespace (start-point)
2958   "As `yas-key-syntaxes' element, look for longest key between point and whitespace.
2959
2960 A newline will be considered whitespace even if the mode syntax
2961 marks it as something else (typically comment ender)."
2962   (if (= (point) start-point)
2963       (yas-try-key-from-whitespace start-point)
2964     (forward-char))
2965   (unless (<= start-point (1+ (point)))
2966     'again))
2967
2968
2969
2970 ;;; User convenience functions, for using in snippet definitions
2971
2972 (defvar yas-modified-p nil
2973   "Non-nil if field has been modified by user or transformation.")
2974
2975 (defvar yas-moving-away-p nil
2976   "Non-nil if user is about to exit field.")
2977
2978 (defvar yas-text nil
2979   "Contains current field text.")
2980
2981 (defun yas-substr (str pattern &optional subexp)
2982   "Search PATTERN in STR and return SUBEXPth match.
2983
2984 If found, the content of subexp group SUBEXP (default 0) is
2985   returned, or else the original STR will be returned."
2986   (let ((grp (or subexp 0)))
2987     (save-match-data
2988       (if (string-match pattern str)
2989           (match-string-no-properties grp str)
2990         str))))
2991
2992 (defun yas-choose-value (&rest possibilities)
2993   "Prompt for a string in POSSIBILITIES and return it.
2994
2995 The last element of POSSIBILITIES may be a list of strings."
2996   (unless (or yas-moving-away-p
2997               yas-modified-p)
2998     (let* ((last-link (last possibilities))
2999            (last-elem (car last-link)))
3000       (when (listp last-elem)
3001         (setcar last-link (car last-elem))
3002         (setcdr last-link (cdr last-elem))))
3003     (cl-some (lambda (fn)
3004                (funcall fn "Choose: " possibilities))
3005              yas-prompt-functions)))
3006
3007 (defun yas-completing-read (&rest args)
3008   "A snippet-aware version of `completing-read'.
3009 This can be used to query the user for the initial value of a
3010 snippet field.  The arguments are the same as `completing-read'.
3011
3012 \(fn PROMPT COLLECTION &optional PREDICATE REQUIRE-MATCH INITIAL-INPUT HIST DEF INHERIT-INPUT-METHOD)"
3013   (unless (or yas-moving-away-p
3014               yas-modified-p)
3015     (apply #'completing-read args)))
3016
3017 (defun yas--auto-next ()
3018   "Helper for `yas-auto-next'."
3019   (remove-hook 'post-command-hook #'yas--auto-next t)
3020   (yas-next-field))
3021
3022 (defmacro yas-auto-next (&rest body)
3023   "Automatically advance to next field after eval'ing BODY."
3024   (declare (indent 0) (debug t))
3025   `(unless yas-moving-away-p
3026      (prog1 ,@body
3027        (add-hook 'post-command-hook #'yas--auto-next nil t))))
3028
3029 (defun yas-key-to-value (alist)
3030   (unless (or yas-moving-away-p
3031               yas-modified-p)
3032     (let ((key (read-key-sequence "")))
3033       (when (stringp key)
3034         (or (cdr (cl-find key alist :key #'car :test #'string=))
3035             key)))))
3036
3037 (defun yas-throw (text)
3038   "Signal `yas-exception' with TEXT as the reason."
3039   (signal 'yas-exception (list text)))
3040 (put 'yas-exception 'error-conditions '(error yas-exception))
3041 (put 'yas-exception 'error-message "[yas] Exception")
3042
3043 (defun yas-verify-value (possibilities)
3044   "Verify that the current field value is in POSSIBILITIES.
3045 Otherwise signal `yas-exception'."
3046   (when (and yas-moving-away-p (not (member yas-text possibilities)))
3047     (yas-throw (format "Field only allows %s" possibilities))))
3048
3049 (defun yas-field-value (number)
3050   "Get the string for field with NUMBER.
3051
3052 Use this in primary and mirror transformations to get the text of
3053 other fields."
3054   (let* ((snippet (car (yas-active-snippets)))
3055          (field (and snippet
3056                      (yas--snippet-find-field snippet number))))
3057     (when field
3058       (yas--field-text-for-display field))))
3059
3060 (defun yas-text ()
3061   "Return `yas-text' if that exists and is non-empty, else nil."
3062   (if (and yas-text
3063            (not (string= "" yas-text)))
3064       yas-text))
3065
3066 (defun yas-selected-text ()
3067   "Return `yas-selected-text' if that exists and is non-empty, else nil."
3068   (if (and yas-selected-text
3069            (not (string= "" yas-selected-text)))
3070       yas-selected-text))
3071
3072 (defun yas--get-field-once (number &optional transform-fn)
3073   (unless yas-modified-p
3074     (if transform-fn
3075         (funcall transform-fn (yas-field-value number))
3076       (yas-field-value number))))
3077
3078 (defun yas-default-from-field (number)
3079   (unless yas-modified-p
3080     (yas-field-value number)))
3081
3082 (defun yas-inside-string ()
3083   "Return non-nil if the point is inside a string according to font-lock."
3084   (equal 'font-lock-string-face (get-char-property (1- (point)) 'face)))
3085
3086 (defun yas-unimplemented (&optional missing-feature)
3087   (if yas--current-template
3088       (if (y-or-n-p (format "This snippet is unimplemented (missing %s) Visit the snippet definition? "
3089                             (or missing-feature
3090                                 "something")))
3091           (yas--visit-snippet-file-1 yas--current-template))
3092     (message "No implementation. Missing %s" (or missing-feature "something"))))
3093
3094
3095 ;;; Snippet expansion and field management
3096
3097 (defvar yas--active-field-overlay nil
3098   "Overlays the currently active field.")
3099
3100 (defvar yas--active-snippets nil
3101   "List of currently active snippets")
3102 (make-variable-buffer-local 'yas--active-snippets)
3103
3104 (defvar yas--field-protection-overlays nil
3105   "Two overlays protect the current active field.")
3106
3107 (defvar yas-selected-text nil
3108   "The selected region deleted on the last snippet expansion.")
3109
3110 (defvar yas--start-column nil
3111   "The column where the snippet expansion started.")
3112
3113 (make-variable-buffer-local 'yas--active-field-overlay)
3114 (make-variable-buffer-local 'yas--field-protection-overlays)
3115 (put 'yas--active-field-overlay 'permanent-local t)
3116 (put 'yas--field-protection-overlays 'permanent-local t)
3117
3118 (cl-defstruct (yas--snippet (:constructor yas--make-snippet (expand-env)))
3119   "A snippet.
3120
3121 ..."
3122   expand-env
3123   (fields '())
3124   (exit nil)
3125   (id (yas--snippet-next-id) :read-only t)
3126   (control-overlay nil)
3127   active-field
3128   ;; stacked expansion: the `previous-active-field' slot saves the
3129   ;; active field where the child expansion took place
3130   previous-active-field
3131   force-exit)
3132
3133 (cl-defstruct (yas--field (:constructor yas--make-field (number start end parent-field)))
3134   "A field.
3135
3136 NUMBER is the field number.
3137 START and END are mostly buffer markers, but see \"apropos markers-to-points\".
3138 PARENT-FIELD is a `yas--field' this field is nested under, or nil.
3139 MIRRORS is a list of `yas--mirror's
3140 TRANSFORM is a lisp form.
3141 MODIFIED-P is a boolean set to true once user inputs text.
3142 NEXT is another `yas--field' or `yas--mirror' or `yas--exit'.
3143 "
3144   number
3145   start end
3146   parent-field
3147   (mirrors '())
3148   (transform nil)
3149   (modified-p nil)
3150   next)
3151
3152
3153 (cl-defstruct (yas--mirror (:constructor yas--make-mirror (start end transform)))
3154   "A mirror.
3155
3156 START and END are mostly buffer markers, but see \"apropos markers-to-points\".
3157 TRANSFORM is a lisp form.
3158 PARENT-FIELD is a `yas--field' this mirror is nested under, or nil.
3159 NEXT is another `yas--field' or `yas--mirror' or `yas--exit'
3160 DEPTH is a count of how many nested mirrors can affect this mirror"
3161   start end
3162   (transform nil)
3163   parent-field
3164   next
3165   depth)
3166
3167 (cl-defstruct (yas--exit (:constructor yas--make-exit (marker)))
3168   marker
3169   next)
3170
3171 (defmacro yas--letenv (env &rest body)
3172   "Evaluate BODY with bindings from ENV.
3173 ENV is a lisp expression that evaluates to list of elements with
3174 the form (VAR FORM), where VAR is a symbol and FORM is a lisp
3175 expression that evaluates to its value."
3176   (declare (debug (form body)) (indent 1))
3177   (let ((envvar (make-symbol "envvar")))
3178     `(let ((,envvar ,env))
3179        (cl-progv
3180            (mapcar #'car ,envvar)
3181            (mapcar (lambda (v-f) (eval (cadr v-f))) ,envvar)
3182          ,@body))))
3183
3184 (defun yas--snippet-map-markers (fun snippet)
3185   "Apply FUN to all marker (sub)fields in SNIPPET.
3186 Update each field with the result of calling FUN."
3187   (dolist (field (yas--snippet-fields snippet))
3188     (setf (yas--field-start field) (funcall fun (yas--field-start field)))
3189     (setf (yas--field-end field)   (funcall fun (yas--field-end field)))
3190     (dolist (mirror (yas--field-mirrors field))
3191       (setf (yas--mirror-start mirror) (funcall fun (yas--mirror-start mirror)))
3192       (setf (yas--mirror-end mirror)   (funcall fun (yas--mirror-end mirror)))))
3193   (let ((snippet-exit (yas--snippet-exit snippet)))
3194     (when snippet-exit
3195       (setf (yas--exit-marker snippet-exit)
3196             (funcall fun (yas--exit-marker snippet-exit))))))
3197
3198 (defun yas--snippet-live-p (snippet)
3199   "Return non-nil if SNIPPET hasn't been committed."
3200   (catch 'live
3201     (yas--snippet-map-markers (lambda (m)
3202                                 (if (markerp m) m
3203                                   (throw 'live nil)))
3204                               snippet)
3205     t))
3206
3207 (defun yas--apply-transform (field-or-mirror field &optional empty-on-nil-p)
3208   "Calculate transformed string for FIELD-OR-MIRROR from FIELD.
3209
3210 If there is no transform for ht field, return nil.
3211
3212 If there is a transform but it returns nil, return the empty
3213 string iff EMPTY-ON-NIL-P is true."
3214   (let* ((yas-text (yas--field-text-for-display field))
3215          (yas-modified-p (yas--field-modified-p field))
3216          (transform (if (yas--mirror-p field-or-mirror)
3217                         (yas--mirror-transform field-or-mirror)
3218                       (yas--field-transform field-or-mirror)))
3219          (start-point (if (yas--mirror-p field-or-mirror)
3220                           (yas--mirror-start field-or-mirror)
3221                         (yas--field-start field-or-mirror)))
3222          (transformed (and transform
3223                            (save-excursion
3224                              (goto-char start-point)
3225                              (let ((ret (yas--eval-for-string transform)))
3226                                (or ret (and empty-on-nil-p "")))))))
3227     transformed))
3228
3229 (defsubst yas--replace-all (from to &optional text)
3230   "Replace all occurrences from FROM to TO.
3231
3232 With optional string TEXT do it in that string."
3233   (if text
3234       (replace-regexp-in-string (regexp-quote from) to text t t)
3235     (goto-char (point-min))
3236     (while (search-forward from nil t)
3237       (replace-match to t t text))))
3238
3239 (defun yas--snippet-find-field (snippet number)
3240   (cl-find-if (lambda (field)
3241                 (eq number (yas--field-number field)))
3242               (yas--snippet-fields snippet)))
3243
3244 (defun yas--snippet-sort-fields (snippet)
3245   "Sort the fields of SNIPPET in navigation order."
3246   (setf (yas--snippet-fields snippet)
3247         (sort (yas--snippet-fields snippet)
3248               #'yas--snippet-field-compare)))
3249
3250 (defun yas--snippet-field-compare (field1 field2)
3251   "Compare FIELD1 and FIELD2.
3252
3253 The field with a number is sorted first.  If they both have a
3254 number, compare through the number.  If neither have, compare
3255 through the field's start point"
3256   (let ((n1 (yas--field-number field1))
3257         (n2 (yas--field-number field2)))
3258     (if n1
3259         (if n2
3260             (or (zerop n2) (and (not (zerop n1))
3261                                 (< n1 n2)))
3262           (not (zerop n1)))
3263       (if n2
3264           (zerop n2)
3265         (< (yas--field-start field1)
3266            (yas--field-start field2))))))
3267
3268 (defun yas--field-probably-deleted-p (snippet field)
3269   "Guess if SNIPPET's FIELD should be skipped."
3270   (and
3271    ;; field must be zero length
3272    ;;
3273    (zerop (- (yas--field-start field) (yas--field-end field)))
3274    ;; field must have been modified
3275    ;;
3276    (yas--field-modified-p field)
3277    ;; either:
3278    (or
3279     ;;  1) it's a nested field
3280     ;;
3281     (yas--field-parent-field field)
3282     ;;  2) ends just before the snippet end
3283     ;;
3284     (and (eq field (car (last (yas--snippet-fields snippet))))
3285          (= (yas--field-start field) (overlay-end (yas--snippet-control-overlay snippet)))))
3286    ;; the field numbered 0, just before the exit marker, should
3287    ;; never be skipped
3288    ;;
3289    (not (and (yas--field-number field)
3290              (zerop (yas--field-number field))))))
3291
3292 (defun yas-active-snippets (&optional beg end)
3293   "Return a sorted list of active snippets.
3294 The most recently-inserted snippets are returned first.
3295
3296 Only snippets overlapping the region BEG ... END are returned.
3297 Overlapping has the same meaning as described in `overlays-in'.
3298 If END is omitted, it defaults to (1+ BEG).  If BEG is omitted,
3299 it defaults to point.  A non-nil, non-buffer position BEG is
3300 equivalent to a range covering the whole buffer."
3301   (unless beg
3302     (setq beg (point)))
3303   (cond ((not (or (integerp beg) (markerp beg)))
3304          (setq beg (point-min) end (point-max)))
3305         ((not end)
3306          (setq end (1+ beg))))
3307   (if (and (eq beg (point-min))
3308            (eq end (point-max)))
3309       yas--active-snippets
3310     ;; Note: don't use `mapcar' here, since it would allocate in
3311     ;; proportion to the amount of overlays, even though the list of
3312     ;; active snippets should be very small.
3313     (let ((snippets nil))
3314       (dolist (ov (overlays-in beg end))
3315         (let ((snippet (overlay-get ov 'yas--snippet)))
3316           ;; Snippets have multiple overlays, so check for dups.
3317           (when (and snippet (not (memq snippet snippets)))
3318             (push snippet snippets))))
3319       (cl-sort snippets #'>= :key #'yas--snippet-id))))
3320
3321 (define-obsolete-function-alias 'yas--snippets-at-point
3322   'yas-active-snippets "0.12")
3323
3324 (defun yas-next-field-or-maybe-expand ()
3325   "Try to expand a snippet at a key before point.
3326
3327 Otherwise delegate to `yas-next-field'."
3328   (interactive)
3329   (if yas-triggers-in-field
3330       (let ((yas-fallback-behavior 'return-nil)
3331             (active-field (overlay-get yas--active-field-overlay 'yas--field)))
3332         (when active-field
3333           (unless (yas-expand-from-trigger-key active-field)
3334             (yas-next-field))))
3335     (yas-next-field)))
3336
3337 (defun yas-next-field-will-exit-p (&optional arg)
3338   "Return non-nil if (yas-next-field ARG) would exit the current snippet."
3339   (let ((snippet (car (yas-active-snippets)))
3340         (active (overlay-get yas--active-field-overlay 'yas--field)))
3341     (when snippet
3342       (not (yas--find-next-field arg snippet active)))))
3343
3344 (defun yas--find-next-field (n snippet active)
3345   "Return the Nth field after the ACTIVE one in SNIPPET."
3346   (let ((live-fields (cl-remove-if
3347                       (lambda (field)
3348                         (and (not (eq field active))
3349                              (yas--field-probably-deleted-p snippet field)))
3350                       (yas--snippet-fields snippet))))
3351     (nth (abs n) (memq active (if (>= n 0) live-fields (reverse live-fields))))))
3352
3353 (defun yas-next-field (&optional arg)
3354   "Navigate to the ARGth next field.
3355
3356 If there's none, exit the snippet."
3357   (interactive)
3358   (unless arg (setq arg 1))
3359   (let* ((active-field (overlay-get yas--active-field-overlay 'yas--field))
3360          (snippet (car (yas-active-snippets (yas--field-start active-field)
3361                                             (yas--field-end active-field))))
3362          (target-field (yas--find-next-field arg snippet active-field)))
3363     (yas--letenv (yas--snippet-expand-env snippet)
3364       ;; Apply transform to active field.
3365       (when active-field
3366         (let ((yas-moving-away-p t))
3367           (when (yas--field-update-display active-field)
3368             (yas--update-mirrors snippet))))
3369       ;; Now actually move...
3370       (if target-field
3371           (yas--move-to-field snippet target-field)
3372         (yas-exit-snippet snippet)))))
3373
3374 (defun yas--place-overlays (snippet field)
3375   "Correctly place overlays for SNIPPET's FIELD."
3376   (yas--make-move-field-protection-overlays snippet field)
3377   ;; Only move active field overlays if this is field is from the
3378   ;; innermost snippet.
3379   (when (eq snippet (car (yas-active-snippets (1- (yas--field-start field))
3380                                               (1+ (yas--field-end field)))))
3381     (yas--make-move-active-field-overlay snippet field)))
3382
3383 (defun yas--move-to-field (snippet field)
3384   "Update SNIPPET to move to field FIELD.
3385
3386 Also create some protection overlays"
3387   (goto-char (yas--field-start field))
3388   (yas--place-overlays snippet field)
3389   (overlay-put yas--active-field-overlay 'yas--snippet snippet)
3390   (overlay-put yas--active-field-overlay 'yas--field field)
3391   (let ((number (yas--field-number field)))
3392     ;; check for the special ${0: ...} field
3393     (if (and number (zerop number))
3394         (progn
3395           (set-mark (yas--field-end field))
3396           (setf (yas--snippet-force-exit snippet)
3397                 (or (yas--field-transform field)
3398                     t)))
3399       ;; make this field active
3400       (setf (yas--snippet-active-field snippet) field)
3401       ;; primary field transform: first call to snippet transform
3402       (unless (yas--field-modified-p field)
3403         (if (yas--field-update-display field)
3404             (yas--update-mirrors snippet)
3405           (setf (yas--field-modified-p field) nil))))))
3406
3407 (defun yas-prev-field ()
3408   "Navigate to prev field.  If there's none, exit the snippet."
3409   (interactive)
3410   (yas-next-field -1))
3411
3412 (defun yas-abort-snippet (&optional snippet)
3413   (interactive)
3414   (let ((snippet (or snippet
3415                      (car (yas-active-snippets)))))
3416     (when snippet
3417       (setf (yas--snippet-force-exit snippet) t))))
3418
3419 (defun yas-exit-snippet (snippet)
3420   "Goto exit-marker of SNIPPET."
3421   (interactive (list (cl-first (yas-active-snippets))))
3422   (when snippet
3423     (setf (yas--snippet-force-exit snippet) t)
3424     (goto-char (if (yas--snippet-exit snippet)
3425                    (yas--exit-marker (yas--snippet-exit snippet))
3426                  (overlay-end (yas--snippet-control-overlay snippet))))))
3427
3428 (defun yas-exit-all-snippets ()
3429   "Exit all snippets."
3430   (interactive)
3431   (mapc #'(lambda (snippet)
3432             (yas-exit-snippet snippet)
3433             (yas--check-commit-snippet))
3434         (yas-active-snippets 'all)))
3435
3436
3437 ;;; Some low level snippet-routines:
3438
3439 (defvar yas--inhibit-overlay-hooks nil
3440   "Bind this temporarily to non-nil to prevent running `yas--on-*-modification'.")
3441
3442 (defvar yas-snippet-beg nil "Beginning position of the last snippet committed.")
3443 (defvar yas-snippet-end nil "End position of the last snippet committed.")
3444
3445 (defun yas--commit-snippet (snippet)
3446   "Commit SNIPPET, but leave point as it is.
3447
3448 This renders the snippet as ordinary text."
3449
3450   (let ((control-overlay (yas--snippet-control-overlay snippet)))
3451     ;;
3452     ;; Save the end of the moribund snippet in case we need to revive it
3453     ;; its original expansion.
3454     ;;
3455     (when (and control-overlay
3456                (overlay-buffer control-overlay))
3457       (setq yas-snippet-beg (overlay-start control-overlay))
3458       (setq yas-snippet-end (overlay-end control-overlay))
3459       (delete-overlay control-overlay)
3460       (setf (yas--snippet-control-overlay snippet) nil))
3461
3462     (let ((yas--inhibit-overlay-hooks t))
3463       (when yas--active-field-overlay
3464         (delete-overlay yas--active-field-overlay))
3465       (when yas--field-protection-overlays
3466         (mapc #'delete-overlay yas--field-protection-overlays)))
3467
3468     ;; stacked expansion: if the original expansion took place from a
3469     ;; field, make sure we advance it here at least to
3470     ;; `yas-snippet-end'...
3471     ;;
3472     (let ((previous-field (yas--snippet-previous-active-field snippet)))
3473       (when (and yas-snippet-end previous-field)
3474         (yas--advance-end-maybe previous-field yas-snippet-end)))
3475
3476     ;; Convert all markers to points,
3477     ;;
3478     (yas--markers-to-points snippet)
3479
3480     ;; It's no longer an active snippet.
3481     (cl-callf2 delq snippet yas--active-snippets)
3482
3483     ;; Take care of snippet revival on undo.
3484     (if (and yas-snippet-revival (listp buffer-undo-list))
3485         (push `(apply yas--snippet-revive ,yas-snippet-beg ,yas-snippet-end ,snippet)
3486               buffer-undo-list)
3487       ;; Dismember the snippet... this is useful if we get called
3488       ;; again from `yas--take-care-of-redo'....
3489       (setf (yas--snippet-fields snippet) nil)))
3490
3491   (yas--message 4 "Snippet %s exited." (yas--snippet-id snippet)))
3492
3493 (defvar yas--snippets-to-move nil)
3494 (make-variable-buffer-local 'yas--snippets-to-move)
3495
3496 (defun yas--prepare-snippets-for-move (beg end buf pos)
3497   "Gather snippets in BEG..END for moving to POS in BUF."
3498   (let ((to-move nil)
3499         (snippets (yas-active-snippets beg end))
3500         (dst-base-line (with-current-buffer buf
3501                          (count-lines (point-min) pos))))
3502     (when snippets
3503       (dolist (snippet snippets)
3504         (yas--snippet-map-markers
3505          (lambda (m)
3506            (goto-char m)
3507            (beginning-of-line)
3508            (prog1 (cons (count-lines (point-min) (point))
3509                         (yas--snapshot-marker-location m))
3510              (set-marker m nil)))
3511          snippet)
3512         (let ((ctrl-ov (yas--snapshot-overlay-line-location
3513                         (yas--snippet-control-overlay snippet))))
3514           (push (list ctrl-ov dst-base-line snippet) to-move)
3515           (delete-overlay (car ctrl-ov))))
3516       (with-current-buffer buf
3517         (setq yas--snippets-to-move (nconc to-move yas--snippets-to-move))))))
3518
3519 (defun yas--on-buffer-kill ()
3520   ;; Org mode uses temp buffers for fontification and "native tab",
3521   ;; move all the snippets to the original org-mode buffer when it's
3522   ;; killed.
3523   (let ((org-marker nil))
3524     (when (and yas-minor-mode
3525                (or (bound-and-true-p org-edit-src-from-org-mode)
3526                    (bound-and-true-p org-src--from-org-mode))
3527                (markerp
3528                 (setq org-marker
3529                       (or (bound-and-true-p org-edit-src-beg-marker)
3530                           (bound-and-true-p org-src--beg-marker)))))
3531       (yas--prepare-snippets-for-move
3532        (point-min) (point-max)
3533        (marker-buffer org-marker) org-marker))))
3534
3535 (add-hook 'kill-buffer-hook #'yas--on-buffer-kill)
3536
3537 (defun yas--finish-moving-snippets ()
3538   "Finish job started in `yas--prepare-snippets-for-move'."
3539   (cl-loop for (ctrl-ov base-line snippet) in yas--snippets-to-move
3540            for base-pos = (progn (goto-char (point-min))
3541                                  (forward-line base-line) (point))
3542            do (yas--snippet-map-markers
3543                (lambda (l-m-r-w)
3544                  (goto-char base-pos)
3545                  (forward-line (nth 0 l-m-r-w))
3546                  (save-restriction
3547                    (narrow-to-region (line-beginning-position)
3548                                      (line-end-position))
3549                    (yas--restore-marker-location (cdr l-m-r-w)))
3550                  (nth 1 l-m-r-w))
3551                snippet)
3552            (goto-char base-pos)
3553            (yas--restore-overlay-location ctrl-ov)
3554            (yas--maybe-move-to-active-field snippet))
3555   (setq yas--snippets-to-move nil))
3556
3557 (defun yas--safely-call-fun (fun)
3558   "Call FUN and catch any errors."
3559   (condition-case error
3560       (funcall fun)
3561     ((debug error)
3562      (yas--message 2 "Error running %s: %s" fun
3563                    (error-message-string error)))))
3564
3565 (defun yas--safely-run-hook (hook)
3566   "Call HOOK's functions.
3567 HOOK should be a symbol, a hook variable, as in `run-hooks'."
3568   (let ((debug-on-error (and (not (memq yas-good-grace '(t hooks)))
3569                              debug-on-error)))
3570     (yas--safely-call-fun (apply-partially #'run-hooks hook))))
3571
3572 (defun yas--check-commit-snippet ()
3573   "Check if point exited the currently active field of the snippet.
3574
3575 If so cleans up the whole snippet up."
3576   (let* ((snippet-exit-transform nil)
3577          (exited-snippets-p nil)
3578          ;; Record the custom snippet `yas-after-exit-snippet-hook'
3579          ;; set in the expand-env field.
3580          (snippet-exit-hook yas-after-exit-snippet-hook))
3581     (dolist (snippet yas--active-snippets)
3582       (let ((active-field (yas--snippet-active-field snippet)))
3583         (yas--letenv (yas--snippet-expand-env snippet)
3584           ;; Note: the `force-exit' field could be a transform in case of
3585           ;; ${0: ...}, see `yas--move-to-field'.
3586           (setq snippet-exit-transform (yas--snippet-force-exit snippet))
3587           (cond ((or snippet-exit-transform
3588                      (not (and active-field (yas--field-contains-point-p active-field))))
3589                  (setf (yas--snippet-force-exit snippet) nil)
3590                  (setq snippet-exit-hook yas-after-exit-snippet-hook)
3591                  (yas--commit-snippet snippet)
3592                  (setq exited-snippets-p t))
3593                 ((and active-field
3594                       (or (not yas--active-field-overlay)
3595                           (not (overlay-buffer yas--active-field-overlay))))
3596                  ;;
3597                  ;; stacked expansion: this case is mainly for recent
3598                  ;; snippet exits that place us back int the field of
3599                  ;; another snippet
3600                  ;;
3601                  (save-excursion
3602                    (yas--move-to-field snippet active-field)
3603                    (yas--update-mirrors snippet)))
3604                 (t
3605                  nil)))))
3606     (unless (or yas--active-snippets (not exited-snippets-p))
3607       (when snippet-exit-transform
3608         (yas--eval-for-effect snippet-exit-transform))
3609       (let ((yas-after-exit-snippet-hook snippet-exit-hook))
3610         (yas--safely-run-hook 'yas-after-exit-snippet-hook)))))
3611
3612 ;; Apropos markers-to-points:
3613 ;;
3614 ;; This was found useful for performance reasons, so that an excessive
3615 ;; number of live markers aren't kept around in the
3616 ;; `buffer-undo-list'.  We don't reuse the original marker object
3617 ;; because that leaves an unreadable object in the history list and
3618 ;; undo-tree persistence has trouble with that.
3619 ;;
3620 ;; This shouldn't bring horrible problems with undo/redo, but you
3621 ;; never know.
3622 ;;
3623 (defun yas--markers-to-points (snippet)
3624   "Save all markers of SNIPPET as positions."
3625   (yas--snippet-map-markers (lambda (m)
3626                               (prog1 (marker-position m)
3627                                 (set-marker m nil)))
3628                             snippet))
3629
3630 (defun yas--points-to-markers (snippet)
3631   "Restore SNIPPET's marker positions, saved by `yas--markers-to-points'."
3632   (yas--snippet-map-markers #'copy-marker snippet))
3633
3634 (defun yas--maybe-move-to-active-field (snippet)
3635   "Try to move to SNIPPET's active (or first) field and return it if found."
3636   (let ((target-field (or (yas--snippet-active-field snippet)
3637                           (car (yas--snippet-fields snippet)))))
3638     (when target-field
3639       (yas--move-to-field snippet target-field)
3640       target-field)))
3641
3642 (defun yas--field-contains-point-p (field &optional point)
3643   (let ((point (or point
3644                    (point))))
3645     (and (>= point (yas--field-start field))
3646          (<= point (yas--field-end field)))))
3647
3648 (defun yas--field-text-for-display (field)
3649   "Return the propertized display text for field FIELD."
3650   (buffer-substring (yas--field-start field) (yas--field-end field)))
3651
3652 (defun yas--undo-in-progress ()
3653   "True if some kind of undo is in progress."
3654   (or undo-in-progress
3655       (eq this-command 'undo)
3656       (eq this-command 'redo)))
3657
3658 (defun yas--make-control-overlay (snippet start end)
3659   "Create the control overlay that surrounds the snippet and
3660 holds the keymap."
3661   (let ((overlay (make-overlay start
3662                                end
3663                                nil
3664                                nil
3665                                t)))
3666     (overlay-put overlay 'keymap yas-keymap)
3667     (overlay-put overlay 'priority yas-overlay-priority)
3668     (overlay-put overlay 'yas--snippet snippet)
3669     overlay))
3670
3671 (defun yas-current-field ()
3672   "Return the currently active field."
3673   (and yas--active-field-overlay
3674        (overlay-buffer yas--active-field-overlay)
3675        (overlay-get yas--active-field-overlay 'yas--field)))
3676
3677 (defun yas--maybe-clear-field-filter (cmd)
3678   "Return CMD if at start of unmodified snippet field.
3679 Use as a `:filter' argument for a conditional keybinding."
3680   (let ((field (yas-current-field)))
3681     (when (and field
3682                (not (yas--field-modified-p field))
3683                (eq (point) (marker-position (yas--field-start field))))
3684       cmd)))
3685
3686 (defun yas-skip-and-clear-field (&optional field)
3687   "Clears unmodified FIELD if at field start, skips to next tab."
3688   (interactive)
3689   (yas--skip-and-clear (or field (yas-current-field)))
3690   (yas-next-field 1))
3691
3692 (defun yas-clear-field (&optional field)
3693   "Clears unmodified FIELD if at field start."
3694   (interactive)
3695   (yas--skip-and-clear (or field (yas-current-field))))
3696
3697 (defun yas-skip-and-clear-or-delete-char (&optional field)
3698   "Clears unmodified field if at field start, skips to next tab.
3699
3700 Otherwise deletes a character normally by calling `delete-char'."
3701   (interactive)
3702   (declare (obsolete "Bind to `yas-maybe-skip-and-clear-field' instead." "0.13"))
3703   (cond ((yas--maybe-clear-field-filter t)
3704          (yas--skip-and-clear (or field (yas-current-field)))
3705          (yas-next-field 1))
3706         (t (call-interactively 'delete-char))))
3707
3708 (defun yas--skip-and-clear (field &optional from)
3709   "Deletes the region of FIELD and sets it's modified state to t.
3710 If given, FROM indicates position to start at instead of FIELD's beginning."
3711   ;; Just before skipping-and-clearing the field, mark its children
3712   ;; fields as modified, too. If the children have mirrors-in-fields
3713   ;; this prevents them from updating erroneously (we're skipping and
3714   ;; deleting!).
3715   ;;
3716   (yas--mark-this-and-children-modified field)
3717   (unless (= (yas--field-start field) (yas--field-end field))
3718     (delete-region (or from (yas--field-start field)) (yas--field-end field))))
3719
3720 (defun yas--mark-this-and-children-modified (field)
3721   (setf (yas--field-modified-p field) t)
3722   (let ((fom (yas--field-next field)))
3723     (while (and fom
3724                 (yas--fom-parent-field fom))
3725       (when (and (eq (yas--fom-parent-field fom) field)
3726                  (yas--field-p fom))
3727         (yas--mark-this-and-children-modified fom))
3728       (setq fom (yas--fom-next fom)))))
3729
3730 (defun yas--make-move-active-field-overlay (snippet field)
3731   "Place the active field overlay in SNIPPET's FIELD.
3732
3733 Move the overlay, or create it if it does not exit."
3734   (if (and yas--active-field-overlay
3735            (overlay-buffer yas--active-field-overlay))
3736       (move-overlay yas--active-field-overlay
3737                     (yas--field-start field)
3738                     (yas--field-end field))
3739     (setq yas--active-field-overlay
3740           (make-overlay (yas--field-start field)
3741                         (yas--field-end field)
3742                         nil nil t))
3743     (overlay-put yas--active-field-overlay 'priority yas-overlay-priority)
3744     (overlay-put yas--active-field-overlay 'face 'yas-field-highlight-face)
3745     (overlay-put yas--active-field-overlay 'yas--snippet snippet)
3746     (overlay-put yas--active-field-overlay 'modification-hooks '(yas--on-field-overlay-modification))
3747     (overlay-put yas--active-field-overlay 'insert-in-front-hooks
3748                  '(yas--on-field-overlay-modification))
3749     (overlay-put yas--active-field-overlay 'insert-behind-hooks
3750                  '(yas--on-field-overlay-modification))))
3751
3752 (defun yas--skip-and-clear-field-p (field beg _end length)
3753   "Tell if newly modified FIELD should be cleared and skipped.
3754 BEG, END and LENGTH like overlay modification hooks."
3755   (and (= length 0) ; A 0 pre-change length indicates insertion.
3756        (= beg (yas--field-start field)) ; Insertion at field start?
3757        (not (yas--field-modified-p field))))
3758
3759 (defun yas--on-field-overlay-modification (overlay after? beg end &optional length)
3760   "Clears the field and updates mirrors, conditionally.
3761
3762 Only clears the field if it hasn't been modified and point is at
3763 field start.  This hook does nothing if an undo is in progress."
3764   (unless (or (not after?)
3765               yas--inhibit-overlay-hooks
3766               (not (overlayp yas--active-field-overlay)) ; Avoid Emacs bug #21824.
3767               ;; If a single change hits multiple overlays of the same
3768               ;; snippet, then we delete the snippet the first time,
3769               ;; and then subsequent calls get a deleted overlay.
3770               ;; Don't delete the snippet again!
3771               (not (overlay-buffer overlay))
3772               (yas--undo-in-progress))
3773     (let* ((inhibit-modification-hooks nil)
3774            (yas--inhibit-overlay-hooks t)
3775            (field (overlay-get overlay 'yas--field))
3776            (snippet (overlay-get yas--active-field-overlay 'yas--snippet)))
3777       (if (yas--snippet-live-p snippet)
3778           (save-match-data
3779             (yas--letenv (yas--snippet-expand-env snippet)
3780               (when (yas--skip-and-clear-field-p field beg end length)
3781                 ;; We delete text starting from the END of insertion.
3782                 (yas--skip-and-clear field end))
3783               (setf (yas--field-modified-p field) t)
3784               ;; Adjust any pending active fields in case of stacked
3785               ;; expansion.
3786               (let ((pfield field)
3787                     (psnippets (yas-active-snippets beg end)))
3788                 (while (and pfield psnippets)
3789                   (let ((psnippet (pop psnippets)))
3790                     (cl-assert (memq pfield (yas--snippet-fields psnippet)))
3791                     (yas--advance-end-maybe pfield (overlay-end overlay))
3792                     (setq pfield (yas--snippet-previous-active-field psnippet)))))
3793               (save-excursion
3794                 (yas--field-update-display field))
3795               (yas--update-mirrors snippet)))
3796         (lwarn '(yasnippet zombie) :warning "Killing zombie snippet!")
3797         (delete-overlay overlay)))))
3798
3799 (defun yas--auto-fill ()
3800   (let* ((orig-point (point))
3801          (end (progn (forward-paragraph) (point)))
3802          (beg (progn (backward-paragraph) (point)))
3803          (snippets (yas-active-snippets beg end))
3804          (remarkers nil)
3805          (reoverlays nil))
3806     (dolist (snippet snippets)
3807       (dolist (m (yas--collect-snippet-markers snippet))
3808         (when (and (<= beg m) (<= m end))
3809           (push (yas--snapshot-marker-location m beg end) remarkers)))
3810       (push (yas--snapshot-overlay-location
3811              (yas--snippet-control-overlay snippet) beg end)
3812             reoverlays))
3813     (goto-char orig-point)
3814     (let ((yas--inhibit-overlay-hooks t))
3815       (if (null yas--original-auto-fill-function)
3816           ;; Try to get more info on #873/919.
3817           (let ((yas--fill-fun-values `((t ,(default-value 'yas--original-auto-fill-function))))
3818                 (fill-fun-values `((t ,(default-value 'auto-fill-function))))
3819                 ;; Listing 2 buffers with the same value is enough
3820                 (print-length 3))
3821             (save-current-buffer
3822               (dolist (buf (let ((bufs (buffer-list)))
3823                              ;; List the current buffer first.
3824                              (setq bufs (cons (current-buffer)
3825                                               (remq (current-buffer) bufs)))))
3826                 (set-buffer buf)
3827                 (let* ((yf-cell (assq yas--original-auto-fill-function
3828                                       yas--fill-fun-values))
3829                        (af-cell (assq auto-fill-function fill-fun-values)))
3830                   (when (local-variable-p 'yas--original-auto-fill-function)
3831                     (if yf-cell (setcdr yf-cell (cons buf (cdr yf-cell)))
3832                       (push (list yas--original-auto-fill-function buf) yas--fill-fun-values)))
3833                   (when (local-variable-p 'auto-fill-function)
3834                     (if af-cell (setcdr af-cell (cons buf (cdr af-cell)))
3835                       (push (list auto-fill-function buf) fill-fun-values))))))
3836                  (lwarn '(yasnippet auto-fill bug) :error
3837                         "`yas--original-auto-fill-function' unexpectedly nil in %S!  Disabling auto-fill.
3838   %S
3839   `auto-fill-function': %S\n%s"
3840                         (current-buffer) yas--fill-fun-values fill-fun-values
3841                         (if (fboundp 'backtrace--print-frame)
3842                             (with-output-to-string
3843                               (mapc (lambda (frame)
3844                                       (apply #'backtrace--print-frame frame))
3845                                     yas--watch-auto-fill-backtrace))
3846                           ""))
3847                  ;; Try to avoid repeated triggering of this bug.
3848                  (auto-fill-mode -1)
3849                  ;; Don't pop up more than once in a session (still log though).
3850                  (defvar warning-suppress-types) ; `warnings' is autoloaded by `lwarn'.
3851                  (add-to-list 'warning-suppress-types '(yasnippet auto-fill bug)))
3852         (funcall yas--original-auto-fill-function)))
3853     (save-excursion
3854       (setq end (progn (forward-paragraph) (point)))
3855       (setq beg (progn (backward-paragraph) (point))))
3856     (save-excursion
3857       (save-restriction
3858         (narrow-to-region beg end)
3859         (mapc #'yas--restore-marker-location remarkers)
3860         (mapc #'yas--restore-overlay-location reoverlays))
3861       (mapc (lambda (snippet)
3862               (yas--letenv (yas--snippet-expand-env snippet)
3863                 (yas--update-mirrors snippet)))
3864             snippets))))
3865
3866
3867 ;;; Apropos protection overlays:
3868 ;;
3869 ;; These exist for nasty users who will try to delete parts of the
3870 ;; snippet outside the active field. Actual protection happens in
3871 ;; `yas--on-protection-overlay-modification'.
3872 ;;
3873 ;; As of github #537 this no longer inhibits the command by issuing an
3874 ;; error: all the snippets at point, including nested snippets, are
3875 ;; automatically commited and the current command can proceed.
3876 ;;
3877 (defun yas--make-move-field-protection-overlays (snippet field)
3878   "Place protection overlays surrounding SNIPPET's FIELD.
3879
3880 Move the overlays, or create them if they do not exit."
3881   (let ((start (yas--field-start field))
3882         (end (yas--field-end field)))
3883     ;; First check if the (1+ end) is contained in the buffer,
3884     ;; otherwise we'll have to do a bit of cheating and silently
3885     ;; insert a newline. the `(1+ (buffer-size))' should prevent this
3886     ;; when using stacked expansion
3887     ;;
3888     (when (< (buffer-size) end)
3889       (save-excursion
3890         (let ((yas--inhibit-overlay-hooks t))
3891           (goto-char (point-max))
3892           (newline))))
3893     ;; go on to normal overlay creation/moving
3894     ;;
3895     (cond ((and yas--field-protection-overlays
3896                 (cl-every #'overlay-buffer yas--field-protection-overlays))
3897            (move-overlay (nth 0 yas--field-protection-overlays)
3898                          (1- start) start)
3899            (move-overlay (nth 1 yas--field-protection-overlays) end (1+ end)))
3900           (t
3901            (setq yas--field-protection-overlays
3902                  (list (make-overlay (1- start) start nil t nil)
3903                        (make-overlay end (1+ end) nil t nil)))
3904            (dolist (ov yas--field-protection-overlays)
3905              (overlay-put ov 'face 'yas--field-debug-face)
3906              (overlay-put ov 'yas--snippet snippet)
3907              ;; (overlay-put ov 'evaporate t)
3908              (overlay-put ov 'modification-hooks '(yas--on-protection-overlay-modification)))))))
3909
3910 (defun yas--on-protection-overlay-modification (_overlay after? beg end &optional length)
3911   "Commit the snippet if the protection overlay is being killed."
3912   (unless (or yas--inhibit-overlay-hooks
3913               (not after?)
3914               (= length (- end beg)) ; deletion or insertion
3915               (yas--undo-in-progress))
3916     (let ((snippets (yas-active-snippets)))
3917       (yas--message 2 "Committing snippets. Action would destroy a protection overlay.")
3918       (cl-loop for snippet in snippets
3919                do (yas--commit-snippet snippet)))))
3920
3921 (add-to-list 'debug-ignored-errors "^Exit the snippet first!$")
3922
3923
3924 ;;; Snippet expansion and "stacked" expansion:
3925 ;;
3926 ;; Stacked expansion is when you try to expand a snippet when already
3927 ;; inside a snippet expansion.
3928 ;;
3929 ;; The parent snippet does not run its fields modification hooks
3930 ;; (`yas--on-field-overlay-modification' and
3931 ;; `yas--on-protection-overlay-modification') while the child snippet
3932 ;; is active. This means, among other things, that the mirrors of the
3933 ;; parent snippet are not updated, this only happening when one exits
3934 ;; the child snippet.
3935 ;;
3936 ;; Unfortunately, this also puts some ugly (and not fully-tested)
3937 ;; bits of code in `yas-expand-snippet' and
3938 ;; `yas--commit-snippet'. I've tried to mark them with "stacked
3939 ;; expansion:".
3940 ;;
3941 ;; This was thought to be safer in an undo/redo perspective, but
3942 ;; maybe the correct implementation is to make the globals
3943 ;; `yas--active-field-overlay' and `yas--field-protection-overlays' be
3944 ;; snippet-local and be active even while the child snippet is
3945 ;; running. This would mean a lot of overlay modification hooks
3946 ;; running, but if managed correctly (including overlay priorities)
3947 ;; they should account for all situations...
3948
3949 (defun yas-expand-snippet (snippet &optional start end expand-env)
3950   "Expand SNIPPET at current point.
3951
3952 Text between START and END will be deleted before inserting
3953 template.  EXPAND-ENV is a list of (SYM VALUE) let-style dynamic
3954 bindings considered when expanding the snippet.  If omitted, use
3955 SNIPPET's expand-env field.
3956
3957 SNIPPET may be a snippet structure (e.g., as returned by
3958 `yas-lookup-snippet'), or just a snippet body (which is a string
3959 for normal snippets, and a list for command snippets)."
3960   (cl-assert (and yas-minor-mode
3961                   (memq 'yas--post-command-handler post-command-hook))
3962              nil
3963              "[yas] `yas-expand-snippet' needs properly setup `yas-minor-mode'")
3964   (run-hooks 'yas-before-expand-snippet-hook)
3965
3966   (let* ((clear-field
3967           (let ((field (and yas--active-field-overlay
3968                             (overlay-buffer yas--active-field-overlay)
3969                             (overlay-get yas--active-field-overlay 'yas--field))))
3970             (and field (yas--skip-and-clear-field-p
3971                         field (point) (point) 0)
3972                  field)))
3973          (start (cond (start)
3974                       ((region-active-p)
3975                        (region-beginning))
3976                       (clear-field
3977                        (yas--field-start clear-field))
3978                       (t (point))))
3979          (end (cond (end)
3980                     ((region-active-p)
3981                      (region-end))
3982                     (clear-field
3983                      (yas--field-end clear-field))
3984                     (t (point))))
3985          (to-delete (and (> end start)
3986                          (buffer-substring-no-properties start end)))
3987          (yas-selected-text
3988           (cond (yas-selected-text)
3989                 ((and (region-active-p)
3990                       (not clear-field))
3991                  to-delete))))
3992     (goto-char start)
3993     (setq yas--indent-original-column (current-column))
3994     ;; Delete the region to delete, this *does* get undo-recorded.
3995     (when to-delete
3996       (delete-region start end))
3997
3998     (let ((content (if (yas--template-p snippet)
3999                        (yas--template-content snippet)
4000                      snippet)))
4001       (when (and (not expand-env) (yas--template-p snippet))
4002         (setq expand-env (yas--template-expand-env snippet)))
4003       (cond ((listp content)
4004              ;; x) This is a snippet-command.
4005              (yas--eval-for-effect content))
4006             (t
4007              ;; x) This is a snippet-snippet :-)
4008              (setq yas--start-column (current-column))
4009              ;; Stacked expansion: also shoosh the overlay modification hooks.
4010              (let ((yas--inhibit-overlay-hooks t))
4011                (setq snippet
4012                      (yas--snippet-create content expand-env start (point))))
4013
4014              ;; Stacked-expansion: This checks for stacked expansion, save the
4015              ;; `yas--previous-active-field' and advance its boundary.
4016              (let ((existing-field (and yas--active-field-overlay
4017                                         (overlay-buffer yas--active-field-overlay)
4018                                         (overlay-get yas--active-field-overlay 'yas--field))))
4019                (when existing-field
4020                  (setf (yas--snippet-previous-active-field snippet) existing-field)
4021                  (yas--advance-end-maybe existing-field (overlay-end yas--active-field-overlay))))
4022
4023              ;; Exit the snippet immediately if no fields.
4024              (unless (yas--snippet-fields snippet)
4025                (yas-exit-snippet snippet))
4026
4027              ;; Now, schedule a move to the first field.
4028              (let ((first-field (car (yas--snippet-fields snippet))))
4029                (when first-field
4030                  (sit-for 0) ;; fix issue 125
4031                  (yas--letenv (yas--snippet-expand-env snippet)
4032                    (yas--move-to-field snippet first-field))
4033                  (when (and (eq (yas--field-number first-field) 0)
4034                             (> (length (yas--field-text-for-display
4035                                         first-field))
4036                                0))
4037                    ;; Keep region for ${0:exit text}.
4038                    (setq deactivate-mark nil))))
4039              (yas--message 4 "snippet %d expanded." (yas--snippet-id snippet))
4040              t)))))
4041
4042 (defun yas--take-care-of-redo (snippet)
4043   "Commits SNIPPET, which in turn pushes an undo action for reviving it.
4044
4045 Meant to exit in the `buffer-undo-list'."
4046   ;; slightly optimize: this action is only needed for snippets with
4047   ;; at least one field
4048   (when (yas--snippet-fields snippet)
4049     (yas--commit-snippet snippet)))
4050
4051 (defun yas--snippet-revive (beg end snippet)
4052   "Revives SNIPPET and creates a control overlay from BEG to END.
4053
4054 BEG and END are, we hope, the original snippets boundaries.
4055 All the markers/points exiting existing inside SNIPPET should point
4056 to their correct locations *at the time the snippet is revived*.
4057
4058 After revival, push the `yas--take-care-of-redo' in the
4059 `buffer-undo-list'"
4060   ;; Reconvert all the points to markers
4061   (yas--points-to-markers snippet)
4062   ;; When at least one editable field existed in the zombie snippet,
4063   ;; try to revive the whole thing...
4064   (when (yas--maybe-move-to-active-field snippet)
4065     (setf (yas--snippet-control-overlay snippet) (yas--make-control-overlay snippet beg end))
4066     (overlay-put (yas--snippet-control-overlay snippet) 'yas--snippet snippet)
4067     (when (listp buffer-undo-list)
4068       (push `(apply yas--take-care-of-redo ,snippet)
4069             buffer-undo-list))))
4070
4071 (defun yas--snippet-create (content expand-env begin end)
4072   "Create a snippet from a template inserted at BEGIN to END.
4073
4074 Returns the newly created snippet."
4075   (save-restriction
4076     (let ((snippet (yas--make-snippet expand-env)))
4077       (yas--letenv expand-env
4078         ;; Put a single undo action for the expanded snippet's
4079         ;; content.
4080         (let ((buffer-undo-list t)
4081               (inhibit-modification-hooks t))
4082           ;; Some versions of cc-mode fail when inserting snippet
4083           ;; content in a narrowed buffer, so make sure to insert
4084           ;; before narrowing.  Furthermore, call before and after
4085           ;; change functions manually, otherwise cc-mode's cache can
4086           ;; get messed up.
4087           (goto-char begin)
4088           (run-hook-with-args 'before-change-functions begin begin)
4089           (insert content)
4090           (setq end (+ end (length content)))
4091           (narrow-to-region begin end)
4092           (goto-char (point-min))
4093           (yas--snippet-parse-create snippet)
4094           (run-hook-with-args 'after-change-functions (point-min) (point-max) 0))
4095         (when (listp buffer-undo-list)
4096           (push (cons (point-min) (point-max))
4097                 buffer-undo-list))
4098
4099         ;; Indent, collecting undo information normally.
4100         (yas--indent snippet)
4101
4102         ;; Follow up with `yas--take-care-of-redo' on the newly
4103         ;; inserted snippet boundaries.
4104         (when (listp buffer-undo-list)
4105           (push `(apply yas--take-care-of-redo ,snippet)
4106                 buffer-undo-list))
4107
4108         ;; Sort and link each field
4109         (yas--snippet-sort-fields snippet)
4110
4111         ;; Create keymap overlay for snippet
4112         (setf (yas--snippet-control-overlay snippet)
4113               (yas--make-control-overlay snippet (point-min) (point-max)))
4114
4115         ;; Move to end
4116         (goto-char (point-max))
4117
4118         (push snippet yas--active-snippets)
4119         snippet))))
4120
4121
4122 ;;; Apropos adjacencies and "fom's":
4123 ;;
4124 ;; Once the $-constructs bits like "$n" and "${:n" are deleted in the
4125 ;; recently expanded snippet, we might actually have many fields,
4126 ;; mirrors (and the snippet exit) in the very same position in the
4127 ;; buffer. Therefore we need to single-link the
4128 ;; fields-or-mirrors-or-exit (which I have abbreviated to "fom")
4129 ;; according to their original positions in the buffer.
4130 ;;
4131 ;; Then we have operation `yas--advance-end-maybe' and
4132 ;; `yas--advance-start-maybe', which conditionally push the starts and
4133 ;; ends of these foms down the chain.
4134 ;;
4135 ;; This allows for like the printf with the magic ",":
4136 ;;
4137 ;;   printf ("${1:%s}\\n"${1:$(if (string-match "%" text) "," "\);")}  \
4138 ;;   $2${1:$(if (string-match "%" text) "\);" "")}$0
4139 ;;
4140 (defun yas--fom-start (fom)
4141   (cond ((yas--field-p fom)
4142          (yas--field-start fom))
4143         ((yas--mirror-p fom)
4144          (yas--mirror-start fom))
4145         (t
4146          (yas--exit-marker fom))))
4147
4148 (defun yas--fom-end (fom)
4149   (cond ((yas--field-p fom)
4150          (yas--field-end fom))
4151         ((yas--mirror-p fom)
4152          (yas--mirror-end fom))
4153         (t
4154          (yas--exit-marker fom))))
4155
4156 (defun yas--fom-next (fom)
4157   (cond ((yas--field-p fom)
4158          (yas--field-next fom))
4159         ((yas--mirror-p fom)
4160          (yas--mirror-next fom))
4161         (t
4162          (yas--exit-next fom))))
4163
4164 (defun yas--fom-parent-field (fom)
4165   (cond ((yas--field-p fom)
4166          (yas--field-parent-field fom))
4167         ((yas--mirror-p fom)
4168          (yas--mirror-parent-field fom))
4169         (t
4170          nil)))
4171
4172 (defun yas--calculate-adjacencies (snippet)
4173   "Calculate adjacencies for fields or mirrors of SNIPPET.
4174
4175 This is according to their relative positions in the buffer, and
4176 has to be called before the $-constructs are deleted."
4177   (let* ((fom-set-next-fom
4178          (lambda (fom nextfom)
4179            (cond ((yas--field-p fom)
4180                   (setf (yas--field-next fom) nextfom))
4181                  ((yas--mirror-p fom)
4182                   (setf (yas--mirror-next fom) nextfom))
4183                  (t
4184                   (setf (yas--exit-next fom) nextfom)))))
4185         (compare-fom-begs
4186          (lambda (fom1 fom2)
4187            (if (= (yas--fom-start fom2) (yas--fom-start fom1))
4188                (yas--mirror-p fom2)
4189              (>= (yas--fom-start fom2) (yas--fom-start fom1)))))
4190         (link-foms fom-set-next-fom))
4191     ;; make some yas--field, yas--mirror and yas--exit soup
4192     (let ((soup))
4193       (when (yas--snippet-exit snippet)
4194         (push (yas--snippet-exit snippet) soup))
4195       (dolist (field (yas--snippet-fields snippet))
4196         (push field soup)
4197         (dolist (mirror (yas--field-mirrors field))
4198           (push mirror soup)))
4199       (setq soup
4200             (sort soup compare-fom-begs))
4201       (when soup
4202         (cl-reduce link-foms soup)))))
4203
4204 (defun yas--calculate-simple-fom-parentage (snippet fom)
4205   "Discover if FOM is parented by some field in SNIPPET.
4206
4207 Use the tightest containing field if more than one field contains
4208 the mirror.  Intended to be called *before* the dollar-regions are
4209 deleted."
4210   (let ((min (point-min))
4211         (max (point-max)))
4212     (dolist (field (remq fom (yas--snippet-fields snippet)))
4213       (when (and (<= (yas--field-start field) (yas--fom-start fom))
4214                  (<= (yas--fom-end fom) (yas--field-end field))
4215                (< min (yas--field-start field))
4216                (< (yas--field-end field) max))
4217           (setq min (yas--field-start field)
4218                 max (yas--field-end field))
4219           (cond ((yas--field-p fom)
4220                  (setf (yas--field-parent-field fom) field))
4221                 ((yas--mirror-p fom)
4222                  (setf (yas--mirror-parent-field fom) field))
4223                 (t ; it's an exit, so noop
4224                  nil ))))))
4225
4226 (defun yas--advance-end-maybe (fom newend)
4227   "Maybe advance FOM's end to NEWEND if it needs it.
4228
4229 If it does, also:
4230
4231 * call `yas--advance-start-maybe' on FOM's next fom.
4232
4233 * in case FOM is field call `yas--advance-end-maybe' on its parent
4234   field
4235
4236 Also, if FOM is an exit-marker, always call
4237 `yas--advance-start-maybe' on its next fom.  This is because
4238 exit-marker have identical start and end markers."
4239   (cond ((and fom (< (yas--fom-end fom) newend))
4240          (set-marker (yas--fom-end fom) newend)
4241          (yas--advance-start-maybe (yas--fom-next fom) newend)
4242          (yas--advance-end-of-parents-maybe (yas--fom-parent-field fom) newend))
4243         ((yas--exit-p fom)
4244          (yas--advance-start-maybe (yas--fom-next fom) newend))))
4245
4246 (defun yas--advance-start-maybe (fom newstart)
4247   "Maybe advance FOM's start to NEWSTART if it needs it.
4248
4249 If it does, also call `yas--advance-end-maybe' on FOM."
4250   (when (and fom (< (yas--fom-start fom) newstart))
4251     (set-marker (yas--fom-start fom) newstart)
4252     (yas--advance-end-maybe fom newstart)))
4253
4254 (defun yas--advance-end-of-parents-maybe (field newend)
4255   "Like `yas--advance-end-maybe' but for parent fields.
4256
4257 Only works for fields and doesn't care about the start of the
4258 next FOM.  Works its way up recursively for parents of parents."
4259   (when (and field
4260              (< (yas--field-end field) newend))
4261     (set-marker (yas--field-end field) newend)
4262     (yas--advance-end-of-parents-maybe (yas--field-parent-field field) newend)))
4263
4264 (defvar yas--dollar-regions nil
4265   "When expanding the snippet the \"parse-create\" functions add
4266 cons cells to this var.")
4267
4268 (defvar yas--indent-markers nil
4269   "List of markers for manual indentation.")
4270
4271 (defun yas--snippet-parse-create (snippet)
4272   "Parse a recently inserted snippet template, creating all
4273 necessary fields, mirrors and exit points.
4274
4275 Meant to be called in a narrowed buffer, does various passes"
4276   (let ((saved-quotes nil)
4277         (parse-start (point)))
4278     ;; Avoid major-mode's syntax propertizing function, since we
4279     ;; change the syntax-table while calling `scan-sexps'.
4280     (let ((syntax-propertize-function nil))
4281       (setq yas--dollar-regions nil)  ; Reset the yas--dollar-regions.
4282       (yas--protect-escapes nil '(?`))  ; Protect just the backquotes.
4283       (goto-char parse-start)
4284       (setq saved-quotes (yas--save-backquotes)) ; `expressions`.
4285       (yas--protect-escapes)            ; Protect escaped characters.
4286       (goto-char parse-start)
4287       (yas--indent-parse-create)        ; Parse indent markers: `$>'.
4288       (goto-char parse-start)
4289       (yas--field-parse-create snippet) ; Parse fields with {}.
4290       (goto-char parse-start)
4291       (yas--simple-fom-create snippet) ; Parse simple mirrors & fields.
4292       (goto-char parse-start)
4293       (yas--transform-mirror-parse-create snippet) ; Parse mirror transforms.
4294       ;; Invalidate any syntax-propertizing done while
4295       ;; `syntax-propertize-function' was nil.
4296       (syntax-ppss-flush-cache parse-start))
4297     ;; Set "next" links of fields & mirrors.
4298     (yas--calculate-adjacencies snippet)
4299     (yas--save-restriction-and-widen    ; Delete $-constructs.
4300       (yas--delete-regions yas--dollar-regions))
4301     ;; Make sure to do this insertion *after* deleting the dollar
4302     ;; regions, otherwise we invalidate the calculated positions of
4303     ;; all the fields following $0.
4304     (let ((exit (yas--snippet-exit snippet)))
4305       (goto-char (if exit (yas--exit-marker exit) (point-max))))
4306     (when (eq yas-wrap-around-region 'cua)
4307       (setq yas-wrap-around-region ?0))
4308     (cond ((and yas-wrap-around-region yas-selected-text)
4309            (insert yas-selected-text))
4310           ((and (characterp yas-wrap-around-region)
4311                 (get-register yas-wrap-around-region))
4312            (insert (prog1 (get-register yas-wrap-around-region)
4313                      (set-register yas-wrap-around-region nil)))))
4314     (yas--restore-backquotes saved-quotes)  ; Restore `expression` values.
4315     (goto-char parse-start)
4316     (yas--restore-escapes)        ; Restore escapes.
4317     (yas--update-mirrors snippet) ; Update mirrors for the first time.
4318     (goto-char parse-start)))
4319
4320 ;; HACK: Some implementations of `indent-line-function' (called via
4321 ;; `indent-according-to-mode') delete text before they insert (like
4322 ;; cc-mode), some make complicated regexp replacements (looking at
4323 ;; you, org-mode).  To find place where the marker "should" go after
4324 ;; indentation, we create a regexp based on what the line looks like
4325 ;; before, putting a capture group where the marker is.  The regexp
4326 ;; matches any whitespace with [[:space:]]* to allow for the
4327 ;; indentation changing whitespace.  Additionally, we try to preserve
4328 ;; the amount of whitespace *following* the marker, because
4329 ;; indentation generally affects whitespace at the beginning, not the
4330 ;; end.
4331 ;;
4332 ;; Two other cases where we apply a similar strategy:
4333 ;;
4334 ;; 1. Handling `auto-fill-mode', in this case we need to use the
4335 ;; current paragraph instead of line.
4336 ;;
4337 ;; 2. Moving snippets from an `org-src' temp buffer into the main org
4338 ;; buffer, in this case we need to count the line offsets (because org
4339 ;; may add indentation on each line making character positions
4340 ;; unreliable).
4341 ;;
4342 ;; This is all best-effort heuristic stuff, but it should cover 99% of
4343 ;; use-cases.
4344
4345 (defun yas--snapshot-marker-location (marker &optional beg end)
4346   "Returns info for restoring MARKER's location after indent.
4347 The returned value is a list of the form (MARKER REGEXP WS-COUNT)."
4348   (unless beg (setq beg (line-beginning-position)))
4349   (unless end (setq end (line-end-position)))
4350   (let ((before (split-string (buffer-substring-no-properties beg marker)
4351                               "[[:space:]\n]+" t))
4352         (after (split-string (buffer-substring-no-properties marker end)
4353                              "[[:space:]\n]+" t)))
4354     (list marker
4355           (concat "[[:space:]\n]*"
4356                   (mapconcat (lambda (s)
4357                                (if (eq s marker) "\\(\\)"
4358                                  (regexp-quote s)))
4359                              (nconc before (list marker) after)
4360                              "[[:space:]\n]*"))
4361           (progn (goto-char marker)
4362                  (skip-chars-forward "[:space:]\n" end)
4363                  (- (point) marker)))))
4364
4365 (defun yas--snapshot-overlay-location (overlay beg end)
4366   "Like `yas--snapshot-marker-location' for overlays.
4367 The returned format is (OVERLAY (RE WS) (RE WS)).  Either of
4368 the (RE WS) lists may be nil if the start or end, respectively,
4369 of the overlay is outside the range BEG .. END."
4370   (let ((obeg (overlay-start overlay))
4371         (oend (overlay-end overlay)))
4372     (list overlay
4373           (when (and (<= beg obeg) (< obeg end))
4374             (cdr (yas--snapshot-marker-location obeg beg end)))
4375           (when (and (<= beg oend) (< oend end))
4376             (cdr (yas--snapshot-marker-location oend beg end))))))
4377
4378 (defun yas--snapshot-overlay-line-location (overlay)
4379   "Return info for restoring OVERLAY's line based location.
4380 The returned format is (OVERLAY (LINE RE WS) (LINE RE WS))."
4381   (let ((loc-beg (progn (goto-char (overlay-start overlay))
4382                         (yas--snapshot-marker-location (point))))
4383         (loc-end (progn (goto-char (overlay-end overlay))
4384                         (yas--snapshot-marker-location (point)))))
4385     (setcar loc-beg (count-lines (point-min) (progn (goto-char (car loc-beg))
4386                                                     (line-beginning-position))))
4387     (setcar loc-end (count-lines (point-min) (progn (goto-char (car loc-end))
4388                                                     (line-beginning-position))))
4389     (list overlay loc-beg loc-end)))
4390
4391 (defun yas--goto-saved-location (regexp ws-count)
4392   "Move point to location saved by `yas--snapshot-marker-location'.
4393 Buffer must be narrowed to BEG..END used to create the snapshot info."
4394   (goto-char (point-min))
4395   (if (not (looking-at regexp))
4396       (lwarn '(yasnippet re-marker) :warning
4397              "Couldn't find: %S" regexp)
4398     (goto-char (match-beginning 1))
4399     (skip-chars-forward "[:space:]\n")
4400     (skip-chars-backward "[:space:]\n" (- (point) ws-count))))
4401
4402 (defun yas--restore-marker-location (re-marker)
4403   "Restores marker based on info from `yas--snapshot-marker-location'.
4404 Buffer must be narrowed to BEG..END used to create the snapshot info."
4405   (apply #'yas--goto-saved-location (cdr re-marker))
4406   (set-marker (car re-marker) (point)))
4407
4408 (defun yas--restore-overlay-location (ov-locations)
4409   "Restores marker based on info from `yas--snapshot-marker-location'.
4410 Buffer must be narrowed to BEG..END used to create the snapshot info."
4411   (cl-destructuring-bind (overlay loc-beg loc-end) ov-locations
4412     (move-overlay overlay
4413                   (if (not loc-beg) (overlay-start overlay)
4414                     (apply #'yas--goto-saved-location loc-beg)
4415                     (point))
4416                   (if (not loc-end) (overlay-end overlay)
4417                     (apply #'yas--goto-saved-location loc-end)
4418                     (point)))))
4419
4420
4421 (defun yas--restore-overlay-line-location (ov-locations)
4422   "Restores overlay based on info from `yas--snapshot-overlay-line-location'."
4423   (save-restriction
4424     (move-overlay (car ov-locations)
4425                   (save-excursion
4426                     (forward-line (car (nth 1 ov-locations)))
4427                     (narrow-to-region (line-beginning-position) (line-end-position))
4428                     (apply #'yas--goto-saved-location (cdr (nth 1 ov-locations)))
4429                     (point))
4430                   (save-excursion
4431                     (forward-line (car (nth 2 ov-locations)))
4432                     (narrow-to-region (line-beginning-position) (line-end-position))
4433                     (apply #'yas--goto-saved-location (cdr (nth 2 ov-locations)))
4434                     (point)))))
4435
4436 (defun yas--indent-region (from to snippet)
4437   "Indent the lines between FROM and TO with `indent-according-to-mode'.
4438 The SNIPPET's markers are preserved."
4439   (save-excursion
4440     (yas--save-restriction-and-widen
4441       (let* ((snippet-markers (yas--collect-snippet-markers snippet))
4442              (to (set-marker (make-marker) to)))
4443         (goto-char from)
4444         (cl-loop for bol = (line-beginning-position)
4445                  for eol = (line-end-position)
4446                  if (or yas-also-indent-empty-lines
4447                         (/= bol eol))
4448                  do
4449                  ;; Indent each non-empty line.
4450                  (let ((remarkers nil))
4451                    (dolist (m snippet-markers)
4452                      (when (and (<= bol m) (<= m eol))
4453                        (push (yas--snapshot-marker-location m bol eol)
4454                              remarkers)))
4455                    (unwind-protect
4456                        (progn (back-to-indentation)
4457                               (indent-according-to-mode))
4458                      (save-restriction
4459                        (narrow-to-region bol (line-end-position))
4460                        (mapc #'yas--restore-marker-location remarkers))))
4461                  while (and (zerop (forward-line 1))
4462                             (< (point) to)))))))
4463
4464 (defvar yas--indent-original-column nil)
4465 (defun yas--indent (snippet)
4466   ;; Indent lines that had indent markers (`$>') on them.
4467   (save-excursion
4468     (dolist (marker yas--indent-markers)
4469       (unless (eq yas-indent-line 'auto)
4470         (goto-char marker)
4471         (yas--indent-region (line-beginning-position)
4472                             (line-end-position)
4473                             snippet))
4474       ;; Finished with this marker.
4475       (set-marker marker nil))
4476     (setq yas--indent-markers nil))
4477   ;; Now do stuff for `fixed' and `auto'.
4478   (save-excursion
4479     ;; We need to be at end of line, so that `forward-line' will only
4480     ;; report 0 if it actually moves over a newline.
4481     (end-of-line)
4482     (cond ((eq yas-indent-line 'fixed)
4483            (when (= (forward-line 1) 0)
4484              (let ((indent-line-function
4485                     (lambda ()
4486                       ;; We need to be at beginning of line in order to
4487                       ;; indent existing whitespace correctly.
4488                       (beginning-of-line)
4489                       (indent-to-column yas--indent-original-column))))
4490                (yas--indent-region (line-beginning-position)
4491                                    (point-max)
4492                                    snippet))))
4493           ((eq yas-indent-line 'auto)
4494            (when (or yas-also-auto-indent-first-line
4495                      (= (forward-line 1) 0))
4496              (yas--indent-region (line-beginning-position)
4497                                  (point-max)
4498                                  snippet))))))
4499
4500 (defun yas--collect-snippet-markers (snippet)
4501   "Make a list of all the markers used by SNIPPET."
4502   (let (markers)
4503     (yas--snippet-map-markers (lambda (m) (push m markers) m) snippet)
4504     markers))
4505
4506 (defun yas--escape-string (escaped)
4507   (concat "YASESCAPE" (format "%d" escaped) "PROTECTGUARD"))
4508
4509 (defun yas--protect-escapes (&optional text escaped)
4510   "Protect all escaped characters with their numeric ASCII value.
4511
4512 With optional string TEXT do it in string instead of buffer."
4513   (let ((changed-text text)
4514         (text-provided-p text))
4515     (mapc #'(lambda (escaped)
4516               (setq changed-text
4517                     (yas--replace-all (concat "\\" (char-to-string escaped))
4518                                      (yas--escape-string escaped)
4519                                      (when text-provided-p changed-text))))
4520           (or escaped yas--escaped-characters))
4521     changed-text))
4522
4523 (defun yas--restore-escapes (&optional text escaped)
4524   "Restore all escaped characters from their numeric ASCII value.
4525
4526 With optional string TEXT do it in string instead of the buffer."
4527   (let ((changed-text text)
4528         (text-provided-p text))
4529     (mapc #'(lambda (escaped)
4530               (setq changed-text
4531                     (yas--replace-all (yas--escape-string escaped)
4532                                      (char-to-string escaped)
4533                                      (when text-provided-p changed-text))))
4534           (or escaped yas--escaped-characters))
4535     changed-text))
4536
4537 (defun yas--save-backquotes ()
4538   "Save all \"\\=`(lisp-expression)\\=`\"-style expressions.
4539 Return a list of (MARKER . STRING) entires for each backquoted
4540 Lisp expression."
4541   (let* ((saved-quotes nil)
4542          (yas--snippet-buffer (current-buffer))
4543          (yas--change-detected nil)
4544          (detect-change (lambda (_beg _end)
4545                           (when (eq (current-buffer) yas--snippet-buffer)
4546                             (setq yas--change-detected t)))))
4547     (while (re-search-forward yas--backquote-lisp-expression-regexp nil t)
4548       (let ((current-string (match-string-no-properties 1)) transformed)
4549         (yas--save-restriction-and-widen
4550           (delete-region (match-beginning 0) (match-end 0)))
4551         (let ((before-change-functions
4552                (cons detect-change before-change-functions)))
4553           (setq transformed (yas--eval-for-string (yas--read-lisp
4554                                                    (yas--restore-escapes
4555                                                     current-string '(?`))))))
4556         (goto-char (match-beginning 0))
4557         (when transformed
4558           (let ((marker (make-marker)))
4559             (yas--save-restriction-and-widen
4560               (insert "Y") ;; quite horrendous, I love it :)
4561               (set-marker marker (point))
4562               (insert "Y"))
4563             (push (cons marker transformed) saved-quotes)))))
4564     (when yas--change-detected
4565       (lwarn '(yasnippet backquote-change) :warning
4566              "`%s' modified buffer in a backquote expression.
4567   To hide this warning, add (yasnippet backquote-change) to `warning-suppress-types'."
4568              (if yas--current-template
4569                  (yas--template-name yas--current-template)
4570                "Snippet")))
4571     saved-quotes))
4572
4573 (defun yas--restore-backquotes (saved-quotes)
4574   "Replace markers in SAVED-QUOTES with their values.
4575 SAVED-QUOTES is the in format returned by `yas--save-backquotes'."
4576   (cl-loop for (marker . string) in saved-quotes do
4577            (save-excursion
4578              (goto-char marker)
4579              (yas--save-restriction-and-widen
4580                (delete-char -1)
4581                (insert string)
4582                (delete-char 1))
4583              (set-marker marker nil))))
4584
4585 (defun yas--scan-sexps (from count)
4586   (ignore-errors
4587     (save-match-data ; `scan-sexps' may modify match data.
4588       (with-syntax-table (standard-syntax-table)
4589         (let ((parse-sexp-lookup-properties nil))
4590           (scan-sexps from count))))))
4591
4592 (defun yas--make-marker (pos)
4593   "Create a marker at POS with nil `marker-insertion-type'."
4594   (let ((marker (set-marker (make-marker) pos)))
4595     (set-marker-insertion-type marker nil)
4596     marker))
4597
4598 (defun yas--indent-parse-create ()
4599   "Parse the \"$>\" indentation markers just inserted."
4600   (setq yas--indent-markers ())
4601   (while (search-forward "$>" nil t)
4602     (delete-region (match-beginning 0) (match-end 0))
4603     ;; Mark the beginning of the line.
4604     (push (yas--make-marker (line-beginning-position))
4605           yas--indent-markers))
4606   (setq yas--indent-markers (nreverse yas--indent-markers)))
4607
4608 (defun yas--field-parse-create (snippet &optional parent-field)
4609   "Parse most field expressions in SNIPPET, except for the simple one \"$n\".
4610
4611 The following count as a field:
4612
4613 * \"${n: text}\", for a numbered field with default text, as long as N is not 0;
4614
4615 * \"${n: text$(expression)}, the same with a Lisp expression;
4616   this is caught with the curiously named `yas--multi-dollar-lisp-expression-regexp'
4617
4618 * the same as above but unnumbered, (no N:) and number is calculated automatically.
4619
4620 When multiple expressions are found, only the last one counts."
4621   ;;
4622   (save-excursion
4623     (while (re-search-forward yas--field-regexp nil t)
4624       (let* ((real-match-end-0 (yas--scan-sexps (1+ (match-beginning 0)) 1))
4625              (number (and (match-string-no-properties 1)
4626                           (string-to-number (match-string-no-properties 1))))
4627              (brand-new-field (and real-match-end-0
4628                                    ;; break if on "$(" immediately
4629                                    ;; after the ":", this will be
4630                                    ;; caught as a mirror with
4631                                    ;; transform later.
4632                                    (not (string-match-p "\\`\\$[ \t\n]*("
4633                                                         (match-string-no-properties 2)))
4634                                    ;; allow ${0: some exit text}
4635                                    ;; (not (and number (zerop number)))
4636                                    (yas--make-field number
4637                                                    (yas--make-marker (match-beginning 2))
4638                                                    (yas--make-marker (1- real-match-end-0))
4639                                                    parent-field))))
4640         (when brand-new-field
4641           (goto-char real-match-end-0)
4642           (push (cons (1- real-match-end-0) real-match-end-0)
4643                 yas--dollar-regions)
4644           (push (cons (match-beginning 0) (match-beginning 2))
4645                 yas--dollar-regions)
4646           (push brand-new-field (yas--snippet-fields snippet))
4647           (save-excursion
4648             (save-restriction
4649               (narrow-to-region (yas--field-start brand-new-field) (yas--field-end brand-new-field))
4650               (goto-char (point-min))
4651               (yas--field-parse-create snippet brand-new-field)))))))
4652   ;; if we entered from a parent field, now search for the
4653   ;; `yas--multi-dollar-lisp-expression-regexp'. This is used for
4654   ;; primary field transformations
4655   ;;
4656   (when parent-field
4657     (save-excursion
4658       (while (re-search-forward yas--multi-dollar-lisp-expression-regexp nil t)
4659         (let* ((real-match-end-1 (yas--scan-sexps (match-beginning 1) 1)))
4660           ;; commit the primary field transformation if:
4661           ;;
4662           ;; 1. we don't find it in yas--dollar-regions (a subnested
4663           ;; field) might have already caught it.
4664           ;;
4665           ;; 2. we really make sure we have either two '$' or some
4666           ;; text and a '$' after the colon ':'. This is a FIXME: work
4667           ;; my regular expressions and end these ugly hacks.
4668           ;;
4669           (when (and real-match-end-1
4670                      (not (member (cons (match-beginning 0)
4671                                         real-match-end-1)
4672                                   yas--dollar-regions))
4673                      (not (eq ?:
4674                               (char-before (1- (match-beginning 1))))))
4675             (let ((lisp-expression-string (buffer-substring-no-properties (match-beginning 1)
4676                                                                           real-match-end-1)))
4677               (setf (yas--field-transform parent-field)
4678                     (yas--read-lisp (yas--restore-escapes lisp-expression-string))))
4679             (push (cons (match-beginning 0) real-match-end-1)
4680                   yas--dollar-regions)))))))
4681
4682 (defun yas--transform-mirror-parse-create (snippet)
4683   "Parse the \"${n:$(lisp-expression)}\" mirror transformations in SNIPPET."
4684   (while (re-search-forward yas--transform-mirror-regexp nil t)
4685     (let* ((real-match-end-0 (yas--scan-sexps (1+ (match-beginning 0)) 1))
4686            (number (string-to-number (match-string-no-properties 1)))
4687            (field (and number
4688                        (not (zerop number))
4689                        (yas--snippet-find-field snippet number)))
4690            (brand-new-mirror
4691             (and real-match-end-0
4692                  field
4693                  (yas--make-mirror (yas--make-marker (match-beginning 0))
4694                                   (yas--make-marker (match-beginning 0))
4695                                   (yas--read-lisp
4696                                    (yas--restore-escapes
4697                                     (buffer-substring-no-properties (match-beginning 2)
4698                                                                     (1- real-match-end-0))))))))
4699       (when brand-new-mirror
4700         (push brand-new-mirror
4701               (yas--field-mirrors field))
4702         (yas--calculate-simple-fom-parentage snippet brand-new-mirror)
4703         (push (cons (match-beginning 0) real-match-end-0) yas--dollar-regions)))))
4704
4705 (defun yas--simple-fom-create (snippet)
4706   "Parse the simple \"$n\" fields/mirrors/exitmarkers in SNIPPET."
4707   (while (re-search-forward yas--simple-mirror-regexp nil t)
4708     (let ((number (string-to-number (match-string-no-properties 1))))
4709       (cond ((zerop number)
4710              (setf (yas--snippet-exit snippet)
4711                    (yas--make-exit (yas--make-marker (match-end 0))))
4712              (push (cons (match-beginning 0) (yas--exit-marker (yas--snippet-exit snippet)))
4713                    yas--dollar-regions))
4714             (t
4715              (let ((field (yas--snippet-find-field snippet number))
4716                    (fom))
4717                (if field
4718                    (push
4719                     (setq fom (yas--make-mirror
4720                                (yas--make-marker (match-beginning 0))
4721                                (yas--make-marker (match-beginning 0))
4722                                nil))
4723                     (yas--field-mirrors field))
4724                  (push
4725                   (setq fom (yas--make-field number
4726                                              (yas--make-marker (match-beginning 0))
4727                                              (yas--make-marker (match-beginning 0))
4728                                              nil))
4729                   (yas--snippet-fields snippet)))
4730                (yas--calculate-simple-fom-parentage snippet fom))
4731              (push (cons (match-beginning 0) (match-end 0))
4732                    yas--dollar-regions))))))
4733
4734 (defun yas--delete-regions (regions)
4735   "Sort disjuct REGIONS by start point, then delete from the back."
4736   (mapc #'(lambda (reg)
4737             (delete-region (car reg) (cdr reg)))
4738         (sort regions
4739               #'(lambda (r1 r2)
4740                   (>= (car r1) (car r2))))))
4741
4742 (defun yas--calculate-mirror-depth (mirror &optional traversed)
4743   (let* ((parent (yas--mirror-parent-field mirror))
4744          (parents-mirrors (and parent
4745                                (yas--field-mirrors parent))))
4746     (or (yas--mirror-depth mirror)
4747         (setf (yas--mirror-depth mirror)
4748               (cond ((memq mirror traversed) 0)
4749                     ((and parent parents-mirrors)
4750                      (1+ (cl-reduce
4751                           #'max parents-mirrors
4752                           :key (lambda (m)
4753                                  (yas--calculate-mirror-depth
4754                                   m (cons mirror traversed))))))
4755                     (parent 1)
4756                     (t 0))))))
4757
4758 (defun yas--update-mirrors (snippet)
4759   "Update all the mirrors of SNIPPET."
4760   (yas--save-restriction-and-widen
4761     (save-excursion
4762       (cl-loop
4763        for (field . mirror)
4764        in (cl-sort
4765            ;; Make a list of (FIELD . MIRROR).
4766            (cl-mapcan (lambda (field)
4767                         (mapcar (lambda (mirror)
4768                                   (cons field mirror))
4769                                 (yas--field-mirrors field)))
4770                       (yas--snippet-fields snippet))
4771            ;; Then sort this list so that entries with mirrors with
4772            ;; parent fields appear before.  This was important for
4773            ;; fixing #290, and also handles the case where a mirror in
4774            ;; a field causes another mirror to need reupdating.
4775            #'> :key (lambda (fm) (yas--calculate-mirror-depth (cdr fm))))
4776        ;; Before updating a mirror with a parent-field, maybe advance
4777        ;; its start (#290).
4778        do (let ((parent-field (yas--mirror-parent-field mirror)))
4779             (when parent-field
4780               (yas--advance-start-maybe mirror (yas--fom-start parent-field))))
4781        ;; Update this mirror.
4782        do (yas--mirror-update-display mirror field)
4783        ;; Delay indenting until we're done all mirrors.  We must do
4784        ;; this to avoid losing whitespace between fields that are
4785        ;; still empty (i.e., they will be non-empty after updating).
4786        when (eq yas-indent-line 'auto)
4787        collect (cons (yas--mirror-start mirror) (yas--mirror-end mirror))
4788        into indent-regions
4789        ;; `yas--place-overlays' is needed since the active field and
4790        ;; protected overlays might have been changed because of insertions
4791        ;; in `yas--mirror-update-display'.
4792        do (let ((active-field (yas--snippet-active-field snippet)))
4793             (when active-field (yas--place-overlays snippet active-field)))
4794        finally do
4795        (let ((yas--inhibit-overlay-hooks t))
4796          (cl-loop for (beg . end) in (cl-sort indent-regions #'< :key #'car)
4797                   do (yas--indent-region beg end snippet)))))))
4798
4799 (defun yas--mirror-update-display (mirror field)
4800   "Update MIRROR according to FIELD (and mirror transform)."
4801
4802   (let* ((mirror-parent-field (yas--mirror-parent-field mirror))
4803          (reflection (and (not (and mirror-parent-field
4804                                     (yas--field-modified-p mirror-parent-field)))
4805                           (or (yas--apply-transform mirror field 'empty-on-nil)
4806                               (yas--field-text-for-display field)))))
4807     (when (and reflection
4808                (not (string= reflection (buffer-substring-no-properties (yas--mirror-start mirror)
4809                                                                         (yas--mirror-end mirror)))))
4810       (goto-char (yas--mirror-start mirror))
4811       (let ((yas--inhibit-overlay-hooks t))
4812         (insert reflection))
4813       (if (> (yas--mirror-end mirror) (point))
4814           (delete-region (point) (yas--mirror-end mirror))
4815         (set-marker (yas--mirror-end mirror) (point))
4816         (yas--advance-start-maybe (yas--mirror-next mirror) (point))
4817         ;; super-special advance
4818         (yas--advance-end-of-parents-maybe mirror-parent-field (point))))))
4819
4820 (defun yas--field-update-display (field)
4821   "Much like `yas--mirror-update-display', but for fields."
4822   (when (yas--field-transform field)
4823     (let ((transformed (and (not (eq (yas--field-number field) 0))
4824                             (yas--apply-transform field field))))
4825       (when (and transformed
4826                  (not (string= transformed (buffer-substring-no-properties (yas--field-start field)
4827                                                                            (yas--field-end field)))))
4828         (setf (yas--field-modified-p field) t)
4829         (goto-char (yas--field-start field))
4830         (let ((yas--inhibit-overlay-hooks t))
4831           (insert transformed)
4832           (if (> (yas--field-end field) (point))
4833               (delete-region (point) (yas--field-end field))
4834             (set-marker (yas--field-end field) (point))
4835             (yas--advance-start-maybe (yas--field-next field) (point)))
4836           t)))))
4837
4838
4839 ;;; Post-command hook:
4840 ;;
4841 (defun yas--post-command-handler ()
4842   "Handles various yasnippet conditions after each command."
4843   (when (and yas--watch-auto-fill-backtrace
4844              (fboundp 'backtrace--print-frame)
4845              (null yas--original-auto-fill-function)
4846              (eq auto-fill-function 'yas--auto-fill))
4847     (lwarn '(yasnippet auto-fill bug) :error
4848            "`yas--original-auto-fill-function' unexpectedly nil! Please report this backtrace\n%S"
4849            (with-output-to-string
4850              (mapc #'backtrace--print-frame
4851                      yas--watch-auto-fill-backtrace)))
4852     ;; Don't pop up more than once in a session (still log though).
4853     (defvar warning-suppress-types) ; `warnings' is autoloaded by `lwarn'.
4854     (add-to-list 'warning-suppress-types '(yasnippet auto-fill bug)))
4855   (condition-case err
4856       (progn (yas--finish-moving-snippets)
4857              (cond ((eq 'undo this-command)
4858                     ;;
4859                     ;; After undo revival the correct field is sometimes not
4860                     ;; restored correctly, this condition handles that
4861                     ;;
4862                     (let* ((snippet (car (yas-active-snippets)))
4863                            (target-field
4864                             (and snippet
4865                                  (cl-find-if-not
4866                                   (lambda (field)
4867                                     (yas--field-probably-deleted-p snippet field))
4868                                   (remq nil
4869                                         (cons (yas--snippet-active-field snippet)
4870                                               (yas--snippet-fields snippet)))))))
4871                       (when target-field
4872                         (yas--move-to-field snippet target-field))))
4873                    ((not (yas--undo-in-progress))
4874                     ;; When not in an undo, check if we must commit the snippet
4875                     ;; (user exited it).
4876                     (yas--check-commit-snippet))))
4877     ((debug error) (signal (car err) (cdr err)))))
4878
4879 ;;; Fancy docs:
4880 ;;
4881 ;; The docstrings for some functions are generated dynamically
4882 ;; depending on the context.
4883 ;;
4884 (put 'yas-expand  'function-documentation
4885      '(yas--expand-from-trigger-key-doc t))
4886 (defun yas--expand-from-trigger-key-doc (context)
4887   "A doc synthesizer for `yas--expand-from-trigger-key-doc'."
4888   (let* ((yas-fallback-behavior (and context yas-fallback-behavior))
4889          (fallback-description
4890           (cond ((eq yas-fallback-behavior 'call-other-command)
4891                  (let* ((fallback (yas--keybinding-beyond-yasnippet)))
4892                    (or (and fallback
4893                             (format "call command `%s'."
4894                                     (pp-to-string fallback)))
4895                        "do nothing (`yas-expand' doesn't override\nanything).")))
4896                 ((eq yas-fallback-behavior 'return-nil)
4897                  "do nothing.")
4898                 (t "defer to `yas-fallback-behavior' (which see)."))))
4899     (concat "Expand a snippet before point. If no snippet
4900 expansion is possible, "
4901             fallback-description
4902             "\n\nOptional argument FIELD is for non-interactive use and is an
4903 object satisfying `yas--field-p' to restrict the expansion to.")))
4904
4905 (put 'yas-expand-from-keymap 'function-documentation
4906      '(yas--expand-from-keymap-doc t))
4907 (defun yas--expand-from-keymap-doc (context)
4908   "A doc synthesizer for `yas--expand-from-keymap-doc'."
4909   (add-hook 'temp-buffer-show-hook #'yas--snippet-description-finish-runonce)
4910   (concat "Expand/run snippets from keymaps, possibly falling back to original binding.\n"
4911           (when (and context (eq this-command 'describe-key))
4912             (let* ((vec (this-single-command-keys))
4913                    (templates (cl-mapcan (lambda (table)
4914                                            (yas--fetch table vec))
4915                                          (yas--get-snippet-tables)))
4916                    (yas--direct-keymaps nil)
4917                    (fallback (key-binding vec)))
4918               (concat "In this case, "
4919                       (when templates
4920                         (concat "these snippets are bound to this key:\n"
4921                                 (yas--template-pretty-list templates)
4922                                 "\n\nIf none of these expands, "))
4923                       (or (and fallback
4924                                (format "fallback `%s' will be called." (pp-to-string fallback)))
4925                           "no fallback keybinding is called."))))))
4926
4927 (defun yas--template-pretty-list (templates)
4928   (let ((acc)
4929         (yas-buffer-local-condition 'always))
4930     (dolist (plate templates)
4931       (setq acc (concat acc "\n*) "
4932                         (propertize (concat "\\\\snippet `" (car plate) "'")
4933                                     'yasnippet (cdr plate)))))
4934     acc))
4935
4936 (define-button-type 'help-snippet-def
4937   :supertype 'help-xref
4938   'help-function (lambda (template) (yas--visit-snippet-file-1 template))
4939   'help-echo (purecopy "mouse-2, RET: find snippets's definition"))
4940
4941 (defun yas--snippet-description-finish-runonce ()
4942   "Final adjustments for the help buffer when snippets are concerned."
4943   (yas--create-snippet-xrefs)
4944   (remove-hook 'temp-buffer-show-hook
4945                #'yas--snippet-description-finish-runonce))
4946
4947 (defun yas--create-snippet-xrefs ()
4948   (save-excursion
4949     (goto-char (point-min))
4950     (while (search-forward-regexp "\\\\\\\\snippet[ \s\t]+`\\([^']+\\)'" nil t)
4951       (let ((template (get-text-property (match-beginning 1)
4952                                          'yasnippet)))
4953         (when template
4954           (help-xref-button 1 'help-snippet-def template)
4955           (delete-region (match-end 1) (match-end 0))
4956           (delete-region (match-beginning 0) (match-beginning 1)))))))
4957
4958 ;;; Eldoc configuration.
4959 (eldoc-add-command 'yas-next-field-or-maybe-expand
4960                    'yas-next-field 'yas-prev-field
4961                    'yas-expand 'yas-expand-from-keymap
4962                    'yas-expand-from-trigger-key)
4963
4964 ;;; Utils
4965
4966 (defvar yas-verbosity 3
4967   "Log level for `yas--message' 4 means trace most anything, 0 means nothing.")
4968
4969 (defun yas--message (level message &rest args)
4970   "When LEVEL is at or below `yas-verbosity', log MESSAGE and ARGS."
4971   (when (>= yas-verbosity level)
4972     (message "%s" (apply #'yas--format message args))))
4973
4974 (defun yas--warning (format-control &rest format-args)
4975   (let ((msg (apply #'format format-control format-args)))
4976     (display-warning 'yasnippet msg :warning)
4977     (yas--message 1 msg)))
4978
4979 (defun yas--format (format-control &rest format-args)
4980   (apply #'format (concat "[yas] " format-control) format-args))
4981
4982
4983 ;;; Unloading
4984
4985 (defvar unload-function-defs-list) ; loadhist.el
4986
4987 (defun yasnippet-unload-function ()
4988   "Disable minor modes when calling `unload-feature'."
4989   ;; Disable `yas-minor-mode' everywhere it's enabled.
4990   (yas-global-mode -1)
4991   (save-current-buffer
4992     (dolist (buffer (buffer-list))
4993       (set-buffer buffer)
4994       (when yas-minor-mode
4995         (yas-minor-mode -1))))
4996   ;; Remove symbol properties of all our functions, this avoids
4997   ;; Bug#25088 in Emacs 25.1, where the compiler macro on
4998   ;; `cl-defstruct' created functions hang around in the symbol plist
4999   ;; and cause errors when loading again (we don't *need* to clean
5000   ;; *all* symbol plists, but it's easier than being precise).
5001   (dolist (def unload-function-defs-list)
5002     (when (eq (car-safe def) 'defun)
5003       (setplist (cdr def) nil)))
5004   ;; Return nil so that `unload-feature' will take of undefining
5005   ;; functions, and changing any buffers using `snippet-mode'.
5006   nil)
5007
5008
5009 ;;; Backward compatibility to yasnippet <= 0.7
5010
5011 (defun yas-initialize ()
5012   "For backward compatibility, enable `yas-minor-mode' globally."
5013   (declare (obsolete "Use (yas-global-mode 1) instead." "0.8"))
5014   (yas-global-mode 1))
5015
5016 (defvar yas--backported-syms '(;; `defcustom's
5017                              ;;
5018                              yas-snippet-dirs
5019                              yas-prompt-functions
5020                              yas-indent-line
5021                              yas-also-auto-indent-first-line
5022                              yas-snippet-revival
5023                              yas-triggers-in-field
5024                              yas-fallback-behavior
5025                              yas-choose-keys-first
5026                              yas-choose-tables-first
5027                              yas-use-menu
5028                              yas-trigger-symbol
5029                              yas-wrap-around-region
5030                              yas-good-grace
5031                              yas-visit-from-menu
5032                              yas-expand-only-for-last-commands
5033                              yas-field-highlight-face
5034
5035                              ;; these vars can be customized as well
5036                              ;;
5037                              yas-keymap
5038                              yas-verbosity
5039                              yas-extra-modes
5040                              yas-key-syntaxes
5041                              yas-after-exit-snippet-hook
5042                              yas-before-expand-snippet-hook
5043                              yas-buffer-local-condition
5044                              yas-dont-activate
5045
5046                              ;; prompting functions
5047                              ;;
5048                              yas-x-prompt
5049                              yas-ido-prompt
5050                              yas-no-prompt
5051                              yas-completing-prompt
5052                              yas-dropdown-prompt
5053
5054                              ;; interactive functions
5055                              ;;
5056                              yas-expand
5057                              yas-minor-mode
5058                              yas-global-mode
5059                              yas-direct-keymaps-reload
5060                              yas-minor-mode-on
5061                              yas-load-directory
5062                              yas-reload-all
5063                              yas-compile-directory
5064                              yas-recompile-all
5065                              yas-about
5066                              yas-expand-from-trigger-key
5067                              yas-expand-from-keymap
5068                              yas-insert-snippet
5069                              yas-visit-snippet-file
5070                              yas-new-snippet
5071                              yas-load-snippet-buffer
5072                              yas-tryout-snippet
5073                              yas-describe-tables
5074                              yas-next-field-or-maybe-expand
5075                              yas-next-field
5076                              yas-prev-field
5077                              yas-abort-snippet
5078                              yas-exit-snippet
5079                              yas-exit-all-snippets
5080                              yas-skip-and-clear-or-delete-char
5081                              yas-initialize
5082
5083                              ;; symbols that I "exported" for use
5084                              ;; in snippets and hookage
5085                              ;;
5086                              yas-expand-snippet
5087                              yas-define-snippets
5088                              yas-define-menu
5089                              yas-snippet-beg
5090                              yas-snippet-end
5091                              yas-modified-p
5092                              yas-moving-away-p
5093                              yas-substr
5094                              yas-choose-value
5095                              yas-key-to-value
5096                              yas-throw
5097                              yas-verify-value
5098                              yas-field-value
5099                              yas-text
5100                              yas-selected-text
5101                              yas-default-from-field
5102                              yas-inside-string
5103                              yas-unimplemented
5104                              yas-define-condition-cache
5105                              yas-hippie-try-expand
5106
5107                              ;; debug definitions
5108                              ;; yas-debug-snippet-vars
5109                              ;; yas-exterminate-package
5110                              ;; yas-debug-test
5111
5112                              ;; testing definitions
5113                              ;; yas-should-expand
5114                              ;; yas-should-not-expand
5115                              ;; yas-mock-insert
5116                              ;; yas-make-file-or-dirs
5117                              ;; yas-variables
5118                              ;; yas-saving-variables
5119                              ;; yas-call-with-snippet-dirs
5120                              ;; yas-with-snippet-dirs
5121 )
5122   "Backported yasnippet symbols.
5123
5124 They are mapped to \"yas/*\" variants.")
5125
5126 (when yas-alias-to-yas/prefix-p
5127   (dolist (sym yas--backported-syms)
5128     (let ((backported (intern (replace-regexp-in-string "\\`yas-" "yas/" (symbol-name sym)))))
5129       (when (boundp sym)
5130         (make-obsolete-variable backported sym "yasnippet 0.8")
5131         (defvaralias backported sym))
5132       (when (fboundp sym)
5133         (make-obsolete backported sym "yasnippet 0.8")
5134         (defalias backported sym))))
5135   (make-obsolete 'yas/root-directory 'yas-snippet-dirs "yasnippet 0.8")
5136   (defvaralias 'yas/root-directory 'yas-snippet-dirs))
5137
5138 (defvar yas--exported-syms
5139   (let (exported)
5140     (mapatoms (lambda (atom)
5141                 (if (and (or (and (boundp atom)
5142                                   (not (get atom 'byte-obsolete-variable)))
5143                              (and (fboundp atom)
5144                                   (not (get atom 'byte-obsolete-info))))
5145                          (string-match-p "\\`yas-[^-]" (symbol-name atom)))
5146                     (push atom exported))))
5147     exported)
5148   "Exported yasnippet symbols.
5149
5150 i.e. the ones with \"yas-\" single dash prefix. I will try to
5151 keep them in future yasnippet versions and other elisp libraries
5152 can more or less safely rely upon them.")
5153
5154
5155 (provide 'yasnippet)
5156 ;; Local Variables:
5157 ;; coding: utf-8
5158 ;; indent-tabs-mode: nil
5159 ;; End:
5160 ;;; yasnippet.el ends here