From f9bf8ac91b206ad109d11018dfe9006baf559d6e Mon Sep 17 00:00:00 2001 From: Alexander Sulfrian Date: Thu, 22 Oct 2009 05:22:19 +0200 Subject: moved to correct place --- emacs.d/yasnippet/yasnippet.el | 3676 ---------------------------------------- 1 file changed, 3676 deletions(-) delete mode 100644 emacs.d/yasnippet/yasnippet.el (limited to 'emacs.d/yasnippet/yasnippet.el') diff --git a/emacs.d/yasnippet/yasnippet.el b/emacs.d/yasnippet/yasnippet.el deleted file mode 100644 index fcbce9e..0000000 --- a/emacs.d/yasnippet/yasnippet.el +++ /dev/null @@ -1,3676 +0,0 @@ -;;; Yasnippet.el --- Yet another snippet extension for Emacs. - -;; Copyright 2008 pluskid -;; 2009 pluskid, joaotavora - -;; Authors: pluskid , joaotavora -;; Version: 0.6.1 -;; Package-version: 0.6.1c -;; X-URL: http://code.google.com/p/yasnippet/ -;; Keywords: convenience, emulation -;; URL: http://code.google.com/p/yasnippet/ -;; EmacsWiki: YaSnippetMode - -;; This file is free software; you can redistribute it and/or modify -;; it under the terms of the GNU General Public License as published by -;; the Free Software Foundation; either version 2, or (at your option) -;; any later version. - -;; This file is distributed in the hope that it will be useful, -;; but WITHOUT ANY WARRANTY; without even the implied warranty of -;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -;; GNU General Public License for more details. - -;; You should have received a copy of the GNU General Public License -;; along with GNU Emacs; see the file COPYING. If not, write to -;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330, -;; Boston, MA 02111-1307, USA. - -;;; Commentary: - -;; Basic steps to setup: -;; -;; 1. In your .emacs file: -;; (add-to-list 'load-path "/dir/to/yasnippet.el") -;; (require 'yasnippet) -;; 2. Place the `snippets' directory somewhere. E.g: ~/.emacs.d/snippets -;; 3. In your .emacs file -;; (setq yas/root-directory "~/.emacs/snippets") -;; (yas/load-directory yas/root-directory) -;; 4. To enable the YASnippet menu and tab-trigger expansion -;; M-x yas/minor-mode -;; 5. To globally enable the minor mode in *all* buffers -;; M-x yas/global-mode -;; -;; Steps 4. and 5. are optional, you don't have to use the minor -;; mode to use YASnippet. -;; -;; Interesting variables are: -;; -;; `yas/root-directory' -;; -;; The directory where user-created snippets are to be -;; stored. Can also be a list of directories that -;; `yas/reload-all' will use for bulk-reloading snippets. In -;; that case the first directory the default for storing new -;; snippets. -;; -;; `yas/mode-symbol' -;; -;; A local variable that you can set in a hook to override -;; snippet-lookup based on major mode. It is a a symbol (or -;; list of symbols) that correspond to subdirectories of -;; `yas/root-directory' and is used for deciding which -;; snippets to consider for the active buffer. -;; -;; Major commands are: -;; -;; M-x yas/expand -;; -;; Try to expand snippets before point. In `yas/minor-mode', -;; this is bound to `yas/trigger-key' which you can customize. -;; -;; M-x yas/load-directory -;; -;; Prompts you for a directory hierarchy of snippets to load. -;; -;; M-x yas/insert-snippet -;; -;; Prompts you for possible snippet expansion if that is -;; possible according to buffer-local and snippet-local -;; expansion conditions. With prefix argument, ignore these -;; conditions. -;; -;; M-x yas/find-snippets -;; -;; Lets you find the snippet files in the correct -;; subdirectory of `yas/root-directory', according to the -;; active major mode (if it exists) like -;; `find-file-other-window'. -;; -;; M-x yas/visit-snippet-file -;; -;; Prompts you for possible snippet expansions like -;; `yas/insert-snippet', but instead of expanding it, takes -;; you directly to the snippet definition's file, if it -;; exists. -;; -;; M-x yas/new-snippet -;; -;; Lets you create a new snippet file in the correct -;; subdirectory of `yas/root-directory', according to the -;; active major mode. -;; -;; M-x yas/load-snippet-buffer -;; -;; When editing a snippet, this loads the snippet. This is -;; bound to "C-c C-c" while in the `snippet-mode' editing -;; mode. -;; -;; M-x yas/tryout-snippet -;; -;; When editing a snippet, this opens a new empty buffer, -;; sets it to the appropriate major mode and inserts the -;; snippet there, so you can see what it looks like. This is -;; bound to "C-c C-t" while in `snippet-mode'. -;; -;; The `dropdown-list.el' extension is bundled with YASnippet, you -;; can optionally use it the preferred "prompting method", puting in -;; your .emacs file, for example: -;; -;; (require 'dropdown-list) -;; (setq yas/prompt-functions '(yas/dropdown-prompt -;; yas/ido-prompt -;; yas/completing-prompt)) -;; -;; Also check out the customization group -;; -;; M-x customize-group RET yasnippet RET -;; -;; If you use the customization group to set variables -;; `yas/root-directory' or `yas/global-mode', make sure the path to -;; "yasnippet.el" is present in the `load-path' *before* the -;; `custom-set-variables' is executed in your .emacs file. -;; -;; For more information and detailed usage, refer to the project page: -;; http://code.google.com/p/yasnippet/ - -;;; Code: - -(require 'cl) -(require 'assoc) -(require 'easymenu) - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; User customizable variables - - -(defgroup yasnippet nil - "Yet Another Snippet extension" - :group 'editing) - -;;;###autoload -(defcustom yas/root-directory nil - "Root directory that stores the snippets for each major mode. - -If you set this from your .emacs, can also be a list of strings, -for multiple root directories. If you make this a list, the first -element is always the user-created snippets directory. Other -directories are used for bulk reloading of all snippets using -`yas/reload-all'" - :type '(choice (string :tag "Single directory (string)") - (repeat :args (string) :tag "List of directories (strings)")) - :group 'yasnippet - :require 'yasnippet - :set #'(lambda (symbol new) - (let ((old (and (boundp symbol) - (symbol-value symbol)))) - (set-default symbol new) - (unless (or (not (fboundp 'yas/reload-all)) - (equal old new)) - (yas/reload-all))))) - -(defcustom yas/prompt-functions '(yas/x-prompt - yas/dropdown-prompt - yas/completing-prompt - yas/ido-prompt - yas/no-prompt) - "Functions to prompt for keys, templates, etc interactively. - -These functions are called with the following arguments: - -- PROMPT: A string to prompt the user - -- CHOICES: a list of strings or objects. - -- optional DISPLAY-FN : A function that, when applied to each of -the objects in CHOICES will return a string. - -The return value of any function you put here should be one of -the objects in CHOICES, properly formatted with DISPLAY-FN (if -that is passed). - -- To signal that your particular style of prompting is -unavailable at the moment, you can also have the function return -nil. - -- To signal that the user quit the prompting process, you can -signal `quit' with - - (signal 'quit \"user quit!\")." - :type '(repeat function) - :group 'yasnippet) - -(defcustom yas/indent-line 'auto - "Controls indenting applied to a recent snippet expansion. - -The following values are possible: - -- `fixed' Indent the snippet to the current column; - -- `auto' Indent each line of the snippet with `indent-according-to-mode' - -Every other value means don't apply any snippet-side indendation -after expansion (the manual per-line \"$>\" indentation still -applies)." - :type '(choice (const :tag "Nothing" nothing) - (const :tag "Fixed" fixed) - (const :tag "Auto" auto)) - :group 'yasnippet) - -(defcustom yas/also-auto-indent-first-line nil - "Non-nil means also auto indent first line according to mode. - -Naturally this is only valid when `yas/indent-line' is `auto'" - :type 'boolean - :group 'yasnippet) - -(defcustom yas/snippet-revival t - "Non-nil means re-activate snippet fields after undo/redo." - :type 'boolean - :group 'yasnippet) - -(defcustom yas/trigger-key "TAB" - "The key bound to `yas/expand' when function `yas/minor-mode' is active. - -Value is a string that is converted to the internal Emacs key -representation using `read-kbd-macro'." - :type 'string - :group 'yasnippet - :set #'(lambda (symbol key) - (let ((old (and (boundp symbol) - (symbol-value symbol)))) - (set-default symbol key) - ;; On very first loading of this defcustom, - ;; `yas/trigger-key' is *not* loaded. - (if (fboundp 'yas/trigger-key-reload) - (yas/trigger-key-reload old))))) - -(defcustom yas/next-field-key '("TAB" "") - "The key to navigate to next field when a snippet is active. - -Value is a string that is converted to the internal Emacs key -representation using `read-kbd-macro'. - -Can also be a list of strings." - :type '(choice (string :tag "String") - (repeat :args (string) :tag "List of strings")) - :group 'yasnippet - :set #'(lambda (symbol val) - (set-default symbol val) - (if (fboundp 'yas/init-yas-in-snippet-keymap) - (yas/init-yas-in-snippet-keymap)))) - - -(defcustom yas/prev-field-key '("" "") - "The key to navigate to previous field when a snippet is active. - -Value is a string that is converted to the internal Emacs key -representation using `read-kbd-macro'. - -Can also be a list of strings." - :type '(choice (string :tag "String") - (repeat :args (string) :tag "List of strings")) - :group 'yasnippet - :set #'(lambda (symbol val) - (set-default symbol val) - (if (fboundp 'yas/init-yas-in-snippet-keymap) - (yas/init-yas-in-snippet-keymap)))) - -(defcustom yas/skip-and-clear-key "C-d" - "The key to clear the currently active field. - -Value is a string that is converted to the internal Emacs key -representation using `read-kbd-macro'. - -Can also be a list of strings." - :type '(choice (string :tag "String") - (repeat :args (string) :tag "List of strings")) - :group 'yasnippet - :set #'(lambda (symbol val) - (set-default symbol val) - (if (fboundp 'yas/init-yas-in-snippet-keymap) - (yas/init-yas-in-snippet-keymap)))) - -(defcustom yas/triggers-in-field nil - "If non-nil, `yas/next-field-key' can trigger stacked expansions. - -Otherwise, `yas/next-field-key' just tries to move on to the next -field" - :type 'boolean - :group 'yasnippet) - -(defcustom yas/fallback-behavior 'call-other-command - "How to act when `yas/trigger-key' does *not* expand a snippet. - -- `call-other-command' means try to temporarily disable YASnippet - and call the next command bound to `yas/trigger-key'. - -- nil or the symbol `return-nil' mean do nothing. (and - `yas/expand-returns' nil) - -- A lisp form (apply COMMAND . ARGS) means interactively call - COMMAND, if ARGS is non-nil, call COMMAND non-interactively - with ARGS as arguments." - :type '(choice (const :tag "Call previous command" call-other-command) - (const :tag "Do nothing" return-nil)) - :group 'yasnippet) -(make-variable-buffer-local 'yas/fallback-behavior) - -(defcustom yas/choose-keys-first nil - "If non-nil, prompt for snippet key first, then for template. - -Otherwise prompts for all possible snippet names. - -This affects `yas/insert-snippet' and `yas/visit-snippet-file'." - :type 'boolean - :group 'yasnippet) - -(defcustom yas/choose-tables-first nil - "If non-nil, and multiple eligible snippet tables, prompts user for tables first. - -Otherwise, user chooses between the merging together of all -eligible tables. - -This affects `yas/insert-snippet', `yas/visit-snippet-file'" - :type 'boolean - :group 'yasnippet) - -(defcustom yas/use-menu 'real-modes - "Display a YASnippet menu in the menu bar. - -When non-nil, submenus for each snippet table will be listed -under the menu \"Yasnippet\". - -- If set to `real-modes' only submenus whose name more or less -corresponds to a major mode are listed. - -- If set to `abbreviate', only the current major-mode -menu and the modes set in `yas/mode-symbol' are listed. - -Any other non-nil value, every submenu is listed." - :type '(choice (const :tag "Full" t) - (const :tag "Real modes only" real-modes) - (const :tag "Abbreviate" abbreviate)) - :group 'yasnippet) - -(defcustom yas/trigger-symbol " =>" - "The text that will be used in menu to represent the trigger." - :type 'string - :group 'yasnippet) - -(defcustom yas/wrap-around-region nil - "If non-nil, snippet expansion wraps around selected region. - -The wrapping occurs just before the snippet's exit marker. This -can be overriden on a per-snippet basis." - :type 'boolean - :group 'yasnippet) - -(defcustom yas/good-grace t - "If non-nil, don't raise errors in inline elisp evaluation. - -An error string \"[yas] error\" is returned instead." - :type 'boolean - :group 'yasnippet) - -(defcustom yas/ignore-filenames-as-triggers nil - "If non-nil, don't derive tab triggers from filenames. - -This means a snippet without a \"# key:'\ directive wont have a -tab trigger." - :type 'boolean - :group 'yasnippet) - -(defcustom yas/visit-from-menu nil - "If non-nil visit snippets's files from menu, instead of expanding them. - -This cafn only work when snippets are loaded from files." - :type 'boolean - :group 'yasnippet) - -(defface yas/field-highlight-face - '((((class color) (background light)) (:background "DarkSeaGreen1")) - (t (:background "DimGrey"))) - "The face used to highlight the currently active field of a snippet" - :group 'yasnippet) - -(defface yas/field-debug-face - '() - "The face used for debugging some overlays normally hidden" - :group 'yasnippet) - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; User can also customize the next defvars -(defun yas/define-some-keys (keys keymap definition) - "Bind KEYS to DEFINITION in KEYMAP, read with `read-kbd-macro'." - (let ((keys (or (and (listp keys) keys) - (list keys)))) - (dolist (key keys) - (define-key keymap (read-kbd-macro key) definition)))) - -(defvar yas/keymap - (let ((map (make-sparse-keymap))) - (mapc #'(lambda (binding) - (yas/define-some-keys (car binding) map (cdr binding))) - `((,yas/next-field-key . yas/next-field-or-maybe-expand) - (,yas/prev-field-key . yas/prev-field) - ("C-g" . yas/abort-snippet) - (,yas/skip-and-clear-key . yas/skip-and-clear-or-delete-char))) - map) - "The keymap active while a snippet expansion is in progress.") - -(defvar yas/key-syntaxes (list "w" "w_" "w_." "^ ") - "A list of syntax of a key. This list is tried in the order -to try to find a key. For example, if the list is '(\"w\" \"w_\"). -And in emacs-lisp-mode, where \"-\" has the syntax of \"_\": - -foo-bar - -will first try \"bar\", if not found, then \"foo-bar\" is tried.") - -(defvar yas/after-exit-snippet-hook - '() - "Hooks to run after a snippet exited. - -The hooks will be run in an environment where some variables bound to -proper values: - -`yas/snippet-beg' : The beginning of the region of the snippet. - -`yas/snippet-end' : Similar to beg. - -Attention: These hooks are not run when exiting nested/stackd snippet expansion!") - -(defvar yas/before-expand-snippet-hook - '() - "Hooks to run just before expanding a snippet.") - -(defvar yas/buffer-local-condition - '(if (and (not (bobp)) - (or (equal 'font-lock-comment-face - (get-char-property (1- (point)) - 'face)) - (equal 'font-lock-string-face - (get-char-property (1- (point)) - 'face)))) - '(require-snippet-condition . force-in-comment) - t) - "Snippet expanding condition. - -This variable is a lisp form: - - * If it evaluates to nil, no snippets can be expanded. - - * If it evaluates to the a cons (require-snippet-condition - . REQUIREMENT) - - * Snippets bearing no \"# condition:\" directive are not - considered - - * Snippets bearing conditions that evaluate to nil (or - produce an error) won't be onsidered. - - * If the snippet has a condition that evaluates to non-nil - RESULT: - - * If REQUIREMENT is t, the snippet is considered - - * If REQUIREMENT is `eq' RESULT, the snippet is - considered - - * Otherwise, the snippet is not considered. - - * If it evaluates to the symbol 'always, all snippets are - considered for expansion, regardless of any conditions. - - * If it evaluates to t or some other non-nil value - - * Snippet bearing no conditions, or conditions that - evaluate to non-nil, are considered for expansion. - - * Otherwise, the snippet is not considered. - -Here's an example preventing snippets from being expanded from -inside comments, in `python-mode' only, with the exception of -snippets returning the symbol 'force-in-comment in their -conditions. - - (add-hook 'python-mode-hook - '(lambda () - (setq yas/buffer-local-condition - '(if (python-in-string/comment) - '(require-snippet-condition . force-in-comment) - t)))) - -The default value is similar, it filters out potential snippet -expansions inside comments and string literals, unless the -snippet itself contains a condition that returns the symbol -`force-in-comment'.") -(make-variable-buffer-local 'yas/buffer-local-condition) - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Internal variables - -(defvar yas/version "0.6.1b") - -(defvar yas/menu-table (make-hash-table) - "A hash table of MAJOR-MODE symbols to menu keymaps.") - -(defvar yas/active-keybindings nil - "A list of cons (KEYMAP . KEY) setup from defining snippets.") - -(defvar yas/known-modes - '(ruby-mode rst-mode markdown-mode) - "A list of mode which is well known but not part of emacs.") - -(defvar yas/escaped-characters - '(?\\ ?` ?' ?$ ?} ) - "List of characters which *might* need to be escaped.") - -(defconst yas/field-regexp - "${\\([0-9]+:\\)?\\([^}]*\\)}" - "A regexp to *almost* recognize a field.") - -(defconst yas/multi-dollar-lisp-expression-regexp - "$+[ \t\n]*\\(([^)]*)\\)" - "A regexp to *almost* recognize a \"$(...)\" expression.") - -(defconst yas/backquote-lisp-expression-regexp - "`\\([^`]*\\)`" - "A regexp to recognize a \"`lisp-expression`\" expression." ) - -(defconst yas/transform-mirror-regexp - "${\\(?:\\([0-9]+\\):\\)?$\\([ \t\n]*([^}]*\\)" - "A regexp to *almost* recognize a mirror with a transform.") - -(defconst yas/simple-mirror-regexp - "$\\([0-9]+\\)" - "A regexp to recognize a simple mirror.") - -(defvar yas/snippet-id-seed 0 - "Contains the next id for a snippet.") - -(defun yas/snippet-next-id () - (let ((id yas/snippet-id-seed)) - (incf yas/snippet-id-seed) - id)) - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Minor mode stuff - -;; XXX: `last-buffer-undo-list' is somehow needed in Carbon Emacs for MacOSX -(defvar last-buffer-undo-list nil) - -(defvar yas/minor-mode-menu nil - "Holds the YASnippet menu") - -(defun yas/init-minor-keymap () - (let ((map (make-sparse-keymap))) - (easy-menu-define yas/minor-mode-menu - map - "Menu used when YAS/minor-mode is active." - '("YASnippet" - "----" - ["Expand trigger" yas/expand - :help "Possibly expand tab trigger before point"] - ["Insert at point..." yas/insert-snippet - :help "Prompt for an expandable snippet and expand it at point"] - ["New snippet..." yas/new-snippet - :help "Create a new snippet in an appropriate directory"] - ["Visit snippet file..." yas/visit-snippet-file - :help "Prompt for an expandable snippet and find its file"] - ["Find snippets..." yas/find-snippets - :help "Invoke `find-file' in the appropriate snippet directory"] - "----" - ("Snippet menu behaviour" - ["Visit snippets" (setq yas/visit-from-menu t) - :help "Visit snippets from the menu" - :active t :style radio :selected yas/visit-from-menu] - ["Expand snippets" (setq yas/visit-from-menu nil) - :help "Expand snippets from the menu" - :active t :style radio :selected (not yas/visit-from-menu)] - "----" - ["Show \"Real\" modes only" (setq yas/use-menu 'real-modes) - :help "Show snippet submenus for modes that appear to be real major modes" - :active t :style radio :selected (eq yas/use-menu 'real-modes)] - ["Show all modes" (setq yas/use-menu 't) - :help "Show one snippet submenu for each loaded table" - :active t :style radio :selected (eq yas/use-menu 't)] - ["Abbreviate according to current mode" (setq yas/use-menu 'abbreviate) - :help "Show only snippet submenus for the current active modes" - :active t :style radio :selected (eq yas/use-menu 'abbreviate)]) - ("Indenting" - ["Auto" (setq yas/indent-line 'auto) - :help "Indent each line of the snippet with `indent-according-to-mode'" - :active t :style radio :selected (eq yas/indent-line 'auto)] - ["Fixed" (setq yas/indent-line 'fixed) - :help "Indent the snippet to the current column" - :active t :style radio :selected (eq yas/indent-line 'fixed)] - ["None" (setq yas/indent-line 'none) - :help "Don't apply any particular snippet indentation after expansion" - :active t :style radio :selected (not (member yas/indent-line '(fixed auto)))] - "----" - ["Also auto indent first line" (setq yas/also-auto-indent-first-line - (not yas/also-auto-indent-first-line)) - :help "When auto-indenting also, auto indent the first line menu" - :active (eq yas/indent-line 'auto) - :style toggle :selected yas/also-auto-indent-first-line] - ) - ("Prompting method" - ["System X-widget" (setq yas/prompt-functions - (cons 'yas/x-prompt - (remove 'yas/x-prompt - yas/prompt-functions))) - :help "Use your windowing system's (gtk, mac, windows, etc...) default menu" - :active t :style radio :selected (eq (car yas/prompt-functions) - 'yas/x-prompt)] - ["Dropdown-list" (setq yas/prompt-functions - (cons 'yas/dropdown-prompt - (remove 'yas/dropdown-prompt - yas/prompt-functions))) - :help "Use a special dropdown list" - :active t :style radio :selected (eq (car yas/prompt-functions) - 'yas/dropdown-prompt)] - ["Ido" (setq yas/prompt-functions - (cons 'yas/ido-prompt - (remove 'yas/ido-prompt - yas/prompt-functions))) - :help "Use an ido-style minibuffer prompt" - :active t :style radio :selected (eq (car yas/prompt-functions) - 'yas/ido-prompt)] - ["Completing read" (setq yas/prompt-functions - (cons 'yas/completing-prompt - (remove 'yas/completing-prompt-prompt - yas/prompt-functions))) - :help "Use a normal minibuffer prompt" - :active t :style radio :selected (eq (car yas/prompt-functions) - 'yas/completing-prompt-prompt)] - ) - ("Misc" - ["Wrap region in exit marker" - (setq yas/wrap-around-region - (not yas/wrap-around-region)) - :help "If non-nil automatically wrap the selected text in the $0 snippet exit" - :style toggle :selected yas/wrap-around-region] - ["Allow stacked expansions " - (setq yas/triggers-in-field - (not yas/triggers-in-field)) - :help "If non-nil allow snippets to be triggered inside other snippet fields" - :style toggle :selected yas/triggers-in-field] - ["Revive snippets on undo " - (setq yas/snippet-revival - (not yas/snippet-revival)) - :help "If non-nil allow snippets to become active again after undo" - :style toggle :selected yas/snippet-revival] - ["Good grace " - (setq yas/good-grace - (not yas/good-grace)) - :help "If non-nil don't raise errors in bad embedded eslip in snippets" - :style toggle :selected yas/good-grace] - ["Ignore filenames as triggers" - (setq yas/ignore-filenames-as-triggers - (not yas/ignore-filenames-as-triggers)) - :help "If non-nil don't derive tab triggers from filenames" - :style toggle :selected yas/ignore-filenames-as-triggers] - ) - "----" - ["Load snippets..." yas/load-directory - :help "Load snippets from a specific directory"] - ["Reload everything" yas/reload-all - :help "Cleanup stuff, reload snippets, rebuild menus"] - ["About" yas/about - :help "Display some information about YASsnippet"])) - ;; Now for the stuff that has direct keybindings - ;; - (define-key map "\C-c&\C-s" 'yas/insert-snippet) - (define-key map "\C-c&\C-n" 'yas/new-snippet) - (define-key map "\C-c&\C-v" 'yas/visit-snippet-file) - (define-key map "\C-c&\C-f" 'yas/find-snippets) - map)) - -(defvar yas/minor-mode-map (yas/init-minor-keymap) - "The keymap used when `yas/minor-mode' is active.") - -(defun yas/trigger-key-reload (&optional unbind-key) - "Rebind `yas/expand' to the new value of `yas/trigger-key'. - -With optional UNBIND-KEY, try to unbind that key from -`yas/minor-mode-map'." - (when (and unbind-key - (stringp unbind-key) - (not (string= unbind-key ""))) - (define-key yas/minor-mode-map (read-kbd-macro unbind-key) nil)) - (when (and yas/trigger-key - (stringp yas/trigger-key) - (not (string= yas/trigger-key ""))) - (define-key yas/minor-mode-map (read-kbd-macro yas/trigger-key) 'yas/expand))) - -;;;###autoload -(define-minor-mode yas/minor-mode - "Toggle YASnippet mode. - -When YASnippet mode is enabled, the `tas/trigger-key' key expands -snippets of code depending on the mode. - -With no argument, this command toggles the mode. -positive prefix argument turns on the mode. -Negative prefix argument turns off the mode. - -You can customize the key through `yas/trigger-key'. - -Key bindings: -\\{yas/minor-mode-map}" - nil - ;; The indicator for the mode line. - " yas" - :group 'yasnippet - (when yas/minor-mode - (yas/trigger-key-reload) - ;; load all snippets definitions unless we still don't have a - ;; root-directory or some snippets have already been loaded. - (unless (or (null yas/root-directory) - (> (hash-table-count yas/snippet-tables) 0)) - (yas/reload-all)))) - -(defvar yas/dont-activate #'(lambda () - (and yas/root-directory - (null (yas/get-snippet-tables)))) - "If non-nil don't let `yas/minor-mode-on' active yas for this buffer. - -`yas/minor-mode-on' is usually called by `yas/global-mode' so -this effectively lets you define exceptions to the \"global\" -behaviour.") -(make-variable-buffer-local 'yas/dont-activate) - - -(defun yas/minor-mode-on () - "Turn on YASnippet minor mode. - -Do this unless `yas/dont-activate' is t or the function -`yas/get-snippet-tables' (which see), returns an empty list." - (interactive) - (unless (or (and (functionp yas/dont-activate) - (funcall yas/dont-activate)) - (and (not (functionp yas/dont-activate)) - yas/dont-activate)) - (yas/minor-mode 1))) - -(defun yas/minor-mode-off () - "Turn off YASnippet minor mode." - (interactive) - (yas/minor-mode -1)) - -(define-globalized-minor-mode yas/global-mode yas/minor-mode yas/minor-mode-on - :group 'yasnippet - :require 'yasnippet) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Major mode stuff -;; -(defvar yas/font-lock-keywords - (append '(("^#.*$" . font-lock-comment-face)) - lisp-font-lock-keywords - lisp-font-lock-keywords-1 - lisp-font-lock-keywords-2 - '(("$\\([0-9]+\\)" - (0 font-lock-keyword-face) - (1 font-lock-string-face t)) - ("${\\([0-9]+\\):?" - (0 font-lock-keyword-face) - (1 font-lock-warning-face t)) - ("${" font-lock-keyword-face) - ("$[0-9]+?" font-lock-preprocessor-face) - ("\\(\\$(\\)" 1 font-lock-preprocessor-face) - ("}" - (0 font-lock-keyword-face))))) - -(defun yas/init-major-keymap () - (let ((map (make-sparse-keymap))) - (easy-menu-define nil - map - "Menu used when snippet-mode is active." - (cons "Snippet" - (mapcar #'(lambda (ent) - (when (third ent) - (define-key map (third ent) (second ent))) - (vector (first ent) (second ent) t)) - (list - (list "Load this snippet" 'yas/load-snippet-buffer "\C-c\C-c") - (list "Try out this snippet" 'yas/tryout-snippet "\C-c\C-t"))))) - map)) - -(defvar snippet-mode-map - (yas/init-major-keymap) - "The keymap used when `snippet-mode' is active") - - -(define-derived-mode snippet-mode text-mode "Snippet" - "A mode for editing yasnippets" - (set-syntax-table (standard-syntax-table)) - (setq font-lock-defaults '(yas/font-lock-keywords)) - (set (make-local-variable 'require-final-newline) nil) - (use-local-map snippet-mode-map)) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Internal structs for template management - -(defstruct (yas/template (:constructor yas/make-template - (content name condition expand-env file keybinding))) - "A template for a snippet." - content - name - condition - expand-env - file - keybinding) - -(defvar yas/snippet-tables (make-hash-table) - "A hash table of MAJOR-MODE symbols to `yas/snippet-table' objects.") - -(defstruct (yas/snippet-table (:constructor yas/make-snippet-table (name))) - "A table to store snippets for a particular mode. - -Has the following fields: - -`yas/snippet-table-name' - - A symbol normally corresponding to a major mode, but can also be - a pseudo major-mode to be referenced in `yas/mode-symbol', for - example. - -`yas/snippet-table-hash' - - A hash table the key is a string (the snippet key) and the - value is yet another hash of (NAME TEMPLATE), where NAME is the - snippet name and TEMPLATE is a `yas/template' object name. - -`yas/snippet-table-parents' - - A list of tables considered parents of this table: i.e. when - searching for expansions they are searched as well." - name - (hash (make-hash-table :test 'equal)) - (parents nil)) - -(defvar yas/better-guess-for-replacements nil - "If non-nil `yas/store' better guess snippet replacements.") - -(defun yas/store (table name key template) - "Store a snippet template in the TABLE." - - ;; This is dones by searching twice: - ;; - ;; * Try to get the existing namehash from TABLE using key. - ;; - ;; * Try to get the existing namehash from by searching the *whole* - ;; snippet table for NAME. This is becuase they user might have - ;; changed the key and that can no longer be used to locate the - ;; previous `yas/template-structure'. - ;; - ;; * If that returns nothing, oh well... - ;; - (dolist (existing-namehash (remove nil (list (gethash key (yas/snippet-table-hash table)) - (when yas/better-guess-for-replacements - (let (a) - (maphash #'(lambda (key namehash) - (when (gethash name namehash) - (setq a namehash))) - (yas/snippet-table-hash table)) - a))))) - (let ((existing-template (gethash name existing-namehash))) - (when existing-template - ;; Remove the existing keybinding - (when (yas/template-keybinding existing-template) - (define-key - (symbol-value (first (yas/template-keybinding existing-template))) - (second (yas/template-keybinding existing-template)) - nil) - (setq yas/active-keybindings - (delete (yas/template-keybinding existing-template) - yas/active-keybindings))) - ;; Remove the (name . template) mapping from existing-namehash. - (remhash name existing-namehash)))) - ;; Now store the new template independent of the previous steps. - ;; - (puthash name - template - (or (gethash key - (yas/snippet-table-hash table)) - (puthash key - (make-hash-table :test 'equal) - (yas/snippet-table-hash table))))) - -(defun yas/fetch (table key) - "Fetch a snippet binding to KEY from TABLE." - (let* ((keyhash (yas/snippet-table-hash table)) - (namehash (and keyhash (gethash key keyhash)))) - (when namehash - (yas/filter-templates-by-condition - (let (alist) - (maphash #'(lambda (k v) - (push (cons k v) alist)) - namehash) - alist))))) - - -;; Filtering/condition logic - -(defun yas/eval-condition (condition) - (condition-case err - (save-excursion - (save-restriction - (save-match-data - (eval condition)))) - (error (progn - (message (format "[yas] error in condition evaluation: %s" - (error-message-string err))) - nil)))) - - -(defun yas/filter-templates-by-condition (templates) - "Filter the templates using the applicable condition. - -TEMPLATES is a list of cons (NAME . TEMPLATE) where NAME is a -string and TEMPLATE is a `yas/template' structure. - -This function implements the rules described in -`yas/buffer-local-condition'. See that variables documentation." - (let ((requirement (yas/require-template-specific-condition-p))) - (if (eq requirement 'always) - templates - (remove-if-not #'(lambda (pair) - (yas/template-can-expand-p (yas/template-condition (cdr pair)) requirement)) - templates)))) - -(defun yas/require-template-specific-condition-p () - "Decides if this buffer requests/requires snippet-specific -conditions to filter out potential expansions." - (if (eq 'always yas/buffer-local-condition) - 'always - (let ((local-condition (or (and (consp yas/buffer-local-condition) - (yas/eval-condition yas/buffer-local-condition)) - yas/buffer-local-condition))) - (when local-condition - (if (eq local-condition t) - t - (and (consp local-condition) - (eq 'require-snippet-condition (car local-condition)) - (symbolp (cdr local-condition)) - (cdr local-condition))))))) - -(defun yas/template-can-expand-p (condition &optional requirement) - "Evaluates CONDITION and REQUIREMENT and returns a boolean" - (let* ((requirement (or requirement - (yas/require-template-specific-condition-p))) - (result (or (null condition) - (yas/eval-condition - (condition-case err - (read condition) - (error (progn - (message (format "[yas] error reading condition: %s" - (error-message-string err)))) - nil)))))) - (cond ((eq requirement t) - result) - (t - (eq requirement result))))) - -(defun yas/snippet-table-get-all-parents (table) - (let ((parents (yas/snippet-table-parents table))) - (when parents - (append (copy-list parents) - (mapcan #'yas/snippet-table-get-all-parents parents))))) - -(defun yas/snippet-table-templates (table) - (when table - (let ((acc (list))) - (maphash #'(lambda (key namehash) - (maphash #'(lambda (name template) - (push (cons name template) acc)) - namehash)) - (yas/snippet-table-hash table)) - (yas/filter-templates-by-condition acc)))) - -(defun yas/current-key () - "Get the key under current position. A key is used to find -the template of a snippet in the current snippet-table." - (let ((start (point)) - (end (point)) - (syntaxes yas/key-syntaxes) - syntax - done - templates) - (while (and (not done) syntaxes) - (setq syntax (car syntaxes)) - (setq syntaxes (cdr syntaxes)) - (save-excursion - (skip-syntax-backward syntax) - (setq start (point))) - (setq templates - (mapcan #'(lambda (table) - (yas/fetch table (buffer-substring-no-properties start end))) - (yas/get-snippet-tables))) - (if templates - (setq done t) - (setq start end))) - (list templates - start - end))) - - -(defun yas/snippet-table-all-keys (table) - (when table - (let ((acc)) - (maphash #'(lambda (key templates) - (when (yas/filter-templates-by-condition templates) - (push key acc))) - (yas/snippet-table-hash table)) - acc))) - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Internal functions - -(defun yas/real-mode? (mode) - "Try to find out if MODE is a real mode. The MODE bound to -a function (like `c-mode') is considered real mode. Other well -known mode like `ruby-mode' which is not part of Emacs might -not bound to a function until it is loaded. So yasnippet keeps -a list of modes like this to help the judgement." - (or (fboundp mode) - (find mode yas/known-modes))) - -(defun yas/read-and-eval-string (string) - ;; TODO: This is a possible optimization point, the expression could - ;; be stored in cons format instead of string, - "Evaluate STRING and convert the result to string." - (let ((retval (catch 'yas/exception - (condition-case err - (save-excursion - (save-restriction - (save-match-data - (widen) - (let ((result (eval (read string)))) - (when result - (format "%s" result)))))) - (error (if yas/good-grace - "[yas] elisp error!" - (error (format "[yas] elisp error: %s" - (error-message-string err))))))))) - (when (and (consp retval) - (eq 'yas/exception (car retval))) - (error (cdr retval))) - retval)) - -(defvar yas/mode-symbol nil - "If non-nil, lookup snippets using this instead of `major-mode'.") -(make-variable-buffer-local 'yas/mode-symbol) - -(defun yas/snippet-table-get-create (mode) - "Get the snippet table corresponding to MODE. - -Optional DIRECTORY gets recorded as the default directory to -search for snippet files if the retrieved/created table didn't -already have such a property." - (let ((table (gethash mode - yas/snippet-tables))) - (unless table - (setq table (yas/make-snippet-table (symbol-name mode))) - (puthash mode table yas/snippet-tables)) - table)) - -(defun yas/get-snippet-tables (&optional mode-symbol dont-search-parents) - "Get snippet tables for current buffer. - -Return a list of 'yas/snippet-table' objects indexed by mode. - -The modes are tried in this order: optional MODE-SYMBOL, then -`yas/mode-symbol', then `major-mode' then, unless -DONT-SEARCH-PARENTS is non-nil, the guessed parent mode of either -MODE-SYMBOL or `major-mode'. - -Guessing is done by looking up the MODE-SYMBOL's -`derived-mode-parent' property, see also `derived-mode-p'." - (let ((mode-tables - (mapcar #'(lambda (mode) - (gethash mode yas/snippet-tables)) - (append (list mode-symbol) - (if (listp yas/mode-symbol) - yas/mode-symbol - (list yas/mode-symbol)) - (list major-mode - (and (not dont-search-parents) - (get (or mode-symbol major-mode) - 'derived-mode-parent)))))) - (all-tables)) - (dolist (table (remove nil mode-tables)) - (push table all-tables) - (nconc all-tables (yas/snippet-table-get-all-parents table))) - (remove-duplicates all-tables))) - -(defun yas/menu-keymap-get-create (mode) - "Get the menu keymap correspondong to MODE." - (or (gethash mode yas/menu-table) - (puthash mode (make-sparse-keymap) yas/menu-table))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; Template-related and snippet loading functions - -(defun yas/parse-template (&optional file) - "Parse the template in the current buffer. - -Optional FILE is the absolute file name of the file being -parsed. - -Return a snippet-definition, i.e. a list - - (KEY TEMPLATE NAME CONDITION GROUP VARS FILE KEYBINDING) - -If the buffer contains a line of \"# --\" then the contents -above this line are ignored. Variables can be set above this -line through the syntax: - -#name : value - -Here's a list of currently recognized variables: - - * name - * contributor - * condition - * key - * group - * expand-env - -#name: #include \"...\" -# -- -#include \"$1\"" - ;; - ;; - (goto-char (point-min)) - (let* ((name (and file - (file-name-nondirectory file))) - (key (unless yas/ignore-filenames-as-triggers - (and name - (file-name-sans-extension name)))) - template - bound - condition - (group (and file - (yas/calculate-group file))) - expand-env - binding) - (if (re-search-forward "^# --\n" nil t) - (progn (setq template - (buffer-substring-no-properties (point) - (point-max))) - (setq bound (point)) - (goto-char (point-min)) - (while (re-search-forward "^# *\\([^ ]+?\\) *: *\\(.*\\)$" bound t) - (when (string= "name" (match-string-no-properties 1)) - (setq name (match-string-no-properties 2))) - (when (string= "condition" (match-string-no-properties 1)) - (setq condition (match-string-no-properties 2))) - (when (string= "group" (match-string-no-properties 1)) - (setq group (match-string-no-properties 2))) - (when (string= "expand-env" (match-string-no-properties 1)) - (setq expand-env (match-string-no-properties 2))) - (when (string= "key" (match-string-no-properties 1)) - (setq key (match-string-no-properties 2))) - (when (string= "binding" (match-string-no-properties 1)) - (setq binding (match-string-no-properties 2))))) - (setq template - (buffer-substring-no-properties (point-min) (point-max)))) - (list key template name condition group expand-env file binding))) - -(defun yas/calculate-group (file) - "Calculate the group for snippet file path FILE." - (let* ((dominating-dir (locate-dominating-file file - ".yas-make-groups")) - (extra-path (and dominating-dir - (replace-regexp-in-string (concat "^" - (expand-file-name dominating-dir)) - "" - (expand-file-name file)))) - (extra-dir (and extra-path - (file-name-directory extra-path))) - (group (and extra-dir - (replace-regexp-in-string "/" - "." - (directory-file-name extra-dir))))) - group)) - -;; (defun yas/glob-files (directory &optional recurse-p append) -;; "Returns files under DIRECTORY ignoring dirs and hidden files. - -;; If RECURSE in non-nil, do that recursively." -;; (let (ret -;; (default-directory directory)) -;; (dolist (entry (directory-files ".")) -;; (cond ((or (string-match "^\\." -;; (file-name-nondirectory entry)) -;; (string-match "~$" -;; (file-name-nondirectory entry))) -;; nil) -;; ((and recurse-p -;; (file-directory-p entry)) -;; (setq ret (nconc ret -;; (yas/glob-files (expand-file-name entry) -;; recurse-p -;; (if append -;; (concat append "/" entry) -;; entry))))) -;; ((file-directory-p entry) -;; nil) -;; (t -;; (push (if append -;; (concat append "/" entry) -;; entry) ret)))) -;; ret)) - -(defun yas/subdirs (directory &optional file?) - "Return subdirs or files of DIRECTORY according to FILE?." - (remove-if (lambda (file) - (or (string-match "^\\." - (file-name-nondirectory file)) - (string-match "~$" - (file-name-nondirectory file)) - (if file? - (file-directory-p file) - (not (file-directory-p file))))) - (directory-files directory t))) - -(defun yas/make-menu-binding (template) - `(lambda () (interactive) (yas/expand-or-visit-from-menu ,template))) - -(defun yas/expand-or-visit-from-menu (template) - (if yas/visit-from-menu - (yas/visit-snippet-file-1 template) - (let ((where (if mark-active - (cons (region-beginning) (region-end)) - (cons (point) (point))))) - (yas/expand-snippet (yas/template-content template) - (car where) - (cdr where))))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Popping up for keys and templates -;; -(defun yas/prompt-for-template (templates &optional prompt) - "Interactively choose a template from the list TEMPLATES. - -TEMPLATES is a list of `yas/template'." - (when templates - (some #'(lambda (fn) - (funcall fn (or prompt "Choose a snippet: ") - templates - #'yas/template-name)) - yas/prompt-functions))) - -(defun yas/prompt-for-keys (keys &optional prompt) - "Interactively choose a template key from the list KEYS." - (when keys - (some #'(lambda (fn) - (funcall fn (or prompt "Choose a snippet key: ") keys)) - yas/prompt-functions))) - -(defun yas/prompt-for-table (tables &optional prompt) - (when tables - (some #'(lambda (fn) - (funcall fn (or prompt "Choose a snippet table: ") - tables - #'yas/snippet-table-name)) - yas/prompt-functions))) - -(defun yas/x-prompt (prompt choices &optional display-fn) - (when (and window-system choices) - (let ((keymap (cons 'keymap - (cons - prompt - (mapcar (lambda (choice) - (list choice - 'menu-item - (if display-fn - (funcall display-fn choice) - choice) - t)) - choices))))) - (when (cdr keymap) - (car (x-popup-menu (if (fboundp 'posn-at-point) - (let ((x-y (posn-x-y (posn-at-point (point))))) - (list (list (+ (car x-y) 10) - (+ (cdr x-y) 20)) - (selected-window))) - t) - keymap)))))) - -(defun yas/ido-prompt (prompt choices &optional display-fn) - (when (and (featurep 'ido) - ido-mode) - (let* ((formatted-choices (or (and display-fn - (mapcar display-fn choices)) - choices)) - (chosen (and formatted-choices - (ido-completing-read prompt - formatted-choices - nil - 'require-match - nil - nil)))) - (when chosen - (nth (position chosen formatted-choices :test #'string=) choices))))) - -(eval-when-compile (require 'dropdown-list nil t)) -(defun yas/dropdown-prompt (prompt choices &optional display-fn) - (when (featurep 'dropdown-list) - (let* ((formatted-choices (or (and display-fn - (mapcar display-fn choices)) - choices)) - (chosen (and formatted-choices - (nth (dropdown-list formatted-choices) - choices)))) - chosen))) - -(defun yas/completing-prompt (prompt choices &optional display-fn) - (let* ((formatted-choices (or (and display-fn - (mapcar display-fn choices)) - choices)) - (chosen (and formatted-choices - (completing-read prompt - formatted-choices - nil - 'require-match - nil - nil)))) - (when chosen - (nth (position chosen formatted-choices :test #'string=) choices)))) - -(defun yas/no-prompt (prompt choices &optional display-fn) - (first choices)) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Loading snippets from files -;; -(defun yas/load-directory-1 (directory &optional parents no-hierarchy-parents making-groups-sym) - "Recursively load snippet templates from DIRECTORY." - ;; TODO: Rewrite this horrible, horrible monster I created - (unless (file-exists-p (concat directory "/" ".yas-skip")) - (let* ((major-mode-and-parents (unless making-groups-sym - (yas/compute-major-mode-and-parents (concat directory "/dummy") - nil - no-hierarchy-parents))) - (yas/ignore-filenames-as-triggers (or yas/ignore-filenames-as-triggers - (file-exists-p (concat directory "/" ".yas-ignore-filenames-as-triggers")))) - (mode-sym (and major-mode-and-parents - (car major-mode-and-parents))) - (parents (if making-groups-sym - parents - (rest major-mode-and-parents))) - (snippet-defs nil) - (make-groups-p (or making-groups-sym - (file-exists-p (concat directory "/" ".yas-make-groups"))))) - (with-temp-buffer - (dolist (file (yas/subdirs directory 'no-subdirs-just-files)) - (when (file-readable-p file) - (insert-file-contents file nil nil nil t) - (push (yas/parse-template file) - snippet-defs)))) - (yas/define-snippets (or mode-sym - making-groups-sym) - snippet-defs - parents) - (dolist (subdir (yas/subdirs directory)) - (if make-groups-p - (yas/load-directory-1 subdir parents 't (or mode-sym - making-groups-sym)) - (yas/load-directory-1 subdir (list mode-sym))))))) - -(defun yas/load-directory (directory) - "Load snippet definition from a directory hierarchy. - -Below the top-level directory, each directory is a mode -name. And under each subdirectory, each file is a definition -of a snippet. The file name is the trigger key and the -content of the file is the template." - (interactive "DSelect the root directory: ") - (unless (file-directory-p directory) - (error "Error %s not a directory" directory)) - (unless yas/root-directory - (setq yas/root-directory directory)) - (dolist (dir (yas/subdirs directory)) - (yas/load-directory-1 dir nil 'no-hierarchy-parents)) - (when (interactive-p) - (message "done."))) - -(defun yas/kill-snippet-keybindings () - "Remove the all active snippet keybindings." - (interactive) - (dolist (keybinding yas/active-keybindings) - (define-key (symbol-value (first keybinding)) (second keybinding) nil)) - (setq yas/active-keybindings nil)) - -(defun yas/reload-all (&optional reset-root-directory) - "Reload all snippets and rebuild the YASnippet menu. " - (interactive "P") - ;; Turn off global modes and minor modes, save their state though - ;; - (let ((restore-global-mode (prog1 yas/global-mode - (yas/global-mode -1))) - (restore-minor-mode (prog1 yas/minor-mode - (yas/minor-mode -1)))) - ;; Empty all snippet tables and all menu tables - ;; - (setq yas/snippet-tables (make-hash-table)) - (setq yas/menu-table (make-hash-table)) - - ;; Init the `yas/minor-mode-map', taking care not to break the - ;; menu.... - ;; - (setf (cdr yas/minor-mode-map) - (cdr (yas/init-minor-keymap))) - - ;; Now, clean up the other keymaps we might have cluttered up. - (yas/kill-snippet-keybindings) - - (when reset-root-directory - (setq yas/root-directory nil)) - - ;; Reload the directories listed in `yas/root-directory' or prompt - ;; the user to select one. - ;; - (if yas/root-directory - (if (listp yas/root-directory) - (dolist (directory yas/root-directory) - (yas/load-directory directory)) - (yas/load-directory yas/root-directory)) - (call-interactively 'yas/load-directory)) - - ;; Restore the mode configuration - ;; - (when restore-minor-mode - (yas/minor-mode 1)) - (when restore-global-mode - (yas/global-mode 1)) - - (message "[yas] Reloading everything... Done."))) - -(defun yas/quote-string (string) - "Escape and quote STRING. -foo\"bar\\! -> \"foo\\\"bar\\\\!\"" - (concat "\"" - (replace-regexp-in-string "[\\\"]" - "\\\\\\&" - string - t) - "\"")) -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; Yasnippet Bundle - -(defun yas/initialize () - "For backward compatibility, enable `yas/minor-mode' globally" - (yas/global-mode 1)) - -(defun yas/compile-bundle - (&optional yasnippet yasnippet-bundle snippet-roots code dropdown) - "Compile snippets in SNIPPET-ROOTS to a single bundle file. - -YASNIPPET is the yasnippet.el file path. - -YASNIPPET-BUNDLE is the output file of the compile result. - -SNIPPET-ROOTS is a list of root directories that contains the -snippets definition. - -CODE is the code to be placed at the end of the generated file -and that can initialize the YASnippet bundle. - -Last optional argument DROPDOWN is the filename of the -dropdown-list.el library. - -Here's the default value for all the parameters: - - (yas/compile-bundle \"yasnippet.el\" - \"yasnippet-bundle.el\" - \"snippets\") - \"(yas/initialize-bundle) - ### autoload - (require 'yasnippet-bundle)`\" - \"dropdown-list.el\") -" - (interactive "ffind the yasnippet.el file: \nFTarget bundle file: \nDSnippet directory to bundle: \nMExtra code? \nfdropdown-library: ") - - (let* ((yasnippet (or yasnippet - "yasnippet.el")) - (yasnippet-bundle (or yasnippet-bundle - "./yasnippet-bundle.el")) - (snippet-roots (or snippet-roots - "snippets")) - (dropdown (or dropdown - "dropdown-list.el")) - (code (or (and code - (condition-case err (read code) (error nil)) - code) - (concat "(yas/initialize-bundle)" - "\n;;;###autoload" ; break through so that won't - "(require 'yasnippet-bundle)"))) - (dirs (or (and (listp snippet-roots) snippet-roots) - (list snippet-roots))) - (bundle-buffer nil)) - (with-temp-file yasnippet-bundle - (insert ";;; yasnippet-bundle.el --- " - "Yet another snippet extension (Auto compiled bundle)\n") - (insert-file-contents yasnippet) - (goto-char (point-max)) - (insert "\n") - (when dropdown - (insert-file-contents dropdown)) - (goto-char (point-max)) - (insert ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n") - (insert ";;;; Auto-generated code ;;;;\n") - (insert ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n") - (insert "(defun yas/initialize-bundle ()\n" - " \"Initialize YASnippet and load snippets in the bundle.\"") - (flet ((yas/define-snippets - (mode snippets &optional parent-or-parents) - (insert ";;; snippets for " (symbol-name mode) "\n") - (let ((literal-snippets (list))) - (dolist (snippet snippets) - (let ((key (first snippet)) - (template-content (second snippet)) - (name (third snippet)) - (condition (fourth snippet)) - (group (fifth snippet)) - (expand-env (sixth snippet)) - ;; Omit the file on purpose - (file nil) ;; (seventh snippet)) - (binding (eighth snippet))) - (push `(,key - ,template-content - ,name - ,condition - ,group - ,expand-env - ,file - ,binding) - literal-snippets))) - (insert (pp-to-string `(yas/define-snippets ',mode ',literal-snippets ',parent-or-parents))) - (insert "\n\n")))) - (dolist (dir dirs) - (dolist (subdir (yas/subdirs dir)) - (yas/load-directory-1 subdir nil 'no-hierarchy-parents)))) - - (insert (pp-to-string `(yas/global-mode 1))) - (insert ")\n\n" code "\n") - - ;; bundle-specific provide and value for yas/dont-activate - (let ((bundle-feature-name (file-name-nondirectory - (file-name-sans-extension - yasnippet-bundle)))) - (insert (pp-to-string `(set-default 'yas/dont-activate - #'(lambda () - (and (or yas/root-directory - (featurep ',(make-symbol bundle-feature-name))) - (null (yas/get-snippet-tables))))))) - (insert (pp-to-string `(provide ',(make-symbol bundle-feature-name))))) - - (insert ";;; " - (file-name-nondirectory yasnippet-bundle) - " ends here\n")))) - -(defun yas/compile-textmate-bundle () - (interactive) - (yas/compile-bundle "yasnippet.el" - "./yasnippet-textmate-bundle.el" - "extras/imported/" - (concat "(yas/initialize-bundle)" - "\n;;;###autoload" ; break through so that won't - "(require 'yasnippet-textmate-bundle)") - "dropdown-list.el")) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; Some user level functions -;;; - -(defun yas/about () - (interactive) - (message (concat "yasnippet (version " - yas/version - ") -- pluskid /joaotavora "))) - -(defun yas/define-snippets (mode snippets &optional parent-mode) - "Define SNIPPETS for MODE. - -SNIPPETS is a list of snippet definitions, each taking the -following form: - - (KEY TEMPLATE NAME CONDITION GROUP EXPAND-ENV FILE KEYBINDING) - -Within these, only TEMPLATE is actually mandatory. - -All the elelements are strings, including CONDITION, EXPAND-ENV -and KEYBINDING which will be `read' and eventually `eval'-ed. - -FILE is probably of very little use if you're programatically -defining snippets. - -You can use `yas/parse-template' to return such lists based on -the current buffers contents. - -Optional PARENT-MODE can be used to specify the parent tables of -MODE. It can be a mode symbol of a list of mode symbols. It does -not need to be a real mode." - (let ((snippet-table (yas/snippet-table-get-create mode)) - (parent-tables (mapcar #'yas/snippet-table-get-create - (if (listp parent-mode) - parent-mode - (list parent-mode)))) - (keymap (if yas/use-menu - (yas/menu-keymap-get-create mode) - nil))) - ;; Setup the menu - ;; - (when parent-tables - (setf (yas/snippet-table-parents snippet-table) - parent-tables) - (when yas/use-menu - (let ((parent-menu-syms-and-names - (if (listp parent-mode) - (mapcar #'(lambda (sym) - (cons sym (concat "parent mode - " (symbol-name sym)))) - parent-mode) - '((parent-mode . "parent mode"))))) - (mapc #'(lambda (sym-and-name) - (define-key keymap - (vector (intern (replace-regexp-in-string " " "_" (cdr sym-and-name)))) - (list 'menu-item (cdr sym-and-name) - (yas/menu-keymap-get-create (car sym-and-name))))) - (reverse parent-menu-syms-and-names))))) - (when yas/use-menu - (define-key yas/minor-mode-menu (vector mode) - `(menu-item ,(symbol-name mode) ,keymap - :visible (yas/show-menu-p ',mode)))) - ;; Iterate the recently parsed snippets definition - ;; - (dolist (snippet snippets) - (let* ((file (seventh snippet)) - (key (or (car snippet) - (unless yas/ignore-filenames-as-triggers - (and file - (file-name-sans-extension (file-name-nondirectory file)))))) - (name (or (third snippet) - (and file - (file-name-directory file)))) - (condition (fourth snippet)) - (group (fifth snippet)) - (keybinding (eighth snippet)) - (template nil)) - ;; Read the snippet's "binding :" expression - ;; - (condition-case err - (when keybinding - (setq keybinding (read (eighth snippet))) - (let* ((this-mode-map-symbol (intern (concat (symbol-name mode) "-map"))) - (keys (or (and (consp keybinding) - (read-kbd-macro (cdr keybinding))) - (read-kbd-macro keybinding))) - (keymap-symbol (or (and (consp keybinding) - (car keybinding)) - this-mode-map-symbol))) - (if (and (boundp keymap-symbol) - (keymapp (symbol-value keymap-symbol))) - (setq keybinding (list keymap-symbol - keys - name)) - (error (format "keymap \"%s\" does not (yet?) exist" keymap-symbol))))) - (error - (message "[yas] warning: keybinding \"%s\" invalid for snippet \"%s\" since %s." - keybinding name (error-message-string err)) - (setf keybinding nil))) - - ;; Create the `yas/template' object and store in the - ;; appropriate snippet table. This only done if we have found - ;; a key and a name for the snippet, because that is what - ;; indexes the snippet tables - ;; - (setq template (yas/make-template (second snippet) - (or name key) - condition - (sixth snippet) - (seventh snippet) - keybinding)) - (when (and key - name) - (yas/store snippet-table - name - key - template)) - ;; If we have a keybinding, register it if it does not - ;; conflict! - ;; - (when keybinding - (let ((lookup (lookup-key (symbol-value (first keybinding)) (second keybinding)))) - (if (and lookup - (not (numberp lookup))) - (message "[yas] warning: won't overwrite keybinding \"%s\" for snippet \"%s\" in `%s'" - (key-description (second keybinding)) name (first keybinding)) - (define-key - (symbol-value (first keybinding)) - (second keybinding) - `(lambda (&optional yas/prefix) - (interactive "P") - (when (yas/template-can-expand-p ,(yas/template-condition template)) - (yas/expand-snippet ,(yas/template-content template) - nil - nil - ,(yas/template-expand-env template))))) - (add-to-list 'yas/active-keybindings keybinding)))) - - ;; Setup the menu groups, reorganizing from group to group if - ;; necessary - ;; - (when yas/use-menu - (let ((group-keymap keymap)) - ;; Delete this entry from another group if already exists - ;; in some other group. An entry is considered as existing - ;; in another group if its name string-matches. - ;; - (yas/delete-from-keymap group-keymap name) - - ;; ... then add this entry to the correct group - (when (and (not (null group)) - (not (string= "" group))) - (dolist (subgroup (mapcar #'make-symbol - (split-string group "\\."))) - (let ((subgroup-keymap (lookup-key group-keymap - (vector subgroup)))) - (when (null subgroup-keymap) - (setq subgroup-keymap (make-sparse-keymap)) - (define-key group-keymap (vector subgroup) - `(menu-item ,(symbol-name subgroup) - ,subgroup-keymap))) - (setq group-keymap subgroup-keymap)))) - (define-key group-keymap (vector (gensym)) - `(menu-item ,(yas/template-name template) - ,(yas/make-menu-binding template) - :help ,name - :keys ,(when (and key name) - (concat key yas/trigger-symbol)))))))))) - -(defun yas/show-menu-p (mode) - (cond ((eq yas/use-menu 'abbreviate) - (find mode - (mapcar #'(lambda (table) - (intern (yas/snippet-table-name table))) - (yas/get-snippet-tables)))) - ((eq yas/use-menu 'real-modes) - (yas/real-mode? mode)) - (t - t))) - -(defun yas/delete-from-keymap (keymap name) - "Recursively delete items name NAME from KEYMAP and its submenus. - -Skip any submenus named \"parent mode\"" - ;; First of all, recursively enter submenus, i.e. the tree is - ;; searched depth first so that stale submenus can be found in the - ;; higher passes. - ;; - (mapc #'(lambda (item) - (when (and (keymapp (fourth item)) - (stringp (third item)) - (not (string-match "parent mode" (third item)))) - (yas/delete-from-keymap (fourth item) name))) - (rest keymap)) - ;; - (when (keymapp keymap) - (let ((pos-in-keymap)) - (while (setq pos-in-keymap - (position-if #'(lambda (item) - (and (listp item) - (or - ;; the menu item we want to delete - (and (eq 'menu-item (second item)) - (third item) - (and (string= (third item) name))) - ;; a stale subgroup - (and (keymapp (fourth item)) - (not (and (stringp (third item)) - (string-match "parent mode" - (third item)))) - (null (rest (fourth item))))))) - keymap)) - (setf (nthcdr pos-in-keymap keymap) - (nthcdr (+ 1 pos-in-keymap) keymap)))))) - -(defun yas/define (mode key template &optional name condition group) - "Define a snippet. Expanding KEY into TEMPLATE. - -NAME is a description to this template. Also update the menu if -`yas/use-menu' is `t'. CONDITION is the condition attached to -this snippet. If you attach a condition to a snippet, then it -will only be expanded when the condition evaluated to non-nil." - (yas/define-snippets mode - (list (list key template name condition group)))) - -(defun yas/hippie-try-expand (first-time?) - "Integrate with hippie expand. Just put this function in -`hippie-expand-try-functions-list'." - (if (not first-time?) - (let ((yas/fallback-behavior 'return-nil)) - (yas/expand)) - (undo 1) - nil)) - -(defun yas/expand () - "Expand a snippet before point. - -If no snippet expansion is possible, fall back to the behaviour -defined in `yas/fallback-behavior'" - (interactive) - (yas/expand-1)) - -(defun yas/expand-1 (&optional field) - "Actually fo the work for `yas/expand'" - (multiple-value-bind (templates start end) (if field - (save-restriction - (narrow-to-region (yas/field-start field) (yas/field-end field)) - (yas/current-key)) - (yas/current-key)) - (if templates - (let ((template (or (and (rest templates) ;; more than one - (yas/prompt-for-template (mapcar #'cdr templates))) - (cdar templates)))) - (when template - (yas/expand-snippet (yas/template-content template) - start - end - (yas/template-expand-env template)))) - (cond ((eq yas/fallback-behavior 'return-nil) - ;; return nil - nil) - ((eq yas/fallback-behavior 'call-other-command) - (let* ((yas/minor-mode nil) - (keys-1 (this-command-keys-vector)) - (keys-2 (and yas/trigger-key - (stringp yas/trigger-key) - (read-kbd-macro yas/trigger-key))) - (command-1 (and keys-1 (key-binding keys-1))) - (command-2 (and keys-2 (key-binding keys-2))) - (command (or (and (not (eq command-1 'yas/expand)) - command-1) - command-2))) - (when (and (commandp command) - (not (eq 'yas/expand command))) - (setq this-command command) - (call-interactively command)))) - ((and (listp yas/fallback-behavior) - (cdr yas/fallback-behavior) - (eq 'apply (car yas/fallback-behavior))) - (if (cddr yas/fallback-behavior) - (apply (cadr yas/fallback-behavior) - (cddr yas/fallback-behavior)) - (when (commandp (cadr yas/fallback-behavior)) - (setq this-command (cadr yas/fallback-behavior)) - (call-interactively (cadr yas/fallback-behavior))))) - (t - ;; also return nil if all the other fallbacks have failed - nil))))) - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; Snippet development - -(defun yas/all-templates (tables) - "Return all snippet tables applicable for the current buffer. - -Honours `yas/choose-tables-first', `yas/choose-keys-first' and -`yas/buffer-local-condition'" - (when yas/choose-tables-first - (setq tables (list (yas/prompt-for-table tables)))) - (mapcar #'cdr - (if yas/choose-keys-first - (let ((key (yas/prompt-for-keys - (mapcan #'yas/snippet-table-all-keys tables)))) - (when key - (mapcan #'(lambda (table) - (yas/fetch table key)) - tables))) - (mapcan #'yas/snippet-table-templates tables)))) - -(defun yas/insert-snippet (&optional no-condition) - "Choose a snippet to expand, pop-up a list of choices according -to `yas/prompt-function'. - -With prefix argument NO-CONDITION, bypass filtering of snippets -by condition." - (interactive "P") - (let* ((yas/buffer-local-condition (or (and no-condition - 'always) - yas/buffer-local-condition)) - (templates (yas/all-templates (yas/get-snippet-tables))) - (template (and templates - (or (and (rest templates) ;; more than one template for same key - (yas/prompt-for-template templates)) - (car templates)))) - (where (if mark-active - (cons (region-beginning) (region-end)) - (cons (point) (point))))) - (if template - (yas/expand-snippet (yas/template-content template) - (car where) - (cdr where) - (yas/template-expand-env template)) - (message "[yas] No snippets can be inserted here!")))) - -(defun yas/visit-snippet-file () - "Choose a snippet to edit, selection like `yas/insert-snippet'. - -Only success if selected snippet was loaded from a file. Put the -visited file in `snippet-mode'." - (interactive) - (let* ((yas/buffer-local-condition 'always) - (templates (yas/all-templates (yas/get-snippet-tables))) - (template (and templates - (or (and (rest templates) ;; more than one template for same key - (yas/prompt-for-template templates - "Choose a snippet template to edit: ")) - (car templates))))) - - (when template - (yas/visit-snippet-file-1 template)))) - -(defun yas/visit-snippet-file-1 (template) - (let ((file (yas/template-file template))) - (cond ((and file (file-exists-p file)) - (find-file-other-window file) - (snippet-mode)) - (file - (message "Original file %s no longer exists!" file)) - (t - (message "This snippet was not loaded from a file!"))))) - -(defun yas/guess-snippet-directories-1 (table &optional suffix) - "Guesses possible snippet subdirsdirectories for TABLE." - (unless suffix - (setq suffix (yas/snippet-table-name table))) - (cons suffix - (mapcan #'(lambda (parent) - (yas/guess-snippet-directories-1 - parent - (concat (yas/snippet-table-name parent) "/" suffix))) - (yas/snippet-table-parents table)))) - -(defun yas/guess-snippet-directories () - "Try to guess suitable directories based on the current active -tables. - -Returns a a list of options alist TABLE -> DIRS where DIRS are -all the possibly directories where snippets of table might be -lurking." - (let ((main-dir (or (and (listp yas/root-directory) - (first yas/root-directory)) - yas/root-directory - (setq yas/root-directory "~/.emacs.d/snippets"))) - (tables (yas/get-snippet-tables))) - ;; HACK! the snippet table created here is a dummy table that - ;; holds the correct name so that `yas/make-directory-maybe' can - ;; work. The real table, if it does not exist in - ;; yas/snippet-tables will be created when the first snippet for - ;; that mode is loaded. - ;; - (unless (gethash major-mode yas/snippet-tables) - (setq tables (cons (yas/make-snippet-table (symbol-name major-mode)) - tables))) - - (mapcar #'(lambda (table) - (cons table - (mapcar #'(lambda (subdir) - (concat main-dir "/" subdir)) - (yas/guess-snippet-directories-1 table)))) - tables))) - -(defun yas/make-directory-maybe (table-and-dirs &optional main-table-string) - "Returns a dir inside TABLE-AND-DIRS, prompts for creation if none exists." - (or (some #'(lambda (dir) (when (file-directory-p dir) dir)) (cdr table-and-dirs)) - (let ((candidate (first (cdr table-and-dirs)))) - (if (y-or-n-p (format "Guessed directory (%s) for%s%s table \"%s\" does not exist! Create? " - candidate - (if (gethash (intern (yas/snippet-table-name (car table-and-dirs))) - yas/snippet-tables) - "" - " brand new") - (or main-table-string - "") - (yas/snippet-table-name (car table-and-dirs)))) - (progn - (make-directory candidate 'also-make-parents) - ;; create the .yas-parents file here... - candidate))))) - -(defun yas/new-snippet (&optional choose-instead-of-guess) - "" - (interactive "P") - (let* ((guessed-directories (yas/guess-snippet-directories)) - (option (or (and choose-instead-of-guess - (some #'(lambda (fn) - (funcall fn "Choose a snippet table: " - guessed-directories - #'(lambda (option) - (yas/snippet-table-name (car option))))) - yas/prompt-functions)) - (first guessed-directories))) - (chosen)) - (setq chosen (yas/make-directory-maybe option (unless choose-instead-of-guess - " main"))) - (unless (or chosen - choose-instead-of-guess) - (if (y-or-n-p (format "Continue guessing for other active tables %s? " - (mapcar #'(lambda (table-and-dirs) - (yas/snippet-table-name (car table-and-dirs))) - (rest guessed-directories)))) - (setq chosen (some #'yas/make-directory-maybe - (rest guessed-directories))))) - (unless (or chosen - choose-instead-of-guess) - (when (y-or-n-p "Having trouble... use snippet root dir? ") - (setq chosen (if (listp yas/root-directory) - (first yas/root-directory) - yas/root-directory)))) - (if chosen - (let ((default-directory chosen) - (name (read-from-minibuffer "Enter a snippet name: "))) - (find-file-other-window (concat name - ".yasnippet")) - (snippet-mode) - (unless (and choose-instead-of-guess - (not (y-or-n-p "Insert a snippet with useful headers? "))) - (yas/expand-snippet (format - "\ -# -*- mode: snippet -*- -# name: %s -# key: $1${2: -# binding: \"${3:keybinding}\"}${4: -# expand-env: ((${5:some-var} ${6:some-value}))} -# -- -$0" name)))) - (message "[yas] aborted snippet creation.")))) - -(defun yas/find-snippets (&optional same-window ) - "Look for user snippets in guessed current mode's directory. - -Calls `find-file' interactively in the guessed directory. - -With prefix arg SAME-WINDOW opens the buffer in the same window. - -Because snippets can be loaded from many different locations, -this has to guess the correct directory using -`yas/guess-snippet-directories', which returns a list of -options. - -If any one of these exists, it is taken and `find-file' is called -there, otherwise, proposes to create the first option returned by -`yas/guess-snippet-directories'." - (interactive "P") - (let* ((guessed-directories (yas/guess-snippet-directories)) - (chosen) - (buffer)) - (setq chosen (yas/make-directory-maybe (first guessed-directories) " main")) - (unless chosen - (if (y-or-n-p (format "Continue guessing for other active tables %s? " - (mapcar #'(lambda (table-and-dirs) - (yas/snippet-table-name (car table-and-dirs))) - (rest guessed-directories)))) - (setq chosen (some #'yas/make-directory-maybe - (rest guessed-directories))))) - (unless chosen - (when (y-or-n-p "Having trouble... go to snippet root dir? ") - (setq chosen (if (listp yas/root-directory) - (first yas/root-directory) - yas/root-directory)))) - (if chosen - (let ((default-directory chosen)) - (setq buffer (call-interactively (if same-window - 'find-file - 'find-file-other-window))) - (when buffer - (save-excursion - (set-buffer buffer) - (when (eq major-mode 'fundamental-mode) - (snippet-mode))))) - (message "Could not guess snippet dir!")))) - -(defun yas/compute-major-mode-and-parents (file &optional prompt-if-failed no-hierarchy-parents) - (let* ((file-dir (and file - (directory-file-name (or (locate-dominating-file file ".yas-make-groups") - (directory-file-name (file-name-directory file)))))) - (major-mode-name (and file-dir - (file-name-nondirectory file-dir))) - (parent-file-dir (and file-dir - (directory-file-name (file-name-directory file-dir)))) - (parent-mode-name (and parent-file-dir - (not no-hierarchy-parents) - (file-name-nondirectory parent-file-dir))) - (major-mode-sym (or (and major-mode-name - (intern major-mode-name)) - (when prompt-if-failed - (read-from-minibuffer - "[yas] Cannot auto-detect major mode! Enter a major mode: ")))) - (parent-mode-sym (and parent-mode-name - (intern parent-mode-name))) - (extra-parents-file-name (concat file-dir "/.yas-parents")) - (more-parents (when (file-readable-p extra-parents-file-name) - (mapcar #'intern - (split-string - (with-temp-buffer - (insert-file-contents extra-parents-file-name) - (buffer-substring-no-properties (point-min) - (point-max)))))))) - (when major-mode-sym - (remove nil (append (list major-mode-sym parent-mode-sym) - more-parents))))) - -(defun yas/load-snippet-buffer (&optional kill) - "Parse and load current buffer's snippet definition. - -With optional prefix argument KILL quit the window and buffer." - (interactive "P") - (if buffer-file-name - (let ((major-mode-and-parent (yas/compute-major-mode-and-parents buffer-file-name))) - (if major-mode-and-parent - (let* ((parsed (yas/parse-template buffer-file-name)) - (name (and parsed - (third parsed)))) - (when name - (let ((yas/better-guess-for-replacements t)) - (yas/define-snippets (car major-mode-and-parent) - (list parsed) - (cdr major-mode-and-parent))) - (when (and (buffer-modified-p) - (y-or-n-p "Save snippet? ")) - (save-buffer)) - (if kill - (quit-window kill) - (message "[yas] Snippet \"%s\" loaded for %s." - name - (car major-mode-and-parent))))) - (message "[yas] Cannot load snippet for unknown major mode"))) - (message "Save the buffer as a file first!"))) - -(defun yas/tryout-snippet (&optional debug) - "Test current buffers's snippet template in other buffer." - (interactive "P") - (let* ((major-mode-and-parent (yas/compute-major-mode-and-parents buffer-file-name)) - (parsed (yas/parse-template)) - (test-mode (or (and (car major-mode-and-parent) - (fboundp (car major-mode-and-parent)) - (car major-mode-and-parent)) - (intern (read-from-minibuffer "[yas] please input a mode: ")))) - (template (and parsed - (fboundp test-mode) - (yas/make-template (second parsed) - (third parsed) - nil - (sixth parsed) - nil - nil)))) - (cond (template - (let ((buffer-name (format "*YAS TEST: %s*" (yas/template-name template)))) - (set-buffer (switch-to-buffer buffer-name)) - (erase-buffer) - (setq buffer-undo-list nil) - (funcall test-mode) - (yas/expand-snippet (yas/template-content template) - (point-min) - (point-max) - (yas/template-expand-env template)) - (when debug - (add-hook 'post-command-hook 'yas/debug-snippet-vars 't 'local)))) - (t - (message "[yas] Cannot test snippet for unknown major mode"))))) - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; User convenience functions, for using in snippet definitions - -(defvar yas/modified-p nil - "Non-nil if field has been modified by user or transformation.") - -(defvar yas/moving-away-p nil - "Non-nil if user is about to exit field.") - -(defvar yas/text nil - "Contains current field text.") - -(defun yas/substr (str pattern &optional subexp) - "Search PATTERN in STR and return SUBEXPth match. - -If found, the content of subexp group SUBEXP (default 0) is - returned, or else the original STR will be returned." - (let ((grp (or subexp 0))) - (save-match-data - (if (string-match pattern str) - (match-string-no-properties grp str) - str)))) - -(defun yas/choose-value (possibilities) - "Prompt for a string in the list POSSIBILITIES and return it." - (unless (or yas/moving-away-p - yas/modified-p) - (some #'(lambda (fn) - (funcall fn "Choose: " possibilities)) - yas/prompt-functions))) - -(defun yas/key-to-value (alist) - "Prompt for a string in the list POSSIBILITIES and return it." - (unless (or yas/moving-away-p - yas/modified-p) - (let ((key (read-key-sequence ""))) - (when (stringp key) - (or (cdr (find key alist :key #'car :test #'string=)) - key))))) - -(defun yas/throw (text) - "Throw a yas/exception with TEXT as the reason." - (throw 'yas/exception (cons 'yas/exception text))) - -(defun yas/verify-value (possibilities) - "Verify that the current field value is in POSSIBILITIES - -Otherwise throw exception." - (when (and yas/moving-away-p (notany #'(lambda (pos) (string= pos yas/text)) possibilities)) - (yas/throw (format "[yas] field only allows %s" possibilities)))) - -(defun yas/field-value (number) - (let* ((snippet (car (yas/snippets-at-point))) - (field (and snippet - (yas/snippet-find-field snippet number)))) - (when field - (yas/field-text-for-display field)))) - -(defun yas/default-from-field (number) - (unless yas/modified-p - (yas/field-value number))) - -(defun yas/inside-string () - (equal 'font-lock-string-face (get-char-property (1- (point)) 'face))) - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; Snippet expansion and field management - -(defvar yas/active-field-overlay nil - "Overlays the currently active field.") - -(defvar yas/field-protection-overlays nil - "Two overlays protect the current active field ") - -(defconst yas/prefix nil - "A prefix argument for expansion direct from keybindings") - -(defvar yas/deleted-text nil - "The text deleted in the last snippet expansion.") - -(defvar yas/selected-text nil - "The selected region deleted on the last snippet expansion.") - -(defvar yas/start-column nil - "The column where the snippet expansion started.") - -(make-variable-buffer-local 'yas/active-field-overlay) -(make-variable-buffer-local 'yas/field-protection-overlays) -(make-variable-buffer-local 'yas/deleted-text) - -(defstruct (yas/snippet (:constructor yas/make-snippet ())) - "A snippet. - -..." - (fields '()) - (exit nil) - (id (yas/snippet-next-id) :read-only t) - (control-overlay nil) - active-field - ;; stacked expansion: the `previous-active-field' slot saves the - ;; active field where the child expansion took place - previous-active-field - force-exit) - -(defstruct (yas/field (:constructor yas/make-field (number start end parent-field))) - "A field." - number - start end - parent-field - (mirrors '()) - (transform nil) - (modified-p nil) - next) - -(defstruct (yas/mirror (:constructor yas/make-mirror (start end transform))) - "A mirror." - start end - (transform nil) - next) - -(defstruct (yas/exit (:constructor yas/make-exit (marker))) - marker - next) - -(defun yas/apply-transform (field-or-mirror field) - "Calculate the value of the field/mirror. If there's a transform -for this field, apply it. Otherwise, returned nil." - (let* ((yas/text (yas/field-text-for-display field)) - (text yas/text) - (yas/modified-p (yas/field-modified-p field)) - (yas/moving-away-p nil) - (transform (if (yas/mirror-p field-or-mirror) - (yas/mirror-transform field-or-mirror) - (yas/field-transform field-or-mirror))) - (start-point (if (yas/mirror-p field-or-mirror) - (yas/mirror-start field-or-mirror) - (yas/field-start field-or-mirror))) - (transformed (and transform - (save-excursion - (goto-char start-point) - (yas/read-and-eval-string transform))))) - transformed)) - -(defsubst yas/replace-all (from to &optional text) - "Replace all occurance from FROM to TO. - -With optional string TEXT do it in that string." - (if text - (replace-regexp-in-string (regexp-quote from) to text t t) - (goto-char (point-min)) - (while (search-forward from nil t) - (replace-match to t t text)))) - -(defun yas/snippet-find-field (snippet number) - (find-if #'(lambda (field) - (eq number (yas/field-number field))) - (yas/snippet-fields snippet))) - -(defun yas/snippet-sort-fields (snippet) - "Sort the fields of SNIPPET in navigation order." - (setf (yas/snippet-fields snippet) - (sort (yas/snippet-fields snippet) - '(lambda (field1 field2) - (yas/snippet-field-compare field1 field2))))) - -(defun yas/snippet-field-compare (field1 field2) - "Compare two fields. The field with a number is sorted first. -If they both have a number, compare through the number. If neither -have, compare through the field's start point" - (let ((n1 (yas/field-number field1)) - (n2 (yas/field-number field2))) - (if n1 - (if n2 - (< n1 n2) - t) - (if n2 - nil - (< (yas/field-start field1) - (yas/field-start field2)))))) - -(defun yas/field-probably-deleted-p (snippet field) - "Guess if SNIPPET's FIELD should be skipped." - (and (zerop (- (yas/field-start field) (yas/field-end field))) - (or (yas/field-parent-field field) - (and (eq field (car (last (yas/snippet-fields snippet)))) - (= (yas/field-start field) (overlay-end (yas/snippet-control-overlay snippet))))))) - -(defun yas/snippets-at-point (&optional all-snippets) - "Return a sorted list of snippets at point, most recently -inserted first." - (sort - (remove nil (remove-duplicates (mapcar #'(lambda (ov) - (overlay-get ov 'yas/snippet)) - (if all-snippets - (overlays-in (point-min) (point-max)) - (overlays-at (point)))))) - #'(lambda (s1 s2) - (<= (yas/snippet-id s2) (yas/snippet-id s1))))) - -(defun yas/next-field-or-maybe-expand () - "Try to expand a snippet at a key before point, otherwise -delegate to `yas/next-field'." - (interactive) - (if yas/triggers-in-field - (let ((yas/fallback-behavior 'return-nil) - (active-field (overlay-get yas/active-field-overlay 'yas/field))) - (when active-field - (unless (yas/expand-1 active-field) - (yas/next-field)))) - (yas/next-field))) - -(defun yas/next-field (&optional arg) - "Navigate to next field. If there's none, exit the snippet." - (interactive) - (let* ((arg (or arg - 1)) - (snippet (first (yas/snippets-at-point))) - (active-field (overlay-get yas/active-field-overlay 'yas/field)) - (live-fields (remove-if #'(lambda (field) - (and (not (eq field active-field)) - (yas/field-probably-deleted-p snippet field))) - (yas/snippet-fields snippet))) - (active-field-pos (position active-field live-fields)) - (target-pos (and active-field-pos (+ arg active-field-pos))) - (target-field (nth target-pos live-fields))) - ;; First check if we're moving out of a field with a transform - ;; - (when (and active-field - (yas/field-transform active-field)) - (let* ((yas/moving-away-p t) - (yas/text (yas/field-text-for-display active-field)) - (text yas/text) - (yas/modified-p (yas/field-modified-p active-field))) - ;; primary field transform: exit call to field-transform - (yas/read-and-eval-string (yas/field-transform active-field)))) - ;; Now actually move... - (cond ((>= target-pos (length live-fields)) - (yas/exit-snippet snippet)) - (target-field - (yas/move-to-field snippet target-field)) - (t - nil)))) - -(defun yas/place-overlays (snippet field) - "Correctly place overlays for SNIPPET's FIELD" - (yas/make-move-field-protection-overlays snippet field) - (yas/make-move-active-field-overlay snippet field)) - -(defun yas/move-to-field (snippet field) - "Update SNIPPET to move to field FIELD. - -Also create some protection overlays" - (goto-char (yas/field-start field)) - (setf (yas/snippet-active-field snippet) field) - (yas/place-overlays snippet field) - (overlay-put yas/active-field-overlay 'yas/field field) - ;; primary field transform: first call to snippet transform - (unless (yas/field-modified-p field) - (if (yas/field-update-display field snippet) - (let ((inhibit-modification-hooks t)) - (yas/update-mirrors snippet)) - (setf (yas/field-modified-p field) nil)))) - -(defun yas/prev-field () - "Navigate to prev field. If there's none, exit the snippet." - (interactive) - (yas/next-field -1)) - -(defun yas/abort-snippet (&optional snippet) - (interactive) - (let ((snippet (or snippet - (car (yas/snippets-at-point))))) - (when snippet - (setf (yas/snippet-force-exit snippet) t)))) - -(defun yas/exit-snippet (snippet) - "Goto exit-marker of SNIPPET." - (interactive) - (setf (yas/snippet-force-exit snippet) t) - (goto-char (if (yas/snippet-exit snippet) - (yas/exit-marker (yas/snippet-exit snippet)) - (overlay-end (yas/snippet-control-overlay snippet))))) - -(defun yas/exit-all-snippets () - "Exit all snippets." - (interactive) - (mapc #'(lambda (snippet) - (yas/exit-snippet snippet) - (yas/check-commit-snippet)) - (yas/snippets-at-point))) - - -;;; Apropos markers-to-points: -;;; -;;; This was found useful for performance reasons, so that an -;;; excessive number of live markers aren't kept around in the -;;; `buffer-undo-list'. However, in `markers-to-points', the -;;; set-to-nil markers can't simply be discarded and replaced with -;;; fresh ones in `points-to-markers'. The original marker that was -;;; just set to nil has to be reused. -;;; -;;; This shouldn't bring horrible problems with undo/redo, but it -;;; you never know -;;; - -(defun yas/markers-to-points (snippet) - "Convert all markers in SNIPPET to a cons (POINT . MARKER) -where POINT is the original position of the marker and MARKER is -the original marker object with the position set to nil." - (dolist (field (yas/snippet-fields snippet)) - (let ((start (marker-position (yas/field-start field))) - (end (marker-position (yas/field-end field)))) - (set-marker (yas/field-start field) nil) - (set-marker (yas/field-end field) nil) - (setf (yas/field-start field) (cons start (yas/field-start field))) - (setf (yas/field-end field) (cons end (yas/field-end field)))) - (dolist (mirror (yas/field-mirrors field)) - (let ((start (marker-position (yas/mirror-start mirror))) - (end (marker-position (yas/mirror-end mirror)))) - (set-marker (yas/mirror-start mirror) nil) - (set-marker (yas/mirror-end mirror) nil) - (setf (yas/mirror-start mirror) (cons start (yas/mirror-start mirror))) - (setf (yas/mirror-end mirror) (cons end (yas/mirror-end mirror)))))) - (let ((snippet-exit (yas/snippet-exit snippet))) - (when snippet-exit - (let ((exit (marker-position (yas/exit-marker snippet-exit)))) - (set-marker (yas/exit-marker snippet-exit) nil) - (setf (yas/exit-marker snippet-exit) (cons exit (yas/exit-marker snippet-exit))))))) - -(defun yas/points-to-markers (snippet) - "Convert all cons (POINT . MARKER) in SNIPPET to markers. This -is done by setting MARKER to POINT with `set-marker'." - (dolist (field (yas/snippet-fields snippet)) - (setf (yas/field-start field) (set-marker (cdr (yas/field-start field)) - (car (yas/field-start field)))) - (setf (yas/field-end field) (set-marker (cdr (yas/field-end field)) - (car (yas/field-end field)))) - (dolist (mirror (yas/field-mirrors field)) - (setf (yas/mirror-start mirror) (set-marker (cdr (yas/mirror-start mirror)) - (car (yas/mirror-start mirror)))) - (setf (yas/mirror-end mirror) (set-marker (cdr (yas/mirror-end mirror)) - (car (yas/mirror-end mirror)))))) - (let ((snippet-exit (yas/snippet-exit snippet))) - (when snippet-exit - (setf (yas/exit-marker snippet-exit) (set-marker (cdr (yas/exit-marker snippet-exit)) - (car (yas/exit-marker snippet-exit))))))) - -(defun yas/commit-snippet (snippet &optional no-hooks) - "Commit SNIPPET, but leave point as it is. This renders the -snippet as ordinary text. - -Return a buffer position where the point should be placed if -exiting the snippet. - -NO-HOOKS means don't run the `yas/after-exit-snippet-hook' hooks." - - (let ((control-overlay (yas/snippet-control-overlay snippet)) - yas/snippet-beg - yas/snippet-end) - ;; - ;; Save the end of the moribund snippet in case we need to revive it - ;; its original expansion. - ;; - (when (and control-overlay - (overlay-buffer control-overlay)) - (setq yas/snippet-beg (overlay-start control-overlay)) - (setq yas/snippet-end (overlay-end control-overlay)) - (delete-overlay control-overlay)) - - (let ((inhibit-modification-hooks t)) - (when yas/active-field-overlay - (delete-overlay yas/active-field-overlay)) - (when yas/field-protection-overlays - (mapc #'delete-overlay yas/field-protection-overlays))) - - ;; stacked expansion: if the original expansion took place from a - ;; field, make sure we advance it here at least to - ;; `yas/snippet-end'... - ;; - (let ((previous-field (yas/snippet-previous-active-field snippet))) - (when (and yas/snippet-end previous-field) - (yas/advance-end-maybe previous-field yas/snippet-end))) - - ;; Convert all markers to points, - ;; - (yas/markers-to-points snippet) - - ;; Take care of snippet revival - ;; - (if yas/snippet-revival - (push `(apply yas/snippet-revive ,yas/snippet-beg ,yas/snippet-end ,snippet) - buffer-undo-list) - ;; Dismember the snippet... this is useful if we get called - ;; again from `yas/take-care-of-redo'.... - (setf (yas/snippet-fields snippet) nil)) - - ;; XXX: `yas/after-exit-snippet-hook' should be run with - ;; `yas/snippet-beg' and `yas/snippet-end' bound. That might not - ;; be the case if the main overlay had somehow already - ;; disappeared, which sometimes happens when the snippet's messed - ;; up... - ;; - (unless no-hooks (run-hooks 'yas/after-exit-snippet-hook))) - - (message "[yas] snippet exited.")) - -(defun yas/check-commit-snippet () - "Checks if point exited the currently active field of the -snippet, if so cleans up the whole snippet up." - (let* ((snippets (yas/snippets-at-point 'all-snippets)) - (snippets-left snippets)) - (dolist (snippet snippets) - (let ((active-field (yas/snippet-active-field snippet))) - (cond ((or (prog1 (yas/snippet-force-exit snippet) - (setf (yas/snippet-force-exit snippet) nil)) - (not (and active-field (yas/field-contains-point-p active-field)))) - (setq snippets-left (delete snippet snippets-left)) - (yas/commit-snippet snippet snippets-left)) - ((and active-field - (or (not yas/active-field-overlay) - (not (overlay-buffer yas/active-field-overlay)))) - ;; - ;; stacked expansion: this case is mainly for recent - ;; snippet exits that place us back int the field of - ;; another snippet - ;; - (save-excursion - (yas/move-to-field snippet active-field) - (yas/update-mirrors snippet))) - (t - nil)))) - (unless snippets-left - (remove-hook 'post-command-hook 'yas/post-command-handler 'local) - (remove-hook 'pre-command-hook 'yas/pre-command-handler 'local)))) - -(defun yas/field-contains-point-p (field &optional point) - (let ((point (or point - (point)))) - (and (>= point (yas/field-start field)) - (<= point (yas/field-end field))))) - -(defun yas/field-text-for-display (field) - "Return the propertized display text for field FIELD. " - (buffer-substring (yas/field-start field) (yas/field-end field))) - -(defun yas/undo-in-progress () - "True if some kind of undo is in progress" - (or undo-in-progress - (eq this-command 'undo) - (eq this-command 'redo))) - -(defun yas/make-control-overlay (snippet start end) - "Creates the control overlay that surrounds the snippet and -holds the keymap." - (let ((overlay (make-overlay start - end - nil - nil - t))) - (overlay-put overlay 'keymap yas/keymap) - (overlay-put overlay 'yas/snippet snippet) - overlay)) - -(defun yas/skip-and-clear-or-delete-char (&optional field) - "Clears unmodified field if at field start, skips to next tab. - -Otherwise deletes a character normally by calling `delete-char'." - (interactive) - (let ((field (or field - (and yas/active-field-overlay - (overlay-buffer yas/active-field-overlay) - (overlay-get yas/active-field-overlay 'yas/field))))) - (cond ((and field - (not (yas/field-modified-p field)) - (eq (point) (marker-position (yas/field-start field)))) - (yas/skip-and-clear field) - (yas/next-field 1)) - (t - (call-interactively 'delete-char))))) - -(defun yas/skip-and-clear (field) - "Deletes the region of FIELD and sets it modified state to t" - (setf (yas/field-modified-p field) t) - (delete-region (yas/field-start field) (yas/field-end field))) - -(defun yas/make-move-active-field-overlay (snippet field) - "Place the active field overlay in SNIPPET's FIELD. - -Move the overlay, or create it if it does not exit." - (if (and yas/active-field-overlay - (overlay-buffer yas/active-field-overlay)) - (move-overlay yas/active-field-overlay - (yas/field-start field) - (yas/field-end field)) - (setq yas/active-field-overlay - (make-overlay (yas/field-start field) - (yas/field-end field) - nil nil t)) - (overlay-put yas/active-field-overlay 'priority 100) - (overlay-put yas/active-field-overlay 'face 'yas/field-highlight-face) - (overlay-put yas/active-field-overlay 'yas/snippet snippet) - (overlay-put yas/active-field-overlay 'modification-hooks '(yas/on-field-overlay-modification)) - (overlay-put yas/active-field-overlay 'insert-in-front-hooks - '(yas/on-field-overlay-modification)) - (overlay-put yas/active-field-overlay 'insert-behind-hooks - '(yas/on-field-overlay-modification)))) - -(defun yas/on-field-overlay-modification (overlay after? beg end &optional length) - "Clears the field and updates mirrors, conditionally. - -Only clears the field if it hasn't been modified and it point it -at field start. This hook doesn't do anything if an undo is in -progress." - (unless (yas/undo-in-progress) - (let ((field (overlay-get yas/active-field-overlay 'yas/field))) - (cond (after? - (yas/advance-end-maybe field (overlay-end overlay)) -;;; primary field transform: normal calls to expression - (let ((saved-point (point))) - (yas/field-update-display field (car (yas/snippets-at-point))) - (goto-char saved-point)) - (yas/update-mirrors (car (yas/snippets-at-point)))) - (field - (when (and (not after?) - (not (yas/field-modified-p field)) - (eq (point) (if (markerp (yas/field-start field)) - (marker-position (yas/field-start field)) - (yas/field-start field)))) - (yas/skip-and-clear field)) - (setf (yas/field-modified-p field) t)))))) - -;;; Apropos protection overlays: -;;; -;;; These exist for nasty users who will try to delete parts of the -;;; snippet outside the active field. Actual protection happens in -;;; `yas/on-protection-overlay-modification'. -;;; -;;; Currently this signals an error which inhibits the command. For -;;; commands that move point (like `kill-line'), point is restored in -;;; the `yas/post-command-handler' using a global -;;; `yas/protection-violation' variable. -;;; -;;; Alternatively, I've experimented with an implementation that -;;; commits the snippet before actually calling `this-command' -;;; interactively, and then signals an eror, which is ignored. but -;;; blocks all other million modification hooks. This presented some -;;; problems with stacked expansion. -;;; - -(defun yas/make-move-field-protection-overlays (snippet field) - "Place protection overlays surrounding SNIPPET's FIELD. - -Move the overlays, or create them if they do not exit." - (let ((start (yas/field-start field)) - (end (yas/field-end field))) - ;; First check if the (1+ end) is contained in the buffer, - ;; otherwise we'll have to do a bit of cheating and silently - ;; insert a newline. the `(1+ (buffer-size))' should prevent this - ;; when using stacked expansion - ;; - (when (< (buffer-size) end) - (save-excursion - (let ((inhibit-modification-hooks t)) - (goto-char (point-max)) - (newline)))) - ;; go on to normal overlay creation/moving - ;; - (cond ((and yas/field-protection-overlays - (every #'overlay-buffer yas/field-protection-overlays)) - (move-overlay (first yas/field-protection-overlays) (1- start) start) - (move-overlay (second yas/field-protection-overlays) end (1+ end))) - (t - (setq yas/field-protection-overlays - (list (make-overlay (1- start) start nil t nil) - (make-overlay end (1+ end) nil t nil))) - (dolist (ov yas/field-protection-overlays) - (overlay-put ov 'face 'yas/field-debug-face) - (overlay-put ov 'yas/snippet snippet) - ;; (overlay-put ov 'evaporate t) - (overlay-put ov 'modification-hooks '(yas/on-protection-overlay-modification))))))) - -(defvar yas/protection-violation nil - "When non-nil, signals attempts to erronesly exit or modify the snippet. - -Functions in the `post-command-hook', for example -`yas/post-command-handler' can check it and reset its value to -nil. The variables value is the point where the violation -originated") - -(defun yas/on-protection-overlay-modification (overlay after? beg end &optional length) - "Signals a snippet violation, then issues error. - -The error should be ignored in `debug-ignored-errors'" - (cond ((not (or after? - (yas/undo-in-progress))) - (setq yas/protection-violation (point)) - (error "Exit the snippet first!")))) - -(add-to-list 'debug-ignored-errors "^Exit the snippet first!$") - - -;;; Apropos stacked expansion: -;;; -;;; the parent snippet does not run its fields modification hooks -;;; (`yas/on-field-overlay-modification' and -;;; `yas/on-protection-overlay-modification') while the child snippet -;;; is active. This means, among other things, that the mirrors of the -;;; parent snippet are not updated, this only happening when one exits -;;; the child snippet. -;;; -;;; Unfortunately, this also puts some ugly (and not fully-tested) -;;; bits of code in `yas/expand-snippet' and -;;; `yas/commit-snippet'. I've tried to mark them with "stacked -;;; expansion:". -;;; -;;; This was thought to be safer in in an undo/redo perpective, but -;;; maybe the correct implementation is to make the globals -;;; `yas/active-field-overlay' and `yas/field-protection-overlays' be -;;; snippet-local and be active even while the child snippet is -;;; running. This would mean a lot of overlay modification hooks -;;; running, but if managed correctly (including overlay priorities) -;;; they should account for all situations... -;;; - -(defun yas/expand-snippet (template &optional start end expand-env) - "Expand snippet at current point. Text between START and END -will be deleted before inserting template." - (run-hooks 'yas/before-expand-snippet-hook) - - ;; If a region is active, set `yas/selected-text' - (setq yas/selected-text - (when mark-active - (prog1 (buffer-substring-no-properties (region-beginning) - (region-end)) - (unless start (setq start (region-beginning)) - (unless end (setq end (region-end))))))) - - (when start - (goto-char start)) - - ;; stacked expansion: shoosh the overlay modification hooks - ;; - (let ((to-delete (and start end (buffer-substring-no-properties start end))) - (start (or start (point))) - (end (or end (point))) - (inhibit-modification-hooks t) - (column (current-column)) - snippet) - - ;; Delete the region to delete, this *does* get undo-recorded. - ;; - (when (and to-delete - (> end start)) - (delete-region start end) - (setq yas/deleted-text to-delete)) - - ;; Narrow the region down to the template, shoosh the - ;; `buffer-undo-list', and create the snippet, the new snippet - ;; updates its mirrors once, so we are left with some plain text. - ;; The undo action for deleting this plain text will get recorded - ;; at the end of this function. - (save-restriction - (narrow-to-region start start) - (let ((buffer-undo-list t)) - ;; snippet creation might evaluate users elisp, which - ;; might generate errors, so we have to be ready to catch - ;; them mostly to make the undo information - ;; - (setq yas/start-column (save-restriction (widen) (current-column))) - (insert template) - - (setq snippet - (if expand-env - (let ((read-vars (condition-case err - (read expand-env) - (error nil)))) - (eval `(let ,read-vars - (yas/snippet-create (point-min) (point-max))))) - (yas/snippet-create (point-min) (point-max)))))) - - ;; stacked-expansion: This checks for stacked expansion, save the - ;; `yas/previous-active-field' and advance its boudary. - ;; - (let ((existing-field (and yas/active-field-overlay - (overlay-buffer yas/active-field-overlay) - (overlay-get yas/active-field-overlay 'yas/field)))) - (when existing-field - (setf (yas/snippet-previous-active-field snippet) existing-field) - (yas/advance-end-maybe existing-field (overlay-end yas/active-field-overlay)))) - - ;; Exit the snippet immediately if no fields - ;; - (unless (yas/snippet-fields snippet) - (yas/exit-snippet snippet)) - - ;; Push two undo actions: the deletion of the inserted contents of - ;; the new snippet (without the "key") followed by an apply of - ;; `yas/take-care-of-redo' on the newly inserted snippet boundaries - ;; - (let ((start (overlay-start (yas/snippet-control-overlay snippet))) - (end (overlay-end (yas/snippet-control-overlay snippet)))) - (push (cons start end) buffer-undo-list) - (push `(apply yas/take-care-of-redo ,start ,end ,snippet) - buffer-undo-list)) - ;; Now, move to the first field - ;; - (let ((first-field (car (yas/snippet-fields snippet)))) - (when first-field - (yas/move-to-field snippet first-field)))) - (message "[yas] snippet expanded.")) - -(defun yas/take-care-of-redo (beg end snippet) - "Commits SNIPPET, which in turn pushes an undo action for -reviving it. - -Meant to exit in the `buffer-undo-list'." - ;; slightly optimize: this action is only needed for snippets with - ;; at least one field - (when (yas/snippet-fields snippet) - (yas/commit-snippet snippet 'no-hooks))) - -(defun yas/snippet-revive (beg end snippet) - "Revives the SNIPPET and creates a control overlay from BEG to -END. - -BEG and END are, we hope, the original snippets boudaries. All -the markers/points exiting existing inside SNIPPET should point -to their correct locations *at the time the snippet is revived*. - -After revival, push the `yas/take-care-of-redo' in the -`buffer-undo-list'" - ;; Reconvert all the points to markers - ;; - (yas/points-to-markers snippet) - ;; When at least one editable field existed in the zombie snippet, - ;; try to revive the whole thing... - ;; - (let ((target-field (or (yas/snippet-active-field snippet) - (car (yas/snippet-fields snippet))))) - (when target-field - (setf (yas/snippet-control-overlay snippet) (yas/make-control-overlay snippet beg end)) - (overlay-put (yas/snippet-control-overlay snippet) 'yas/snippet snippet) - - (yas/move-to-field snippet target-field) - - (add-hook 'post-command-hook 'yas/post-command-handler nil t) - (add-hook 'pre-command-hook 'yas/pre-command-handler t t) - - (push `(apply yas/take-care-of-redo ,beg ,end ,snippet) - buffer-undo-list)))) - -(defun yas/snippet-create (begin end) - "Creates a snippet from an template inserted between BEGIN and END. - -Returns the newly created snippet." - (let ((snippet (yas/make-snippet))) - (goto-char begin) - (yas/snippet-parse-create snippet) - - ;; Sort and link each field - (yas/snippet-sort-fields snippet) - - ;; Create keymap overlay for snippet - (setf (yas/snippet-control-overlay snippet) - (yas/make-control-overlay snippet (point-min) (point-max))) - - ;; Move to end - (goto-char (point-max)) - - ;; Setup hooks - (add-hook 'post-command-hook 'yas/post-command-handler nil t) - (add-hook 'pre-command-hook 'yas/pre-command-handler t t) - - snippet)) - - -;;; Apropos adjacencies: Once the $-constructs bits like "$n" and -;;; "${:n" are deleted in the recently expanded snippet, we might -;;; actually have many fields, mirrors (and the snippet exit) in the -;;; very same position in the buffer. Therefore we need to single-link -;;; the fields-or-mirrors-or-exit, which I have called "fom", -;;; according to their original positions in the buffer. -;;; -;;; Then we have operation `yas/advance-end-maybe' and -;;; `yas/advance-start-maybe', which conditionally push the starts and -;;; ends of these foms down the chain. -;;; -;;; This allows for like the printf with the magic ",": -;;; -;;; printf ("${1:%s}\\n"${1:$(if (string-match "%" text) "," "\);")} \ -;;; $2${1:$(if (string-match "%" text) "\);" "")}$0 -;;; - -(defun yas/fom-start (fom) - (cond ((yas/field-p fom) - (yas/field-start fom)) - ((yas/mirror-p fom) - (yas/mirror-start fom)) - (t - (yas/exit-marker fom)))) - -(defun yas/fom-end (fom) - (cond ((yas/field-p fom) - (yas/field-end fom)) - ((yas/mirror-p fom) - (yas/mirror-end fom)) - (t - (yas/exit-marker fom)))) - -(defun yas/fom-next (fom) - (cond ((yas/field-p fom) - (yas/field-next fom)) - ((yas/mirror-p fom) - (yas/mirror-next fom)) - (t - (yas/exit-next fom)))) - -(defun yas/calculate-adjacencies (snippet) - "Calculate adjacencies for fields or mirrors of SNIPPET. - -This is according to their relative positions in the buffer, and -has to be called before the $-constructs are deleted." - (flet ((yas/fom-set-next-fom (fom nextfom) - (cond ((yas/field-p fom) - (setf (yas/field-next fom) nextfom)) - ((yas/mirror-p fom) - (setf (yas/mirror-next fom) nextfom)) - (t - (setf (yas/exit-next fom) nextfom)))) - (yas/compare-fom-begs (fom1 fom2) - (> (yas/fom-start fom2) (yas/fom-start fom1))) - (yas/link-foms (fom1 fom2) - (yas/fom-set-next-fom fom1 fom2))) - ;; make some yas/field, yas/mirror and yas/exit soup - (let ((soup)) - (when (yas/snippet-exit snippet) - (push (yas/snippet-exit snippet) soup)) - (dolist (field (yas/snippet-fields snippet)) - (push field soup) - (dolist (mirror (yas/field-mirrors field)) - (push mirror soup))) - (setq soup - (sort soup - #'yas/compare-fom-begs)) - (when soup - (reduce #'yas/link-foms soup))))) - -(defun yas/advance-end-maybe (fom newend) - "Maybe advance FOM's end to NEWEND if it needs it. - -If it does, also: - -* call `yas/advance-start-maybe' on FOM's next fom. - -* in case FOM is field call `yas/advance-end-maybe' on its parent - field" - (when (and fom (< (yas/fom-end fom) newend)) - (set-marker (yas/fom-end fom) newend) - (yas/advance-start-maybe (yas/fom-next fom) newend) - (if (and (yas/field-p fom) - (yas/field-parent-field fom)) - (yas/advance-end-maybe (yas/field-parent-field fom) newend)))) - -(defun yas/advance-start-maybe (fom newstart) - "Maybe advance FOM's start to NEWSTART if it needs it. - -If it does, also call `yas/advance-end-maybe' on FOM." - (when (and fom (< (yas/fom-start fom) newstart)) - (set-marker (yas/fom-start fom) newstart) - (yas/advance-end-maybe fom newstart))) - -(defvar yas/dollar-regions nil - "When expanding the snippet the \"parse-create\" functions add - cons cells to this var") - -(defun yas/snippet-parse-create (snippet) - "Parse a recently inserted snippet template, creating all -necessary fields, mirrors and exit points. - -Meant to be called in a narrowed buffer, does various passes" - (let ((parse-start (point))) - ;; Reset the yas/dollar-regions - ;; - (setq yas/dollar-regions nil) - ;; protect escaped quote, backquotes and backslashes - ;; - (yas/protect-escapes nil '(?\\ ?` ?')) - ;; replace all backquoted expressions - ;; - (goto-char parse-start) - (yas/replace-backquotes) - ;; protect escapes again since previous steps might have generated - ;; more characters needing escaping - ;; - (goto-char parse-start) - (yas/protect-escapes) - ;; parse fields with {} - ;; - (goto-char parse-start) - (yas/field-parse-create snippet) - ;; parse simple mirrors and fields - ;; - (goto-char parse-start) - (yas/simple-mirror-parse-create snippet) - ;; parse mirror transforms - ;; - (goto-char parse-start) - (yas/transform-mirror-parse-create snippet) - ;; calculate adjacencies of fields and mirrors - ;; - (yas/calculate-adjacencies snippet) - ;; Delete $-constructs - ;; - (yas/delete-regions yas/dollar-regions) - ;; restore escapes - ;; - (goto-char parse-start) - (yas/restore-escapes) - ;; update mirrors for the first time - ;; - (yas/update-mirrors snippet) - ;; indent the best we can - ;; - (goto-char parse-start) - (yas/indent snippet))) - -(defun yas/indent-according-to-mode (snippet-markers) - "Indent current line according to mode, preserving -SNIPPET-MARKERS." - ;; XXX: Here seems to be the indent problem: - ;; - ;; `indent-according-to-mode' uses whatever - ;; `indent-line-function' is available. Some - ;; implementations of these functions delete text - ;; before they insert. If there happens to be a marker - ;; just after the text being deleted, the insertion - ;; actually happens after the marker, which misplaces - ;; it. - ;; - ;; This would also happen if we had used overlays with - ;; the `front-advance' property set to nil. - ;; - ;; This is why I have these `trouble-markers', they are the ones at - ;; they are the ones at the first non-whitespace char at the line - ;; (i.e. at `yas/real-line-beginning'. After indentation takes place - ;; we should be at the correct to restore them to. All other - ;; non-trouble-markers have been *pushed* and don't need special - ;; attention. - ;; - (goto-char (yas/real-line-beginning)) - (let ((trouble-markers (remove-if-not #'(lambda (marker) - (= marker (point))) - snippet-markers))) - (save-restriction - (widen) - (condition-case err - (indent-according-to-mode) - (error (message "[yas] warning: yas/indent-according-to-mode habing problems running %s" indent-line-function) - nil))) - (mapc #'(lambda (marker) - (set-marker marker (point))) - trouble-markers))) - -(defun yas/indent (snippet) - (let ((snippet-markers (yas/collect-snippet-markers snippet))) - ;; Look for those $> - (save-excursion - (while (re-search-forward "$>" nil t) - (delete-region (match-beginning 0) (match-end 0)) - (when (not (eq yas/indent-line 'auto)) - (yas/indent-according-to-mode snippet-markers)))) - ;; Now do stuff for 'fixed and 'auto - (save-excursion - (cond ((eq yas/indent-line 'fixed) - (while (and (zerop (forward-line)) - (zerop (current-column))) - (indent-to-column column))) - ((eq yas/indent-line 'auto) - (let ((end (set-marker (make-marker) (point-max))) - (indent-first-line-p yas/also-auto-indent-first-line)) - (while (and (zerop (if indent-first-line-p - (prog1 - (forward-line 0) - (setq indent-first-line-p nil)) - (forward-line 1))) - (not (eobp)) - (<= (point) end)) - (yas/indent-according-to-mode snippet-markers)))) - (t - nil))))) - -(defun yas/collect-snippet-markers (snippet) - "Make a list of all the markers used by SNIPPET." - (let (markers) - (dolist (field (yas/snippet-fields snippet)) - (push (yas/field-start field) markers) - (push (yas/field-end field) markers) - (dolist (mirror (yas/field-mirrors field)) - (push (yas/mirror-start mirror) markers) - (push (yas/mirror-end mirror) markers))) - (let ((snippet-exit (yas/snippet-exit snippet))) - (when (and snippet-exit - (marker-buffer (yas/exit-marker snippet-exit))) - (push (yas/exit-marker snippet-exit) markers))) - markers)) - -(defun yas/real-line-beginning () - (let ((c (char-after (line-beginning-position))) - (n (line-beginning-position))) - (while (or (eql c ?\ ) - (eql c ?\t)) - (incf n) - (setq c (char-after n))) - n)) - -(defun yas/escape-string (escaped) - (concat "YASESCAPE" (format "%d" escaped) "PROTECTGUARD")) - -(defun yas/protect-escapes (&optional text escaped) - "Protect all escaped characters with their numeric ASCII value. - -With optional string TEXT do it in string instead of buffer." - (let ((changed-text text) - (text-provided-p text)) - (mapc #'(lambda (escaped) - (setq changed-text - (yas/replace-all (concat "\\" (char-to-string escaped)) - (yas/escape-string escaped) - (when text-provided-p changed-text)))) - (or escaped yas/escaped-characters)) - changed-text)) - -(defun yas/restore-escapes (&optional text escaped) - "Restore all escaped characters from their numeric ASCII value. - -With optional string TEXT do it in string instead of the buffer." - (let ((changed-text text) - (text-provided-p text)) - (mapc #'(lambda (escaped) - (setq changed-text - (yas/replace-all (yas/escape-string escaped) - (char-to-string escaped) - (when text-provided-p changed-text)))) - (or escaped yas/escaped-characters)) - changed-text)) - -(defun yas/replace-backquotes () - "Replace all the \"`(lisp-expression)`\"-style expression - with their evaluated value" - (while (re-search-forward yas/backquote-lisp-expression-regexp nil t) - (let ((transformed (yas/read-and-eval-string (yas/restore-escapes (match-string 1))))) - (goto-char (match-end 0)) - (when transformed (insert transformed)) - (delete-region (match-beginning 0) (match-end 0))))) - -(defun yas/scan-sexps (from count) - (condition-case err - (with-syntax-table (standard-syntax-table) - (scan-sexps from count)) - (error - nil))) - -(defun yas/make-marker (pos) - "Create a marker at POS with `nil' `marker-insertion-type'" - (let ((marker (set-marker (make-marker) pos))) - (set-marker-insertion-type marker nil) - marker)) - -(defun yas/field-parse-create (snippet &optional parent-field) - "Parse most field expressions, except for the simple one \"$n\". - -The following count as a field: - -* \"${n: text}\", for a numbered field with default text, as long as N is not 0; - -* \"${n: text$(expression)}, the same with a lisp expression; - this is caught with the curiously named `yas/multi-dollar-lisp-expression-regexp' - -* the same as above but unnumbered, (no N:) and number is calculated automatically. - -When multiple expressions are found, only the last one counts." - ;; - (save-excursion - (while (re-search-forward yas/field-regexp nil t) - (let* ((real-match-end-0 (yas/scan-sexps (1+ (match-beginning 0)) 1)) - (number (and (match-string-no-properties 1) - (string-to-number (match-string-no-properties 1)))) - (brand-new-field (and real-match-end-0 - ;; break if on "$(" immediately - ;; after the ":", this will be - ;; caught as a mirror with - ;; transform later. - (not (save-match-data - (eq (string-match "$[ \t\n]*(" - (match-string-no-properties 2)) 0))) - (not (and number (zerop number))) - (yas/make-field number - (yas/make-marker (match-beginning 2)) - (yas/make-marker (1- real-match-end-0)) - parent-field)))) - (when brand-new-field - (goto-char real-match-end-0) - (push (cons (1- real-match-end-0) real-match-end-0) - yas/dollar-regions) - (push (cons (match-beginning 0) (match-beginning 2)) - yas/dollar-regions) - (push brand-new-field (yas/snippet-fields snippet)) - (save-excursion - (save-restriction - (narrow-to-region (yas/field-start brand-new-field) (yas/field-end brand-new-field)) - (goto-char (point-min)) - (yas/field-parse-create snippet brand-new-field))))))) - ;; if we entered from a parent field, now search for the - ;; `yas/multi-dollar-lisp-expression-regexp'. THis is used for - ;; primary field transformations - ;; - (when parent-field - (save-excursion - (while (re-search-forward yas/multi-dollar-lisp-expression-regexp nil t) - (let* ((real-match-end-1 (yas/scan-sexps (match-beginning 1) 1))) - ;; commit the primary field transformation if we don't find - ;; it in yas/dollar-regions (a subnested field) might have - ;; already caught it. - (when (and real-match-end-1 - (not (member (cons (match-beginning 0) - real-match-end-1) - yas/dollar-regions))) - (let ((lisp-expression-string (buffer-substring-no-properties (match-beginning 1) - real-match-end-1))) - (setf (yas/field-transform parent-field) (yas/restore-escapes lisp-expression-string))) - (push (cons (match-beginning 0) real-match-end-1) - yas/dollar-regions))))))) - -(defun yas/transform-mirror-parse-create (snippet) - "Parse the \"${n:$(lisp-expression)}\" mirror transformations." - (while (re-search-forward yas/transform-mirror-regexp nil t) - (let* ((real-match-end-0 (yas/scan-sexps (1+ (match-beginning 0)) 1)) - (number (string-to-number (match-string-no-properties 1))) - (field (and number - (not (zerop number)) - (yas/snippet-find-field snippet number)))) - (when (and real-match-end-0 - field) - (push (yas/make-mirror (yas/make-marker (match-beginning 0)) - (yas/make-marker (match-beginning 0)) - (yas/restore-escapes - (buffer-substring-no-properties (match-beginning 2) - (1- real-match-end-0)))) - (yas/field-mirrors field)) - (push (cons (match-beginning 0) real-match-end-0) yas/dollar-regions))))) - -(defun yas/simple-mirror-parse-create (snippet) - "Parse the simple \"$n\" mirrors and the exit-marker." - (while (re-search-forward yas/simple-mirror-regexp nil t) - (let ((number (string-to-number (match-string-no-properties 1)))) - (cond ((zerop number) - - (setf (yas/snippet-exit snippet) - (yas/make-exit (yas/make-marker (match-end 0)))) - (save-excursion - (goto-char (match-beginning 0)) - (when yas/wrap-around-region - (cond (yas/selected-text - (insert yas/selected-text)) - ((and (eq yas/wrap-around-region 'cua) - cua-mode - (get-register ?0)) - (insert (prog1 (get-register ?0) - (set-register ?0 nil)))))) - (push (cons (point) (yas/exit-marker (yas/snippet-exit snippet))) - yas/dollar-regions))) - (t - (let ((field (yas/snippet-find-field snippet number))) - (if field - (push (yas/make-mirror (yas/make-marker (match-beginning 0)) - (yas/make-marker (match-beginning 0)) - nil) - (yas/field-mirrors field)) - (push (yas/make-field number - (yas/make-marker (match-beginning 0)) - (yas/make-marker (match-beginning 0)) - nil) - (yas/snippet-fields snippet)))) - (push (cons (match-beginning 0) (match-end 0)) - yas/dollar-regions)))))) - -(defun yas/delete-regions (regions) - "Sort disjuct REGIONS by start point, then delete from the back." - (mapc #'(lambda (reg) - (delete-region (car reg) (cdr reg))) - (sort regions - #'(lambda (r1 r2) - (>= (car r1) (car r2)))))) - -(defun yas/update-mirrors (snippet) - "Updates all the mirrors of SNIPPET." - (save-excursion - (dolist (field (yas/snippet-fields snippet)) - (dolist (mirror (yas/field-mirrors field)) - ;; stacked expansion: I added an `inhibit-modification-hooks' - ;; here, for safety, may need to remove if we the mechanism is - ;; altered. - ;; - (let ((inhibit-modification-hooks t)) - (yas/mirror-update-display mirror field) - ;; `yas/place-overlays' is needed if the active field and - ;; protected overlays have been changed because of insertions - ;; in `yas/mirror-update-display' - ;; - (when (eq field (yas/snippet-active-field snippet)) - (yas/place-overlays snippet field))))))) - -(defun yas/mirror-update-display (mirror field) - "Update MIRROR according to FIELD (and mirror transform)." - (let ((reflection (or (yas/apply-transform mirror field) - (yas/field-text-for-display field)))) - (when (and reflection - (not (string= reflection (buffer-substring-no-properties (yas/mirror-start mirror) - (yas/mirror-end mirror))))) - (goto-char (yas/mirror-start mirror)) - (insert reflection) - (if (> (yas/mirror-end mirror) (point)) - (delete-region (point) (yas/mirror-end mirror)) - (set-marker (yas/mirror-end mirror) (point)) - (yas/advance-start-maybe (yas/mirror-next mirror) (point)))))) - -(defun yas/field-update-display (field snippet) - "Much like `yas/mirror-update-display', but for fields" - (when (yas/field-transform field) - (let ((inhibit-modification-hooks t) - (transformed (yas/apply-transform field field)) - (point (point))) - (when (and transformed - (not (string= transformed (buffer-substring-no-properties (yas/field-start field) - (yas/field-end field))))) - (setf (yas/field-modified-p field) t) - (goto-char (yas/field-start field)) - (insert transformed) - (if (> (yas/field-end field) (point)) - (delete-region (point) (yas/field-end field)) - (set-marker (yas/field-end field) (point)) - (yas/advance-start-maybe (yas/field-next field) (point))) - t)))) - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Pre- and post-command hooks -;; -(defun yas/pre-command-handler () ) - -(defun yas/post-command-handler () - "Handles various yasnippet conditions after each command." - (cond (yas/protection-violation - (goto-char yas/protection-violation) - (setq yas/protection-violation nil)) - ((eq 'undo this-command) - ;; - ;; After undo revival the correct field is sometimes not - ;; restored correctly, this condition handles that - ;; - (let* ((snippet (car (yas/snippets-at-point))) - (target-field (and snippet - (find-if-not #'(lambda (field) - (yas/field-probably-deleted-p snippet field)) - (remove nil - (cons (yas/snippet-active-field snippet) - (yas/snippet-fields snippet))))))) - (when target-field - (yas/move-to-field snippet target-field)))) - ((not (yas/undo-in-progress)) - ;; When not in an undo, check if we must commit the snippet (use exited it). - (yas/check-commit-snippet)))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Debug functions. Use (or change) at will whenever needed. -;; -;; some useful debug code for looking up snippet tables -;; -;; (insert (pp -;; (let ((shit)) -;; (maphash #'(lambda (k v) -;; (push k shit)) -;; (yas/snippet-table-hash (gethash 'ruby-mode yas/snippet-tables))) -;; shit))) -;; - -(defun yas/debug-tables () - (interactive) - (with-output-to-temp-buffer "*YASnippet tables*" - (dolist (symbol (remove nil (append (list major-mode) - (if (listp yas/mode-symbol) - yas/mode-symbol - (list yas/mode-symbol))))) - (princ (format "Snippet table hash keys for %s:\n\n" symbol)) - (let ((keys)) - (maphash #'(lambda (k v) - (push k keys)) - (yas/snippet-table-hash (gethash symbol yas/snippet-tables))) - (princ keys)) - - (princ (format "Keymap for %s:\n\n" symbol)) - (princ (gethash symbol yas/menu-table))))) - -(defun yas/debug-snippet-vars () - "Debug snippets, fields, mirrors and the `buffer-undo-list'." - (interactive) - (with-output-to-temp-buffer "*YASnippet trace*" - (princ "Interesting YASnippet vars: \n\n") - - (princ (format "\nPost command hook: %s\n" post-command-hook)) - (princ (format "\nPre command hook: %s\n" pre-command-hook)) - - (princ (format "%s live snippets in total\n" (length (yas/snippets-at-point (quote all-snippets))))) - (princ (format "%s overlays in buffer:\n\n" (length (overlays-in (point-min) (point-max))))) - (princ (format "%s live snippets at point:\n\n" (length (yas/snippets-at-point)))) - - - (dolist (snippet (yas/snippets-at-point)) - (princ (format "\tsid: %d control overlay from %d to %d\n" - (yas/snippet-id snippet) - (overlay-start (yas/snippet-control-overlay snippet)) - (overlay-end (yas/snippet-control-overlay snippet)))) - (princ (format "\tactive field: %d from %s to %s covering \"%s\"\n" - (yas/field-number (yas/snippet-active-field snippet)) - (marker-position (yas/field-start (yas/snippet-active-field snippet))) - (marker-position (yas/field-end (yas/snippet-active-field snippet))) - (buffer-substring-no-properties (yas/field-start (yas/snippet-active-field snippet)) (yas/field-end (yas/snippet-active-field snippet))))) - (when (yas/snippet-exit snippet) - (princ (format "\tsnippet-exit: at %s next: %s\n" - (yas/exit-marker (yas/snippet-exit snippet)) - (yas/exit-next (yas/snippet-exit snippet))))) - (dolist (field (yas/snippet-fields snippet)) - (princ (format "\tfield: %d from %s to %s covering \"%s\" next: %s\n" - (yas/field-number field) - (marker-position (yas/field-start field)) - (marker-position (yas/field-end field)) - (buffer-substring-no-properties (yas/field-start field) (yas/field-end field)) - (yas/debug-format-fom-concise (yas/field-next field)))) - (dolist (mirror (yas/field-mirrors field)) - (princ (format "\t\tmirror: from %s to %s covering \"%s\" next: %s\n" - (marker-position (yas/mirror-start mirror)) - (marker-position (yas/mirror-end mirror)) - (buffer-substring-no-properties (yas/mirror-start mirror) (yas/mirror-end mirror)) - (yas/debug-format-fom-concise (yas/mirror-next mirror))))))) - - (princ (format "\nUndo is %s and point-max is %s.\n" - (if (eq buffer-undo-list t) - "DISABLED" - "ENABLED") - (point-max))) - (unless (eq buffer-undo-list t) - (princ (format "Undpolist has %s elements. First 10 elements follow:\n" (length buffer-undo-list))) - (let ((first-ten (subseq buffer-undo-list 0 19))) - (dolist (undo-elem first-ten) - (princ (format "%2s: %s\n" (position undo-elem first-ten) (truncate-string-to-width (format "%s" undo-elem) 70)))))))) - -(defun yas/debug-format-fom-concise (fom) - (when fom - (cond ((yas/field-p fom) - (format "field %d from %d to %d" - (yas/field-number fom) - (marker-position (yas/field-start fom)) - (marker-position (yas/field-end fom)))) - ((yas/mirror-p fom) - (format "mirror from %d to %d" - (marker-position (yas/mirror-start fom)) - (marker-position (yas/mirror-end fom)))) - (t - (format "snippet exit at %d" - (marker-position (yas/fom-start fom))))))) - - -(defun yas/exterminate-package () - (interactive) - (yas/global-mode -1) - (yas/minor-mode -1) - (yas/kill-snippet-keybindings) - (mapatoms #'(lambda (atom) - (when (string-match "yas/" (symbol-name atom)) - (unintern atom))))) - -(defun yas/debug-test (&optional quiet) - (interactive "P") - (yas/load-directory (or (and (listp yas/root-directory) - (first yas/root-directory)) - yas/root-directory - "~/Source/yasnippet/snippets/")) - (set-buffer (switch-to-buffer "*YAS TEST*")) - (mapc #'yas/commit-snippet (yas/snippets-at-point 'all-snippets)) - (erase-buffer) - (setq buffer-undo-list nil) - (setq undo-in-progress nil) - (snippet-mode) - (yas/minor-mode 1) - (let ((abbrev)) - (setq abbrev "$f") - (insert abbrev)) - (unless quiet - (add-hook 'post-command-hook 'yas/debug-snippet-vars 't 'local))) - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; `locate-dominating-file' is added for compatibility in emacs < 23 -(unless (or (eq emacs-major-version 23) - (fboundp 'locate-dominating-file)) - (defvar locate-dominating-stop-dir-regexp - "\\`\\(?:[\\/][\\/][^\\/]+[\\/]\\|/\\(?:net\\|afs\\|\\.\\.\\.\\)/\\)\\'" - "Regexp of directory names which stop the search in `locate-dominating-file'. -Any directory whose name matches this regexp will be treated like -a kind of root directory by `locate-dominating-file' which will stop its search -when it bumps into it. -The default regexp prevents fruitless and time-consuming attempts to find -special files in directories in which filenames are interpreted as hostnames, -or mount points potentially requiring authentication as a different user.") - - (defun locate-dominating-file (file name) - "Look up the directory hierarchy from FILE for a file named NAME. -Stop at the first parent directory containing a file NAME, -and return the directory. Return nil if not found." - ;; We used to use the above locate-dominating-files code, but the - ;; directory-files call is very costly, so we're much better off doing - ;; multiple calls using the code in here. - ;; - ;; Represent /home/luser/foo as ~/foo so that we don't try to look for - ;; `name' in /home or in /. - (setq file (abbreviate-file-name file)) - (let ((root nil) - (prev-file file) - ;; `user' is not initialized outside the loop because - ;; `file' may not exist, so we may have to walk up part of the - ;; hierarchy before we find the "initial UID". - (user nil) - try) - (while (not (or root - (null file) - ;; FIXME: Disabled this heuristic because it is sometimes - ;; inappropriate. - ;; As a heuristic, we stop looking up the hierarchy of - ;; directories as soon as we find a directory belonging - ;; to another user. This should save us from looking in - ;; things like /net and /afs. This assumes that all the - ;; files inside a project belong to the same user. - ;; (let ((prev-user user)) - ;; (setq user (nth 2 (file-attributes file))) - ;; (and prev-user (not (equal user prev-user)))) - (string-match locate-dominating-stop-dir-regexp file))) - (setq try (file-exists-p (expand-file-name name file))) - (cond (try (setq root file)) - ((equal file (setq prev-file file - file (file-name-directory - (directory-file-name file)))) - (setq file nil)))) - root))) - -(provide 'yasnippet) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Monkey patching for other functions that's causing -;; problems to yasnippet. For details on why I patch -;; those functions, refer to -;; http://code.google.com/p/yasnippet/wiki/MonkeyPatching -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -(defadvice c-neutralize-syntax-in-CPP - (around yas-mp/c-neutralize-syntax-in-CPP activate) - "Adviced `c-neutralize-syntax-in-CPP' to properly -handle the end-of-buffer error fired in it by calling -`forward-char' at the end of buffer." - (condition-case err - ad-do-it - (error (message (error-message-string err))))) - -;; disable c-electric-* serial command in YAS fields -(add-hook 'c-mode-common-hook - '(lambda () - (dolist (k '(":" ">" ";" "<" "{" "}")) - (define-key (symbol-value (make-local-variable 'yas/keymap)) - k 'self-insert-command)))) - - -;;; yasnippet.el ends here -- cgit v1.2.3