From 897eee81de8b3f6adf0165f50e95600a7b89c20c Mon Sep 17 00:00:00 2001 From: Simeon Simeonov Date: Wed, 4 Feb 2015 21:41:42 +0100 Subject: Standalone lisp and snippet repo --- .emacs.d/lisp/php-mode.el | 1536 ++++++++++++ .emacs.d/lisp/yasnippet.el | 5901 +++++++++++++++++++++++++------------------- 2 files changed, 4950 insertions(+), 2487 deletions(-) create mode 100644 .emacs.d/lisp/php-mode.el (limited to '.emacs.d/lisp') diff --git a/.emacs.d/lisp/php-mode.el b/.emacs.d/lisp/php-mode.el new file mode 100644 index 0000000..1841c4b --- /dev/null +++ b/.emacs.d/lisp/php-mode.el @@ -0,0 +1,1536 @@ +;;; php-mode.el --- Major mode for editing PHP code + +;; Copyright (C) 1999, 2000, 2001, 2003, 2004 Turadg Aleahmad +;; 2008 Aaron S. Hawley +;; 2011, 2012, 2013, 2014, 2015 Eric James Michael Ritz + +;;; Author: Eric James Michael Ritz +;;; URL: https://github.com/ejmr/php-mode +;;; Version: 1.15.3 + +(defconst php-mode-version-number "1.15.3" + "PHP Mode version number.") + +(defconst php-mode-modified "2015-01-31" + "PHP Mode build date.") + +;;; License + +;; 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 3 +;; of the License, 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 this file; if not, write to the Free Software +;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +;; 02110-1301, USA. + +;;; Usage + +;; Put this file in your Emacs lisp path (eg. site-lisp) and add to +;; your .emacs file: +;; +;; (require 'php-mode) + +;; To use abbrev-mode, add lines like this: +;; (add-hook 'php-mode-hook +;; '(lambda () (define-abbrev php-mode-abbrev-table "ex" "extends"))) + +;; To make php-mode compatible with html-mode, see http://php-mode.sf.net + +;; Many options available under Help:Customize +;; Options specific to php-mode are in +;; Programming/Languages/Php +;; Since it inherits much functionality from c-mode, look there too +;; Programming/Languages/C + +;;; Commentary: + +;; PHP mode is a major mode for editing PHP source code. It's an +;; extension of C mode; thus it inherits all C mode's navigation +;; functionality. But it colors according to the PHP grammar and +;; indents according to the PEAR coding guidelines. It also includes +;; a couple handy IDE-type features such as documentation search and a +;; source and class browser. + +;;; Code: + +(require 'cc-mode) +(eval-when-compile + (require 'cc-langs) + (require 'cc-fonts)) + +;; Boilerplate from other `cc-mode' derived modes. See +;; http://cc-mode.sourceforge.net/derived-mode-ex.el for details on how this all +;; fits together. +(eval-and-compile + (c-add-language 'php-mode 'java-mode)) + +(require 'font-lock) +(require 'add-log) +(require 'custom) +(require 'flymake) +(require 'etags) +(require 'speedbar) +(eval-when-compile + (unless (require 'cl-lib nil t) + (require 'cl)) + (require 'regexp-opt) + (defvar c-vsemi-status-unknown-p) + (defvar syntax-propertize-via-font-lock)) + +;; Work around emacs bug#18845, cc-mode expects cl to be loaded +;; while php-mode only uses cl-lib (without compatibility aliases) +(eval-when-compile + (if (and (= emacs-major-version 24) (= emacs-minor-version 4)) + (require 'cl))) + +;; Use the recommended cl functions in php-mode but alias them to the +;; old names when we detect emacs < 24.3 +(if (and (= emacs-major-version 24) (< emacs-minor-version 3)) + (progn + (unless (fboundp 'cl-flet) + (defalias 'cl-flet 'flet)) + (unless (fboundp 'cl-set-difference) + (defalias 'cl-set-difference 'set-difference)))) + + +;; Local variables +;;;###autoload +(defgroup php nil + "Major mode `php-mode' for editing PHP code." + :prefix "php-" + :group 'languages + :link '(url-link :tag "Official Site" "https://github.com/ejmr/php-mode") + :link '(url-link :tag "PHP Mode Wiki" "https://github.com/ejmr/php-mode/wiki")) + +(defcustom php-executable "/usr/bin/php" + "The location of the PHP executable." + :type 'string + :group 'php) + +(defcustom php-default-face 'default + "Default face in `php-mode' buffers." + :type 'face + :group 'php) + +(defcustom php-speedbar-config t + "When set to true automatically configures Speedbar to observe PHP files. +Ignores php-file patterns option; fixed to expression \"\\.\\(inc\\|php[s345]?\\)\"" + :type 'boolean + :set (lambda (sym val) + (set-default sym val) + (when val + (speedbar-add-supported-extension + "\\.\\(inc\\|php[s345]?\\|phtml\\)"))) + :group 'php) + +(defcustom php-mode-speedbar-open nil + "Normally `php-mode' starts with the speedbar closed. +Turning this on will open it whenever `php-mode' is loaded." + :type 'boolean + :set (lambda (sym val) + (set-default sym val) + (when val + (speedbar 1))) + :group 'php) + +(defcustom php-template-compatibility t + "Should detect presence of html tags." + :type 'boolean + :group 'php) + +(defun php-mode-extra-constants-create-regexp(kwds) + "Create regexp for the list of extra constant keywords KWDS." + (concat "[^_$]?\\<\\(" + (regexp-opt + (append kwds + (when (boundp 'web-mode-extra-php-constants) web-mode-extra-php-constants))) + "\\)\\>[^_]?")) + +(defun php-mode-extra-constants-set(sym value) + "Apply the list of extra constant keywords VALUE. + +This function is called when the custom variable php-extra-constants +is updated. The web-mode-extra-constants list is appended to the list +of constants when set." + ;; remove old keywords + (when (boundp 'php-extra-constants) + (font-lock-remove-keywords + 'php-mode `((,(php-mode-extra-constants-create-regexp php-extra-constants) 1 font-lock-constant-face)))) + ;; add new keywords + (when value + (font-lock-add-keywords + 'php-mode `((,(php-mode-extra-constants-create-regexp value) 1 font-lock-constant-face)))) + (set sym value)) + +(defcustom php-lineup-cascaded-calls nil + "Indent chained method calls to the previous line" + :type 'boolean + :group 'php) + +;;;###autoload +(defcustom php-extra-constants '() + "A list of additional strings to treat as PHP constants." + :type 'list + :set 'php-mode-extra-constants-set + :group 'php) + +(defun php-create-regexp-for-method (visibility) + "Make a regular expression for methods with the given VISIBILITY. + +VISIBILITY must be a string that names the visibility for a PHP +method, e.g. 'public'. The parameter VISIBILITY can itself also +be a regular expression. + +The regular expression this function returns will check for other +keywords that can appear in method signatures, e.g. 'final' and +'static'. The regular expression will have one capture group +which will be the name of the method." + (concat + ;; Initial space with possible 'abstract' or 'final' keywords + "^\\s-*\\(?:\\(?:abstract\\|final\\)\\s-+\\)?" + ;; 'static' keyword may come either before or after visibility + "\\(?:" visibility "\\(?:\\s-+static\\)?\\|\\(?:static\\s-+\\)?" visibility "\\)\\s-+" + ;; Make sure 'function' comes next with some space after + "function\\s-+" + ;; Capture the name as the first group and the regexp and make sure + ;; by the end we see the opening parenthesis for the parameters. + "\\(\\(?:\\sw\\|\\s_\\)+\\)\\s-*(")) + +(defun php-create-regexp-for-classlike (type) + "Accepts a `type' of a 'classlike' object as a string, such as +'class' or 'interface', and returns a regexp as a string which +can be used to match against definitions for that classlike." + (concat + ;; First see if 'abstract' or 'final' appear, although really these + ;; are not valid for all values of `type' that the function + ;; accepts. + "^\\s-*\\(?:\\(?:abstract\\|final\\)\\s-+\\)?" + ;; The classlike type + type + ;; Its name, which is the first captured group in the regexp. We + ;; allow backslashes in the name to handle namespaces, but again + ;; this is not necessarily correct for all values of `type'. + "\\s-+\\(\\(?:\\sw\\|\\\\\\|\\s_\\)+\\)")) + +(defvar php-imenu-generic-expression + `(("Namespaces" + ,(php-create-regexp-for-classlike "namespace") 1) + ("Classes" + ,(php-create-regexp-for-classlike "class") 1) + ("Interfaces" + ,(php-create-regexp-for-classlike "interface") 1) + ("Traits" + ,(php-create-regexp-for-classlike "trait") 1) + ("All Methods" + ,(php-create-regexp-for-method "\\(?:\\sw\\|\\s_\\)+") 1) + ("Private Methods" + ,(php-create-regexp-for-method "private") 1) + ("Protected Methods" + ,(php-create-regexp-for-method "protected") 1) + ("Public Methods" + ,(php-create-regexp-for-method "public") 1) + ("Anonymous Functions" + "\\<\\(\\(?:\\sw\\|\\s_\\)+\\)\\s-*=\\s-*function\\s-*(" 1) + ("Named Functions" + "^\\s-*function\\s-+\\(\\(?:\\sw\\|\\s_\\)+\\)\\s-*(" 1)) + "Imenu generic expression for PHP Mode. See `imenu-generic-expression'.") + +(defcustom php-manual-url "http://www.php.net/manual/en/" + "URL at which to find PHP manual. +You can replace \"en\" with your ISO language code." + :type 'string + :group 'php) + +(defcustom php-search-url "http://www.php.net/" + "URL at which to search for documentation on a word." + :type 'string + :group 'php) + +(defcustom php-completion-file "" + "Path to the file which contains the function names known to PHP." + :type 'string + :group 'php) + +(defcustom php-manual-path "" + "Path to the directory which contains the PHP manual." + :type 'string + :group 'php) + +;;;###autoload +(add-to-list 'interpreter-mode-alist (cons "php" 'php-mode)) + +(defcustom php-mode-hook nil + "List of functions to be executed on entry to `php-mode'." + :type 'hook + :group 'php) + +(defcustom php-mode-pear-hook nil + "Hook called when a PHP PEAR file is opened with `php-mode'." + :type 'hook + :group 'php) + +(defcustom php-mode-drupal-hook nil + "Hook called when a Drupal file is opened with `php-mode'." + :type 'hook + :group 'php) + +(defcustom php-mode-wordpress-hook nil + "Hook called when a WordPress file is opened with `php-mode'." + :type 'hook + :group 'php) + +(defcustom php-mode-symfony2-hook nil + "Hook called when a Symfony2 file is opened with `php-mode'." + :type 'hook + :group 'php) + +(defcustom php-mode-psr2-hook nil + "Hook called when a PSR-2 file is opened with `php-mode'." + :type 'hook + :group 'php) + +(defcustom php-mode-force-pear nil + "Normally PEAR coding rules are enforced only when the filename contains \"PEAR.\" +Turning this on will force PEAR rules on all PHP files." + :type 'boolean + :group 'php) + +(defcustom php-mode-warn-if-mumamo-off t + "Warn once per buffer if you try to indent a buffer without +mumamo-mode turned on. Detects if there are any HTML tags in the +buffer before warning, but this is is not very smart; e.g. if you +have any tags inside a PHP string, it will be fooled." + :type '(choice (const :tag "Warg" t) (const "Don't warn" nil)) + :group 'php) + +(defcustom php-mode-coding-style 'pear + "Select default coding style to use with php-mode. +This variable can take one of the following symbol values: + +`Default' - use a reasonable default style for PHP. + +`PEAR' - use coding styles preferred for PEAR code and modules. + +`Drupal' - use coding styles preferred for working with Drupal projects. + +`WordPress' - use coding styles preferred for working with WordPress projects. + +`Symfony2' - use coding styles preferred for working with Symfony2 projects. + +`PSR-2' - use coding styles preferred for working with projects using PSR-2 standards." + :type '(choice (const :tag "Default" default) + (const :tag "PEAR" pear) + (const :tag "Drupal" drupal) + (const :tag "WordPress" wordpress) + (const :tag "Symfony2" symfony2) + (const :tag "PSR-2" psr2)) + :group 'php + :set 'php-mode-custom-coding-style-set + :initialize 'custom-initialize-default) + +(defun php-mode-custom-coding-style-set (sym value) + (when (eq major-mode 'php-mode) + (set sym value) + (set-default sym value) + (cond ((eq value 'pear) + (php-enable-pear-coding-style)) + ((eq value 'default) + (php-enable-default-coding-style)) + ((eq value 'drupal) + (php-enable-drupal-coding-style)) + ((eq value 'wordpress) + (php-enable-wordpress-coding-style)) + ((eq value 'symfony2) + (php-enable-symfony2-coding-style)) + ((eq value 'psr2) + (php-enable-psr2-coding-style))))) + +(defun php-mode-version () + "Display string describing the version of PHP mode." + (interactive) + (message "PHP mode %s of %s" + php-mode-version-number php-mode-modified)) + +(defvar php-mode-map + (let ((map (make-sparse-keymap))) + ;; (define-key map [menu-bar php] + ;; (cons "PHP" (make-sparse-keymap "PHP"))) + + ;; (define-key map [menu-bar php complete-function] + ;; '("Complete function name" . php-complete-function)) + ;; (define-key map [menu-bar php browse-manual] + ;; '("Browse manual" . php-browse-manual)) + ;; (define-key map [menu-bar php search-documentation] + ;; '("Search documentation" . php-search-documentation)) + + ;; By default PHP mode binds C-M-h to c-mark-function, which it + ;; inherits from cc-mode. But there are situations where + ;; c-mark-function fails to properly mark a function. For + ;; example, if we use c-mark-function within a method definition + ;; then the region will expand beyond the method and into the + ;; class definition itself. + ;; + ;; Changing the default to mark-defun provides behavior that users + ;; are more likely to expect. + (define-key map (kbd "C-M-h") 'mark-defun) + + ;; Many packages based on cc-mode provide the 'C-c C-w' binding + ;; to toggle Subword Mode. See the page + ;; + ;; https://www.gnu.org/software/emacs/manual/html_node/ccmode/Subword-Movement.html + ;; + ;; for more information about Submode Word. + (if (boundp 'subword-mode) + (if subword-mode + (subword-mode nil) + (subword-mode t))) + + ;; We inherit c-beginning-of-defun and c-end-of-defun from CC Mode + ;; but we have two replacement functions specifically for PHP. We + ;; remap the commands themselves and not their default + ;; key-bindings so that our PHP-specific versions will work even + ;; if the user has reconfigured their keys, e.g. if they rebind + ;; c-end-of-defun to something other than C-M-e. + (define-key map [remap c-beginning-of-defun] 'php-beginning-of-defun) + (define-key map [remap c-end-of-defun] 'php-end-of-defun) + + (define-key map [(control c) (control f)] 'php-search-documentation) + (define-key map [(meta tab)] 'php-complete-function) + (define-key map [(control c) (control m)] 'php-browse-manual) + (define-key map [(control .)] 'php-show-arglist) + (define-key map [(control c) (control r)] 'php-send-region) + ;; Use the Emacs standard indentation binding. This may upset c-mode + ;; which does not follow this at the moment, but I see no better + ;; choice. + (define-key map [tab] 'indent-for-tab-command) + map) + "Keymap for `php-mode'") + +(c-lang-defconst c-mode-menu + php (append '(["Complete function name" php-complete-function t] + ["Browse manual" php-browse-manual t] + ["Search documentation" php-search-documentation t] + ["----" t]) + (c-lang-const c-mode-menu))) + +(c-lang-defconst c-at-vsemi-p-fn + php 'php-c-at-vsemi-p) + +(c-lang-defconst c-vsemi-status-unknown-p-fn + php 'php-c-vsemi-status-unknown-p) + +;; Make php-mode recognize opening tags as preprocessor macro's. +;; +;; This is a workaround, the tags must be recognized as something +;; in order for the syntactic guesses of code below the tag +;; to be correct and as a result not break indentation. +;; +;; Note that submatches or \\| here are not expected by cc-mode. +(c-lang-defconst c-opt-cpp-prefix + php "\\s-*<\\?") + +(c-lang-defconst c-identifier-ops + php '( + (left-assoc "\\" "::" "->") + (prefix "\\" "::"))) + +;; Allow '\' when scanning from open brace back to defining +;; construct like class +(c-lang-defconst c-block-prefix-disallowed-chars + php (cl-set-difference (c-lang-const c-block-prefix-disallowed-chars) + '(?\\))) + +;; Allow $ so variables are recognized in cc-mode and remove @. This +;; makes cc-mode highlight variables and their type hints in arglists. +(c-lang-defconst c-symbol-start + php (concat "[" c-alpha "_$]")) + +;; All string literals can possibly span multiple lines +(c-lang-defconst c-multiline-string-start-char + php t) + +(c-lang-defconst c-assignment-operators + ;; falls back to java, so no need to specify the language + php (append (remove ">>>=" (c-lang-const c-assignment-operators)) + '(".="))) + +(c-lang-defconst beginning-of-defun-function + php 'php-beginning-of-defun) + +(c-lang-defconst end-of-defun-function + php 'php-end-of-defun) + +(c-lang-defconst c-primitive-type-kwds + php '("int" "integer" "bool" "boolean" "float" "double" "real" + "string" "object")) + +(c-lang-defconst c-class-decl-kwds + "Keywords introducing declarations where the following block (if any) +contains another declaration level that should be considered a class." + php '("class" "trait" "interface")) + +(c-lang-defconst c-brace-list-decl-kwds + "Keywords introducing declarations where the following block (if +any) is a brace list. + +PHP does not have an \"enum\"-like keyword." + php nil) + +(c-lang-defconst c-typeless-decl-kwds + php (append (c-lang-const c-class-decl-kwds) '("function"))) + +(c-lang-defconst c-modifier-kwds + php '("abstract" "const" "final" "native" "static" "strictfp" + "synchronized" "transient" "volatile")) + +(c-lang-defconst c-protection-kwds + "Access protection label keywords in classes." + php '("private" "protected" "public")) + +(c-lang-defconst c-postfix-decl-spec-kwds + php '("implements" "extends")) + +(c-lang-defconst c-type-list-kwds + php '("new" "use" "implements" "extends" "namespace" "instanceof" "insteadof")) + +(c-lang-defconst c-ref-list-kwds + php nil) + +(c-lang-defconst c-block-stmt-2-kwds + php (append '("elseif" "foreach" "declare") + (remove "synchronized" (c-lang-const c-block-stmt-2-kwds)))) + +(c-lang-defconst c-simple-stmt-kwds + php (append '("include" "include_once" "require" "require_once" + "echo" "print" "die" "exit") + (c-lang-const c-simple-stmt-kwds))) + +(c-lang-defconst c-constant-kwds + php '("true" + "false" + "null")) + +(c-lang-defconst c-lambda-kwds + php '("function")) + +(c-lang-defconst c-other-kwds + "Keywords not accounted for by any other `*-kwds' language constant." + php '( + "__halt_compiler" + "and" + "array" + "callable" + "as" + "break" + "catch all" + "catch" + "clone" + "default" + "empty" + "enddeclare" + "endfor" + "endforeach" + "endif" + "endswitch" + "endwhile" + "eval" + "global" + "isset" + "list" + "or" + "parent" + "static" + "unset" + "var" + "xor" + "yield" + + ;; Below keywords are technically not reserved keywords, but + ;; threated no differently by php-mode from actual reserved + ;; keywords + ;; + ;;; declare directives: + "encoding" + "ticks" + + ;;; self for static references: + "self" + )) + +;; PHP does not have <> templates/generics +(c-lang-defconst c-recognize-<>-arglists + php nil) + +(c-lang-defconst c-enums-contain-decls + php nil) + +(c-lang-defconst c-nonlabel-token-key + "Regexp matching things that can't occur in generic colon labels. + +This overrides cc-mode `c-nonlabel-token-key' to support switching on +double quoted strings and true/false/null. + +Note: this regexp is also applied to goto-labels, a future improvement +might be to handle switch and goto labels differently." + php (concat + ;; All keywords except `c-label-kwds' and `c-constant-kwds'. + (c-make-keywords-re t + (cl-set-difference (c-lang-const c-keywords) + (append (c-lang-const c-label-kwds) + (c-lang-const c-constant-kwds)) + :test 'string-equal)))) + +(defun php-lineup-cascaded-calls (langelem) + "Line up chained methods using `c-lineup-cascaded-calls', +but only if the setting is enabled" + (if php-lineup-cascaded-calls + (c-lineup-cascaded-calls langelem))) + +(c-add-style + "php" + '((c-basic-offset . 4) + (c-doc-comment-style . javadoc) + (c-offsets-alist . ((arglist-close . php-lineup-arglist-close) + (arglist-cont . (first php-lineup-cascaded-calls 0)) + (arglist-cont-nonempty . (first php-lineup-cascaded-calls c-lineup-arglist)) + (arglist-intro . php-lineup-arglist-intro) + (case-label . +) + (class-open . -) + (comment-intro . 0) + (inlambda . 0) + (inline-open . 0) + (label . +) + (statement-cont . (first php-lineup-cascaded-calls php-lineup-string-cont +)) + (substatement-open . 0) + (topmost-intro-cont . (first php-lineup-cascaded-calls +)))))) + +(defun php-enable-default-coding-style () + "Set PHP Mode to use reasonable default formatting." + (interactive) + (c-set-style "php")) + +(c-add-style + "pear" + '("php" + (c-basic-offset . 4) + (c-offsets-alist . ((case-label . 0))))) + +(defun php-enable-pear-coding-style () + "Sets up php-mode to use the coding styles preferred for PEAR +code and modules." + (interactive) + (setq tab-width 4 + indent-tabs-mode nil) + (c-set-style "pear") + + ;; Undo drupal/PSR-2 coding style whitespace effects + (set (make-local-variable 'show-trailing-whitespace) + (default-value 'show-trailing-whitespace))) + +(c-add-style + "drupal" + '("php" + (c-basic-offset . 2))) + +(defun php-enable-drupal-coding-style () + "Makes php-mode use coding styles that are preferable for +working with Drupal." + (interactive) + (setq tab-width 2 + indent-tabs-mode nil + fill-column 78) + (set (make-local-variable 'show-trailing-whitespace) t) + (add-hook 'before-save-hook 'delete-trailing-whitespace nil t) + (c-set-style "drupal")) + +(c-add-style + "wordpress" + '("php" + (c-basic-offset . 4))) + +(defun php-enable-wordpress-coding-style () + "Makes php-mode use coding styles that are preferable for +working with Wordpress." + (interactive) + (setq indent-tabs-mode t + fill-column 78 + tab-width 4 + c-indent-comments-syntactically-p t) + (c-set-style "wordpress") + + ;; Undo drupal/PSR-2 coding style whitespace effects + (set (make-local-variable 'show-trailing-whitespace) + (default-value 'show-trailing-whitespace))) + +(c-add-style + "symfony2" + '("php" + (c-offsets-alist . ((statement-cont . php-lineup-hanging-semicolon))))) + +(defun php-enable-symfony2-coding-style () + "Makes php-mode use coding styles that are preferable for +working with Symfony2." + (interactive) + (setq indent-tabs-mode nil + fill-column 78 + c-indent-comments-syntactically-p t + require-final-newline t) + (c-set-style "symfony2") + + ;; Undo drupal/PSR-2 coding style whitespace effects + (set (make-local-variable 'show-trailing-whitespace) + (default-value 'show-trailing-whitespace))) + +(c-add-style + "psr2" + '("php")) + +(defun php-enable-psr2-coding-style () + "Makes php-mode comply to the PSR-2 coding style" + (interactive) + (setq indent-tabs-mode nil + fill-column 78 + c-indent-comments-syntactically-p t + require-final-newline t) + (c-set-style "psr2") + + ;; Apply drupal-like coding style whitespace effects + (set (make-local-variable 'require-final-newline) t) + (set (make-local-variable 'show-trailing-whitespace) t) + (add-hook 'before-save-hook 'delete-trailing-whitespace nil t)) + +(defconst php-beginning-of-defun-regexp + "^\\s-*\\(?:\\(?:abstract\\|final\\|private\\|protected\\|public\\|static\\)\\s-+\\)*function\\s-+&?\\(\\(?:\\sw\\|\\s_\\)+\\)\\s-*(" + "Regular expression for a PHP function.") + +(defun php-beginning-of-defun (&optional arg) + "Move to the beginning of the ARGth PHP function from point. +Implements PHP version of `beginning-of-defun-function'." + (interactive "p") + (let ((arg (or arg 1))) + (while (> arg 0) + (re-search-backward php-beginning-of-defun-regexp + nil 'noerror) + (setq arg (1- arg))) + (while (< arg 0) + (end-of-line 1) + (let ((opoint (point))) + (beginning-of-defun 1) + (forward-list 2) + (forward-line 1) + (if (eq opoint (point)) + (re-search-forward php-beginning-of-defun-regexp + nil 'noerror)) + (setq arg (1+ arg)))))) + +(defun php-end-of-defun (&optional arg) + "Move the end of the ARGth PHP function from point. +Implements PHP befsion of `end-of-defun-function' + +See `php-beginning-of-defun'." + (interactive "p") + (php-beginning-of-defun (- (or arg 1)))) + + +(defvar php-warned-bad-indent nil) + +;; Do it but tell it is not good if html tags in buffer. +(defun php-check-html-for-indentation () + (let ((html-tag-re "^\\s-*") + (here (point))) + (goto-char (line-beginning-position)) + (if (or (when (boundp 'mumamo-multi-major-mode) mumamo-multi-major-mode) + ;; Fix-me: no idea how to check for mmm or multi-mode + (save-match-data + (not (or (re-search-forward html-tag-re (line-end-position) t) + (re-search-backward html-tag-re (line-beginning-position) t))))) + (progn + (goto-char here) + t) + (goto-char here) + (setq php-warned-bad-indent t) + (let* ((known-multi-libs '(("mumamo" mumamo (lambda () (nxhtml-mumamo))) + ("mmm-mode" mmm-mode (lambda () (mmm-mode 1))) + ("multi-mode" multi-mode (lambda () (multi-mode 1))) + ("web-mode" web-mode (lambda () (web-mode))))) + (known-names (mapcar (lambda (lib) (car lib)) known-multi-libs)) + (available-multi-libs (delq nil + (mapcar + (lambda (lib) + (when (locate-library (car lib)) lib)) + known-multi-libs))) + (available-names (mapcar (lambda (lib) (car lib)) available-multi-libs)) + (base-msg + (concat + "Indentation fails badly with mixed HTML/PHP in the HTML part in +plain `php-mode'. To get indentation to work you must use an +Emacs library that supports 'multiple major modes' in a buffer. +Parts of the buffer will then be in `php-mode' and parts in for +example `html-mode'. Known such libraries are:\n\t" + (mapconcat 'identity known-names ", ") + "\n" + (if available-multi-libs + (concat + "You have these available in your `load-path':\n\t" + (mapconcat 'identity available-names ", ") + "\n\n" + "Do you want to turn any of those on? ") + "You do not have any of those in your `load-path'."))) + (is-using-multi + (catch 'is-using + (dolist (lib available-multi-libs) + (when (and (boundp (cadr lib)) + (symbol-value (cadr lib))) + (throw 'is-using t)))))) + (unless is-using-multi + (if available-multi-libs + (if (not (y-or-n-p base-msg)) + (message "Did not do indentation, but you can try again now if you want") + (let* ((name + (if (= 1 (length available-multi-libs)) + (car available-names) + ;; Minibuffer window is more than one line, fix that first: + (message "") + (completing-read "Choose multiple major mode support library: " + available-names nil t + (car available-names) + '(available-names . 1) + ))) + (mode (when name + (caddr (assoc name available-multi-libs))))) + (when mode + ;; Minibuffer window is more than one line, fix that first: + (message "") + (load name) + (funcall mode)))) + (lwarn 'php-indent :warning base-msg))) + nil)))) + +(defun php-cautious-indent-region (start end &optional quiet) + (if (or (not php-mode-warn-if-mumamo-off) + php-warned-bad-indent + (php-check-html-for-indentation)) + (funcall 'c-indent-region start end quiet))) + +(defun php-cautious-indent-line () + (if (or (not php-mode-warn-if-mumamo-off) + php-warned-bad-indent + (php-check-html-for-indentation)) + (let ((here (point)) + doit) + (move-beginning-of-line nil) + ;; Don't indent heredoc end mark + (save-match-data + (unless (looking-at "[a-zA-Z0-9_]+;\n") + (setq doit t))) + (goto-char here) + (when doit + (funcall 'c-indent-line))))) + +(defun php-c-at-vsemi-p (&optional pos) + "Return t on html lines (including php region border), otherwise nil. +POS is a position on the line in question. + +This is was done due to the problem reported here: + + URL `https://answers.launchpad.net/nxhtml/+question/43320'" + (if (not php-template-compatibility) + nil + (setq pos (or pos (point))) + (let ((here (point)) + ret) + (save-match-data + (goto-char pos) + (beginning-of-line) + (setq ret (looking-at + (rx + (or (seq + bol + (0+ space) + "<" + (in "a-z\\?")) + (seq + (0+ not-newline) + (in "a-z\\?") + ">" + (0+ space) + eol)))))) + (goto-char here) + ret))) + +(defun php-c-vsemi-status-unknown-p () + "See `php-c-at-vsemi-p'." + ) + +(defun php-lineup-string-cont (langelem) + "Line up string toward equal sign or dot +e.g. +$str = 'some' + . 'string'; +this ^ lineup" + (save-excursion + (goto-char (cdr langelem)) + (when (or (search-forward "=" (line-end-position) t) + (search-forward "." (line-end-position) t)) + (vector (1- (current-column)))))) + +(defun php-lineup-arglist-intro (langelem) + (save-excursion + (goto-char (cdr langelem)) + (vector (+ (current-column) c-basic-offset)))) + +(defun php-lineup-arglist-close (langelem) + (save-excursion + (goto-char (cdr langelem)) + (vector (current-column)))) + +(defun php-lineup-arglist (langelem) + (save-excursion + (beginning-of-line) + (if (looking-at-p "\\s-*->") '+ 0))) + +(defun php-lineup-hanging-semicolon (langelem) + (save-excursion + (beginning-of-line) + (if (looking-at-p "\\s-*;\\s-*$") 0 '+))) + +(defconst php-heredoc-start-re + "<<<\\(?:\\w+\\|'\\w+'\\)$" + "Regular expression for the start of a PHP heredoc.") + +(defun php-heredoc-end-re (heredoc-start) + "Build a regular expression for the end of a heredoc started by +the string HEREDOC-START." + ;; Extract just the identifier without <<< and quotes. + (string-match "\\w+" heredoc-start) + (concat "^\\(" (match-string 0 heredoc-start) "\\)\\W")) + +(defsubst php-in-string-p () + (nth 3 (syntax-ppss))) + +(defsubst php-in-comment-p () + (nth 4 (syntax-ppss))) + +(defun php-syntax-propertize-function (start end) + "Apply propertize rules from START to END." + ;; (defconst php-syntax-propertize-function + ;; (syntax-propertize-rules + ;; (php-heredoc-start-re (0 (ignore (php-heredoc-syntax)))))) + (goto-char start) + (while (and (< (point) end) + (re-search-forward php-heredoc-start-re end t)) + (php-heredoc-syntax)) + (goto-char start) + (while (re-search-forward "['\"]" end t) + (when (php-in-comment-p) + (c-put-char-property (match-beginning 0) + 'syntax-table (string-to-syntax "_"))))) + +(defun php-heredoc-syntax () + "Mark the boundaries of searched heredoc." + (goto-char (match-beginning 0)) + (c-put-char-property (point) 'syntax-table (string-to-syntax "|")) + (if (re-search-forward (php-heredoc-end-re (match-string 0)) nil t) + (goto-char (match-end 1)) + ;; Did not find the delimiter so go to the end of the buffer. + (goto-char (point-max))) + (c-put-char-property (1- (point)) 'syntax-table (string-to-syntax "|"))) + +(defun php-syntax-propertize-extend-region (start end) + "Extend the propertize region if START or END falls inside a +PHP heredoc." + (let ((new-start) + (new-end)) + (goto-char start) + (when (re-search-backward php-heredoc-start-re nil t) + (let ((maybe (point))) + (when (and (re-search-forward + (php-heredoc-end-re (match-string 0)) nil t) + (> (point) start)) + (setq new-start maybe)))) + (goto-char end) + (when (re-search-backward php-heredoc-start-re nil t) + (if (re-search-forward + (php-heredoc-end-re (match-string 0)) nil t) + (when (> (point) end) + (setq new-end (point))) + (setq new-end (point-max)))) + (when (or new-start new-end) + (cons (or new-start start) (or new-end end))))) + +(easy-menu-define php-mode-menu php-mode-map "PHP Mode Commands" + (cons "PHP" (c-lang-const c-mode-menu php))) + +;;;###autoload +(define-derived-mode php-mode c-mode "PHP" + "Major mode for editing PHP code. + +\\{php-mode-map}" + + (c-initialize-cc-mode t) + (c-init-language-vars php-mode) + (c-common-init 'php-mode) + + (modify-syntax-entry ?_ "_" php-mode-syntax-table) + (modify-syntax-entry ?` "\"" php-mode-syntax-table) + (modify-syntax-entry ?\" "\"" php-mode-syntax-table) + (modify-syntax-entry ?# "< b" php-mode-syntax-table) + (modify-syntax-entry ?\n "> b" php-mode-syntax-table) + + (set (make-local-variable 'syntax-propertize-via-font-lock) + '(("\\(\"\\)\\(\\\\.\\|[^\"\n\\]\\)*\\(\"\\)" (1 "\"") (3 "\"")) + ("\\(\'\\)\\(\\\\.\\|[^\'\n\\]\\)*\\(\'\\)" (1 "\"") (3 "\"")))) + + (when (boundp 'syntax-propertize-function) + (add-to-list (make-local-variable 'syntax-propertize-extend-region-functions) + #'php-syntax-propertize-extend-region) + (set (make-local-variable 'syntax-propertize-function) + #'php-syntax-propertize-function)) + + (setq font-lock-maximum-decoration t + imenu-generic-expression php-imenu-generic-expression) + + ;; PHP vars are case-sensitive + (setq case-fold-search t) + + ;; Do not force newline at end of file. Such newlines can cause + ;; trouble if the PHP file is included in another file before calls + ;; to header() or cookie(). + (set (make-local-variable 'require-final-newline) nil) + (set (make-local-variable 'next-line-add-newlines) nil) + + ;; PEAR coding standards + (add-hook 'php-mode-pear-hook 'php-enable-pear-coding-style + nil t) + + ;; ;; Drupal coding standards + (add-hook 'php-mode-drupal-hook 'php-enable-drupal-coding-style + nil t) + + ;; ;; WordPress coding standards + (add-hook 'php-mode-wordpress-hook 'php-enable-wordpress-coding-style + nil t) + + ;; ;; Symfony2 coding standards + (add-hook 'php-mode-symfony2-hook 'php-enable-symfony2-coding-style + nil t) + + ;; ;; PSR-2 coding standards + (add-hook 'php-mode-psr2-hook 'php-enable-psr2-coding-style + nil t) + + (cond ((eq php-mode-coding-style 'pear) + (php-enable-pear-coding-style) + (run-hooks 'php-mode-pear-hook)) + ((eq php-mode-coding-style 'drupal) + (php-enable-drupal-coding-style) + (run-hooks 'php-mode-drupal-hook)) + ((eq php-mode-coding-style 'wordpress) + (php-enable-wordpress-coding-style) + (run-hooks 'php-mode-wordpress-hook)) + ((eq php-mode-coding-style 'symfony2) + (php-enable-symfony2-coding-style) + (run-hooks 'php-mode-symfony2-hook)) + ((eq php-mode-coding-style 'psr2) + (php-enable-psr2-coding-style) + (run-hooks 'php-mode-psr2-hook))) + + (if (or php-mode-force-pear + (and (stringp buffer-file-name) + (string-match "PEAR\\|pear" + (buffer-file-name)) + (string-match "\\.php$" (buffer-file-name)))) + (run-hooks 'php-mode-pear-hook)) + + (setq indent-line-function 'php-cautious-indent-line) + (setq indent-region-function 'php-cautious-indent-region) + (setq c-at-vsemi-p-fn 'php-c-at-vsemi-p) + (setq c-vsemi-status-unknown-p 'php-c-vsemi-status-unknown-p) + + (set (make-local-variable 'syntax-begin-function) + 'c-beginning-of-syntax) + + ;; We map the php-{beginning,end}-of-defun functions so that they + ;; replace the similar commands that we inherit from CC Mode. + ;; Because of our remapping we may not actually need to keep the + ;; following two local variables, but we keep them for now until we + ;; are completely sure their removal will not break any current + ;; behavior or backwards compatibility. + (set (make-local-variable 'beginning-of-defun-function) + 'php-beginning-of-defun) + (set (make-local-variable 'end-of-defun-function) + 'php-end-of-defun) + + (set (make-local-variable 'open-paren-in-column-0-is-defun-start) + nil) + (set (make-local-variable 'defun-prompt-regexp) + "^\\s-*function\\s-+&?\\s-*\\(\\(\\sw\\|\\s_\\)+\\)\\s-*") + (set (make-local-variable 'add-log-current-defun-header-regexp) + php-beginning-of-defun-regexp)) + +;; Define function name completion function +(defvar php-completion-table nil + "Obarray of tag names defined in current tags table and functions known to PHP.") + +(defun php-complete-function () + "Perform function completion on the text around point. +Completes to the set of names listed in the current tags table +and the standard php functions. +The string to complete is chosen in the same way as the default +for \\[find-tag] (which see)." + (interactive) + (let ((pattern (php-get-pattern)) + beg + completion + (php-functions (php-completion-table))) + (if (not pattern) (message "Nothing to complete") + (if (not (search-backward pattern nil t)) + (message "Can't complete here") + (setq beg (point)) + (forward-char (length pattern)) + (setq completion (try-completion pattern php-functions nil)) + (cond ((eq completion t)) + ((null completion) + (message "Can't find completion for \"%s\"" pattern) + (ding)) + ((not (string= pattern completion)) + (delete-region beg (point)) + (insert completion)) + (t + (message "Making completion list...") + (with-output-to-temp-buffer "*Completions*" + (display-completion-list + (all-completions pattern php-functions))) + (message "Making completion list...%s" "done"))))))) + +(defun php-completion-table () + "Build variable `php-completion-table' on demand. +The table includes the PHP functions and the tags from the +current `tags-file-name'." + (or (and tags-file-name + (save-excursion (tags-verify-table tags-file-name)) + php-completion-table) + (let ((tags-table + (when tags-file-name + (with-current-buffer (get-file-buffer tags-file-name) + (etags-tags-completion-table)))) + (php-table + (cond ((and (not (string= "" php-completion-file)) + (file-readable-p php-completion-file)) + (php-build-table-from-file php-completion-file)) + (php-manual-path + (php-build-table-from-path php-manual-path)) + (t nil)))) + (unless (or php-table tags-table) + (error + (concat "No TAGS file active nor are " + "`php-completion-file' or `php-manual-path' set"))) + (when tags-table + ;; Combine the tables. + (mapatoms (lambda (sym) (intern (symbol-name sym) php-table)) + tags-table)) + (setq php-completion-table php-table)))) + +(defun php-build-table-from-file (filename) + (let ((table (make-vector 1022 0)) + (buf (find-file-noselect filename))) + (with-current-buffer buf + (goto-char (point-min)) + (while (re-search-forward + "^\\([-a-zA-Z0-9_.]+\\)\n" + nil t) + (intern (buffer-substring (match-beginning 1) (match-end 1)) + table))) + (kill-buffer buf) + table)) + +(defun php-build-table-from-path (path) + (let ((table (make-vector 1022 0)) + (files (directory-files + path + nil + "^function\\..+\\.html$"))) + (mapc (lambda (file) + (string-match "\\.\\([-a-zA-Z_0-9]+\\)\\.html$" file) + (intern + (replace-regexp-in-string + "-" "_" (substring file (match-beginning 1) (match-end 1)) t) + table)) + files) + table)) + +;; Find the pattern we want to complete +;; find-tag-default from GNU Emacs etags.el +(defun php-get-pattern () + (save-excursion + (while (looking-at "\\sw\\|\\s_") + (forward-char 1)) + (if (or (re-search-backward "\\sw\\|\\s_" + (save-excursion (beginning-of-line) (point)) + t) + (re-search-forward "\\(\\sw\\|\\s_\\)+" + (save-excursion (end-of-line) (point)) + t)) + (progn (goto-char (match-end 0)) + (buffer-substring-no-properties + (point) + (progn (forward-sexp -1) + (while (looking-at "\\s'") + (forward-char 1)) + (point)))) + nil))) + +(defun php-show-arglist () + (interactive) + (let* ((tagname (php-get-pattern)) + (buf (find-tag-noselect tagname nil nil)) + arglist) + (with-current-buffer buf + (goto-char (point-min)) + (when (re-search-forward + (format "function\\s-+%s\\s-*(\\([^{]*\\))" tagname) + nil t) + (setq arglist (buffer-substring-no-properties + (match-beginning 1) (match-end 1))))) + (if arglist + (message "Arglist for %s: %s" tagname arglist) + (message "Unknown function: %s" tagname)))) + +(defcustom php-search-documentation-browser-function nil + "Function to display PHP documentation in a WWW browser. + +If non-nil, this shadows the value of `browse-url-browser-function' when +calling `php-search-documentation' or `php-search-local-documentation'." + :type '(choice (const :tag "default" nil) function) + :link '(variable-link browse-url-browser-function) + :group 'php) + +(defun php-browse-documentation-url (url) + "Browse a documentation URL using the configured browser function. + +See `php-search-documentation-browser-function'." + (let ((browse-url-browser-function + (or php-search-documentation-browser-function + browse-url-browser-function))) + (browse-url url))) + +(defvar php-search-local-documentation-types + (list "function" "control-structures" "class" "book") + ;; "intro" and "ref" also look interesting, but for all practical purposes + ;; their terms are sub-sets of the "book" terms (with the few exceptions + ;; being very unlikely search terms). + "The set (and priority sequence) of documentation file prefixes +under which to search for files in the local documentation directory.") + +(defvar php-search-local-documentation-words-cache nil) + +(defun php--search-documentation-read-arg () + "Obtain interactive argument for searching documentation." + ;; Cache the list of documentation words available for completion, + ;; based on the defined types-of-interest. + (let ((types-list php-search-local-documentation-types) + (words-cache php-search-local-documentation-words-cache) + (local-manual (and (stringp php-manual-path) + (not (string= php-manual-path ""))))) + (when (and local-manual + (not (assq types-list words-cache))) + ;; Generate the cache on the first run, or if the types changed. + ;; We read the filenames matching our types list in the local + ;; documention directory, and extract the 'middle' component + ;; of each. e.g. "function.array-map.html" => "array_map". + (let* ((types-opt (regexp-opt types-list)) + (pattern (concat "\\`" types-opt "\\.\\(.+\\)\\.html\\'")) + (collection + (mapcar (lambda (filename) (subst-char-in-string + ?- ?_ (replace-regexp-in-string + pattern "\\1" filename))) + (directory-files php-manual-path nil pattern)))) + ;; Replace the entire cache. If the types changed, we don't need + ;; to retain the collection for the previous value. + (setq words-cache (list (cons types-list collection))) + (setq php-search-local-documentation-words-cache words-cache))) + ;; By default we search for (current-word) immediately, without prompting. + ;; With a prefix argument, or if there is no (current-word), we perform a + ;; completing read for a word from the cached collection. + (let* ((default (current-word)) + (prompt (if default + (format "Search PHP docs (%s): " default) + "Search PHP docs: ")) + (collection (and local-manual + (cdr (assq types-list words-cache)))) + (word (if (or current-prefix-arg (not default)) + (completing-read prompt collection nil nil nil nil default) + default))) + ;; Return interactive argument list. + (list word)))) + +(defun php-search-local-documentation (word) + "Search the local PHP documentation (i.e. in `php-manual-path') for +the word at point. The function returns t if the requested documentation +exists, and nil otherwise. + +With a prefix argument, prompt (with completion) for a word to search for." + (interactive (php--search-documentation-read-arg)) + (cl-flet ((php-file-for (type name) + (expand-file-name + (format "%s.%s.html" type + (replace-regexp-in-string + "_" "-" (downcase name))) + php-manual-path)) + (php-file-url (file) + ;; Some browsers require the file:// prefix. + ;; Others do not seem to care. But it should + ;; never be incorrect to use the prefix. + (if (string-prefix-p "file://" file) + file + (concat "file://" file)))) + (let ((file (catch 'found + (loop for type in php-search-local-documentation-types do + (let ((file (php-file-for type word))) + (when (file-exists-p file) + (throw 'found file))))))) + (when file + (php-browse-documentation-url (php-file-url file)) + t)))) + +;; Define function documentation function +(defun php-search-documentation (word) + "Search PHP documentation for the word at point. + +If `php-manual-path' has a non-empty string value then the command +will first try searching the local documentation. If the requested +documentation does not exist it will fallback to searching the PHP +website. + +With a prefix argument, prompt for a documentation word to search +for. If the local documentation is available, it is used to build +a completion list." + (interactive (php--search-documentation-read-arg)) + (cl-flet ((php-search-web-documentation (name) + (php-browse-documentation-url + (concat php-search-url name)))) + (if (and (stringp php-manual-path) + (not (string= php-manual-path ""))) + (or (php-search-local-documentation word) + (php-search-web-documentation word)) + (php-search-web-documentation word)))) + +;; Define function for browsing manual +(defun php-browse-manual () + "Bring up manual for PHP." + (interactive) + (browse-url php-manual-url)) + +(defconst php-font-lock-keywords-1 (c-lang-const c-matchers-1 php) + "Basic highlighting for PHP mode.") + +(defconst php-font-lock-keywords-2 (c-lang-const c-matchers-2 php) + "Medium level highlighting for PHP mode.") + +(defconst php-font-lock-keywords-3 + (append + ;; php-mode patterns *before* cc-mode: + ;; only add patterns here if you want to prevent cc-mode from applying + ;; a different face. + '( + ;; Highlight variables, e.g. 'var' in '$var' and '$obj->var', but + ;; not in $obj->var() + ("->\\(\\sw+\\)\\s-*(" 1 'default) + + ;; Highlight special variables + ("\\$\\(this\\|that\\)" 1 font-lock-constant-face) + ("\\(\\$\\|->\\)\\([a-zA-Z0-9_]+\\)" 2 font-lock-variable-name-face) + + ;; Highlight function/method names + ("\\var', but + ;; not in $obj->var() + ("->\\(\\sw+\\)\\s-*(" 1 'default) + + ("\\(\\$\\|->\\)\\([a-zA-Z0-9_]+\\)" 2 font-lock-variable-name-face) + + ;; Highlight all upper-cased symbols as constant + ("\\<\\([A-Z_][A-Z0-9_]+\\)\\>" 1 font-lock-constant-face) + + ;; Highlight all statically accessed class names as constant, + ;; another valid option would be using type-face, but using + ;; constant-face because this is how it works in c++-mode. + ("\\(\\sw+\\)::" 1 font-lock-constant-face) + + ;; Highlight class name after "use .. as" + ("\\" "")) 0 font-lock-preprocessor-face))) + "Detailed highlighting for PHP mode.") + +(defvar php-font-lock-keywords php-font-lock-keywords-3 + "Default expressions to highlight in PHP mode.") + +;;; Provide support for Flymake so that users can see warnings and +;;; errors in real-time as they write code. + +(defun flymake-php-init () + (let* ((temp-file (flymake-init-create-temp-buffer-copy + 'flymake-create-temp-inplace)) + (local-file (file-relative-name + temp-file + (file-name-directory buffer-file-name)))) + (list php-executable (list "-f" local-file "-l")))) + +(add-to-list 'flymake-allowed-file-name-masks + '("\\.php[345s]?$" + flymake-php-init + flymake-simple-cleanup + flymake-get-real-file-name)) + +(add-to-list 'flymake-err-line-patterns + '("\\(Parse\\|Fatal\\) error: \\(.*?\\) in \\(.*?\\) on line \\([0-9]+\\)" 3 4 nil 2)) + + +(defun php-send-region (start end) + "Send the region between `start' and `end' to PHP for execution. +The output will appear in the buffer *PHP*." + (interactive "r") + (let ((php-buffer (get-buffer-create "*PHP*")) + (code (buffer-substring start end))) + ;; Calling 'php -r' will fail if we send it code that starts with + ;; '\\|::") + (no-front-space "->\\|::")) + (when (and (eq major-mode 'php-mode) + (or (looking-at-p (concat " \\(" no-behind-space "\\)")) + (save-excursion + (forward-char -2) + (looking-at-p no-front-space)))) + (delete-char 1)))) + +(ad-activate 'fixup-whitespace) + +;; Advice `font-lock-fontify-keywords-region' to support namespace +;; separators in class names. Use word syntax for backslashes when +;; doing keyword fontification, but not when doing syntactic +;; fontification because that breaks \ as escape character in strings. +;; +;; Special care is taken to restore the original syntax, because we +;; want \ not to be word for functions like forward-word. +(defadvice font-lock-fontify-keywords-region (around backslash-as-word activate) + "Fontify keywords with backslash as word character" + (let ((old-syntax (string (char-syntax ?\\)))) + (modify-syntax-entry ?\\ "w") + ad-do-it + (modify-syntax-entry ?\\ old-syntax))) + + +;;;###autoload +(dolist (pattern '("\\.php[s345t]?\\'" "\\.phtml\\'" "Amkfile" "\\.amk$")) + (add-to-list 'auto-mode-alist `(,pattern . php-mode) t)) + +(provide 'php-mode) + +;;; php-mode.el ends here diff --git a/.emacs.d/lisp/yasnippet.el b/.emacs.d/lisp/yasnippet.el index fcbce9e..bbfca9c 100644 --- a/.emacs.d/lisp/yasnippet.el +++ b/.emacs.d/lisp/yasnippet.el @@ -1,164 +1,175 @@ -;;; 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/ +;;; yasnippet.el --- Yet another snippet extension for Emacs. + +;; Copyright (C) 2008-2013 Free Software Foundation, Inc. +;; Authors: pluskid , João Távora +;; Maintainer: João Távora +;; Version: 0.8.1 +;; Package-version: 0.8.0 +;; X-URL: http://github.com/capitaomorte/yasnippet ;; Keywords: convenience, emulation -;; URL: http://code.google.com/p/yasnippet/ +;; URL: http://github.com/capitaomorte/yasnippet ;; EmacsWiki: YaSnippetMode -;; This file is free software; you can redistribute it and/or modify +;; This program 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. +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. -;; This file is distributed in the hope that it will be useful, +;; This program 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. +;; along with this program. If not, see . ;;; 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 +;; Basic steps to setup: +;; +;; (add-to-list 'load-path +;; "~/path-to-yasnippet") +;; (require 'yasnippet) +;; (yas-global-mode 1) ;; -;; Steps 4. and 5. are optional, you don't have to use the minor -;; mode to use YASnippet. ;; ;; Interesting variables are: ;; -;; `yas/root-directory' +;; `yas-snippet-dirs' ;; ;; 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. +;; stored. Can also be a list of directories. In that case, +;; when used for bulk (re)loading of snippets (at startup or +;; via `yas-reload-all'), directories appearing earlier in +;; the list shadow other dir's snippets. Also, the first +;; directory is taken as the default for storing the user's +;; new snippets. ;; -;; `yas/mode-symbol' +;; The deprecated `yas/root-directory' aliases this variable +;; for backward-compatibility. ;; -;; 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 +;; 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. +;; Try to expand snippets before point. In `yas-minor-mode', +;; this is normally bound to TAB, but you can customize it in +;; `yas-minor-mode-map'. ;; -;; M-x yas/load-directory +;; M-x yas-load-directory ;; ;; Prompts you for a directory hierarchy of snippets to load. ;; -;; M-x yas/insert-snippet +;; M-x yas-activate-extra-mode +;; +;; Prompts you for an extra mode to add snippets for in the +;; current buffer. +;; +;; 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 +;; M-x yas-visit-snippet-file ;; ;; Prompts you for possible snippet expansions like -;; `yas/insert-snippet', but instead of expanding it, takes +;; `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 +;; M-x yas-new-snippet ;; ;; Lets you create a new snippet file in the correct -;; subdirectory of `yas/root-directory', according to the +;; subdirectory of `yas-snippet-dirs', according to the ;; active major mode. ;; -;; M-x yas/load-snippet-buffer +;; 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 +;; 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: +;; M-x yas-describe-tables +;; +;; Lists known snippets in a separate buffer. User is +;; prompted as to whether only the currently active tables +;; are to be displayed, or all the tables for all major +;; modes. +;; +;; If you have `dropdown-list' installed, you can optionally use it +;; as the preferred "prompting method", putting in your .emacs file, +;; for example: ;; ;; (require 'dropdown-list) -;; (setq yas/prompt-functions '(yas/dropdown-prompt -;; yas/ido-prompt -;; yas/completing-prompt)) +;; (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 +;; `yas-snippet-dirs' 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/ +;; http://github.com/capitaomorte/yasnippet ;;; Code: (require 'cl) -(require 'assoc) +(require 'cl-lib) (require 'easymenu) +(require 'help-mode) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; User customizable variables +(defvar yas--editing-template) +(defvar yas--guessed-modes) +(defvar yas--indent-original-column) +(defvar yas--scheduled-jit-loads) +(defvar yas-keymap) +(defvar yas-selected-text) +(defvar yas-verbosity) +(defvar yas--current-template) + +;;; User customizable variables (defgroup yasnippet nil "Yet Another Snippet extension" + :prefix "yas-" :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'" +(defvar yas-installed-snippets-dir nil) +(setq yas-installed-snippets-dir + (when load-file-name + (concat (file-name-directory load-file-name) "snippets"))) + +(defcustom yas-snippet-dirs (remove nil + (list "~/.emacs.d/snippets" + 'yas-installed-snippets-dir)) + "List of top-level snippet directories. + +Each element, a string or a symbol whose value is a string, +designates a top-level directory where per-mode snippet +directories can be found. + +Elements appearing earlier in the list shadow later elements' +snippets. + +The first directory is taken as the default for storing snippet's +created with `yas-new-snippet'. " :type '(choice (string :tag "Single directory (string)") (repeat :args (string) :tag "List of directories (strings)")) :group 'yasnippet @@ -167,15 +178,43 @@ directories are used for bulk reloading of all snippets using (let ((old (and (boundp symbol) (symbol-value symbol)))) (set-default symbol new) - (unless (or (not (fboundp 'yas/reload-all)) + (unless (or (not (fboundp 'yas-reload-all)) (equal old new)) - (yas/reload-all))))) + (yas-reload-all))))) + +(defun yas-snippet-dirs () + "Return variable `yas-snippet-dirs' as list of strings." + (cl-loop for e in (if (listp yas-snippet-dirs) + yas-snippet-dirs + (list yas-snippet-dirs)) + collect + (cond ((stringp e) e) + ((and (symbolp e) + (boundp e) + (stringp (symbol-value e))) + (symbol-value e)) + (t + (error "[yas] invalid element %s in `yas-snippet-dirs'" e))))) + +(defvaralias 'yas/root-directory 'yas-snippet-dirs) + +(defcustom yas-new-snippet-default "\ +# -*- mode: snippet; require-final-newline: nil -*- +# name: $1 +# key: ${2:${1:$(yas--key-from-desc yas-text)}}${3: +# binding: ${4:direct-keybinding}} +# -- +$0" + "Default snippet to use when creating a new snippet. +If nil, don't use any snippet." + :type 'string + :group 'yasnippet) -(defcustom yas/prompt-functions '(yas/x-prompt - yas/dropdown-prompt - yas/completing-prompt - yas/ido-prompt - yas/no-prompt) +(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: @@ -202,7 +241,7 @@ signal `quit' with :type '(repeat function) :group 'yasnippet) -(defcustom yas/indent-line 'auto +(defcustom yas-indent-line 'auto "Controls indenting applied to a recent snippet expansion. The following values are possible: @@ -211,7 +250,7 @@ The following values are possible: - `auto' Indent each line of the snippet with `indent-according-to-mode' -Every other value means don't apply any snippet-side indendation +Every other value means don't apply any snippet-side indentation after expansion (the manual per-line \"$>\" indentation still applies)." :type '(choice (const :tag "Nothing" nothing) @@ -219,248 +258,217 @@ applies)." (const :tag "Auto" auto)) :group 'yasnippet) -(defcustom yas/also-auto-indent-first-line nil +(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'" +Naturally this is only valid when `yas-indent-line' is `auto'" :type 'boolean :group 'yasnippet) -(defcustom yas/snippet-revival t +(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. +(defcustom yas-triggers-in-field nil + "If non-nil, allow stacked expansions (snippets inside snippets). -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" +Otherwise `yas-next-field-or-maybe-expand' just moves 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. +(defcustom yas-fallback-behavior 'call-other-command + "How to act when `yas-expand' does *not* expand a snippet. - `call-other-command' means try to temporarily disable YASnippet - and call the next command bound to `yas/trigger-key'. + and call the next command bound to whatever key was used to + invoke `yas-expand'. - nil or the symbol `return-nil' mean do nothing. (and - `yas/expand-returns' nil) + `yas-expand' returns nil) -- A lisp form (apply COMMAND . ARGS) means interactively call - COMMAND, if ARGS is non-nil, call COMMAND non-interactively +- 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 +(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'." +This affects `yas-insert-snippet' and `yas-visit-snippet-file'." :type 'boolean :group 'yasnippet) -(defcustom yas/choose-tables-first nil +(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'" +This affects `yas-insert-snippet', `yas-visit-snippet-file'" :type 'boolean :group 'yasnippet) -(defcustom yas/use-menu 'real-modes +(defcustom yas-use-menu 'abbreviate "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. +menu and the modes set in `yas--extra-modes' are listed. + +- If set to `full', every submenu is listed + +- If set to `nil', hide the menu. 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)) + :type '(choice (const :tag "Full" full) + (const :tag "Abbreviate" abbreviate) + (const :tag "No menu" nil)) :group 'yasnippet) -(defcustom yas/trigger-symbol " =>" +(defcustom yas-trigger-symbol (or (and (eq window-system 'mac) + (ignore-errors + (char-to-string ?\x21E5))) ;; little ->| sign + " =>") "The text that will be used in menu to represent the trigger." :type 'string :group 'yasnippet) -(defcustom yas/wrap-around-region nil +(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." +can be overridden on a per-snippet basis." :type 'boolean :group 'yasnippet) -(defcustom yas/good-grace t +(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. +(defcustom yas-visit-from-menu nil + "If non-nil visit snippets's files from menu, instead of expanding them. -This means a snippet without a \"# key:'\ directive wont have a -tab trigger." +This can only work when snippets are loaded from files." :type 'boolean :group 'yasnippet) -(defcustom yas/visit-from-menu nil - "If non-nil visit snippets's files from menu, instead of expanding them. +(defcustom yas-expand-only-for-last-commands nil + "List of `last-command' values to restrict tab-triggering to, or nil. -This cafn only work when snippets are loaded from files." - :type 'boolean +Leave this set at nil (the default) to be able to trigger an +expansion simply by placing the cursor after a valid tab trigger, +using whichever commands. + +Optionally, set this to something like '(self-insert-command) if +you to wish restrict expansion to only happen when the last +letter of the snippet tab trigger was typed immediately before +the trigger key itself." + :type '(repeat function) :group 'yasnippet) -(defface yas/field-highlight-face - '((((class color) (background light)) (:background "DarkSeaGreen1")) - (t (:background "DimGrey"))) +;; Only two faces, and one of them shouldn't even be used... +;; +(defface yas-field-highlight-face + '((t (:inherit 'region))) "The face used to highlight the currently active field of a snippet" :group 'yasnippet) -(defface yas/field-debug-face +(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.") +;;; User-visible variables + +(defvar yas-keymap (let ((map (make-sparse-keymap))) + (define-key map [(tab)] 'yas-next-field-or-maybe-expand) + (define-key map (kbd "TAB") 'yas-next-field-or-maybe-expand) + (define-key map [(shift tab)] 'yas-prev-field) + (define-key map [backtab] 'yas-prev-field) + (define-key map (kbd "C-g") 'yas-abort-snippet) + (define-key map (kbd "C-d") 'yas-skip-and-clear-or-delete-char) + map) + "The active keymap while a snippet expansion is in progress.") + +(defvar yas-key-syntaxes (list "w" "w_" "w_." "w_.()" + #'yas-try-key-from-whitespace) + "Syntaxes and functions to help look for trigger keys before point. + +Each element in this list specifies how to skip buffer positions +backwards and look for the start of a trigger key. + +Each element can be either a string or a function receiving the +original point as an argument. A string element is simply passed +to `skip-syntax-backward' whereas a function element is called +with no arguments and should also place point before the original +position. + +The string between the resulting buffer position and the original +point is matched against the trigger keys in the active snippet +tables. + +If no expandable snippets are found, the next element is the list +is tried, unless a function element returned the symbol `again', +in which case it is called again from the previous position and +may once more reposition point. -(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 \"_\": +For example, if `yas-key-syntaxes'' value is '(\"w\" \"w_\"), +trigger keys composed exclusively of \"word\"-syntax characters +are looked for first. Failing that, longer keys composed of +\"word\" or \"symbol\" syntax are looked for. Therefore, +triggering after foo-bar -will first try \"bar\", if not found, then \"foo-bar\" is tried.") +will, according to the \"w\" element first try \"barbaz\". If +that isn't a trigger key, \"foo-barbaz\" is tried, respecting the +second \"w_\" element. Notice that even if \"baz\" is a trigger +key for an active snippet, it won't be expanded, unless a +function is added to `yas-key-syntaxes' that eventually places +point between \"bar\" and \"baz\". + +See also Info node `(elisp) Syntax Descriptors'.") -(defvar yas/after-exit-snippet-hook +(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-beg' : The beginning of the region of the snippet. -`yas/snippet-end' : Similar to beg. +`yas-snippet-end' : Similar to beg. -Attention: These hooks are not run when exiting nested/stackd snippet expansion!") +Attention: These hooks are not run when exiting nested/stacked snippet expansion!") -(defvar yas/before-expand-snippet-hook +(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)))) +(defvar yas-buffer-local-condition + '(if (and (or (fourth (syntax-ppss)) + (fifth (syntax-ppss))) + this-command + (eq this-command 'yas-expand-from-trigger-key)) '(require-snippet-condition . force-in-comment) t) "Snippet expanding condition. -This variable is a lisp form: +This variable is a Lisp form which is evaluated every time a +snippet expansion is attempted: * If it evaluates to nil, no snippets can be expanded. @@ -471,7 +479,7 @@ This variable is a lisp form: considered * Snippets bearing conditions that evaluate to nil (or - produce an error) won't be onsidered. + produce an error) won't be considered. * If the snippet has a condition that evaluates to non-nil RESULT: @@ -489,7 +497,7 @@ This variable is a lisp form: * 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. + evaluate to non-nil, are considered for expansion. * Otherwise, the snippet is not considered. @@ -500,7 +508,7 @@ conditions. (add-hook 'python-mode-hook '(lambda () - (setq yas/buffer-local-condition + (setq yas-buffer-local-condition '(if (python-in-string/comment) '(require-snippet-condition . force-in-comment) t)))) @@ -509,273 +517,364 @@ 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 +;;; Internal variables -(defvar yas/version "0.6.1b") +(defvar yas--version "0.8.0beta") -(defvar yas/menu-table (make-hash-table) +(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 +(defvar yas--known-modes '(ruby-mode rst-mode markdown-mode) - "A list of mode which is well known but not part of emacs.") + "A list of mode which is well known but not part of Emacs.") -(defvar yas/escaped-characters - '(?\\ ?` ?' ?$ ?} ) +(defvar yas--escaped-characters + '(?\\ ?` ?\" ?' ?$ ?} ?{ ?\( ?\)) "List of characters which *might* need to be escaped.") -(defconst yas/field-regexp +(defconst yas--field-regexp "${\\([0-9]+:\\)?\\([^}]*\\)}" "A regexp to *almost* recognize a field.") -(defconst yas/multi-dollar-lisp-expression-regexp +(defconst yas--multi-dollar-lisp-expression-regexp "$+[ \t\n]*\\(([^)]*)\\)" "A regexp to *almost* recognize a \"$(...)\" expression.") -(defconst yas/backquote-lisp-expression-regexp +(defconst yas--backquote-lisp-expression-regexp "`\\([^`]*\\)`" "A regexp to recognize a \"`lisp-expression`\" expression." ) -(defconst yas/transform-mirror-regexp +(defconst yas--transform-mirror-regexp "${\\(?:\\([0-9]+\\):\\)?$\\([ \t\n]*([^}]*\\)" "A regexp to *almost* recognize a mirror with a transform.") -(defconst yas/simple-mirror-regexp +(defconst yas--simple-mirror-regexp "$\\([0-9]+\\)" "A regexp to recognize a simple mirror.") -(defvar yas/snippet-id-seed 0 +(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) +(defun yas--snippet-next-id () + (let ((id yas--snippet-id-seed)) + (cl-incf yas--snippet-id-seed) id)) -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Minor mode stuff +;;; 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") +(defvar yas--minor-mode-menu nil + "Holds the YASnippet menu.") -(defun yas/init-minor-keymap () +(defvar yas-minor-mode-map (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))) + (define-key map [(tab)] 'yas-expand) + (define-key map (kbd "TAB") 'yas-expand) + (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) + map) + "The keymap used when `yas-minor-mode' is active.") + +(easy-menu-define yas--minor-mode-menu + yas-minor-mode-map + "Menu used when `yas-minor-mode' is active." + '("YASnippet" :visible yas-use-menu + "----" + ["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"] + "----" + ("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 all known modes" (setq yas-use-menu 'full) + :help "Show one snippet submenu for each loaded table" + :active t :style radio :selected (eq yas-use-menu 'full)] + ["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 + yas-prompt-functions))) + :help "Use a normal minibuffer prompt" + :active t :style radio :selected (eq (car yas-prompt-functions) + 'yas-completing-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 elisp in snippets" + :style toggle :selected yas-good-grace] + ) + "----" + ["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 YASnippet"])) + +(defvar yas--extra-modes nil + "An internal list of modes for which to also lookup snippets. + +This variable probably makes more sense as buffer-local, so +ensure your use `make-local-variable' when you set it.") +(define-obsolete-variable-alias 'yas-extra-modes 'yas--extra-modes "0.8.1") + +(defvar yas--tables (make-hash-table) + "A hash table of mode symbols to `yas--table' objects.") + +(defvar yas--parents (make-hash-table) + "A hash table of mode symbols do lists of direct parent mode symbols. + +This list is populated when reading the \".yas-parents\" files +found when traversing snippet directories with +`yas-load-directory'. + +There might be additional parenting information stored in the +`derived-mode-parent' property of some mode symbols, but that is +not recorded here.") + +(defvar yas--direct-keymaps (list) + "Keymap alist supporting direct snippet keybindings. + +This variable is placed in `emulation-mode-map-alists'. + +Its elements looks like (TABLE-NAME . KEYMAP). They're +instantiated on `yas-reload-all' but KEYMAP is added to only when +loading snippets. `yas--direct-TABLE-NAME' is then a variable set +buffer-locally when entering `yas-minor-mode'. KEYMAP binds all +defined direct keybindings to the command +`yas-expand-from-keymap' which then which snippet to expand.") + +(defun yas-direct-keymaps-reload () + "Force reload the direct keybinding for active snippet tables." + (interactive) + (setq yas--direct-keymaps nil) + (maphash #'(lambda (name table) + (push (cons (intern (format "yas--direct-%s" name)) + (yas--table-direct-keymap table)) + yas--direct-keymaps)) + yas--tables)) + +(defun yas--modes-to-activate () + "Compute list of mode symbols that are active for `yas-expand' +and friends." + (let (dfs) + (setq dfs (lambda (mode &optional explored) + (push mode explored) + (cons mode + (loop for neighbour + in (cl-list* (get mode 'derived-mode-parent) + (ignore-errors (symbol-function mode)) + (gethash mode yas--parents)) + when (and neighbour + (not (memq neighbour explored)) + (symbolp neighbour)) + append (funcall dfs neighbour explored))))) + (remove-duplicates (append yas--extra-modes + (funcall dfs major-mode))))) + +(defvar yas-minor-mode-hook nil + "Hook run when `yas-minor-mode' is turned on.") ;;;###autoload -(define-minor-mode yas/minor-mode +(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. +When YASnippet mode is enabled, `yas-expand', normally bound to +the TAB key, expands snippets of code depending on the major +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}" +\\{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 () + (cond (yas-minor-mode + ;; Install the direct keymaps in `emulation-mode-map-alists' + ;; (we use `add-hook' even though it's not technically a hook, + ;; but it works). Then define variables named after modes to + ;; index `yas--direct-keymaps'. + ;; + ;; Also install the post-command-hook. + ;; + (add-hook 'emulation-mode-map-alists 'yas--direct-keymaps) + (add-hook 'post-command-hook 'yas--post-command-handler nil t) + ;; Set the `yas--direct-%s' vars for direct keymap expansion + ;; + (dolist (mode (yas--modes-to-activate)) + (let ((name (intern (format "yas--direct-%s" mode)))) + (set-default name nil) + (set (make-local-variable name) t))) + ;; Perform JIT loads + ;; + (yas--load-pending-jits)) + (t + ;; Uninstall the direct keymaps and the post-command hook + ;; + (remove-hook 'post-command-hook 'yas--post-command-handler t) + (remove-hook 'emulation-mode-map-alists 'yas--direct-keymaps)))) + +(defun yas-activate-extra-mode (mode) + "Activates the snippets for the given `mode' in the buffer. + +The function can be called in the hook of a minor mode to +activate snippets associated with that mode." + (interactive + (let (modes + symbol) + (maphash (lambda (k _) + (setq modes (cons (list k) modes))) + yas--parents) + (setq symbol (completing-read + "Activate mode: " modes nil t)) + (list + (when (not (string= "" symbol)) + (intern symbol))))) + (when mode + (add-to-list (make-local-variable 'yas--extra-modes) mode) + (yas--load-pending-jits))) + +(defun yas-deactivate-extra-mode (mode) + "Deactivates the snippets for the given `mode' in the buffer." + (interactive + (list (intern + (completing-read + "Deactivate mode: " (mapcar #'list yas--extra-modes) nil t)))) + (set (make-local-variable 'yas--extra-modes) + (remove mode + yas--extra-modes))) + +(defvar yas-dont-activate '(minibufferp) + "If non-nil don't let `yas-global-mode' affect some buffers. + +If a function of zero arguments, then its result is used. + +If a list of functions, then all functions must return nil to +activate yas for this buffer. + +In Emacsen <= 23, this variable is buffer-local. Because +`yas-minor-mode-on' is called by `yas-global-mode' after +executing the buffer's major mode hook, setting this variable +there is an effective way to define exceptions to the \"global\" +activation behaviour. + +In Emacsen > 23, only the global value is used. To define +per-mode exceptions to the \"global\" activation behaviour, call +`yas-minor-mode' with a negative argument directily in the major +mode's hook.") +(unless (> emacs-major-version 23) + (with-no-warnings + (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." +Honour `yas-dont-activate', which see." (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)) + ;; Check `yas-dont-activate' + (unless (cond ((functionp yas-dont-activate) + (funcall yas-dont-activate)) + ((consp yas-dont-activate) + (some #'funcall yas-dont-activate)) + (yas-dont-activate)) + (yas-minor-mode 1))) -(define-globalized-minor-mode yas/global-mode yas/minor-mode yas/minor-mode-on +;;;###autoload +(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 +(defun yas--global-mode-reload-with-jit-maybe () + "Run `yas-reload-all' when `yas-global-mode' is on." + (when yas-global-mode (yas-reload-all))) + +(add-hook 'yas-global-mode-hook 'yas--global-mode-reload-with-jit-maybe) + + +;;; 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) @@ -783,13 +882,13 @@ Do this unless `yas/dont-activate' is t or the function ("${\\([0-9]+\\):?" (0 font-lock-keyword-face) (1 font-lock-warning-face t)) - ("${" font-lock-keyword-face) - ("$[0-9]+?" font-lock-preprocessor-face) + ("${" . 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 () +(defvar snippet-mode-map (let ((map (make-sparse-keymap))) (easy-menu-define nil map @@ -799,162 +898,312 @@ Do this unless `yas/dont-activate' is t or the function (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") + '(("Load this snippet" yas-load-snippet-buffer "\C-c\C-l") + ("Load and quit window" yas-load-snippet-buffer-and-close "\C-c\C-c") + ("Try out this snippet" yas-tryout-snippet "\C-c\C-t"))))) + map) + "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)) + (setq font-lock-defaults '(yas--font-lock-keywords)) (set (make-local-variable 'require-final-newline) nil) - (use-local-map snippet-mode-map)) + (set (make-local-variable 'comment-start) "#") + (set (make-local-variable 'comment-start-skip) "#+[\t ]*")) + -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Internal structs for template management + +;;; Internal structs for template management -(defstruct (yas/template (:constructor yas/make-template - (content name condition expand-env file keybinding))) +(defstruct (yas--template (:constructor yas--make-blank-template)) "A template for a snippet." + key 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))) + keybinding + uuid + menu-binding-pair + group ;; as dictated by the #group: directive or .yas-make-groups + perm-group ;; as dictated by `yas-define-menu' + table + ) + +(defun yas--populate-template (template &rest args) + "Helper function to populate TEMPLATE with properties." + (while args + (aset template + (position (intern (substring (symbol-name (car args)) 1)) + (mapcar #'car (get 'yas--template 'cl-struct-slots))) + (second args)) + (setq args (cddr args))) + template) + +(defstruct (yas--table (:constructor yas--make-snippet-table (name))) "A table to store snippets for a particular mode. Has the following fields: -`yas/snippet-table-name' +`yas--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. + A symbol name normally corresponding to a major mode, but can + also be a pseudo major-mode to be used in + `yas-activate-extra-mode', for example. -`yas/snippet-table-hash' +`yas--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. + A hash table (KEY . NAMEHASH), known as the \"keyhash\". KEY is + a string or a vector, where the former is the snippet's trigger + and the latter means it's a direct keybinding. NAMEHASH is yet + another hash of (NAME . TEMPLATE) where NAME is the snippet's + name and TEMPLATE is a `yas--template' object. -`yas/snippet-table-parents' +`yas--table-direct-keymap' - A list of tables considered parents of this table: i.e. when - searching for expansions they are searched as well." + A keymap for the snippets in this table that have direct + keybindings. This is kept in sync with the keyhash, i.e., all + the elements of the keyhash that are vectors appear here as + bindings to `yas-expand-from-keymap'. + +`yas--table-uuidhash' + + A hash table mapping snippets uuid's to the same `yas--template' + objects. A snippet uuid defaults to the snippet's name." name (hash (make-hash-table :test 'equal)) - (parents nil)) + (uuidhash (make-hash-table :test 'equal)) + (parents nil) + (direct-keymap (make-sparse-keymap))) -(defvar yas/better-guess-for-replacements nil - "If non-nil `yas/store' better guess snippet replacements.") +(defun yas--get-template-by-uuid (mode uuid) + "Find the snippet template in MODE by its UUID." + (let* ((table (gethash mode yas--tables mode))) + (when table + (gethash uuid (yas--table-uuidhash table))))) -(defun yas/store (table name key template) - "Store a snippet template in the TABLE." +;; Apropos storing/updating in TABLE, this works in two steps: +;; +;; 1. `yas--remove-template-by-uuid' removes any +;; keyhash-namehash-template mappings from TABLE, grabbing the +;; snippet by its uuid. Also removes mappings from TABLE's +;; `yas--table-direct-keymap' (FIXME: and should probably take care +;; of potentially stale menu bindings right?.) +;; +;; 2. `yas--add-template' adds this all over again. +;; +;; Create a new or add to an existing keyhash-namehash mapping. +;; +;; For reference on understanding this, consider three snippet +;; definitions: +;; +;; A: # name: The Foo +;; # key: foo +;; # binding: C-c M-l +;; +;; B: # name: Mrs Foo +;; # key: foo +;; +;; C: # name: The Bar +;; # binding: C-c M-l +;; +;; D: # name: Baz +;; # key: baz +;; +;; keyhash namehashes(3) yas--template structs(4) +;; ----------------------------------------------------- +;; __________ +;; / \ +;; "foo" ---> "The Foo" ---> [yas--template A] | +;; "Mrs Foo" ---> [yas--template B] | +;; | +;; [C-c M-l] ---> "The Foo" -------------------------/ +;; "The Bar" ---> [yas--template C] +;; +;; "baz" ---> "Baz" ---> [yas--template D] +;; +;; Additionally, since uuid defaults to the name, we have a +;; `yas--table-uuidhash' for TABLE +;; +;; uuidhash yas--template structs +;; ------------------------------- +;; "The Foo" ---> [yas--template A] +;; "Mrs Foo" ---> [yas--template B] +;; "The Bar" ---> [yas--template C] +;; "Baz" ---> [yas--template D] +;; +;; FIXME: the more I look at this data-structure the more I think I'm +;; stupid. There has to be an easier way (but beware lots of code +;; depends on this). +;; +(defun yas--remove-template-by-uuid (table uuid) + "Remove from TABLE a template identified by UUID." + (let ((template (gethash uuid (yas--table-uuidhash table)))) + (when template + (let* ((name (yas--template-name template)) + (empty-keys nil)) + ;; Remove the name from each of the targeted namehashes + ;; + (maphash #'(lambda (k v) + (let ((template (gethash name v))) + (when (and template + (eq uuid (yas--template-uuid template))) + (remhash name v) + (when (zerop (hash-table-count v)) + (push k empty-keys))))) + (yas--table-hash table)) + ;; Remove the namehash themselves if they've become empty + ;; + (dolist (key empty-keys) + (when (vectorp key) + (define-key (yas--table-direct-keymap table) key nil)) + (remhash key (yas--table-hash 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'. + ;; Finally, remove the uuid from the uuidhash + ;; + (remhash uuid (yas--table-uuidhash table)))))) + +(defun yas--add-template (table template) + "Store in TABLE the snippet template TEMPLATE. + +KEY can be a string (trigger key) of a vector (direct +keybinding)." + (let ((name (yas--template-name template)) + (key (yas--template-key template)) + (keybinding (yas--template-keybinding template)) + (_menu-binding-pair (yas--template-menu-binding-pair-get-create template))) + (dolist (k (remove nil (list key keybinding))) + (puthash name + template + (or (gethash k + (yas--table-hash table)) + (puthash k + (make-hash-table :test 'equal) + (yas--table-hash table)))) + (when (vectorp k) + (define-key (yas--table-direct-keymap table) k 'yas-expand-from-keymap))) + + ;; Update TABLE's `yas--table-uuidhash' + (puthash (yas--template-uuid template) + template + (yas--table-uuidhash table)))) + +(defun yas--update-template (table template) + "Add or update TEMPLATE in TABLE. + +Also takes care of adding and updating to the associated menu." + ;; Remove from table by uuid ;; - ;; * If that returns nothing, oh well... + (yas--remove-template-by-uuid table (yas--template-uuid template)) + ;; Add to table again ;; - (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. + (yas--add-template table template) + ;; Take care of the menu ;; - (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)) + (yas--update-template-menu table template)) + +(defun yas--update-template-menu (table template) + "Update every menu-related for TEMPLATE." + (let ((menu-binding-pair (yas--template-menu-binding-pair-get-create template)) + (key (yas--template-key template)) + (keybinding (yas--template-keybinding template))) + ;; The snippet might have changed name or keys, so update + ;; user-visible strings + ;; + (unless (eq (cdr menu-binding-pair) :none) + ;; the menu item name + ;; + (setf (cadar menu-binding-pair) (yas--template-name template)) + ;; the :keys information (also visible to the user) + (setf (getf (cdr (car menu-binding-pair)) :keys) + (or (and keybinding (key-description keybinding)) + (and key (concat key yas-trigger-symbol)))))) + (unless (yas--template-menu-managed-by-yas-define-menu template) + (let ((menu-keymap + (yas--menu-keymap-get-create (yas--table-mode table) + (mapcar #'yas--table-mode + (yas--table-parents table)))) + (group (yas--template-group template))) + ;; Remove from menu keymap + ;; + (assert menu-keymap) + (yas--delete-from-keymap menu-keymap (yas--template-uuid template)) + + ;; Add necessary subgroups as necessary. + ;; + (dolist (subgroup group) + (let ((subgroup-keymap (lookup-key menu-keymap (vector (make-symbol subgroup))))) + (unless (and subgroup-keymap + (keymapp subgroup-keymap)) + (setq subgroup-keymap (make-sparse-keymap)) + (define-key menu-keymap (vector (make-symbol subgroup)) + `(menu-item ,subgroup ,subgroup-keymap))) + (setq menu-keymap subgroup-keymap))) + + ;; Add this entry to the keymap + ;; + (define-key menu-keymap + (vector (make-symbol (yas--template-uuid template))) + (car (yas--template-menu-binding-pair template)))))) + +(defun yas--namehash-templates-alist (namehash) + "Return NAMEHASH as an alist." + (let (alist) + (maphash #'(lambda (k v) + (push (cons k v) alist)) + namehash) + alist)) + +(defun yas--fetch (table key) + "Fetch templates in TABLE by KEY. + +Return a list of cons (NAME . TEMPLATE) where NAME is a +string and TEMPLATE is a `yas--template' structure." + (let* ((keyhash (yas--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))))) + (yas--filter-templates-by-condition (yas--namehash-templates-alist namehash))))) -;; Filtering/condition logic +;;; Filtering/condition logic -(defun yas/eval-condition (condition) +(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))) + (yas--message 1 "Error in condition evaluation: %s" (error-message-string err)) nil)))) -(defun yas/filter-templates-by-condition (templates) +(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. +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))) +`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)) + (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 +(defun yas--require-template-specific-condition-p () + "Decide if this buffer requests/requires snippet-specific conditions to filter out potential expansions." - (if (eq 'always yas/buffer-local-condition) + (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))) + (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 @@ -963,207 +1212,229 @@ conditions to filter out potential expansions." (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)))))) +(defun yas--template-can-expand-p (condition requirement) + "Evaluate CONDITION and REQUIREMENT and return a boolean." + (let* ((result (or (null condition) + (yas--eval-condition condition)))) (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) +(defun yas--table-templates (table) (when table (let ((acc (list))) - (maphash #'(lambda (key namehash) + (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))) + (yas--table-hash table)) + (yas--filter-templates-by-condition acc)))) + +(defun yas--templates-for-key-at-point () + "Find `yas--template' objects for any trigger keys preceding point. +Returns (TEMPLATES START END). This function respects +`yas-key-syntaxes', which see." + (save-excursion + (let ((original (point)) + (methods yas-key-syntaxes) + (templates) + (method)) + (while (and methods + (not templates)) + (unless (eq method (car methods)) + ;; TRICKY: `eq'-ness test means we can only be here if + ;; `method' is a function that returned `again', and hence + ;; don't revert back to original position as per + ;; `yas-key-syntaxes'. + (goto-char original)) + (setq method (car methods)) + (cond ((stringp method) + (skip-syntax-backward method) + (setq methods (cdr methods))) + ((functionp method) + (unless (eq (funcall method original) + 'again) + (setq methods (cdr methods)))) + (t + (yas--warning "Warning invalid element %s in `yas-key-syntaxes'" method))) + (let ((possible-key (buffer-substring-no-properties (point) original))) + (save-excursion + (goto-char original) + (setq templates + (mapcan #'(lambda (table) + (yas--fetch table possible-key)) + (yas--get-snippet-tables)))))) + (when templates + (list templates (point) original))))) + +(defun yas--table-all-keys (table) + "Get trigger keys of all active snippets in TABLE." + (let ((acc)) + (maphash #'(lambda (key namehash) + (when (yas--filter-templates-by-condition (yas--namehash-templates-alist namehash)) + (push key acc))) + (yas--table-hash table)) + acc)) + +(defun yas--table-mode (table) + (intern (yas--table-name table))) -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; 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." +;;; Internal functions and macros: + +(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 judgment." (or (fboundp mode) - (find mode yas/known-modes))) + (find mode yas--known-modes))) + +(defun yas--handle-error (err) + "Handle error depending on value of `yas-good-grace'." + (let ((msg (yas--format "elisp error: %s" (error-message-string err)))) + (if yas-good-grace msg + (error "%s" msg)))) -(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 +(defun yas--eval-lisp (form) + "Evaluate FORM 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)))) + (let ((result (eval form))) (when result (format "%s" result)))))) - (error (if yas/good-grace - "[yas] elisp error!" - (error (format "[yas] elisp error: %s" - (error-message-string err))))))))) + (error (yas--handle-error err)))))) (when (and (consp retval) - (eq 'yas/exception (car 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--eval-lisp-no-saves (form) + (condition-case err + (eval form) + (error (message "%s" (yas--handle-error err))))) -(defun yas/snippet-table-get-create (mode) - "Get the snippet table corresponding to MODE. +(defun yas--read-lisp (string &optional nil-on-error) + "Read STRING as a elisp expression and return it. -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." +In case STRING in an invalid expression and NIL-ON-ERROR is nil, +return an expression that when evaluated will issue an error." + (condition-case err + (read string) + (error (and (not nil-on-error) + `(error (error-message-string ,err)))))) + +(defun yas--read-keybinding (keybinding) + "Read KEYBINDING as a snippet keybinding, return a vector." + (when (and keybinding + (not (string-match "keybinding" keybinding))) + (condition-case err + (let ((res (or (and (string-match "^\\[.*\\]$" keybinding) + (read keybinding)) + (read-kbd-macro keybinding 'need-vector)))) + res) + (error + (yas--message 3 "warning: keybinding \"%s\" invalid since %s." + keybinding (error-message-string err)) + nil)))) + +(defun yas--table-get-create (mode) + "Get or create the snippet table corresponding to MODE." (let ((table (gethash mode - yas/snippet-tables))) + yas--tables))) (unless table - (setq table (yas/make-snippet-table (symbol-name mode))) - (puthash mode table yas/snippet-tables)) + (setq table (yas--make-snippet-table (symbol-name mode))) + (puthash mode table yas--tables) + (push (cons (intern (format "yas--direct-%s" mode)) + (yas--table-direct-keymap table)) + yas--direct-keymaps)) table)) -(defun yas/get-snippet-tables (&optional mode-symbol dont-search-parents) +(defun yas--get-snippet-tables () "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))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +Return a list of `yas--table' objects. The list of modes to +consider is returned by `yas--modes-to-activate'" + (remove nil + (mapcar #'(lambda (name) + (gethash name yas--tables)) + (yas--modes-to-activate)))) + +(defun yas--menu-keymap-get-create (mode &optional parents) + "Get or create the menu keymap for MODE and its PARENTS. + +This may very well create a plethora of menu keymaps and arrange +them all in `yas--menu-table'" + (let* ((menu-keymap (or (gethash mode yas--menu-table) + (puthash mode (make-sparse-keymap) yas--menu-table)))) + (mapc #'yas--menu-keymap-get-create parents) + (define-key yas--minor-mode-menu (vector mode) + `(menu-item ,(symbol-name mode) ,menu-keymap + :visible (yas--show-menu-p ',mode))) + menu-keymap)) + + +(defmacro yas--called-interactively-p (&optional kind) + "A backward-compatible version of `called-interactively-p'. + +Optional KIND is as documented at `called-interactively-p' +in GNU Emacs 24.1 or higher." + (if (string< emacs-version "24.1") + '(called-interactively-p) + `(called-interactively-p ,kind))) + + ;;; Template-related and snippet loading functions -(defun yas/parse-template (&optional file) +(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. +Optional GROUP is the group where the template is to go, +otherwise we attempt to calculate it from FILE. + Return a snippet-definition, i.e. a list - (KEY TEMPLATE NAME CONDITION GROUP VARS FILE KEYBINDING) + (KEY TEMPLATE NAME CONDITION GROUP VARS FILE KEYBINDING UUID) -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: +If the buffer contains a line of \"# --\" then the contents above +this line are ignored. Directives can set most of these with the syntax: -#name : value +# directive-name : directive-value -Here's a list of currently recognized variables: +Here's a list of currently recognized directives: + * type * name * contributor * condition - * key * group + * key * expand-env - -#name: #include \"...\" -# -- -#include \"$1\"" - ;; - ;; + * binding + * uuid" (goto-char (point-min)) - (let* ((name (and file + (let* ((type 'snippet) + (name (and file (file-name-nondirectory file))) - (key (unless yas/ignore-filenames-as-triggers - (and name - (file-name-sans-extension name)))) + (key nil) template bound condition (group (and file - (yas/calculate-group file))) + (yas--calculate-group file))) expand-env - binding) + binding + uuid) (if (re-search-forward "^# --\n" nil t) (progn (setq template (buffer-substring-no-properties (point) @@ -1171,23 +1442,36 @@ Here's a list of currently recognized variables: (setq bound (point)) (goto-char (point-min)) (while (re-search-forward "^# *\\([^ ]+?\\) *: *\\(.*\\)$" bound t) + (when (string= "uuid" (match-string-no-properties 1)) + (setq uuid (match-string-no-properties 2))) + (when (string= "type" (match-string-no-properties 1)) + (setq type (if (string= "command" (match-string-no-properties 2)) + 'command + 'snippet))) + (when (string= "key" (match-string-no-properties 1)) + (setq key (match-string-no-properties 2))) (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))) + (setq condition (yas--read-lisp (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))) + (setq expand-env (yas--read-lisp (match-string-no-properties 2) + 'nil-on-error))) (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) + (unless (or key binding) + (setq key (and file (file-name-nondirectory file)))) + (when (eq type 'command) + (setq template (yas--read-lisp (concat "(progn" template ")")))) + (when group + (setq group (split-string group "\\."))) + (list key template name condition group expand-env file binding uuid))) + +(defun yas--calculate-group (file) "Calculate the group for snippet file path FILE." (let* ((dominating-dir (locate-dominating-file file ".yas-make-groups")) @@ -1204,261 +1488,448 @@ Here's a list of currently recognized variables: (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?." +(defun yas--subdirs (directory &optional filep) + "Return subdirs or files of DIRECTORY according to FILEP." (remove-if (lambda (file) (or (string-match "^\\." (file-name-nondirectory file)) + (string-match "^#.*#$" + (file-name-nondirectory file)) (string-match "~$" (file-name-nondirectory file)) - (if file? + (if filep (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--make-menu-binding (template) + (let ((mode (yas--table-mode (yas--template-table template)))) + `(lambda () (interactive) (yas--expand-or-visit-from-menu ',mode ,(yas--template-uuid template))))) + +(defun yas--expand-or-visit-from-menu (mode uuid) + (let* ((table (yas--table-get-create mode)) + (yas--current-template (and table + (gethash uuid (yas--table-uuidhash table))))) + (when yas--current-template + (if yas-visit-from-menu + (yas--visit-snippet-file-1 yas--current-template) + (let ((where (if (region-active-p) + (cons (region-beginning) (region-end)) + (cons (point) (point))))) + (yas-expand-snippet (yas--template-content yas--current-template) + (car where) + (cdr where) + (yas--template-expand-env yas--current-template))))))) + +(defun yas--key-from-desc (text) + "Return a yasnippet key from a description string TEXT." + (replace-regexp-in-string "\\(\\w+\\).*" "\\1" text)) -(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 -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Popping up for keys and templates -;; -(defun yas/prompt-for-template (templates &optional prompt) +(defun yas--prompt-for-template (templates &optional prompt) "Interactively choose a template from the list TEMPLATES. -TEMPLATES is a list of `yas/template'." +TEMPLATES is a list of `yas--template'. + +Optional PROMPT sets the prompt to use." (when templates + (setq templates + (sort templates #'(lambda (t1 t2) + (< (length (yas--template-name t1)) + (length (yas--template-name t2)))))) (some #'(lambda (fn) (funcall fn (or prompt "Choose a snippet: ") templates - #'yas/template-name)) - yas/prompt-functions))) + #'yas--template-name)) + yas-prompt-functions))) -(defun yas/prompt-for-keys (keys &optional prompt) - "Interactively choose a template key from the list KEYS." +(defun yas--prompt-for-keys (keys &optional prompt) + "Interactively choose a template key from the list KEYS. + +Optional PROMPT sets the prompt to use." (when keys (some #'(lambda (fn) (funcall fn (or prompt "Choose a snippet key: ") keys)) - yas/prompt-functions))) + yas-prompt-functions))) + +(defun yas--prompt-for-table (tables &optional prompt) + "Interactively choose a table from the list TABLES. -(defun yas/prompt-for-table (tables &optional prompt) +Optional PROMPT sets the prompt to use." (when tables (some #'(lambda (fn) (funcall fn (or prompt "Choose a snippet table: ") tables - #'yas/snippet-table-name)) - yas/prompt-functions))) + #'yas--table-name)) + yas-prompt-functions))) -(defun yas/x-prompt (prompt choices &optional display-fn) +(defun yas-x-prompt (prompt choices &optional display-fn) + "Display choices in a x-window prompt." (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) + (or + (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) + `(,prompt ("title" + ,@(mapcar* (lambda (c d) `(,(concat " " d) . ,c)) + choices + (if display-fn (mapcar display-fn choices) choices))))) + (keyboard-quit)))) + +(defun yas-ido-prompt (prompt choices &optional display-fn) + (when (and (fboundp 'ido-completing-read) + (or (>= emacs-major-version 24) + ido-mode)) + (yas-completing-prompt prompt choices display-fn #'ido-completing-read))) + +(defun yas-dropdown-prompt (_prompt choices &optional display-fn) + (when (fboundp 'dropdown-list) + (let* ((formatted-choices + (if display-fn (mapcar display-fn choices) choices)) + (n (dropdown-list formatted-choices))) + (if n (nth n choices) + (keyboard-quit))))) + +(defun yas-completing-prompt (prompt choices &optional display-fn completion-fn) + (let* ((formatted-choices + (if display-fn (mapcar display-fn choices) choices)) + (chosen (funcall (or completion-fn #'completing-read) + prompt formatted-choices + nil 'require-match nil nil))) + (if (eq choices formatted-choices) + chosen + (nth (or (position chosen formatted-choices :test #'string=) 0) + choices)))) + +(defun yas-no-prompt (_prompt choices &optional _display-fn) (first choices)) -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Loading snippets from files + +;;; Defining snippets +;; This consists of creating and registering `yas--template' objects in the +;; correct tables. ;; -(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 +(defvar yas--creating-compiled-snippets nil) + +(defun yas--define-snippets-1 (snippet snippet-table) + "Helper for `yas-define-snippets'." + ;; X) Calculate some more defaults on the values returned by + ;; `yas--parse-template'. ;; - (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 + (let* ((file (seventh snippet)) + (key (car snippet)) + (name (or (third snippet) + (and file + (file-name-directory file)))) + (condition (fourth snippet)) + (group (fifth snippet)) + (keybinding (yas--read-keybinding (eighth snippet))) + (uuid (or (ninth snippet) + name)) + (template (or (gethash uuid (yas--table-uuidhash snippet-table)) + (yas--make-blank-template)))) + ;; X) populate the template object ;; - (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.... + (yas--populate-template template + :table snippet-table + :key key + :content (second snippet) + :name (or name key) + :group group + :condition condition + :expand-env (sixth snippet) + :file (seventh snippet) + :keybinding keybinding + :uuid uuid) + ;; X) Update this template in the appropriate table. This step + ;; also will take care of adding the key indicators in the + ;; templates menu entry, if any ;; - (setf (cdr yas/minor-mode-map) - (cdr (yas/init-minor-keymap))) + (yas--update-template snippet-table template) + ;; X) Return the template + ;; + ;; + template)) - ;; Now, clean up the other keymaps we might have cluttered up. - (yas/kill-snippet-keybindings) +(defun yas-define-snippets (mode snippets) + "Define SNIPPETS for MODE. - (when reset-root-directory - (setq yas/root-directory nil)) +SNIPPETS is a list of snippet definitions, each taking the +following form - ;; 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)) + (KEY TEMPLATE NAME CONDITION GROUP EXPAND-ENV FILE KEYBINDING UUID) + +Within these, only KEY and TEMPLATE are actually mandatory. + +TEMPLATE might be a Lisp form or a string, depending on whether +this is a snippet or a snippet-command. + +CONDITION, EXPAND-ENV and KEYBINDING are Lisp forms, they have +been `yas--read-lisp'-ed and will eventually be +`yas--eval-lisp'-ed. + +The remaining elements are strings. + +FILE is probably of very little use if you're programatically +defining snippets. + +UUID is the snippet's \"unique-id\". Loading a second snippet +file with the same uuid would replace the previous snippet. + +You can use `yas--parse-template' to return such lists based on +the current buffers contents." + (if yas--creating-compiled-snippets + (progn + (insert ";;; Snippet definitions:\n;;;\n") + (let ((literal-snippets (list)) + (print-length nil)) + (dolist (snippet snippets) + (let ((key (nth 0 snippet)) + (template-content (nth 1 snippet)) + (name (nth 2 snippet)) + (condition (nth 3 snippet)) + (group (nth 4 snippet)) + (expand-env (nth 5 snippet)) + (file nil) ;; omit on purpose + (binding (nth 7 snippet)) + (uuid (nth 8 snippet))) + (push `(,key + ,template-content + ,name + ,condition + ,group + ,expand-env + ,file + ,binding + ,uuid) + literal-snippets))) + (insert (pp-to-string + `(yas-define-snippets ',mode ',literal-snippets))) + (insert "\n\n"))) + ;; Normal case. + (let ((snippet-table (yas--table-get-create mode)) + (template nil)) + (dolist (snippet snippets) + (setq template (yas--define-snippets-1 snippet + snippet-table))) + template))) - (message "[yas] Reloading everything... Done."))) + +;;; Loading snippets from files + +(defun yas--load-yas-setup-file (file) + (if (not yas--creating-compiled-snippets) + ;; Normal case. + (load file 'noerror) + (let ((elfile (concat file ".el"))) + (when (file-exists-p elfile) + (insert ";;; .yas-setup.el support file if any:\n;;;\n") + (insert-file-contents elfile) + (goto-char (point-max)))))) + +(defun yas--define-parents (mode parents) + "Add PARENTS to the list of MODE's parents." + (puthash mode (remove-duplicates + (append parents + (gethash mode yas--parents))) + yas--parents)) + +(defun yas-load-directory (top-level-dir &optional use-jit interactive) + "Load snippets in directory hierarchy TOP-LEVEL-DIR. + +Below TOP-LEVEL-DIR each directory should be a mode name. + +With prefix argument USE-JIT do jit-loading of snippets." + (interactive + (list (read-directory-name "Select the root directory: " nil nil t) + current-prefix-arg t)) + (unless yas-snippet-dirs + (setq yas-snippet-dirs top-level-dir)) + (let ((impatient-buffers)) + (dolist (dir (yas--subdirs top-level-dir)) + (let* ((major-mode-and-parents (yas--compute-major-mode-and-parents + (concat dir "/dummy"))) + (mode-sym (car major-mode-and-parents)) + (parents (cdr major-mode-and-parents))) + ;; Attention: The parents and the menus are already defined + ;; here, even if the snippets are later jit-loaded. + ;; + ;; * We need to know the parents at this point since entering a + ;; given mode should jit load for its parents + ;; immediately. This could be reviewed, the parents could be + ;; discovered just-in-time-as well + ;; + ;; * We need to create the menus here to support the `full' + ;; option to `yas-use-menu' (all known snippet menus are shown to the user) + ;; + (yas--define-parents mode-sym parents) + (yas--menu-keymap-get-create mode-sym) + (let ((fun `(lambda () ;; FIXME: Simulating lexical-binding. + (yas--load-directory-1 ',dir ',mode-sym)))) + (if use-jit + (yas--schedule-jit mode-sym fun) + (funcall fun))) + ;; Look for buffers that are already in `mode-sym', and so + ;; need the new snippets immediately... + ;; + (when use-jit + (cl-loop for buffer in (buffer-list) + do (with-current-buffer buffer + (when (eq major-mode mode-sym) + (yas--message 3 "Discovered there was already %s in %s" buffer mode-sym) + (push buffer impatient-buffers))))))) + ;; ...after TOP-LEVEL-DIR has been completely loaded, call + ;; `yas--load-pending-jits' in these impatient buffers. + ;; + (cl-loop for buffer in impatient-buffers + do (with-current-buffer buffer (yas--load-pending-jits)))) + (when interactive + (yas--message 3 "Loaded snippets from %s." top-level-dir))) -(defun yas/quote-string (string) +(defun yas--load-directory-1 (directory mode-sym) + "Recursively load snippet templates from DIRECTORY." + (if yas--creating-compiled-snippets + (let ((output-file (expand-file-name ".yas-compiled-snippets.el" + directory))) + (with-temp-file output-file + (insert (format ";;; Compiled snippets and support files for `%s'\n" + mode-sym)) + (yas--load-directory-2 directory mode-sym) + (insert (format ";;; Do not edit! File generated at %s\n" + (current-time-string))))) + ;; Normal case. + (unless (file-exists-p (concat directory "/" ".yas-skip")) + (if (and (progn (yas--message 2 "Loading compiled snippets from %s" directory) t) + (load (expand-file-name ".yas-compiled-snippets" directory) 'noerror (<= yas-verbosity 3))) + (yas--message 2 "Loading snippet files from %s" directory) + (yas--load-directory-2 directory mode-sym))))) + +(defun yas--load-directory-2 (directory mode-sym) + ;; Load .yas-setup.el files wherever we find them + ;; + (yas--load-yas-setup-file (expand-file-name ".yas-setup" directory)) + (let* ((default-directory directory) + (snippet-defs nil)) + ;; load the snippet files + ;; + (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)))) + (when snippet-defs + (yas-define-snippets mode-sym + snippet-defs)) + ;; now recurse to a lower level + ;; + (dolist (subdir (yas--subdirs directory)) + (yas--load-directory-2 subdir + mode-sym)))) + +(defun yas--load-snippet-dirs (&optional nojit) + "Reload the directories listed in `yas-snippet-dirs' or +prompt the user to select one." + (let (errors) + (if yas-snippet-dirs + (dolist (directory (reverse (yas-snippet-dirs))) + (cond ((file-directory-p directory) + (yas-load-directory directory (not nojit)) + (if nojit + (yas--message 3 "Loaded %s" directory) + (yas--message 3 "Prepared just-in-time loading for %s" directory))) + (t + (push (yas--message 0 "Check your `yas-snippet-dirs': %s is not a directory" directory) errors)))) + (call-interactively 'yas-load-directory)) + errors)) + +(defun yas-reload-all (&optional no-jit interactive) + "Reload all snippets and rebuild the YASnippet menu. + +When NO-JIT is non-nil force immediate reload of all known +snippets under `yas-snippet-dirs', otherwise use just-in-time +loading. + +When called interactively, use just-in-time loading when given a +prefix argument." + (interactive (list (not current-prefix-arg) t)) + (catch 'abort + (let ((errors) + (snippet-editing-buffers + (remove-if-not #'(lambda (buffer) + (with-current-buffer buffer yas--editing-template)) + (buffer-list)))) + ;; Warn if there are buffers visiting snippets, since reloading will break + ;; any on-line editing of those buffers. + ;; + (when snippet-editing-buffers + (if interactive + (if (y-or-n-p "Some buffers editing live snippets, close them and proceed with reload? ") + (mapc #'kill-buffer snippet-editing-buffers) + (yas--message 1 "Aborted reload...") + (throw 'abort nil)) + ;; in a non-interactive use, at least set + ;; `yas--editing-template' to nil, make it guess it next time around + (mapc #'(lambda (buffer) + (with-current-buffer buffer + (kill-local-variable 'yas--editing-template))) + (buffer-list)))) + + ;; Empty all snippet tables and parenting info + ;; + (setq yas--tables (make-hash-table)) + (setq yas--parents (make-hash-table)) + + ;; Before killing `yas--menu-table' use its keys to cleanup the + ;; mode menu parts of `yas--minor-mode-menu' (thus also cleaning + ;; up `yas-minor-mode-map', which points to it) + ;; + (maphash #'(lambda (menu-symbol _keymap) + (define-key yas--minor-mode-menu (vector menu-symbol) nil)) + yas--menu-table) + ;; Now empty `yas--menu-table' as well + (setq yas--menu-table (make-hash-table)) + + ;; Cancel all pending 'yas--scheduled-jit-loads' + ;; + (setq yas--scheduled-jit-loads (make-hash-table)) + + ;; Reload the directories listed in `yas-snippet-dirs' or prompt + ;; the user to select one. + ;; + (setq errors (yas--load-snippet-dirs no-jit)) + ;; Reload the direct keybindings + ;; + (yas-direct-keymaps-reload) + + (run-hooks 'yas-after-reload-hook) + (yas--message 3 "Reloaded everything%s...%s." + (if no-jit "" " (snippets will load just-in-time)") + (if errors " (some errors, check *Messages*)" ""))))) + +(defvar yas-after-reload-hook nil + "Hooks run after `yas-reload-all'.") + +(defun yas--load-pending-jits () + (dolist (mode (yas--modes-to-activate)) + (let ((funs (reverse (gethash mode yas--scheduled-jit-loads)))) + ;; must reverse to maintain coherence with `yas-snippet-dirs' + (dolist (fun funs) + (yas--message 3 "Loading for `%s', just-in-time: %s!" mode fun) + (funcall fun)) + (remhash mode yas--scheduled-jit-loads)))) + +;; (when (<= emacs-major-version 22) +;; (add-hook 'after-change-major-mode-hook 'yas--load-pending-jits)) + +(defun yas--quote-string (string) "Escape and quote STRING. foo\"bar\\! -> \"foo\\\"bar\\\\!\"" (concat "\"" @@ -1467,745 +1938,868 @@ foo\"bar\\! -> \"foo\\\"bar\\\\!\"" string t) "\"")) -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; Yasnippet Bundle + +;;; Snippet compilation function -(defun yas/initialize () - "For backward compatibility, enable `yas/minor-mode' globally" - (yas/global-mode 1)) +(defun yas-compile-directory (top-level-dir) + "Create .yas-compiled-snippets.el files under subdirs of TOP-LEVEL-DIR. -(defun yas/compile-bundle - (&optional yasnippet yasnippet-bundle snippet-roots code dropdown) - "Compile snippets in SNIPPET-ROOTS to a single bundle file. +This works by stubbing a few functions, then calling +`yas-load-directory'." + (interactive "DTop level snippet directory?") + (let ((yas--creating-compiled-snippets t)) + (yas-load-directory top-level-dir nil))) -YASNIPPET is the yasnippet.el file path. +(defun yas-recompile-all () + "Compile every dir in `yas-snippet-dirs'." + (interactive) + (mapc #'yas-compile-directory (yas-snippet-dirs))) -YASNIPPET-BUNDLE is the output file of the compile result. -SNIPPET-ROOTS is a list of root directories that contains the -snippets definition. +;;; JIT loading +;;; -CODE is the code to be placed at the end of the generated file -and that can initialize the YASnippet bundle. +(defvar yas--scheduled-jit-loads (make-hash-table) + "Alist of mode-symbols to forms to be evaled when `yas-minor-mode' kicks in.") -Last optional argument DROPDOWN is the filename of the -dropdown-list.el library. +(defun yas--schedule-jit (mode fun) + (push fun (gethash mode yas--scheduled-jit-loads))) -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 () +(defun yas-about () (interactive) (message (concat "yasnippet (version " - yas/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) + +;;; Apropos snippet menu: +;; +;; The snippet menu keymaps are store by mode in hash table called +;; `yas--menu-table'. They are linked to the main menu in +;; `yas--menu-keymap-get-create' and are initially created empty, +;; reflecting the table hierarchy. +;; +;; They can be populated in two mutually exclusive ways: (1) by +;; reading `yas--template-group', which in turn is populated by the "# +;; group:" directives of the snippets or the ".yas-make-groups" file +;; or (2) by using a separate `yas-define-menu' call, which declares a +;; menu structure based on snippets uuids. +;; +;; Both situations are handled in `yas--update-template-menu', which +;; uses the predicate `yas--template-menu-managed-by-yas-define-menu' +;; that can tell between the two situations. +;; +;; Note: +;; +;; * if `yas-define-menu' is used it must run before +;; `yas-define-snippets' and the UUIDS must match, otherwise we get +;; duplicate entries. The `yas--template' objects are created in +;; `yas-define-menu', holding nothing but the menu entry, +;; represented by a pair of ((menu-item NAME :keys KEYS) TYPE) and +;; stored in `yas--template-menu-binding-pair'. The (menu-item ...) +;; part is then stored in the menu keymap itself which make the item +;; appear to the user. These limitations could probably be revised. +;; +;; * The `yas--template-perm-group' slot is only used in +;; `yas-describe-tables'. +;; +(defun yas--template-menu-binding-pair-get-create (template &optional type) + "Get TEMPLATE's menu binding or assign it a new one. + +TYPE may be `:stay', signaling this menu binding should be +static in the menu." + (or (yas--template-menu-binding-pair template) + (let (;; (key (yas--template-key template)) + ;; (keybinding (yas--template-keybinding template)) + ) + (setf (yas--template-menu-binding-pair template) + (cons `(menu-item ,(or (yas--template-name template) + (yas--template-uuid template)) + ,(yas--make-menu-binding template) + :keys ,nil) + type))))) +(defun yas--template-menu-managed-by-yas-define-menu (template) + "Non-nil if TEMPLATE's menu entry was included in a `yas-define-menu' call." + (cdr (yas--template-menu-binding-pair template))) + + +(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))) + (yas--table-mode table)) + (yas--get-snippet-tables)))) + (yas-use-menu t))) -(defun yas/delete-from-keymap (keymap name) - "Recursively delete items name NAME from KEYMAP and its submenus. +(defun yas--delete-from-keymap (keymap uuid) + "Recursively delete items with UUID from KEYMAP and its submenus." -Skip any submenus named \"parent mode\"" + ;; XXX: This used to 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))) + (when (and (listp (cdr item)) + (keymapp (third (cdr item)))) + (yas--delete-from-keymap (third (cdr item)) uuid))) (rest keymap)) + ;; Set the uuid entry to nil + ;; + (define-key keymap (vector (make-symbol uuid)) nil) + ;; Destructively modify 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) + (setcdr keymap (delete-if #'(lambda (item) + (or (null (cdr item)) + (and (keymapp (third (cdr item))) + (null (cdr (third (cdr item))))))) + (rest keymap)))) + +(defun yas-define-menu (mode menu &optional omit-items) + "Define a snippet menu for MODE according to MENU, omitting OMIT-ITEMS. + +MENU is a list, its elements can be: + +- (yas-item UUID) : Creates an entry the snippet identified with + UUID. The menu entry for a snippet thus identified is + permanent, i.e. it will never move (be reordered) in the menu. + +- (yas-separator) : Creates a separator + +- (yas-submenu NAME SUBMENU) : Creates a submenu with NAME, + SUBMENU has the same form as MENU. NAME is also added to the + list of groups of the snippets defined thereafter. + +OMIT-ITEMS is a list of snippet uuid's that will always be +omitted from MODE's menu, even if they're manually loaded." + (let* ((table (yas--table-get-create mode)) + (hash (yas--table-uuidhash table))) + (yas--define-menu-1 table + (yas--menu-keymap-get-create mode) + menu + hash) + (dolist (uuid omit-items) + (let ((template (or (gethash uuid hash) + (yas--populate-template (puthash uuid + (yas--make-blank-template) + hash) + :table table + :uuid uuid)))) + (setf (yas--template-menu-binding-pair template) (cons nil :none)))))) + +(defun yas--define-menu-1 (table menu-keymap menu uuidhash &optional group-list) + "Helper for `yas-define-menu'." + (dolist (e (reverse menu)) + (cond ((eq (first e) 'yas-item) + (let ((template (or (gethash (second e) uuidhash) + (yas--populate-template (puthash (second e) + (yas--make-blank-template) + uuidhash) + :table table + :perm-group group-list + :uuid (second e))))) + (define-key menu-keymap (vector (gensym)) + (car (yas--template-menu-binding-pair-get-create template :stay))))) + ((eq (first e) 'yas-submenu) + (let ((subkeymap (make-sparse-keymap))) + (define-key menu-keymap (vector (gensym)) + `(menu-item ,(second e) ,subkeymap)) + (yas--define-menu-1 table + subkeymap + (third e) + uuidhash + (append group-list (list (second e)))))) + ((eq (first e) 'yas-separator) + (define-key menu-keymap (vector (gensym)) + '(menu-item "----"))) + (t + (yas--message 3 "Don't know anything about menu entry %s" (first e)))))) + +(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 +`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 + (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-hippie-try-expand (first-time?) + "Integrate with hippie expand. + +Just put this function in `hippie-expand-try-functions-list'." + (when yas-minor-mode + (if (not first-time?) + (let ((yas-fallback-behavior 'return-nil)) + (yas-expand)) + (undo 1) + nil))) + -(defun yas/expand () +;;; Apropos condition-cache: +;;; +;;; +;;; +;;; +(defvar yas--condition-cache-timestamp nil) +(defmacro yas-define-condition-cache (func doc &rest body) + "Define a function FUNC with doc DOC and body BODY. +BODY is executed at most once every snippet expansion attempt, to check +expansion conditions. + +It doesn't make any sense to call FUNC programatically." + `(defun ,func () ,(if (and doc + (stringp doc)) + (concat doc +"\n\nFor use in snippets' conditions. Within each +snippet-expansion routine like `yas-expand', computes actual +value for the first time then always returns a cached value.") + (setq body (cons doc body)) + nil) + (let ((timestamp-and-value (get ',func 'yas--condition-cache))) + (if (equal (car timestamp-and-value) yas--condition-cache-timestamp) + (cdr timestamp-and-value) + (let ((new-value (progn + ,@body + ))) + (put ',func 'yas--condition-cache (cons yas--condition-cache-timestamp new-value)) + new-value))))) + +(defalias 'yas-expand 'yas-expand-from-trigger-key) +(defun yas-expand-from-trigger-key (&optional field) "Expand a snippet before point. If no snippet expansion is possible, fall back to the behaviour -defined in `yas/fallback-behavior'" +defined in `yas-fallback-behavior'. + +Optional argument FIELD is for non-interactive use and is an +object satisfying `yas--field-p' to restrict the expansion to." + (interactive) + (setq yas--condition-cache-timestamp (current-time)) + (let (templates-and-pos) + (unless (and yas-expand-only-for-last-commands + (not (member last-command yas-expand-only-for-last-commands))) + (setq templates-and-pos (if field + (save-restriction + (narrow-to-region (yas--field-start field) + (yas--field-end field)) + (yas--templates-for-key-at-point)) + (yas--templates-for-key-at-point)))) + (if templates-and-pos + (yas--expand-or-prompt-for-template (first templates-and-pos) + (second templates-and-pos) + (third templates-and-pos)) + (yas--fallback)))) + +(defun yas-expand-from-keymap () + "Directly expand some snippets, searching `yas--direct-keymaps'. + +If expansion fails, execute the previous binding for this key" (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)) + (setq yas--condition-cache-timestamp (current-time)) + (let* ((vec (subseq (this-command-keys-vector) (if current-prefix-arg + (length (this-command-keys)) + 0))) + (templates (mapcan #'(lambda (table) + (yas--fetch table vec)) + (yas--get-snippet-tables)))) (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))))) + (yas--expand-or-prompt-for-template templates) + (let ((yas-fallback-behavior 'call-other-command)) + (yas--fallback))))) + +(defun yas--expand-or-prompt-for-template (templates &optional start end) + "Expand one of TEMPLATES from START to END. + +Prompt the user if TEMPLATES has more than one element, else +expand immediately. Common gateway for +`yas-expand-from-trigger-key' and `yas-expand-from-keymap'." + (let ((yas--current-template (or (and (rest templates) ;; more than one + (yas--prompt-for-template (mapcar #'cdr templates))) + (cdar templates)))) + (when yas--current-template + (yas-expand-snippet (yas--template-content yas--current-template) + start + end + (yas--template-expand-env yas--current-template))))) + +;; Apropos the trigger key and the fallback binding: +;; +;; When `yas-minor-mode-map' binds , that correctly overrides +;; org-mode's , for example and searching for fallbacks correctly +;; returns `org-cycle'. However, most other modes bind "TAB". TODO, +;; improve this explanation. +;; +(defun yas--fallback () + "Fallback after expansion has failed. + +Common gateway for `yas-expand-from-trigger-key' and +`yas-expand-from-keymap'." + (cond ((eq yas-fallback-behavior 'return-nil) + ;; return nil + nil) + ((eq yas-fallback-behavior 'yas--fallback) + (error (concat "yasnippet fallback loop!\n" + "This can happen when you bind `yas-expand' " + "outside of the `yas-minor-mode-map'."))) + ((eq yas-fallback-behavior 'call-other-command) + (let* ((yas-fallback-behavior 'yas--fallback) + ;; Also bind `yas-minor-mode' to prevent fallback + ;; loops when other extensions use mechanisms similar + ;; to `yas--keybinding-beyond-yasnippet'. (github #525 + ;; and #526) + ;; + (yas-minor-mode nil) + (beyond-yasnippet (yas--keybinding-beyond-yasnippet))) + (yas--message 4 "Falling back to %s" beyond-yasnippet) + (assert (or (null beyond-yasnippet) (commandp beyond-yasnippet))) + (setq this-original-command beyond-yasnippet) + (when beyond-yasnippet + (call-interactively beyond-yasnippet)))) + ((and (listp yas-fallback-behavior) + (cdr yas-fallback-behavior) + (eq 'apply (car yas-fallback-behavior))) + (let ((command-or-fn (cadr yas-fallback-behavior)) + (args (cddr yas-fallback-behavior)) + (yas-fallback-behavior 'yas--fallback) + (yas-minor-mode nil)) + (if args + (apply command-or-fn args) + (when (commandp command-or-fn) + (setq this-command command-or-fn) + (call-interactively command-or-fn))))) + (t + ;; also return nil if all the other fallbacks have failed + nil))) + +(defun yas--keybinding-beyond-yasnippet () + "Get current keys's binding as if YASsnippet didn't exist." + (let* ((yas-minor-mode nil) + (yas--direct-keymaps nil) + (keys (this-single-command-keys))) + (or (key-binding keys t) + (key-binding (yas--fallback-translate-input keys) t)))) + +(defun yas--fallback-translate-input (keys) + "Emulate `read-key-sequence', at least what I think it does. + +Keys should be an untranslated key vector. Returns a translated +vector of keys. FIXME not thoroughly tested." + (let ((retval []) + (i 0)) + (while (< i (length keys)) + (let ((j i) + (translated local-function-key-map)) + (while (and (< j (length keys)) + translated + (keymapp translated)) + (setq translated (cdr (assoc (aref keys j) (remove 'keymap translated))) + j (1+ j))) + (setq retval (vconcat retval (cond ((symbolp translated) + `[,translated]) + ((vectorp translated) + translated) + (t + (substring keys i j))))) + (setq i j))) + retval)) -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; Snippet development +;;; Utils for snippet development: -(defun yas/all-templates (tables) - "Return all snippet tables applicable for the current buffer. +(defun yas--all-templates (tables) + "Get `yas--template' objects in TABLES, applicable for buffer and point. -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)))) +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)))) + (if yas-choose-keys-first + (let ((key (yas--prompt-for-keys + (mapcan #'yas--table-all-keys tables)))) (when key (mapcan #'(lambda (table) - (yas/fetch table key)) + (yas--fetch table key)) tables))) - (mapcan #'yas/snippet-table-templates tables)))) + (remove-duplicates (mapcan #'yas--table-templates tables) + :test #'equal)))) -(defun yas/insert-snippet (&optional no-condition) +(defun yas-insert-snippet (&optional no-condition) "Choose a snippet to expand, pop-up a list of choices according -to `yas/prompt-function'. +to `yas-prompt-functions'. With prefix argument NO-CONDITION, bypass filtering of snippets by condition." (interactive "P") - (let* ((yas/buffer-local-condition (or (and no-condition + (setq yas--condition-cache-timestamp (current-time)) + (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 + yas-buffer-local-condition)) + (templates (yas--all-templates (yas--get-snippet-tables))) + (yas--current-template (and templates + (or (and (rest templates) ;; more than one template for same key + (yas--prompt-for-template templates)) + (car templates)))) + (where (if (region-active-p) (cons (region-beginning) (region-end)) (cons (point) (point))))) - (if template - (yas/expand-snippet (yas/template-content template) + (if yas--current-template + (yas-expand-snippet (yas--template-content yas--current-template) (car where) (cdr where) - (yas/template-expand-env template)) - (message "[yas] No snippets can be inserted here!")))) + (yas--template-expand-env yas--current-template)) + (yas--message 3 "No snippets can be inserted here!")))) -(defun yas/visit-snippet-file () - "Choose a snippet to edit, selection like `yas/insert-snippet'. +(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))) + (let* ((yas-buffer-local-condition 'always) + (templates (yas--all-templates (yas--get-snippet-tables))) + (yas-prompt-functions '(yas-ido-prompt yas-completing-prompt)) (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: ")) + (or (yas--prompt-for-template templates + "Choose a snippet template to edit: ") (car templates))))) - (when template - (yas/visit-snippet-file-1 template)))) + (if template + (yas--visit-snippet-file-1 template) + (message "No snippets tables active!")))) -(defun yas/visit-snippet-file-1 (template) - (let ((file (yas/template-file template))) - (cond ((and file (file-exists-p file)) +(defun yas--visit-snippet-file-1 (template) + "Helper for `yas-visit-snippet-file'." + (let ((file (yas--template-file template))) + (cond ((and file (file-readable-p file)) (find-file-other-window file) - (snippet-mode)) + (snippet-mode) + (set (make-local-variable 'yas--editing-template) template)) (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 + (switch-to-buffer (format "*%s*"(yas--template-name template))) + (let ((type 'snippet)) + (when (listp (yas--template-content template)) + (insert (format "# type: command\n")) + (setq type 'command)) + (insert (format "# key: %s\n" (yas--template-key template))) + (insert (format "# name: %s\n" (yas--template-name template))) + (when (yas--template-keybinding template) + (insert (format "# binding: %s\n" (yas--template-keybinding template)))) + (when (yas--template-expand-env template) + (insert (format "# expand-env: %s\n" (yas--template-expand-env template)))) + (when (yas--template-condition template) + (insert (format "# condition: %s\n" (yas--template-condition template)))) + (insert "# --\n") + (insert (if (eq type 'command) + (pp-to-string (yas--template-content template)) + (yas--template-content template)))) + (snippet-mode) + (set (make-local-variable 'yas--editing-template) template))))) + +(defun yas--guess-snippet-directories-1 (table) + "Guess possible snippet subdirectories for TABLE." + (cons (yas--table-name table) (mapcan #'(lambda (parent) - (yas/guess-snippet-directories-1 - parent - (concat (yas/snippet-table-name parent) "/" suffix))) - (yas/snippet-table-parents table)))) + (yas--guess-snippet-directories-1 + parent)) + (yas--table-parents table)))) -(defun yas/guess-snippet-directories () +(defun yas--guess-snippet-directories (&optional table) "Try to guess suitable directories based on the current active -tables. +tables (or optional TABLE). + +Returns a list of elements (TABLE . DIRS) where TABLE is a +`yas--table' object and DIRS is a list of all possible directories +where snippets of table might exist." + (let ((main-dir (replace-regexp-in-string + "/+$" "" + (or (first (or (yas-snippet-dirs) + (setq yas-snippet-dirs '("~/.emacs.d/snippets"))))))) + (tables (or (and table + (list table)) + (yas--get-snippet-tables)))) + ;; HACK! the snippet table created here is actually registered! + ;; + (unless (or table (gethash major-mode yas--tables)) + (push (yas--table-get-create major-mode) + 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)))) + (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." +(defun yas--make-directory-maybe (table-and-dirs &optional main-table-string) + "Return 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)))) + (unless (file-writable-p (file-name-directory candidate)) + (error (yas--format "%s is not writable." candidate))) (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) + (if (gethash (yas--table-mode (car table-and-dirs)) + yas--tables) "" " brand new") (or main-table-string "") - (yas/snippet-table-name (car table-and-dirs)))) + (yas--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. +(defun yas-new-snippet (&optional no-template) + "Pops a new buffer for writing a snippet. -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'." +Expands a snippet-writing snippet, unless the optional prefix arg +NO-TEMPLATE is non-nil." (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 ((guessed-directories (yas--guess-snippet-directories))) + + (switch-to-buffer "*new snippet*") + (erase-buffer) + (kill-all-local-variables) + (snippet-mode) + (yas-minor-mode 1) + (set (make-local-variable 'yas--guessed-modes) (mapcar #'(lambda (d) + (yas--table-mode (car d))) + guessed-directories)) + (if (and (not no-template) yas-new-snippet-default) + (yas-expand-snippet yas-new-snippet-default)))) + +(defun yas--compute-major-mode-and-parents (file) + "Given FILE, find the nearest snippet directory for a given mode. + +Returns a list (MODE-SYM PARENTS), the mode's symbol and a list +representing one or more of the mode's parents. + +Note that MODE-SYM need not be the symbol of a real major mode, +neither do the elements of PARENTS." (let* ((file-dir (and file - (directory-file-name (or (locate-dominating-file file ".yas-make-groups") + (directory-file-name (or (some #'(lambda (special) + (locate-dominating-file file special)) + '(".yas-setup.el" + ".yas-make-groups" + ".yas-parents")) (directory-file-name (file-name-directory file)))))) + (parents-file-name (concat file-dir "/.yas-parents")) (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) + (intern major-mode-name)))) + (parents (when (file-readable-p parents-file-name) (mapcar #'intern (split-string (with-temp-buffer - (insert-file-contents extra-parents-file-name) + (insert-file-contents 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." + (cons major-mode-sym (remove major-mode-sym parents))))) + +(defvar yas--editing-template nil + "Supporting variable for `yas-load-snippet-buffer' and `yas--visit-snippet'.") + +(defvar yas--current-template nil + "Holds the current template being expanded into a snippet.") + +(defvar yas--guessed-modes nil + "List of guessed modes supporting `yas-load-snippet-buffer'.") + +(defun yas--read-table () + "Ask user for a snippet table, help with some guessing." + (let ((prompt (if (and (featurep 'ido) + ido-mode) + 'ido-completing-read 'completing-read))) + (unless yas--guessed-modes + (set (make-local-variable 'yas--guessed-modes) + (or (yas--compute-major-mode-and-parents buffer-file-name)))) + (intern + (funcall prompt (format "Choose or enter a table (yas guesses %s): " + (if yas--guessed-modes + (first yas--guessed-modes) + "nothing")) + (mapcar #'symbol-name yas--guessed-modes) + nil + nil + nil + nil + (if (first yas--guessed-modes) + (symbol-name (first yas--guessed-modes))))))) + +(defun yas-load-snippet-buffer (table &optional interactive) + "Parse and load current buffer's snippet definition into TABLE. + +TABLE is a symbol naming a passed to `yas--table-get-create'. + +When called interactively, prompt for the table name." + (interactive (list (yas--read-table) t)) + (cond + ;; We have `yas--editing-template', this buffer's content comes from a + ;; template which is already loaded and neatly positioned,... + ;; + (yas--editing-template + (yas--define-snippets-1 (yas--parse-template (yas--template-file yas--editing-template)) + (yas--template-table yas--editing-template))) + ;; Try to use `yas--guessed-modes'. If we don't have that use the + ;; value from `yas--compute-major-mode-and-parents' + ;; + (t + (unless yas--guessed-modes + (set (make-local-variable 'yas--guessed-modes) (or (yas--compute-major-mode-and-parents buffer-file-name)))) + (let* ((table (yas--table-get-create table))) + (set (make-local-variable 'yas--editing-template) + (yas--define-snippets-1 (yas--parse-template buffer-file-name) + table))))) + (when interactive + (yas--message 3 "Snippet \"%s\" loaded for %s." + (yas--template-name yas--editing-template) + (yas--table-name (yas--template-table yas--editing-template))))) + +(defun yas-load-snippet-buffer-and-close (table &optional kill) + "Load the snippet with `yas-load-snippet-buffer', possibly + save, then `quit-window' if saved. + +If the snippet is new, ask the user whether (and where) to save +it. If the snippet already has a file, just save it. + +The prefix argument KILL is passed to `quit-window'. + +Don't use this from a Lisp program, call `yas-load-snippet-buffer' +and `kill-buffer' instead." + (interactive (list (yas--read-table) current-prefix-arg)) + (yas-load-snippet-buffer table t) + (when (and (or + ;; Only offer to save this if it looks like a library or new + ;; snippet (loaded from elisp, from a dir in `yas-snippet-dirs' + ;; which is not the first, or from an unwritable file) + ;; + (not (yas--template-file yas--editing-template)) + (not (file-writable-p (yas--template-file yas--editing-template))) + (and (listp yas-snippet-dirs) + (second yas-snippet-dirs) + (not (string-match (expand-file-name (first yas-snippet-dirs)) + (yas--template-file yas--editing-template))))) + (y-or-n-p (yas--format "Looks like a library or new snippet. Save to new file? "))) + (let* ((option (first (yas--guess-snippet-directories (yas--template-table yas--editing-template)))) + (chosen (and option + (yas--make-directory-maybe option)))) + (when chosen + (let ((default-file-name (or (and (yas--template-file yas--editing-template) + (file-name-nondirectory (yas--template-file yas--editing-template))) + (yas--template-name yas--editing-template)))) + (write-file (concat chosen "/" + (read-from-minibuffer (format "File name to create in %s? " chosen) + default-file-name))) + (setf (yas--template-file yas--editing-template) buffer-file-name))))) + (when buffer-file-name + (save-buffer) + (quit-window kill))) + +(defun yas-tryout-snippet (&optional debug) + "Test current buffer'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)) + (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) + (first yas--guessed-modes) + (intern (read-from-minibuffer (yas--format "Please input a mode: "))))) + (yas--current-template + (and parsed + (fboundp test-mode) + (yas--populate-template (yas--make-blank-template) + :table nil ;; no tables for ephemeral snippets + :key (first parsed) + :content (second parsed) + :name (third parsed) + :expand-env (sixth parsed))))) + (cond (yas--current-template + (let ((buffer-name (format "*testing snippet: %s*" (yas--template-name yas--current-template)))) + (kill-buffer (get-buffer-create buffer-name)) + (switch-to-buffer (get-buffer-create buffer-name)) (setq buffer-undo-list nil) - (funcall test-mode) - (yas/expand-snippet (yas/template-content template) + (condition-case nil (funcall test-mode) (error nil)) + (yas-minor-mode 1) + (setq buffer-read-only nil) + (yas-expand-snippet (yas--template-content yas--current-template) (point-min) (point-max) - (yas/template-expand-env template)) - (when debug - (add-hook 'post-command-hook 'yas/debug-snippet-vars 't 'local)))) + (yas--template-expand-env yas--current-template)) + (when (and debug + (require 'yasnippet-debug nil t)) + (add-hook 'post-command-hook 'yas-debug-snippet-vars nil t)))) (t - (message "[yas] Cannot test snippet for unknown major mode"))))) + (yas--message 3 "Cannot test snippet for unknown major mode"))))) + +(defun yas-active-keys () + "Return all active trigger keys for current buffer and point." + (remove-duplicates + (remove-if-not #'stringp (mapcan #'yas--table-all-keys (yas--get-snippet-tables))) + :test #'string=)) + +(defun yas--template-fine-group (template) + (car (last (or (yas--template-group template) + (yas--template-perm-group template))))) + +(defun yas-describe-tables (&optional choose) + "Display snippets for each table." + (interactive "P") + (let* ((by-name-hash (and choose + (y-or-n-p "Show by namehash? "))) + (buffer (get-buffer-create "*YASnippet tables*")) + (active-tables (yas--get-snippet-tables)) + (remain-tables (let ((all)) + (maphash #'(lambda (_k v) + (unless (find v active-tables) + (push v all))) + yas--tables) + all)) + (table-lists (list active-tables remain-tables)) + (original-buffer (current-buffer)) + (continue t) + (yas--condition-cache-timestamp (current-time))) + (with-current-buffer buffer + (setq buffer-read-only nil) + (erase-buffer) + (cond ((not by-name-hash) + (insert "YASnippet tables: \n") + (while (and table-lists + continue) + (dolist (table (car table-lists)) + (yas--describe-pretty-table table original-buffer)) + (setq table-lists (cdr table-lists)) + (when table-lists + (yas--create-snippet-xrefs) + (display-buffer buffer) + (setq continue (and choose (y-or-n-p "Show also non-active tables? "))))) + (yas--create-snippet-xrefs) + (help-mode) + (goto-char 1)) + (t + (insert "\n\nYASnippet tables by NAMEHASH: \n") + (dolist (table (append active-tables remain-tables)) + (insert (format "\nSnippet table `%s':\n\n" (yas--table-name table))) + (let ((keys)) + (maphash #'(lambda (k _v) + (push k keys)) + (yas--table-hash table)) + (dolist (key keys) + (insert (format " key %s maps snippets: %s\n" key + (let ((names)) + (maphash #'(lambda (k _v) + (push k names)) + (gethash key (yas--table-hash table))) + names)))))))) + (goto-char 1) + (setq buffer-read-only t)) + (display-buffer buffer))) + +(defun yas--describe-pretty-table (table &optional original-buffer) + (insert (format "\nSnippet table `%s'" + (yas--table-name table))) + (if (yas--table-parents table) + (insert (format " parents: %s\n" + (mapcar #'yas--table-name + (yas--table-parents table)))) + (insert "\n")) + (insert (make-string 100 ?-) "\n") + (insert "group state name key binding\n") + (let ((groups-hash (make-hash-table :test #'equal))) + (maphash #'(lambda (_k v) + (let ((group (or (yas--template-fine-group v) + "(top level)"))) + (when (yas--template-name v) + (puthash group + (cons v (gethash group groups-hash)) + groups-hash)))) + (yas--table-uuidhash table)) + (maphash + #'(lambda (group templates) + (setq group (truncate-string-to-width group 25 0 ? "...")) + (insert (make-string 100 ?-) "\n") + (dolist (p templates) + (let ((name (truncate-string-to-width (propertize (format "\\\\snippet `%s'" (yas--template-name p)) + 'yasnippet p) + 50 0 ? "...")) + (group (prog1 group + (setq group (make-string (length group) ? )))) + (condition-string (let ((condition (yas--template-condition p))) + (if (and condition + original-buffer) + (with-current-buffer original-buffer + (if (yas--eval-condition condition) + "(y)" + "(s)")) + "(a)")))) + (insert group " ") + (insert condition-string " ") + (insert name + (if (string-match "\\.\\.\\.$" name) + "'" + " ") + " ") + (insert (truncate-string-to-width (or (yas--template-key p) "") + 15 0 ? "...") " ") + (insert (truncate-string-to-width (key-description (yas--template-keybinding p)) + 15 0 ? "...") " ") + (insert "\n")))) + groups-hash))) + + + +;;; User convenience functions, for using in `yas-key-syntaxes' + +(defun yas-try-key-from-whitespace (_start-point) + "As `yas-key-syntaxes' element, look for whitespace delimited key. + +A newline will be considered whitespace even if the mode syntax +marks it as something else (typically comment ender)." + (skip-chars-backward "^[:space:]\n")) + +(defun yas-shortest-key-until-whitespace (_start-point) + "Like `yas-longest-key-from-whitespace' but take the shortest key." + (when (/= (skip-chars-backward "^[:space:]\n" (1- (point))) 0) + 'again)) + +(defun yas-longest-key-from-whitespace (start-point) + "As `yas-key-syntaxes' element, look for longest key between point and whitespace. + +A newline will be considered whitespace even if the mode syntax +marks it as something else (typically comment ender)." + (if (= (point) start-point) + (yas-try-key-from-whitespace start-point) + (forward-char)) + (unless (<= start-point (1+ (point))) + 'again)) + -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; User convenience functions, for using in snippet definitions -(defvar yas/modified-p nil +(defvar yas-modified-p nil "Non-nil if field has been modified by user or transformation.") -(defvar yas/moving-away-p nil +(defvar yas-moving-away-p nil "Non-nil if user is about to exit field.") -(defvar yas/text nil +(defvar yas-text nil "Contains current field text.") -(defun yas/substr (str pattern &optional subexp) +(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 @@ -2216,81 +2810,111 @@ If found, the content of subexp group SUBEXP (default 0) is (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) +(defun yas-choose-value (&rest possibilities) + "Prompt for a string in POSSIBILITIES and return it. + +The last element of POSSIBILITIES may be a list of strings." + (unless (or yas-moving-away-p + yas-modified-p) + (let* ((last-link (last possibilities)) + (last-elem (car last-link))) + (when (listp last-elem) + (setcar last-link (car last-elem)) + (setcdr last-link (cdr last-elem)))) (some #'(lambda (fn) (funcall fn "Choose: " possibilities)) - yas/prompt-functions))) + 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) +(defun yas-key-to-value (alist) + (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-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 +(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)))) + (when (and yas-moving-away-p (notany #'(lambda (pos) (string= pos yas-text)) possibilities)) + (yas-throw (yas--format "Field only allows %s" possibilities)))) + +(defun yas-field-value (number) + "Get the string for field with NUMBER. -(defun yas/field-value (number) - (let* ((snippet (car (yas/snippets-at-point))) +Use this in primary and mirror transformations to tget." + (let* ((snippet (car (yas--snippets-at-point))) (field (and snippet - (yas/snippet-find-field snippet number)))) + (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 () + (yas--field-text-for-display field)))) + +(defun yas-text () + "Return `yas-text' if that exists and is non-empty, else nil." + (if (and yas-text + (not (string= "" yas-text))) + yas-text)) + +(defun yas-selected-text () + "Return `yas-selected-text' if that exists and is non-empty, else nil." + (if (and yas-selected-text + (not (string= "" yas-selected-text))) + yas-selected-text)) + +(defun yas--get-field-once (number &optional transform-fn) + (unless yas-modified-p + (if transform-fn + (funcall transform-fn (yas-field-value number)) + (yas-field-value number)))) + +(defun yas-default-from-field (number) + (unless yas-modified-p + (yas-field-value number))) + +(defun yas-inside-string () + "Return non-nil if the point is inside a string according to font-lock." (equal 'font-lock-string-face (get-char-property (1- (point)) 'face))) +(defun yas-unimplemented (&optional missing-feature) + (if yas--current-template + (if (y-or-n-p (format "This snippet is unimplemented (missing %s) Visit the snippet definition? " + (or missing-feature + "something"))) + (yas--visit-snippet-file-1 yas--current-template)) + (message "No implementation. Missing %s" (or missing-feature "something")))) + -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Snippet expansion and field management -(defvar yas/active-field-overlay nil +(defvar yas--active-field-overlay nil "Overlays the currently active field.") -(defvar yas/field-protection-overlays nil - "Two overlays protect the current 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 +(defvar yas-selected-text nil "The selected region deleted on the last snippet expansion.") -(defvar yas/start-column nil +(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) +(make-variable-buffer-local 'yas--active-field-overlay) +(make-variable-buffer-local 'yas--field-protection-overlays) +(put 'yas--active-field-overlay 'permanent-local t) +(put 'yas--field-protection-overlays 'permanent-local t) -(defstruct (yas/snippet (:constructor yas/make-snippet ())) +(defstruct (yas--snippet (:constructor yas--make-snippet ())) "A snippet. ..." (fields '()) (exit nil) - (id (yas/snippet-next-id) :read-only t) + (id (yas--snippet-next-id) :read-only t) (control-overlay nil) active-field ;; stacked expansion: the `previous-active-field' slot saves the @@ -2298,8 +2922,17 @@ Otherwise throw exception." previous-active-field force-exit) -(defstruct (yas/field (:constructor yas/make-field (number start end parent-field))) - "A field." +(defstruct (yas--field (:constructor yas--make-field (number start end parent-field))) + "A field. + +NUMBER is the field number. +START and END are mostly buffer markers, but see \"apropos markers-to-points\". +PARENT-FIELD is a `yas--field' this field is nested under, or nil. +MIRRORS is a list of `yas--mirror's +TRANSFORM is a lisp form. +MODIFIED-P is a boolean set to true once user inputs text. +NEXT is another `yas--field' or `yas--mirror' or `yas--exit'. +" number start end parent-field @@ -2308,37 +2941,50 @@ Otherwise throw exception." (modified-p nil) next) -(defstruct (yas/mirror (:constructor yas/make-mirror (start end transform))) - "A mirror." + +(defstruct (yas--mirror (:constructor yas--make-mirror (start end transform))) + "A mirror. + +START and END are mostly buffer markers, but see \"apropos markers-to-points\". +TRANSFORM is a lisp form. +PARENT-FIELD is a `yas--field' this mirror is nested under, or nil. +NEXT is another `yas--field' or `yas--mirror' or `yas--exit' +DEPTH is a count of how many nested mirrors can affect this mirror" start end (transform nil) - next) + parent-field + next + depth) -(defstruct (yas/exit (:constructor yas/make-exit (marker))) +(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))) +(defun yas--apply-transform (field-or-mirror field &optional empty-on-nil-p) + "Calculate transformed string for FIELD-OR-MIRROR from FIELD. + +If there is no transform for ht field, return nil. + +If there is a transform but it returns nil, return the empty +string iff EMPTY-ON-NIL-P is true." + (let* ((yas-text (yas--field-text-for-display field)) + (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))))) + (let ((ret (yas--eval-lisp transform))) + (or ret (and empty-on-nil-p ""))))))) transformed)) -(defsubst yas/replace-all (from to &optional text) - "Replace all occurance from FROM to TO. +(defsubst yas--replace-all (from to &optional text) + "Replace all occurrences from FROM to TO. With optional string TEXT do it in that string." (if text @@ -2347,408 +2993,457 @@ With optional string TEXT do it in that string." (while (search-forward from nil t) (replace-match to t t text)))) -(defun yas/snippet-find-field (snippet number) +(defun yas--snippet-find-field (snippet number) (find-if #'(lambda (field) - (eq number (yas/field-number field))) - (yas/snippet-fields snippet))) + (eq number (yas--field-number field))) + (yas--snippet-fields snippet))) -(defun yas/snippet-sort-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))) + (setf (yas--snippet-fields snippet) + (sort (yas--snippet-fields snippet) + #'yas--snippet-field-compare))) + +(defun yas--snippet-field-compare (field1 field2) + "Compare FIELD1 and FIELD2. + +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) + (or (zerop n2) (and (not (zerop n1)) + (< n1 n2))) + (not (zerop n1))) (if n2 - nil - (< (yas/field-start field1) - (yas/field-start field2)))))) + (zerop n2) + (< (yas--field-start field1) + (yas--field-start field2)))))) -(defun yas/field-probably-deleted-p (snippet field) +(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." + (and + ;; field must be zero length + ;; + (zerop (- (yas--field-start field) (yas--field-end field))) + ;; field must have been modified + ;; + (yas--field-modified-p field) + ;; either: + (or + ;; 1) it's a nested field + ;; + (yas--field-parent-field field) + ;; 2) ends just before the snippet end + ;; + (and (eq field (car (last (yas--snippet-fields snippet)))) + (= (yas--field-start field) (overlay-end (yas--snippet-control-overlay snippet))))) + ;; the field numbered 0, just before the exit marker, should + ;; never be skipped + ;; + (not (zerop (yas--field-number field))))) + +(defun yas--snippets-at-point (&optional all-snippets) + "Return a sorted list of snippets at point. + +The most recently-inserted snippets are returned first." (sort (remove nil (remove-duplicates (mapcar #'(lambda (ov) - (overlay-get ov 'yas/snippet)) + (overlay-get ov 'yas--snippet)) (if all-snippets (overlays-in (point-min) (point-max)) - (overlays-at (point)))))) + (nconc (overlays-at (point)) (overlays-at (1- (point)))))))) #'(lambda (s1 s2) - (<= (yas/snippet-id s2) (yas/snippet-id s1))))) + (<= (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'." +(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))) + (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))) + (unless (yas-expand-from-trigger-key active-field) + (yas-next-field)))) + (yas-next-field))) + +(defun yas-next-field (&optional arg) + "Navigate to the ARGth next field. -(defun yas/next-field (&optional arg) - "Navigate to next field. If there's none, exit the snippet." +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)) + (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))) + (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))) + (target-field (and target-pos (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))) + (yas--field-transform active-field)) + (let* ((yas-moving-away-p t) + (yas-text (yas--field-text-for-display active-field)) + (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)))) + (yas--eval-lisp (yas--field-transform active-field)))) ;; Now actually move... - (cond ((>= target-pos (length live-fields)) - (yas/exit-snippet snippet)) + (cond ((and target-pos (>= target-pos (length live-fields))) + (yas-exit-snippet snippet)) (target-field - (yas/move-to-field 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--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) +(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 () + (goto-char (yas--field-start field)) + (yas--place-overlays snippet field) + (overlay-put yas--active-field-overlay 'yas--field field) + (let ((number (yas--field-number field))) + ;; check for the special ${0: ...} field + (if (and number (zerop number)) + (progn + (set-mark (yas--field-end field)) + (setf (yas--snippet-force-exit snippet) + (or (yas--field-transform field) + t))) + ;; make this field active + (setf (yas--snippet-active-field snippet) field) + ;; primary field transform: first call to snippet transform + (unless (yas--field-modified-p field) + (if (yas--field-update-display field) + (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)) + (yas-next-field -1)) -(defun yas/abort-snippet (&optional snippet) +(defun yas-abort-snippet (&optional snippet) (interactive) (let ((snippet (or snippet - (car (yas/snippets-at-point))))) + (car (yas--snippets-at-point))))) (when snippet - (setf (yas/snippet-force-exit snippet) t)))) + (setf (yas--snippet-force-exit snippet) t)))) -(defun yas/exit-snippet (snippet) +(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 () + (interactive (list (first (yas--snippets-at-point)))) + (when snippet + (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))) + (yas-exit-snippet snippet) + (yas--check-commit-snippet)) + (yas--snippets-at-point 'all-snippets))) -;;; 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 -;;; +;;; Some low level snippet-routines: -(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))))))) +(defvar yas--inhibit-overlay-hooks nil + "Bind this temporarily to non-nil to prevent running `yas--on-*-modification'.") -(defun yas/commit-snippet (snippet &optional no-hooks) - "Commit SNIPPET, but leave point as it is. This renders the -snippet as ordinary text. +(defmacro yas--inhibit-overlay-hooks (&rest body) + "Run BODY with `yas--inhibit-overlay-hooks' set to t." + (declare (indent 0)) + `(let ((yas--inhibit-overlay-hooks t)) + ,@body)) -Return a buffer position where the point should be placed if -exiting the snippet. +(defvar yas-snippet-beg nil "Beginning position of the last snippet committed.") +(defvar yas-snippet-end nil "End position of the last snippet committed.") -NO-HOOKS means don't run the `yas/after-exit-snippet-hook' hooks." +(defun yas--commit-snippet (snippet) + "Commit SNIPPET, but leave point as it is. - (let ((control-overlay (yas/snippet-control-overlay snippet)) - yas/snippet-beg - yas/snippet-end) +This renders the snippet as ordinary text." + + (let ((control-overlay (yas--snippet-control-overlay snippet))) ;; ;; 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)) + (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))) + (yas--inhibit-overlay-hooks + (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'... + ;; `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))) + (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) + (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) + (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))) + ;; again from `yas--take-care-of-redo'.... + (setf (yas--snippet-fields snippet) nil))) + + (yas--message 3 "Snippet %s exited." (yas--snippet-id snippet))) - (message "[yas] snippet exited.")) +(defun yas--safely-run-hooks (hook-var) + (condition-case error + (run-hooks hook-var) + (error + (yas--message 3 "%s error: %s" hook-var (error-message-string error))))) + + +(defun yas--check-commit-snippet () + "Check if point exited the currently active field of the snippet. -(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)) +If so cleans up the whole snippet up." + (let* ((snippets (yas--snippets-at-point 'all-snippets)) + (snippets-left snippets) + (snippet-exit-transform)) (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)))) + (let ((active-field (yas--snippet-active-field snippet))) + (setq snippet-exit-transform (yas--snippet-force-exit snippet)) + (cond ((or snippet-exit-transform + (not (and active-field (yas--field-contains-point-p active-field)))) (setq snippets-left (delete snippet snippets-left)) - (yas/commit-snippet snippet snippets-left)) + (setf (yas--snippet-force-exit snippet) nil) + (yas--commit-snippet snippet)) ((and active-field - (or (not yas/active-field-overlay) - (not (overlay-buffer yas/active-field-overlay)))) + (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))) + (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)))) + (unless (or (null snippets) snippets-left) + (if snippet-exit-transform + (yas--eval-lisp-no-saves snippet-exit-transform)) + (yas--safely-run-hooks 'yas-after-exit-snippet-hook)))) -(defun yas/field-contains-point-p (field &optional 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--field-contains-point-p (field &optional point) (let ((point (or point (point)))) - (and (>= point (yas/field-start field)) - (<= point (yas/field-end field))))) + (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--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" +(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 +(defun yas--make-control-overlay (snippet start end) + "Create 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-put overlay 'keymap yas-keymap) + (overlay-put overlay 'priority 100) + (overlay-put overlay 'yas--snippet snippet) overlay)) -(defun yas/skip-and-clear-or-delete-char (&optional field) +(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))))) + (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)) + (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) +(defun yas--skip-and-clear (field) + "Deletes the region of FIELD and sets it's modified state to t." + ;; Just before skipping-and-clearing the field, mark its children + ;; fields as modified, too. If the children have mirrors-in-fields + ;; this prevents them from updating erroneously (we're skipping and + ;; deleting!). + ;; + (yas--mark-this-and-children-modified field) + (delete-region (yas--field-start field) (yas--field-end field))) + +(defun yas--mark-this-and-children-modified (field) + (setf (yas--field-modified-p field) t) + (let ((fom (yas--field-next field))) + (while (and fom + (yas--fom-parent-field fom)) + (when (and (eq (yas--fom-parent-field fom) field) + (yas--field-p fom)) + (yas--mark-this-and-children-modified fom)) + (setq fom (yas--fom-next fom))))) + +(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) + (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) + (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 +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))) + (unless (or yas--inhibit-overlay-hooks + (yas--undo-in-progress)) + (let* ((field (overlay-get overlay 'yas--field)) + (snippet (overlay-get yas--active-field-overlay 'yas--snippet))) (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)))) + (yas--advance-end-maybe field (overlay-end overlay)) + (save-excursion + (yas--field-update-display field)) + (yas--update-mirrors snippet)) (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)))))) + (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) +;; +;; 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'. +;; +;; As of github #537 this no longer inhibits the command by issuing an +;; error: all the snippets at point, including nested snippets, are +;; automatically commited and the current command can proceed. +;; +(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))) + (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 @@ -2756,424 +3451,476 @@ Move the overlays, or create them if they do not exit." ;; (when (< (buffer-size) end) (save-excursion - (let ((inhibit-modification-hooks t)) + (yas--inhibit-overlay-hooks (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))) + (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 + (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) + (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") + (overlay-put ov 'modification-hooks '(yas--on-protection-overlay-modification))))))) -(defun yas/on-protection-overlay-modification (overlay after? beg end &optional length) +(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!")))) + (unless (or yas--inhibit-overlay-hooks + after? + (yas--undo-in-progress)) + (let ((snippets (yas--snippets-at-point))) + (yas--message 3 "Comitting snippets. Action would destroy a protection overlay.") + (cl-loop for snippet in snippets + do (yas--commit-snippet snippet))))) (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))))))) +;;; Snippet expansion and "stacked" expansion: +;; +;; Stacked expansion is when you try to expand a snippet when already +;; inside a snippet 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 an undo/redo perspective, 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 (content &optional start end expand-env) + "Expand snippet CONTENT at current point. - (when start - (goto-char start)) +Text between START and END will be deleted before inserting +template. EXPAND-ENV is are let-style variable to value bindings +considered when expanding the snippet." + (run-hooks 'yas-before-expand-snippet-hook) - ;; 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) - + (let* ((yas-selected-text (or yas-selected-text + (and (region-active-p) + (buffer-substring-no-properties (region-beginning) + (region-end))))) + (start (or start + (and (region-active-p) + (region-beginning)) + (point))) + (end (or end + (and (region-active-p) + (region-end)) + (point))) + (to-delete (and start + end + (buffer-substring-no-properties start end))) + snippet) + (goto-char start) + (setq yas--indent-original-column (current-column)) ;; 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.")) + (delete-region start end)) -(defun yas/take-care-of-redo (beg end snippet) - "Commits SNIPPET, which in turn pushes an undo action for -reviving it. + (cond ((listp content) + ;; x) This is a snippet-command + ;; + (yas--eval-lisp-no-saves content)) + (t + ;; x) This is a snippet-snippet :-) + ;; + ;; Narrow the region down to the content, 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. + ;; + ;; stacked expansion: also shoosh the overlay modification hooks + (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 (current-column)) + (yas--inhibit-overlay-hooks + (setq snippet + (if expand-env + (eval `(let* ,expand-env + (insert content) + (yas--snippet-create start (point)))) + (insert content) + (yas--snippet-create start (point)))))) + + ;; stacked-expansion: This checks for stacked expansion, save the + ;; `yas--previous-active-field' and advance its boundary. + ;; + (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 + ;; + ;; A small exception, if `yas-also-auto-indent-first-line' + ;; is t and `yas--indent' decides to indent the line to a + ;; point before the actual expansion point, undo would be + ;; messed up. We call the early point "newstart"". case, + ;; and attempt to fix undo. + ;; + (let ((newstart (overlay-start (yas--snippet-control-overlay snippet))) + (end (overlay-end (yas--snippet-control-overlay snippet)))) + (when (< newstart start) + (push (cons (make-string (- start newstart) ? ) newstart) buffer-undo-list)) + (push (cons newstart end) buffer-undo-list) + (push `(apply yas--take-care-of-redo ,start ,end ,snippet) + buffer-undo-list)) + ;; Now, schedule a move to the first field + ;; + (let ((first-field (car (yas--snippet-fields snippet)))) + (when first-field + (sit-for 0) ;; fix issue 125 + (yas--move-to-field snippet first-field))) + (yas--message 3 "snippet expanded.") + t)))) + +(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))) + (when (yas--snippet-fields snippet) + (yas--commit-snippet snippet))) -(defun yas/snippet-revive (beg end snippet) - "Revives the SNIPPET and creates a control overlay from BEG to -END. +(defun yas--snippet-revive (beg end snippet) + "Revives 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 +BEG and END are, we hope, the original snippets boundaries. +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 +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) + (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))))) + (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) + (setf (yas--snippet-control-overlay snippet) (yas--make-control-overlay snippet beg end)) + (overlay-put (yas--snippet-control-overlay snippet) 'yas--snippet snippet) - (add-hook 'post-command-hook 'yas/post-command-handler nil t) - (add-hook 'pre-command-hook 'yas/pre-command-handler t t) + (yas--move-to-field snippet target-field) - (push `(apply yas/take-care-of-redo ,beg ,end ,snippet) + (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. +(defun yas--snippet-create (begin end) + "Create a snippet from a template inserted at BEGIN to END. Returns the newly created snippet." - (let ((snippet (yas/make-snippet))) - (goto-char begin) - (yas/snippet-parse-create snippet) + (save-restriction + (narrow-to-region begin end) + (let ((snippet (yas--make-snippet))) + (goto-char begin) + (yas--snippet-parse-create snippet) - ;; Sort and link each field - (yas/snippet-sort-fields 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))) + ;; 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) + ;; Move to end + (goto-char (point-max)) - snippet)) + 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 -;;; +;;; Apropos adjacencies and "fom's": +;; +;; 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 abbreviated to "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-start (fom) - (cond ((yas/field-p fom) - (yas/field-start fom)) - ((yas/mirror-p fom) - (yas/mirror-start 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)))) + (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)) +(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-marker fom)))) + (yas--exit-next fom)))) -(defun yas/fom-next (fom) - (cond ((yas/field-p fom) - (yas/field-next fom)) - ((yas/mirror-p fom) - (yas/mirror-next fom)) +(defun yas--fom-parent-field (fom) + (cond ((yas--field-p fom) + (yas--field-parent-field fom)) + ((yas--mirror-p fom) + (yas--mirror-parent-field fom)) (t - (yas/exit-next fom)))) + nil))) -(defun yas/calculate-adjacencies (snippet) +(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* ((fom-set-next-fom + (lambda (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))))) + (compare-fom-begs + (lambda (fom1 fom2) + (if (= (yas--fom-start fom2) (yas--fom-start fom1)) + (yas--mirror-p fom2) + (>= (yas--fom-start fom2) (yas--fom-start fom1))))) + (link-foms fom-set-next-fom)) + ;; 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)) + (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)) + (dolist (mirror (yas--field-mirrors field)) (push mirror soup))) (setq soup - (sort soup - #'yas/compare-fom-begs)) + (sort soup compare-fom-begs)) (when soup - (reduce #'yas/link-foms soup))))) - -(defun yas/advance-end-maybe (fom newend) + (reduce link-foms soup))))) + +(defun yas--calculate-mirrors-in-fields (snippet mirror) + "Attempt to assign a parent field of SNIPPET to the mirror MIRROR. + +Use the tightest containing field if more than one field contains +the mirror. Intended to be called *before* the dollar-regions are +deleted." + (let ((min (point-min)) + (max (point-max))) + (dolist (field (yas--snippet-fields snippet)) + (when (and (<= (yas--field-start field) (yas--mirror-start mirror)) + (<= (yas--mirror-end mirror) (yas--field-end field)) + (< min (yas--field-start field)) + (< (yas--field-end field) max)) + (setq min (yas--field-start field) + max (yas--field-end field)) + (setf (yas--mirror-parent-field mirror) field))))) + +(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. +* call `yas--advance-start-maybe' on FOM's next fom. + +* in case FOM is field call `yas--advance-end-maybe' on its parent + field -* 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)))) +Also, if FOM is an exit-marker, always call +`yas--advance-start-maybe' on its next fom. This is because +exit-marker have identical start and end markers." + (cond ((and fom (< (yas--fom-end fom) newend)) + (set-marker (yas--fom-end fom) newend) + (yas--advance-start-maybe (yas--fom-next fom) newend) + (yas--advance-end-of-parents-maybe (yas--fom-parent-field fom) newend)) + ((yas--exit-p fom) + (yas--advance-start-maybe (yas--fom-next fom) newend)))) -(defun yas/advance-start-maybe (fom newstart) +(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))) +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))) + +(defun yas--advance-end-of-parents-maybe (field newend) + "Like `yas--advance-end-maybe' but for parent fields. -(defvar yas/dollar-regions nil +Only works for fields and doesn't care about the start of the +next FOM. Works its way up recursively for parents of parents." + (when (and field + (< (yas--field-end field) newend)) + (set-marker (yas--field-end field) newend) + (yas--advance-end-of-parents-maybe (yas--field-parent-field field) newend))) + +(defvar yas--dollar-regions nil "When expanding the snippet the \"parse-create\" functions add - cons cells to this var") +cons cells to this var.") + +(defvar yas--backquote-markers-and-strings nil + "List of (MARKER . STRING) marking where the values from +backquoted Lisp expressions should be inserted at the end of +expansion.") -(defun yas/snippet-parse-create (snippet) +(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 + ;; Reset the yas--dollar-regions ;; - (setq yas/dollar-regions nil) - ;; protect escaped quote, backquotes and backslashes + (setq yas--dollar-regions nil) + ;; protect just the backquotes ;; - (yas/protect-escapes nil '(?\\ ?` ?')) + (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 + (yas--save-backquotes) + ;; protect escaped characters ;; - (goto-char parse-start) - (yas/protect-escapes) + (yas--protect-escapes) ;; parse fields with {} ;; (goto-char parse-start) - (yas/field-parse-create snippet) + (yas--field-parse-create snippet) ;; parse simple mirrors and fields ;; (goto-char parse-start) - (yas/simple-mirror-parse-create snippet) + (yas--simple-mirror-parse-create snippet) ;; parse mirror transforms ;; (goto-char parse-start) - (yas/transform-mirror-parse-create snippet) + (yas--transform-mirror-parse-create snippet) ;; calculate adjacencies of fields and mirrors ;; - (yas/calculate-adjacencies snippet) + (yas--calculate-adjacencies snippet) ;; Delete $-constructs ;; - (yas/delete-regions yas/dollar-regions) + (save-restriction (widen) (yas--delete-regions yas--dollar-regions)) + ;; restore backquoted expression values + ;; + (yas--restore-backquotes) ;; restore escapes ;; (goto-char parse-start) - (yas/restore-escapes) + (yas--restore-escapes) ;; update mirrors for the first time ;; - (yas/update-mirrors snippet) + (yas--update-mirrors snippet) ;; indent the best we can ;; (goto-char parse-start) - (yas/indent snippet))) + (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: +(defun yas--indent-according-to-mode (snippet-markers) + "Indent current line according to mode, preserving SNIPPET-MARKERS." + ;;; Apropos indenting problems.... ;; - ;; `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. + ;; `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 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 + ;; (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)) + (goto-char (yas--real-line-beginning)) (let ((trouble-markers (remove-if-not #'(lambda (marker) (= marker (point))) snippet-markers))) (save-restriction (widen) - (condition-case err + (condition-case _ (indent-according-to-mode) - (error (message "[yas] warning: yas/indent-according-to-mode habing problems running %s" indent-line-function) + (error (yas--message 3 "Warning: `yas--indent-according-to-mode' having 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))) +(defvar yas--indent-original-column nil) +(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)))) + (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) + (cond ((eq yas-indent-line 'fixed) (while (and (zerop (forward-line)) (zerop (current-column))) - (indent-to-column column))) - ((eq yas/indent-line 'auto) + (indent-to-column yas--indent-original-column))) + ((eq yas-indent-line 'auto) (let ((end (set-marker (make-marker) (point-max))) - (indent-first-line-p yas/also-auto-indent-first-line)) + (indent-first-line-p yas-also-auto-indent-first-line)) (while (and (zerop (if indent-first-line-p (prog1 (forward-line 0) @@ -3181,38 +3928,38 @@ SNIPPET-MARKERS." (forward-line 1))) (not (eobp)) (<= (point) end)) - (yas/indent-according-to-mode snippet-markers)))) + (yas--indent-according-to-mode snippet-markers)))) (t nil))))) -(defun yas/collect-snippet-markers (snippet) +(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))) + (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))) + (marker-buffer (yas--exit-marker snippet-exit))) + (push (yas--exit-marker snippet-exit) markers))) markers)) -(defun yas/real-line-beginning () +(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) + (cl-incf n) (setq c (char-after n))) n)) -(defun yas/escape-string (escaped) +(defun yas--escape-string (escaped) (concat "YASESCAPE" (format "%d" escaped) "PROTECTGUARD")) -(defun yas/protect-escapes (&optional text escaped) +(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." @@ -3220,13 +3967,13 @@ With optional string TEXT do it in string instead of buffer." (text-provided-p text)) (mapc #'(lambda (escaped) (setq changed-text - (yas/replace-all (concat "\\" (char-to-string escaped)) - (yas/escape-string escaped) + (yas--replace-all (concat "\\" (char-to-string escaped)) + (yas--escape-string escaped) (when text-provided-p changed-text)))) - (or escaped yas/escaped-characters)) + (or escaped yas--escaped-characters)) changed-text)) -(defun yas/restore-escapes (&optional text escaped) +(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." @@ -3234,51 +3981,75 @@ With optional string TEXT do it in string instead of the buffer." (text-provided-p text)) (mapc #'(lambda (escaped) (setq changed-text - (yas/replace-all (yas/escape-string escaped) + (yas--replace-all (yas--escape-string escaped) (char-to-string escaped) (when text-provided-p changed-text)))) - (or escaped yas/escaped-characters)) + (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 +(defun yas--save-backquotes () + "Save all the \"`(lisp-expression)`\"-style expressions +with their evaluated value into `yas--backquote-markers-and-strings'." + (while (re-search-forward yas--backquote-lisp-expression-regexp nil t) + (let ((current-string (match-string-no-properties 1)) transformed) + (save-restriction (widen) + (delete-region (match-beginning 0) (match-end 0))) + (setq transformed (yas--eval-lisp (yas--read-lisp (yas--restore-escapes current-string '(?`))))) + (goto-char (match-beginning 0)) + (when transformed + (let ((marker (make-marker))) + (save-restriction + (widen) + (insert "Y") ;; quite horrendous, I love it :) + (set-marker marker (point)) + (insert "Y")) + (push (cons marker transformed) yas--backquote-markers-and-strings)))))) + +(defun yas--restore-backquotes () + "Replace markers in `yas--backquote-markers-and-strings' with their values." + (while yas--backquote-markers-and-strings + (let* ((marker-and-string (pop yas--backquote-markers-and-strings)) + (marker (car marker-and-string)) + (string (cdr marker-and-string))) + (save-excursion + (goto-char marker) + (save-restriction + (widen) + (delete-char -1) + (insert string) + (delete-char 1)) + (set-marker marker nil))))) + +(defun yas--scan-sexps (from count) + (condition-case _ (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'" +(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\". +(defun yas--field-parse-create (snippet &optional parent-field) + "Parse most field expressions in SNIPPET, 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' +* \"${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)) + (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 @@ -3289,98 +4060,116 @@ When multiple expressions are found, only the last one counts." (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)) + ;; allow ${0: some exit text} + ;; (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) + yas--dollar-regions) (push (cons (match-beginning 0) (match-beginning 2)) - yas/dollar-regions) - (push brand-new-field (yas/snippet-fields snippet)) + 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)) + (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))))))) + (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 + ;; `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. + (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: + ;; + ;; 1. we don't find it in yas--dollar-regions (a subnested + ;; field) might have already caught it. + ;; + ;; 2. we really make sure we have either two '$' or some + ;; text and a '$' after the colon ':'. This is a FIXME: work + ;; my regular expressions and end these ugly hacks. + ;; (when (and real-match-end-1 (not (member (cons (match-beginning 0) real-match-end-1) - yas/dollar-regions))) + yas--dollar-regions)) + (not (eq ?: + (char-before (1- (match-beginning 1)))))) (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))) + (setf (yas--field-transform parent-field) + (yas--read-lisp (yas--restore-escapes lisp-expression-string)))) (push (cons (match-beginning 0) real-match-end-1) - yas/dollar-regions))))))) + 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)) +(defun yas--transform-mirror-parse-create (snippet) + "Parse the \"${n:$(lisp-expression)}\" mirror transformations in SNIPPET." + (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) + (yas--snippet-find-field snippet number))) + (brand-new-mirror + (and real-match-end-0 + field + (yas--make-mirror (yas--make-marker (match-beginning 0)) + (yas--make-marker (match-beginning 0)) + (yas--read-lisp + (yas--restore-escapes + (buffer-substring-no-properties (match-beginning 2) + (1- real-match-end-0)))))))) + (when brand-new-mirror + (push brand-new-mirror + (yas--field-mirrors field)) + (yas--calculate-mirrors-in-fields snippet brand-new-mirror) + (push (cons (match-beginning 0) real-match-end-0) yas--dollar-regions))))) + +(defun yas--simple-mirror-parse-create (snippet) + "Parse the simple \"$n\" fields/mirrors/exitmarkers in SNIPPET." + (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)))) + (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) + (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))) + (push (cons (point) (yas--exit-marker (yas--snippet-exit snippet))) + yas--dollar-regions))) (t - (let ((field (yas/snippet-find-field snippet number))) + (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)) + (let ((brand-new-mirror (yas--make-mirror + (yas--make-marker (match-beginning 0)) + (yas--make-marker (match-beginning 0)) + nil))) + (push brand-new-mirror + (yas--field-mirrors field)) + (yas--calculate-mirrors-in-fields snippet brand-new-mirror)) + (push (yas--make-field number + (yas--make-marker (match-beginning 0)) + (yas--make-marker (match-beginning 0)) nil) - (yas/snippet-fields snippet)))) + (yas--snippet-fields snippet)))) (push (cons (match-beginning 0) (match-end 0)) - yas/dollar-regions)))))) + yas--dollar-regions)))))) -(defun yas/delete-regions (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))) @@ -3388,220 +4177,240 @@ When multiple expressions are found, only the last one counts." #'(lambda (r1 r2) (>= (car r1) (car r2)))))) -(defun yas/update-mirrors (snippet) - "Updates all the mirrors of SNIPPET." +(defun yas--calculate-mirror-depth (mirror &optional traversed) + (let* ((parent (yas--mirror-parent-field mirror)) + (parents-mirrors (and parent + (yas--field-mirrors parent)))) + (or (yas--mirror-depth mirror) + (setf (yas--mirror-depth mirror) + (cond ((memq mirror traversed) + 0) + ((and parent parents-mirrors) + (1+ (reduce #'max + (mapcar #'(lambda (m) + (yas--calculate-mirror-depth m + (cons mirror + traversed))) + parents-mirrors)))) + (parent + 1) + (t + 0)))))) + +(defun yas--update-mirrors (snippet) + "Update 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. + (dolist (field-and-mirror (sort + ;; make a list of ((F1 . M1) (F1 . M2) (F2 . M3) (F2 . M4) ...) + ;; where F is the field that M is mirroring + ;; + (mapcan #'(lambda (field) + (mapcar #'(lambda (mirror) + (cons field mirror)) + (yas--field-mirrors field))) + (yas--snippet-fields snippet)) + ;; then sort this list so that entries with mirrors with parent + ;; fields appear before. This was important for fixing #290, and + ;; luckily also handles the case where a mirror in a field causes + ;; another mirror to need reupdating + ;; + #'(lambda (field-and-mirror1 field-and-mirror2) + (> (yas--calculate-mirror-depth (cdr field-and-mirror1)) + (yas--calculate-mirror-depth (cdr field-and-mirror2)))))) + (let* ((field (car field-and-mirror)) + (mirror (cdr field-and-mirror)) + (parent-field (yas--mirror-parent-field mirror))) + ;; before updating a mirror with a parent-field, maybe advance + ;; its start (#290) ;; - (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))))))) + (when parent-field + (yas--advance-start-maybe mirror (yas--fom-start parent-field))) + ;; update this mirror + ;; + (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) +(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)))) + + (let* ((mirror-parent-field (yas--mirror-parent-field mirror)) + (reflection (and (not (and mirror-parent-field + (yas--field-modified-p mirror-parent-field))) + (or (yas--apply-transform mirror field 'empty-on-nil) + (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))) + (not (string= reflection (buffer-substring-no-properties (yas--mirror-start mirror) + (yas--mirror-end mirror))))) + (goto-char (yas--mirror-start mirror)) + (yas--inhibit-overlay-hooks + (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)) + ;; super-special advance + (yas--advance-end-of-parents-maybe mirror-parent-field (point)))))) + +(defun yas--field-update-display (field) + "Much like `yas--mirror-update-display', but for fields." + (when (yas--field-transform field) + (let ((transformed (and (not (eq (yas--field-number field) 0)) + (yas--apply-transform field field)))) (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)))) + (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)) + (yas--inhibit-overlay-hooks + (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 +;;; Post-command hook: ;; -(defun yas/pre-command-handler () ) - -(defun yas/post-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) + (cond ((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))) + (let* ((snippet (car (yas--snippets-at-point))) (target-field (and snippet (find-if-not #'(lambda (field) - (yas/field-probably-deleted-p snippet field)) + (yas--field-probably-deleted-p snippet field)) (remove nil - (cons (yas/snippet-active-field snippet) - (yas/snippet-fields snippet))))))) + (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 + (yas--move-to-field snippet target-field)))) + ((not (yas--undo-in-progress)) + ;; When not in an undo, check if we must commit the snippet + ;; (user exited it). + (yas--check-commit-snippet)))) + +;;; Fancy docs: ;; -;; (insert (pp -;; (let ((shit)) -;; (maphash #'(lambda (k v) -;; (push k shit)) -;; (yas/snippet-table-hash (gethash 'ruby-mode yas/snippet-tables))) -;; shit))) +;; The docstrings for some functions are generated dynamically +;; depending on the context. ;; +(put 'yas-expand 'function-documentation + '(yas--expand-from-trigger-key-doc t)) +(defun yas--expand-from-trigger-key-doc (context) + "A doc synthesizer for `yas--expand-from-trigger-key-doc'." + (let* ((yas-fallback-behavior (and context yas-fallback-behavior)) + (fallback-description + (cond ((eq yas-fallback-behavior 'call-other-command) + (let* ((fallback (yas--keybinding-beyond-yasnippet))) + (or (and fallback + (format "call command `%s'." + (pp-to-string fallback))) + "do nothing (`yas-expand' doesn't shadow\nanything)."))) + ((eq yas-fallback-behavior 'return-nil) + "do nothing.") + (t "defer to `yas-fallback-behavior' (which see).")))) + (concat "Expand a snippet before point. If no snippet +expansion is possible, " + fallback-description + "\n\nOptional argument FIELD is for non-interactive use and is an +object satisfying `yas--field-p' to restrict the expansion to."))) + +(put 'yas-expand-from-keymap 'function-documentation + '(yas--expand-from-keymap-doc t)) +(defun yas--expand-from-keymap-doc (context) + "A doc synthesizer for `yas--expand-from-keymap-doc'." + (add-hook 'temp-buffer-show-hook 'yas--snippet-description-finish-runonce) + (concat "Expand/run snippets from keymaps, possibly falling back to original binding.\n" + (when (and context (eq this-command 'describe-key)) + (let* ((vec (this-single-command-keys)) + (templates (mapcan #'(lambda (table) + (yas--fetch table vec)) + (yas--get-snippet-tables))) + (yas--direct-keymaps nil) + (fallback (key-binding vec))) + (concat "In this case, " + (when templates + (concat "these snippets are bound to this key:\n" + (yas--template-pretty-list templates) + "\n\nIf none of these expands, ")) + (or (and fallback + (format "fallback `%s' will be called." (pp-to-string fallback))) + "no fallback keybinding is called.")))))) + +(defun yas--template-pretty-list (templates) + (let ((acc) + (yas-buffer-local-condition 'always)) + (dolist (plate templates) + (setq acc (concat acc "\n*) " + (propertize (concat "\\\\snippet `" (car plate) "'") + 'yasnippet (cdr plate))))) + acc)) + +(define-button-type 'help-snippet-def + :supertype 'help-xref + 'help-function (lambda (template) (yas--visit-snippet-file-1 template)) + 'help-echo (purecopy "mouse-2, RET: find snippets's definition")) + +(defun yas--snippet-description-finish-runonce () + "Final adjustments for the help buffer when snippets are concerned." + (yas--create-snippet-xrefs) + (remove-hook 'temp-buffer-show-hook 'yas--snippet-description-finish-runonce)) + +(defun yas--create-snippet-xrefs () + (save-excursion + (goto-char (point-min)) + (while (search-forward-regexp "\\\\\\\\snippet[ \s\t]+`\\([^']+\\)'" nil t) + (let ((template (get-text-property (match-beginning 1) + 'yasnippet))) + (when template + (help-xref-button 1 'help-snippet-def template) + (kill-region (match-end 1) (match-end 0)) + (kill-region (match-beginning 0) (match-beginning 1))))))) + +;;; Utils -(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)) +(defvar yas-verbosity 4 + "Log level for `yas--message' 4 means trace most anything, 0 means nothing.") - (princ (format "Keymap for %s:\n\n" symbol)) - (princ (gethash symbol yas/menu-table))))) +(defun yas--message (level message &rest args) + "When LEVEL is above `yas-verbosity-level', log MESSAGE and ARGS." + (when (> yas-verbosity level) + (message "%s" (apply #'yas--format message args)))) -(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--warning (format-control &rest format-args) + (let ((msg (apply #'format format-control format-args))) + (display-warning 'yasnippet msg :warning) + (yas--message 1 msg))) +(defun yas--format (format-control &rest format-args) + (apply #'format (concat "[yas] " format-control) format-args)) -(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'. + +;;; Some hacks: +;; +;; The functions +;; +;; `locate-dominating-file' +;; `region-active-p' +;; +;; added for compatibility in emacsen < 23 +(unless (>= emacs-major-version 23) + (unless (fboundp 'region-active-p) + (defun region-active-p () (and transient-mark-mode mark-active))) + + (unless (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. @@ -3609,68 +4418,186 @@ 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. + (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)))) + ;; 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) + 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 file (file-name-directory + (directory-file-name file)))) + (setq file nil)))) + root)))) + +;;; Backward compatibility to yasnippet <= 0.7 + +(defun yas-initialize () + "For backward compatibility, enable `yas-minor-mode' globally." + (yas-global-mode 1)) + +(defvar yas--backported-syms '(;; `defcustom's + ;; + yas-snippet-dirs + yas-prompt-functions + yas-indent-line + yas-also-auto-indent-first-line + yas-snippet-revival + yas-triggers-in-field + yas-fallback-behavior + yas-choose-keys-first + yas-choose-tables-first + yas-use-menu + yas-trigger-symbol + yas-wrap-around-region + yas-good-grace + yas-visit-from-menu + yas-expand-only-for-last-commands + yas-field-highlight-face + + ;; these vars can be customized as well + ;; + yas-keymap + yas-verbosity + yas-extra-modes + yas-key-syntaxes + yas-after-exit-snippet-hook + yas-before-expand-snippet-hook + yas-buffer-local-condition + yas-dont-activate + + ;; prompting functions + ;; + yas-x-prompt + yas-ido-prompt + yas-no-prompt + yas-completing-prompt + yas-dropdown-prompt + + ;; interactive functions + ;; + yas-expand + yas-minor-mode + yas-global-mode + yas-direct-keymaps-reload + yas-minor-mode-on + yas-load-directory + yas-reload-all + yas-compile-directory + yas-recompile-all + yas-about + yas-expand-from-trigger-key + yas-expand-from-keymap + yas-insert-snippet + yas-visit-snippet-file + yas-new-snippet + yas-load-snippet-buffer + yas-tryout-snippet + yas-describe-tables + yas-next-field-or-maybe-expand + yas-next-field + yas-prev-field + yas-abort-snippet + yas-exit-snippet + yas-exit-all-snippets + yas-skip-and-clear-or-delete-char + yas-initialize + + ;; symbols that I "exported" for use + ;; in snippets and hookage + ;; + yas-expand-snippet + yas-define-snippets + yas-define-menu + yas-snippet-beg + yas-snippet-end + yas-modified-p + yas-moving-away-p + yas-substr + yas-choose-value + yas-key-to-value + yas-throw + yas-verify-value + yas-field-value + yas-text + yas-selected-text + yas-default-from-field + yas-inside-string + yas-unimplemented + yas-define-condition-cache + yas-hippie-try-expand + + ;; debug definitions + ;; yas-debug-snippet-vars + ;; yas-exterminate-package + ;; yas-debug-test + + ;; testing definitions + ;; yas-should-expand + ;; yas-should-not-expand + ;; yas-mock-insert + ;; yas-make-file-or-dirs + ;; yas-variables + ;; yas-saving-variables + ;; yas-call-with-snippet-dirs + ;; yas-with-snippet-dirs +) + "Backported yasnippet symbols. + +They are mapped to \"yas/*\" variants.") + +(dolist (sym yas--backported-syms) + (let ((backported (intern (replace-regexp-in-string "^yas-" "yas/" (symbol-name sym))))) + (when (boundp sym) + (make-obsolete-variable backported sym "yasnippet 0.8") + (defvaralias backported sym)) + (when (fboundp sym) + (make-obsolete backported sym "yasnippet 0.8") + (defalias backported sym)))) + +(defvar yas--exported-syms + (let (exported) + (mapatoms (lambda (atom) + (if (and (or (and (boundp atom) + (not (get atom 'byte-obsolete-variable))) + (and (fboundp atom) + (not (get atom 'byte-obsolete-info)))) + (string-match-p "^yas-[^-]" (symbol-name atom))) + (push atom exported)))) + exported) + "Exported yasnippet symbols. + +i.e. the ones with \"yas-\" single dash prefix. I will try to +keep them in future yasnippet versions and other elisp libraries +can more or less safely rely upon them.") + +(provide 'yasnippet) +;; Local Variables: +;; coding: utf-8 +;; indent-tabs-mode: nil +;; byte-compile-warnings: (not cl-functions) +;; End: ;;; yasnippet.el ends here -- cgit v1.3