From 97a0c68eb209825624f4e0bd34c58742bc61af89 Mon Sep 17 00:00:00 2001 From: Andreas Gerler Date: Tue, 22 Jul 2014 17:32:54 +0200 Subject: [PATCH] added elpa/auto-complete and elpa/popup Signed-off-by: Andreas Gerler --- .../auto-complete-autoloads.el | 66 + .../auto-complete-config.el | 521 ++ .../auto-complete-pkg.el | 2 + .../auto-complete.el | 2076 ++++++ .../auto-complete-20140618.2217/dict/ada-mode | 72 + .../auto-complete-20140618.2217/dict/c++-mode | 84 + elpa/auto-complete-20140618.2217/dict/c-mode | 44 + .../dict/caml-mode | 231 + .../dict/clojure-mode | 580 ++ .../dict/clojurescript-mode | 475 ++ .../auto-complete-20140618.2217/dict/coq-mode | 278 + .../auto-complete-20140618.2217/dict/css-mode | 874 +++ .../dict/erlang-mode | 216 + elpa/auto-complete-20140618.2217/dict/go-mode | 25 + .../dict/haskell-mode | 679 ++ .../dict/java-mode | 53 + .../dict/javascript-mode | 148 + .../auto-complete-20140618.2217/dict/lua-mode | 21 + .../auto-complete-20140618.2217/dict/php-mode | 6144 +++++++++++++++++ .../dict/python-mode | 175 + .../auto-complete-20140618.2217/dict/qml-mode | 183 + .../dict/ruby-mode | 181 + .../dict/scheme-mode | 216 + .../dict/sclang-mode | 1481 ++++ elpa/auto-complete-20140618.2217/dict/sh-mode | 182 + .../auto-complete-20140618.2217/dict/tcl-mode | 172 + elpa/auto-complete-20140618.2217/dict/ts-mode | 797 +++ .../dict/tuareg-mode | 231 + .../dict/verilog-mode | 313 + elpa/auto-complete-auctex-readme.txt | 2 + elpa/auto-complete-c-headers-readme.txt | 2 + elpa/auto-complete-chunk-readme.txt | 9 + elpa/auto-complete-clang-async-readme.txt | 3 + elpa/auto-complete-clang-readme.txt | 2 + elpa/auto-complete-exuberant-ctags-readme.txt | 19 + elpa/auto-complete-nxml-readme.txt | 2 + elpa/auto-complete-readme.txt | 16 + elpa/auto-complete-rst-readme.txt | 2 + elpa/auto-dictionary-readme.txt | 16 + elpa/popup-20140207.1702/popup-autoloads.el | 18 + elpa/popup-20140207.1702/popup-pkg.el | 1 + elpa/popup-20140207.1702/popup.el | 1411 ++++ 42 files changed, 18023 insertions(+) create mode 100644 elpa/auto-complete-20140618.2217/auto-complete-autoloads.el create mode 100644 elpa/auto-complete-20140618.2217/auto-complete-config.el create mode 100644 elpa/auto-complete-20140618.2217/auto-complete-pkg.el create mode 100644 elpa/auto-complete-20140618.2217/auto-complete.el create mode 100644 elpa/auto-complete-20140618.2217/dict/ada-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/c++-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/c-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/caml-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/clojure-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/clojurescript-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/coq-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/css-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/erlang-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/go-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/haskell-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/java-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/javascript-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/lua-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/php-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/python-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/qml-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/ruby-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/scheme-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/sclang-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/sh-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/tcl-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/ts-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/tuareg-mode create mode 100644 elpa/auto-complete-20140618.2217/dict/verilog-mode create mode 100644 elpa/auto-complete-auctex-readme.txt create mode 100644 elpa/auto-complete-c-headers-readme.txt create mode 100644 elpa/auto-complete-chunk-readme.txt create mode 100644 elpa/auto-complete-clang-async-readme.txt create mode 100644 elpa/auto-complete-clang-readme.txt create mode 100644 elpa/auto-complete-exuberant-ctags-readme.txt create mode 100644 elpa/auto-complete-nxml-readme.txt create mode 100644 elpa/auto-complete-readme.txt create mode 100644 elpa/auto-complete-rst-readme.txt create mode 100644 elpa/auto-dictionary-readme.txt create mode 100644 elpa/popup-20140207.1702/popup-autoloads.el create mode 100644 elpa/popup-20140207.1702/popup-pkg.el create mode 100644 elpa/popup-20140207.1702/popup.el diff --git a/elpa/auto-complete-20140618.2217/auto-complete-autoloads.el b/elpa/auto-complete-20140618.2217/auto-complete-autoloads.el new file mode 100644 index 00000000..87441a2f --- /dev/null +++ b/elpa/auto-complete-20140618.2217/auto-complete-autoloads.el @@ -0,0 +1,66 @@ +;;; auto-complete-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + + +;;;### (autoloads (global-auto-complete-mode auto-complete-mode auto-complete) +;;;;;; "auto-complete" "auto-complete.el" (21446 8669 0 0)) +;;; Generated autoloads from auto-complete.el + +(autoload 'auto-complete "auto-complete" "\ +Start auto-completion at current point. + +\(fn &optional SOURCES)" t nil) + +(autoload 'auto-complete-mode "auto-complete" "\ +AutoComplete mode + +\(fn &optional ARG)" t nil) + +(defvar global-auto-complete-mode nil "\ +Non-nil if Global-Auto-Complete mode is enabled. +See the command `global-auto-complete-mode' for a description of this minor mode. +Setting this variable directly does not take effect; +either customize it (see the info node `Easy Customization') +or call the function `global-auto-complete-mode'.") + +(custom-autoload 'global-auto-complete-mode "auto-complete" nil) + +(autoload 'global-auto-complete-mode "auto-complete" "\ +Toggle Auto-Complete mode in all buffers. +With prefix ARG, enable Global-Auto-Complete mode if ARG is positive; +otherwise, disable it. If called from Lisp, enable the mode if +ARG is omitted or nil. + +Auto-Complete mode is enabled in all buffers where +`auto-complete-mode-maybe' would do it. +See `auto-complete-mode' for more information on Auto-Complete mode. + +\(fn &optional ARG)" t nil) + +;;;*** + +;;;### (autoloads (ac-config-default) "auto-complete-config" "auto-complete-config.el" +;;;;;; (21446 8669 0 0)) +;;; Generated autoloads from auto-complete-config.el + +(autoload 'ac-config-default "auto-complete-config" "\ + + +\(fn)" nil nil) + +;;;*** + +;;;### (autoloads nil nil ("auto-complete-pkg.el") (21446 8669 72090 +;;;;;; 0)) + +;;;*** + +(provide 'auto-complete-autoloads) +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; auto-complete-autoloads.el ends here diff --git a/elpa/auto-complete-20140618.2217/auto-complete-config.el b/elpa/auto-complete-20140618.2217/auto-complete-config.el new file mode 100644 index 00000000..40e63bc8 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/auto-complete-config.el @@ -0,0 +1,521 @@ +;;; auto-complete-config.el --- auto-complete additional configuations + +;; Copyright (C) 2009, 2010 Tomohiro Matsuyama + +;; Author: Tomohiro Matsuyama +;; Keywords: convenience +;; Version: 1.4 + +;; 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 3 of the License, or +;; (at your option) any later version. + +;; 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 this program. If not, see . + +;;; Commentary: + +;; + +;;; Code: + +(eval-when-compile + (require 'cl)) + +(require 'auto-complete) + + + +;;;; Additional sources + +;; imenu + +(defvar ac-imenu-index nil) + +(ac-clear-variable-every-10-minutes 'ac-imenu-index) + +(defun ac-imenu-candidates () + (loop with i = 0 + with stack = (progn + (unless (local-variable-p 'ac-imenu-index) + (make-local-variable 'ac-imenu-index)) + (or ac-imenu-index + (setq ac-imenu-index + (ignore-errors + (with-no-warnings + (imenu--make-index-alist)))))) + with result + while (and stack (or (not (integerp ac-limit)) + (< i ac-limit))) + for node = (pop stack) + if (consp node) + do + (let ((car (car node)) + (cdr (cdr node))) + (if (consp cdr) + (mapc (lambda (child) + (push child stack)) + cdr) + (when (and (stringp car) + (string-match (concat "^" (regexp-quote ac-prefix)) car)) + ;; Remove extra characters + (if (string-match "^.*\\(()\\|=\\|<>\\)$" car) + (setq car (substring car 0 (match-beginning 1)))) + (push car result) + (incf i)))) + finally return (nreverse result))) + +(ac-define-source imenu + '((depends imenu) + (candidates . ac-imenu-candidates) + (symbol . "s"))) + +;; gtags + +(defface ac-gtags-candidate-face + '((t (:inherit ac-candidate-face :foreground "navy"))) + "Face for gtags candidate" + :group 'auto-complete) + +(defface ac-gtags-selection-face + '((t (:inherit ac-selection-face :background "navy"))) + "Face for the gtags selected candidate." + :group 'auto-complete) + +(defun ac-gtags-candidate () + (ignore-errors + (split-string (shell-command-to-string (format "global -ciq %s" ac-prefix)) "\n"))) + +(ac-define-source gtags + '((candidates . ac-gtags-candidate) + (candidate-face . ac-gtags-candidate-face) + (selection-face . ac-gtags-selection-face) + (requires . 3) + (symbol . "s"))) + +;; yasnippet + +(defface ac-yasnippet-candidate-face + '((t (:inherit ac-candidate-face + :background "sandybrown" :foreground "black"))) + "Face for yasnippet candidate." + :group 'auto-complete) + +(defface ac-yasnippet-selection-face + '((t (:inherit ac-selection-face :background "coral3"))) + "Face for the yasnippet selected candidate." + :group 'auto-complete) + +(defun ac-yasnippet-table-hash (table) + (cond + ((fboundp 'yas/snippet-table-hash) + (yas/snippet-table-hash table)) + ((fboundp 'yas/table-hash) + (yas/table-hash table)))) + +(defun ac-yasnippet-table-parent (table) + (cond + ((fboundp 'yas/snippet-table-parent) + (yas/snippet-table-parent table)) + ((fboundp 'yas/table-parent) + (yas/table-parent table)))) + +(defun ac-yasnippet-candidate-1 (table) + (with-no-warnings + (let ((hashtab (ac-yasnippet-table-hash table)) + (parent (ac-yasnippet-table-parent table)) + candidates) + (maphash (lambda (key value) + (push key candidates)) + hashtab) + (setq candidates (all-completions ac-prefix (nreverse candidates))) + (if parent + (setq candidates + (append candidates (ac-yasnippet-candidate-1 parent)))) + candidates))) + +(defun ac-yasnippet-candidates () + (with-no-warnings + (cond (;; 0.8 onwards + (fboundp 'yas-active-keys) + (all-completions ac-prefix (yas-active-keys))) + (;; >0.6.0 + (fboundp 'yas/get-snippet-tables) + (apply 'append (mapcar 'ac-yasnippet-candidate-1 + (condition-case nil + (yas/get-snippet-tables major-mode) + (wrong-number-of-arguments + (yas/get-snippet-tables))))) + ) + (t + (let ((table + (if (fboundp 'yas/snippet-table) + ;; <0.6.0 + (yas/snippet-table major-mode) + ;; 0.6.0 + (yas/current-snippet-table)))) + (if table + (ac-yasnippet-candidate-1 table))))))) + +(ac-define-source yasnippet + '((depends yasnippet) + (candidates . ac-yasnippet-candidates) + (action . yas/expand) + (candidate-face . ac-yasnippet-candidate-face) + (selection-face . ac-yasnippet-selection-face) + (symbol . "a"))) + +;; semantic + +(defun ac-semantic-candidates (prefix) + (with-no-warnings + (delete "" ; semantic sometimes returns an empty string + (mapcar (lambda (elem) + (cons (semantic-tag-name elem) + (semantic-tag-clone elem))) + (ignore-errors + (or (semantic-analyze-possible-completions + (semantic-analyze-current-context)) + (senator-find-tag-for-completion prefix))))))) + +(defun ac-semantic-doc (symbol) + (with-no-warnings + (let* ((proto (semantic-format-tag-summarize-with-file symbol nil t)) + (doc (semantic-documentation-for-tag symbol)) + (res proto)) + (when doc + (setq res (concat res "\n\n" doc))) + res))) + +(ac-define-source semantic + '((available . (or (require 'semantic-ia nil t) + (require 'semantic/ia nil t))) + (candidates . (ac-semantic-candidates ac-prefix)) + (document . ac-semantic-doc) + (prefix . cc-member) + (requires . 0) + (symbol . "m"))) + +(ac-define-source semantic-raw + '((available . (or (require 'semantic-ia nil t) + (require 'semantic/ia nil t))) + (candidates . (ac-semantic-candidates ac-prefix)) + (document . ac-semantic-doc) + (symbol . "s"))) + +;; eclim + +(defun ac-eclim-candidates () + (with-no-warnings + (loop for c in (eclim/java-complete) + collect (nth 1 c)))) + +(ac-define-source eclim + '((candidates . ac-eclim-candidates) + (prefix . c-dot) + (requires . 0) + (symbol . "f"))) + +;; css + +;; Copied from company-css.el +(defconst ac-css-property-alist + ;; see http://www.w3.org/TR/CSS21/propidx.html + '(("azimuth" angle "left-side" "far-left" "left" "center-left" "center" + "center-right" "right" "far-right" "right-side" "behind" "leftwards" + "rightwards") + ("background" background-color background-image background-repeat + background-attachment background-position) + ("background-attachment" "scroll" "fixed") + ("background-color" color "transparent") + ("background-image" uri "none") + ("background-position" percentage length "left" "center" "right" percentage + length "top" "center" "bottom" "left" "center" "right" "top" "center" + "bottom") + ("background-repeat" "repeat" "repeat-x" "repeat-y" "no-repeat") + ("border" border-width border-style border-color) + ("border-bottom" border) + ("border-bottom-color" border-color) + ("border-bottom-style" border-style) + ("border-bottom-width" border-width) + ("border-collapse" "collapse" "separate") + ("border-color" color "transparent") + ("border-left" border) + ("border-left-color" border-color) + ("border-left-style" border-style) + ("border-left-width" border-width) + ("border-right" border) + ("border-right-color" border-color) + ("border-right-style" border-style) + ("border-right-width" border-width) + ("border-spacing" length length) + ("border-style" border-style) + ("border-top" border) + ("border-top-color" border-color) + ("border-top-style" border-style) + ("border-top-width" border-width) + ("border-width" border-width) + ("bottom" length percentage "auto") + ("caption-side" "top" "bottom") + ("clear" "none" "left" "right" "both") + ("clip" shape "auto") + ("color" color) + ("content" "normal" "none" string uri counter "attr()" "open-quote" + "close-quote" "no-open-quote" "no-close-quote") + ("counter-increment" identifier integer "none") + ("counter-reset" identifier integer "none") + ("cue" cue-before cue-after) + ("cue-after" uri "none") + ("cue-before" uri "none") + ("cursor" uri "*" "auto" "crosshair" "default" "pointer" "move" "e-resize" + "ne-resize" "nw-resize" "n-resize" "se-resize" "sw-resize" "s-resize" + "w-resize" "text" "wait" "help" "progress") + ("direction" "ltr" "rtl") + ("display" "inline" "block" "list-item" "run-in" "inline-block" "table" + "inline-table" "table-row-group" "table-header-group" "table-footer-group" + "table-row" "table-column-group" "table-column" "table-cell" + "table-caption" "none") + ("elevation" angle "below" "level" "above" "higher" "lower") + ("empty-cells" "show" "hide") + ("float" "left" "right" "none") + ("font" font-style font-variant font-weight font-size "/" line-height + font-family "caption" "icon" "menu" "message-box" "small-caption" + "status-bar") + ("font-family" family-name generic-family) + ("font-size" absolute-size relative-size length percentage) + ("font-style" "normal" "italic" "oblique") + ("font-variant" "normal" "small-caps") + ("font-weight" "normal" "bold" "bolder" "lighter" "100" "200" "300" "400" + "500" "600" "700" "800" "900") + ("height" length percentage "auto") + ("left" length percentage "auto") + ("letter-spacing" "normal" length) + ("line-height" "normal" number length percentage) + ("list-style" list-style-type list-style-position list-style-image) + ("list-style-image" uri "none") + ("list-style-position" "inside" "outside") + ("list-style-type" "disc" "circle" "square" "decimal" "decimal-leading-zero" + "lower-roman" "upper-roman" "lower-greek" "lower-latin" "upper-latin" + "armenian" "georgian" "lower-alpha" "upper-alpha" "none") + ("margin" margin-width) + ("margin-bottom" margin-width) + ("margin-left" margin-width) + ("margin-right" margin-width) + ("margin-top" margin-width) + ("max-height" length percentage "none") + ("max-width" length percentage "none") + ("min-height" length percentage) + ("min-width" length percentage) + ("orphans" integer) + ("outline" outline-color outline-style outline-width) + ("outline-color" color "invert") + ("outline-style" border-style) + ("outline-width" border-width) + ("overflow" "visible" "hidden" "scroll" "auto") + ("padding" padding-width) + ("padding-bottom" padding-width) + ("padding-left" padding-width) + ("padding-right" padding-width) + ("padding-top" padding-width) + ("page-break-after" "auto" "always" "avoid" "left" "right") + ("page-break-before" "auto" "always" "avoid" "left" "right") + ("page-break-inside" "avoid" "auto") + ("pause" time percentage) + ("pause-after" time percentage) + ("pause-before" time percentage) + ("pitch" frequency "x-low" "low" "medium" "high" "x-high") + ("pitch-range" number) + ("play-during" uri "mix" "repeat" "auto" "none") + ("position" "static" "relative" "absolute" "fixed") + ("quotes" string string "none") + ("richness" number) + ("right" length percentage "auto") + ("speak" "normal" "none" "spell-out") + ("speak-header" "once" "always") + ("speak-numeral" "digits" "continuous") + ("speak-punctuation" "code" "none") + ("speech-rate" number "x-slow" "slow" "medium" "fast" "x-fast" "faster" + "slower") + ("stress" number) + ("table-layout" "auto" "fixed") + ("text-align" "left" "right" "center" "justify") + ("text-decoration" "none" "underline" "overline" "line-through" "blink") + ("text-indent" length percentage) + ("text-transform" "capitalize" "uppercase" "lowercase" "none") + ("top" length percentage "auto") + ("unicode-bidi" "normal" "embed" "bidi-override") + ("vertical-align" "baseline" "sub" "super" "top" "text-top" "middle" + "bottom" "text-bottom" percentage length) + ("visibility" "visible" "hidden" "collapse") + ("voice-family" specific-voice generic-voice "*" specific-voice + generic-voice) + ("volume" number percentage "silent" "x-soft" "soft" "medium" "loud" + "x-loud") + ("white-space" "normal" "pre" "nowrap" "pre-wrap" "pre-line") + ("widows" integer) + ("width" length percentage "auto") + ("word-spacing" "normal" length) + ("z-index" "auto" integer)) + "A list of CSS properties and their possible values.") + +(defconst ac-css-value-classes + '((absolute-size "xx-small" "x-small" "small" "medium" "large" "x-large" + "xx-large") + (border-style "none" "hidden" "dotted" "dashed" "solid" "double" "groove" + "ridge" "inset" "outset") + (color "aqua" "black" "blue" "fuchsia" "gray" "green" "lime" "maroon" "navy" + "olive" "orange" "purple" "red" "silver" "teal" "white" "yellow" + "rgb") + (counter "counter") + (family-name "Courier" "Helvetica" "Times") + (generic-family "serif" "sans-serif" "cursive" "fantasy" "monospace") + (generic-voice "male" "female" "child") + (margin-width "auto") ;; length percentage + (relative-size "larger" "smaller") + (shape "rect") + (uri "url")) + "A list of CSS property value classes and their contents.") + +(defconst ac-css-pseudo-classes + '("active" "after" "before" "first" "first-child" "first-letter" "first-line" + "focus" "hover" "lang" "left" "link" "right" "visited") + "Identifiers for CSS pseudo-elements and pseudo-classes.") + +(defvar ac-css-property nil + "Current editing property.") + +(defun ac-css-prefix () + (when (save-excursion (re-search-backward "\\_<\\(.+?\\)\\_>\\s *:[^;]*\\=" nil t)) + (setq ac-css-property (match-string 1)) + (or (ac-prefix-symbol) (point)))) + +(defun ac-css-property-candidates () + (let ((list (assoc-default ac-css-property ac-css-property-alist))) + (if list + (loop with seen + with value + while (setq value (pop list)) + if (symbolp value) + do (unless (memq value seen) + (push value seen) + (setq list + (append list + (or (assoc-default value ac-css-value-classes) + (assoc-default (symbol-name value) ac-css-property-alist))))) + else collect value) + ac-css-pseudo-classes))) + +(ac-define-source css-property + '((candidates . ac-css-property-candidates) + (prefix . ac-css-prefix) + (requires . 0))) + +;; slime +(ac-define-source slime + '((depends slime) + (candidates . (car (slime-simple-completions ac-prefix))) + (symbol . "s") + (cache))) + +;; ghc-mod +(ac-define-source ghc-mod + '((depends ghc) + (candidates . (ghc-select-completion-symbol)) + (symbol . "s") + (cache))) + + + +;;;; Not maintained sources + +;; ropemacs + +(defvar ac-ropemacs-loaded nil) +(defun ac-ropemacs-require () + (with-no-warnings + (unless ac-ropemacs-loaded + (pymacs-load "ropemacs" "rope-") + (if (boundp 'ropemacs-enable-autoimport) + (setq ropemacs-enable-autoimport t)) + (setq ac-ropemacs-loaded t)))) + +(defun ac-ropemacs-setup () + (ac-ropemacs-require) + ;(setq ac-sources (append (list 'ac-source-ropemacs) ac-sources)) + (setq ac-omni-completion-sources '(("\\." ac-source-ropemacs)))) + +(defun ac-ropemacs-initialize () + (autoload 'pymacs-apply "pymacs") + (autoload 'pymacs-call "pymacs") + (autoload 'pymacs-eval "pymacs" nil t) + (autoload 'pymacs-exec "pymacs" nil t) + (autoload 'pymacs-load "pymacs" nil t) + (add-hook 'python-mode-hook 'ac-ropemacs-setup) + t) + +(defvar ac-ropemacs-completions-cache nil) +(defvar ac-source-ropemacs + '((init + . (lambda () + (setq ac-ropemacs-completions-cache + (mapcar + (lambda (completion) + (concat ac-prefix completion)) + (ignore-errors + (rope-completions)))))) + (candidates . ac-ropemacs-completions-cache))) + +;; rcodetools + +(defvar ac-source-rcodetools + '((init . (lambda () + (require 'rcodetools) + (condition-case x + (save-excursion + (rct-exec-and-eval rct-complete-command-name "--completion-emacs-icicles")) + (error) (setq rct-method-completion-table nil)))) + (candidates . (lambda () + (all-completions + ac-prefix + (mapcar + (lambda (completion) + (replace-regexp-in-string "\t.*$" "" (car completion))) + rct-method-completion-table)))))) + + + +;;;; Default settings + +(defun ac-common-setup () + ;(add-to-list 'ac-sources 'ac-source-filename) + ) + +(defun ac-emacs-lisp-mode-setup () + (setq ac-sources (append '(ac-source-features ac-source-functions ac-source-yasnippet ac-source-variables ac-source-symbols) ac-sources))) + +(defun ac-cc-mode-setup () + (setq ac-sources (append '(ac-source-yasnippet ac-source-gtags) ac-sources))) + +(defun ac-ruby-mode-setup ()) + +(defun ac-css-mode-setup () + (setq ac-sources (append '(ac-source-css-property) ac-sources))) + +;;;###autoload +(defun ac-config-default () + (setq-default ac-sources '(ac-source-abbrev ac-source-dictionary ac-source-words-in-same-mode-buffers)) + (add-hook 'emacs-lisp-mode-hook 'ac-emacs-lisp-mode-setup) + (add-hook 'c-mode-common-hook 'ac-cc-mode-setup) + (add-hook 'ruby-mode-hook 'ac-ruby-mode-setup) + (add-hook 'css-mode-hook 'ac-css-mode-setup) + (add-hook 'auto-complete-mode-hook 'ac-common-setup) + (global-auto-complete-mode t)) + +(provide 'auto-complete-config) +;;; auto-complete-config.el ends here diff --git a/elpa/auto-complete-20140618.2217/auto-complete-pkg.el b/elpa/auto-complete-20140618.2217/auto-complete-pkg.el new file mode 100644 index 00000000..3346991e --- /dev/null +++ b/elpa/auto-complete-20140618.2217/auto-complete-pkg.el @@ -0,0 +1,2 @@ +(define-package "auto-complete" "20140618.2217" "Auto Completion for GNU Emacs" + '((popup "0.5.0"))) diff --git a/elpa/auto-complete-20140618.2217/auto-complete.el b/elpa/auto-complete-20140618.2217/auto-complete.el new file mode 100644 index 00000000..9fc14792 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/auto-complete.el @@ -0,0 +1,2076 @@ +;;; auto-complete.el --- Auto Completion for GNU Emacs + +;; Copyright (C) 2008, 2009, 2010, 2011, 2012, 2013 Tomohiro Matsuyama + +;; Author: Tomohiro Matsuyama +;; URL: http://cx4a.org/software/auto-complete +;; Keywords: completion, convenience +;; Version: 1.4.0 + +;; 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 3 of the License, or +;; (at your option) any later version. + +;; 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 this program. If not, see . + +;;; Commentary: +;; +;; This extension provides a way to complete with popup menu like: +;; +;; def-!- +;; +-----------------+ +;; |defun::::::::::::| +;; |defvar | +;; |defmacro | +;; | ... | +;; +-----------------+ +;; +;; You can complete by typing and selecting menu. +;; +;; Entire documents are located in doc/ directory. +;; Take a look for information. +;; +;; Enjoy! + +;;; Code: + + + +(defconst ac-version "1.4.0") + +(eval-when-compile + (require 'cl)) + +(require 'popup) + +;;;; Global stuff + +(defun ac-error (&optional var) + "Report an error and disable `auto-complete-mode'." + (ignore-errors + (message "auto-complete error: %s" var) + (auto-complete-mode -1) + var)) + + + +;;;; Customization + +(defgroup auto-complete nil + "Auto completion." + :group 'completion + :prefix "ac-") + +(defcustom ac-delay 0.1 + "Delay to completions will be available." + :type 'float + :group 'auto-complete) + +(defcustom ac-auto-show-menu 0.8 + "Non-nil means completion menu will be automatically shown." + :type '(choice (const :tag "Yes" t) + (const :tag "Never" nil) + (float :tag "Timer")) + :group 'auto-complete) + +(defcustom ac-show-menu-immediately-on-auto-complete t + "Non-nil means menu will be showed immediately on `auto-complete'." + :type 'boolean + :group 'auto-complete) + +(defcustom ac-expand-on-auto-complete t + "Non-nil means expand whole common part on first time `auto-complete'." + :type 'boolean + :group 'auto-complete) + +(defcustom ac-disable-faces '(font-lock-comment-face font-lock-string-face font-lock-doc-face) + "Non-nil means disable automatic completion on specified faces." + :type '(repeat symbol) + :group 'auto-complete) + +(defcustom ac-stop-flymake-on-completing t + "Non-nil means disble flymake temporarily on completing." + :type 'boolean + :group 'auto-complete) + +(defcustom ac-use-fuzzy (and (locate-library "fuzzy") t) + "Non-nil means use fuzzy matching." + :type 'boolean + :group 'auto-complete) + +(defcustom ac-fuzzy-cursor-color "red" + "Cursor color in fuzzy mode." + :type 'string + :group 'auto-complete) + +(defcustom ac-use-comphist t + "Non-nil means use intelligent completion history." + :type 'boolean + :group 'auto-complete) + +(defcustom ac-comphist-threshold 0.7 + "Percentage of ignoring low scored candidates." + :type 'float + :group 'auto-complete) + +(defcustom ac-comphist-file + (expand-file-name (concat (if (boundp 'user-emacs-directory) + user-emacs-directory + "~/.emacs.d/") + "/ac-comphist.dat")) + "Completion history file name." + :type 'string + :group 'auto-complete) + +(defcustom ac-user-dictionary nil + "User defined dictionary" + :type '(repeat string) + :group 'auto-complete) + +(defcustom ac-dictionary-files '("~/.dict") + "Dictionary files." + :type '(repeat string) + :group 'auto-complete) +(defvaralias 'ac-user-dictionary-files 'ac-dictionary-files) + +(defcustom ac-dictionary-directories + (ignore-errors + (when load-file-name + (let ((installed-dir (file-name-directory load-file-name))) + (loop for name in '("ac-dict" "dict") + for dir = (concat installed-dir name) + if (file-directory-p dir) + collect dir)))) + "Dictionary directories." + :type '(repeat string) + :group 'auto-complete) + +(defcustom ac-use-quick-help t + "Non-nil means use quick help." + :type 'boolean + :group 'auto-complete) + +(defcustom ac-quick-help-delay 1.5 + "Delay to show quick help." + :type 'float + :group 'auto-complete) + +(defcustom ac-menu-height 10 + "Max height of candidate menu." + :type 'integer + :group 'auto-complete) +(defvaralias 'ac-candidate-menu-height 'ac-menu-height) + +(defcustom ac-quick-help-height 20 + "Max height of quick help." + :type 'integer + :group 'auto-complete) + +(defcustom ac-quick-help-prefer-pos-tip t + "Prefer native tooltip with pos-tip than overlay popup for displaying quick help." + :type 'boolean + :group 'auto-complete) +(defvaralias 'ac-quick-help-prefer-x 'ac-quick-help-prefer-pos-tip) + +(defcustom ac-candidate-limit nil + "Limit number of candidates. Non-integer means no limit." + :type 'integer + :group 'auto-complete) +(defvaralias 'ac-candidate-max 'ac-candidate-limit) + +(defcustom ac-modes + '(emacs-lisp-mode lisp-mode lisp-interaction-mode + slime-repl-mode + c-mode cc-mode c++-mode go-mode + java-mode malabar-mode clojure-mode clojurescript-mode scala-mode + scheme-mode + ocaml-mode tuareg-mode coq-mode haskell-mode agda-mode agda2-mode + perl-mode cperl-mode python-mode ruby-mode lua-mode tcl-mode + ecmascript-mode javascript-mode js-mode js2-mode php-mode css-mode + makefile-mode sh-mode fortran-mode f90-mode ada-mode + xml-mode sgml-mode + ts-mode + sclang-mode + verilog-mode + qml-mode) + "Major modes `auto-complete-mode' can run on." + :type '(repeat symbol) + :group 'auto-complete) + +(defcustom ac-compatible-packages-regexp + "^ac-" + "Regexp to indicate what packages can work with auto-complete." + :type 'string + :group 'auto-complete) + +(defcustom ac-non-trigger-commands + '(*table--cell-self-insert-command + electric-buffer-list) + "Commands that can't be used as triggers of `auto-complete'." + :type '(repeat symbol) + :group 'auto-complete) + +(defcustom ac-trigger-commands + '(self-insert-command) + "Trigger commands that specify whether `auto-complete' should start or not." + :type '(repeat symbol) + :group 'auto-complete) + +(defcustom ac-trigger-commands-on-completing + '(delete-backward-char + backward-delete-char + backward-delete-char-untabify + ;; autopair + autopair-backspace + ;; paredit + paredit-backward-delete + paredit-backward-delete-word) + "Trigger commands that specify whether `auto-complete' should continue or not." + :type '(repeat symbol) + :group 'auto-complete) + +(defcustom ac-trigger-key nil + "Non-nil means `auto-complete' will start by typing this key. +If you specify this TAB, for example, `auto-complete' will start by typing TAB, +and if there is no completions, an original command will be fallbacked." + :type '(choice (const :tag "None" nil) + (string :tag "Key")) + :group 'auto-complete + :set (lambda (symbol value) + (set-default symbol value) + (when (and value + (fboundp 'ac-set-trigger-key)) + (ac-set-trigger-key value)))) + +(defcustom ac-auto-start 2 + "Non-nil means completion will be started automatically. +Positive integer means if a length of a word you entered is larger than the value, +completion will be started automatically. +If you specify `nil', never be started automatically." + :type '(choice (const :tag "Yes" t) + (const :tag "Never" nil) + (integer :tag "Require")) + :group 'auto-complete) + +(defcustom ac-stop-words nil + "List of string to stop completion." + :type '(repeat string) + :group 'auto-complete) +(defvaralias 'ac-ignores 'ac-stop-words) + +(defcustom ac-use-dictionary-as-stop-words t + "Non-nil means a buffer related dictionary will be thought of as stop words." + :type 'boolean + :group 'auto-complete) + +(defcustom ac-ignore-case 'smart + "Non-nil means auto-complete ignores case. +If this value is `smart', auto-complete ignores case only when +a prefix doen't contain any upper case letters." + :type '(choice (const :tag "Yes" t) + (const :tag "Smart" smart) + (const :tag "No" nil)) + :group 'auto-complete) + +(defcustom ac-dwim t + "Non-nil means `auto-complete' works based on Do What I Mean." + :type 'boolean + :group 'auto-complete) + +(defcustom ac-use-menu-map nil + "Non-nil means a special keymap `ac-menu-map' on completing menu will be used." + :type 'boolean + :group 'auto-complete) + +(defcustom ac-use-overriding-local-map nil + "Non-nil means `overriding-local-map' will be used to hack for overriding key events on auto-completion." + :type 'boolean + :group 'auto-complete) + +(defcustom ac-disable-inline nil + "Non-nil disable inline completion visibility" + :type 'boolean + :group 'auto-complete) + +(defcustom ac-candidate-menu-min 1 + "Number of candidates required to display menu" + :type 'integer + :group 'auto-complete) + +(defcustom ac-max-width nil + "Maximum width for auto-complete menu to have" + :type '(choice (const :tag "No limit" nil) + (const :tag "Character Limit" 25) + (const :tag "Window Ratio Limit" 0.5)) + :group 'auto-complete) + +(defface ac-completion-face + '((t (:foreground "darkgray" :underline t))) + "Face for inline completion" + :group 'auto-complete) + +(defface ac-candidate-face + '((t (:inherit popup-face))) + "Face for candidate." + :group 'auto-complete) + +(defface ac-candidate-mouse-face + '((t (:inherit popup-menu-mouse-face))) + "Mouse face for candidate." + :group 'auto-complete) + +(defface ac-selection-face + '((t (:inherit popup-menu-selection-face))) + "Face for selected candidate." + :group 'auto-complete) + +(defvar auto-complete-mode-hook nil + "Hook for `auto-complete-mode'.") + + + +;;;; Internal variables + +(defvar auto-complete-mode nil + "Dummy variable to suppress compiler warnings.") + +(defvar ac-cursor-color nil + "Old cursor color.") + +(defvar ac-inline nil + "Inline completion instance.") + +(defvar ac-menu nil + "Menu instance.") + +(defvar ac-show-menu nil + "Flag to show menu on timer tick.") + +(defvar ac-last-completion nil + "Cons of prefix marker and selected item of last completion.") + +(defvar ac-quick-help nil + "Quick help instance") + +(defvar ac-completing nil + "Non-nil means `auto-complete-mode' is now working on completion.") + +(defvar ac-buffer nil + "Buffer where auto-complete is started.") + +(defvar ac-point nil + "Start point of prefix.") + +(defvar ac-last-point nil + "Last point of updating pattern.") + +(defvar ac-prefix nil + "Prefix string.") +(defvaralias 'ac-target 'ac-prefix) + +(defvar ac-selected-candidate nil + "Last selected candidate.") + +(defvar ac-common-part nil + "Common part string of meaningful candidates. +If there is no common part, this will be nil.") + +(defvar ac-whole-common-part nil + "Common part string of whole candidates. +If there is no common part, this will be nil.") + +(defvar ac-prefix-overlay nil + "Overlay for prefix string.") + +(defvar ac-timer nil + "Completion idle timer.") + +(defvar ac-show-menu-timer nil + "Show menu idle timer.") + +(defvar ac-quick-help-timer nil + "Quick help idle timer.") + +(defvar ac-triggered nil + "Flag to update.") + +(defvar ac-limit nil + "Limit number of candidates for each sources.") + +(defvar ac-candidates nil + "Current candidates.") + +(defvar ac-candidates-cache nil + "Candidates cache for individual sources.") + +(defvar ac-fuzzy-enable nil + "Non-nil means fuzzy matching is enabled.") + +(defvar ac-dwim-enable nil + "Non-nil means DWIM completion will be allowed.") + +(defvar ac-mode-map (make-sparse-keymap) + "Auto-complete mode map. It is also used for trigger key command. See also `ac-trigger-key'.") + +(defvar ac-completing-map + (let ((map (make-sparse-keymap))) + (define-key map "\t" 'ac-expand) + (define-key map [tab] 'ac-expand) + (define-key map "\r" 'ac-complete) + (define-key map [return] 'ac-complete) + (define-key map (kbd "M-TAB") 'auto-complete) + + (define-key map "\M-n" 'ac-next) + (define-key map "\M-p" 'ac-previous) + (define-key map [down] 'ac-next) + (define-key map [up] 'ac-previous) + + (define-key map [f1] 'ac-help) + (define-key map [M-f1] 'ac-persist-help) + (define-key map (kbd "C-?") 'ac-help) + (define-key map (kbd "C-M-?") 'ac-persist-help) + + (define-key map [C-down] 'ac-quick-help-scroll-down) + (define-key map [C-up] 'ac-quick-help-scroll-up) + (define-key map "\C-\M-n" 'ac-quick-help-scroll-down) + (define-key map "\C-\M-p" 'ac-quick-help-scroll-up) + + (dotimes (i 9) + (let ((symbol (intern (format "ac-complete-select-%d" (1+ i))))) + (fset symbol + `(lambda () + (interactive) + (when (and (ac-menu-live-p) (popup-select ac-menu ,i)) + (ac-complete)))) + (define-key map (read-kbd-macro (format "M-%s" (1+ i))) symbol))) + + map) + "Keymap for completion.") +(defvaralias 'ac-complete-mode-map 'ac-completing-map) + +(defvar ac-menu-map + (let ((map (make-sparse-keymap))) + (set-keymap-parent map ac-completing-map) + (define-key map "\C-n" 'ac-next) + (define-key map "\C-p" 'ac-previous) + (define-key map "\C-s" 'ac-isearch) + (define-key map [mouse-1] 'ac-mouse-1) + (define-key map [down-mouse-1] 'ac-ignore) + (define-key map [mouse-4] 'ac-mouse-4) + (define-key map [mouse-5] 'ac-mouse-5) + map) + "Keymap for completion on completing menu.") + +(defvar ac-current-map + (let ((map (make-sparse-keymap))) + (set-keymap-parent map ac-completing-map) + map)) + +(defvar ac-match-function 'all-completions + "Default match function.") + +(defvar ac-prefix-definitions + '((symbol . ac-prefix-symbol) + (file . ac-prefix-file) + (valid-file . ac-prefix-valid-file) + (c-dot . ac-prefix-c-dot) + (c-dot-ref . ac-prefix-c-dot-ref) + (cc-member . ac-prefix-cc-member)) + "Prefix definitions for common use.") + +(defvar ac-sources '(ac-source-words-in-same-mode-buffers) + "Sources for completion.") +(make-variable-buffer-local 'ac-sources) + +(defvar ac-compiled-sources nil + "Compiled source of `ac-sources'.") + +(defvar ac-current-sources nil + "Current working sources. This is sublist of `ac-compiled-sources'.") + +(defvar ac-omni-completion-sources nil + "Do not use this anymore.") + +(defvar ac-current-prefix-def nil) + +(defvar ac-ignoring-prefix-def nil) + + + +;;;; Intelligent completion history + +(defvar ac-comphist nil + "Database of completion history.") + +(defsubst ac-comphist-make-tab () + (make-hash-table :test 'equal)) + +(defsubst ac-comphist-tab (db) + (nth 0 db)) + +(defsubst ac-comphist-cache (db) + (nth 1 db)) + +(defun ac-comphist-make (&optional tab) + (list (or tab (ac-comphist-make-tab)) (make-hash-table :test 'equal :weakness t))) + +(defun ac-comphist-get (db string &optional create) + (let* ((tab (ac-comphist-tab db)) + (index (gethash string tab))) + (when (and create (null index)) + (setq index (make-vector (length string) 0)) + (puthash string index tab)) + index)) + +(defun ac-comphist-add (db string prefix) + (setq prefix (min prefix (1- (length string)))) + (when (<= 0 prefix) + (setq string (substring-no-properties string)) + (let ((stat (ac-comphist-get db string t))) + (incf (aref stat prefix)) + (remhash string (ac-comphist-cache db))))) + +(defun ac-comphist-score (db string prefix) + (setq prefix (min prefix (1- (length string)))) + (if (<= 0 prefix) + (let ((cache (gethash string (ac-comphist-cache db)))) + (or (and cache (aref cache prefix)) + (let ((stat (ac-comphist-get db string)) + (score 0.0)) + (when stat + (loop for p from 0 below (length string) + ;; sigmoid function + with a = 5 + with b = (/ 700.0 a) ; bounds for avoiding range error in `exp' + with d = (/ 6.0 a) + for x = (max (- b) (min b (- d (abs (- prefix p))))) + for r = (/ 1.0 (1+ (exp (* (- a) x)))) + do + (incf score (* (aref stat p) r)))) + ;; Weight by distance + (incf score (max 0.0 (- 0.3 (/ (- (length string) prefix) 100.0)))) + (unless cache + (setq cache (make-vector (length string) nil)) + (puthash string cache (ac-comphist-cache db))) + (aset cache prefix score) + score))) + 0.0)) + +(defun ac-comphist-sort (db collection prefix &optional threshold) + (let (result + (n 0) + (total 0) + (cur 0)) + (setq result (mapcar (lambda (a) + (when (and cur threshold) + (if (>= cur (* total threshold)) + (setq cur nil) + (incf n) + (incf cur (cdr a)))) + (car a)) + (sort (mapcar (lambda (string) + (let ((score (ac-comphist-score db string prefix))) + (incf total score) + (cons string score))) + collection) + (lambda (a b) (< (cdr b) (cdr a)))))) + (if threshold + (cons n result) + result))) + +(defun ac-comphist-serialize (db) + (let (alist) + (maphash (lambda (k v) + (push (cons k v) alist)) + (ac-comphist-tab db)) + (list alist))) + +(defun ac-comphist-deserialize (sexp) + (condition-case nil + (ac-comphist-make (let ((tab (ac-comphist-make-tab))) + (mapc (lambda (cons) + (puthash (car cons) (cdr cons) tab)) + (nth 0 sexp)) + tab)) + (error (message "Invalid comphist db.") nil))) + +(defun ac-comphist-init () + (ac-comphist-load) + (add-hook 'kill-emacs-hook 'ac-comphist-save)) + +(defun ac-comphist-load () + (interactive) + (let ((db (if (file-exists-p ac-comphist-file) + (ignore-errors + (with-temp-buffer + (insert-file-contents ac-comphist-file) + (goto-char (point-min)) + (ac-comphist-deserialize (read (current-buffer)))))))) + (setq ac-comphist (or db (ac-comphist-make))))) + +(defun ac-comphist-save () + (interactive) + (require 'pp) + (ignore-errors + (with-temp-buffer + (pp (ac-comphist-serialize ac-comphist) (current-buffer)) + (write-region (point-min) (point-max) ac-comphist-file)))) + + + +;;;; Dictionary +(defvar ac-buffer-dictionary nil) +(defvar ac-file-dictionary (make-hash-table :test 'equal)) + +(defun ac-clear-dictionary-cache () + (interactive) + (dolist (buffer (buffer-list)) + (with-current-buffer buffer + (if (local-variable-p 'ac-buffer-dictionary) + (kill-local-variable 'ac-buffer-dictionary)))) + (clrhash ac-file-dictionary)) + +(defun ac-file-dictionary (filename) + (let ((cache (gethash filename ac-file-dictionary 'none))) + (if (and cache (not (eq cache 'none))) + cache + (let (result) + (ignore-errors + (with-temp-buffer + (insert-file-contents filename) + (setq result (split-string (buffer-string) "\n" t)))) + (puthash filename result ac-file-dictionary) + result)))) + +(defun ac-mode-dictionary (mode) + (loop for name in (cons (symbol-name mode) + (ignore-errors (list (file-name-extension (buffer-file-name))))) + append (loop for dir in ac-dictionary-directories + for file = (concat dir "/" name) + if (file-exists-p file) + append (ac-file-dictionary file)))) + +(defun ac-buffer-dictionary (&optional buffer) + (with-current-buffer (or buffer (current-buffer)) + (if (local-variable-p 'ac-buffer-dictionary) + ac-buffer-dictionary + (make-local-variable 'ac-buffer-dictionary) + (setq ac-buffer-dictionary + (apply 'append + ac-user-dictionary + (ac-mode-dictionary major-mode) + (mapcar 'ac-file-dictionary ac-dictionary-files)))))) + + + +;;;; Auto completion internals + +(defun ac-menu-at-wrapper-line-p () + "Return non-nil if current line is long and wrapped to next visual line." + (and (not truncate-lines) + (eq (line-beginning-position) + (save-excursion + (vertical-motion 1) + (line-beginning-position))))) + +(defun ac-stop-word-p (word) + (or (member word ac-stop-words) + (if ac-use-dictionary-as-stop-words + (member word (ac-buffer-dictionary))))) + +(defun ac-prefix-default () + "Same as `ac-prefix-symbol' but ignore a number prefix." + (let ((start (ac-prefix-symbol))) + (when start + (loop with end = (point) + for pos from start below end + for c = (char-after pos) + if (not (and (<= ?0 c) (<= c ?9))) + return start)))) + +(defun ac-prefix-symbol () + "Default prefix definition function." + (require 'thingatpt) + (car-safe (bounds-of-thing-at-point 'symbol))) + +(defun ac-prefix-file () + "File prefix." + (let ((point (re-search-backward "[\"<>' \t\r\n]" nil t))) + (if point (1+ point)))) + +(defsubst ac-windows-remote-file-p (file) + (and (memq system-type '(ms-dos windows-nt cygwin)) + (string-match-p "\\`\\(?://\\|\\\\\\\\\\)" file))) + +(defun ac-prefix-valid-file () + "Existed (or to be existed) file prefix." + (let* ((line-beg (line-beginning-position)) + (end (point)) + (start (or (let ((point (re-search-backward "[\"<>'= \t\r\n]" line-beg t))) + (if point (1+ point))) + line-beg)) + (file (buffer-substring start end))) + (if (and file (or (string-match "^/" file) + (and (setq file (and (string-match "^[^/]*/" file) + (match-string 0 file))) + (file-directory-p file)))) + (unless (ac-windows-remote-file-p file) + start)))) + +(defun ac-prefix-c-dot () + "C-like languages dot(.) prefix." + (if (re-search-backward "\\.\\(\\(?:[a-zA-Z0-9][_a-zA-Z0-9]*\\)?\\)\\=" nil t) + (match-beginning 1))) + +(defun ac-prefix-c-dot-ref () + "C-like languages dot(.) and reference(->) prefix." + (if (re-search-backward "\\(?:\\.\\|->\\)\\(\\(?:[a-zA-Z0-9][_a-zA-Z0-9]*\\)?\\)\\=" nil t) + (match-beginning 1))) + +(defun ac-prefix-cc-member () + "C-like languages member(.)(->)(::) prefix." + (when (re-search-backward "\\(?:\\.\\|->\\|::\\)\\(\\(?:[a-zA-Z0-9][_a-zA-Z0-9]*\\)?\\)\\=" nil t) + (match-beginning 1))) + +(defun ac-define-prefix (name prefix) + "Define new prefix definition. +You can not use it in source definition like (prefix . `NAME')." + (push (cons name prefix) ac-prefix-definitions)) + +(defun ac-match-substring (prefix candidates) + (loop with regexp = (regexp-quote prefix) + for candidate in candidates + if (string-match regexp candidate) + collect candidate)) + +(defsubst ac-source-entity (source) + (if (symbolp source) + (symbol-value source) + source)) + +(defun ac-source-available-p (source) + (if (and (symbolp source) + (get source 'available)) + (eq (get source 'available) t) + (let* ((src (ac-source-entity source)) + (avail-pair (assq 'available src)) + (avail-cond (cdr avail-pair)) + (available (and (if avail-pair + (cond + ((symbolp avail-cond) + (funcall avail-cond)) + ((listp avail-cond) + (eval avail-cond))) + t) + (loop for feature in (assoc-default 'depends src) + unless (require feature nil t) return nil + finally return t)))) + (if (symbolp source) + (put source 'available (if available t 'no))) + available))) + +(defun ac-compile-sources (sources) + "Compiled `SOURCES' into expanded sources style." + (loop for source in sources + if (ac-source-available-p source) + do + (setq source (ac-source-entity source)) + ;; prefix + (let* ((prefix (assoc 'prefix source)) + (real (assoc-default (cdr prefix) ac-prefix-definitions))) + (cond + (real + (add-to-list 'source (cons 'prefix real))) + ((null prefix) + (add-to-list 'source (cons 'prefix 'ac-prefix-default))))) + ;; match + (let ((match (assq 'match source))) + (cond + ((eq (cdr match) 'substring) + (setcdr match 'ac-match-substring)))) + and collect source)) + +(defun ac-compiled-sources () + (or ac-compiled-sources + (setq ac-compiled-sources + (ac-compile-sources ac-sources)))) + +(defsubst ac-menu-live-p () + (popup-live-p ac-menu)) + +(defun ac-menu-create (point width height) + (setq ac-menu + (popup-create point width height + :around t + :face 'ac-candidate-face + :max-width ac-max-width + :mouse-face 'ac-candidate-mouse-face + :selection-face 'ac-selection-face + :symbol t + :scroll-bar t + :margin-left 1 + :keymap ac-menu-map + ))) + +(defun ac-menu-delete () + (when ac-menu + (popup-delete ac-menu) + (setq ac-menu))) + +(defsubst ac-inline-overlay () + (nth 0 ac-inline)) + +(defsubst ac-inline-live-p () + (and ac-inline (ac-inline-overlay) t)) + +(defun ac-inline-show (point string) + (unless ac-inline + (setq ac-inline (list nil))) + (save-excursion + (let ((overlay (ac-inline-overlay)) + (width 0) + (string-width (string-width string)) + (length 0) + (original-string string)) + ;; Calculate string space to show completion + (goto-char point) + (let (c) + (while (and (not (eolp)) + (< width string-width) + (setq c (char-after)) + (not (eq c ?\t))) ; special case for tab + (incf width (char-width c)) + (incf length) + (forward-char))) + + ;; Show completion + (goto-char point) + (cond + ((= width 0) + ;; End-of-line + ;; Do nothing + ) + ((<= width string-width) + ;; No space to show + ;; Do nothing + ) + ((> width string-width) + ;; Need to fill space + (setq string (concat string (make-string (- width string-width) ? ))))) + (setq string (propertize string 'face 'ac-completion-face)) + (if overlay + (progn + (move-overlay overlay point (+ point length)) + (overlay-put overlay 'invisible nil)) + (setq overlay (make-overlay point (+ point length))) + (setf (nth 0 ac-inline) overlay) + (overlay-put overlay 'priority 9999) + ;; Help prefix-overlay in some cases + (overlay-put overlay 'keymap ac-current-map)) + ;; TODO no width but char + (if (eq length 0) + ;; Case: End-of-line + (progn + (put-text-property 0 1 'cursor t string) + (overlay-put overlay 'after-string string)) + (let ((display (substring string 0 1)) + (after-string (substring string 1))) + (overlay-put overlay 'display display) + (overlay-put overlay 'after-string after-string))) + (overlay-put overlay 'string original-string)))) + +(defun ac-inline-delete () + (when (ac-inline-live-p) + (ac-inline-hide) + (delete-overlay (ac-inline-overlay)) + (setq ac-inline nil))) + +(defun ac-inline-hide () + (when (ac-inline-live-p) + (let ((overlay (ac-inline-overlay)) + (buffer-undo-list t)) + (when overlay + (move-overlay overlay (point-min) (point-min)) + (overlay-put overlay 'invisible t) + (overlay-put overlay 'display nil) + (overlay-put overlay 'after-string nil))))) + +(defun ac-inline-update () + (if (and ac-completing ac-prefix (stringp ac-common-part)) + (let ((common-part-length (length ac-common-part)) + (prefix-length (length ac-prefix))) + (if (> common-part-length prefix-length) + (progn + (ac-inline-hide) + (ac-inline-show (point) (substring ac-common-part prefix-length))) + (ac-inline-delete))) + (ac-inline-delete))) + +(defun ac-put-prefix-overlay () + (unless ac-prefix-overlay + (let (newline) + ;; Insert newline to make sure that cursor always on the overlay + (when (eobp) + (popup-save-buffer-state + (insert "\n")) + (setq newline t)) + (setq ac-prefix-overlay (make-overlay ac-point (1+ (point)) nil t t)) + (overlay-put ac-prefix-overlay 'priority 9999) + (overlay-put ac-prefix-overlay 'keymap (make-sparse-keymap)) + (overlay-put ac-prefix-overlay 'newline newline)))) + +(defun ac-remove-prefix-overlay () + (when ac-prefix-overlay + (when (overlay-get ac-prefix-overlay 'newline) + ;; Remove inserted newline + (popup-save-buffer-state + (goto-char (point-max)) + (if (eq (char-before) ?\n) + (delete-char -1)))) + (delete-overlay ac-prefix-overlay))) + +(defun ac-activate-completing-map () + (if (and ac-show-menu ac-use-menu-map) + (set-keymap-parent ac-current-map ac-menu-map)) + (when (and ac-use-overriding-local-map + (null overriding-terminal-local-map)) + (setq overriding-terminal-local-map ac-current-map)) + (when ac-prefix-overlay + (set-keymap-parent (overlay-get ac-prefix-overlay 'keymap) ac-current-map))) + +(defun ac-deactivate-completing-map () + (set-keymap-parent ac-current-map ac-completing-map) + (when (and ac-use-overriding-local-map + (eq overriding-terminal-local-map ac-current-map)) + (setq overriding-terminal-local-map nil)) + (when ac-prefix-overlay + (set-keymap-parent (overlay-get ac-prefix-overlay 'keymap) nil))) + +(defsubst ac-selected-candidate () + (if ac-menu + (popup-selected-item ac-menu))) + +(defun ac-prefix (requires ignore-list) + (loop with current = (point) + with point + with prefix-def + with sources + for source in (ac-compiled-sources) + for prefix = (assoc-default 'prefix source) + for req = (or (assoc-default 'requires source) requires 1) + + if (null prefix-def) + do + (unless (member prefix ignore-list) + (save-excursion + (setq point (cond + ((symbolp prefix) + (funcall prefix)) + ((stringp prefix) + (and (re-search-backward (concat prefix "\\=") nil t) + (or (match-beginning 1) (match-beginning 0)))) + ((stringp (car-safe prefix)) + (let ((regexp (nth 0 prefix)) + (end (nth 1 prefix)) + (group (nth 2 prefix))) + (and (re-search-backward (concat regexp "\\=") nil t) + (funcall (if end 'match-end 'match-beginning) + (or group 0))))) + (t + (eval prefix)))) + (if (and point + (integerp req) + (< (- current point) req)) + (setq point nil)) + (if point + (setq prefix-def prefix)))) + + if (equal prefix prefix-def) do (push source sources) + + finally return + (and point (list prefix-def point (nreverse sources))))) + +(defun ac-init () + "Initialize current sources to start completion." + (setq ac-candidates-cache nil) + (loop for source in ac-current-sources + for function = (assoc-default 'init source) + if function do + (save-excursion + (cond + ((functionp function) + (funcall function)) + (t + (eval function)))))) + +(defun ac-candidates-1 (source) + (let* ((do-cache (assq 'cache source)) + (function (assoc-default 'candidates source)) + (action (assoc-default 'action source)) + (document (assoc-default 'document source)) + (symbol (assoc-default 'symbol source)) + (ac-limit (or (assoc-default 'limit source) ac-limit)) + (face (or (assoc-default 'face source) (assoc-default 'candidate-face source))) + (selection-face (assoc-default 'selection-face source)) + (cache (and do-cache (assq source ac-candidates-cache))) + (candidates (cdr cache))) + (unless cache + (setq candidates (save-excursion + (cond + ((functionp function) + (funcall function)) + (t + (eval function))))) + ;; Convert (name value) format candidates into name with text properties. + (setq candidates (mapcar (lambda (candidate) + (if (consp candidate) + (propertize (car candidate) 'value (cdr candidate)) + candidate)) + candidates)) + (when do-cache + (push (cons source candidates) ac-candidates-cache))) + (setq candidates (funcall (or (assoc-default 'match source) + ac-match-function) + ac-prefix candidates)) + ;; Remove extra items regarding to ac-limit + (if (and (integerp ac-limit) (> ac-limit 1) (> (length candidates) ac-limit)) + (setcdr (nthcdr (1- ac-limit) candidates) nil)) + ;; Put candidate properties + (setq candidates (mapcar (lambda (candidate) + (popup-item-propertize candidate + 'action action + 'symbol symbol + 'document document + 'popup-face face + 'selection-face selection-face)) + candidates)) + candidates)) + +(defun ac-candidates () + "Produce candidates for current sources." + (loop with completion-ignore-case = (or (eq ac-ignore-case t) + (and (eq ac-ignore-case 'smart) + (let ((case-fold-search nil)) (not (string-match "[[:upper:]]" ac-prefix))))) + with case-fold-search = completion-ignore-case + with prefix-len = (length ac-prefix) + for source in ac-current-sources + append (ac-candidates-1 source) into candidates + finally return + (progn + (delete-dups candidates) + (if (and ac-use-comphist ac-comphist) + (if ac-show-menu + (let* ((pair (ac-comphist-sort ac-comphist candidates prefix-len ac-comphist-threshold)) + (n (car pair)) + (result (cdr pair)) + (cons (if (> n 0) (nthcdr (1- n) result))) + (cdr (cdr cons))) + (if cons (setcdr cons nil)) + (setq ac-common-part (try-completion ac-prefix result)) + (setq ac-whole-common-part (try-completion ac-prefix candidates)) + (if cons (setcdr cons cdr)) + result) + (setq candidates (ac-comphist-sort ac-comphist candidates prefix-len)) + (setq ac-common-part (if candidates (popup-x-to-string (car candidates)))) + (setq ac-whole-common-part (try-completion ac-prefix candidates)) + candidates) + (setq ac-common-part (try-completion ac-prefix candidates)) + (setq ac-whole-common-part ac-common-part) + candidates)))) + +(defun ac-update-candidates (cursor scroll-top) + "Update candidates of menu to `ac-candidates' and redraw it." + (setf (popup-cursor ac-menu) cursor + (popup-scroll-top ac-menu) scroll-top) + (setq ac-dwim-enable (= (length ac-candidates) 1)) + (if ac-candidates + (progn + (setq ac-completing t) + (ac-activate-completing-map)) + (setq ac-completing nil) + (ac-deactivate-completing-map)) + (unless ac-disable-inline + (ac-inline-update)) + (popup-set-list ac-menu ac-candidates) + (if (and (not ac-fuzzy-enable) + (<= (length ac-candidates) ac-candidate-menu-min)) + (popup-hide ac-menu) + (if ac-show-menu + (popup-draw ac-menu)))) + +(defun ac-reposition () + "Force to redraw candidate menu with current `ac-candidates'." + (let ((cursor (popup-cursor ac-menu)) + (scroll-top (popup-scroll-top ac-menu)) + (height (popup-height ac-menu))) + (ac-menu-delete) + (ac-menu-create ac-point (popup-preferred-width ac-candidates) height) + (ac-update-candidates cursor scroll-top))) + +(defun ac-cleanup () + "Cleanup auto completion." + (if ac-cursor-color + (set-cursor-color ac-cursor-color)) + (when (and ac-use-comphist ac-comphist) + (when (and (null ac-selected-candidate) + (member ac-prefix ac-candidates)) + ;; Assume candidate is selected by just typing + (setq ac-selected-candidate ac-prefix) + (setq ac-last-point ac-point)) + (when ac-selected-candidate + (ac-comphist-add ac-comphist + ac-selected-candidate + (if ac-last-point + (- ac-last-point ac-point) + (length ac-prefix))))) + (ac-deactivate-completing-map) + (ac-remove-prefix-overlay) + (ac-remove-quick-help) + (ac-inline-delete) + (ac-menu-delete) + (ac-cancel-timer) + (ac-cancel-show-menu-timer) + (ac-cancel-quick-help-timer) + (setq ac-cursor-color nil + ac-inline nil + ac-show-menu nil + ac-menu nil + ac-completing nil + ac-point nil + ac-last-point nil + ac-prefix nil + ac-prefix-overlay nil + ac-selected-candidate nil + ac-common-part nil + ac-whole-common-part nil + ac-triggered nil + ac-limit nil + ac-candidates nil + ac-candidates-cache nil + ac-fuzzy-enable nil + ac-dwim-enable nil + ac-compiled-sources nil + ac-current-sources nil + ac-current-prefix-def nil + ac-ignoring-prefix-def nil)) + +(defsubst ac-abort () + "Abort completion." + (ac-cleanup)) + +(defun ac-expand-string (string &optional remove-undo-boundary) + "Expand `STRING' into the buffer and update `ac-prefix' to `STRING'. +This function records deletion and insertion sequences by `undo-boundary'. +If `remove-undo-boundary' is non-nil, this function also removes `undo-boundary' +that have been made before in this function. When `buffer-undo-list' is +`t', `remove-undo-boundary' has no effect." + (when (eq buffer-undo-list t) + (setq remove-undo-boundary nil)) + (when (not (equal string (buffer-substring ac-point (point)))) + (undo-boundary) + ;; We can't use primitive-undo since it undoes by + ;; groups, divided by boundaries. + ;; We don't want boundary between deletion and insertion. + ;; So do it manually. + ;; Delete region silently for undo: + (if remove-undo-boundary + (progn + (let (buffer-undo-list) + (save-excursion + (delete-region ac-point (point)))) + (setq buffer-undo-list + (nthcdr 2 buffer-undo-list))) + (delete-region ac-point (point))) + (insert (substring-no-properties string)) + ;; Sometimes, possible when omni-completion used, (insert) added + ;; to buffer-undo-list strange record about position changes. + ;; Delete it here: + (when (and remove-undo-boundary + (integerp (cadr buffer-undo-list))) + (setcdr buffer-undo-list (nthcdr 2 buffer-undo-list))) + (undo-boundary) + (setq ac-selected-candidate string) + (setq ac-prefix string))) + +(defun ac-set-trigger-key (key) + "Set `ac-trigger-key' to `KEY'. It is recommemded to use this function instead of calling `setq'." + ;; Remove old mapping + (when ac-trigger-key + (define-key ac-mode-map (read-kbd-macro ac-trigger-key) nil)) + + ;; Make new mapping + (setq ac-trigger-key key) + (when key + (define-key ac-mode-map (read-kbd-macro key) 'ac-trigger-key-command))) + +(defun ac-set-timer () + (unless ac-timer + (setq ac-timer (run-with-idle-timer ac-delay ac-delay 'ac-update-greedy)))) + +(defun ac-cancel-timer () + (when (timerp ac-timer) + (cancel-timer ac-timer) + (setq ac-timer nil))) + +(defun ac-update (&optional force) + (when (and auto-complete-mode + ac-prefix + (or ac-triggered + force) + (not isearch-mode)) + (ac-put-prefix-overlay) + (setq ac-candidates (ac-candidates)) + (let ((preferred-width (popup-preferred-width ac-candidates))) + ;; Reposition if needed + (when (or (null ac-menu) + (>= (popup-width ac-menu) preferred-width) + (<= (popup-width ac-menu) (- preferred-width 10)) + (and (> (popup-direction ac-menu) 0) + (ac-menu-at-wrapper-line-p))) + (ac-inline-hide) ; Hide overlay to calculate correct column + (ac-remove-quick-help) + (ac-menu-delete) + (ac-menu-create ac-point preferred-width ac-menu-height))) + (ac-update-candidates 0 0) + t)) + +(defun ac-update-greedy (&optional force) + (let (result) + (while (when (and (setq result (ac-update force)) + (null ac-candidates)) + (add-to-list 'ac-ignoring-prefix-def ac-current-prefix-def) + (ac-start :force-init t) + ac-current-prefix-def)) + result)) + +(defun ac-set-show-menu-timer () + (when (and (or (integerp ac-auto-show-menu) (floatp ac-auto-show-menu)) + (null ac-show-menu-timer)) + (setq ac-show-menu-timer (run-with-idle-timer ac-auto-show-menu ac-auto-show-menu 'ac-show-menu)))) + +(defun ac-cancel-show-menu-timer () + (when (timerp ac-show-menu-timer) + (cancel-timer ac-show-menu-timer) + (setq ac-show-menu-timer nil))) + +(defun ac-show-menu () + (when (not (eq ac-show-menu t)) + (setq ac-show-menu t) + (ac-inline-hide) + (ac-remove-quick-help) + (ac-update t))) + +(defun ac-help (&optional persist) + (interactive "P") + (when ac-menu + (popup-menu-show-help ac-menu persist))) + +(defun ac-persist-help () + (interactive) + (ac-help t)) + +(defun ac-last-help (&optional persist) + (interactive "P") + (when ac-last-completion + (popup-item-show-help (cdr ac-last-completion) persist))) + +(defun ac-last-persist-help () + (interactive) + (ac-last-help t)) + +(defun ac-set-quick-help-timer () + (when (and ac-use-quick-help + (null ac-quick-help-timer)) + (setq ac-quick-help-timer (run-with-idle-timer ac-quick-help-delay ac-quick-help-delay 'ac-quick-help)))) + +(defun ac-cancel-quick-help-timer () + (when (timerp ac-quick-help-timer) + (cancel-timer ac-quick-help-timer) + (setq ac-quick-help-timer nil))) + +(defun ac-pos-tip-show-quick-help (menu &optional item &rest args) + (let* ((point (plist-get args :point)) + (around nil) + (parent-offset (popup-offset menu)) + (doc (popup-menu-documentation menu item))) + (when (stringp doc) + (if (popup-hidden-p menu) + (setq around t) + (setq point nil)) + (with-no-warnings + (pos-tip-show doc + 'popup-tip-face + (or point + (and menu + (popup-child-point menu parent-offset)) + (point)) + nil 300 + popup-tip-max-width + nil nil + (and (not around) 0)) + (unless (plist-get args :nowait) + (clear-this-command-keys) + (unwind-protect + (push (read-event (plist-get args :prompt)) unread-command-events) + (pos-tip-hide)) + t))))) + +(defun ac-quick-help-use-pos-tip-p () + (and ac-quick-help-prefer-pos-tip + window-system + (featurep 'pos-tip))) + +(defun ac-quick-help (&optional force) + (interactive) + ;; TODO don't use FORCE + (when (and (or force + (with-no-warnings + ;; called-interactively-p can take no args + (called-interactively-p)) + ;; ac-isearch'ing + (null this-command)) + (ac-menu-live-p) + (null ac-quick-help)) + (setq ac-quick-help + (funcall (if (ac-quick-help-use-pos-tip-p) + 'ac-pos-tip-show-quick-help + 'popup-menu-show-quick-help) + ac-menu nil + :point ac-point + :height ac-quick-help-height + :nowait t)))) + +(defun ac-remove-quick-help () + (when (ac-quick-help-use-pos-tip-p) + (with-no-warnings + (pos-tip-hide))) + (when ac-quick-help + (popup-delete ac-quick-help) + (setq ac-quick-help nil))) + +(defun ac-last-quick-help () + (interactive) + (when (and ac-last-completion + (eq (marker-buffer (car ac-last-completion)) + (current-buffer))) + (let ((doc (popup-item-documentation (cdr ac-last-completion))) + (point (marker-position (car ac-last-completion)))) + (when (stringp doc) + (if (ac-quick-help-use-pos-tip-p) + (with-no-warnings (pos-tip-show doc nil point nil 300)) + (popup-tip doc + :point point + :around t + :scroll-bar t + :margin t)))))) + +(defmacro ac-define-quick-help-command (name arglist &rest body) + (declare (indent 2)) + `(progn + (defun ,name ,arglist ,@body) + (put ',name 'ac-quick-help-command t))) + +(ac-define-quick-help-command ac-quick-help-scroll-down () + (interactive) + (when ac-quick-help + (popup-scroll-down ac-quick-help))) + +(ac-define-quick-help-command ac-quick-help-scroll-up () + (interactive) + (when ac-quick-help + (popup-scroll-up ac-quick-help))) + + + +;;;; Auto completion isearch + +(defun ac-isearch-callback (list) + (setq ac-dwim-enable (eq (length list) 1))) + +(defun ac-isearch () + (interactive) + (when (ac-menu-live-p) + (ac-cancel-show-menu-timer) + (ac-show-menu) + (if ac-use-quick-help + (let ((popup-menu-show-quick-help-function + (if (ac-quick-help-use-pos-tip-p) + 'ac-pos-tip-show-quick-help + 'popup-menu-show-quick-help))) + (popup-isearch ac-menu + :callback 'ac-isearch-callback + :help-delay ac-quick-help-delay)) + (popup-isearch ac-menu :callback 'ac-isearch-callback)))) + + + +;;;; Auto completion commands + +(defun* auto-complete-1 (&key sources (triggered 'command)) + (let ((menu-live (ac-menu-live-p)) + (inline-live (ac-inline-live-p)) + started) + (ac-abort) + (let ((ac-sources (or sources ac-sources))) + (if (or ac-show-menu-immediately-on-auto-complete + inline-live) + (setq ac-show-menu t)) + (setq started (ac-start :triggered triggered))) + (when (ac-update-greedy t) + ;; TODO Not to cause inline completion to be disrupted. + (if (ac-inline-live-p) + (ac-inline-hide)) + ;; Not to expand when it is first time to complete + (when (and (or (and (not ac-expand-on-auto-complete) + (> (length ac-candidates) 1) + (not menu-live)) + (not (let ((ac-common-part ac-whole-common-part)) + (ac-expand-common)))) + ac-use-fuzzy + (null ac-candidates)) + (ac-fuzzy-complete))) + started)) + +;;;###autoload +(defun auto-complete (&optional sources) + "Start auto-completion at current point." + (interactive) + (auto-complete-1 :sources sources)) + +(defun ac-fuzzy-complete () + "Start fuzzy completion at current point." + (interactive) + (if (not (require 'fuzzy nil t)) + (message "Please install fuzzy.el if you use fuzzy completion") + (unless (ac-menu-live-p) + (ac-start)) + (let ((ac-match-function 'fuzzy-all-completions)) + (unless ac-cursor-color + (setq ac-cursor-color (frame-parameter (selected-frame) 'cursor-color))) + (if ac-fuzzy-cursor-color + (set-cursor-color ac-fuzzy-cursor-color)) + (setq ac-show-menu t) + (setq ac-fuzzy-enable t) + (setq ac-triggered nil) + (ac-update t))) + t) + +(defun ac-next () + "Select next candidate." + (interactive) + (when (ac-menu-live-p) + (when (popup-hidden-p ac-menu) + (ac-show-menu)) + (popup-next ac-menu) + (if (eq this-command 'ac-next) + (setq ac-dwim-enable t)))) + +(defun ac-previous () + "Select previous candidate." + (interactive) + (when (ac-menu-live-p) + (when (popup-hidden-p ac-menu) + (ac-show-menu)) + (popup-previous ac-menu) + (if (eq this-command 'ac-previous) + (setq ac-dwim-enable t)))) + +(defun ac-expand () + "Try expand, and if expanded twice, select next candidate." + (interactive) + (unless (ac-expand-common) + (let ((string (ac-selected-candidate))) + (when string + (when (equal ac-prefix string) + (ac-next) + (setq string (ac-selected-candidate))) + (ac-expand-string string (eq last-command this-command)) + ;; Do reposition if menu at long line + (if (and (> (popup-direction ac-menu) 0) + (ac-menu-at-wrapper-line-p)) + (ac-reposition)) + (setq ac-show-menu t) + string)))) + +(defun ac-expand-common () + "Try to expand meaningful common part." + (interactive) + (if (and ac-dwim ac-dwim-enable) + (ac-complete) + (when (and (ac-inline-live-p) + ac-common-part) + (ac-inline-hide) + (ac-expand-string ac-common-part (eq last-command this-command)) + (setq ac-common-part nil) + t))) + +(defun ac-complete-1 (candidate) + (let ((action (popup-item-property candidate 'action)) + (fallback nil)) + (when candidate + (unless (ac-expand-string candidate) + (setq fallback t)) + ;; Remember to show help later + (when (and ac-point candidate) + (unless ac-last-completion + (setq ac-last-completion (cons (make-marker) nil))) + (set-marker (car ac-last-completion) ac-point ac-buffer) + (setcdr ac-last-completion candidate))) + (ac-abort) + (cond + (action + (funcall action)) + (fallback + (ac-fallback-command))) + candidate)) + +(defun ac-complete () + "Try complete." + (interactive) + (ac-complete-1 (ac-selected-candidate))) + +(defun* ac-start (&key + requires + force-init + (triggered (or ac-triggered t))) + "Start completion." + (interactive) + (if (not auto-complete-mode) + (message "auto-complete-mode is not enabled") + (let* ((info (ac-prefix requires ac-ignoring-prefix-def)) + (prefix-def (nth 0 info)) + (point (nth 1 info)) + (sources (nth 2 info)) + prefix + (init (or force-init (not (eq ac-point point))))) + (if (or (null point) + (progn + (setq prefix (buffer-substring-no-properties point (point))) + (and (not (eq triggered 'command)) + (ac-stop-word-p prefix)))) + (prog1 nil + (ac-abort)) + (unless ac-cursor-color + (setq ac-cursor-color (frame-parameter (selected-frame) 'cursor-color))) + (setq ac-show-menu (or ac-show-menu (if (eq ac-auto-show-menu t) t)) + ac-current-sources sources + ac-buffer (current-buffer) + ac-point point + ac-prefix prefix + ac-limit ac-candidate-limit + ac-triggered triggered + ac-current-prefix-def prefix-def) + (when (or init (null ac-prefix-overlay)) + (ac-init)) + (ac-set-timer) + (ac-set-show-menu-timer) + (ac-set-quick-help-timer) + (ac-put-prefix-overlay) + t)))) + +(defun ac-stop () + "Stop completiong." + (interactive) + (setq ac-selected-candidate nil) + (ac-abort)) + +(defun ac-ignore (&rest ignore) + "Same as `ignore'." + (interactive)) + +(defun ac-mouse-1 (event) + (interactive "e") + (popup-awhen (popup-menu-item-of-mouse-event event) + (ac-complete-1 it))) + +(defun ac-mouse-4 (event) + (interactive "e") + (ac-previous)) + +(defun ac-mouse-5 (event) + (interactive "e") + (ac-next)) + +(defun ac-trigger-key-command (&optional force) + (interactive "P") + (let (started) + (when (or force (ac-trigger-command-p last-command)) + (setq started (auto-complete-1 :triggered 'trigger-key))) + (unless started + (ac-fallback-command 'ac-trigger-key-command)))) + + + +;;;; Basic cache facility + +(defvar ac-clear-variables-every-minute-timer nil) +(defvar ac-clear-variables-after-save nil) +(defvar ac-clear-variables-every-minute nil) +(defvar ac-minutes-counter 0) + +(defun ac-clear-variable-after-save (variable &optional pred) + (add-to-list 'ac-clear-variables-after-save (cons variable pred))) + +(defun ac-clear-variables-after-save () + (dolist (pair ac-clear-variables-after-save) + (if (or (null (cdr pair)) + (funcall (cdr pair))) + (set (car pair) nil)))) + +(defun ac-clear-variable-every-minutes (variable minutes) + (add-to-list 'ac-clear-variables-every-minute (cons variable minutes))) + +(defun ac-clear-variable-every-minute (variable) + (ac-clear-variable-every-minutes variable 1)) + +(defun ac-clear-variable-every-10-minutes (variable) + (ac-clear-variable-every-minutes variable 10)) + +(defun ac-clear-variables-every-minute () + (incf ac-minutes-counter) + (dolist (pair ac-clear-variables-every-minute) + (if (eq (% ac-minutes-counter (cdr pair)) 0) + (set (car pair) nil)))) + + + +;;;; Auto complete mode + +(defun ac-cursor-on-diable-face-p (&optional point) + (memq (get-text-property (or point (point)) 'face) ac-disable-faces)) + +(defun ac-trigger-command-p (command) + "Return non-nil if `COMMAND' is a trigger command." + (and (symbolp command) + (not (memq command ac-non-trigger-commands)) + (or (memq command ac-trigger-commands) + (string-match "self-insert-command" (symbol-name command)) + (string-match "electric" (symbol-name command))))) + +(defun ac-fallback-key-sequence () + (setq unread-command-events + (append (this-single-command-raw-keys) + unread-command-events)) + (read-key-sequence-vector "")) + +(defun ac-fallback-command (&optional except-command) + (let* ((auto-complete-mode nil) + (keys (ac-fallback-key-sequence)) + (command (and keys (key-binding keys)))) + (when (and (commandp command) + (not (eq command except-command))) + (setq this-command command) + (call-interactively command)))) + +(defun ac-compatible-package-command-p (command) + "Return non-nil if `COMMAND' is compatible with auto-complete." + (and (symbolp command) + (string-match ac-compatible-packages-regexp (symbol-name command)))) + +(defun ac-handle-pre-command () + (condition-case var + (if (or (setq ac-triggered (and (not ac-fuzzy-enable) ; ignore key storkes in fuzzy mode + (or (eq this-command 'auto-complete) ; special case + (ac-trigger-command-p this-command) + (and ac-completing + (memq this-command ac-trigger-commands-on-completing))) + (not (ac-cursor-on-diable-face-p)) + (or ac-triggered t))) + (ac-compatible-package-command-p this-command)) + (progn + (if (or (not (symbolp this-command)) + (not (get this-command 'ac-quick-help-command))) + (ac-remove-quick-help)) + ;; Not to cause inline completion to be disrupted. + (ac-inline-hide)) + (ac-abort)) + (error (ac-error var)))) + +(defun ac-handle-post-command () + (condition-case var + (when (and ac-triggered + (or ac-auto-start + ac-completing) + (not isearch-mode)) + (setq ac-last-point (point)) + (ac-start :requires (unless ac-completing ac-auto-start)) + (unless ac-disable-inline + (ac-inline-update))) + (error (ac-error var)))) + +(defun ac-setup () + (if ac-trigger-key + (ac-set-trigger-key ac-trigger-key)) + (if ac-use-comphist + (ac-comphist-init)) + (unless ac-clear-variables-every-minute-timer + (setq ac-clear-variables-every-minute-timer (run-with-timer 60 60 'ac-clear-variables-every-minute))) + (if ac-stop-flymake-on-completing + (defadvice flymake-on-timer-event (around ac-flymake-stop-advice activate) + (unless ac-completing + ad-do-it)) + (ad-disable-advice 'flymake-on-timer-event 'around 'ac-flymake-stop-advice))) + +;;;###autoload +(define-minor-mode auto-complete-mode + "AutoComplete mode" + :lighter " AC" + :keymap ac-mode-map + :group 'auto-complete + (if auto-complete-mode + (progn + (ac-setup) + (add-hook 'pre-command-hook 'ac-handle-pre-command nil t) + (add-hook 'post-command-hook 'ac-handle-post-command nil t) + (add-hook 'after-save-hook 'ac-clear-variables-after-save nil t) + (run-hooks 'auto-complete-mode-hook)) + (remove-hook 'pre-command-hook 'ac-handle-pre-command t) + (remove-hook 'post-command-hook 'ac-handle-post-command t) + (remove-hook 'after-save-hook 'ac-clear-variables-after-save t) + (ac-abort))) + +(defun auto-complete-mode-maybe () + "What buffer `auto-complete-mode' prefers." + (if (and (not (minibufferp (current-buffer))) + (memq major-mode ac-modes)) + (auto-complete-mode 1))) + +;;;###autoload +(define-global-minor-mode global-auto-complete-mode + auto-complete-mode auto-complete-mode-maybe + :group 'auto-complete) + + + +;;;; Compatibilities with other extensions + +(defun ac-flyspell-workaround () + "Flyspell uses `sit-for' for delaying its process. Unfortunatelly, +it stops auto completion which is trigger with `run-with-idle-timer'. +This workaround avoid flyspell processes when auto completion is being started." + (interactive) + (defadvice flyspell-post-command-hook (around ac-flyspell-workaround activate) + (unless ac-triggered + ad-do-it))) + +(defun ac-linum-workaround () + "linum-mode tries to display the line numbers even for the +completion menu. This workaround stops that annoying behavior." + (interactive) + (defadvice linum-update (around ac-linum-update-workaround activate) + (unless ac-completing + ad-do-it))) + + + +;;;; Standard sources + +(defmacro ac-define-source (name source) + "Source definition macro. It defines a complete command also." + (declare (indent 1)) + `(progn + (defvar ,(intern (format "ac-source-%s" name))) + ;; Use `setq' to reset ac-source-NAME every time + ;; `ac-define-source' is called. This is useful, for example + ;; when evaluating `ac-define-source' using C-M-x (`eval-defun'). + (setq ,(intern (format "ac-source-%s" name)) ,source) + (defun ,(intern (format "ac-complete-%s" name)) () + (interactive) + (auto-complete '(,(intern (format "ac-source-%s" name))))))) + +;; Words in buffer source +(defvar ac-word-index nil) + +(defun ac-candidate-words-in-buffer (point prefix limit) + (let ((i 0) + candidate + candidates + (regexp (concat "\\_<" (regexp-quote prefix) "\\(\\sw\\|\\s_\\)+\\_>"))) + (save-excursion + ;; Search backward + (goto-char point) + (while (and (or (not (integerp limit)) (< i limit)) + (re-search-backward regexp nil t)) + (setq candidate (match-string-no-properties 0)) + (unless (member candidate candidates) + (push candidate candidates) + (incf i))) + ;; Search backward + (goto-char (+ point (length prefix))) + (while (and (or (not (integerp limit)) (< i limit)) + (re-search-forward regexp nil t)) + (setq candidate (match-string-no-properties 0)) + (unless (member candidate candidates) + (push candidate candidates) + (incf i))) + (nreverse candidates)))) + +(defun ac-incremental-update-word-index () + (unless (local-variable-p 'ac-word-index) + (make-local-variable 'ac-word-index)) + (if (null ac-word-index) + (setq ac-word-index (cons nil nil))) + ;; Mark incomplete + (if (car ac-word-index) + (setcar ac-word-index nil)) + (let ((index (cdr ac-word-index)) + (words (ac-candidate-words-in-buffer ac-point ac-prefix (or (and (integerp ac-limit) ac-limit) 10)))) + (dolist (word words) + (unless (member word index) + (push word index) + (setcdr ac-word-index index))))) + +(defun ac-update-word-index-1 () + (unless (local-variable-p 'ac-word-index) + (make-local-variable 'ac-word-index)) + (when (and (not (car ac-word-index)) + (< (buffer-size) 1048576)) + ;; Complete index + (setq ac-word-index + (cons t + (split-string (buffer-substring-no-properties (point-min) (point-max)) + "\\(?:^\\|\\_>\\).*?\\(?:\\_<\\|$\\)"))))) + +(defun ac-update-word-index () + (dolist (buffer (buffer-list)) + (when (or ac-fuzzy-enable + (not (eq buffer (current-buffer)))) + (with-current-buffer buffer + (ac-update-word-index-1))))) + +(defun ac-word-candidates (&optional buffer-pred) + (loop initially (unless ac-fuzzy-enable (ac-incremental-update-word-index)) + for buffer in (buffer-list) + if (and (or (not (integerp ac-limit)) (< (length candidates) ac-limit)) + (if buffer-pred (funcall buffer-pred buffer) t)) + append (funcall ac-match-function + ac-prefix + (and (local-variable-p 'ac-word-index buffer) + (cdr (buffer-local-value 'ac-word-index buffer)))) + into candidates + finally return candidates)) + +(ac-define-source words-in-buffer + '((candidates . ac-word-candidates))) + +(ac-define-source words-in-all-buffer + '((init . ac-update-word-index) + (candidates . ac-word-candidates))) + +(ac-define-source words-in-same-mode-buffers + '((init . ac-update-word-index) + (candidates . (ac-word-candidates + (lambda (buffer) + (derived-mode-p (buffer-local-value 'major-mode buffer))))))) + +;; Lisp symbols source +(defvar ac-symbols-cache nil) +(ac-clear-variable-every-10-minutes 'ac-symbols-cache) + +(defun ac-symbol-file (symbol type) + (if (fboundp 'find-lisp-object-file-name) + (find-lisp-object-file-name symbol type) + (let ((file-name (with-no-warnings + (describe-simplify-lib-file-name + (symbol-file symbol type))))) + (when (equal file-name "loaddefs.el") + ;; Find the real def site of the preloaded object. + (let ((location (condition-case nil + (if (eq type 'defun) + (find-function-search-for-symbol symbol nil + "loaddefs.el") + (find-variable-noselect symbol file-name)) + (error nil)))) + (when location + (with-current-buffer (car location) + (when (cdr location) + (goto-char (cdr location))) + (when (re-search-backward + "^;;; Generated autoloads from \\(.*\\)" nil t) + (setq file-name (match-string 1))))))) + (if (and (null file-name) + (or (eq type 'defun) + (integerp (get symbol 'variable-documentation)))) + ;; It's a object not defined in Elisp but in C. + (if (get-buffer " *DOC*") + (if (eq type 'defun) + (help-C-file-name (symbol-function symbol) 'subr) + (help-C-file-name symbol 'var)) + 'C-source) + file-name)))) + +(defun ac-symbol-documentation (symbol) + (if (stringp symbol) + (setq symbol (intern-soft symbol))) + (ignore-errors + (with-temp-buffer + (let ((standard-output (current-buffer))) + (prin1 symbol) + (princ " is ") + (cond + ((fboundp symbol) + ;; import help-xref-following + (require 'help-mode) + (let ((help-xref-following t) + (major-mode 'help-mode)) ; avoid error in Emacs 24 + (describe-function-1 symbol)) + (buffer-string)) + ((boundp symbol) + (let ((file-name (ac-symbol-file symbol 'defvar))) + (princ "a variable") + (when file-name + (princ " defined in `") + (princ (if (eq file-name 'C-source) + "C source code" + (file-name-nondirectory file-name)))) + (princ "'.\n\n") + (princ (or (documentation-property symbol 'variable-documentation t) + "Not documented.")) + (buffer-string))) + ((facep symbol) + (let ((file-name (ac-symbol-file symbol 'defface))) + (princ "a face") + (when file-name + (princ " defined in `") + (princ (if (eq file-name 'C-source) + "C source code" + (file-name-nondirectory file-name)))) + (princ "'.\n\n") + (princ (or (documentation-property symbol 'face-documentation t) + "Not documented.")) + (buffer-string))) + (t + (let ((doc (documentation-property symbol 'group-documentation t))) + (when doc + (princ "a group.\n\n") + (princ doc) + (buffer-string))))))))) + +(defun ac-symbol-candidates () + (or ac-symbols-cache + (setq ac-symbols-cache + (loop for x being the symbols + if (or (fboundp x) + (boundp x) + (symbol-plist x)) + collect (symbol-name x))))) + +(ac-define-source symbols + '((candidates . ac-symbol-candidates) + (document . ac-symbol-documentation) + (symbol . "s") + (cache))) + +;; Lisp functions source +(defvar ac-functions-cache nil) +(ac-clear-variable-every-10-minutes 'ac-functions-cache) + +(defun ac-function-candidates () + (or ac-functions-cache + (setq ac-functions-cache + (loop for x being the symbols + if (fboundp x) + collect (symbol-name x))))) + +(ac-define-source functions + '((candidates . ac-function-candidates) + (document . ac-symbol-documentation) + (symbol . "f") + (prefix . "(\\(\\(?:\\sw\\|\\s_\\)+\\)") + (cache))) + +;; Lisp variables source +(defvar ac-variables-cache nil) +(ac-clear-variable-every-10-minutes 'ac-variables-cache) + +(defun ac-variable-candidates () + (or ac-variables-cache + (setq ac-variables-cache + (loop for x being the symbols + if (boundp x) + collect (symbol-name x))))) + +(ac-define-source variables + '((candidates . ac-variable-candidates) + (document . ac-symbol-documentation) + (symbol . "v") + (cache))) + +;; Lisp features source +(defvar ac-emacs-lisp-features nil) +(ac-clear-variable-every-10-minutes 'ac-emacs-lisp-features) + +(defun ac-emacs-lisp-feature-candidates () + (or ac-emacs-lisp-features + (if (fboundp 'find-library-suffixes) + (let ((suffix (concat (regexp-opt (find-library-suffixes) t) "\\'"))) + (setq ac-emacs-lisp-features + (append (mapcar 'prin1-to-string features) + (loop for dir in load-path + if (file-directory-p dir) + append (loop for file in (directory-files dir) + if (string-match suffix file) + collect (substring file 0 (match-beginning 0)))))))))) + +(ac-define-source features + '((depends find-func) + (candidates . ac-emacs-lisp-feature-candidates) + (prefix . "require +'\\(\\(?:\\sw\\|\\s_\\)*\\)") + (requires . 0))) + +(defvaralias 'ac-source-emacs-lisp-features 'ac-source-features) + +;; Abbrev source +(ac-define-source abbrev + '((candidates . (mapcar 'popup-x-to-string (append (vconcat local-abbrev-table global-abbrev-table) nil))) + (action . expand-abbrev) + (symbol . "a") + (cache))) + +;; Files in current directory source +(ac-define-source files-in-current-dir + '((candidates . (directory-files default-directory)) + (cache))) + +;; Filename source +(defvar ac-filename-cache nil) + +(defun ac-filename-candidate () + (let (file-name-handler-alist) + (unless (or (and comment-start-skip + (string-match comment-start-skip ac-prefix)) + (file-regular-p ac-prefix)) + (ignore-errors + (loop with dir = (file-name-directory ac-prefix) + with files = (or (assoc-default dir ac-filename-cache) + (let ((files (directory-files dir nil "^[^.]"))) + (push (cons dir files) ac-filename-cache) + files)) + for file in files + for path = (concat dir file) + collect (if (file-directory-p path) + (concat path "/") + path)))))) + +(ac-define-source filename + '((init . (setq ac-filename-cache nil)) + (candidates . ac-filename-candidate) + (prefix . valid-file) + (requires . 0) + (action . ac-start) + (limit . nil))) + +;; Dictionary source +(ac-define-source dictionary + '((candidates . ac-buffer-dictionary) + (symbol . "d"))) + +(provide 'auto-complete) +;;; auto-complete.el ends here diff --git a/elpa/auto-complete-20140618.2217/dict/ada-mode b/elpa/auto-complete-20140618.2217/dict/ada-mode new file mode 100644 index 00000000..bea538fb --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/ada-mode @@ -0,0 +1,72 @@ +abort +abs +abstract +accept +access +aliased +all +and +array +at +begin +body +case +constant +declare +delay +delta +digits +do +else +elsif +end +entry +exception +exit +for +function +generic +goto +if +in +interface +is +limited +loop +mod +new +not +null +of +or +others +out +overriding +package +pragma +private +procedure +protected +raise +range +record +rem +renames +requeue +return +reverse +select +separate +subtype +synchronized +tagged +task +terminate +then +type +until +use +when +while +with +xor diff --git a/elpa/auto-complete-20140618.2217/dict/c++-mode b/elpa/auto-complete-20140618.2217/dict/c++-mode new file mode 100644 index 00000000..2579e9fe --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/c++-mode @@ -0,0 +1,84 @@ +alignas +alignof +and +and_eq +asm +auto +bitand +bitor +bool +break +case +catch +char +char16_t +char32_t +class +compl +const +const_cast +constexpr +continue +decltype +default +delete +do +double +dynamic_cast +else +enum +explicit +export +extern +false +float +for +friend +goto +if +inline +int +long +mutable +namespace +new +noexcept +not +not_eq +nullptr +operator +or +or_eq +private +protected +public +register +reinterpret_cast +return +short +signed +sizeof +static +static_assert +static_cast +struct +switch +template +this +thread_local +throw +true +try +typedef +typeid +typename +union +unsigned +using +virtual +void +volatile +wchar_t +while +xor +xor_eq diff --git a/elpa/auto-complete-20140618.2217/dict/c-mode b/elpa/auto-complete-20140618.2217/dict/c-mode new file mode 100644 index 00000000..ec262c76 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/c-mode @@ -0,0 +1,44 @@ +auto +_Alignas +_Alignof +_Atomic +_Bool +break +case +char +_Complex +const +continue +default +do +double +else +enum +extern +float +for +goto +_Generic +if +_Imaginary +inline +int +long +_Noreturn +register +restrict +return +short +signed +sizeof +static +struct +switch +_Static_assert +typedef +_Thread_local +union +unsigned +void +volatile +while diff --git a/elpa/auto-complete-20140618.2217/dict/caml-mode b/elpa/auto-complete-20140618.2217/dict/caml-mode new file mode 100644 index 00000000..e709f9f6 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/caml-mode @@ -0,0 +1,231 @@ +# OCaml 3.12.1 + +# Keywords +and +as +assert +begin +class +constraint +do +done +downto +else +end +exception +external +false +for +fun +function +functor +if +in +include +inherit +initializer +lazy +let +match +method +module +mutable +new +object +of +open +or +private +rec +sig +struct +then +to +true +try +type +val +virtual +when +while +with + +# Pervasives +! +!= +& +&& +* +** +*. ++ ++. +- +-. +/ +/. +:= +< +<= +<> += +== +> +>= +@ +FP_infinite +FP_nan +FP_normal +FP_subnormal +FP_zero +LargeFile +Open_append +Open_binary +Open_creat +Open_nonblock +Open_rdonly +Open_text +Open_trunc +Open_wronly +Oupen_excl +^ +^^ +abs +abs_float +acos +asin +asr +at_exit +atan +atan2 +bool_of_string +ceil +char_of_int +classify_float +close_in +close_in_noerr +close_out +close_out_noerr +compare +cos +cosh +decr +do_at_exit +epsilon_float +exit +exp +expm1 +failwith +float +float_of_int +float_of_string +floor +flush +flush_all +format +format4 +format_of_string +fpclass +frexp +fst +ignore +in_channel +in_channel_length +incr +infinity +input +input_binary_int +input_byte +input_char +input_line +input_value +int_of_char +int_of_float +int_of_string +invalid_arg +land +ldexp +lnot +log +log10 +log1p +lor +lsl +lsr +lxor +max +max_float +max_int +min +min_float +min_int +mod +mod_float +modf +nan +neg_infinity +not +open_flag +open_in +open_in_bin +open_in_gen +open_out +open_out_bin +open_out_gen +or +out_channel +out_channel_length +output +output_binary_int +output_byte +output_char +output_string +output_value +pos_in +pos_out +pred +prerr_char +prerr_endline +prerr_float +prerr_int +prerr_newline +prerr_string +print_char +print_endline +print_float +print_int +print_newline +print_string +raise +read_float +read_int +read_line +really_input +ref +seek_in +seek_out +set_binary_mode_in +set_binary_mode_out +sin +sinh +snd +sqrt +stderr +stdin +stdout +string_of_bool +string_of_float +string_of_format +string_of_int +succ +tan +tanh +truncate +unsafe_really_input +valid_float_lexem +|| +~ +~+ +~+. +~- +~-. diff --git a/elpa/auto-complete-20140618.2217/dict/clojure-mode b/elpa/auto-complete-20140618.2217/dict/clojure-mode new file mode 100644 index 00000000..eefe33fc --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/clojure-mode @@ -0,0 +1,580 @@ +*agent* +*allow-unresolved-vars* +*assert* +*clojure-version* +*command-line-args* +*compile-files* +*compile-path* +*compiler-options* +*data-readers* +*default-data-reader-fn* +*err* +*file* +*flush-on-newline* +*fn-loader* +*in* +*math-context* +*ns* +*out* +*print-dup* +*print-length* +*print-level* +*print-meta* +*print-readably* +*read-eval* +*source-path* +*unchecked-math* +*use-context-classloader* +*verbose-defrecords* +*warn-on-reflection* +->ArrayChunk +->Vec +->VecNode +->VecSeq +-cache-protocol-fn +-reset-methods +accessor +aclone +add-classpath +add-watch +agent +agent-error +agent-errors +aget +alength +alias +all-ns +alter +alter-meta! +alter-var-root +amap +ancestors +and +apply +areduce +array-map +as-> +aset +aset-boolean +aset-byte +aset-char +aset-double +aset-float +aset-int +aset-long +aset-short +assert +assoc +assoc! +assoc-in +associative? +atom +await +await-for +await1 +bases +bean +bigdec +bigint +biginteger +binding +bit-and +bit-and-not +bit-clear +bit-flip +bit-not +bit-or +bit-set +bit-shift-left +bit-shift-right +bit-test +bit-xor +boolean +boolean-array +booleans +bound-fn +bound-fn* +bound? +butlast +byte +byte-array +bytes +case +cast +char +char-array +char-escape-string +char-name-string +char? +chars +chunk +chunk-append +chunk-buffer +chunk-cons +chunk-first +chunk-next +chunk-rest +chunked-seq? +class +class? +clear-agent-errors +clojure-version +coll? +comment +commute +comp +comparator +compare +compare-and-set! +compile +complement +concat +cond +cond-> +cond->> +condp +conj +conj! +cons +constantly +construct-proxy +contains? +count +counted? +create-ns +create-struct +cycle +dec +dec' +decimal? +declare +default-data-readers +definline +definterface +defmacro +defmethod +defmulti +defn +defn- +defonce +defprotocol +defrecord +defstruct +deftype +delay +delay? +deliver +denominator +deref +derive +descendants +destructure +disj +disj! +dissoc +dissoc! +distinct +distinct? +doall +doc +dorun +doseq +dosync +dotimes +doto +double +double-array +doubles +drop +drop-last +drop-while +dtype +empty +empty? +ensure +enumeration-seq +error-handler +error-mode +eval +even? +every-pred +every? +ex-data +ex-info +extend +extend-class +extend-protocol +extend-type +extenders +extends? +false? +ffirst +file-seq +filter +filterv +find +find-doc +find-keyword +find-ns +find-protocol-impl +find-protocol-method +find-var +first +flatten +float +float-array +float? +floats +flush +fn +fn? +fnext +fnil +for +force +format +frequencies +future +future-call +future-cancel +future-cancelled? +future-done? +future? +gen-class +gen-interface +gensym +get +get-in +get-method +get-proxy-class +get-thread-bindings +get-validator +group-by +hash +hash-combine +hash-map +hash-set +identical? +identity +if-let +if-not +ifn? +import +in-ns +inc +inc' +init-proxy +instance? +int +int-array +integer? +interleave +intern +interpose +into +into-array +ints +io! +isa? +iterate +iterator-seq +juxt +keep +keep-indexed +key +keys +keyword +keyword? +last +lazy-cat +lazy-seq +let +letfn +line-seq +list +list* +list? +load +load-file +load-reader +load-string +loaded-libs +locking +long +long-array +longs +loop +macroexpand +macroexpand-1 +make-array +make-hierarchy +map +map-indexed +map? +mapcat +mapv +max +max-key +memfn +memoize +merge +merge-with +meta +method-sig +methods +min +min-key +mod +munge +name +namespace +namespace-munge +neg? +newline +next +nfirst +nil? +nnext +not +not-any? +not-empty +not-every? +not= +ns +ns-aliases +ns-imports +ns-interns +ns-map +ns-name +ns-publics +ns-refers +ns-resolve +ns-unalias +ns-unmap +nth +nthnext +nthrest +num +number? +numerator +object-array +odd? +or +parents +partial +partition +partition-all +partition-by +pcalls +peek +persistent! +pmap +pop +pop! +pop-thread-bindings +pos? +pr +pr-str +prefer-method +prefers +primitives-classnames +print +print-ctor +print-dup +print-method +print-namespace-doc +print-simple +print-str +printf +println +println-str +prn +prn-str +promise +proxy +proxy-call-with-super +proxy-mappings +proxy-name +proxy-super +push-thread-bindings +pvalues +quot +rand +rand-int +rand-nth +range +ratio? +rational? +rationalize +re-find +re-groups +re-matcher +re-matches +re-pattern +re-seq +read +read-line +read-string +realized? +reduce +reduce-kv +reduced +reduced? +reductions +ref +ref-history-count +ref-max-history +ref-min-history +ref-set +refer +refer-clojure +reify +release-pending-sends +rem +remove +remove-all-methods +remove-method +remove-ns +remove-watch +repeat +repeatedly +replace +replicate +require +reset! +reset-meta! +resolve +rest +restart-agent +resultset-seq +reverse +reversible? +rseq +rsubseq +satisfies? +second +select-keys +send +send-off +send-via +seq +seq? +seque +sequence +sequential? +set +set-agent-send-executor! +set-agent-send-off-executor! +set-error-handler! +set-error-mode! +set-validator! +set? +short +short-array +shorts +shuffle +shutdown-agents +slurp +some +some-> +some->> +some-fn +sort +sort-by +sorted-map +sorted-map-by +sorted-set +sorted-set-by +sorted? +special-form-anchor +special-symbol? +spit +split-at +split-with +str +stream? +string? +struct +struct-map +subs +subseq +subvec +supers +swap! +symbol +symbol? +sync +syntax-symbol-anchor +take +take-last +take-nth +take-while +test +the-ns +thread-bound? +time +to-array +to-array-2d +trampoline +transient +tree-seq +true? +type +unchecked-add +unchecked-add-int +unchecked-byte +unchecked-char +unchecked-dec +unchecked-dec-int +unchecked-divide +unchecked-divide-int +unchecked-double +unchecked-float +unchecked-inc +unchecked-inc-int +unchecked-int +unchecked-long +unchecked-multiply +unchecked-multiply-int +unchecked-negate +unchecked-negate-int +unchecked-remainder +unchecked-remainder-int +unchecked-short +unchecked-subtract +unchecked-subtract-int +underive +unquote +unquote-splicing +update-in +update-proxy +use +val +vals +var-get +var-set +var? +vary-meta +vec +vector +vector-of +vector? +when +when-first +when-let +when-not +while +with-bindings +with-bindings* +with-in-str +with-loading-context +with-local-vars +with-meta +with-open +with-out-str +with-precision +with-redefs +with-redefs-fn +xml-seq +zero? +zipmap \ No newline at end of file diff --git a/elpa/auto-complete-20140618.2217/dict/clojurescript-mode b/elpa/auto-complete-20140618.2217/dict/clojurescript-mode new file mode 100644 index 00000000..16348edb --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/clojurescript-mode @@ -0,0 +1,475 @@ +*agent* +*clojure-version* +*command-line-args* +*compile-files* +*compile-path* +*err* +*file* +*flush-on-newline* +*in* +*ns* +*out* +*print-dup* +*print-length* +*print-level* +*print-meta* +*print-readably* +*read-eval* +*warn-on-reflection* +accessor +aclone +add-classpath +add-watch +agent +agent-error +agent-errors +aget +alength +alias +all-ns +alter +alter-meta! +alter-var-root +amap +ancestors +and +apply +areduce +array-map +aset +aset-boolean +aset-byte +aset-char +aset-double +aset-float +aset-int +aset-long +aset-short +assert +assoc +assoc! +assoc-in +associative? +atom +await +await-for +bases +bean +bigdec +bigint +binding +bit-and +bit-and-not +bit-clear +bit-flip +bit-not +bit-or +bit-set +bit-shift-left +bit-shift-right +bit-test +bit-xor +boolean +boolean-array +booleans +bound-fn +bound-fn* +butlast +byte +byte-array +bytes +case +cast +char +char-array +char-escape-string +char-name-string +char? +chars +class +class? +clear-agent-errors +clojure-version +coll? +comment +commute +comp +comparator +compare +compare-and-set! +compile +complement +concat +cond +condp +conj +conj! +cons +constantly +construct-proxy +contains? +count +counted? +create-ns +create-struct +cycle +dec +decimal? +declare +definline +defmacro +defmethod +defmulti +defn +defn- +defonce +defprotocol +defstruct +deftype +delay +delay? +deliver +deref +derive +descendants +disj +disj! +dissoc +dissoc! +distinct +distinct? +doall +doc +dorun +doseq +dosync +dotimes +doto +double +double-array +doubles +drop +drop-last +drop-while +dtype +empty +empty? +ensure +enumeration-seq +error-handler +error-mode +eval +even? +every? +extend +extend-class +extend-protocol +extend-type +extenders +extends? +false? +ffirst +file-seq +filter +find +find-doc +find-ns +find-var +first +float +float-array +float? +floats +flush +fn +fn? +fnext +for +force +format +future +future-call +future-cancel +future-cancelled? +future-done? +future? +gen-class +gen-interface +gensym +get +get-in +get-method +get-proxy-class +get-thread-bindings +get-validator +hash +hash-map +hash-set +identical? +identity +if-let +if-not +ifn? +import +in-ns +inc +init-proxy +instance? +int +int-array +integer? +interleave +intern +interpose +into +into-array +ints +io! +isa? +iterate +iterator-seq +juxt +key +keys +keyword +keyword? +last +lazy-cat +lazy-seq +let +letfn +line-seq +list +list* +list? +load +load-file +load-reader +load-string +loaded-libs +locking +long +long-array +longs +loop +macroexpand +macroexpand-1 +make-array +make-hierarchy +map +map? +mapcat +max +max-key +memfn +memoize +merge +merge-with +meta +methods +min +min-key +mod +name +namespace +neg? +newline +next +nfirst +nil? +nnext +not +not-any? +not-empty +not-every? +not= +ns +ns-aliases +ns-imports +ns-interns +ns-map +ns-name +ns-publics +ns-refers +ns-resolve +ns-unalias +ns-unmap +nth +nthnext +num +number? +object-array +odd? +or +parents +partial +partition +pcalls +peek +persistent! +pmap +pop +pop! +pop-thread-bindings +pos? +pr +pr-str +prefer-method +prefers +print +print-namespace-doc +print-str +printf +println +println-str +prn +prn-str +promise +proxy +proxy-mappings +proxy-super +push-thread-bindings +pvalues +quot +rand +rand-int +range +ratio? +rationalize +re-find +re-groups +re-matcher +re-matches +re-pattern +re-seq +read +read-line +read-string +reduce +ref +ref-history-count +ref-max-history +ref-min-history +ref-set +refer +refer-clojure +reify +release-pending-sends +rem +remove +remove-method +remove-ns +remove-watch +repeat +repeatedly +replace +replicate +require +reset! +reset-meta! +resolve +rest +restart-agent +resultset-seq +reverse +reversible? +rseq +rsubseq +satisfies? +second +select-keys +send +send-off +seq +seq? +seque +sequence +sequential? +set +set-error-handler! +set-error-mode! +set-validator! +set? +short +short-array +shorts +shutdown-agents +slurp +some +sort +sort-by +sorted-map +sorted-map-by +sorted-set +sorted-set-by +sorted? +special-form-anchor +special-symbol? +split-at +split-with +str +stream? +string? +struct +struct-map +subs +subseq +subvec +supers +swap! +symbol +symbol? +sync +syntax-symbol-anchor +take +take-last +take-nth +take-while +test +the-ns +time +to-array +to-array-2d +trampoline +transient +tree-seq +true? +type +unchecked-add +unchecked-dec +unchecked-divide +unchecked-inc +unchecked-multiply +unchecked-negate +unchecked-remainder +unchecked-subtract +underive +update-in +update-proxy +use +val +vals +var-get +var-set +var? +vary-meta +vec +vector +vector-of +vector? +when +when-first +when-let +when-not +while +with-bindings +with-bindings* +with-in-str +with-local-vars +with-meta +with-open +with-out-str +with-precision +xml-seq +zero? +zipmap \ No newline at end of file diff --git a/elpa/auto-complete-20140618.2217/dict/coq-mode b/elpa/auto-complete-20140618.2217/dict/coq-mode new file mode 100644 index 00000000..219448fa --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/coq-mode @@ -0,0 +1,278 @@ +# Generated by the following form. +# (loop for regexp in (append +# coq-solve-tactics +# coq-keywords +# coq-reserved +# coq-tactics +# coq-tacticals +# (list "Set" "Type" "Prop")) +# append (split-string regexp (regexp-quote "\\s-+")) into words +# finally (loop initially (goto-char (point-max)) +# for word in (delete-dups (sort words 'string<)) +# do (insert word) (newline))) + +Abort +About +Abstract +Add +Admit +Admitted +All +Arguments +AutoInline +Axiom +Bind +Canonical +Cd +Chapter +Check +Close +CoFixpoint +CoInductive +Coercion +Coercions +Comments +Conjecture +Constant +Constructors +Corollary +Declare +Defined +Definition +Delimit +Dependent +Depth +Derive +End +Eval +Export +Extern +Extract +Extraction +Fact +False +Field +File +Fixpoint +Focus +Function +Functional +Goal +Hint +Hypotheses +Hypothesis +Hyps +Identity +If +Immediate +Implicit +Import +Inductive +Infix +Inline +Inlined +Inspect +Inversion +Language +Lemma +Let +Library +Limit +LoadPath +Local +Locate +Ltac +ML +Module +Morphism +Next Obligation +NoInline +Notation +Notations +Obligation +Obligations +Off +On +Opaque +Open +Optimize +Parameter +Parameters +Path +Print +Printing +Program +Proof +Prop +Pwd +Qed +Rec +Record +Recursive +Remark +Remove +Require +Reserved +Reset +Resolve +Rewrite +Ring +Save +Scheme +Scope +Search +SearchAbout +SearchPattern +SearchRewrite +Section +Semi +Set +Setoid +Show +Solve +Sort +Strict +Structure +Synth +Tactic +Test +Theorem +Time +Transparent +True +Type +Undo +Unfocus +Unfold +Unset +Variable +Variables +Width +Wildcard +abstract +absurd +after +apply +as +assert +assumption +at +auto +autorewrite +beta +by +case +cbv +change +clear +clearbody +cofix +coinduction +compare +compute +congruence +constructor +contradiction +cut +cutrewrite +decide +decompose +delta +dependent +dest +destruct +discrR +discriminate +do +double +eapply +eauto +econstructor +eexists +eleft +elim +else +end +equality +esplit +exact +exists +fail +field +first +firstorder +fix +fold +forall +fourier +fun +functional +generalize +hnf +idtac +if +in +induction +info +injection +instantiate +into +intro +intros +intuition +inversion +inversion_clear +iota +lapply +lazy +left +let +linear +load +match +move +omega +pattern +pose +progress +prolog +quote +record +red +refine +reflexivity +rename +repeat +replace +return +rewrite +right +ring +set +setoid +setoid_replace +setoid_rewrite +simpl +simple +simplify_eq +solve +specialize +split +split_Rabs +split_Rmult +stepl +stepr +struct +subst +sum +symmetry +tauto +then +transitivity +trivial +try +unfold +until +using +with +zeta diff --git a/elpa/auto-complete-20140618.2217/dict/css-mode b/elpa/auto-complete-20140618.2217/dict/css-mode new file mode 100644 index 00000000..6ab36ecf --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/css-mode @@ -0,0 +1,874 @@ +!important +@font-face +@font-feature-values +@keyframes +ActiveBorder +ActiveCaption +Alpha +AppWorkspace +Background +Barn +BasicImage +Blinds +Blur +ButtonFace +ButtonHighlight +ButtonShadow +ButtonText +CaptionText +CheckerBoard +Chroma +Compositor +CradientWipe +DXImageTransform +DropShadow +Emboss +Engrave +Fade +FlipH +FlipV +Glow +Gray +GrayText +Highlight +HighlightText +Hz +ICMFilter +InactiveBorder +InactiveCaption +InactiveCaptionText +InfoBackground +InfoText +Inset +Invert +Iris +Light +MaskFilter +Matrix +Menu +MenuText +Microsoft +MotionBlur +Pixelate +RadialWipe +RandomBars +RandomDissolve +RevealTrans +Scrollbar +Shadow +Slide +Spiral +Stretch +Strips +ThreeDDarkShadow +ThreeDFace +ThreeDHighlight +ThreeDLightShadow +ThreeDShadow +Wave +Wheel +Window +WindowFrame +WindowText +Xray +Zigzag +_azimuth +_background +_background-position-x +_background-position-y +_border +_bottom +_caption +_clear +_clip +_color +_content +_counter +_cue +_cursor +_direction +_display +_elevation +_empty +_filter +_filter:progid:DXImageTransform.Microsoft +_float +_font +_height +_ime +_ime-mode +_layout +_layout-flow +_layout-grid +_layout-grid-char +_layout-grid-line +_layout-grid-mode +_layout-grid-type +_left +_letter +_line +_line-break +_list +_margin +_orphans +_outline +_overflow +_overflow-x +_overflow-y +_padding +_page +_pause +_pitch +_play +_position +_quotes +_richness +_right +_ruby +_ruby-align +_ruby-overhang +_ruby-position +_scrollbar +_scrollbar-3dlight-color +_scrollbar-arrow-color +_scrollbar-base-color +_scrollbar-darkshadow-color +_scrollbar-face-color +_scrollbar-highlight-color +_scrollbar-track-color +_speak +_speech +_stress +_table +_text +_text-align-last +_text-autospace +_text-justify +_text-kashida-space +_text-overflow +_text-underline-position +_top +_unicode +_vertical +_visibility +_voice +_volume +_white +_widows +_width +_word +_word-break +_word-wrap +_writing +_writing-mode +_z +_zoom +above +active +adjust +after +aliceblue +align +align-content +align-items +align-self +always +animation +animation-delay +animation-direction +animation-duration +animation-fill-mode +animation-iteration-count +animation-name +animation-play-state +animation-timing-function +antiquewhite +aqua +aquamarine +armenian +arrow +attachment +auto +autospace +avoid +azimuth +azure +backface-visibility +background +background-attachment +background-clip +background-color +background-image +background-origin +background-position +background-repeat +background-size +bar +base +baseline +before +behind +beige +below +bidi +bidi-override +bisque +black +blanchedalmond +blink +block +blue +blueviolet +bold +bolder +border +border-bottom +border-bottom-color +border-bottom-left-radius +border-bottom-right-radius +border-bottom-style +border-bottom-width +border-collapse +border-color +border-image +border-image-outset +border-image-repeat +border-image-slice +border-image-source +border-image-width +border-left +border-left-color +border-left-style +border-left-width +border-radius +border-right +border-right-color +border-right-style +border-right-width +border-spacing +border-style +border-top +border-top-color +border-top-left-radius +border-top-right-radius +border-top-style +border-top-width +border-width +both +bottom +box +box-decoration-break +box-shadow +box-sizing +break +break-after +break-before +break-inside +brown +burlwood +cadetblue +capitalize +caps +caption +caption-side +cell +cells +center +center-left +center-right +char +chartreuse +chocolate +circle +cjk +cjk-ideographic +clear +clip +close +close-quote +cm +code +collapse +color +column +column-count +column-fill +column-gap +column-rule +column-rule-color +column-rule-style +column-rule-width +column-span +column-width +columns +compact +condensed +content +continuous +coral +cornflowerblue +cornsilk +counter +counter-increment +counter-reset +crimson +crop +cross +crosshair +cue +cue-after +cue-before +cursive +cursor +cyan +darkblue +darkcyan +darkgoldenrod +darkgray +darkgreen +darkkhaki +darkmagenta +darkolivegreen +darkorange +darkorchid +darkred +darksalmon +darkseagreen +darkshadow +darkslateblue +darkslategray +darkturquoise +darkviolet +dashed +decimal +decimal-leading-zero +decoration +deeppink +deepskyblue +default +deg +digits +dimgray +direction +disc +display +dodgerblue +dotted +double +during +e +e-resize +elevation +em +embed +empty +empty-cells +ex +expanded +extra +extra-condensed +extra-expanded +face +family +fantasy +far +far-left +far-right +fast +faster +filter +firebrick +first +first-child +first-letter +first-line +fixed +flex +flex-basis +flex-direction +flex-flow +flex-grow +flex-shrink +flex-wrap +float +floralwhite +flow +focus +font +font-family +font-feature-setting +font-kerning +font-language-override +font-size +font-size-adjust +font-stretch +font-style +font-synthesis +font-variant +font-variant-alternates +font-variant-caps +font-variant-east-asian +font-variant-ligatures +font-variant-numeric +font-variant-position +font-weight +footer +forestgreen +fuchsia +gainsboro +georgian +ghostwhite +gold +goldenrod +gray +greek +green +greenyellow +grid +groove +group +hanging-punctuation +header +hebrew +height +help +hidden +hide +high +higher +hiragana +hiragana-iroha +honeydew +hotpink +hover +hyphens +icon +ideographic +image +image-orientation +image-rendering +image-resolution +ime-mode +in +increment +indent +index +indianred +indigo +inherit +inline +inline-block +inline-table +inset +inside +iroha +italic +item +ivory +justify +justify-content +kHz +kashida +katakana +katakana-iroha +khaki +landscape +lang() +large +larger +last +latin +lavender +lavenderblush +lawngreen +layout +leading +left +left-side +leftwards +lenonchiffon +letter +letter-spacing +level +lightblue +lightcoral +lightcyan +lighter +lightgoldenrodyellow +lightgray +lightgreen +lightgrey +lightpink +lightsalmon +lightseagreen +lightskyblue +lightslategray +lightsteelblue +lightyellow +lime +limegreen +line +line-break +line-height +line-through +linen +link +list +list-item +list-style +list-style-image +list-style-position +list-style-type +loud +low +lower +lower-alpha +lower-greek +lower-latin +lower-roman +lowercase +ltr +magenta +margin +margin-bottom +margin-left +margin-right +margin-top +mark +mark-after +mark-before +marker +marker-offset +marks +maroon +marquee-direction +marquee-play-count +marquee-speed +marquee-style +mask +mask-type +max +max-height +max-width +medium +mediumaquamarine +mediumblue +mediumorchid +mediumpurple +mediumseagreen +mediumslateblue +mediumspringgreen +mediumturquoise +mediumvioletred +menu +message +message-box +middle +midnightblue +min +min-height +min-width +mintcream +mistyrose +mix +mm +moccasin +mode +monospace +move +ms +n +n-resize +naby +narrower +nav-down +nav-index +nav-left +nav-right +nav-up +navajowhite +ne +ne-resize +no +no-close-quote +no-open-quote +no-repeat +none +normal +nowrap +number +numeral +nw +nw-resize +object-fit +object-position +oblique +offset +oldlace +olive +olivedrab +once +opacity +open +open-quote +orange +orangered +orchid +order +orphans +out +outline +outline-color +outline-offset +outline-style +outline-width +outset +outside +overflow +overflow-wrap +overflow-x +overflow-y +overhang +overline +override +padding +padding-bottom +padding-left +padding-right +padding-top +page +page-break-after +page-break-before +page-break-inside +palegoldenrod +palegreen +paleturquoise +palevioletred +papayawhip +pause +pause-after +pause-before +pc +peachpuff +perspective +perspective-origin +peru +phonemes +pink +pitch +pitch-range +play +play-during +plum +pointer +portarait +position +powderblue +pre +pre-line +pre-wrap +progid +progress +pt +punctuation +purple +px +quote +quotes +rad +range +rate +red +relative +repeat +repeat-x +repeat-y +reset +resize +rest +rest-after +rest-before +richness +ridge +right +right-side +rightwards +roman +rosybrown +row +royalblue +rtl +run +run-in +s +s-resize +saddlebrown +salmon +sandybrown +sans-serif +scroll +se +se-resize +seagreen +seashell +semi +semi-condensed +semi-expanded +separate +serif +shadow +show +side +sienna +silent +silever +silver +size +skyblue +slateblue +slategray +slow +slower +small +small-caps +small-caption +smaller +snow +soft +solid +space +spacing +speak +speak-header +speak-numeral +speak-punctuation +specific +specific-voice +speech +speech-rate +spell +spell-out +springgreen +square +static +status +status-bar +steelblue +stress +stretch +style +sub +super +sw +sw-resize +tab-size +table +table-caption +table-cell +table-column +table-column-group +table-footer-group +table-header-group +table-layout +table-row +table-row-group +tan +teal +text +text-align +text-align-last +text-bottom +text-combine-horizontal +text-decoration +text-decoration-color +text-decoration-line +text-decoration-style +text-indent +text-justify +text-orientation +text-overflow +text-shadow +text-top +text-transform +text-underline-position +thick +thin +thistle +through +tomato +top +track +transform +transform-origin +transform-style +transition +transition-delay +transition-duration +transition-property +transition-timing-function +transparent +turquoise +type +ultra +ultra-condensed +ultra-expanded +underline +unicode +unicode-bidi +upper +upper-alpha +upper-latin +upper-roman +uppercase +variant +vertical +vertical-align +violet +visibility +visible +visited +voice +voice-balance +voice-duration +voice-family +voice-pitch +voice-pitch-range +voice-rate +voice-stress +voice-volume +volume +w +w-resize +wait +weight +wheat +white +white-space +whitesmoke +wider +widows +width +word +word-break +word-spacing +word-wrap +wrap +writing-mode +x +x-fast +x-high +x-large +x-loud +x-low +x-slow +x-small +x-soft +xx +xx-large +xx-small +y +yellow +yellowgreen +z +z-index +zero diff --git a/elpa/auto-complete-20140618.2217/dict/erlang-mode b/elpa/auto-complete-20140618.2217/dict/erlang-mode new file mode 100644 index 00000000..960f2b83 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/erlang-mode @@ -0,0 +1,216 @@ +after +begin +catch +case +cond +end +fun +if +let +of +query +receive +try +when +and +andalso +band +bnot +bor +bsl +bsr +bxor +div +not +or +orelse +rem +xor +is_atom +is_binary +is_bitstring +is_boolean +is_float +is_function +is_integer +is_list +is_number +is_pid +is_port +is_record +is_reference +is_tuple +atom +binary +bitstring +boolean +function +integer +list +number +pid +port +record +reference +tuple +abs +adler32 +adler32_combine +alive +apply +atom_to_binary +atom_to_list +binary_to_atom +binary_to_existing_atom +binary_to_list +binary_to_term +bit_size +bitstring_to_list +byte_size +check_process_code +contact_binary +crc32 +crc32_combine +date +decode_packet +delete_module +disconnect_node +element +erase +exit +float +float_to_list +garbage_collect +get +get_keys +group_leader +halt +hd +integer_to_list +internal_bif +iolist_size +iolist_to_binary +is_alive +is_atom +is_binary +is_bitstring +is_boolean +is_float +is_function +is_integer +is_list +is_number +is_pid +is_port +is_process_alive +is_record +is_reference +is_tuple +length +link +list_to_atom +list_to_binary +list_to_bitstring +list_to_existing_atom +list_to_float +list_to_integer +list_to_pid +list_to_tuple +load_module +make_ref +module_loaded +monitor_node +node +node_link +node_unlink +nodes +notalive +now +open_port +pid_to_list +port_close +port_command +port_connect +port_control +pre_loaded +process_flag +process_info +processes +purge_module +put +register +registered +round +self +setelement +size +spawn +spawn_link +spawn_monitor +spawn_opt +split_binary +statistics +term_to_binary +time +throw +tl +trunc +tuple_size +tuple_to_list +unlink +unregister +whereis +append_element +bump_reductions +cancel_timer +demonitor +display +fun_info +fun_to_list +function_exported +get_cookie +get_stacktrace +hash +integer_to_list +is_builtin +list_to_integer +loaded +localtime +localtime_to_universaltime +make_tuple +max +md5 +md5_final +md5_init +md5_update +memory +min +monitor +monitor_node +phash +phash2 +port_call +port_info +port_to_list +ports +process_display +read_timer +ref_to_list +resume_process +send +send_after +send_nosuspend +set_cookie +start_timer +suspend_process +system_flag +system_info +system_monitor +system_profile +trace +trace_delivered +trace_info +trace_pattern +universaltime +universaltime_to_localtime +yield diff --git a/elpa/auto-complete-20140618.2217/dict/go-mode b/elpa/auto-complete-20140618.2217/dict/go-mode new file mode 100644 index 00000000..b943a164 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/go-mode @@ -0,0 +1,25 @@ +break +case +chan +const +continue +default +defer +else +fallthrough +for +func +go +goto +if +import +interface +map +package +range +return +select +struct +switch +type +var diff --git a/elpa/auto-complete-20140618.2217/dict/haskell-mode b/elpa/auto-complete-20140618.2217/dict/haskell-mode new file mode 100644 index 00000000..9ad1b999 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/haskell-mode @@ -0,0 +1,679 @@ +Arrows +BangPatterns +Bool +Bounded +CPP +Char +Complex +ConstrainedClassMethods +Control.Applicative +Control.Arrow +Control.Category +Control.Concurrent +Control.Concurrent.MVar +Control.Concurrent.QSem +Control.Concurrent.QSemN +Control.Concurrent.STM +Control.Concurrent.STM.TArray +Control.Concurrent.STM.TChan +Control.Concurrent.STM.TMVar +Control.Concurrent.STM.TVar +Control.Concurrent.SampleVar +Control.Exception +Control.Exception.Base +Control.Monad +Control.Monad.Cont +Control.Monad.Cont.Class +Control.Monad.Error +Control.Monad.Error.Class +Control.Monad.Fix +Control.Monad.Identity +Control.Monad.Instances +Control.Monad.List +Control.Monad.RWS +Control.Monad.RWS.Class +Control.Monad.RWS.Lazy +Control.Monad.RWS.Strict +Control.Monad.Reader +Control.Monad.Reader.Class +Control.Monad.ST +Control.Monad.ST.Lazy +Control.Monad.ST.Strict +Control.Monad.STM +Control.Monad.State +Control.Monad.State.Class +Control.Monad.State.Lazy +Control.Monad.State.Strict +Control.Monad.Trans +Control.Monad.Writer +Control.Monad.Writer.Class +Control.Monad.Writer.Lazy +Control.Monad.Writer.Strict +Control.OldException +Control.Parallel +Control.Parallel.Strategies +DEPRECATED +Data.Array +Data.Array.Diff +Data.Array.IArray +Data.Array.IO +Data.Array.IO.Internals +Data.Array.MArray +Data.Array.Paralell +Data.Array.Paralell.Arr +Data.Array.Paralell.Base +Data.Array.Paralell.Int +Data.Array.Paralell.Lifted +Data.Array.Paralell.PArray +Data.Array.Paralell.Prelude +Data.Array.Paralell.Prelude.Double +Data.Array.Paralell.Stream +Data.Array.Paralell.Unlifted +Data.Array.Paralell.Unlifted.Distributed +Data.Array.Paralell.Unlifted.Paralell +Data.Array.Paralell.Unlifted.Sqeuential +Data.Array.Paralell.Word8 +Data.Array.ST +Data.Array.Storable +Data.Array.Unboxed +Data.Bits +Data.Bool +Data.ByteString +Data.ByteString.Char8 +Data.ByteString.Fusion +Data.ByteString.Internal +Data.ByteString.Lazy +Data.ByteString.Lazy.Char8 +Data.ByteString.Lazy.Fusion +Data.ByteString.Lazy.Internal +Data.ByteString.Unsafe +Data.Char +Data.Complex +Data.Data +Data.Dynamic +Data.Either +Data.Eq +Data.Fixed +Data.Foldable +Data.Function +Data.Generics +Data.Generics.Aliases +Data.Generics.Basics +Data.Generics.Instances +Data.Generics.Schemes +Data.Generics.Text +Data.Generics.Twins +Data.Graph +Data.HashTable +Data.IORef +Data.Int +Data.IntMap +Data.IntSet +Data.Ix +Data.List +Data.Map +Data.Maybe +Data.Monoid +Data.Ord +Data.Ratio +Data.STRef +Data.STRef.Lazy +Data.STRef.Strict +Data.Sequence +Data.Set +Data.String +Data.Time +Data.Time.Calendar +Data.Time.Calendar.Easter +Data.Time.Calendar.Julian +Data.Time.Calendar.MonthDay +Data.Time.Calendar.OrdinalDate +Data.Time.Calendar.WeekDate +Data.Time.Clock +Data.Time.Clock.POSIX +Data.Time.Clock.TAI +Data.Time.Format +Data.Time.LocalTime +Data.Traversable +Data.Tree +Data.Tuple +Data.Typeable +Data.Unique +Data.Version +Data.Word +Debug.Trace +DeriveDataTypeable +DisambiguateRecordFields +Distribution.Compat.ReadP +Distribution.Compiler +Distribution.InstalledPackageInfo +Distribution.License +Distribution.Make +Distribution.ModuleName +Distribution.Package +Distribution.PackageDescription +Distribution.PackageDescription.Check +Distribution.PackageDescription.Configuration +Distribution.PackageDescription.Parse +Distribution.ParseUtils +Distribution.ReadE +Distribution.Simple +Distribution.Simple.Build +Distribution.Simple.Build.Macros +Distribution.Simple.Build.PathsModule +Distribution.Simple.BuildPaths +Distribution.Simple.Command +Distribution.Simple.Compiler +Distribution.Simple.Configure +Distribution.Simple.GHC +Distribution.Simple.Haddock +Distribution.Simple.Hugs +Distribution.Simple.Install +Distribution.Simple.InstallDirs +Distribution.Simple.JHC +Distribution.Simple.LocalBuildInfo +Distribution.Simple.NHC +Distribution.Simple.PackageIndex +Distribution.Simple.PreProcess +Distribution.Simple.PreProcess.Unlit +Distribution.Simple.Program +Distribution.Simple.Register +Distribution.Simple.Setup +Distribution.Simple.SrcDist +Distribution.Simple.UserHooks +Distribution.Simple.Utils +Distribution.System +Distribution.Text +Distribution.Verbosity +Distribution.Version +Double +EQ +Either +EmptyDataDecls +Enum +Eq +ExistentialQuantification +ExtendedDefaultRules +False +FilePath +FlexibleContexts +FlexibleInstances +Float +Floating +Foreign +Foreign.C +Foreign.C.Error +Foreign.C.String +Foreign.C.Types +Foreign.Concurrent +Foreign.ForeignPtr +Foreign.Marshal +Foreign.Marshal.Alloc +Foreign.Marshal.Array +Foreign.Marshal.Error +Foreign.Marshal.Pool +Foreign.Marshal.Utils +Foreign.Ptr +Foreign.StablePtr +Foreign.Storable +ForeignFunctionInterface +Fractional +FunctionnalDependencies +Functor +GADTs +GHC.Arr +GHC.Bool +GHC.Conc +GHC.ConsoleHandler +GHC.Desugar +GHC.Environment +GHC.Err +GHC.Exts +GHC.Generics +GHC.Handle +GHC.Ordering +GHC.PArr +GHC.Prim +GHC.PrimopWrappers +GHC.Tuple +GHC.Types +GHC.Unicode +GHC.Unit +GT +GeneralizedNewtypeDeriving +Generics +INCLUDE +INLINE +IO +IOError +IOException +ImplicitParams +ImplicitPrelude +ImpredicativeTypes +IncoherentInstances +Int +Integer +Integral +Just +KindSignatures +LANGUAGE +LINE +LT +Language.Haskell.Extension +Language.Haskell.Lexer +Language.Haskell.ParseMonad +Language.Haskell.ParseUtils +Language.Haskell.Parser +Language.Haskell.Pretty +Language.Haskell.Syntax +Language.Haskell.TH +Language.Haskell.TH.Lib +Language.Haskell.TH.Ppr +Language.Haskell.TH.PprLib +Language.Haskell.TH.Quote +Language.Haskell.TH.Syntax +Left +LiberalTypeSynonyms +MagicHash +Maybe +Monad +MonoPatBinds +MonomorphismRestriction +MultiParamTypeClasses +NOINLINE +NamedFieldPuns +Network +Network.BSD +Network.Socket +Network.URI +NewQualifiedOperators +NoArrows +NoBangPatterns +NoCPP +NoConstrainedClassMethods +NoDeriveDataTypeable +NoDisambiguateRecordFields +NoEmptyDataDecls +NoExistentialQuantification +NoExtendedDefaultRules +NoFlexibleContexts +NoFlexibleInstances +NoForeignFunctionInterface +NoFunctionnalDependencies +NoGADTs +NoGeneralizedNewtypeDeriving +NoGenerics +NoImplicitParams +NoImplicitPrelude +NoImpredicativeTypes +NoIncoherentInstances +NoKindSignatures +NoLiberalTypeSynonyms +NoMagicHash +NoMonoPatBinds +NoMonomorphismRestriction +NoMultiParamTypeClasses +NoNamedFieldPuns +NoNewQualifiedOperators +NoOverlappingInstances +NoOverloadedStrings +NoPArr +NoPackageImports +NoParallelListComp +NoPatternGuards +NoPolymorphicComponents +NoQuasiQuotes +NoRank2Types +NoRankNTypes +NoRecordWildCards +NoRecursiveDo +NoRelaxedPolyRec +NoScopedTypeVariables +NoStandaloneDeriving +NoTemplateHaskell +NoTransformListComp +NoTypeFamilies +NoTypeOperators +NoTypeSynonymInstances +NoUnboxedTuples +NoUndecidableInstances +NoUnicodeSyntax +NoUnliftedFFITypes +NoViewPatterns +Nothing +Num +Numeric +OPTIONS_GHC +Ord +Ordering +OverlappingInstances +OverloadedStrings +PArr +PackageImports +ParallelListComp +PatternGuards +PolymorphicComponents +Prelude +QuasiQuotes +RULES +Rank2Types +RankNTypes +Ratio +Read +ReadS +Real +RealFloat +RealFrac +RecordWildCards +RecursiveDo +RelaxedPolyRec +Right +SOURCE +SPECIALIZE +ScopedTypeVariables +ShowS +StandaloneDeriving +String +System.CPUTime +System.Cmd +System.Console.Editline +System.Console.GetOpt +System.Console.Readline +System.Directory +System.Environment +System.Exit +System.FilePath +System.FilePath.Posix +System.FilePath.Windows +System.IO +System.IO.Error +System.IO.Unsafe +System.Info +System.Locale +System.Mem +System.Mem.StableName +System.Mem.Weak +System.Posix +System.Posix.Directory +System.Posix.DynamicLinker +System.Posix.DynamicLinker.Module +System.Posix.DynamicLinker.Prim +System.Posix.Env +System.Posix.Error +System.Posix.Files +System.Posix.IO +System.Posix.Process +System.Posix.Process.Internals +System.Posix.Resource +System.Posix.Semaphore +System.Posix.SharedMem +System.Posix.Signals +System.Posix.Signals.Exts +System.Posix.Temp +System.Posix.Terminal +System.Posix.Time +System.Posix.Types +System.Posix.Unistd +System.Posix.User +System.Process +System.Random +System.Time +System.Timeout +TemplateHaskell +Test.HUnit +Test.HUnit.Base +Test.HUnit.Lang +Test.HUnit.Terminal +Test.HUnit.Text +Test.QuickCheck +Test.QuickCheck.Batch +Test.QuickCheck.Poly +Test.QuickCheck.Utils +Text.Html +Text.Html.BlockTable +Text.ParserCombinators.Parsec +Text.ParserCombinators.Parsec.Char +Text.ParserCombinators.Parsec.Combinator +Text.ParserCombinators.Parsec.Error +Text.ParserCombinators.Parsec.Expr +Text.ParserCombinators.Parsec.Language +Text.ParserCombinators.Parsec.Perm +Text.ParserCombinators.Parsec.Pos +Text.ParserCombinators.Parsec.Prim +Text.ParserCombinators.Parsec.Token +Text.ParserCombinators.ReadP +Text.ParserCombinators.ReadPrec +Text.PrettyPrint +Text.PrettyPrint.HughesPJ +Text.Printf +Text.Read +Text.Read.Lex +Text.Regex.Base +Text.Regex.Base.Context +Text.Regex.Base.Impl +Text.Regex.Base.RegexLike +Text.Regex.Posix +Text.Regex.Posix.ByteString +Text.Regex.Posix.String +Text.Regex.Posix.Wrap +Text.Show +Text.Show.Functions +Text.XHtml +Text.XHtml.Debug +Text.XHtml.Frameset +Text.XHtml.Strict +Text.XHtml.Table +Text.XHtml.Transitional +Trace.Hpc.Mix +Trace.Hpc.Reflect +Trace.Hpc.Tix +Trace.Hpc.Util +TransformListComp +True +TypeFamilies +TypeOperators +TypeSynonymInstances +UNPACK +UnboxedTuples +UndecidableInstances +UnicodeSyntax +UnliftedFFITypes +Unsafe.Coerce +ViewPatterns +WARNING +abs +acos +acosh +all +and +any +appendFile +as +asTypeOf +asin +asinh +atan +atan2 +atanh +break +case +catch +ceiling +class +compare +concat +concatMap +const +cos +cosh +curry +cycle +data +decodeFloat +default +deriving +div +divMod +do +drop +dropWhile +either +elem +else +encodeFloat +enumFrom +enumFromThen +enumFromThenTo +enumFromTo +error +exp +exponent +fail +filter +flip +floatDigits +floatRadix +floatRange +floor +fmap +fold +fold1 +foldr +foldr1 +fromEnum +fromInteger +fromIntegral +fromRational +fst +gcd +getChar +getContents +getLine +head +hiding +id +if +import +in +infix +infixl +infixr +init +instance +intract +ioError +isDenormalized +isIEEE +isInfinite +isNan +isNegativeZero +iterate +last +lcm +length +let +lex +lines +log +logBase +lookup +map +mapM +mapM_ +max +maxBound +maximum +maybe +min +minBound +minimum +mod +module +negate +newtype +not +notElem +null +odd +of +or +otherwise +pi +pred +print +product +properFraction +putChar +putStr +putStrLn +qualified +quot +quotRem +read +readFile +readIO +readList +readLn +readParen +reads +readsPrec +realtoFrac +recip +rem +repeat +replicate +return +reverse +round +scaleFloat +scanl +scanl1 +scanr +scanr1 +seq +sequence +sequence_ +show +showChar +showList +showParen +showString +shows +showsPrec +significand +signum +sin +sinh +snd +span +splitAt +sqrt +subtract +succ +sum +tail +take +takeWhile +tan +tanh +then +toEnum +toInteger +toRational +truncate +type +uncurry +undefined +unlines +until +unwords +unzip +unzip3 +userError +where +words +writeFile +zip +zip3 +zipWith +zipWith3 \ No newline at end of file diff --git a/elpa/auto-complete-20140618.2217/dict/java-mode b/elpa/auto-complete-20140618.2217/dict/java-mode new file mode 100644 index 00000000..125deeb5 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/java-mode @@ -0,0 +1,53 @@ +abstract +assert +boolean +break +byte +case +catch +char +class +const +continue +default +do +double +else +enum +extends +final +finally +float +for +goto +if +implements +import +instanceof +int +interface +long +native +new +package +private +protected +public +return +short +static +strictfp +super +switch +synchronized +this +throw +throws +transient +try +void +volatile +while +@Override +@Deprecated +@SuppressWarnings \ No newline at end of file diff --git a/elpa/auto-complete-20140618.2217/dict/javascript-mode b/elpa/auto-complete-20140618.2217/dict/javascript-mode new file mode 100644 index 00000000..3d83f843 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/javascript-mode @@ -0,0 +1,148 @@ +Anchor +Area +Array +Boolean +Button +Checkbox +Date +Document +Element +FileUpload +Form +Frame +Function +Hidden +History +Image +Infinity +JavaArray +JavaClass +JavaObject +JavaPackage +Link +Location +Math +MimeType +NaN +Navigator +Number +Object +Option +Packages +Password +Plugin +Radio +RegExp +Reset +Select +String +Submit +Text +Textarea +Window +alert +arguments +assign +blur +break +callee +caller +captureEvents +case +clearInterval +clearTimeout +close +closed +comment +confirm +constructor +continue +default +defaultStatus +delete +do +document +else +escape +eval +export +find +focus +for +frames +function +getClass +history +home +if +import +in +innerHeight +innerWidth +isFinite +isNan +java +label +length +location +locationbar +menubar +moveBy +moveTo +name +navigate +navigator +netscape +new +onBlur +onError +onFocus +onLoad +onUnload +open +opener +outerHeight +outerWidth +pageXoffset +pageYoffset +parent +parseFloat +parseInt +personalbar +print +prompt +prototype +ref +releaseEvents +resizeBy +resizeTo +return +routeEvent +scroll +scrollBy +scrollTo +scrollbars +self +setInterval +setTimeout +status +statusbar +stop +sun +switch +taint +this +toString +toolbar +top +typeof +unescape +untaint +unwatch +valueOf +var +void +watch +while +window +with diff --git a/elpa/auto-complete-20140618.2217/dict/lua-mode b/elpa/auto-complete-20140618.2217/dict/lua-mode new file mode 100644 index 00000000..d0de6a4d --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/lua-mode @@ -0,0 +1,21 @@ +and +break +do +else +elseif +end +false +for +function +if +in +local +nil +not +or +repeat +return +then +true +until +while diff --git a/elpa/auto-complete-20140618.2217/dict/php-mode b/elpa/auto-complete-20140618.2217/dict/php-mode new file mode 100644 index 00000000..07f2e898 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/php-mode @@ -0,0 +1,6144 @@ +abs +acos +acosh +addcslashes +addslashes +aggregate +aggregate_info +aggregate_methods +aggregate_methods_by_list +aggregate_methods_by_regexp +aggregate_properties +aggregate_properties_by_list +aggregate_properties_by_regexp +aggregation_info +amqpconnection +amqpexchange +amqpqueue +and +apache_child_terminate +apache_getenv +apache_get_modules +apache_get_version +apache_lookup_uri +apache_note +apache_request_headers +apache_reset_timeout +apache_response_headers +apache_setenv +apc_add +apc_bin_dump +apc_bin_dumpfile +apc_bin_load +apc_bin_loadfile +apc_cache_info +apc_cas +apc_clear_cache +apc_compile_file +apc_dec +apc_define_constants +apc_delete +apc_delete_file +apc_exists +apc_fetch +apc_inc +apciterator +apc_load_constants +apc_sma_info +apc_store +apd_breakpoint +apd_callstack +apd_clunk +apd_continue +apd_croak +apd_dump_function_table +apd_dump_persistent_resources +apd_dump_regular_resources +apd_echo +apd_get_active_symbols +apd_set_pprof_trace +apd_set_session +apd_set_session_trace +apd_set_session_trace_socket +appenditerator +array +arrayaccess +array_change_key_case +array_chunk +array_combine +array_count_values +array_diff +array_diff_assoc +array_diff_key +array_diff_uassoc +array_diff_ukey +array_fill +array_fill_keys +array_filter +array_flip +array_intersect +array_intersect_assoc +array_intersect_key +array_intersect_uassoc +array_intersect_ukey +arrayiterator +array_key_exists +array_keys +array_map +array_merge +array_merge_recursive +array_multisort +arrayobject +array_pad +array_pop +array_product +array_push +array_rand +array_reduce +array_replace +array_replace_recursive +array_reverse +array_search +array_shift +array_slice +array_splice +array_sum +array_udiff +array_udiff_assoc +array_udiff_uassoc +array_uintersect +array_uintersect_assoc +array_uintersect_uassoc +array_unique +array_unshift +array_values +array_walk +array_walk_recursive +arsort +as +asin +asinh +asort +assert +assert_options +atan +atan2 +atanh +badfunctioncallexception +badmethodcallexception +base64_decode +base64_encode +base_convert +basename +bbcode_add_element +bbcode_add_smiley +bbcode_create +bbcode_destroy +bbcode_parse +bbcode_set_arg_parser +bbcode_set_flags +bcadd +bccomp +bcdiv +bcmod +bcmul +bcompiler_load +bcompiler_load_exe +bcompiler_parse_class +bcompiler_read +bcompiler_write_class +bcompiler_write_constant +bcompiler_write_exe_footer +bcompiler_write_file +bcompiler_write_footer +bcompiler_write_function +bcompiler_write_functions_from_file +bcompiler_write_header +bcompiler_write_included_filename +bcpow +bcpowmod +bcscale +bcsqrt +bcsub +bin2hex +bindec +bindtextdomain +bind_textdomain_codeset +break +bson_decode +bson_encode +bumpValue +bzclose +bzcompress +bzdecompress +bzerrno +bzerror +bzerrstr +bzflush +bzopen +bzread +bzwrite +cachingiterator +cairo +cairoantialias +cairocontent +cairocontext +cairo_create +cairoexception +cairoextend +cairofillrule +cairofilter +cairofontface +cairo_font_face_get_type +cairo_font_face_status +cairofontoptions +cairo_font_options_create +cairo_font_options_equal +cairo_font_options_get_antialias +cairo_font_options_get_hint_metrics +cairo_font_options_get_hint_style +cairo_font_options_get_subpixel_order +cairo_font_options_hash +cairo_font_options_merge +cairo_font_options_set_antialias +cairo_font_options_set_hint_metrics +cairo_font_options_set_hint_style +cairo_font_options_set_subpixel_order +cairo_font_options_status +cairofontslant +cairofonttype +cairofontweight +cairoformat +cairo_format_stride_for_width +cairogradientpattern +cairohintmetrics +cairohintstyle +cairoimagesurface +cairo_image_surface_create +cairo_image_surface_create_for_data +cairo_image_surface_create_from_png +cairo_image_surface_get_data +cairo_image_surface_get_format +cairo_image_surface_get_height +cairo_image_surface_get_stride +cairo_image_surface_get_width +cairolineargradient +cairolinecap +cairolinejoin +cairomatrix +cairo_matrix_create_scale +cairo_matrix_create_translate +cairo_matrix_invert +cairo_matrix_multiply +cairo_matrix_rotate +cairo_matrix_transform_distance +cairo_matrix_transform_point +cairo_matrix_translate +cairooperator +cairopath +cairopattern +cairo_pattern_add_color_stop_rgb +cairo_pattern_add_color_stop_rgba +cairo_pattern_create_for_surface +cairo_pattern_create_linear +cairo_pattern_create_radial +cairo_pattern_create_rgb +cairo_pattern_create_rgba +cairo_pattern_get_color_stop_count +cairo_pattern_get_color_stop_rgba +cairo_pattern_get_extend +cairo_pattern_get_filter +cairo_pattern_get_linear_points +cairo_pattern_get_matrix +cairo_pattern_get_radial_circles +cairo_pattern_get_rgba +cairo_pattern_get_surface +cairo_pattern_get_type +cairo_pattern_set_extend +cairo_pattern_set_filter +cairo_pattern_set_matrix +cairo_pattern_status +cairopatterntype +cairopdfsurface +cairo_pdf_surface_create +cairo_pdf_surface_set_size +cairo_ps_get_levels +cairopslevel +cairo_ps_level_to_string +cairopssurface +cairo_ps_surface_create +cairo_ps_surface_dsc_begin_page_setup +cairo_ps_surface_dsc_begin_setup +cairo_ps_surface_dsc_comment +cairo_ps_surface_get_eps +cairo_ps_surface_restrict_to_level +cairo_ps_surface_set_eps +cairo_ps_surface_set_size +cairoradialgradient +cairoscaledfont +cairo_scaled_font_create +cairo_scaled_font_extents +cairo_scaled_font_get_ctm +cairo_scaled_font_get_font_face +cairo_scaled_font_get_font_matrix +cairo_scaled_font_get_font_options +cairo_scaled_font_get_scale_matrix +cairo_scaled_font_get_type +cairo_scaled_font_glyph_extents +cairo_scaled_font_status +cairo_scaled_font_text_extents +cairosolidpattern +cairostatus +cairosubpixelorder +cairosurface +cairo_surface_copy_page +cairo_surface_create_similar +cairo_surface_finish +cairo_surface_flush +cairo_surface_get_content +cairo_surface_get_device_offset +cairo_surface_get_font_options +cairo_surface_get_type +cairo_surface_mark_dirty +cairo_surface_mark_dirty_rectangle +cairosurfacepattern +cairo_surface_set_device_offset +cairo_surface_set_fallback_resolution +cairo_surface_show_page +cairo_surface_status +cairosurfacetype +cairo_surface_write_to_png +cairosvgsurface +cairo_svg_surface_create +cairo_svg_surface_restrict_to_version +cairosvgversion +cairo_svg_version_to_string +cairotoyfontface +calculhmac +calcul_hmac +cal_days_in_month +cal_from_jd +cal_info +__call() +callbackfilteriterator +__callStatic() +call_user_func +call_user_func_array +call_user_method +call_user_method_array +cal_to_jd +case +catch +ceil +cfunction +chdb +chdb_create +chdir +checkdate +checkdnsrr +chgrp +chmod +chop +chown +chr +chroot +chunk_split +class +__CLASS__ +class_alias +class_exists +class_implements +classkit_import +classkit_method_add +classkit_method_copy +classkit_method_redefine +classkit_method_remove +classkit_method_rename +class_parents +clearstatcache +clone +__clone() +closedir +closelog +collator +com +com_addref +com_create_guid +com_event_sink +com_get +com_get_active_object +com_invoke +com_isenum +com_load +com_load_typelib +com_message_pump +compact +com_print_typeinfo +com_propget +com_propput +com_propset +com_release +com_set +connection_aborted +connection_status +connection_timeout +const +constant +construct +__construct() +continue +convert_cyr_string +convert_uudecode +convert_uuencode +copy +cos +cosh +count +countable +count_chars +counter_bump +counter_bump_value +counter_create +counter_get +counter_get_meta +counter_get_named +counter_get_value +counter_reset +counter_reset_value +crack_check +crack_closedict +crack_getlastmessage +crack_opendict +crc32 +create_function +crypt +ctype_alnum +ctype_alpha +ctype_cntrl +ctype_digit +ctype_graph +ctype_lower +ctype_print +ctype_punct +ctype_space +ctype_upper +ctype_xdigit +cubrid_affected_rows +cubrid_bind +cubrid_client_encoding +cubrid_close +cubrid_close_prepare +cubrid_close_request +cubrid_col_get +cubrid_col_size +cubrid_column_names +cubrid_column_types +cubrid_commit +cubrid_connect +cubrid_connect_with_url +cubrid_current_oid +cubrid_data_seek +cubrid_db_name +cubrid_disconnect +cubrid_drop +cubrid_errno +cubrid_error +cubrid_error_code +cubrid_error_code_facility +cubrid_error_msg +cubrid_execute +cubrid_fetch +cubrid_fetch_array +cubrid_fetch_assoc +cubrid_fetch_field +cubrid_fetch_lengths +cubrid_fetch_object +cubrid_fetch_row +cubrid_field_flags +cubrid_field_len +cubrid_field_name +cubrid_field_seek +cubrid_field_table +cubrid_field_type +cubrid_free_result +cubrid_get +cubrid_get_autocommit +cubrid_get_charset +cubrid_get_class_name +cubrid_get_client_info +cubrid_get_db_parameter +cubrid_get_server_info +cubrid_insert_id +cubrid_is_instance +cubrid_list_dbs +cubrid_load_from_glo +cubrid_lob_close +cubrid_lob_export +cubrid_lob_get +cubrid_lob_send +cubrid_lob_size +cubrid_lock_read +cubrid_lock_write +cubrid_move_cursor +cubrid_new_glo +cubrid_next_result +cubrid_num_cols +cubrid_num_fields +cubrid_num_rows +cubrid_ping +cubrid_prepare +cubrid_put +cubrid_query +cubrid_real_escape_string +cubrid_result +cubrid_rollback +cubrid_save_to_glo +cubrid_schema +cubrid_send_glo +cubrid_seq_drop +cubrid_seq_insert +cubrid_seq_put +cubrid_set_add +cubrid_set_autocommit +cubrid_set_db_parameter +cubrid_set_drop +cubrid_unbuffered_query +cubrid_version +curl_close +curl_copy_handle +curl_errno +curl_error +curl_exec +curl_getinfo +curl_init +curl_multi_add_handle +curl_multi_close +curl_multi_exec +curl_multi_getcontent +curl_multi_info_read +curl_multi_init +curl_multi_remove_handle +curl_multi_select +curl_setopt +curl_setopt_array +curl_version +current +cyrus_authenticate +cyrus_bind +cyrus_close +cyrus_connect +cyrus_query +cyrus_unbind +date +date_add +date_create +date_create_from_format +date_date_set +date_default_timezone_get +date_default_timezone_set +date_diff +date_format +date_get_last_errors +dateinterval +date_interval_create_from_date_string +date_interval_format +date_isodate_set +date_modify +date_offset_get +date_parse +date_parse_from_format +dateperiod +date_sub +date_sun_info +date_sunrise +date_sunset +datetime +date_time_set +date_timestamp_get +date_timestamp_set +datetimezone +date_timezone_get +date_timezone_set +db2_autocommit +db2_bind_param +db2_client_info +db2_close +db2_column_privileges +db2_columns +db2_commit +db2_connect +db2_conn_error +db2_conn_errormsg +db2_cursor_type +db2_escape_string +db2_exec +db2_execute +db2_fetch_array +db2_fetch_assoc +db2_fetch_both +db2_fetch_object +db2_fetch_row +db2_field_display_size +db2_field_name +db2_field_num +db2_field_precision +db2_field_scale +db2_field_type +db2_field_width +db2_foreign_keys +db2_free_result +db2_free_stmt +db2_get_option +db2_last_insert_id +db2_lob_read +db2_next_result +db2_num_fields +db2_num_rows +db2_pclose +db2_pconnect +db2_prepare +db2_primary_keys +db2_procedure_columns +db2_procedures +db2_result +db2_rollback +db2_server_info +db2_set_option +db2_special_columns +db2_statistics +db2_stmt_error +db2_stmt_errormsg +db2_table_privileges +db2_tables +dba_close +dba_delete +dba_exists +dba_fetch +dba_firstkey +dba_handlers +dba_insert +dba_key_split +dba_list +dba_nextkey +dba_open +dba_optimize +dba_popen +dba_replace +dbase_add_record +dbase_close +dbase_create +dbase_delete_record +dbase_get_header_info +dbase_get_record +dbase_get_record_with_names +dbase_numfields +dbase_numrecords +dbase_open +dbase_pack +dbase_replace_record +dba_sync +dbplus_add +dbplus_aql +dbplus_chdir +dbplus_close +dbplus_curr +dbplus_errcode +dbplus_errno +dbplus_find +dbplus_first +dbplus_flush +dbplus_freealllocks +dbplus_freelock +dbplus_freerlocks +dbplus_getlock +dbplus_getunique +dbplus_info +dbplus_last +dbplus_lockrel +dbplus_next +dbplus_open +dbplus_prev +dbplus_rchperm +dbplus_rcreate +dbplus_rcrtexact +dbplus_rcrtlike +dbplus_resolve +dbplus_restorepos +dbplus_rkeys +dbplus_ropen +dbplus_rquery +dbplus_rrename +dbplus_rsecindex +dbplus_runlink +dbplus_rzap +dbplus_savepos +dbplus_setindex +dbplus_setindexbynumber +dbplus_sql +dbplus_tcl +dbplus_tremove +dbplus_undo +dbplus_undoprepare +dbplus_unlockrel +dbplus_unselect +dbplus_update +dbplus_xlockrel +dbplus_xunlockrel +dbx_close +dbx_compare +dbx_connect +dbx_error +dbx_escape_string +dbx_fetch_row +dbx_query +dbx_sort +dcgettext +dcngettext +deaggregate +debug_backtrace +debug_print_backtrace +debug_zval_dump +decbin +dechex +declare +decoct +default +define +defined +define_syslog_variables +deg2rad +delete +__destruct() +dgettext +die +dio_close +dio_fcntl +dio_open +dio_read +dio_seek +dio_stat +dio_tcsetattr +dio_truncate +dio_write +dir +__DIR__ +directoryiterator +dirname +diskfreespace +disk_free_space +disk_total_space +dl +dngettext +dns_check_record +dns_get_mx +dns_get_record +do +domainexception +domattr +domattribute_name +domattribute_set_value +domattribute_specified +domattribute_value +domcharacterdata +domcomment +domdocument +domdocument_add_root +domdocument_create_attribute +domdocument_create_cdata_section +domdocument_create_comment +domdocument_create_element +domdocument_create_element_ns +domdocument_create_entity_reference +domdocument_create_processing_instruction +domdocument_create_text_node +domdocument_doctype +domdocument_document_element +domdocument_dump_file +domdocument_dump_mem +domdocumentfragment +domdocument_get_element_by_id +domdocument_get_elements_by_tagname +domdocument_html_dump_mem +domdocumenttype +domdocumenttype_entities +domdocumenttype_internal_subset +domdocumenttype_name +domdocumenttype_notations +domdocumenttype_public_id +domdocumenttype_system_id +domdocument_xinclude +domelement +domelement_get_attribute +domelement_get_attribute_node +domelement_get_elements_by_tagname +domelement_has_attribute +domelement_remove_attribute +domelement_set_attribute +domelement_set_attribute_node +domelement_tagname +domentity +domentityreference +domexception +domimplementation +dom_import_simplexml +domnamednodemap +domnode +domnode_add_namespace +domnode_append_child +domnode_append_sibling +domnode_attributes +domnode_child_nodes +domnode_clone_node +domnode_dump_node +domnode_first_child +domnode_get_content +domnode_has_attributes +domnode_has_child_nodes +domnode_insert_before +domnode_is_blank_node +domnode_last_child +domnodelist +domnode_next_sibling +domnode_node_name +domnode_node_type +domnode_node_value +domnode_owner_document +domnode_parent_node +domnode_prefix +domnode_previous_sibling +domnode_remove_child +domnode_replace_child +domnode_replace_node +domnode_set_content +domnode_set_name +domnode_set_namespace +domnode_unlink_node +domnotation +domprocessinginstruction +domprocessinginstruction_data +domprocessinginstruction_target +domtext +domxml_new_doc +domxml_open_file +domxml_open_mem +domxml_version +domxml_xmltree +domxml_xslt_stylesheet +domxml_xslt_stylesheet_doc +domxml_xslt_stylesheet_file +domxml_xslt_version +domxpath +domxsltstylesheet_process +domxsltstylesheet_result_dump_file +domxsltstylesheet_result_dump_mem +dotnet +dotnet_load +doubleval +each +easter_date +easter_days +echo +else +elseif +empty +emptyiterator +enchant_broker_describe +enchant_broker_dict_exists +enchant_broker_free +enchant_broker_free_dict +enchant_broker_get_error +enchant_broker_init +enchant_broker_list_dicts +enchant_broker_request_dict +enchant_broker_request_pwl_dict +enchant_broker_set_ordering +enchant_dict_add_to_personal +enchant_dict_add_to_session +enchant_dict_check +enchant_dict_describe +enchant_dict_get_error +enchant_dict_is_in_session +enchant_dict_quick_check +enchant_dict_store_replacement +enchant_dict_suggest +end +enddeclare +endfor +endforeach +endif +endswitch +endwhile +ereg +eregi +eregi_replace +ereg_replace +errorexception +error_get_last +error_log +error_reporting +escapeshellarg +escapeshellcmd +eval +event_add +event_base_free +event_base_loop +event_base_loopbreak +event_base_loopexit +event_base_new +event_base_priority_init +event_base_set +event_buffer_base_set +event_buffer_disable +event_buffer_enable +event_buffer_fd_set +event_buffer_free +event_buffer_new +event_buffer_priority_set +event_buffer_read +event_buffer_set_callback +event_buffer_timeout_set +event_buffer_watermark_set +event_buffer_write +event_del +event_free +event_new +event_set +exception +exec +exif_imagetype +exif_read_data +exif_tagname +exif_thumbnail +exit +exp +expect_expectl +expect_popen +explode +expm1 +export +extends +extension_loaded +extract +ezmlm_hash +fam_cancel_monitor +fam_close +fam_monitor_collection +fam_monitor_directory +fam_monitor_file +fam_next_event +fam_open +fam_pending +fam_resume_monitor +fam_suspend_monitor +fbsql_affected_rows +fbsql_autocommit +fbsql_blob_size +fbsql_change_user +fbsql_clob_size +fbsql_close +fbsql_commit +fbsql_connect +fbsql_create_blob +fbsql_create_clob +fbsql_create_db +fbsql_database +fbsql_database_password +fbsql_data_seek +fbsql_db_query +fbsql_db_status +fbsql_drop_db +fbsql_errno +fbsql_error +fbsql_fetch_array +fbsql_fetch_assoc +fbsql_fetch_field +fbsql_fetch_lengths +fbsql_fetch_object +fbsql_fetch_row +fbsql_field_flags +fbsql_field_len +fbsql_field_name +fbsql_field_seek +fbsql_field_table +fbsql_field_type +fbsql_free_result +fbsql_get_autostart_info +fbsql_hostname +fbsql_insert_id +fbsql_list_dbs +fbsql_list_fields +fbsql_list_tables +fbsql_next_result +fbsql_num_fields +fbsql_num_rows +fbsql_password +fbsql_pconnect +fbsql_query +fbsql_read_blob +fbsql_read_clob +fbsql_result +fbsql_rollback +fbsql_rows_fetched +fbsql_select_db +fbsql_set_characterset +fbsql_set_lob_mode +fbsql_set_password +fbsql_set_transaction +fbsql_start_db +fbsql_stop_db +fbsql_tablename +fbsql_table_name +fbsql_username +fbsql_warnings +fclose +fdf_add_doc_javascript +fdf_add_template +fdf_close +fdf_create +fdf_enum_values +fdf_errno +fdf_error +fdf_get_ap +fdf_get_attachment +fdf_get_encoding +fdf_get_file +fdf_get_flags +fdf_get_opt +fdf_get_status +fdf_get_value +fdf_get_version +fdf_header +fdf_next_field_name +fdf_open +fdf_open_string +fdf_remove_item +fdf_save +fdf_save_string +fdf_set_ap +fdf_set_encoding +fdf_set_file +fdf_set_flags +fdf_set_javascript_action +fdf_set_on_import_javascript +fdf_set_opt +fdf_set_status +fdf_set_submit_form_action +fdf_set_target_frame +fdf_set_value +fdf_set_version +feof +fflush +fgetc +fgetcsv +fgets +fgetss +file +__FILE__ +fileatime +filectime +file_exists +file_get_contents +filegroup +fileinode +filemtime +fileowner +fileperms +filepro +filepro_fieldcount +filepro_fieldname +filepro_fieldtype +filepro_fieldwidth +filepro_retrieve +filepro_rowcount +file_put_contents +filesize +filesystemiterator +filetype +filter_has_var +filter_id +filter_input +filter_input_array +filteriterator +filter_list +filter_var +filter_var_array +final +finfo_buffer +finfo_close +finfo_file +finfo_open +finfo_set_flags +floatval +flock +floor +flush +fmod +fnmatch +fopen +for +foreach +forward_static_call +forward_static_call_array +fpassthru +fprintf +fputcsv +fputs +fread +frenchtojd +fribidi_log2vis +fscanf +fseek +fsockopen +fstat +ftell +ftok +ftp_alloc +ftp_cdup +ftp_chdir +ftp_chmod +ftp_close +ftp_connect +ftp_delete +ftp_exec +ftp_fget +ftp_fput +ftp_get +ftp_get_option +ftp_login +ftp_mdtm +ftp_mkdir +ftp_nb_continue +ftp_nb_fget +ftp_nb_fput +ftp_nb_get +ftp_nb_put +ftp_nlist +ftp_pasv +ftp_put +ftp_pwd +ftp_quit +ftp_raw +ftp_rawlist +ftp_rename +ftp_rmdir +ftp_set_option +ftp_site +ftp_size +ftp_ssl_connect +ftp_systype +ftruncate +func_get_arg +func_get_args +func_num_args +function +__FUNCTION__ +function_exists +fwrite +gc_collect_cycles +gc_disable +gc_enable +gc_enabled +gd_info +gearmanclient +gearmanjob +gearmantask +gearmanworker +geoip_continent_code_by_name +geoip_country_code3_by_name +geoip_country_code_by_name +geoip_country_name_by_name +geoip_database_info +geoip_db_avail +geoip_db_filename +geoip_db_get_all_info +geoip_id_by_name +geoip_isp_by_name +geoip_org_by_name +geoip_record_by_name +geoip_region_by_name +geoip_region_name_by_code +geoip_time_zone_by_country_and_region +__get() +getallheaders +get_browser +get_called_class +get_cfg_var +get_class +get_class_methods +get_class_vars +getclosure +getconstant +getconstants +getconstructor +get_current_user +getcwd +getdate +get_declared_classes +get_declared_interfaces +getdefaultproperties +get_defined_constants +get_defined_functions +get_defined_vars +getdoccomment +getendline +getenv +getextension +get_extension_funcs +getextensionname +getfilename +get_headers +gethostbyaddr +gethostbyname +gethostbynamel +gethostname +get_html_translation_table +getimagesize +get_included_files +get_include_path +getinterfacenames +getinterfaces +getlastmod +get_loaded_extensions +get_magic_quotes_gpc +get_magic_quotes_runtime +getMeta +get_meta_tags +getmethod +getmethods +getmodifiers +getmxrr +getmygid +getmyinode +getmypid +getmyuid +getname +getNamed +getnamespacename +get_object_vars +getopt +getparentclass +get_parent_class +getproperties +getproperty +getprotobyname +getprotobynumber +getrandmax +get_required_files +get_resource_type +getrusage +getservbyname +getservbyport +getshortname +getstartline +getstaticproperties +getstaticpropertyvalue +gettext +gettimeofday +gettraitaliases +gettraitnames +gettraits +gettype +getValue +glob +global +globiterator +gmagick +gmagickdraw +gmagickpixel +gmdate +gmmktime +gmp_abs +gmp_add +gmp_and +gmp_clrbit +gmp_cmp +gmp_com +gmp_div +gmp_divexact +gmp_div_q +gmp_div_qr +gmp_div_r +gmp_fact +gmp_gcd +gmp_gcdext +gmp_hamdist +gmp_init +gmp_intval +gmp_invert +gmp_jacobi +gmp_legendre +gmp_mod +gmp_mul +gmp_neg +gmp_nextprime +gmp_or +gmp_perfect_square +gmp_popcount +gmp_pow +gmp_powm +gmp_prob_prime +gmp_random +gmp_scan0 +gmp_scan1 +gmp_setbit +gmp_sign +gmp_sqrt +gmp_sqrtrem +gmp_strval +gmp_sub +gmp_testbit +gmp_xor +gmstrftime +gnupg_adddecryptkey +gnupg_addencryptkey +gnupg_addsignkey +gnupg_cleardecryptkeys +gnupg_clearencryptkeys +gnupg_clearsignkeys +gnupg_decrypt +gnupg_decryptverify +gnupg_encrypt +gnupg_encryptsign +gnupg_export +gnupg_geterror +gnupg_getprotocol +gnupg_import +gnupg_init +gnupg_keyinfo +gnupg_setarmor +gnupg_seterrormode +gnupg_setsignmode +gnupg_sign +gnupg_verify +gopher_parsedir +goto +grapheme_extract +grapheme_stripos +grapheme_stristr +grapheme_strlen +grapheme_strpos +grapheme_strripos +grapheme_strrpos +grapheme_strstr +grapheme_substr +gregoriantojd +gupnp_context_get_host_ip +gupnp_context_get_port +gupnp_context_get_subscription_timeout +gupnp_context_host_path +gupnp_context_new +gupnp_context_set_subscription_timeout +gupnp_context_timeout_add +gupnp_context_unhost_path +gupnp_control_point_browse_start +gupnp_control_point_browse_stop +gupnp_control_point_callback_set +gupnp_control_point_new +gupnp_device_action_callback_set +gupnp_device_info_get +gupnp_device_info_get_service +gupnp_root_device_get_available +gupnp_root_device_get_relative_location +gupnp_root_device_new +gupnp_root_device_set_available +gupnp_root_device_start +gupnp_root_device_stop +gupnp_service_action_get +gupnp_service_action_return +gupnp_service_action_return_error +gupnp_service_action_set +gupnp_service_freeze_notify +gupnp_service_info_get +gupnp_service_info_get_introspection +gupnp_service_introspection_get_state_variable +gupnp_service_notify +gupnp_service_proxy_action_get +gupnp_service_proxy_action_set +gupnp_service_proxy_add_notify +gupnp_service_proxy_callback_set +gupnp_service_proxy_get_subscribed +gupnp_service_proxy_remove_notify +gupnp_service_proxy_set_subscribed +gupnp_service_thaw_notify +gzclose +gzcompress +gzdecode +gzdeflate +gzencode +gzeof +gzfile +gzgetc +gzgets +gzgetss +gzinflate +gzopen +gzpassthru +gzputs +gzread +gzrewind +gzseek +gztell +gzuncompress +gzwrite +halt_compiler +haruannotation +haruannotation_setborderstyle +haruannotation_sethighlightmode +haruannotation_seticon +haruannotation_setopened +harudestination +harudestination_setfit +harudestination_setfitb +harudestination_setfitbh +harudestination_setfitbv +harudestination_setfith +harudestination_setfitr +harudestination_setfitv +harudestination_setxyz +harudoc +harudoc_addpage +harudoc_addpagelabel +harudoc_construct +harudoc_createoutline +harudoc_getcurrentencoder +harudoc_getcurrentpage +harudoc_getencoder +harudoc_getfont +harudoc_getinfoattr +harudoc_getpagelayout +harudoc_getpagemode +harudoc_getstreamsize +harudoc_insertpage +harudoc_loadjpeg +harudoc_loadpng +harudoc_loadraw +harudoc_loadttc +harudoc_loadttf +harudoc_loadtype1 +harudoc_output +harudoc_readfromstream +harudoc_reseterror +harudoc_resetstream +harudoc_save +harudoc_savetostream +harudoc_setcompressionmode +harudoc_setcurrentencoder +harudoc_setencryptionmode +harudoc_setinfoattr +harudoc_setinfodateattr +harudoc_setopenaction +harudoc_setpagelayout +harudoc_setpagemode +harudoc_setpagesconfiguration +harudoc_setpassword +harudoc_setpermission +harudoc_usecnsencodings +harudoc_usecnsfonts +harudoc_usecntencodings +harudoc_usecntfonts +harudoc_usejpencodings +harudoc_usejpfonts +harudoc_usekrencodings +harudoc_usekrfonts +haruencoder +haruencoder_getbytetype +haruencoder_gettype +haruencoder_getunicode +haruencoder_getwritingmode +haruexception +harufont +harufont_getascent +harufont_getcapheight +harufont_getdescent +harufont_getencodingname +harufont_getfontname +harufont_gettextwidth +harufont_getunicodewidth +harufont_getxheight +harufont_measuretext +haruimage +haruimage_getbitspercomponent +haruimage_getcolorspace +haruimage_getheight +haruimage_getsize +haruimage_getwidth +haruimage_setcolormask +haruimage_setmaskimage +haruoutline +haruoutline_setdestination +haruoutline_setopened +harupage +harupage_arc +harupage_begintext +harupage_circle +harupage_closepath +harupage_concat +harupage_createdestination +harupage_createlinkannotation +harupage_createtextannotation +harupage_createurlannotation +harupage_curveto +harupage_curveto2 +harupage_curveto3 +harupage_drawimage +harupage_ellipse +harupage_endpath +harupage_endtext +harupage_eofill +harupage_eofillstroke +harupage_fill +harupage_fillstroke +harupage_getcharspace +harupage_getcmykfill +harupage_getcmykstroke +harupage_getcurrentfont +harupage_getcurrentfontsize +harupage_getcurrentpos +harupage_getcurrenttextpos +harupage_getdash +harupage_getfillingcolorspace +harupage_getflatness +harupage_getgmode +harupage_getgrayfill +harupage_getgraystroke +harupage_getheight +harupage_gethorizontalscaling +harupage_getlinecap +harupage_getlinejoin +harupage_getlinewidth +harupage_getmiterlimit +harupage_getrgbfill +harupage_getrgbstroke +harupage_getstrokingcolorspace +harupage_gettextleading +harupage_gettextmatrix +harupage_gettextrenderingmode +harupage_gettextrise +harupage_gettextwidth +harupage_gettransmatrix +harupage_getwidth +harupage_getwordspace +harupage_lineto +harupage_measuretext +harupage_movetextpos +harupage_moveto +harupage_movetonextline +harupage_rectangle +harupage_setcharspace +harupage_setcmykfill +harupage_setcmykstroke +harupage_setdash +harupage_setflatness +harupage_setfontandsize +harupage_setgrayfill +harupage_setgraystroke +harupage_setheight +harupage_sethorizontalscaling +harupage_setlinecap +harupage_setlinejoin +harupage_setlinewidth +harupage_setmiterlimit +harupage_setrgbfill +harupage_setrgbstroke +harupage_setrotate +harupage_setsize +harupage_setslideshow +harupage_settextleading +harupage_settextmatrix +harupage_settextrenderingmode +harupage_settextrise +harupage_setwidth +harupage_setwordspace +harupage_showtext +harupage_showtextnextline +harupage_stroke +harupage_textout +harupage_textrect +hasconstant +hash +hash_algos +hash_copy +hash_file +hash_final +hash_hmac +hash_hmac_file +hash_init +hash_update +hash_update_file +hash_update_stream +hasmethod +hasproperty +header +header_register_callback +header_remove +headers_list +headers_sent +hebrev +hebrevc +hex2bin +hexdec +highlight_file +highlight_string +htmlentities +html_entity_decode +htmlspecialchars +htmlspecialchars_decode +http_build_cookie +http_build_query +http_build_str +http_build_url +http_cache_etag +http_cache_last_modified +http_chunked_decode +http_date +http_deflate +httpdeflatestream +httpdeflatestream_construct +httpdeflatestream_factory +httpdeflatestream_finish +httpdeflatestream_flush +httpdeflatestream_update +http_get +http_get_request_body +http_get_request_body_stream +http_get_request_headers +http_head +http_inflate +httpinflatestream +httpinflatestream_construct +httpinflatestream_factory +httpinflatestream_finish +httpinflatestream_flush +httpinflatestream_update +http_match_etag +http_match_modified +http_match_request_header +httpmessage +httpmessage_addheaders +httpmessage_construct +httpmessage_detach +httpmessage_factory +httpmessage_fromenv +httpmessage_fromstring +httpmessage_getbody +httpmessage_getheader +httpmessage_getheaders +httpmessage_gethttpversion +httpmessage_getparentmessage +httpmessage_getrequestmethod +httpmessage_getrequesturl +httpmessage_getresponsecode +httpmessage_getresponsestatus +httpmessage_gettype +httpmessage_guesscontenttype +httpmessage_prepend +httpmessage_reverse +httpmessage_send +httpmessage_setbody +httpmessage_setheaders +httpmessage_sethttpversion +httpmessage_setrequestmethod +httpmessage_setrequesturl +httpmessage_setresponsecode +httpmessage_setresponsestatus +httpmessage_settype +httpmessage_tomessagetypeobject +httpmessage_tostring +http_negotiate_charset +http_negotiate_content_type +http_negotiate_language +http_parse_cookie +http_parse_headers +http_parse_message +http_parse_params +http_persistent_handles_clean +http_persistent_handles_count +http_persistent_handles_ident +http_post_data +http_post_fields +http_put_data +http_put_file +http_put_stream +httpquerystring +httpquerystring_construct +httpquerystring_get +httpquerystring_mod +httpquerystring_set +httpquerystring_singleton +httpquerystring_toarray +httpquerystring_tostring +httpquerystring_xlate +http_redirect +httprequest +http_request +httprequest_addcookies +httprequest_addheaders +httprequest_addpostfields +httprequest_addpostfile +httprequest_addputdata +httprequest_addquerydata +httprequest_addrawpostdata +httprequest_addssloptions +http_request_body_encode +httprequest_clearhistory +httprequest_construct +httprequest_enablecookies +httprequest_getcontenttype +httprequest_getcookies +httprequest_getheaders +httprequest_gethistory +httprequest_getmethod +httprequest_getoptions +httprequest_getpostfields +httprequest_getpostfiles +httprequest_getputdata +httprequest_getputfile +httprequest_getquerydata +httprequest_getrawpostdata +httprequest_getrawrequestmessage +httprequest_getrawresponsemessage +httprequest_getrequestmessage +httprequest_getresponsebody +httprequest_getresponsecode +httprequest_getresponsecookies +httprequest_getresponsedata +httprequest_getresponseheader +httprequest_getresponseinfo +httprequest_getresponsemessage +httprequest_getresponsestatus +httprequest_getssloptions +httprequest_geturl +http_request_method_exists +http_request_method_name +http_request_method_register +http_request_method_unregister +httprequestpool +httprequestpool_attach +httprequestpool_construct +httprequestpool_destruct +httprequestpool_detach +httprequestpool_getattachedrequests +httprequestpool_getfinishedrequests +httprequestpool_reset +httprequestpool_send +httprequestpool_socketperform +httprequestpool_socketselect +httprequest_resetcookies +httprequest_send +httprequest_setcontenttype +httprequest_setcookies +httprequest_setheaders +httprequest_setmethod +httprequest_setoptions +httprequest_setpostfields +httprequest_setpostfiles +httprequest_setputdata +httprequest_setputfile +httprequest_setquerydata +httprequest_setrawpostdata +httprequest_setssloptions +httprequest_seturl +httpresponse +httpresponse_capture +http_response_code +httpresponse_getbuffersize +httpresponse_getcache +httpresponse_getcachecontrol +httpresponse_getcontentdisposition +httpresponse_getcontenttype +httpresponse_getdata +httpresponse_getetag +httpresponse_getfile +httpresponse_getgzip +httpresponse_getheader +httpresponse_getlastmodified +httpresponse_getrequestbody +httpresponse_getrequestbodystream +httpresponse_getrequestheaders +httpresponse_getstream +httpresponse_getthrottledelay +httpresponse_guesscontenttype +httpresponse_redirect +httpresponse_send +httpresponse_setbuffersize +httpresponse_setcache +httpresponse_setcachecontrol +httpresponse_setcontentdisposition +httpresponse_setcontenttype +httpresponse_setdata +httpresponse_setetag +httpresponse_setfile +httpresponse_setgzip +httpresponse_setheader +httpresponse_setlastmodified +httpresponse_setstream +httpresponse_setthrottledelay +httpresponse_status +http_send_content_disposition +http_send_content_type +http_send_data +http_send_file +http_send_last_modified +http_send_status +http_send_stream +http_support +http_throttle +hwapi_attribute +hwapi_attribute_key +hwapi_attribute_langdepvalue +hwapi_attribute_value +hwapi_attribute_values +hwapi_checkin +hwapi_checkout +hwapi_children +hwapi_content +hwapi_content_mimetype +hwapi_content_read +hwapi_copy +hwapi_dbstat +hwapi_dcstat +hwapi_dstanchors +hwapi_dstofsrcanchor +hwapi_error_count +hwapi_error_reason +hwapi_find +hwapi_ftstat +hwapi_hgcsp +hwapi_hwstat +hwapi_identify +hwapi_info +hwapi_insert +hwapi_insertanchor +hwapi_insertcollection +hwapi_insertdocument +hwapi_link +hwapi_lock +hwapi_move +hwapi_new_content +hwapi_object +hwapi_object_assign +hwapi_object_attreditable +hwapi_objectbyanchor +hwapi_object_count +hwapi_object_insert +hwapi_object_new +hwapi_object_remove +hwapi_object_title +hwapi_object_value +hwapi_parents +hwapi_reason_description +hwapi_reason_type +hwapi_remove +hwapi_replace +hwapi_setcommittedversion +hwapi_srcanchors +hwapi_srcsofdst +hwapi_unlock +hwapi_user +hwapi_userlist +hw_array2objrec +hw_changeobject +hw_children +hw_childrenobj +hw_close +hw_connect +hw_connection_info +hw_cp +hw_deleteobject +hw_docbyanchor +hw_docbyanchorobj +hw_document_attributes +hw_document_bodytag +hw_document_content +hw_document_setcontent +hw_document_size +hw_dummy +hw_edittext +hw_error +hw_errormsg +hw_free_document +hw_getanchors +hw_getanchorsobj +hw_getandlock +hw_getchildcoll +hw_getchildcollobj +hw_getchilddoccoll +hw_getchilddoccollobj +hw_getobject +hw_getobjectbyquery +hw_getobjectbyquerycoll +hw_getobjectbyquerycollobj +hw_getobjectbyqueryobj +hw_getparents +hw_getparentsobj +hw_getrellink +hw_getremote +hw_getremotechildren +hw_getsrcbydestobj +hw_gettext +hw_getusername +hw_identify +hw_incollections +hw_info +hw_inscoll +hw_insdoc +hw_insertanchors +hw_insertdocument +hw_insertobject +hw_mapid +hw_modifyobject +hw_mv +hw_new_document +hw_objrec2array +hw_output_document +hw_pconnect +hw_pipedocument +hw_root +hw_setlinkroot +hw_stat +hw_unlock +hw_who +hypot +ibase_add_user +ibase_affected_rows +ibase_backup +ibase_blob_add +ibase_blob_cancel +ibase_blob_close +ibase_blob_create +ibase_blob_echo +ibase_blob_get +ibase_blob_import +ibase_blob_info +ibase_blob_open +ibase_close +ibase_commit +ibase_commit_ret +ibase_connect +ibase_db_info +ibase_delete_user +ibase_drop_db +ibase_errcode +ibase_errmsg +ibase_execute +ibase_fetch_assoc +ibase_fetch_object +ibase_fetch_row +ibase_field_info +ibase_free_event_handler +ibase_free_query +ibase_free_result +ibase_gen_id +ibase_maintain_db +ibase_modify_user +ibase_name_result +ibase_num_fields +ibase_num_params +ibase_param_info +ibase_pconnect +ibase_prepare +ibase_query +ibase_restore +ibase_rollback +ibase_rollback_ret +ibase_server_info +ibase_service_attach +ibase_service_detach +ibase_set_event_handler +ibase_timefmt +ibase_trans +ibase_wait_event +iconv +iconv_get_encoding +iconv_mime_decode +iconv_mime_decode_headers +iconv_mime_encode +iconv_set_encoding +iconv_strlen +iconv_strpos +iconv_strrpos +iconv_substr +id3_get_frame_long_name +id3_get_frame_short_name +id3_get_genre_id +id3_get_genre_list +id3_get_genre_name +id3_get_tag +id3_get_version +id3_remove_tag +id3_set_tag +idate +idn_to_ascii +idn_to_unicode +idn_to_utf8 +if +ifx_affected_rows +ifx_blobinfile_mode +ifx_byteasvarchar +ifx_close +ifx_connect +ifx_copy_blob +ifx_create_blob +ifx_create_char +ifx_do +ifx_error +ifx_errormsg +ifx_fetch_row +ifx_fieldproperties +ifx_fieldtypes +ifx_free_blob +ifx_free_char +ifx_free_result +ifx_get_blob +ifx_get_char +ifx_getsqlca +ifx_htmltbl_result +ifx_nullformat +ifx_num_fields +ifx_num_rows +ifx_pconnect +ifx_prepare +ifx_query +ifx_textasvarchar +ifx_update_blob +ifx_update_char +ifxus_close_slob +ifxus_create_slob +ifxus_free_slob +ifxus_open_slob +ifxus_read_slob +ifxus_seek_slob +ifxus_tell_slob +ifxus_write_slob +ignore_user_abort +iis_add_server +iis_get_dir_security +iis_get_script_map +iis_get_server_by_comment +iis_get_server_by_path +iis_get_server_rights +iis_get_service_state +iis_remove_server +iis_set_app_settings +iis_set_dir_security +iis_set_script_map +iis_set_server_rights +iis_start_server +iis_start_service +iis_stop_server +iis_stop_service +image2wbmp +imagealphablending +imageantialias +imagearc +imagechar +imagecharup +imagecolorallocate +imagecolorallocatealpha +imagecolorat +imagecolorclosest +imagecolorclosestalpha +imagecolorclosesthwb +imagecolordeallocate +imagecolorexact +imagecolorexactalpha +imagecolormatch +imagecolorresolve +imagecolorresolvealpha +imagecolorset +imagecolorsforindex +imagecolorstotal +imagecolortransparent +imageconvolution +imagecopy +imagecopymerge +imagecopymergegray +imagecopyresampled +imagecopyresized +imagecreate +imagecreatefromgd +imagecreatefromgd2 +imagecreatefromgd2part +imagecreatefromgif +imagecreatefromjpeg +imagecreatefrompng +imagecreatefromstring +imagecreatefromwbmp +imagecreatefromxbm +imagecreatefromxpm +imagecreatetruecolor +imagedashedline +imagedestroy +imageellipse +imagefill +imagefilledarc +imagefilledellipse +imagefilledpolygon +imagefilledrectangle +imagefilltoborder +imagefilter +imagefontheight +imagefontwidth +imageftbbox +imagefttext +imagegammacorrect +imagegd +imagegd2 +imagegif +imagegrabscreen +imagegrabwindow +imageinterlace +imageistruecolor +imagejpeg +imagelayereffect +imageline +imageloadfont +imagepalettecopy +imagepng +imagepolygon +imagepsbbox +imagepsencodefont +imagepsextendfont +imagepsfreefont +imagepsloadfont +imagepsslantfont +imagepstext +imagerectangle +imagerotate +imagesavealpha +imagesetbrush +imagesetpixel +imagesetstyle +imagesetthickness +imagesettile +imagestring +imagestringup +imagesx +imagesy +imagetruecolortopalette +imagettfbbox +imagettftext +imagetypes +image_type_to_extension +image_type_to_mime_type +imagewbmp +imagexbm +imagick +imagick_adaptiveblurimage +imagick_adaptiveresizeimage +imagick_adaptivesharpenimage +imagick_adaptivethresholdimage +imagick_addimage +imagick_addnoiseimage +imagick_affinetransformimage +imagick_animateimages +imagick_annotateimage +imagick_appendimages +imagick_averageimages +imagick_blackthresholdimage +imagick_blurimage +imagick_borderimage +imagick_charcoalimage +imagick_chopimage +imagick_clear +imagick_clipimage +imagick_clippathimage +imagick_clone +imagick_clutimage +imagick_coalesceimages +imagick_colorfloodfillimage +imagick_colorizeimage +imagick_combineimages +imagick_commentimage +imagick_compareimagechannels +imagick_compareimagelayers +imagick_compareimages +imagick_compositeimage +imagick_construct +imagick_contrastimage +imagick_contraststretchimage +imagick_convolveimage +imagick_cropimage +imagick_cropthumbnailimage +imagick_current +imagick_cyclecolormapimage +imagick_decipherimage +imagick_deconstructimages +imagick_deleteimageartifact +imagick_despeckleimage +imagick_destroy +imagick_displayimage +imagick_displayimages +imagick_distortimage +imagickdraw +imagickdraw_affine +imagickdraw_annotation +imagickdraw_arc +imagickdraw_bezier +imagickdraw_circle +imagickdraw_clear +imagickdraw_clone +imagickdraw_color +imagickdraw_comment +imagickdraw_composite +imagickdraw_construct +imagickdraw_destroy +imagickdraw_ellipse +imagickdraw_getclippath +imagickdraw_getcliprule +imagickdraw_getclipunits +imagickdraw_getfillcolor +imagickdraw_getfillopacity +imagickdraw_getfillrule +imagickdraw_getfont +imagickdraw_getfontfamily +imagickdraw_getfontsize +imagickdraw_getfontstyle +imagickdraw_getfontweight +imagickdraw_getgravity +imagickdraw_getstrokeantialias +imagickdraw_getstrokecolor +imagickdraw_getstrokedasharray +imagickdraw_getstrokedashoffset +imagickdraw_getstrokelinecap +imagickdraw_getstrokelinejoin +imagickdraw_getstrokemiterlimit +imagickdraw_getstrokeopacity +imagickdraw_getstrokewidth +imagickdraw_gettextalignment +imagickdraw_gettextantialias +imagickdraw_gettextdecoration +imagickdraw_gettextencoding +imagickdraw_gettextundercolor +imagickdraw_getvectorgraphics +imagick_drawimage +imagickdraw_line +imagickdraw_matte +imagickdraw_pathclose +imagickdraw_pathcurvetoabsolute +imagickdraw_pathcurvetoquadraticbezierabsolute +imagickdraw_pathcurvetoquadraticbezierrelative +imagickdraw_pathcurvetoquadraticbeziersmoothabsolute +imagickdraw_pathcurvetoquadraticbeziersmoothrelative +imagickdraw_pathcurvetorelative +imagickdraw_pathcurvetosmoothabsolute +imagickdraw_pathcurvetosmoothrelative +imagickdraw_pathellipticarcabsolute +imagickdraw_pathellipticarcrelative +imagickdraw_pathfinish +imagickdraw_pathlinetoabsolute +imagickdraw_pathlinetohorizontalabsolute +imagickdraw_pathlinetohorizontalrelative +imagickdraw_pathlinetorelative +imagickdraw_pathlinetoverticalabsolute +imagickdraw_pathlinetoverticalrelative +imagickdraw_pathmovetoabsolute +imagickdraw_pathmovetorelative +imagickdraw_pathstart +imagickdraw_point +imagickdraw_polygon +imagickdraw_polyline +imagickdraw_pop +imagickdraw_popclippath +imagickdraw_popdefs +imagickdraw_poppattern +imagickdraw_push +imagickdraw_pushclippath +imagickdraw_pushdefs +imagickdraw_pushpattern +imagickdraw_rectangle +imagickdraw_render +imagickdraw_rotate +imagickdraw_roundrectangle +imagickdraw_scale +imagickdraw_setclippath +imagickdraw_setcliprule +imagickdraw_setclipunits +imagickdraw_setfillalpha +imagickdraw_setfillcolor +imagickdraw_setfillopacity +imagickdraw_setfillpatternurl +imagickdraw_setfillrule +imagickdraw_setfont +imagickdraw_setfontfamily +imagickdraw_setfontsize +imagickdraw_setfontstretch +imagickdraw_setfontstyle +imagickdraw_setfontweight +imagickdraw_setgravity +imagickdraw_setstrokealpha +imagickdraw_setstrokeantialias +imagickdraw_setstrokecolor +imagickdraw_setstrokedasharray +imagickdraw_setstrokedashoffset +imagickdraw_setstrokelinecap +imagickdraw_setstrokelinejoin +imagickdraw_setstrokemiterlimit +imagickdraw_setstrokeopacity +imagickdraw_setstrokepatternurl +imagickdraw_setstrokewidth +imagickdraw_settextalignment +imagickdraw_settextantialias +imagickdraw_settextdecoration +imagickdraw_settextencoding +imagickdraw_settextundercolor +imagickdraw_setvectorgraphics +imagickdraw_setviewbox +imagickdraw_skewx +imagickdraw_skewy +imagickdraw_translate +imagick_edgeimage +imagick_embossimage +imagick_encipherimage +imagick_enhanceimage +imagick_equalizeimage +imagick_evaluateimage +imagick_extentimage +imagick_flattenimages +imagick_flipimage +imagick_floodfillpaintimage +imagick_flopimage +imagick_frameimage +imagick_fximage +imagick_gammaimage +imagick_gaussianblurimage +imagick_getcolorspace +imagick_getcompression +imagick_getcompressionquality +imagick_getcopyright +imagick_getfilename +imagick_getfont +imagick_getformat +imagick_getgravity +imagick_gethomeurl +imagick_getimage +imagick_getimagealphachannel +imagick_getimageartifact +imagick_getimagebackgroundcolor +imagick_getimageblob +imagick_getimageblueprimary +imagick_getimagebordercolor +imagick_getimagechanneldepth +imagick_getimagechanneldistortion +imagick_getimagechanneldistortions +imagick_getimagechannelextrema +imagick_getimagechannelmean +imagick_getimagechannelrange +imagick_getimagechannelstatistics +imagick_getimageclipmask +imagick_getimagecolormapcolor +imagick_getimagecolors +imagick_getimagecolorspace +imagick_getimagecompose +imagick_getimagecompression +imagick_getimagecompressionquality +imagick_getimagedelay +imagick_getimagedepth +imagick_getimagedispose +imagick_getimagedistortion +imagick_getimageextrema +imagick_getimagefilename +imagick_getimageformat +imagick_getimagegamma +imagick_getimagegeometry +imagick_getimagegravity +imagick_getimagegreenprimary +imagick_getimageheight +imagick_getimagehistogram +imagick_getimageindex +imagick_getimageinterlacescheme +imagick_getimageinterpolatemethod +imagick_getimageiterations +imagick_getimagelength +imagick_getimagemagicklicense +imagick_getimagematte +imagick_getimagemattecolor +imagick_getimageorientation +imagick_getimagepage +imagick_getimagepixelcolor +imagick_getimageprofile +imagick_getimageprofiles +imagick_getimageproperties +imagick_getimageproperty +imagick_getimageredprimary +imagick_getimageregion +imagick_getimagerenderingintent +imagick_getimageresolution +imagick_getimagesblob +imagick_getimagescene +imagick_getimagesignature +imagick_getimagesize +imagick_getimagetickspersecond +imagick_getimagetotalinkdensity +imagick_getimagetype +imagick_getimageunits +imagick_getimagevirtualpixelmethod +imagick_getimagewhitepoint +imagick_getimagewidth +imagick_getinterlacescheme +imagick_getiteratorindex +imagick_getnumberimages +imagick_getoption +imagick_getpackagename +imagick_getpage +imagick_getpixeliterator +imagick_getpixelregioniterator +imagick_getpointsize +imagick_getquantumdepth +imagick_getquantumrange +imagick_getreleasedate +imagick_getresource +imagick_getresourcelimit +imagick_getsamplingfactors +imagick_getsize +imagick_getsizeoffset +imagick_getversion +imagick_hasnextimage +imagick_haspreviousimage +imagick_identifyimage +imagick_implodeimage +imagick_labelimage +imagick_levelimage +imagick_linearstretchimage +imagick_liquidrescaleimage +imagick_magnifyimage +imagick_mapimage +imagick_mattefloodfillimage +imagick_medianfilterimage +imagick_mergeimagelayers +imagick_minifyimage +imagick_modulateimage +imagick_montageimage +imagick_morphimages +imagick_mosaicimages +imagick_motionblurimage +imagick_negateimage +imagick_newimage +imagick_newpseudoimage +imagick_nextimage +imagick_normalizeimage +imagick_oilpaintimage +imagick_opaquepaintimage +imagick_optimizeimagelayers +imagick_orderedposterizeimage +imagick_paintfloodfillimage +imagick_paintopaqueimage +imagick_painttransparentimage +imagick_pingimage +imagick_pingimageblob +imagick_pingimagefile +imagickpixel +imagickpixel_clear +imagickpixel_construct +imagickpixel_destroy +imagickpixel_getcolor +imagickpixel_getcolorasstring +imagickpixel_getcolorcount +imagickpixel_getcolorvalue +imagickpixel_gethsl +imagickpixel_issimilar +imagickpixeliterator +imagickpixeliterator_clear +imagickpixeliterator_construct +imagickpixeliterator_destroy +imagickpixeliterator_getcurrentiteratorrow +imagickpixeliterator_getiteratorrow +imagickpixeliterator_getnextiteratorrow +imagickpixeliterator_getpreviousiteratorrow +imagickpixeliterator_newpixeliterator +imagickpixeliterator_newpixelregioniterator +imagickpixeliterator_resetiterator +imagickpixeliterator_setiteratorfirstrow +imagickpixeliterator_setiteratorlastrow +imagickpixeliterator_setiteratorrow +imagickpixeliterator_synciterator +imagickpixel_setcolor +imagickpixel_setcolorvalue +imagickpixel_sethsl +imagick_polaroidimage +imagick_posterizeimage +imagick_previewimages +imagick_previousimage +imagick_profileimage +imagick_quantizeimage +imagick_quantizeimages +imagick_queryfontmetrics +imagick_queryfonts +imagick_queryformats +imagick_radialblurimage +imagick_raiseimage +imagick_randomthresholdimage +imagick_readimage +imagick_readimageblob +imagick_readimagefile +imagick_recolorimage +imagick_reducenoiseimage +imagick_removeimage +imagick_removeimageprofile +imagick_render +imagick_resampleimage +imagick_resetimagepage +imagick_resizeimage +imagick_rollimage +imagick_rotateimage +imagick_roundcorners +imagick_sampleimage +imagick_scaleimage +imagick_separateimagechannel +imagick_sepiatoneimage +imagick_setbackgroundcolor +imagick_setcolorspace +imagick_setcompression +imagick_setcompressionquality +imagick_setfilename +imagick_setfirstiterator +imagick_setfont +imagick_setformat +imagick_setgravity +imagick_setimage +imagick_setimagealphachannel +imagick_setimageartifact +imagick_setimagebackgroundcolor +imagick_setimagebias +imagick_setimageblueprimary +imagick_setimagebordercolor +imagick_setimagechanneldepth +imagick_setimageclipmask +imagick_setimagecolormapcolor +imagick_setimagecolorspace +imagick_setimagecompose +imagick_setimagecompression +imagick_setimagecompressionquality +imagick_setimagedelay +imagick_setimagedepth +imagick_setimagedispose +imagick_setimageextent +imagick_setimagefilename +imagick_setimageformat +imagick_setimagegamma +imagick_setimagegravity +imagick_setimagegreenprimary +imagick_setimageindex +imagick_setimageinterlacescheme +imagick_setimageinterpolatemethod +imagick_setimageiterations +imagick_setimagematte +imagick_setimagemattecolor +imagick_setimageopacity +imagick_setimageorientation +imagick_setimagepage +imagick_setimageprofile +imagick_setimageproperty +imagick_setimageredprimary +imagick_setimagerenderingintent +imagick_setimageresolution +imagick_setimagescene +imagick_setimagetickspersecond +imagick_setimagetype +imagick_setimageunits +imagick_setimagevirtualpixelmethod +imagick_setimagewhitepoint +imagick_setinterlacescheme +imagick_setiteratorindex +imagick_setlastiterator +imagick_setoption +imagick_setpage +imagick_setpointsize +imagick_setresolution +imagick_setresourcelimit +imagick_setsamplingfactors +imagick_setsize +imagick_setsizeoffset +imagick_settype +imagick_shadeimage +imagick_shadowimage +imagick_sharpenimage +imagick_shaveimage +imagick_shearimage +imagick_sigmoidalcontrastimage +imagick_sketchimage +imagick_solarizeimage +imagick_spliceimage +imagick_spreadimage +imagick_steganoimage +imagick_stereoimage +imagick_stripimage +imagick_swirlimage +imagick_textureimage +imagick_thresholdimage +imagick_thumbnailimage +imagick_tintimage +imagick_transformimage +imagick_transparentpaintimage +imagick_transposeimage +imagick_transverseimage +imagick_trimimage +imagick_uniqueimagecolors +imagick_unsharpmaskimage +imagick_valid +imagick_vignetteimage +imagick_waveimage +imagick_whitethresholdimage +imagick_writeimage +imagick_writeimagefile +imagick_writeimages +imagick_writeimagesfile +imap_8bit +imap_alerts +imap_append +imap_base64 +imap_binary +imap_body +imap_bodystruct +imap_check +imap_clearflag_full +imap_close +imap_create +imap_createmailbox +imap_delete +imap_deletemailbox +imap_errors +imap_expunge +imap_fetchbody +imap_fetchheader +imap_fetchmime +imap_fetch_overview +imap_fetchstructure +imap_fetchtext +imap_gc +imap_getacl +imap_getmailboxes +imap_get_quota +imap_get_quotaroot +imap_getsubscribed +imap_header +imap_headerinfo +imap_headers +imap_last_error +imap_list +imap_listmailbox +imap_listscan +imap_listsubscribed +imap_lsub +imap_mail +imap_mailboxmsginfo +imap_mail_compose +imap_mail_copy +imap_mail_move +imap_mime_header_decode +imap_msgno +imap_num_msg +imap_num_recent +imap_open +imap_ping +imap_qprint +imap_rename +imap_renamemailbox +imap_reopen +imap_rfc822_parse_adrlist +imap_rfc822_parse_headers +imap_rfc822_write_address +imap_savebody +imap_scan +imap_scanmailbox +imap_search +imap_setacl +imap_setflag_full +imap_set_quota +imap_sort +imap_status +imap_subscribe +imap_thread +imap_timeout +imap_uid +imap_undelete +imap_unsubscribe +imap_utf7_decode +imap_utf7_encode +imap_utf8 +implements +implementsinterface +implode +import_request_variables +in_array +include +include_once +inclued_get_data +inet_ntop +inet_pton +infiniteiterator +ingres_autocommit +ingres_autocommit_state +ingres_charset +ingres_close +ingres_commit +ingres_connect +ingres_cursor +ingres_errno +ingres_error +ingres_errsqlstate +ingres_escape_string +ingres_execute +ingres_fetch_array +ingres_fetch_assoc +ingres_fetch_object +ingres_fetch_proc_return +ingres_fetch_row +ingres_field_length +ingres_field_name +ingres_field_nullable +ingres_field_precision +ingres_field_scale +ingres_field_type +ingres_free_result +ingres_next_error +ingres_num_fields +ingres_num_rows +ingres_pconnect +ingres_prepare +ingres_query +ingres_result_seek +ingres_rollback +ingres_set_environment +ingres_unbuffered_query +ini_alter +ini_get +ini_get_all +ini_restore +ini_set +innamespace +inotify_add_watch +inotify_init +inotify_queue_len +inotify_read +inotify_rm_watch +instanceof +interface +interface_exists +intldateformatter +intl_error_name +intl_get_error_code +intl_get_error_message +intl_is_failure +intval +invalidargumentexception +invoke +__invoke() +invokeargs +ip2long +iptcembed +iptcparse +is_a +isabstract +is_array +is_bool +is_callable +iscloneable +is_dir +isdisabled +is_double +is_executable +is_file +isfinal +is_finite +is_float +is_infinite +isinstance +isinstantiable +is_int +is_integer +isinterface +isinternal +isiterateable +is_link +is_long +is_nan +is_null +is_numeric +is_object +is_readable +is_real +is_resource +is_scalar +isset +__isset() +is_soap_fault +is_string +issubclassof +is_subclass_of +istrait +is_uploaded_file +isuserdefined +is_writable +is_writeable +iterator +iteratoraggregate +iterator_apply +iterator_count +iteratoriterator +iterator_to_array +java_last_exception_clear +java_last_exception_get +jddayofweek +jdmonthname +jdtofrench +jdtogregorian +jdtojewish +jdtojulian +jdtounix +jewishtojd +join +jpeg2wbmp +json_decode +json_encode +json_last_error +jsonserializable +judy +judy_type +judy_version +juliantojd +kadm5_chpass_principal +kadm5_create_principal +kadm5_delete_principal +kadm5_destroy +kadm5_flush +kadm5_get_policies +kadm5_get_principal +kadm5_get_principals +kadm5_init_with_password +kadm5_modify_principal +key +krsort +ksort +ktaglib_id3v2_attachedpictureframe +ktaglib_id3v2_frame +ktaglib_id3v2_tag +ktaglib_mpeg_audioproperties +ktaglib_mpeg_file +ktaglib_tag +lcfirst +lcg_value +lchgrp +lchown +ldap_8859_to_t61 +ldap_add +ldap_bind +ldap_close +ldap_compare +ldap_connect +ldap_count_entries +ldap_delete +ldap_dn2ufn +ldap_err2str +ldap_errno +ldap_error +ldap_explode_dn +ldap_first_attribute +ldap_first_entry +ldap_first_reference +ldap_free_result +ldap_get_attributes +ldap_get_dn +ldap_get_entries +ldap_get_option +ldap_get_values +ldap_get_values_len +ldap_list +ldap_mod_add +ldap_mod_del +ldap_modify +ldap_mod_replace +ldap_next_attribute +ldap_next_entry +ldap_next_reference +ldap_parse_reference +ldap_parse_result +ldap_read +ldap_rename +ldap_sasl_bind +ldap_search +ldap_set_option +ldap_set_rebind_proc +ldap_sort +ldap_start_tls +ldap_t61_to_8859 +ldap_unbind +lengthexception +levenshtein +libxml_clear_errors +libxml_disable_entity_loader +libxmlerror +libxml_get_errors +libxml_get_last_error +libxml_set_streams_context +libxml_use_internal_errors +limititerator +__LINE__ +link +linkinfo +list +locale +localeconv +localtime +log +log10 +log1p +logicexception +long2ip +lstat +ltrim +lua +luaclosure +lzf_compress +lzf_decompress +lzf_optimized_for +magic_quotes_runtime +mail +mailparse_determine_best_xfer_encoding +mailparse_msg_create +mailparse_msg_extract_part +mailparse_msg_extract_part_file +mailparse_msg_extract_whole_part_file +mailparse_msg_free +mailparse_msg_get_part +mailparse_msg_get_part_data +mailparse_msg_get_structure +mailparse_msg_parse +mailparse_msg_parse_file +mailparse_rfc822_parse_addresses +mailparse_stream_encode +mailparse_uudecode_all +main +max +maxdb_affected_rows +maxdb_autocommit +maxdb_bind_param +maxdb_bind_result +maxdb_change_user +maxdb_character_set_name +maxdb_client_encoding +maxdb_close +maxdb_close_long_data +maxdb_commit +maxdb_connect +maxdb_connect_errno +maxdb_connect_error +maxdb_data_seek +maxdb_debug +maxdb_disable_reads_from_master +maxdb_disable_rpl_parse +maxdb_dump_debug_info +maxdb_embedded_connect +maxdb_enable_reads_from_master +maxdb_enable_rpl_parse +maxdb_errno +maxdb_error +maxdb_escape_string +maxdb_execute +maxdb_fetch +maxdb_fetch_array +maxdb_fetch_assoc +maxdb_fetch_field +maxdb_fetch_field_direct +maxdb_fetch_fields +maxdb_fetch_lengths +maxdb_fetch_object +maxdb_fetch_row +maxdb_field_count +maxdb_field_seek +maxdb_field_tell +maxdb_free_result +maxdb_get_client_info +maxdb_get_client_version +maxdb_get_host_info +maxdb_get_metadata +maxdb_get_proto_info +maxdb_get_server_info +maxdb_get_server_version +maxdb_info +maxdb_init +maxdb_insert_id +maxdb_kill +maxdb_master_query +maxdb_more_results +maxdb_multi_query +maxdb_next_result +maxdb_num_fields +maxdb_num_rows +maxdb_options +maxdb_param_count +maxdb_ping +maxdb_prepare +maxdb_query +maxdb_real_connect +maxdb_real_escape_string +maxdb_real_query +maxdb_report +maxdb_rollback +maxdb_rpl_parse_enabled +maxdb_rpl_probe +maxdb_rpl_query_type +maxdb_select_db +maxdb_send_long_data +maxdb_send_query +maxdb_server_end +maxdb_server_init +maxdb_set_opt +maxdb_sqlstate +maxdb_ssl_set +maxdb_stat +maxdb_stmt_affected_rows +maxdb_stmt_bind_param +maxdb_stmt_bind_result +maxdb_stmt_close +maxdb_stmt_close_long_data +maxdb_stmt_data_seek +maxdb_stmt_errno +maxdb_stmt_error +maxdb_stmt_execute +maxdb_stmt_fetch +maxdb_stmt_free_result +maxdb_stmt_init +maxdb_stmt_num_rows +maxdb_stmt_param_count +maxdb_stmt_prepare +maxdb_stmt_reset +maxdb_stmt_result_metadata +maxdb_stmt_send_long_data +maxdb_stmt_sqlstate +maxdb_stmt_store_result +maxdb_store_result +maxdb_thread_id +maxdb_thread_safe +maxdb_use_result +maxdb_warning_count +mb_check_encoding +mb_convert_case +mb_convert_encoding +mb_convert_kana +mb_convert_variables +mb_decode_mimeheader +mb_decode_numericentity +mb_detect_encoding +mb_detect_order +mb_encode_mimeheader +mb_encode_numericentity +mb_encoding_aliases +mb_ereg +mb_eregi +mb_eregi_replace +mb_ereg_match +mb_ereg_replace +mb_ereg_search +mb_ereg_search_getpos +mb_ereg_search_getregs +mb_ereg_search_init +mb_ereg_search_pos +mb_ereg_search_regs +mb_ereg_search_setpos +mb_get_info +mb_http_input +mb_http_output +mb_internal_encoding +mb_language +mb_list_encodings +mb_output_handler +mb_parse_str +mb_preferred_mime_name +mb_regex_encoding +mb_regex_set_options +mb_send_mail +mb_split +mb_strcut +mb_strimwidth +mb_stripos +mb_stristr +mb_strlen +mb_strpos +mb_strrchr +mb_strrichr +mb_strripos +mb_strrpos +mb_strstr +mb_strtolower +mb_strtoupper +mb_strwidth +mb_substitute_character +mb_substr +mb_substr_count +m_checkstatus +m_completeauthorizations +m_connect +m_connectionerror +mcrypt_cbc +mcrypt_cfb +mcrypt_create_iv +mcrypt_decrypt +mcrypt_ecb +mcrypt_enc_get_algorithms_name +mcrypt_enc_get_block_size +mcrypt_enc_get_iv_size +mcrypt_enc_get_key_size +mcrypt_enc_get_modes_name +mcrypt_enc_get_supported_key_sizes +mcrypt_enc_is_block_algorithm +mcrypt_enc_is_block_algorithm_mode +mcrypt_enc_is_block_mode +mcrypt_encrypt +mcrypt_enc_self_test +mcrypt_generic +mcrypt_generic_deinit +mcrypt_generic_end +mcrypt_generic_init +mcrypt_get_block_size +mcrypt_get_cipher_name +mcrypt_get_iv_size +mcrypt_get_key_size +mcrypt_list_algorithms +mcrypt_list_modes +mcrypt_module_close +mcrypt_module_get_algo_block_size +mcrypt_module_get_algo_key_size +mcrypt_module_get_supported_key_sizes +mcrypt_module_is_block_algorithm +mcrypt_module_is_block_algorithm_mode +mcrypt_module_is_block_mode +mcrypt_module_open +mcrypt_module_self_test +mcrypt_ofb +md5 +md5_file +mdecrypt_generic +m_deletetrans +m_destroyconn +m_destroyengine +memcache +memcached +memcache_debug +memory_get_peak_usage +memory_get_usage +messageformatter +metaphone +__METHOD__ +method_exists +m_getcell +m_getcellbynum +m_getcommadelimited +m_getheader +mhash +mhash_count +mhash_get_block_size +mhash_get_hash_name +mhash_keygen_s2k +microtime +mime_content_type +min +ming_keypress +ming_setcubicthreshold +ming_setscale +ming_setswfcompression +ming_useconstants +ming_useswfversion +m_initconn +m_initengine +m_iscommadelimited +mkdir +mktime +m_maxconntimeout +m_monitor +m_numcolumns +m_numrows +money_format +mongo +mongobindata +mongocode +mongocollection +mongoconnectionexception +mongocursor +mongocursorexception +mongocursortimeoutexception +mongodate +mongodb +mongodbref +mongoexception +mongogridfs +mongogridfscursor +mongogridfsexception +mongogridfsfile +mongoid +mongoint32 +mongoint64 +mongolog +mongomaxkey +mongominkey +mongopool +mongoregex +mongotimestamp +move_uploaded_file +m_parsecommadelimited +mqseries_back +mqseries_begin +mqseries_close +mqseries_cmit +mqseries_conn +mqseries_connx +mqseries_disc +mqseries_get +mqseries_inq +mqseries_open +mqseries_put +mqseries_put1 +mqseries_set +mqseries_strerror +m_responsekeys +m_responseparam +m_returnstatus +msession_connect +msession_count +msession_create +msession_destroy +msession_disconnect +msession_find +msession_get +msession_get_array +msession_get_data +msession_inc +msession_list +msession_listvar +msession_lock +msession_plugin +msession_randstr +msession_set +msession_set_array +msession_set_data +msession_timeout +msession_uniq +msession_unlock +m_setblocking +m_setdropfile +m_setip +m_setssl +m_setssl_cafile +m_setssl_files +m_settimeout +msg_get_queue +msg_queue_exists +msg_receive +msg_remove_queue +msg_send +msg_set_queue +msg_stat_queue +msql +msql_affected_rows +msql_close +msql_connect +msql_createdb +msql_create_db +msql_data_seek +msql_dbname +msql_db_query +msql_drop_db +msql_error +msql_fetch_array +msql_fetch_field +msql_fetch_object +msql_fetch_row +msql_fieldflags +msql_field_flags +msql_fieldlen +msql_field_len +msql_fieldname +msql_field_name +msql_field_seek +msql_fieldtable +msql_field_table +msql_fieldtype +msql_field_type +msql_free_result +msql_list_dbs +msql_list_fields +msql_list_tables +msql_numfields +msql_num_fields +msql_numrows +msql_num_rows +msql_pconnect +msql_query +msql_regcase +msql_result +msql_select_db +msql_tablename +m_sslcert_gen_hash +mssql_bind +mssql_close +mssql_connect +mssql_data_seek +mssql_execute +mssql_fetch_array +mssql_fetch_assoc +mssql_fetch_batch +mssql_fetch_field +mssql_fetch_object +mssql_fetch_row +mssql_field_length +mssql_field_name +mssql_field_seek +mssql_field_type +mssql_free_result +mssql_free_statement +mssql_get_last_message +mssql_guid_string +mssql_init +mssql_min_error_severity +mssql_min_message_severity +mssql_next_result +mssql_num_fields +mssql_num_rows +mssql_pconnect +mssql_query +mssql_result +mssql_rows_affected +mssql_select_db +mt_getrandmax +mt_rand +m_transactionssent +m_transinqueue +m_transkeyval +m_transnew +m_transsend +mt_srand +multipleiterator +m_uwait +m_validateidentifier +m_verifyconnection +m_verifysslcert +mysql_affected_rows +mysql_client_encoding +mysql_close +mysql_connect +mysql_create_db +mysql_data_seek +mysql_db_name +mysql_db_query +mysql_drop_db +mysql_errno +mysql_error +mysql_escape_string +mysql_fetch_array +mysql_fetch_assoc +mysql_fetch_field +mysql_fetch_lengths +mysql_fetch_object +mysql_fetch_row +mysql_field_flags +mysql_field_len +mysql_field_name +mysql_field_seek +mysql_field_table +mysql_field_type +mysql_free_result +mysql_get_client_info +mysql_get_host_info +mysql_get_proto_info +mysql_get_server_info +mysqli +mysqli_bind_param +mysqli_bind_result +mysqli_client_encoding +mysqli_connect +mysqli_disable_reads_from_master +mysqli_disable_rpl_parse +mysqli_driver +mysqli_enable_reads_from_master +mysqli_enable_rpl_parse +mysqli_escape_string +mysqli_execute +mysqli_fetch +mysqli_get_metadata +mysqli_master_query +mysql_info +mysql_insert_id +mysqli_param_count +mysqli_report +mysqli_result +mysqli_rpl_parse_enabled +mysqli_rpl_probe +mysqli_rpl_query_type +mysqli_send_long_data +mysqli_send_query +mysqli_set_opt +mysqli_slave_query +mysqli_stmt +mysqli_warning +mysql_list_dbs +mysql_list_fields +mysql_list_processes +mysql_list_tables +mysqlnd_ms_get_stats +mysqlnd_ms_query_is_select +mysqlnd_ms_set_user_pick_server +mysqlnd_qc_change_handler +mysqlnd_qc_clear_cache +mysqlnd_qc_get_cache_info +mysqlnd_qc_get_core_stats +mysqlnd_qc_get_handler +mysqlnd_qc_get_query_trace_log +mysqlnd_qc_set_user_handlers +mysql_num_fields +mysql_num_rows +mysql_pconnect +mysql_ping +mysql_query +mysql_real_escape_string +mysql_result +mysql_select_db +mysql_set_charset +mysql_stat +mysql_tablename +mysql_thread_id +mysql_unbuffered_query +namespace +__NAMESPACE__ +natcasesort +natsort +ncurses_addch +ncurses_addchnstr +ncurses_addchstr +ncurses_addnstr +ncurses_addstr +ncurses_assume_default_colors +ncurses_attroff +ncurses_attron +ncurses_attrset +ncurses_baudrate +ncurses_beep +ncurses_bkgd +ncurses_bkgdset +ncurses_border +ncurses_bottom_panel +ncurses_can_change_color +ncurses_cbreak +ncurses_clear +ncurses_clrtobot +ncurses_clrtoeol +ncurses_color_content +ncurses_color_set +ncurses_curs_set +ncurses_define_key +ncurses_def_prog_mode +ncurses_def_shell_mode +ncurses_delay_output +ncurses_delch +ncurses_deleteln +ncurses_del_panel +ncurses_delwin +ncurses_doupdate +ncurses_echo +ncurses_echochar +ncurses_end +ncurses_erase +ncurses_erasechar +ncurses_filter +ncurses_flash +ncurses_flushinp +ncurses_getch +ncurses_getmaxyx +ncurses_getmouse +ncurses_getyx +ncurses_halfdelay +ncurses_has_colors +ncurses_has_ic +ncurses_has_il +ncurses_has_key +ncurses_hide_panel +ncurses_hline +ncurses_inch +ncurses_init +ncurses_init_color +ncurses_init_pair +ncurses_insch +ncurses_insdelln +ncurses_insertln +ncurses_insstr +ncurses_instr +ncurses_isendwin +ncurses_keyok +ncurses_keypad +ncurses_killchar +ncurses_longname +ncurses_meta +ncurses_mouseinterval +ncurses_mousemask +ncurses_mouse_trafo +ncurses_move +ncurses_move_panel +ncurses_mvaddch +ncurses_mvaddchnstr +ncurses_mvaddchstr +ncurses_mvaddnstr +ncurses_mvaddstr +ncurses_mvcur +ncurses_mvdelch +ncurses_mvgetch +ncurses_mvhline +ncurses_mvinch +ncurses_mvvline +ncurses_mvwaddstr +ncurses_napms +ncurses_newpad +ncurses_new_panel +ncurses_newwin +ncurses_nl +ncurses_nocbreak +ncurses_noecho +ncurses_nonl +ncurses_noqiflush +ncurses_noraw +ncurses_pair_content +ncurses_panel_above +ncurses_panel_below +ncurses_panel_window +ncurses_pnoutrefresh +ncurses_prefresh +ncurses_putp +ncurses_qiflush +ncurses_raw +ncurses_refresh +ncurses_replace_panel +ncurses_reset_prog_mode +ncurses_reset_shell_mode +ncurses_resetty +ncurses_savetty +ncurses_scr_dump +ncurses_scr_init +ncurses_scrl +ncurses_scr_restore +ncurses_scr_set +ncurses_show_panel +ncurses_slk_attr +ncurses_slk_attroff +ncurses_slk_attron +ncurses_slk_attrset +ncurses_slk_clear +ncurses_slk_color +ncurses_slk_init +ncurses_slk_noutrefresh +ncurses_slk_refresh +ncurses_slk_restore +ncurses_slk_set +ncurses_slk_touch +ncurses_standend +ncurses_standout +ncurses_start_color +ncurses_termattrs +ncurses_termname +ncurses_timeout +ncurses_top_panel +ncurses_typeahead +ncurses_ungetch +ncurses_ungetmouse +ncurses_update_panels +ncurses_use_default_colors +ncurses_use_env +ncurses_use_extended_names +ncurses_vidattr +ncurses_vline +ncurses_waddch +ncurses_waddstr +ncurses_wattroff +ncurses_wattron +ncurses_wattrset +ncurses_wborder +ncurses_wclear +ncurses_wcolor_set +ncurses_werase +ncurses_wgetch +ncurses_whline +ncurses_wmouse_trafo +ncurses_wmove +ncurses_wnoutrefresh +ncurses_wrefresh +ncurses_wstandend +ncurses_wstandout +ncurses_wvline +new +newinstance +newinstanceargs +newinstancewithoutconstructor +newt_bell +newt_button +newt_button_bar +newt_centered_window +newt_checkbox +newt_checkbox_get_value +newt_checkbox_set_flags +newt_checkbox_set_value +newt_checkbox_tree +newt_checkbox_tree_add_item +newt_checkbox_tree_find_item +newt_checkbox_tree_get_current +newt_checkbox_tree_get_entry_value +newt_checkbox_tree_get_multi_selection +newt_checkbox_tree_get_selection +newt_checkbox_tree_multi +newt_checkbox_tree_set_current +newt_checkbox_tree_set_entry +newt_checkbox_tree_set_entry_value +newt_checkbox_tree_set_width +newt_clear_key_buffer +newt_cls +newt_compact_button +newt_component_add_callback +newt_component_takes_focus +newt_create_grid +newt_cursor_off +newt_cursor_on +newt_delay +newt_draw_form +newt_draw_root_text +newt_entry +newt_entry_get_value +newt_entry_set +newt_entry_set_filter +newt_entry_set_flags +newt_finished +newt_form +newt_form_add_component +newt_form_add_components +newt_form_add_hot_key +newt_form_destroy +newt_form_get_current +newt_form_run +newt_form_set_background +newt_form_set_height +newt_form_set_size +newt_form_set_timer +newt_form_set_width +newt_form_watch_fd +newt_get_screen_size +newt_grid_add_components_to_form +newt_grid_basic_window +newt_grid_free +newt_grid_get_size +newt_grid_h_close_stacked +newt_grid_h_stacked +newt_grid_place +newt_grid_set_field +newt_grid_simple_window +newt_grid_v_close_stacked +newt_grid_v_stacked +newt_grid_wrapped_window +newt_grid_wrapped_window_at +newt_init +newt_label +newt_label_set_text +newt_listbox +newt_listbox_append_entry +newt_listbox_clear +newt_listbox_clear_selection +newt_listbox_delete_entry +newt_listbox_get_current +newt_listbox_get_selection +newt_listbox_insert_entry +newt_listbox_item_count +newt_listbox_select_item +newt_listbox_set_current +newt_listbox_set_current_by_key +newt_listbox_set_data +newt_listbox_set_entry +newt_listbox_set_width +newt_listitem +newt_listitem_get_data +newt_listitem_set +newt_open_window +newt_pop_help_line +newt_pop_window +newt_push_help_line +newt_radiobutton +newt_radio_get_current +newt_redraw_help_line +newt_reflow_text +newt_refresh +newt_resize_screen +newt_resume +newt_run_form +newt_scale +newt_scale_set +newt_scrollbar_set +newt_set_help_callback +newt_set_suspend_callback +newt_suspend +newt_textbox +newt_textbox_get_num_lines +newt_textbox_reflowed +newt_textbox_set_height +newt_textbox_set_text +newt_vertical_scrollbar +newt_wait_for_key +newt_win_choice +newt_win_entries +newt_win_menu +newt_win_message +newt_win_messagev +newt_win_ternary +next +ngettext +nl2br +nl_langinfo +norewinditerator +normalizer +notes_body +notes_copy_db +notes_create_db +notes_create_note +notes_drop_db +notes_find_note +notes_header_info +notes_list_msgs +notes_mark_read +notes_mark_unread +notes_nav_create +notes_search +notes_unread +notes_version +nsapi_request_headers +nsapi_response_headers +nsapi_virtual +nthmac +number_format +numberformatter +oauth +oauthexception +oauth_get_sbs +oauthprovider +oauth_urlencode +ob_clean +ob_deflatehandler +ob_end_clean +ob_end_flush +ob_etaghandler +ob_flush +ob_get_clean +ob_get_contents +ob_get_flush +ob_get_length +ob_get_level +ob_get_status +ob_gzhandler +ob_iconv_handler +ob_implicit_flush +ob_inflatehandler +ob_list_handlers +ob_start +ob_tidyhandler +oci_bind_array_by_name +ocibindbyname +oci_bind_by_name +ocicancel +oci_cancel +oci_client_version +oci_close +ocicloselob +ocicollappend +ocicollassign +ocicollassignelem +oci_collection_append +oci_collection_assign +oci_collection_element_assign +oci_collection_element_get +oci_collection_free +oci_collection_max +oci_collection_size +oci_collection_trim +ocicollgetelem +ocicollmax +ocicollsize +ocicolltrim +ocicolumnisnull +ocicolumnname +ocicolumnprecision +ocicolumnscale +ocicolumnsize +ocicolumntype +ocicolumntyperaw +ocicommit +oci_commit +oci_connect +ocidefinebyname +oci_define_by_name +ocierror +oci_error +ociexecute +oci_execute +ocifetch +oci_fetch +oci_fetch_all +oci_fetch_array +oci_fetch_assoc +ocifetchinto +oci_fetch_object +oci_fetch_row +ocifetchstatement +oci_field_is_null +oci_field_name +oci_field_precision +oci_field_scale +oci_field_size +oci_field_type +oci_field_type_raw +ocifreecollection +ocifreecursor +ocifreedesc +ocifreestatement +oci_free_statement +ociinternaldebug +oci_internal_debug +ociloadlob +oci_lob_append +oci_lob_close +oci_lob_copy +oci_lob_eof +oci_lob_erase +oci_lob_export +oci_lob_flush +oci_lob_free +oci_lob_getbuffering +oci_lob_import +oci_lob_is_equal +oci_lob_load +oci_lob_read +oci_lob_rewind +oci_lob_save +oci_lob_savefile +oci_lob_seek +oci_lob_setbuffering +oci_lob_size +oci_lob_tell +oci_lob_truncate +oci_lob_write +oci_lob_writetemporary +oci_lob_writetofile +ocilogoff +ocilogon +ocinewcollection +oci_new_collection +oci_new_connect +ocinewcursor +oci_new_cursor +ocinewdescriptor +oci_new_descriptor +ocinlogon +ocinumcols +oci_num_fields +oci_num_rows +ociparse +oci_parse +oci_password_change +oci_pconnect +ociplogon +ociresult +oci_result +ocirollback +oci_rollback +ocirowcount +ocisavelob +ocisavelobfile +ociserverversion +oci_server_version +oci_set_action +oci_set_client_identifier +oci_set_client_info +oci_set_edition +oci_set_module_name +ocisetprefetch +oci_set_prefetch +ocistatementtype +oci_statement_type +ociwritelobtofile +ociwritetemporarylob +octdec +odbc_autocommit +odbc_binmode +odbc_close +odbc_close_all +odbc_columnprivileges +odbc_columns +odbc_commit +odbc_connect +odbc_cursor +odbc_data_source +odbc_do +odbc_error +odbc_errormsg +odbc_exec +odbc_execute +odbc_fetch_array +odbc_fetch_into +odbc_fetch_object +odbc_fetch_row +odbc_field_len +odbc_field_name +odbc_field_num +odbc_field_precision +odbc_field_scale +odbc_field_type +odbc_foreignkeys +odbc_free_result +odbc_gettypeinfo +odbc_longreadlen +odbc_next_result +odbc_num_fields +odbc_num_rows +odbc_pconnect +odbc_prepare +odbc_primarykeys +odbc_procedurecolumns +odbc_procedures +odbc_result +odbc_result_all +odbc_rollback +odbc_setoption +odbc_specialcolumns +odbc_statistics +odbc_tableprivileges +odbc_tables +old_function +openal_buffer_create +openal_buffer_data +openal_buffer_destroy +openal_buffer_get +openal_buffer_loadwav +openal_context_create +openal_context_current +openal_context_destroy +openal_context_process +openal_context_suspend +openal_device_close +openal_device_open +openal_listener_get +openal_listener_set +openal_source_create +openal_source_destroy +openal_source_get +openal_source_pause +openal_source_play +openal_source_rewind +openal_source_set +openal_source_stop +openal_stream +opendir +openlog +openssl_cipher_iv_length +openssl_csr_export +openssl_csr_export_to_file +openssl_csr_get_public_key +openssl_csr_get_subject +openssl_csr_new +openssl_csr_sign +openssl_decrypt +openssl_dh_compute_key +openssl_digest +openssl_encrypt +openssl_error_string +openssl_free_key +openssl_get_cipher_methods +openssl_get_md_methods +openssl_get_privatekey +openssl_get_publickey +openssl_open +openssl_pkcs12_export +openssl_pkcs12_export_to_file +openssl_pkcs12_read +openssl_pkcs7_decrypt +openssl_pkcs7_encrypt +openssl_pkcs7_sign +openssl_pkcs7_verify +openssl_pkey_export +openssl_pkey_export_to_file +openssl_pkey_free +openssl_pkey_get_details +openssl_pkey_get_private +openssl_pkey_get_public +openssl_pkey_new +openssl_private_decrypt +openssl_private_encrypt +openssl_public_decrypt +openssl_public_encrypt +openssl_random_pseudo_bytes +openssl_seal +openssl_sign +openssl_verify +openssl_x509_check_private_key +openssl_x509_checkpurpose +openssl_x509_export +openssl_x509_export_to_file +openssl_x509_free +openssl_x509_parse +openssl_x509_read +or +ord +outeriterator +outofboundsexception +outofrangeexception +output_add_rewrite_var +output_reset_rewrite_vars +overflowexception +overload +override_function +ovrimos_close +ovrimos_commit +ovrimos_connect +ovrimos_cursor +ovrimos_exec +ovrimos_execute +ovrimos_fetch_into +ovrimos_fetch_row +ovrimos_field_len +ovrimos_field_name +ovrimos_field_num +ovrimos_field_type +ovrimos_free_result +ovrimos_longreadlen +ovrimos_num_fields +ovrimos_num_rows +ovrimos_prepare +ovrimos_result +ovrimos_result_all +ovrimos_rollback +pack +parentiterator +parse_ini_file +parse_ini_string +parsekit_compile_file +parsekit_compile_string +parsekit_func_arginfo +parse_str +parse_url +passthru +pathinfo +pclose +pcntl_alarm +pcntl_exec +pcntl_fork +pcntl_getpriority +pcntl_setpriority +pcntl_signal +pcntl_signal_dispatch +pcntl_sigprocmask +pcntl_sigtimedwait +pcntl_sigwaitinfo +pcntl_wait +pcntl_waitpid +pcntl_wexitstatus +pcntl_wifexited +pcntl_wifsignaled +pcntl_wifstopped +pcntl_wstopsig +pcntl_wtermsig +pdf_activate_item +pdf_add_annotation +pdf_add_bookmark +pdf_add_launchlink +pdf_add_locallink +pdf_add_nameddest +pdf_add_note +pdf_add_outline +pdf_add_pdflink +pdf_add_table_cell +pdf_add_textflow +pdf_add_thumbnail +pdf_add_weblink +pdf_arc +pdf_arcn +pdf_attach_file +pdf_begin_document +pdf_begin_font +pdf_begin_glyph +pdf_begin_item +pdf_begin_layer +pdf_begin_page +pdf_begin_page_ext +pdf_begin_pattern +pdf_begin_template +pdf_begin_template_ext +pdf_circle +pdf_clip +pdf_close +pdf_close_image +pdf_closepath +pdf_closepath_fill_stroke +pdf_closepath_stroke +pdf_close_pdi +pdf_close_pdi_page +pdf_concat +pdf_continue_text +pdf_create_3dview +pdf_create_action +pdf_create_annotation +pdf_create_bookmark +pdf_create_field +pdf_create_fieldgroup +pdf_create_gstate +pdf_create_pvf +pdf_create_textflow +pdf_curveto +pdf_define_layer +pdf_delete +pdf_delete_pvf +pdf_delete_table +pdf_delete_textflow +pdf_encoding_set_char +pdf_end_document +pdf_end_font +pdf_end_glyph +pdf_end_item +pdf_end_layer +pdf_end_page +pdf_end_page_ext +pdf_endpath +pdf_end_pattern +pdf_end_template +pdf_fill +pdf_fill_imageblock +pdf_fill_pdfblock +pdf_fill_stroke +pdf_fill_textblock +pdf_findfont +pdf_fit_image +pdf_fit_pdi_page +pdf_fit_table +pdf_fit_textflow +pdf_fit_textline +pdf_get_apiname +pdf_get_buffer +pdf_get_errmsg +pdf_get_errnum +pdf_get_font +pdf_get_fontname +pdf_get_fontsize +pdf_get_image_height +pdf_get_image_width +pdf_get_majorversion +pdf_get_minorversion +pdf_get_parameter +pdf_get_pdi_parameter +pdf_get_pdi_value +pdf_get_value +pdf_info_font +pdf_info_matchbox +pdf_info_table +pdf_info_textflow +pdf_info_textline +pdf_initgraphics +pdf_lineto +pdf_load_3ddata +pdf_load_font +pdf_load_iccprofile +pdf_load_image +pdf_makespotcolor +pdf_moveto +pdf_new +pdf_open_ccitt +pdf_open_file +pdf_open_gif +pdf_open_image +pdf_open_image_file +pdf_open_jpeg +pdf_open_memory_image +pdf_open_pdi +pdf_open_pdi_document +pdf_open_pdi_page +pdf_open_tiff +pdf_pcos_get_number +pdf_pcos_get_stream +pdf_pcos_get_string +pdf_place_image +pdf_place_pdi_page +pdf_process_pdi +pdf_rect +pdf_restore +pdf_resume_page +pdf_rotate +pdf_save +pdf_scale +pdf_set_border_color +pdf_set_border_dash +pdf_set_border_style +pdf_set_char_spacing +pdf_setcolor +pdf_setdash +pdf_setdashpattern +pdf_set_duration +pdf_setflat +pdf_setfont +pdf_setgray +pdf_setgray_fill +pdf_setgray_stroke +pdf_set_gstate +pdf_set_horiz_scaling +pdf_set_info +pdf_set_info_author +pdf_set_info_creator +pdf_set_info_keywords +pdf_set_info_subject +pdf_set_info_title +pdf_set_layer_dependency +pdf_set_leading +pdf_setlinecap +pdf_setlinejoin +pdf_setlinewidth +pdf_setmatrix +pdf_setmiterlimit +pdf_set_parameter +pdf_setpolydash +pdf_setrgbcolor +pdf_setrgbcolor_fill +pdf_setrgbcolor_stroke +pdf_set_text_matrix +pdf_set_text_pos +pdf_set_text_rendering +pdf_set_text_rise +pdf_set_value +pdf_set_word_spacing +pdf_shading +pdf_shading_pattern +pdf_shfill +pdf_show +pdf_show_boxed +pdf_show_xy +pdf_skew +pdf_stringwidth +pdf_stroke +pdf_suspend_page +pdf_translate +pdf_utf16_to_utf8 +pdf_utf32_to_utf16 +pdf_utf8_to_utf16 +pdo +pdo_cubrid_schema +pdoexception +pdo_pgsqllobcreate +pdo_pgsqllobopen +pdo_pgsqllobunlink +pdo_sqlitecreateaggregate +pdo_sqlitecreatefunction +pdostatement +pfsockopen +pg_affected_rows +pg_cancel_query +pg_client_encoding +pg_close +pg_connect +pg_connection_busy +pg_connection_reset +pg_connection_status +pg_convert +pg_copy_from +pg_copy_to +pg_dbname +pg_delete +pg_end_copy +pg_escape_bytea +pg_escape_string +pg_execute +pg_fetch_all +pg_fetch_all_columns +pg_fetch_array +pg_fetch_assoc +pg_fetch_object +pg_fetch_result +pg_fetch_row +pg_field_is_null +pg_field_name +pg_field_num +pg_field_prtlen +pg_field_size +pg_field_table +pg_field_type +pg_field_type_oid +pg_free_result +pg_get_notify +pg_get_pid +pg_get_result +pg_host +pg_insert +pg_last_error +pg_last_notice +pg_last_oid +pg_lo_close +pg_lo_create +pg_lo_export +pg_lo_import +pg_lo_open +pg_lo_read +pg_lo_read_all +pg_lo_seek +pg_lo_tell +pg_lo_unlink +pg_lo_write +pg_meta_data +pg_num_fields +pg_num_rows +pg_options +pg_parameter_status +pg_pconnect +pg_ping +pg_port +pg_prepare +pg_put_line +pg_query +pg_query_params +pg_result_error +pg_result_error_field +pg_result_seek +pg_result_status +pg_select +pg_send_execute +pg_send_prepare +pg_send_query +pg_send_query_params +pg_set_client_encoding +pg_set_error_verbosity +pg_trace +pg_transaction_status +pg_tty +pg_unescape_bytea +pg_untrace +pg_update +pg_version +Phar +PharData +PharException +PharFileInfo +php_check_syntax +phpcredits +phpinfo +php_ini_loaded_file +php_ini_scanned_files +php_logo_guid +php_sapi_name +php_strip_whitespace +php_uname +phpversion +pi +png2wbmp +popen +pos +posix_access +posix_ctermid +posix_errno +posix_getcwd +posix_getegid +posix_geteuid +posix_getgid +posix_getgrgid +posix_getgrnam +posix_getgroups +posix_get_last_error +posix_getlogin +posix_getpgid +posix_getpgrp +posix_getpid +posix_getppid +posix_getpwnam +posix_getpwuid +posix_getrlimit +posix_getsid +posix_getuid +posix_initgroups +posix_isatty +posix_kill +posix_mkfifo +posix_mknod +posix_setegid +posix_seteuid +posix_setgid +posix_setpgid +posix_setsid +posix_setuid +posix_strerror +posix_times +posix_ttyname +posix_uname +pow +preg_filter +preg_grep +preg_last_error +preg_match +preg_match_all +preg_quote +preg_replace +preg_replace_callback +preg_split +prev +print +printer_abort +printer_close +printer_create_brush +printer_create_dc +printer_create_font +printer_create_pen +printer_delete_brush +printer_delete_dc +printer_delete_font +printer_delete_pen +printer_draw_bmp +printer_draw_chord +printer_draw_elipse +printer_draw_line +printer_draw_pie +printer_draw_rectangle +printer_draw_roundrect +printer_draw_text +printer_end_doc +printer_end_page +printer_get_option +printer_list +printer_logical_fontheight +printer_open +printer_select_brush +printer_select_font +printer_select_pen +printer_set_option +printer_start_doc +printer_start_page +printer_write +printf +print_r +private +proc_close +proc_get_status +proc_nice +proc_open +proc_terminate +property_exists +protected +ps_add_bookmark +ps_add_launchlink +ps_add_locallink +ps_add_note +ps_add_pdflink +ps_add_weblink +ps_arc +ps_arcn +ps_begin_page +ps_begin_pattern +ps_begin_template +ps_circle +ps_clip +ps_close +ps_close_image +ps_closepath +ps_closepath_stroke +ps_continue_text +ps_curveto +ps_delete +ps_end_page +ps_end_pattern +ps_end_template +ps_fill +ps_fill_stroke +ps_findfont +ps_get_buffer +ps_get_parameter +ps_get_value +ps_hyphenate +ps_include_file +ps_lineto +ps_makespotcolor +ps_moveto +ps_new +ps_open_file +ps_open_image +ps_open_image_file +ps_open_memory_image +pspell_add_to_personal +pspell_add_to_session +pspell_check +pspell_clear_session +pspell_config_create +pspell_config_data_dir +pspell_config_dict_dir +pspell_config_ignore +pspell_config_mode +pspell_config_personal +pspell_config_repl +pspell_config_runtogether +pspell_config_save_repl +pspell_new +pspell_new_config +pspell_new_personal +pspell_save_wordlist +pspell_store_replacement +pspell_suggest +ps_place_image +ps_rect +ps_restore +ps_rotate +ps_save +ps_scale +ps_set_border_color +ps_set_border_dash +ps_set_border_style +ps_setcolor +ps_setdash +ps_setflat +ps_setfont +ps_setgray +ps_set_info +ps_setlinecap +ps_setlinejoin +ps_setlinewidth +ps_setmiterlimit +ps_setoverprintmode +ps_set_parameter +ps_setpolydash +ps_set_text_pos +ps_set_value +ps_shading +ps_shading_pattern +ps_shfill +ps_show +ps_show2 +ps_show_boxed +ps_show_xy +ps_show_xy2 +ps_string_geometry +ps_stringwidth +ps_stroke +ps_symbol +ps_symbol_name +ps_symbol_width +ps_translate +public +putenv +px_close +px_create_fp +px_date2string +px_delete +px_delete_record +px_get_field +px_get_info +px_get_parameter +px_get_record +px_get_schema +px_get_value +px_insert_record +px_new +px_numfields +px_numrecords +px_open_fp +px_put_record +px_retrieve_record +px_set_blob_file +px_set_parameter +px_set_tablename +px_set_targetencoding +px_set_value +px_timestamp2string +px_update_record +qdom_error +qdom_tree +quickhashinthash +quickhashintset +quickhashintstringhash +quickhashstringinthash +quoted_printable_decode +quoted_printable_encode +quotemeta +rad2deg +radius_acct_open +radius_add_server +radius_auth_open +radius_close +radius_config +radius_create_request +radius_cvt_addr +radius_cvt_int +radius_cvt_string +radius_demangle +radius_demangle_mppe_key +radius_get_attr +radius_get_vendor_attr +radius_put_addr +radius_put_attr +radius_put_int +radius_put_string +radius_put_vendor_addr +radius_put_vendor_attr +radius_put_vendor_int +radius_put_vendor_string +radius_request_authenticator +radius_send_request +radius_server_secret +radius_strerror +rand +range +rangeexception +rararchive +rarentry +rarexception +rar_wrapper_cache_stats +rawurldecode +rawurlencode +readdir +read_exif_data +readfile +readgzfile +readline +readline_add_history +readline_callback_handler_install +readline_callback_handler_remove +readline_callback_read_char +readline_clear_history +readline_completion_function +readline_info +readline_list_history +readline_on_new_line +readline_read_history +readline_redisplay +readline_write_history +readlink +realpath +realpath_cache_get +realpath_cache_size +recode +recode_file +recode_string +recursivearrayiterator +recursivecachingiterator +recursivecallbackfilteriterator +recursivedirectoryiterator +recursivefilteriterator +recursiveiterator +recursiveiteratoriterator +recursiveregexiterator +recursivetreeiterator +reflection +reflectionclass +reflectionexception +reflectionextension +reflectionfunction +reflectionfunctionabstract +reflectionmethod +reflectionobject +reflectionparameter +reflectionproperty +reflector +regexiterator +register_shutdown_function +register_tick_function +rename +rename_function +require +require_once +reset +resetValue +resourcebundle +restore_error_handler +restore_exception_handler +restore_include_path +return +rewind +rewinddir +rmdir +round +rpm_close +rpm_get_tag +rpm_is_valid +rpm_open +rpm_version +rrd_create +rrdcreator +rrd_error +rrd_fetch +rrd_first +rrdgraph +rrd_graph +rrd_info +rrd_last +rrd_lastupdate +rrd_restore +rrd_tune +rrd_update +rrdupdater +rrd_version +rrd_xport +rsort +rtrim +runkit_class_adopt +runkit_class_emancipate +runkit_constant_add +runkit_constant_redefine +runkit_constant_remove +runkit_function_add +runkit_function_copy +runkit_function_redefine +runkit_function_remove +runkit_function_rename +runkit_import +runkit_lint +runkit_lint_file +runkit_method_add +runkit_method_copy +runkit_method_redefine +runkit_method_remove +runkit_method_rename +runkit_return_value_used +runkit_sandbox_output_handler +runkit_superglobals +runtimeexception +samconnection_commit +samconnection_connect +samconnection_constructor +samconnection_disconnect +samconnection_errno +samconnection_error +samconnection_isconnected +samconnection_peek +samconnection_peekall +samconnection_receive +samconnection_remove +samconnection_rollback +samconnection_send +samconnection_setDebug +samconnection_subscribe +samconnection_unsubscribe +sammessage_body +sammessage_constructor +sammessage_header +sca_createdataobject +sca_getservice +sca_localproxy_createdataobject +scandir +sca_soapproxy_createdataobject +sdo_das_changesummary_beginlogging +sdo_das_changesummary_endlogging +sdo_das_changesummary_getchangeddataobjects +sdo_das_changesummary_getchangetype +sdo_das_changesummary_getoldcontainer +sdo_das_changesummary_getoldvalues +sdo_das_changesummary_islogging +sdo_das_datafactory_addpropertytotype +sdo_das_datafactory_addtype +sdo_das_datafactory_getdatafactory +sdo_das_dataobject_getchangesummary +sdo_das_relational_applychanges +sdo_das_relational_construct +sdo_das_relational_createrootdataobject +sdo_das_relational_executepreparedquery +sdo_das_relational_executequery +sdo_das_setting_getlistindex +sdo_das_setting_getpropertyindex +sdo_das_setting_getpropertyname +sdo_das_setting_getvalue +sdo_das_setting_isset +sdo_das_xml_addtypes +sdo_das_xml_create +sdo_das_xml_createdataobject +sdo_das_xml_createdocument +sdo_das_xml_document_getrootdataobject +sdo_das_xml_document_getrootelementname +sdo_das_xml_document_getrootelementuri +sdo_das_xml_document_setencoding +sdo_das_xml_document_setxmldeclaration +sdo_das_xml_document_setxmlversion +sdo_das_xml_loadfile +sdo_das_xml_loadstring +sdo_das_xml_savefile +sdo_das_xml_savestring +sdo_datafactory_create +sdo_dataobject_clear +sdo_dataobject_createdataobject +sdo_dataobject_getcontainer +sdo_dataobject_getsequence +sdo_dataobject_gettypename +sdo_dataobject_gettypenamespaceuri +sdo_exception_getcause +sdo_list_insert +sdo_model_property_getcontainingtype +sdo_model_property_getdefault +sdo_model_property_getname +sdo_model_property_gettype +sdo_model_property_iscontainment +sdo_model_property_ismany +sdo_model_reflectiondataobject_construct +sdo_model_reflectiondataobject_export +sdo_model_reflectiondataobject_getcontainmentproperty +sdo_model_reflectiondataobject_getinstanceproperties +sdo_model_reflectiondataobject_gettype +sdo_model_type_getbasetype +sdo_model_type_getname +sdo_model_type_getnamespaceuri +sdo_model_type_getproperties +sdo_model_type_getproperty +sdo_model_type_isabstracttype +sdo_model_type_isdatatype +sdo_model_type_isinstance +sdo_model_type_isopentype +sdo_model_type_issequencedtype +sdo_sequence_getproperty +sdo_sequence_insert +sdo_sequence_move +seekableiterator +sem_acquire +sem_get +sem_release +sem_remove +serializable +serialize +session_cache_expire +session_cache_limiter +session_commit +session_decode +session_destroy +session_encode +session_get_cookie_params +session_id +session_is_registered +session_module_name +session_name +session_pgsql_add_error +session_pgsql_get_error +session_pgsql_get_field +session_pgsql_reset +session_pgsql_set_field +session_pgsql_status +session_regenerate_id +session_register +session_save_path +session_set_cookie_params +session_set_save_handler +session_start +session_unregister +session_unset +session_write_close +__set() +setcookie +setCounterClass +set_error_handler +set_exception_handler +set_file_buffer +set_include_path +setlocale +set_magic_quotes_runtime +setproctitle +setrawcookie +set_socket_blocking +__set_state() +setstaticpropertyvalue +setthreadtitle +set_time_limit +settype +sha1 +sha1_file +shell_exec +shm_attach +shm_detach +shm_get_var +shm_has_var +shmop_close +shmop_delete +shmop_open +shmop_read +shmop_size +shmop_write +shm_put_var +shm_remove +shm_remove_var +show_source +shuffle +signeurlpaiement +similar_text +simplexmlelement +simplexml_import_dom +simplexmliterator +simplexml_load_file +simplexml_load_string +sin +sinh +sizeof +sleep +__sleep() +snmp +snmp2_get +snmp2_getnext +snmp2_real_walk +snmp2_set +snmp2_walk +snmp3_get +snmp3_getnext +snmp3_real_walk +snmp3_set +snmp3_walk +snmpexception +snmpget +snmpgetnext +snmp_get_quick_print +snmp_get_valueretrieval +snmp_read_mib +snmprealwalk +snmpset +snmp_set_enum_print +snmp_set_oid_numeric_print +snmp_set_oid_output_format +snmp_set_quick_print +snmp_set_valueretrieval +snmpwalk +snmpwalkoid +soapclient +soapfault +soapheader +soapparam +soapserver +soapvar +socket_accept +socket_bind +socket_clear_error +socket_close +socket_connect +socket_create +socket_create_listen +socket_create_pair +socket_get_option +socket_getpeername +socket_getsockname +socket_get_status +socket_last_error +socket_listen +socket_read +socket_recv +socket_recvfrom +socket_select +socket_send +socket_sendto +socket_set_block +socket_set_blocking +socket_set_nonblock +socket_set_option +socket_set_timeout +socket_shutdown +socket_strerror +socket_write +solrclient +solrclientexception +solrdocument +solrdocumentfield +solrexception +solrgenericresponse +solr_get_version +solrillegalargumentexception +solrillegaloperationexception +solrinputdocument +solrmodifiableparams +solrobject +solrparams +solrpingresponse +solrquery +solrqueryresponse +solrresponse +solrupdateresponse +solrutils +sort +soundex +sphinxclient +spl_autoload +spl_autoload_call +spl_autoload_extensions +spl_autoload_functions +spl_autoload_register +spl_autoload_unregister +splbool +spl_classes +spldoublylinkedlist +splenum +splfileinfo +splfileobject +splfixedarray +splfloat +splheap +splint +split +spliti +splmaxheap +splminheap +spl_object_hash +splobjectstorage +splobserver +splpriorityqueue +splqueue +splstack +splstring +splsubject +spltempfileobject +spltype +spoofchecker +sprintf +sqlite3 +sqlite3result +sqlite3stmt +sqlite_array_query +sqlite_busy_timeout +sqlite_changes +sqlite_close +sqlite_column +sqlite_create_aggregate +sqlite_create_function +sqlite_current +sqlite_error_string +sqlite_escape_string +sqlite_exec +sqlite_factory +sqlite_fetch_all +sqlite_fetch_array +sqlite_fetch_column_types +sqlite_fetch_object +sqlite_fetch_single +sqlite_fetch_string +sqlite_field_name +sqlite_has_more +sqlite_has_prev +sqlite_key +sqlite_last_error +sqlite_last_insert_rowid +sqlite_libencoding +sqlite_libversion +sqlite_next +sqlite_num_fields +sqlite_num_rows +sqlite_open +sqlite_popen +sqlite_prev +sqlite_query +sqlite_rewind +sqlite_seek +sqlite_single_query +sqlite_udf_decode_binary +sqlite_udf_encode_binary +sqlite_unbuffered_query +sqlite_valid +sql_regcase +sqlsrv_begin_transaction +sqlsrv_cancel +sqlsrv_client_info +sqlsrv_close +sqlsrv_commit +sqlsrv_configure +sqlsrv_connect +sqlsrv_errors +sqlsrv_execute +sqlsrv_fetch +sqlsrv_fetch_array +sqlsrv_fetch_object +sqlsrv_field_metadata +sqlsrv_free_stmt +sqlsrv_get_config +sqlsrv_get_field +sqlsrv_has_rows +sqlsrv_next_result +sqlsrv_num_fields +sqlsrv_num_rows +sqlsrv_prepare +sqlsrv_query +sqlsrv_rollback +sqlsrv_rows_affected +sqlsrv_send_stream_data +sqlsrv_server_info +sqrt +srand +sscanf +ssdeep_fuzzy_compare +ssdeep_fuzzy_hash +ssdeep_fuzzy_hash_filename +ssh2_auth_hostbased_file +ssh2_auth_none +ssh2_auth_password +ssh2_auth_pubkey_file +ssh2_connect +ssh2_exec +ssh2_fetch_stream +ssh2_fingerprint +ssh2_methods_negotiated +ssh2_publickey_add +ssh2_publickey_init +ssh2_publickey_list +ssh2_publickey_remove +ssh2_scp_recv +ssh2_scp_send +ssh2_sftp +ssh2_sftp_lstat +ssh2_sftp_mkdir +ssh2_sftp_readlink +ssh2_sftp_realpath +ssh2_sftp_rename +ssh2_sftp_rmdir +ssh2_sftp_stat +ssh2_sftp_symlink +ssh2_sftp_unlink +ssh2_shell +ssh2_tunnel +stat +static +stats_absolute_deviation +stats_cdf_beta +stats_cdf_binomial +stats_cdf_cauchy +stats_cdf_chisquare +stats_cdf_exponential +stats_cdf_f +stats_cdf_gamma +stats_cdf_laplace +stats_cdf_logistic +stats_cdf_negative_binomial +stats_cdf_noncentral_chisquare +stats_cdf_noncentral_f +stats_cdf_poisson +stats_cdf_t +stats_cdf_uniform +stats_cdf_weibull +stats_covariance +stats_dens_beta +stats_dens_cauchy +stats_dens_chisquare +stats_dens_exponential +stats_dens_f +stats_dens_gamma +stats_dens_laplace +stats_dens_logistic +stats_dens_negative_binomial +stats_dens_normal +stats_dens_pmf_binomial +stats_dens_pmf_hypergeometric +stats_dens_pmf_poisson +stats_dens_t +stats_dens_weibull +stats_den_uniform +stats_harmonic_mean +stats_kurtosis +stats_rand_gen_beta +stats_rand_gen_chisquare +stats_rand_gen_exponential +stats_rand_gen_f +stats_rand_gen_funiform +stats_rand_gen_gamma +stats_rand_gen_ibinomial +stats_rand_gen_ibinomial_negative +stats_rand_gen_int +stats_rand_gen_ipoisson +stats_rand_gen_iuniform +stats_rand_gen_noncenral_chisquare +stats_rand_gen_noncentral_f +stats_rand_gen_noncentral_t +stats_rand_gen_normal +stats_rand_gen_t +stats_rand_get_seeds +stats_rand_phrase_to_seeds +stats_rand_ranf +stats_rand_setall +stats_skew +stats_standard_deviation +stats_stat_binomial_coef +stats_stat_correlation +stats_stat_gennch +stats_stat_independent_t +stats_stat_innerproduct +stats_stat_noncentral_t +stats_stat_paired_t +stats_stat_percentile +stats_stat_powersum +stats_variance +stomp +stomp_connect_error +stompexception +stompframe +stomp_version +strcasecmp +strchr +strcmp +strcoll +strcspn +stream_bucket_append +stream_bucket_make_writeable +stream_bucket_new +stream_bucket_prepend +stream_context_create +stream_context_get_default +stream_context_get_options +stream_context_get_params +stream_context_set_default +stream_context_set_option +stream_context_set_params +stream_copy_to_stream +stream_encoding +stream_filter_append +stream_filter_prepend +stream_filter_register +stream_filter_remove +stream_get_contents +stream_get_filters +stream_get_line +stream_get_meta_data +stream_get_transports +stream_get_wrappers +stream_is_local +stream_notification_callback +stream_register_wrapper +stream_resolve_include_path +stream_select +stream_set_blocking +stream_set_read_buffer +stream_set_timeout +stream_set_write_buffer +stream_socket_accept +stream_socket_client +stream_socket_enable_crypto +stream_socket_get_name +stream_socket_pair +stream_socket_recvfrom +stream_socket_sendto +stream_socket_server +stream_socket_shutdown +stream_supports_lock +streamwrapper +stream_wrapper_register +stream_wrapper_restore +stream_wrapper_unregister +strftime +str_getcsv +stripcslashes +stripos +stripslashes +strip_tags +str_ireplace +stristr +strlen +strnatcasecmp +strnatcmp +strncasecmp +strncmp +str_pad +strpbrk +strpos +strptime +strrchr +str_repeat +str_replace +strrev +strripos +str_rot13 +strrpos +str_shuffle +str_split +strspn +strstr +strtok +strtolower +strtotime +strtoupper +strtr +strval +str_word_count +substr +substr_compare +substr_count +substr_replace +svm +svmmodel +svn_add +svn_auth_get_parameter +svn_auth_set_parameter +svn_blame +svn_cat +svn_checkout +svn_cleanup +svn_client_version +svn_commit +svn_delete +svn_diff +svn_export +svn_fs_abort_txn +svn_fs_apply_text +svn_fs_begin_txn2 +svn_fs_change_node_prop +svn_fs_check_path +svn_fs_contents_changed +svn_fs_copy +svn_fs_delete +svn_fs_dir_entries +svn_fs_file_contents +svn_fs_file_length +svn_fs_is_dir +svn_fs_is_file +svn_fs_make_dir +svn_fs_make_file +svn_fs_node_created_rev +svn_fs_node_prop +svn_fs_props_changed +svn_fs_revision_prop +svn_fs_revision_root +svn_fs_txn_root +svn_fs_youngest_rev +svn_import +svn_log +svn_ls +svn_mkdir +svn_repos_create +svn_repos_fs +svn_repos_fs_begin_txn_for_commit +svn_repos_fs_commit_txn +svn_repos_hotcopy +svn_repos_open +svn_repos_recover +svn_revert +svn_status +svn_update +swfaction +swfaction.construct +swf_actiongeturl +swf_actiongotoframe +swf_actiongotolabel +swf_actionnextframe +swf_actionplay +swf_actionprevframe +swf_actionsettarget +swf_actionstop +swf_actiontogglequality +swf_actionwaitforframe +swf_addbuttonrecord +swf_addcolor +swfbitmap +swfbitmap.construct +swfbitmap.getheight +swfbitmap.getwidth +swfbutton +swfbutton.addaction +swfbutton.addasound +swfbutton.addshape +swfbutton.construct +swfbutton.setaction +swfbutton.setdown +swfbutton.sethit +swfbutton.setmenu +swfbutton.setover +swfbutton.setup +swf_closefile +swf_definebitmap +swf_definefont +swf_defineline +swf_definepoly +swf_definerect +swf_definetext +swfdisplayitem +swfdisplayitem.addaction +swfdisplayitem.addcolor +swfdisplayitem.endmask +swfdisplayitem.getrot +swfdisplayitem.getx +swfdisplayitem.getxscale +swfdisplayitem.getxskew +swfdisplayitem.gety +swfdisplayitem.getyscale +swfdisplayitem.getyskew +swfdisplayitem.move +swfdisplayitem.moveto +swfdisplayitem.multcolor +swfdisplayitem.remove +swfdisplayitem.rotate +swfdisplayitem.rotateto +swfdisplayitem.scale +swfdisplayitem.scaleto +swfdisplayitem.setdepth +swfdisplayitem.setmasklevel +swfdisplayitem.setmatrix +swfdisplayitem.setname +swfdisplayitem.setratio +swfdisplayitem.skewx +swfdisplayitem.skewxto +swfdisplayitem.skewy +swfdisplayitem.skewyto +swf_endbutton +swf_enddoaction +swf_endshape +swf_endsymbol +swffill +swffill.moveto +swffill.rotateto +swffill.scaleto +swffill.skewxto +swffill.skewyto +swffont +swffontchar +swffontchar.addchars +swffontchar.addutf8chars +swffont.construct +swffont.getascent +swffont.getdescent +swffont.getleading +swffont.getshape +swffont.getutf8width +swffont.getwidth +swf_fontsize +swf_fontslant +swf_fonttracking +swf_getbitmapinfo +swf_getfontinfo +swf_getframe +swfgradient +swfgradient.addentry +swfgradient.construct +swf_labelframe +swf_lookat +swf_modifyobject +swfmorph +swfmorph.construct +swfmorph.getshape1 +swfmorph.getshape2 +swfmovie +swfmovie.add +swfmovie.addexport +swfmovie.addfont +swfmovie.construct +swfmovie.importchar +swfmovie.importfont +swfmovie.labelframe +swfmovie.nextframe +swfmovie.output +swfmovie.remove +swfmovie.save +swfmovie.savetofile +swfmovie.setbackground +swfmovie.setdimension +swfmovie.setframes +swfmovie.setrate +swfmovie.startsound +swfmovie.stopsound +swfmovie.streammp3 +swfmovie.writeexports +swf_mulcolor +swf_nextid +swf_oncondition +swf_openfile +swf_ortho +swf_ortho2 +swf_perspective +swf_placeobject +swf_polarview +swf_popmatrix +swf_posround +swfprebuiltclip +swfprebuiltclip.construct +swf_pushmatrix +swf_removeobject +swf_rotate +swf_scale +swf_setfont +swf_setframe +swfshape +swfshape.addfill +swf_shapearc +swfshape.construct +swf_shapecurveto +swf_shapecurveto3 +swfshape.drawarc +swfshape.drawcircle +swfshape.drawcubic +swfshape.drawcubicto +swfshape.drawcurve +swfshape.drawcurveto +swfshape.drawglyph +swfshape.drawline +swfshape.drawlineto +swf_shapefillbitmapclip +swf_shapefillbitmaptile +swf_shapefilloff +swf_shapefillsolid +swf_shapelinesolid +swf_shapelineto +swfshape.movepen +swfshape.movepento +swf_shapemoveto +swfshape.setleftfill +swfshape.setline +swfshape.setrightfill +swf_showframe +swfsound +swfsound.construct +swfsoundinstance +swfsoundinstance.loopcount +swfsoundinstance.loopinpoint +swfsoundinstance.loopoutpoint +swfsoundinstance.nomultiple +swfsprite +swfsprite.add +swfsprite.construct +swfsprite.labelframe +swfsprite.nextframe +swfsprite.remove +swfsprite.setframes +swfsprite.startsound +swfsprite.stopsound +swf_startbutton +swf_startdoaction +swf_startshape +swf_startsymbol +swftext +swftext.addstring +swftext.addutf8string +swftext.construct +swftextfield +swftextfield.addchars +swftextfield.addstring +swftextfield.align +swftextfield.construct +swftextfield.setbounds +swftextfield.setcolor +swftextfield.setfont +swftextfield.setheight +swftextfield.setindentation +swftextfield.setleftmargin +swftextfield.setlinespacing +swftextfield.setmargins +swftextfield.setname +swftextfield.setpadding +swftextfield.setrightmargin +swftext.getascent +swftext.getdescent +swftext.getleading +swftext.getutf8width +swftext.getwidth +swftext.moveto +swftext.setcolor +swftext.setfont +swftext.setheight +swftext.setspacing +swf_textwidth +swf_translate +swfvideostream +swfvideostream.construct +swfvideostream.getnumframes +swfvideostream.setdimension +swf_viewport +swish_construct +swish_getmetalist +swish_getpropertylist +swish_prepare +swish_query +swishresult_getmetalist +swishresults_getparsedwords +swishresults_getremovedstopwords +swishresults_nextresult +swishresults_seekresult +swishresult_stem +swishsearch_execute +swishsearch_resetlimit +swishsearch_setlimit +swishsearch_setphrasedelimiter +swishsearch_setsort +swishsearch_setstructure +switch +sybase_affected_rows +sybase_close +sybase_connect +sybase_data_seek +sybase_deadlock_retry_count +sybase_fetch_array +sybase_fetch_assoc +sybase_fetch_field +sybase_fetch_object +sybase_fetch_row +sybase_field_seek +sybase_free_result +sybase_get_last_message +sybase_min_client_severity +sybase_min_error_severity +sybase_min_message_severity +sybase_min_server_severity +sybase_num_fields +sybase_num_rows +sybase_pconnect +sybase_query +sybase_result +sybase_select_db +sybase_set_message_handler +sybase_unbuffered_query +symlink +sys_getloadavg +sys_get_temp_dir +syslog +system +tan +tanh +tcpwrap_check +tempnam +textdomain +throw +tidy +tidy_access_count +tidy_config_count +tidy_diagnose +tidy_error_count +tidy_get_error_buffer +tidy_get_output +tidy_load_config +tidynode +tidy_reset_config +tidy_save_config +tidy_set_encoding +tidy_setopt +tidy_warning_count +time +time_nanosleep +time_sleep_until +timezone_abbreviations_list +timezone_identifiers_list +timezone_location_get +timezone_name_from_abbr +timezone_name_get +timezone_offset_get +timezone_open +timezone_transitions_get +timezone_version_get +tmpfile +token_get_all +token_name +tokyotyrant +tokyotyrantquery +tokyotyranttable +tostring +__toString() +touch +transliterator +traversable +trigger_error +trim +try +uasort +ucfirst +ucwords +udm_add_search_limit +udm_alloc_agent +udm_alloc_agent_array +udm_api_version +udm_cat_list +udm_cat_path +udm_check_charset +udm_check_stored +udm_clear_search_limits +udm_close_stored +udm_crc32 +udm_errno +udm_error +udm_find +udm_free_agent +udm_free_ispell_data +udm_free_res +udm_get_doc_count +udm_get_res_field +udm_get_res_param +udm_hash32 +udm_load_ispell_data +udm_open_stored +udm_set_agent_param +uksort +umask +underflowexception +unexpectedvalueexception +uniqid +unixtojd +unlink +unpack +unregister_tick_function +unserialize +unset +__unset() +urldecode +urlencode +use +user_error +use_soap_error_handler +usleep +usort +utf8_decode +utf8_encode +v8js +v8jsexception +var +var_dump +var_export +variant +variant_abs +variant_add +variant_and +variant_cast +variant_cat +variant_cmp +variant_date_from_timestamp +variant_date_to_timestamp +variant_div +variant_eqv +variant_fix +variant_get_type +variant_idiv +variant_imp +variant_int +variant_mod +variant_mul +variant_neg +variant_not +variant_or +variant_pow +variant_round +variant_set +variant_set_type +variant_sub +variant_xor +version_compare +vfprintf +virtual +vpopmail_add_alias_domain +vpopmail_add_alias_domain_ex +vpopmail_add_domain +vpopmail_add_domain_ex +vpopmail_add_user +vpopmail_alias_add +vpopmail_alias_del +vpopmail_alias_del_domain +vpopmail_alias_get +vpopmail_alias_get_all +vpopmail_auth_user +vpopmail_del_domain +vpopmail_del_domain_ex +vpopmail_del_user +vpopmail_error +vpopmail_passwd +vpopmail_set_user_quota +vprintf +vsprintf +w32api_deftype +w32api_init_dtype +w32api_invoke_function +w32api_register_function +w32api_set_call_method +__wakeup() +wddx_add_vars +wddx_deserialize +wddx_packet_end +wddx_packet_start +wddx_serialize_value +wddx_serialize_vars +weakref +while +win32_continue_service +win32_create_service +win32_delete_service +win32_get_last_control_message +win32_pause_service +win32_ps_list_procs +win32_ps_stat_mem +win32_ps_stat_proc +win32_query_service_status +win32_set_service_status +win32_start_service +win32_start_service_ctrl_dispatcher +win32_stop_service +wincache_fcache_fileinfo +wincache_fcache_meminfo +wincache_lock +wincache_ocache_fileinfo +wincache_ocache_meminfo +wincache_refresh_if_changed +wincache_rplist_fileinfo +wincache_rplist_meminfo +wincache_scache_info +wincache_scache_meminfo +wincache_ucache_add +wincache_ucache_cas +wincache_ucache_clear +wincache_ucache_dec +wincache_ucache_delete +wincache_ucache_exists +wincache_ucache_get +wincache_ucache_inc +wincache_ucache_info +wincache_ucache_meminfo +wincache_ucache_set +wincache_unlock +wordwrap +xattr_get +xattr_list +xattr_remove +xattr_set +xattr_supported +xdiff_file_bdiff +xdiff_file_bdiff_size +xdiff_file_bpatch +xdiff_file_diff +xdiff_file_diff_binary +xdiff_file_merge3 +xdiff_file_patch +xdiff_file_patch_binary +xdiff_file_rabdiff +xdiff_string_bdiff +xdiff_string_bdiff_size +xdiff_string_bpatch +xdiff_string_diff +xdiff_string_diff_binary +xdiff_string_merge3 +xdiff_string_patch +xdiff_string_patch_binary +xdiff_string_rabdiff +xhprof_disable +xhprof_enable +xhprof_sample_disable +xhprof_sample_enable +xml_error_string +xml_get_current_byte_index +xml_get_current_column_number +xml_get_current_line_number +xml_get_error_code +xml_parse +xml_parse_into_struct +xml_parser_create +xml_parser_create_ns +xml_parser_free +xml_parser_get_option +xml_parser_set_option +xmlreader +xmlrpc_decode +xmlrpc_decode_request +xmlrpc_encode +xmlrpc_encode_request +xmlrpc_get_type +xmlrpc_is_fault +xmlrpc_parse_method_descriptions +xmlrpc_server_add_introspection_data +xmlrpc_server_call_method +xmlrpc_server_create +xmlrpc_server_destroy +xmlrpc_server_register_introspection_callback +xmlrpc_server_register_method +xmlrpc_set_type +xml_set_character_data_handler +xml_set_default_handler +xml_set_element_handler +xml_set_end_namespace_decl_handler +xml_set_external_entity_ref_handler +xml_set_notation_decl_handler +xml_set_object +xml_set_processing_instruction_handler +xml_set_start_namespace_decl_handler +xml_set_unparsed_entity_decl_handler +xmlwriter_end_attribute +xmlwriter_end_cdata +xmlwriter_end_comment +xmlwriter_end_document +xmlwriter_end_dtd +xmlwriter_end_dtd_attlist +xmlwriter_end_dtd_element +xmlwriter_end_dtd_entity +xmlwriter_end_element +xmlwriter_end_pi +xmlwriter_flush +xmlwriter_full_end_element +xmlwriter_open_memory +xmlwriter_open_uri +xmlwriter_output_memory +xmlwriter_set_indent +xmlwriter_set_indent_string +xmlwriter_start_attribute +xmlwriter_start_attribute_ns +xmlwriter_start_cdata +xmlwriter_start_comment +xmlwriter_start_document +xmlwriter_start_dtd +xmlwriter_start_dtd_attlist +xmlwriter_start_dtd_element +xmlwriter_start_dtd_entity +xmlwriter_start_element +xmlwriter_start_element_ns +xmlwriter_start_pi +xmlwriter_text +xmlwriter_write_attribute +xmlwriter_write_attribute_ns +xmlwriter_write_cdata +xmlwriter_write_comment +xmlwriter_write_dtd +xmlwriter_write_dtd_attlist +xmlwriter_write_dtd_element +xmlwriter_write_dtd_entity +xmlwriter_write_element +xmlwriter_write_element_ns +xmlwriter_write_pi +xmlwriter_write_raw +xor +xpath_eval +xpath_eval_expression +xpath_new_context +xpath_register_ns +xpath_register_ns_auto +xptr_eval +xptr_new_context +xslt_backend_info +xslt_backend_name +xslt_backend_version +xslt_create +xslt_errno +xslt_error +xslt_free +xslt_getopt +xslt_process +xsltprocessor +xslt_set_base +xslt_set_encoding +xslt_set_error_handler +xslt_set_log +xslt_set_object +xslt_setopt +xslt_set_sax_handler +xslt_set_sax_handlers +xslt_set_scheme_handler +xslt_set_scheme_handlers +yaml_emit +yaml_emit_file +yaml_parse +yaml_parse_file +yaml_parse_url +yaz_addinfo +yaz_ccl_conf +yaz_ccl_parse +yaz_close +yaz_connect +yaz_database +yaz_element +yaz_errno +yaz_error +yaz_es +yaz_es_result +yaz_get_option +yaz_hits +yaz_itemorder +yaz_present +yaz_range +yaz_record +yaz_scan +yaz_scan_result +yaz_schema +yaz_search +yaz_set_option +yaz_sort +yaz_syntax +yaz_wait +yp_all +yp_cat +yp_errno +yp_err_string +yp_first +yp_get_default_domain +yp_master +yp_match +yp_next +yp_order +zend_logo_guid +zend_thread_id +zend_version +ziparchive +ziparchive_addemptydir +ziparchive_addfile +ziparchive_addfromstring +ziparchive_close +ziparchive_deleteindex +ziparchive_deletename +ziparchive_extractto +ziparchive_getarchivecomment +ziparchive_getcommentindex +ziparchive_getcommentname +ziparchive_getfromindex +ziparchive_getfromname +ziparchive_getnameindex +ziparchive_getstatusstring +ziparchive_getstream +ziparchive_locatename +ziparchive_open +ziparchive_renameindex +ziparchive_renamename +ziparchive_setarchivecomment +ziparchive_setcommentindex +ziparchive_setCommentName +ziparchive_statindex +ziparchive_statname +ziparchive_unchangeall +ziparchive_unchangearchive +ziparchive_unchangeindex +ziparchive_unchangename +zip_close +zip_entry_close +zip_entry_compressedsize +zip_entry_compressionmethod +zip_entry_filesize +zip_entry_name +zip_entry_open +zip_entry_read +zip_open +zip_read +zlib_get_coding_type +amqpchannel +amqpenvelope +autoload +bumpvalue +class_uses +closure +cubrid_get_query_timeout +cubrid_pconnect +cubrid_pconnect_with_url +cubrid_set_query_timeout +directory +domcdatasection +eio_busy +eio_cancel +eio_chmod +eio_chown +eio_close +eio_custom +eio_dup2 +eio_event_loop +eio_fallocate +eio_fchmod +eio_fchown +eio_fdatasync +eio_fstat +eio_fstatvfs +eio_fsync +eio_ftruncate +eio_futime +eio_get_event_stream +eio_grp +eio_grp_add +eio_grp_cancel +eio_grp_limit +eio_link +eio_lstat +eio_mkdir +eio_mknod +eio_nop +eio_npending +eio_nready +eio_nreqs +eio_nthreads +eio_open +eio_poll +eio_read +eio_readahead +eio_readdir +eio_readlink +eio_realpath +eio_rename +eio_rmdir +eio_sendfile +eio_set_max_idle +eio_set_max_parallel +eio_set_max_poll_reqs +eio_set_max_poll_time +eio_set_min_parallel +eio_stat +eio_statvfs +eio_symlink +eio_sync +eio_sync_file_range +eio_syncfs +eio_truncate +eio_unlink +eio_utime +eio_write +get_declared_traits +getimagesizefromstring +getmeta +getnamed +getvalue +hwapi_attribute_new +hwapi_content_new +is_tainted +lapack +lapackexception +ldap_control_paged_result +ldap_control_paged_result_response +libxml_set_external_entity_loader +mysqli_get_cache_stats +mysqli_sql_exception +mysqlnd_ms_get_last_gtid +mysqlnd_ms_get_last_used_connection +mysqlnd_ms_match_wild +mysqlnd_ms_set_qos +mysqlnd_qc_get_available_handlers +mysqlnd_qc_get_normalized_query_trace_log +mysqlnd_qc_set_cache_condition +mysqlnd_qc_set_is_select +mysqlnd_qc_set_storage_handler +mysqlnd_uh_convert_to_mysqlnd +mysqlnd_uh_set_connection_proxy +mysqlnd_uh_set_statement_proxy +mysqlnduhconnection +mysqlnduhpreparedstatement +pg_escape_identifier +pg_escape_literal +phar +phardata +pharexception +pharfileinfo +php_user_filter +reflectionzendextension +resetvalue +session_register_shutdown +session_status +sessionhandler +sessionhandlerinterface +setcounterclass +socket_import_stream +stream_set_chunk_size +taint +tokyotyrantexception +tokyotyrantiterator +trait_exists +untaint +varnishadmin +varnishlog +varnishstat +yaf_action_abstract +yaf_application +yaf_bootstrap_abstract +yaf_config_abstract +yaf_config_ini +yaf_config_simple +yaf_controller_abstract +yaf_dispatcher +yaf_exception +yaf_exception_dispatchfailed +yaf_exception_loadfailed +yaf_exception_loadfailed_action +yaf_exception_loadfailed_controller +yaf_exception_loadfailed_module +yaf_exception_loadfailed_view +yaf_exception_routerfailed +yaf_exception_startuperror +yaf_exception_typeerror +yaf_loader +yaf_plugin_abstract +yaf_registry +yaf_request_abstract +yaf_request_http +yaf_request_simple +yaf_response_abstract +yaf_route_interface +yaf_route_map +yaf_route_regex +yaf_route_rewrite +yaf_route_simple +yaf_route_static +yaf_route_supervar +yaf_router +yaf_session +yaf_view_interface +yaf_view_simple +zlib_decode +zlib_encode +trait +insteadof diff --git a/elpa/auto-complete-20140618.2217/dict/python-mode b/elpa/auto-complete-20140618.2217/dict/python-mode new file mode 100644 index 00000000..0ef64894 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/python-mode @@ -0,0 +1,175 @@ +ArithmeticError +AssertionError +AttributeError +BaseException +BufferError +BytesWarning +DeprecationWarning +EOFError +Ellipsis +EnvironmentError +Exception +False +FloatingPointError +FutureWarning +GeneratorExit +IOError +ImportError +ImportWarning +IndentationError +IndexError +KeyError +KeyboardInterrupt +LookupError +MemoryError +NameError +None +NotImplemented +NotImplementedError +OSError +OverflowError +PendingDeprecationWarning +ReferenceError +RuntimeError +RuntimeWarning +StandardError +StopIteration +SyntaxError +SyntaxWarning +SystemError +SystemExit +TabError +True +TypeError +UnboundLocalError +UnicodeDecodeError +UnicodeEncodeError +UnicodeError +UnicodeTranslateError +UnicodeWarning +UserWarning +ValueError +Warning +ZeroDivisionError +__builtins__ +__debug__ +__doc__ +__file__ +__import__ +__name__ +__package__ +abs +all +and +any +apply +as +assert +basestring +bin +bool +break +buffer +bytearray +bytes +callable +chr +class +classmethod +cmp +coerce +compile +complex +continue +copyright +credits +def +del +delattr +dict +dir +divmod +elif +else +enumerate +eval +except +exec +execfile +exit +file +filter +finally +float +for +format +from +frozenset +getattr +global +globals +hasattr +hash +help +hex +id +if +import +in +input +int +intern +is +isinstance +issubclass +iter +lambda +len +license +list +locals +long +map +max +memoryview +min +next +not +object +oct +open +or +ord +pass +pow +print +property +quit +raise +range +raw_input +reduce +reload +repr +return +reversed +round +set +setattr +slice +sorted +staticmethod +str +sum +super +try +tuple +type +unichr +unicode +vars +while +with +xrange +yield +zip diff --git a/elpa/auto-complete-20140618.2217/dict/qml-mode b/elpa/auto-complete-20140618.2217/dict/qml-mode new file mode 100644 index 00000000..7d9976e6 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/qml-mode @@ -0,0 +1,183 @@ +AlignBottom +AlignCenter +AlignHCenter +AlignLeft +AlignRight +AlignTop +AlignVCenter +AnchorAnimation +AnchorChanges +Audio +Behavior +Binding +BorderImage +ColorAnimation +Column +Component +Connections +Easing +Flickable +Flipable +Flow +FocusScope +GestureArea +Grid +GridView +Horizontal +Image +InBack +InBounce +InCirc +InCubic +InElastic +InExpo +InOutBack +InOutBounce +InOutCirc +InOutCubic +InOutElastic +InOutExpo +InOutQuad +InOutQuart +InOutQuint +InQuad +InQuart +InQuint +InQuint +InSine +Item +LayoutItem +LeftButton +Linear +ListElement +ListModel +ListView +Loader +MidButton +MiddleButton +MouseArea +NoButton +NumberAnimation +OutBack +OutBounce +OutCirc +OutCubic +OutElastic +OutExpo +OutInBack +OutInBounce +OutInCirc +OutInCubic +OutInElastic +OutInExpo +OutInQuad +OutInQuart +OutInQuint +OutQuad +OutQuart +OutQuint +OutSine +Package +ParallelAnimation +ParentAnimation +ParentChange +ParticleMotionGravity +ParticleMotionLinear +ParticleMotionWander +Particles +Path +PathAttribute +PathCubic +PathLine +PathPercent +PathQuad +PathView +PauseAnimation +PropertyAction +PropertyAnimation +PropertyChanges +Qt +QtObject +Rectangle +Repeater +RightButton +Rotation +RotationAnimation +Row +Scale +ScriptAction +SequentialAnimation +SmoothedAnimation +SoundEffect +SpringFollow +State +StateChangeScript +StateGroup +SystemPalette +Text +TextEdit +TextInput +Timer +Transition +Translate +Vertical +Video +ViewsPositionersMediaEffects +VisualDataModel +VisualItemModel +WebView +WorkerScript +XmlListModel +XmlRole +alias +as +bool +break +case +catch +color +const +continue +date +debugger +default +delete +do +double +else +enum +false +false +finally +for +function +if +import +import +in +instanceof +int +let +new +null +on +parent +property +real +return +signal +string +switch +this +throw +true +try +typeof +undefined +url +var +variant +void +while +with +yield diff --git a/elpa/auto-complete-20140618.2217/dict/ruby-mode b/elpa/auto-complete-20140618.2217/dict/ruby-mode new file mode 100644 index 00000000..1a854178 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/ruby-mode @@ -0,0 +1,181 @@ +$! +$" +$$ +$& +$' +$* +$+ +$, +$-0 +$-F +$-I +$-K +$-a +$-d +$-i +$-l +$-p +$-v +$-w +$. +$/ +$0 +$1 +$10 +$11 +$2 +$3 +$4 +$5 +$6 +$7 +$8 +$9 +$: +$; +$< +$= +$> +$? +$@ +$DEBUG +$FILENAME +$KCODE +$LOADED_FEATURES +$LOAD_PATH +$PROGRAM_NAME +$SAFE +$VERBOSE +$\ +$_ +$` +$deferr +$defout +$stderr +$stdin +$stdout +$~ +ARGF +ARGV +Array +BEGIN +DATA +END +ENV +FALSE +Float +Integer +NIL +PLATFORM +RELEASE_DATE +RUBY_COPYRIGHT +RUBY_DESCRIPTION +RUBY_PATCHLEVEL +RUBY_PLATFORM +RUBY_RELEASE_DATE +RUBY_VERSION +SCRIPT_LINES__ +STDERR +STDIN +STDOUT +String +TOPLEVEL_BINDING +TRUE +VERSION +__method__ +` +abort +alias +and +at_exit +autoload +autoload? +begin +binding +block_given +break +callcc +caller +case +catch +chomp +chomp! +chop +chop +class +def +defined? +do +else +elsif +end +ensure +eval +exec +exit +exit! +fail +false +for +fork +format +getc +gets +global_variables +gsub +gsub! +if +in +iterator? +lambda +load +local_variables +loop +module +next +nil +not +open +or +p +printf +proc +putc +puts +raise +rand +readline +readlines +redo +require +require_relative +rescue +retry +return +scan +select +self +set_trace_func +sleep +split +sprintf +srand +sub +sub! +super +syscall +system +test +then +throw +trace_var +trap +true +undef +unless +until +untrace_var +warn +when +while +yield diff --git a/elpa/auto-complete-20140618.2217/dict/scheme-mode b/elpa/auto-complete-20140618.2217/dict/scheme-mode new file mode 100644 index 00000000..e5cca615 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/scheme-mode @@ -0,0 +1,216 @@ +case-lambda +call/cc +class +define-class +exit-handler +field +import +inherit +init-field +interface +let*-values +let-values +let/ec +mixin +opt-lambda +override +protect +provide +public +rename +require +require-for-syntax +syntax +syntax-case +syntax-error +unit/sig +unless +when +with-syntax +and +begin +call-with-current-continuation +call-with-input-file +call-with-output-file +case +cond +define +define-syntax +delay +do +dynamic-wind +else +for-each +if +lambda +let +let* +let-syntax +letrec +letrec-syntax +map +or +syntax-rules +abs +acos +angle +append +apply +asin +assoc +assq +assv +atan +boolean? +caar +cadr +call-with-input-file +call-with-output-file +call-with-values +car +cdddar +cddddr +cdr +ceiling +char->integer +char-alphabetic? +char-ci<=? +char-ci=? +char-ci>? +char-downcase +char-lower-case? +char-numeric? +char-ready? +char-upcase +char-upper-case? +char-whitespace? +char<=? +char=? +char>? +char? +close-input-port +close-output-port +complex? +cons +cos +current-input-port +current-output-port +denominator +display +eof-object? +eq? +equal? +eqv? +eval +even? +exact->inexact +exact? +exp +expt +#f +floor +force +gcd +imag-part +inexact->exact +inexact? +input-port? +integer->char +integer? +interaction-environment +lcm +length +list +list->string +list->vector +list-ref +list-tail +list? +load +log +magnitude +make-polar +make-rectangular +make-string +make-vector +max +member +memq +memv +min +modulo +negative? +newline +not +null-environment +null? +number->string +number? +numerator +odd? +open-input-file +open-output-file +output-port? +pair? +peek-char +port? +positive? +procedure? +quasiquote +quote +quotient +rational? +rationalize +read +read-char +real-part +real? +remainder +reverse +round +scheme-report-environment +set! +set-car! +set-cdr! +sin +sqrt +string +string->list +string->number +string->symbol +string-append +string-ci<=? +string-ci=? +string-ci>? +string-copy +string-fill! +string-length +string-ref +string-set! +string<=? +string=? +string>? +string? +substring +symbol->string +symbol? +#t +tan +transcript-off +transcript-on +truncate +values +vector +vector->list +vector-fill! +vector-length +vector-ref +vector-set! diff --git a/elpa/auto-complete-20140618.2217/dict/sclang-mode b/elpa/auto-complete-20140618.2217/dict/sclang-mode new file mode 100644 index 00000000..2b92135b --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/sclang-mode @@ -0,0 +1,1481 @@ +A2K +A2K +abs +absdif +AbstractFunction +AbstractIn +AbstractOut +AbstractServerAction +acos +addition +Adverbs +AllpassC +AllpassL +AllpassN +amclip +AmpComp +AmpComp +AmpCompA +AmpCompA +ampdb +Amplitude +Amplitude +APF +AppClock +Archive +Array +Array2D +ArrayedCollection +asin +Assignment +Association +asTarget +atan +atan2 +AudioControl +AudioIn +audio_rate_mapping +AutoClassHelper +Bag +Balance2 +Balance2 +Ball +Ball +BAllPass +BAllPass +BasicOpUGen +basic_live_coding_techniques +BBandPass +BBandPass +BBandStop +BBandStop +BeatTrack +BeatTrack +BeatTrack +BeatTrack2 +BeatTrack2 +BeatTrack2 +BEQSuite +BEQSuite +BHiPass +BHiPass +BHiPass4 +BHiShelf +BHiShelf +BinaryOpFunction +BinaryOpStream +BinaryOpUGen +BiPanB2 +BiPanB2 +Blip +Blip +BLowPass +BLowPass +BLowPass4 +BLowShelf +BLowShelf +Boolean +BPeakEQ +BPeakEQ +BPF +BPF +BPZ2 +BPZ2 +BRF +BRF +BrownNoise +BrownNoise +BRZ2 +BRZ2 +BufAllpassC +BufAllpassL +BufAllpassN +BufChannels +BufChannels +BufCombC +BufCombL +BufCombN +BufDelayC +BufDelayL +BufDelayN +BufDur +BufDur +Buffer +Buffers +BufFrames +BufFrames +BufRateScale +BufRateScale +BufRd +BufRd +BufSampleRate +BufSampleRate +BufSamples +BufSamples +BufWr +BufWr +bundledCommands +Bus +BusPlug +Busses +Button +CCResponder +ceil +Changed +Changed +ChaosGen +Char +CheckBadValues +Class +Classes +ClassHelpTemplate +ClearBuf +ClientVsServer +Clip +Clip +clip2 +ClipNoise +ClipNoise +Clock +CmdPeriod +cmds +CocoaMenuItem +CoinGate +CoinGate +Collection +Collections +Color +CombC +CombL +CombN +Comments +Compander +Compander +CompanderD +Complex +CompositeView +Condition +ContiguousBlockAllocator +Control +Control-Structures +ControlDur +ControlName +ControlRate +ControlSpec +convertRhythm +Convolution +Convolution2 +Convolution2L +Convolution3 +cos +COsc +COsc +cosh +cpsmidi +cpsoct +Crackle +Crackle +Creating-Standalone-Applications +Crossplatform +CSVFileReader +cubed +CuspL +CuspL +CuspN +CuspN +Date +dbamp +Dbrown +Dbrown +Dbufrd +Dbufrd +Dbufwr +Dbufwr +DC +DC +Debugging-tips +DebugNodeWatcher +Decay +Decay +Decay2 +Decay2 +DecodeB2 +DecodeB2 +default_group +DegreeToKey +DegreeToKey +Delay1 +Delay2 +DelayC +DelayL +DelayN +DelTapRd +DelTapRd +DelTapWr +DelTapWr +Demand +Demand +DemandEnvGen +DemandEnvGen +DemandEnvGen +DetectIndex +DetectIndex +DetectSilence +DetectSilence +DetectSilence +Dgeom +Dgeom +Dialog +Dibrown +Dictionary +difsqr +DiskIn +DiskIn +DiskIn +DiskOut +DiskOut +DiskOut +distort +division +Diwhite +Document +DocumentAutoCompletion +Donce +Done +Done +DoubleArray +Dpoll +Dpoll +DragBoth +DragSink +DragSource +Drand +Drand +Dreset +Dreset +Dseq +Dseq +Dser +Dser +Dseries +Dseries +Dshuf +Dshuf +Dstutter +Dstutter +Dswitch +Dswitch +Dswitch1 +Dswitch1 +DUGen +Dunique +Dust +Dust +Dust2 +Dust2 +Duty +Duty +Dwhite +Dwhite +Dwrand +Dwrand +Dxrand +DynKlang +DynKlang +DynKlank +DynKlank +DynKlank +EmacsEditor +EmacsGUI +Env +EnvelopeView +EnvGate +EnvGen +EnvGen +EnvirGui +Environment +EnvironmentRedirect +Error +Event +EventPatternProxy +EventPatternProxy +EventStream +EventStreamPlayer +Event_types +Exception +excess +exp +exponentiation +ExpRand +ExpRand +ExpRand +Expression-Sequence +EZGui +EZKnob +EZLists +EZListView +EZNumber +EZPopUpMenu +EZRanger +EZScroller +EZSlider +EZText +False +FBSineC +FBSineC +FBSineL +FBSineL +FBSineN +FBSineN +Fdef +FFT +FFTTrigger +File +FileReader +Filter +FilterPattern +FilterPattern +Float +FloatArray +floor +FlowLayout +FlowView +Fold +Fold +fold2 +Font +Formant +Formant +Formlet +Formlet +FOS +FOS +frac +Frame +Free +Free +FreeSelf +FreeSelf +FreeSelfWhenDone +FreeSelfWhenDone +FreeVerb +FreeVerb2 +FreqScope +FreqScopeView +FreqShift +FreqShift +FreqShift +FSinOsc +FSinOsc +FuncFilterPattern +Function +FunctionDef +FunctionList +Functions +Gate +GbmanL +GbmanL +GbmanN +GbmanN +Gendy1 +Gendy1 +Gendy2 +Gendy2 +Gendy3 +Gendy3 +GeneralHID +GeneralHIDDevice +GeneralHIDSlot +GeneralHIDSpec +Glossary +Gradient +GrainBuf +GrainBuf +GrainFM +GrainIn +GrainSin +GrayNoise +GrayNoise +greaterorequalthan +greaterthan +Group +Groups +GUI +gui +GUI-Classes +GUI-Overview +GVerb +Harmonics +Hasher +Hasher +Help +HelpDocsLicensing +Helper +HelpSearchResult +HenonC +HenonC +HenonL +HenonL +HenonN +HenonN +HIDDeviceService +Hilbert +HilbertFIR +HiliteGradient +History +HistoryGui +HLayoutView +How-to-Use-the-Interpreter +HPF +HPF +HPZ1 +HPZ1 +HPZ2 +HPZ2 +hypot +hypotApx +IdentityBag +IdentityDictionary +IdentitySet +IEnvGen +IEnvGen +if +IFFT +Impulse +Impulse +In +Index +Index +IndexInBetween +IndexInBetween +IndexL +IndexL +InFeedback +Infinitum +initClass +InRange +InRange +InRect +InRect +Int16Array +Int32Array +Int8Array +Integer +Integrator +Integrator +Integrator +Internal-Snooping +InterplEnv +InterplPairs +InterplXYC +Interpreter +Interval +InTrig +Intro-to-Objects +Introductory_tutorial +IRand +IRand +IRand +isKindOf +isNegative +isPositive +isStrictlyPositive +JITGui +JITLib +jitlib_asCompileString +jitlib_basic_concepts_01 +jitlib_basic_concepts_02 +jitlib_basic_concepts_03 +jitlib_basic_concepts_04 +jitlib_efficiency +jitlib_fading +jitlib_networking +J_concepts_in_SC +K2A +K2A +KeyState +KeyState +KeyTrack +KeyTrack +Klang +Klang +Klang +Klank +Klank +Klank +Knob +Lag +Lag +Lag2 +Lag2 +Lag2UD +Lag2UD +Lag3 +Lag3 +Lag3UD +Lag3UD +LagControl +LagIn +LagUD +LagUD +LastValue +Latch +Latch +LatoocarfianC +LatoocarfianC +LatoocarfianL +LatoocarfianL +LatoocarfianN +LatoocarfianN +LazyEnvir +LeakDC +LeakDC +LeastChange +LeastChange +lessorequalthan +lessthan +LFClipNoise +LFClipNoise +LFCub +LFCub +LFDClipNoise +LFDClipNoise +LFDNoise0 +LFDNoise0 +LFDNoise1 +LFDNoise1 +LFDNoise3 +LFDNoise3 +LFGauss +LFGauss +LFNoise0 +LFNoise0 +LFNoise1 +LFNoise1 +LFNoise2 +LFNoise2 +LFPar +LFPar +LFPulse +LFPulse +LFSaw +LFSaw +LFTri +LFTri +Library +LibraryBase +Licensing +LID +Limiter +Limiter +LinCongC +LinCongC +LinCongL +LinCongL +LinCongN +LinCongN +Line +Line +Linen +Linen +LinExp +LinExp +LinkedList +LinkedListNode +LinLin +LinLin +LinPan2 +LinPan2 +LinRand +LinRand +LinRand +LinSelectX +Linux_udev_setup +LinXFade2 +LinXFade2 +List +ListComprehensions +ListDUGen +ListPattern +ListPattern +ListView +Literals +LocalBuf +LocalBuf +LocalIn +LocalOut +log +log10 +log2 +Logistic +Logistic +loop +LorenzL +LorenzL +Loudness +Loudness +LPF +LPF +LPZ1 +LPZ1 +LPZ2 +LPZ2 +Magnitude +Main +MantissaMask +MantissaMask +matchItem +max +MaxLocalBufs +MaxLocalBufs +Maybe +Median +Median +Method +Method-Calls +MFCC +MFCC +MidEQ +MidEQ +MIDI +midicps +MIDIIn +MIDIOut +MIDIResponder +min +Mix +modifiers +Modifying_Standalones +modulo +Monitor +MonitorGui +MoogFF +MoogFF +More-On-Getting-Help +MostChange +MostChange +MouseButton +MouseButton +MouseX +MouseX +MouseY +MouseY +MovieView +MulAdd +MultiChannel +MultiLevelIdentityDictionary +MultiOutUGen +multiplication +MultiSliderView +MultiTap +NamedControl +NAryOpFunction +NAryOpStream +Ndef +NdefGui +NdefMixer +NdefMixerOld +NdefParamGui +neg +NetAddr +Nil +Node +NodeControl +NodeEvent +NodeMap +NodeMessaging +NodeProxy +NodeProxyEditor +NodeProxy_roles +NodeWatcher +Non-Realtime-Synthesis +Normalizer +Normalizer +NoteOnResponder +Notes-on-the-HTML-Help-System +NotificationCenter +NRand +NRand +NRand +NumAudioBuses +Number +NumberBox +NumBuffers +NumControlBuses +NumInputBuses +NumOutputBuses +NumRunningSynths +Object +ObjectGui +ObjectTable +octcps +OffsetOut +OnePole +OnePole +OneZero +OneZero +Onsets +Onsets +Operators +Order +Order-of-execution +OrderedIdentitySet +Osc +Osc +OSCBundle +OscN +OscN +OSCpathResponder +OSCresponder +OSCresponderNode +OSC_communication +Out +OutputProxy +PAbstractGroup +PackFFT +Padd +Padd +Paddp +Paddp +Paddpre +Paddpre +Pair +Pan2 +Pan2 +Pan4 +Pan4 +PanAz +PanAz +PanB +PanB +PanB2 +PanB2 +Panner +PartConv +Partial-Application +PathName +Pattern +PatternConductor +PatternProxy +PatternProxy +PatternsDocumentedAndNot +Pause +Pause +PauseSelf +PauseSelf +PauseSelfWhenDone +Pavaroh +Pavaroh +Pbeta +Pbeta +Pbind +Pbind +Pbindef +Pbindef +Pbindf +Pbindf +PbindProxy +PbindProxy +Pbinop +Pbinop +Pbrown +Pbrown +Pbus +Pbus +Pcauchy +Pcauchy +Pchain +Pchain +Pclump +Pclutch +Pclutch +Pcollect +Pcollect +Pconst +Pconst +Pdef +Pdef +PdefAllGui +PdefEditor +PdefGui +Pdefn +Pdefn +PdegreeToKey +PdegreeToKey +Pdfsm +Pdfsm +Pdict +Pdict +Pdiff +Pdrop +PdurStutter +PdurStutter +Peak +Peak +PeakFollower +PeakFollower +Pen +Penvir +Penvir +Pevent +Peventmod +Pexprand +Pexprand +PfadeIn +PfadeOut +Pfin +Pfin +Pfindur +Pfindur +PfinQuant +Pfinval +Pfinval +Pflatten +Pflow +Pflow +Pfpar +Pfset +Pfset +Pfsm +Pfsm +Pfunc +Pfunc +Pfuncn +Pfuncn +Pfx +Pfx +Pfxb +Pfxb +Pgate +Pgate +Pgauss +Pgauss +Pgbrown +Pgbrown +Pgeom +Pgeom +Pget +Pgpar +Pgpar +Pgroup +Pgroup +Pgtpar +PG_01_Introduction +PG_02_Basic_Vocabulary +PG_03_What_Is_Pbind +PG_04_Words_to_Phrases +PG_05_Math_on_Patterns +PG_060_Filter_Patterns +PG_06a_Repetition_Contraint_Patterns +PG_06b_Time_Based_Patterns +PG_06c_Composition_of_Patterns +PG_06d_Parallel_Patterns +PG_06e_Language_Control +PG_06f_Server_Control +PG_06g_Data_Sharing +PG_07_Value_Conversions +PG_08_Event_Types_and_Parameters +PG_Cookbook01_Basic_Sequencing +PG_Cookbook02_Manipulating_Patterns +PG_Cookbook03_External_Control +PG_Cookbook04_Sending_MIDI +PG_Cookbook05_Using_Samples +PG_Cookbook06_Phrase_Network +PG_Cookbook07_Rhythmic_Variations +PG_Ref01_Pattern_Internals +Phasor +Phasor +Phid +Phid +PhidKey +PhidKey +PhidSlot +PhidSlot +Phprand +Phprand +Pif +Pif +Pindex +Pindex +PingPong +PinkerNoise +PinkNoise +PinkNoise +Pipe +Pitch +Pitch +Pitch +PitchShift +PitchShift +Pkey +Pkey +Place +Place +Plag +Plambda +Plambda +Platform +play +PlayBuf +PlayBuf +playN +Plazy +Plazy +PlazyEnvir +PlazyEnvir +PlazyEnvirN +PlazyEnvirN +Plet +plot +Plotter +Plprand +Plprand +Pluck +Pluck +Pmeanrand +Pmeanrand +Pmono +Pmono +PmonoArtic +PmonoArtic +PMOsc +PMOsc +Pmul +Pmul +Pmulp +Pmulp +Pmulpre +Pmulpre +Pn +Pn +Pnaryop +Pnaryop +Pnsym +Pnsym +Pnsym1 +Point +Polar +Poll +Poll +Polymorphism +PopUpMenu +Post +pow +Ppar +Ppar +PparGroup +Ppatlace +Ppatlace +Ppatmod +Ppatmod +Pplayer +Ppoisson +Ppoisson +Pprob +Pprob +Pprotect +Pprotect +Pproto +Pproto +Prand +Prand +Preject +Preject +Prewrite +Prewrite +PriorityQueue +Process +Prorate +Prorate +Prout +Prout +Proutine +Proutine +ProxyMixer +ProxyMixerOld +ProxyMonitorGui +ProxySpace +proxyspace_examples +ProxySynthDef +Pseed +Pseed +Pseg +Pseg +Pselect +Pselect +Pseq +Pseq +Pser +Pser +Pseries +Pseries +Pset +Pset +Psetp +Psetp +Psetpre +Psetpre +Pshuf +Pshuf +PSinGrain +Pslide +Pslide +Pspawn +Pspawn +Pspawner +Pspawner +Pstep +Pstep +Pstep2add +Pstep3add +PstepNadd +PstepNadd +PstepNfunc +PstepNfunc +Pstretch +Pstretchp +Pstutter +Pstutter +Pswitch +Pswitch +Pswitch1 +Pswitch1 +Psym +Psym +Psym1 +Psync +Psync +Ptime +Ptime +Ptpar +Ptpar +Ptrace +Ptsym +Ptuple +Ptuple +publishing_code +Pulse +Pulse +PulseCount +PulseDivider +Punop +Punop +pvcalc +pvcalc2 +pvcollect +PV_Add +PV_BinScramble +PV_BinShift +PV_BinWipe +PV_BrickWall +PV_ChainUGen +PV_ChainUGen +PV_ConformalMap +PV_Conj +PV_Copy +PV_CopyPhase +PV_Diffuser +PV_Div +PV_HainsworthFoote +PV_JensenAndersen +PV_LocalMax +PV_MagAbove +PV_MagBelow +PV_MagClip +PV_MagDiv +PV_MagFreeze +PV_MagMul +PV_MagNoise +PV_MagShift +PV_MagSmear +PV_MagSquared +PV_Max +PV_Min +PV_Mul +PV_PhaseShift +PV_PhaseShift270 +PV_PhaseShift90 +PV_RandComb +PV_RandWipe +PV_RectComb +PV_RectComb2 +Pwalk +Pwalk +Pwhile +Pwhile +Pwhite +Pwhite +Pwrand +Pwrand +Pwrap +Pwrap +Pxrand +Pxrand +QuadC +QuadC +QuadL +QuadL +QuadN +QuadN +Quant +Quark +Quarks +RadiansPerSample +Ramp +Ramp +Rand +Rand +Rand +RandID +RandID +Randomness +randomSeed +RandSeed +RandSeed +RangeSlider +RawArray +RawPointer +reciprocal +RecNodeProxy +RecordBuf +RecordBuf +Rect +recursive_phrasing +Ref +RefCopy +Regenerate-GUI-Help +ReplaceOut +resize +Resonz +Resonz +RHPF +RHPF +ring1 +ring2 +ring3 +ring4 +Ringz +Ringz +RLPF +RLPF +RootNode +Rossler +Rotate2 +Rotate2 +round +Routine +runMe +runMe2 +RunningMax +RunningMax +RunningMin +RunningMin +RunningSum +RunningSum +SampleDur +SampleRate +Saw +Saw +SC2DSlider +SC2DTabletSlider +Scale +scaleneg +SCButton +SCCompositeView +SCContainerView +SCControlView +SCDragBoth +SCDragSink +SCDragSource +SCDragView +SCEnvelopeEdit +SCEnvelopeView +SCFont +SCFreqScope +SCFreqScopeWindow +Scheduler +SCHLayoutView +Schmidt +Schmidt +SCImage +SCImageFilter +SCImageKernel +SCKnob +SCLayoutView +SCLevelIndicator +SCListView +SCMenuGroup +SCMenuItem +SCMenuSeparator +SCModalSheet +SCModalWindow +SCMovieView +SCMultiSliderView +SCNumberBox +Scope +ScopeOut +ScopeOut2 +ScopeView +Score +SCPen +SCPopUpMenu +SCQuartzComposerView +SCRangeSlider +ScrollView +SCScope +SCScrollTopView +SCScrollView +SCSlider +SCSliderBase +SCSoundFileView +SCStaticText +SCStaticTextBase +SCStethoscope +SCTabletView +SCTextField +SCTextView +SCTopView +SCUserView +SCUserView-Subclassing +SCView +SCVLayoutView +SCWindow +Select +Select +SelectX +SelectX +SelectXFocus +SelectXFocus +Semaphore +SendPeakRMS +SendReply +SendTrig +SequenceableCollection +SerialPort +Server +Server-Architecture +Server-Command-Reference +ServerBoot +ServerOptions +ServerQuit +ServerTiming +ServerTree +Set +SetBuf +SetResetFF +Shaper +Shaper +SharedIn +SharedOut +Shortcuts +sign +Signal +Silent +Silent +SimpleController +SimpleNumber +sin +sinh +SinOsc +SinOsc +SinOscFB +SkipJack +Slew +Slew +Slider +Slider2D +Slope +Slope +Slope +softclip +softPut +softSet +softVol_ +somepage +SortedList +SOS +SOS +SoundFile +SoundFileView +SoundFileViewProgressWindow +SoundIn +SparseArray +Spawner +Spec +SpecCentroid +SpecCentroid +SpecFlatness +SpecFlatness +SpecPcile +SpecPcile +Splay +SplayAz +SplayZ +Spring +Spring +sqrdif +sqrsum +sqrt +squared +StandardL +StandardL +StandardN +StandardN +StartUp +StaticText +Stepper +StereoConvolution2L +Stethoscope +Stream +StreamClutch +Streams +Streams-Patterns-Events1 +Streams-Patterns-Events2 +Streams-Patterns-Events3 +Streams-Patterns-Events4 +Streams-Patterns-Events5 +Streams-Patterns-Events6 +Streams-Patterns-Events7 +String +StubTemplate +SubsampleOffset +subtraction +sumsqr +Sweep +switch +Symbol +SymbolArray +SymbolicNotations +SyncSaw +SyncSaw +Syntax-Shortcuts +Synth +Synth-Controlling-UGens +Synth-Definition-File-Format +SynthDef +SynthDesc +SynthDescLib +SystemClock +T2A +T2A +T2K +T2K +TabFileReader +TabletSlider2D +TabletView +tan +tanh +Tap +Tap +Task +TaskProxy +TaskProxy +TaskProxyGui +TBall +TBall +TChoose +Tdef +Tdef +TdefAllGui +TdefEditor +TdefGui +TDelay +TDelay +TDuty +TDuty +TempoBusClock +TempoClock +TExpRand +TExpRand +TextField +TextView +TGrains +TGrains +TGrains +the_lazy_proxy +Thread +thresh +Thunk +Timer +TIRand +TIRand +ToggleFF +TopicHelpTemplate +Tour_of_UGens +TRand +TRand +Trig +Trig1 +TrigControl +True +trunc +Tuning +Tutorial +TWChoose +TWChoose +TWindex +TWindex +TwoPole +TwoPole +TwoWayIdentityDictionary +TwoZero +TwoZero +UGen +UGen-doneActions +UGenHelpTemplate +UGens +UGens-and-Synths +UnaryOpFunction +UnaryOpStream +UnaryOpUGen +Understanding-Errors +Undocumented-Classes +UniqueID +UnixFILE +Unpack1FFT +UnpackFFT +UserView +Using-Extensions +Using-the-Startup-File +UsingMIDI +VarLag +VarSaw +VarSaw +VDiskIn +VDiskIn +VDiskIn +Vibrato +View +ViewRedirect +VLayoutView +Volume +VOsc +VOsc +VOsc3 +VOsc3 +Warp +Warp1 +Warp1 +Warp1 +Wavetable +WhiteNoise +WhiteNoise +WidthFirstUGen +WiiMote +WikiUsage +Window +Wrap +Wrap +wrap2 +WrapIndex +WrapIndex +Writing-Classes +Writing_Unit_Generators +XFade +XFade2 +XFade2 +XLine +XLine +XOut +ZeroCrossing +ZeroCrossing diff --git a/elpa/auto-complete-20140618.2217/dict/sh-mode b/elpa/auto-complete-20140618.2217/dict/sh-mode new file mode 100644 index 00000000..df66ae35 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/sh-mode @@ -0,0 +1,182 @@ +# Bash Family Shell Dictionary +# http://www.gnu.org/software/bash/manual/bash.html + +. +: +[ +alias +bg +bind +break +builtin +caller +cd +command +compgen +complete +compopt +continue +declare +dirs +disown +echo +enable +eval +exec +exit +export +fc +fg +getopts +hash +help +history +jobs +kill +let +local +logout +mapfile +popd +printf +pushd +pwd +read +readarray +readonly +return +set +shift +shopt +source +suspend +test +times +trap +type +typeset +ulimit +umask +unalias +unset +wait +! +[[ +]] +case +do +done +elif +else +esac +fi +for +function +if +in +select +then +time +until +while +{ +} +! +# +$ +* +- +0 +? +@ +_ +BASH +BASH_ALIASES +BASH_ARGC +BASH_ARGV +BASH_CMDS +BASH_COMMAND +BASH_ENV +BASH_EXECUTION_STRING +BASH_LINENO +BASH_REMATCH +BASH_SOURCE +BASH_SUBSHELL +BASH_VERSINFO +BASH_VERSION +BASH_XTRACEFD +BASHOPTS +BASHPID +CDPATH +COLUMNS +COMP_CWORD +COMP_KEY +COMP_LINE +COMP_POINT +COMP_TYPE +COMP_WORDBREAKS +COMP_WORDS +COMPREPLY +DIRSTACK +EMACS +EUID +FCEDIT +FIGNORE +FUNCNAME +GLOBIGNORE +GROUPS +HISTCMD +HISTCONTROL +HISTFILE +HISTFILESIZE +HISTIGNORE +HISTSIZE +HISTTIMEFORMAT +HOME +HOSTFILE +HOSTNAME +HOSTTYPE +IFS +IGNOREEOF +INPUTRC +LANG +LC_ALL +LC_COLLATE +LC_CTYPE +LC_MESSAGES +LC_MESSAGES +LC_NUMERIC +LINENO +LINES +MACHTYPE +MAIL +MAILCHECK +MAILPATH +OLDPWD +OPTARG +OPTERR +OPTIND +OSTYPE +PATH +PIPESTATUS +POSIXLY_CORRECT +PPID +PROMPT_COMMAND +PROMPT_DIRTRIM +PS1 +PS2 +PS3 +PS4 +PWD +RANDOM +REPLY +SECONDS +SHELL +SHELLOPTS +SHLVL +TEXTDOMAIN +TEXTDOMAINDIR +TIMEFORMAT +TMOUT +TMPDIR +UID diff --git a/elpa/auto-complete-20140618.2217/dict/tcl-mode b/elpa/auto-complete-20140618.2217/dict/tcl-mode new file mode 100644 index 00000000..07a12815 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/tcl-mode @@ -0,0 +1,172 @@ +after +append +apply +array +auto_execok +auto_import +auto_load +auto_load_index +auto_mkindex +auto_mkindex_old +auto_qualify +auto_reset +bell +binary +bind +bindtags +break +button +canvas +case +catch +cd +chan +checkbutton +clipboard +clock +close +concat +continue +destroy +dict +encoding +entry +eof +error +eval +event +exec +exit +expr +fblocked +fconfigure +fcopy +file +fileevent +flush +focus +font +for +foreach +format +frame +gets +glob +global +grab +grid +if +image +incr +info +interp +join +label +labelframe +lappend +lassign +lindex +linsert +list +listbox +llength +load +lower +lrange +lrepeat +lreplace +lreverse +lsearch +lset +lsort +menu +menubutton +message +namespace +open +option +pack +package +panedwindow +pid +pkg_mkIndex +place +proc +puts +pwd +radiobutton +raise +read +regexp +registry +regsub +rename +return +scale +scan +scrollbar +seek +selection +set +socket +source +spinbox +split +string +subst +switch +tclLog +tclPkgSetup +tclPkgUnknown +tcl_findLibrary +tell +text +time +tk +tk_chooseColor +tk_chooseDirectory +tk_getOpenFile +tk_getSaveFile +tk_menuSetFocus +tk_messageBox +tk_popup +tk_textCopy +tk_textCut +tk_textPaste +tkwait +toplevel +ttk::button +ttk::checkbutton +ttk::combobox +ttk::entry +ttk::focusFirst +ttk::frame +ttk::label +ttk::labelframe +ttk::menubutton +ttk::notebook +ttk::paned +ttk::panedwindow +ttk::progressbar +ttk::radiobutton +ttk::scale +ttk::scrollbar +ttk::separator +ttk::setTheme +ttk::sizegrip +ttk::style +ttk::takefocus +ttk::themes +ttk::treeview +trace +unknown +unload +unset +update +uplevel +upvar +variable +vwait +while +winfo +wm diff --git a/elpa/auto-complete-20140618.2217/dict/ts-mode b/elpa/auto-complete-20140618.2217/dict/ts-mode new file mode 100644 index 00000000..ffe377f9 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/ts-mode @@ -0,0 +1,797 @@ +absRefPrefix +accessibility +accessibilityWrap +accessKey +ACT +ACTIFSUB +ACTIVSUBRO +ACTRO +addAttributes +addExtUrlsAndShortCuts +additionalHeaders +additionalParams +addParams +addQueryString +addQueryString +adjustItemsH +adjustSubItemsH +adminPanelStyles +after +age +align +align.field +all +allowedAttribs +allowedGroups +allowEdit +allowNew +allowTags +allStdWrap +allWrap +alternativeSortingField +alternativeTempPath +altImgResource +altTarget +altText +alwaysActivePIDlist +alwaysLink +andWhere +angle +antiAlias +append +applyTotalH +applyTotalW +arrayReturnMode +arrowACT +arrowImgParams +arrowNO +ATagBeforeWrap +ATagParams +ATagTitle +atLeast +atMost +authcodeFields +autoInsertPID +autostart +backColor +badMess +base64 +baseURL +beforeImg +beforeImgLink +beforeImgTagParams +beforeROImg +beforeWrap +begin +begin +beginAtLevel +beLoginLinkIPList +beLoginLinkIPList_login +beLoginLinkIPList_logout +beUserLogin +bgImg +blankStrEqFalse +blur +bm +bodyTag +bodyTag +bodyTagAdd +bodyTagCObject +bodyTagMargins +border +border +borderCol +bordersWithin +borderThick +bottomContent +bottomHeight +br +breakSpace +breakWidth +brTag +bytes +c +cache_clearAtMidnight +cached +cache_period +caption +captionAlign +captionSplit +case +case +CASE +casesensitiveComp +cellpadding +cellspacing +char +charcoal +clearCacheOfPages +cMargins +COA +COA_INT +cObject +cObjNum +code +collapse +color +color1 +color2 +color3 +color.default +color.field +colRelations +cols +cols +colSpace +COLUMNS +COMMENT +commentWrap +compensateFieldWidth +compX +compY +concatenateJsAndCss +conf +config +config +CONFIG +constants +CONTENT +content_fallback +content_from_pid_allowOutsideDomain +controllerActionName +controllerExtensionName +controllerName +crop +cropHTML +csConv +cssInline +CSS_inlineStyle +CTABLE +CUR +CURIFSUB +CURIFSUBRO +current +CURRO +cWidth +data +dataArray +dataWrap +date +debug +debugData +debugFunc +debugItemConf +debugRenumberedObject +decimals +dec_point +default +defaultAlign +defaultCmd +defaultCode +defaultGetVars +delete +denyTags +depth +dimensions +directImageLink +directionLeft +directionUp +directReturn +disableAllHeaderCode +disableAltText +disableCharsetHeader +disableImgBorderAttr +disablePageExternalUrl +disablePrefixComment +disablePreviewNotification +displayActiveOnLoad +displayActiveOnLoad +displayrecord +distributeX +distributeY +doctype +doctypeSwitch +doNotLinkIt +doNotShowLink +doNotStripHTML +dontCheckPid +dontFollowMouse +dontHideOnMouseUp +dontLinkIfSubmenu +dontMd5FieldNames +dontWrapInTable +doubleBrTag +doublePostCheck +dWorkArea +edge +edit +editIcons +editIcons +editPanel +EDITPANEL +EDITPANEL +effects +email +emailMess +emboss +emptyTitleHandling +emptyTitleHandling +emptyTitleHandling +enable +enableContentLengthHeader +encapsLines +encapsLinesStdWrap +encapsTagList +entryLevel +equalH +equals +evalErrors +evalFunc +excludeDoktypes +excludeNoSearchPages +excludeUidList +expAll +explode +ext +extbase +externalBlocks +extOnReady +extTarget +face.default +face.field +FEData +fe_userEditSelf +fe_userOwnSelf +field +fieldPrefix +fieldRequired +fieldWrap +file +FILE +filelink +fileList +fileTarget +firstLabel +firstLabelGeneral +flip +flop +foldSpeed +foldTimer +fontFile +fontSize +fontSizeMultiplicator +fontTag +footerData +forceAbsoluteUrl +forceTypeValue +FORM +format +formName +formurl +frame +frameReloadIfNotInFrameset +frameSet +freezeMouseover +ftu +gamma +gapBgCol +gapLineCol +gapLineThickness +gapWidth +gif +GIFBUILDER +globalNesting +GMENU +goodMess +gray +gr_list +groupBy +headerComment +headerData +headTag +height +hiddenFields +hide +hideButCreateMap +hideMenuTimer +hideMenuWhenNotOver +hideNonTranslated +highColor +HMENU +hover +hoverStyle +HRULER +HTML +html5 +htmlmail +HTMLparser +htmlSpecialChars +htmlTag_dir +htmlTag_langKey +htmlTag_setParams +http +icon +iconCObject +icon_image_ext_list +icon_link +icon_thumbSize +if +ifBlank +ifEmpty +IFSUB +IFSUBRO +ignore +IMAGE +image_compression +image_effects +image_frames +imgList +imgMap +imgMapExtras +imgMax +imgNameNotRandom +imgNamePrefix +imgObjNum +imgParams +imgPath +imgStart +IMGTEXT +import +inBranch +includeCSS +includeJS +includeJSFooter +includeJSFooterlibs +includeJSlibs +includeLibrary +includeLibs +includeNotInMenu +incT3Lib_htmlmail +index_descrLgd +index_enable +index_externals +index_metatags +infomail +inlineJS +inlineLanguageLabel +inlineSettings +inlineStyle2TempFile +innerStdWrap_all +innerWrap +innerWrap2 +inputLevels +insertClassesFromRTE +insertData +intensity +intTarget +intval +invert +IProcFunc +isFalse +isGreaterThan +isInList +isLessThan +isPositive +isTrue +itemArrayProcFunc +items +iterations +javascriptLibs +join +jpg +jsFooterInline +jsInline +JSMENU +JSwindow +JSwindow.altUrl +JSwindow.altUrl_noDefaultParams +JSwindow.expand +JSwindow.newWindow +JSwindow_params +jumpurl +jumpurl_enable +jumpurl_mailto_disable +keep +keepNonMatchedTags +keywords +keywordsField +labelStdWrap +labelWrap +lang +language +language_alt +languageField +layer_menu_id +layerStyle +layout +layoutRootPath +leftjoin +leftOffset +levels +limit +lineColor +lineThickness +linkAccessRestrictedPages +linkParams +linkVars +linkWrap +list +listNum +lm +LOAD_REGISTER +locale_all +localNesting +locationData +lockFilePath +lockPosition +lockPosition_addSelf +lockPosition_adjust +loginUser +longdescURL +loop +lowColor +lower +mailto +main +mainScript +makelinks +markers +markerWrap +mask +max +maxAge +maxH +maxHeight +maxItems +maxW +maxWidth +maxWInText +m.bgImg +m.bottomImg +m.bottomImg_mask +md5 +meaningfulTempFilePrefix +menuBackColor +menuHeight +menuOffset +menuWidth +message_page_is_being_generated +message_preview +message_preview_workspace +meta +metaCharset +method +minH +minifyCSS +minifyJS +minItems +minItems +minW +m.mask +moveJsFromHeaderToFooter +MP_defaults +MP_disableTypolinkClosestMPvalue +MP_mapRootPoints +MULTIMEDIA +name +namespaces +negate +newRecordFromTable +newRecordInPid +next +niceText +NO +noAttrib +noBlur +no_cache +noCols +noLink +noLinkUnderline +nonCachedSubst +none +nonTypoTagStdWrap +nonTypoTagUserFunc +nonWrappedTag +noOrderBy +noPageTitle +noResultObj +normalWhenNoLanguage +noRows +noScale +noScaleUp +noscript +noStretchAndMarginCells +notification_email_charset +notification_email_encoding +notification_email_urlmode +noTrimWrap +noValueInsert +noWrapAttr +numberFormat +numRows +obj +offset +offset +_offset +offsetWrap +onlyCurrentPid +opacity +options +orderBy +OTABLE +outerWrap +outline +output +outputLevels +override +overrideAttribs +overrideEdit +overrideId +PAGE +pageGenScript +pageRendererTemplateFile +pageTitleFirst +parameter +params +parseFunc +parseFunc +parseValues +partialRootPath +path +pidInList +pixelSpaceFontSizeRef +plainTextStdWrap +pluginNames +png +postCObject +postUserFunc +postUserFunkInt +preCObject +prefixComment +prefixLocalAnchors +prefixLocalAnchors +prefixRelPathWith +preIfEmptyListNum +prepend +preUserFunc +prev +previewBorder +printBeforeContent +prioriCalc +processScript +properties +protect +protectLvar +quality +quality +radioInputWrap +radioWrap +range +range +rawUrlEncode +recipient +RECORDS +recursive +redirect +reduceColors +relativeToParentLayer +relativeToTriggerItem +relPathPrefix +remap +remapTag +removeBadHTML +removeDefaultJS +removeIfEquals +removeIfFalse +removeObjectsOfDummy +removePrependedNumbers +removeTags +removeWrapping +renderCharset +renderObj +renderWrap +REQ +required +required +resources +resultObj +returnKey +returnLast +reverseOrder +rightjoin +rm +rmTagIfNoAttrib +RO_chBgColor +rootline +rotate +rows +rowSpace +sample +sample +section +sectionIndex +select +sendCacheHeaders +sendCacheHeaders_onlyWhenLoginDeniedInBranch +separator +setContentToCurrent +setCurrent +setfixed +setFixedHeight +setFixedWidth +setJS_mouseOver +setJS_openPic +setKeywords +shadow +sharpen +shear +short +shortcutIcon +showAccessRestrictedPages +showActive +showFirst +simulateStaticDocuments +simulateStaticDocuments_addTitle +simulateStaticDocuments_dontRedirectPathInfoError +simulateStaticDocuments_noTypeIfNoTitle +simulateStaticDocuments_pEnc +simulateStaticDocuments_pEnc_onlyP +simulateStaticDocuments_replacementChar +sitetitle +size +size.default +size.field +slide +smallFormFields +solarize +source +space +spaceAfter +spaceBefore +spaceBelowAbove +spaceLeft +spaceRight +spacing +spamProtectEmailAddresses +spamProtectEmailAddresses_atSubst +spamProtectEmailAddresses_lastDotSubst +SPC +special +split +splitRendering +src +stat +stat_apache +stat_apache_logfile +stat_apache_niceTitle +stat_apache_noHost +stat_apache_noRoot +stat_apache_notExtended +stat_apache_pagenames +stat_excludeBEuserHits +stat_excludeIPList +stat_mysql +stat_pageLen +stat_titleLen +stat_typeNumList +stayFolded +stdWrap +stdWrap2 +strftime +stripHtml +stripProfile +stylesheet +submenuObjSuffixes +subMenuOffset +subparts +subst_elementUid +subst_elementUid +substMarksSeparately +substring +swirl +sword +sword_noMixedCase +sword_standAlone +sys_language_mode +sys_language_overlay +sys_language_softExclude +sys_language_softMergeIfNotBlank +sys_language_uid +sys_page +table +tableParams +tables +tableStdWrap +tableStyle +tags +target +TCAselectItem +TDparams +template +TEMPLATE +templateFile +text +TEXT +textMargin +textMargin_outOfText +textMaxLength +textObjNum +textPos +textStyle +thickness +thousands_sep +title +titleTagFunction +titleText +titleText +tm +TMENU +token +topOffset +totalWidth +transparentBackground +transparentColor +trim +twice +typeNum +types +typolink +typolinkCheckRootline +typolinkEnableLinksAcrossDomains +typolinkLinkAccessRestrictedPages +typolinkLinkAccessRestrictedPages_addParams +uid +uidInList +uniqueGlobal +uniqueLinkVars +uniqueLocal +unset +unsetEmpty +upper +url +useCacheHash +useLargestItemX +useLargestItemY +USER +USERDEF1 +USERDEF1RO +USERDEF2RO +USERFEF2 +userFunc +userFunc_updateArray +userIdColumn +USER_INT +USERNAME_substToken +USERUID_substToken +USR +USRRO +value +variables +wave +where +width +wordSpacing +workArea +workOnSubpart +wrap +wrap2 +wrap3 +wrapAlign +wrapFieldName +wrapItemAndSub +wrapNoWrappedLines +wraps +xhtml_11 +xhtml_2 +xhtml_basic +xhtml_cleaning +xhtmlDoctype +xhtml_frames +xhtml+rdfa_10 +xhtml_strict +xhtml_trans +xml_10 +xml_11 +xmlprologue +xPosOffset +yPosOffset diff --git a/elpa/auto-complete-20140618.2217/dict/tuareg-mode b/elpa/auto-complete-20140618.2217/dict/tuareg-mode new file mode 100644 index 00000000..e709f9f6 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/tuareg-mode @@ -0,0 +1,231 @@ +# OCaml 3.12.1 + +# Keywords +and +as +assert +begin +class +constraint +do +done +downto +else +end +exception +external +false +for +fun +function +functor +if +in +include +inherit +initializer +lazy +let +match +method +module +mutable +new +object +of +open +or +private +rec +sig +struct +then +to +true +try +type +val +virtual +when +while +with + +# Pervasives +! +!= +& +&& +* +** +*. ++ ++. +- +-. +/ +/. +:= +< +<= +<> += +== +> +>= +@ +FP_infinite +FP_nan +FP_normal +FP_subnormal +FP_zero +LargeFile +Open_append +Open_binary +Open_creat +Open_nonblock +Open_rdonly +Open_text +Open_trunc +Open_wronly +Oupen_excl +^ +^^ +abs +abs_float +acos +asin +asr +at_exit +atan +atan2 +bool_of_string +ceil +char_of_int +classify_float +close_in +close_in_noerr +close_out +close_out_noerr +compare +cos +cosh +decr +do_at_exit +epsilon_float +exit +exp +expm1 +failwith +float +float_of_int +float_of_string +floor +flush +flush_all +format +format4 +format_of_string +fpclass +frexp +fst +ignore +in_channel +in_channel_length +incr +infinity +input +input_binary_int +input_byte +input_char +input_line +input_value +int_of_char +int_of_float +int_of_string +invalid_arg +land +ldexp +lnot +log +log10 +log1p +lor +lsl +lsr +lxor +max +max_float +max_int +min +min_float +min_int +mod +mod_float +modf +nan +neg_infinity +not +open_flag +open_in +open_in_bin +open_in_gen +open_out +open_out_bin +open_out_gen +or +out_channel +out_channel_length +output +output_binary_int +output_byte +output_char +output_string +output_value +pos_in +pos_out +pred +prerr_char +prerr_endline +prerr_float +prerr_int +prerr_newline +prerr_string +print_char +print_endline +print_float +print_int +print_newline +print_string +raise +read_float +read_int +read_line +really_input +ref +seek_in +seek_out +set_binary_mode_in +set_binary_mode_out +sin +sinh +snd +sqrt +stderr +stdin +stdout +string_of_bool +string_of_float +string_of_format +string_of_int +succ +tan +tanh +truncate +unsafe_really_input +valid_float_lexem +|| +~ +~+ +~+. +~- +~-. diff --git a/elpa/auto-complete-20140618.2217/dict/verilog-mode b/elpa/auto-complete-20140618.2217/dict/verilog-mode new file mode 100644 index 00000000..acc2f322 --- /dev/null +++ b/elpa/auto-complete-20140618.2217/dict/verilog-mode @@ -0,0 +1,313 @@ +`define +`else +`endif +`ifdef +`ifndef +`macromodule +`module +`primitive +`timescale +above +abs +absdelay +ac_stim +acos +acosh +alias +aliasparam +always +always_comb +always_ff +always_latch +analog +analysis +and +asin +asinh +assert +assign +assume +atan +atan2 +atanh +automatic +before +begin +bind +bins +binsof +bit +branch +break +buf +bufif0 +bufif1 +byte +case +casex +casez +cell +chandle +class +clocking +cmos +config +connectmodule +connectrules +const +constraint +context +continue +cos +cosh +cover +covergroup +coverpoint +cross +ddt +ddx +deassign +default +define +defparam +design +disable +discipline +dist +do +driver_update +edge +else +end +endcase +endclass +endclocking +endconfig +endconnectrules +enddiscipline +endfunction +endgenerate +endgroup +endif +endinterface +endmodule +endnature +endpackage +endparamset +endprimitive +endprogram +endproperty +endsequence +endspecify +endtable +endtask +enum +event +exclude +exp +expect +export +extends +extern +final +final_step +first_match +flicker_noise +floor +flow +for +force +foreach +forever +fork +forkjoin +from +function +generate +genvar +ground +highz0 +highz1 +hypot +idt +idtmod +if +ifdef +iff +ifndef +ifnone +ignore_bins +illegal_bins +import +incdir +include +inf +initial +initial_step +inout +input +inside +instance +int +integer +interface +intersect +join +join_any +join_none +laplace_nd +laplace_np +laplace_zd +laplace_zp +large +last_crossing +liblist +library +limexp +ln +local +localparam +log +logic +longint +macromodule +mailbox +matches +max +medium +min +modport +module +nand +nand +nature +negedge +net_resolution +new +nmos +nmos +noise_table +nor +noshowcancelled +not +notif0 +notif1 +null +or +output +package +packed +parameter +paramset +pmos +pmos +posedge +potential +pow +primitive +priority +program +property +protected +pull0 +pull1 +pullup +pulsestyle_ondetect +pulsestyle_onevent +pure +rand +randc +randcase +randcase +randsequence +rcmos +real +realtime +ref +reg +release +repeat +return +rnmos +rpmos +rtran +rtranif0 +rtranif1 +scalared +semaphore +sequence +shortint +shortreal +showcancelled +signed +sin +sinh +slew +small +solve +specify +specparam +sqrt +static +string +strong0 +strong1 +struct +super +supply +supply0 +supply1 +table +tagged +tan +tanh +task +then +this +throughout +time +timeprecision +timer +timescale +timeunit +tran +tran +tranif0 +tranif1 +transition +tri +tri +tri0 +tri1 +triand +trior +trireg +type +typedef +union +unique +unsigned +use +uwire +var +vectored +virtual +void +wait +wait_order +wand +weak0 +weak1 +while +white_noise +wildcard +wire +with +within +wor +wreal +xnor +xor +zi_nd +zi_np +zi_zd diff --git a/elpa/auto-complete-auctex-readme.txt b/elpa/auto-complete-auctex-readme.txt new file mode 100644 index 00000000..aee5cd16 --- /dev/null +++ b/elpa/auto-complete-auctex-readme.txt @@ -0,0 +1,2 @@ +You can install this by (require 'auto-complete-auctex). +Feel free to contribute better documentation! diff --git a/elpa/auto-complete-c-headers-readme.txt b/elpa/auto-complete-c-headers-readme.txt new file mode 100644 index 00000000..8802c54d --- /dev/null +++ b/elpa/auto-complete-c-headers-readme.txt @@ -0,0 +1,2 @@ +(require 'auto-complete-c-headers) +(add-to-list 'ac-sources 'ac-source-c-headers) diff --git a/elpa/auto-complete-chunk-readme.txt b/elpa/auto-complete-chunk-readme.txt new file mode 100644 index 00000000..1ac47f4e --- /dev/null +++ b/elpa/auto-complete-chunk-readme.txt @@ -0,0 +1,9 @@ +Example usage: + + (add-hook + 'python-mode + (lambda () + ;; Make sure `ac-source-chunk-list' comes first. + (setq ac-sources (append '(ac-source-chunk-list) ac-sources)) + (setq ac-chunk-list + '("os.path.abspath" "os.path.altsep" "os.path.basename")))) diff --git a/elpa/auto-complete-clang-async-readme.txt b/elpa/auto-complete-clang-async-readme.txt new file mode 100644 index 00000000..7ff7bf0e --- /dev/null +++ b/elpa/auto-complete-clang-async-readme.txt @@ -0,0 +1,3 @@ +Auto Completion source for clang. +Uses a "completion server" process to utilize libclang. +Also provides flymake syntax checking. diff --git a/elpa/auto-complete-clang-readme.txt b/elpa/auto-complete-clang-readme.txt new file mode 100644 index 00000000..b81dd2b9 --- /dev/null +++ b/elpa/auto-complete-clang-readme.txt @@ -0,0 +1,2 @@ +Auto Completion source for clang. Most of codes are taken from +company-clang.el and modified and enhanced for Auto Completion. diff --git a/elpa/auto-complete-exuberant-ctags-readme.txt b/elpa/auto-complete-exuberant-ctags-readme.txt new file mode 100644 index 00000000..68d6f180 --- /dev/null +++ b/elpa/auto-complete-exuberant-ctags-readme.txt @@ -0,0 +1,19 @@ +This package provide Exuberant ctags auto-complete.el source + +Installation: + +Put anything-exuberant-ctags.el to your load-path. +The load-path is usually ~/elisp/. +It's set in your ~/.emacs like this: +(add-to-list 'load-path (expand-file-name "~/elisp")) + +And the following to your ~/.emacs startup file. + +(require 'auto-complete-exuberant-ctags) +(ac-exuberant-ctags-setup) + +In your project root directory, do follow command to make tags file. + +ctags --verbose -R --fields="+afikKlmnsSzt" + +No need more. diff --git a/elpa/auto-complete-nxml-readme.txt b/elpa/auto-complete-nxml-readme.txt new file mode 100644 index 00000000..79065e0c --- /dev/null +++ b/elpa/auto-complete-nxml-readme.txt @@ -0,0 +1,2 @@ +This extension provides completion by auto-complete.el on nXML-mode. +About auto-complete.el, see . diff --git a/elpa/auto-complete-readme.txt b/elpa/auto-complete-readme.txt new file mode 100644 index 00000000..d0a9b31a --- /dev/null +++ b/elpa/auto-complete-readme.txt @@ -0,0 +1,16 @@ +This extension provides a way to complete with popup menu like: + + def-!- + +-----------------+ + |defun::::::::::::| + |defvar | + |defmacro | + | ... | + +-----------------+ + +You can complete by typing and selecting menu. + +Entire documents are located in doc/ directory. +Take a look for information. + +Enjoy! diff --git a/elpa/auto-complete-rst-readme.txt b/elpa/auto-complete-rst-readme.txt new file mode 100644 index 00000000..89612ec6 --- /dev/null +++ b/elpa/auto-complete-rst-readme.txt @@ -0,0 +1,2 @@ +Usage: + (eval-after-load "rst" '(auto-complete-rst-init)) diff --git a/elpa/auto-dictionary-readme.txt b/elpa/auto-dictionary-readme.txt new file mode 100644 index 00000000..4c9e9c41 --- /dev/null +++ b/elpa/auto-dictionary-readme.txt @@ -0,0 +1,16 @@ +Add the following to your .emacs file: +(require 'auto-dictionary) +(add-hook 'flyspell-mode-hook (lambda () (auto-dictionary-mode 1))) + +Then just type. When you stop for a few moments `auto-dictionary-mode' will +start evaluating the content. + +You can also force a check using `adict-guess-dictionary', whether or not +`auto-dictionary-mode' is enabled. + +If you're unhappy with the results, call `adict-change-dictionary' to +change it and stop automatic checks. + +You can use `adict-change-dictionary-hook' to hook into any of these changes, +or `adict-conditional-insert' to insert text (like signatures) that will +automatically conform to the language. diff --git a/elpa/popup-20140207.1702/popup-autoloads.el b/elpa/popup-20140207.1702/popup-autoloads.el new file mode 100644 index 00000000..3e3220f7 --- /dev/null +++ b/elpa/popup-20140207.1702/popup-autoloads.el @@ -0,0 +1,18 @@ +;;; popup-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + + +;;;### (autoloads nil nil ("popup-pkg.el" "popup.el") (21446 8667 +;;;;;; 508939 0)) + +;;;*** + +(provide 'popup-autoloads) +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; popup-autoloads.el ends here diff --git a/elpa/popup-20140207.1702/popup-pkg.el b/elpa/popup-20140207.1702/popup-pkg.el new file mode 100644 index 00000000..79df43d3 --- /dev/null +++ b/elpa/popup-20140207.1702/popup-pkg.el @@ -0,0 +1 @@ +(define-package "popup" "20140207.1702" "Visual Popup User Interface" (quote ((cl-lib "0.3")))) diff --git a/elpa/popup-20140207.1702/popup.el b/elpa/popup-20140207.1702/popup.el new file mode 100644 index 00000000..28778543 --- /dev/null +++ b/elpa/popup-20140207.1702/popup.el @@ -0,0 +1,1411 @@ +;;; popup.el --- Visual Popup User Interface + +;; Copyright (C) 2009, 2010, 2011, 2012, 2013 Tomohiro Matsuyama + +;; Author: Tomohiro Matsuyama +;; Keywords: lisp +;; Version: 20140207.1702 +;; X-Original-Version: 0.5.0 +;; Package-Requires: ((cl-lib "0.3")) + +;; 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 3 of the License, or +;; (at your option) any later version. + +;; 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 this program. If not, see . + +;;; Commentary: + +;; popup.el is a visual popup user interface library for Emacs. This +;; provides a basic API and common UI widgets such as popup tooltips +;; and popup menus. +;; See README.markdown for more information. + +;;; Code: + +(require 'cl-lib) + +(defconst popup-version "0.5.0") + + + +;;; Utilities + +(defun popup-calculate-max-width (max-width) + "Determines whether the width desired is +character or window proportion based, And returns the result." + (cl-typecase max-width + (integer max-width) + (float (* (ceiling (/ (round (* max-width (window-width))) 10.0)) 10)))) + +(defvar popup-use-optimized-column-computation t + "Use the optimized column computation routine. +If there is a problem, please set it nil.") + +(defmacro popup-aif (test then &rest else) + "Anaphoric if." + (declare (indent 2)) + `(let ((it ,test)) + (if it ,then ,@else))) + +(defmacro popup-awhen (test &rest body) + "Anaphoric when." + (declare (indent 1)) + `(let ((it ,test)) + (when it ,@body))) + +(defun popup-x-to-string (x) + "Convert any object to string effeciently. +This is faster than `prin1-to-string' in many cases." + (cl-typecase x + (string x) + (symbol (symbol-name x)) + (integer (number-to-string x)) + (float (number-to-string x)) + (t (format "%s" x)))) + +(defun popup-substring-by-width (string width) + "Return a cons cell of substring and remaining string by +splitting with WIDTH." + ;; Expand tabs into 4 spaces + (setq string (replace-regexp-in-string "\t" " " string)) + (cl-loop with len = (length string) + with w = 0 + for l from 0 + for c in (append string nil) + while (<= (cl-incf w (char-width c)) width) + finally return + (if (< l len) + (cons (substring string 0 l) (substring string l)) + (list string)))) + +(defun popup-fill-string (string &optional width max-width justify squeeze) + "Split STRING into fixed width strings and return a cons cell +like \(WIDTH . ROWS). Here, the car WIDTH indicates the actual +maxim width of ROWS. + +The argument WIDTH specifies the width of filling each +paragraph. WIDTH nil means don't perform any justification and +word wrap. Note that this function doesn't add any padding +characters at the end of each row. + +MAX-WIDTH, if WIDTH is nil, specifies the maximum number of +columns. + +The optional fourth argument JUSTIFY specifies which kind of +justification to do: `full', `left', `right', `center', or +`none' (equivalent to nil). A value of t means handle each +paragraph as specified by its text properties. + +SQUEEZE nil means leave whitespaces other than line breaks +untouched." + (if (eq width 0) + (error "Can't fill string with 0 width")) + (if width + (setq max-width width)) + (with-temp-buffer + (let ((tab-width 4) + (fill-column width) + (left-margin 0) + (kinsoku-limit 1) + indent-tabs-mode + row rows) + (insert string) + (untabify (point-min) (point-max)) + (if width + (fill-region (point-min) (point-max) justify (not squeeze))) + (goto-char (point-min)) + (setq width 0) + (while (prog2 + (let ((line (buffer-substring + (point) (progn (end-of-line) (point))))) + (if max-width + (while (progn + (setq row (truncate-string-to-width line max-width) + width (max width (string-width row))) + (push row rows) + (if (not (= (length row) (length line))) + (setq line (substring line (length row)))))) + (setq width (max width (string-width line))) + (push line rows))) + (< (point) (point-max)) + (beginning-of-line 2))) + (cons width (nreverse rows))))) + +(defmacro popup-save-buffer-state (&rest body) + (declare (indent 0)) + `(save-excursion + (let ((buffer-undo-list t) + (inhibit-read-only t) + (modified (buffer-modified-p))) + (unwind-protect + (progn ,@body) + (set-buffer-modified-p modified))))) + +(defun popup-window-full-width-p (&optional window) + "A portable version of `window-full-width-p'." + (if (fboundp 'window-full-width-p) + (window-full-width-p window) + (= (window-width window) (frame-width (window-frame (or window (selected-window))))))) + +(defun popup-truncated-partial-width-window-p (&optional window) + "A portable version of `truncated-partial-width-window-p'." + (unless window + (setq window (selected-window))) + (unless (popup-window-full-width-p window) + (let ((t-p-w-w (buffer-local-value 'truncate-partial-width-windows + (window-buffer window)))) + (if (integerp t-p-w-w) + (< (window-width window) t-p-w-w) + t-p-w-w)))) + +(defun popup-current-physical-column () + "Return the current physical column." + (or (when (and popup-use-optimized-column-computation + (eq (window-hscroll) 0)) + (let ((current-column (current-column))) + (if (or (popup-truncated-partial-width-window-p) + truncate-lines + (< current-column (window-width))) + current-column))) + (car (posn-col-row (posn-at-point))))) + +(defun popup-vertical-motion (column direction) + "A portable version of `vertical-motion'." + (if (>= emacs-major-version 23) + (vertical-motion (cons column direction)) + (vertical-motion direction) + (move-to-column (+ (current-column) column)))) + +(defun popup-last-line-of-buffer-p () + "Return non-nil if the cursor is at the last line of the +buffer." + (save-excursion (end-of-line) (/= (forward-line) 0))) + +(defun popup-lookup-key-by-event (function event) + (or (funcall function (vector event)) + (if (symbolp event) + (popup-aif (get event 'event-symbol-element-mask) + (funcall function + (vector (logior (or (get (car it) 'ascii-character) + 0) + (cadr it)))))))) + + + +;;; Core + +(defgroup popup nil + "Visual Popup User Interface" + :group 'lisp + :prefix "popup-") + +(defface popup-face + '((t (:background "lightgray" :foreground "black"))) + "Face for popup." + :group 'popup) + +(defface popup-summary-face + '((t (:inherit popup-face :foreground "dimgray"))) + "Face for popup summary." + :group 'popup) + +(defface popup-scroll-bar-foreground-face + '((t (:background "black"))) + "Foreground face for scroll-bar." + :group 'popup) + +(defface popup-scroll-bar-background-face + '((t (:background "gray"))) + "Background face for scroll-bar." + :group 'popup) + +(defvar popup-instances nil + "Popup instances.") + +(defvar popup-scroll-bar-foreground-char + (propertize " " 'face 'popup-scroll-bar-foreground-face) + "Foreground character for scroll-bar.") + +(defvar popup-scroll-bar-background-char + (propertize " " 'face 'popup-scroll-bar-background-face) + "Background character for scroll-bar.") + +(cl-defstruct popup + point row column width height min-height direction overlays keymap + parent depth + face mouse-face selection-face summary-face + margin-left margin-right margin-left-cancel scroll-bar symbol + cursor offset scroll-top current-height list newlines + pattern original-list) + +(defun popup-item-propertize (item &rest properties) + "Same as `propertize' except that this avoids overriding +existed value with `nil' property." + (cl-loop for (k v) on properties by 'cddr + if v append (list k v) into props + finally return + (apply 'propertize + (popup-x-to-string item) + props))) + +(defun popup-item-property (item property) + "Same as `get-text-property' except that this returns nil if +ITEM is not string." + (if (stringp item) + (get-text-property 0 property item))) + +(cl-defun popup-make-item (name + &key + value + face + mouse-face + selection-face + sublist + document + symbol + summary) + "Utility function to make popup item. See also +`popup-item-propertize'." + (popup-item-propertize name + 'value value + 'popup-face face + 'popup-mouse-face mouse-face + 'selection-face selection-face + 'document document + 'symbol symbol + 'summary summary + 'sublist sublist)) + +(defsubst popup-item-value (item) (popup-item-property item 'value)) +(defsubst popup-item-value-or-self (item) (or (popup-item-value item) item)) +(defsubst popup-item-face (item) (popup-item-property item 'popup-face)) +(defsubst popup-item-mouse-face (item) (popup-item-property item 'popup-mouse-face)) +(defsubst popup-item-selection-face (item) (popup-item-property item 'selection-face)) +(defsubst popup-item-document (item) (popup-item-property item 'document)) +(defsubst popup-item-summary (item) (popup-item-property item 'summary)) +(defsubst popup-item-symbol (item) (popup-item-property item 'symbol)) +(defsubst popup-item-sublist (item) (popup-item-property item 'sublist)) + +(defun popup-item-documentation (item) + (let ((doc (popup-item-document item))) + (if (functionp doc) + (setq doc (funcall doc (popup-item-value-or-self item)))) + doc)) + +(defun popup-item-show-help-1 (item) + (let ((doc (popup-item-documentation item))) + (when doc + (with-current-buffer (get-buffer-create " *Popup Help*") + (erase-buffer) + (insert doc) + (goto-char (point-min)) + (display-buffer (current-buffer))) + t))) + +(defun popup-item-show-help-with-event-loop (item) + (save-window-excursion + (when (popup-item-show-help-1 item) + (cl-loop do (clear-this-command-keys) + for key = (read-key-sequence-vector nil) + do + (cl-case (key-binding key) + (scroll-other-window + (scroll-other-window)) + (scroll-other-window-down + (scroll-other-window-down nil)) + (otherwise + (setq unread-command-events (append key unread-command-events)) + (cl-return))))))) + +(defun popup-item-show-help (item &optional persist) + "Display the documentation of ITEM with `display-buffer'. If +PERSIST is nil, the documentation buffer will be closed +automatically, meaning interal event loop ensures the buffer to +be closed. Otherwise, the buffer will be just displayed as +usual." + (when item + (if (not persist) + (popup-item-show-help-with-event-loop item) + (popup-item-show-help-1 item)))) + +(defun popup-set-list (popup list) + (popup-set-filtered-list popup list) + (setf (popup-pattern popup) nil) + (setf (popup-original-list popup) list)) + +(defun popup-set-filtered-list (popup list) + (let ((offset + (if (> (popup-direction popup) 0) + 0 + (max (- (popup-height popup) (length list)) 0)))) + (setf (popup-list popup) list + (popup-offset popup) offset))) + +(defun popup-selected-item (popup) + (nth (popup-cursor popup) (popup-list popup))) + +(defun popup-selected-line (popup) + (- (popup-cursor popup) (popup-scroll-top popup))) + +(defun popup-line-overlay (popup line) + (aref (popup-overlays popup) line)) + +(defun popup-selected-line-overlay (popup) + (popup-line-overlay popup (popup-selected-line popup))) + +(defun popup-hide-line (popup line) + (let ((overlay (popup-line-overlay popup line))) + (overlay-put overlay 'display nil) + (overlay-put overlay 'after-string nil))) + +(defun popup-line-hidden-p (popup line) + (let ((overlay (popup-line-overlay popup line))) + (and (eq (overlay-get overlay 'display) nil) + (eq (overlay-get overlay 'after-string) nil)))) + +(cl-defun popup-set-line-item (popup + line + &key + item + face + mouse-face + margin-left + margin-right + scroll-bar-char + symbol + summary + summary-face + keymap) + (let* ((overlay (popup-line-overlay popup line)) + (content (popup-create-line-string popup (popup-x-to-string item) + :margin-left margin-left + :margin-right margin-right + :symbol symbol + :summary summary + :summary-face summary-face)) + (start 0) + (prefix (overlay-get overlay 'prefix)) + (postfix (overlay-get overlay 'postfix)) + end) + (put-text-property 0 (length content) 'popup-item item content) + (put-text-property 0 (length content) 'keymap keymap content) + ;; Overlap face properties + (when (get-text-property start 'face content) + (setq start (next-single-property-change start 'face content))) + (while (and start (setq end (next-single-property-change start 'face content))) + (put-text-property start end 'face face content) + (setq start (next-single-property-change end 'face content))) + (when start + (put-text-property start (length content) 'face face content)) + (when mouse-face + (put-text-property 0 (length content) 'mouse-face mouse-face content)) + (unless (overlay-get overlay 'dangle) + (overlay-put overlay 'display (concat prefix (substring content 0 1))) + (setq prefix nil + content (concat (substring content 1)))) + (overlay-put overlay + 'after-string + (concat prefix + content + scroll-bar-char + postfix)))) + +(cl-defun popup-create-line-string (popup + string + &key + margin-left + margin-right + symbol + summary + summary-face) + (let* ((popup-width (popup-width popup)) + (summary-width (string-width summary)) + (content-width (max + (min popup-width (string-width string)) + (- popup-width + (if (> summary-width 0) + (+ summary-width 2) + 0)))) + (string (car (popup-substring-by-width string content-width))) + (string-width (string-width string)) + (spacing (max (- popup-width string-width summary-width) + (if (> popup-width string-width) 1 0))) + (truncated-summary + (car (popup-substring-by-width + summary (max (- popup-width string-width spacing) 0))))) + (when summary-face + (put-text-property 0 (length truncated-summary) + 'face summary-face truncated-summary)) + (concat margin-left + string + (make-string spacing ? ) + truncated-summary + symbol + margin-right))) + +(defun popup-live-p (popup) + "Return non-nil if POPUP is alive." + (and popup (popup-overlays popup) t)) + +(defun popup-child-point (popup &optional offset) + (overlay-end + (popup-line-overlay + popup + (or offset + (popup-selected-line popup))))) + +(defun popup-calculate-direction (height row) + "Return a proper direction when displaying a popup on this +window. HEIGHT is the a height of the popup, and ROW is a line +number at the point." + (let* ((remaining-rows (- (max 1 (- (window-height) + (if mode-line-format 1 0) + (if header-line-format 1 0))) + (count-lines (window-start) (point)))) + (enough-space-above (> row height)) + (enough-space-below (<= height remaining-rows))) + (if (and enough-space-above + (not enough-space-below)) + -1 + 1))) + +(cl-defun popup-create (point + width + height + &key + min-height + max-width + around + (face 'popup-face) + mouse-face + (selection-face face) + (summary-face 'popup-summary-face) + scroll-bar + margin-left + margin-right + symbol + parent + parent-offset + keymap) + "Create a popup instance at POINT with WIDTH and HEIGHT. + +MIN-HEIGHT is a minimal height of the popup. The default value is +0. + +MAX-WIDTH is the maximum width of the popup. The default value is +nil (no limit). If a floating point, the value refers to the ratio of +the window. If an integer, limit is in characters. + +If AROUND is non-nil, the popup will be displayed around the +point but not at the point. + +FACE is a background face of the popup. The default value is POPUP-FACE. + +SELECTION-FACE is a foreground (selection) face of the popup The +default value is POPUP-FACE. + +If SCROLL-BAR is non-nil, the popup will have a scroll bar at the +right. + +If MARGIN-LEFT is non-nil, the popup will have a margin at the +left. + +If MARGIN-RIGHT is non-nil, the popup will have a margin at the +right. + +SYMBOL is a single character which indicates a kind of the item. + +PARENT is a parent popup instance. If PARENT is omitted, the +popup will be a root instance. + +PARENT-OFFSET is a row offset from the parent popup. + +KEYMAP is a keymap that will be put on the popup contents." + (or margin-left (setq margin-left 0)) + (or margin-right (setq margin-right 0)) + (unless point + (setq point + (if parent (popup-child-point parent parent-offset) (point)))) + (when max-width + (setq width (min width (popup-calculate-max-width max-width)))) + (save-excursion + (goto-char point) + (let* ((row (line-number-at-pos)) + (column (popup-current-physical-column)) + (overlays (make-vector height nil)) + (popup-width (+ width + (if scroll-bar 1 0) + margin-left + margin-right + (if symbol 2 0))) + margin-left-cancel + (window (selected-window)) + (window-start (window-start)) + (window-hscroll (window-hscroll)) + (window-width (window-width)) + (right (+ column popup-width)) + (overflow (and (> right window-width) + (>= right popup-width))) + (foldable (and (null parent) + (>= column popup-width))) + (direction (or + ;; Currently the direction of cascade popup won't be changed + (and parent (popup-direction parent)) + + ;; Calculate direction + (popup-calculate-direction height row))) + (depth (if parent (1+ (popup-depth parent)) 0)) + (newlines (max 0 (+ (- height (count-lines point (point-max))) (if around 1 0)))) + current-column) + ;; Case: no newlines at the end of the buffer + (when (> newlines 0) + (popup-save-buffer-state + (goto-char (point-max)) + (insert (make-string newlines ?\n)))) + + ;; Case: the popup overflows + (if overflow + (if foldable + (progn + (cl-decf column (- popup-width margin-left margin-right)) + (unless around (move-to-column column))) + (when (not truncate-lines) + ;; Truncate. + (let ((d (1+ (- popup-width (- window-width column))))) + (cl-decf popup-width d) + (cl-decf width d))) + (cl-decf column margin-left)) + (cl-decf column margin-left)) + + ;; Case: no space at the left + (when (and (null parent) + (< column 0)) + ;; Cancel margin left + (setq column 0) + (cl-decf popup-width margin-left) + (setq margin-left-cancel t)) + + (dotimes (i height) + (let (overlay begin w (dangle t) (prefix "") (postfix "")) + (when around + (popup-vertical-motion column direction)) + (setq around t + current-column (popup-current-physical-column)) + + (when (> current-column column) + (backward-char) + (setq current-column (popup-current-physical-column))) + (when (< current-column column) + ;; Extend short buffer lines by popup prefix (line of spaces) + (setq prefix (make-string + (+ (if (= current-column 0) + (- window-hscroll (current-column)) + 0) + (- column current-column)) + ? ))) + + (setq begin (point)) + (setq w (+ popup-width (length prefix))) + (while (and (not (eolp)) (> w 0)) + (setq dangle nil) + (cl-decf w (char-width (char-after))) + (forward-char)) + (if (< w 0) + (setq postfix (make-string (- w) ? ))) + + (setq overlay (make-overlay begin (point))) + (overlay-put overlay 'window window) + (overlay-put overlay 'dangle dangle) + (overlay-put overlay 'prefix prefix) + (overlay-put overlay 'postfix postfix) + (overlay-put overlay 'width width) + (aset overlays + (if (> direction 0) i (- height i 1)) + overlay))) + (cl-loop for p from (- 10000 (* depth 1000)) + for overlay in (nreverse (append overlays nil)) + do (overlay-put overlay 'priority p)) + (let ((it (make-popup :point point + :row row + :column column + :width width + :height height + :min-height min-height + :direction direction + :parent parent + :depth depth + :face face + :mouse-face mouse-face + :selection-face selection-face + :summary-face summary-face + :margin-left margin-left + :margin-right margin-right + :margin-left-cancel margin-left-cancel + :scroll-bar scroll-bar + :symbol symbol + :cursor 0 + :offset 0 + :scroll-top 0 + :current-height 0 + :list nil + :newlines newlines + :overlays overlays + :keymap keymap))) + (push it popup-instances) + it)))) + +(defun popup-delete (popup) + "Delete POPUP instance." + (when (popup-live-p popup) + (popup-hide popup) + (mapc 'delete-overlay (popup-overlays popup)) + (setf (popup-overlays popup) nil) + (setq popup-instances (delq popup popup-instances)) + ;; Restore newlines state + (let ((newlines (popup-newlines popup))) + (when (> newlines 0) + (popup-save-buffer-state + (goto-char (point-max)) + (dotimes (i newlines) + (if (= (char-before) ?\n) + (delete-char -1))))))) + nil) + +(defun popup-draw (popup) + "Draw POPUP." + (cl-loop with height = (popup-height popup) + with min-height = (popup-min-height popup) + with popup-face = (popup-face popup) + with mouse-face = (popup-mouse-face popup) + with selection-face = (popup-selection-face popup) + with summary-face-0 = (popup-summary-face popup) + with list = (popup-list popup) + with length = (length list) + with thum-size = (max (/ (* height height) (max length 1)) 1) + with page-size = (/ (+ 0.0 (max length 1)) height) + with scroll-bar = (popup-scroll-bar popup) + with margin-left = (make-string (if (popup-margin-left-cancel popup) 0 (popup-margin-left popup)) ? ) + with margin-right = (make-string (popup-margin-right popup) ? ) + with symbol = (popup-symbol popup) + with cursor = (popup-cursor popup) + with scroll-top = (popup-scroll-top popup) + with offset = (popup-offset popup) + with keymap = (popup-keymap popup) + for o from offset + for i from scroll-top + while (< o height) + for item in (nthcdr scroll-top list) + for page-index = (* thum-size (/ o thum-size)) + for face = (if (= i cursor) + (or (popup-item-selection-face item) selection-face) + (or (popup-item-face item) popup-face)) + for summary-face = (unless (= i cursor) summary-face-0) + for empty-char = (propertize " " 'face face) + for scroll-bar-char = (if scroll-bar + (cond + ((and (not (eq scroll-bar :always)) + (<= page-size 1)) + empty-char) + ((and (> page-size 1) + (>= cursor (* page-index page-size)) + (< cursor (* (+ page-index thum-size) page-size))) + popup-scroll-bar-foreground-char) + (t + popup-scroll-bar-background-char)) + "") + for sym = (if symbol + (concat " " (or (popup-item-symbol item) " ")) + "") + for summary = (or (popup-item-summary item) "") + + do + ;; Show line and set item to the line + (popup-set-line-item popup o + :item item + :face face + :mouse-face mouse-face + :margin-left margin-left + :margin-right margin-right + :scroll-bar-char scroll-bar-char + :symbol sym + :summary summary + :summary-face summary-face + :keymap keymap) + + finally + ;; Remember current height + (setf (popup-current-height popup) (- o offset)) + + ;; Hide remaining lines + (let ((scroll-bar-char (if scroll-bar (propertize " " 'face popup-face) "")) + (symbol (if symbol " " ""))) + (if (> (popup-direction popup) 0) + (progn + (when min-height + (while (< o min-height) + (popup-set-line-item popup o + :item "" + :face popup-face + :margin-left margin-left + :margin-right margin-right + :scroll-bar-char scroll-bar-char + :symbol symbol + :summary "") + (cl-incf o))) + (while (< o height) + (popup-hide-line popup o) + (cl-incf o))) + (cl-loop with h = (if min-height (- height min-height) offset) + for o from 0 below offset + if (< o h) + do (popup-hide-line popup o) + if (>= o h) + do (popup-set-line-item popup o + :item "" + :face popup-face + :margin-left margin-left + :margin-right margin-right + :scroll-bar-char scroll-bar-char + :symbol symbol + :summary "")))))) + +(defun popup-hide (popup) + "Hide POPUP." + (dotimes (i (popup-height popup)) + (popup-hide-line popup i))) + +(defun popup-hidden-p (popup) + "Return non-nil if POPUP is hidden." + (let ((hidden t)) + (when (popup-live-p popup) + (dotimes (i (popup-height popup)) + (unless (popup-line-hidden-p popup i) + (setq hidden nil)))) + hidden)) + +(defun popup-jump (popup cursor) + "Jump to a position specified by CURSOR of POPUP and draw." + (let ((scroll-top (popup-scroll-top popup))) + ;; Do not change page as much as possible. + (unless (and (<= scroll-top cursor) + (< cursor (+ scroll-top (popup-height popup)))) + (setf (popup-scroll-top popup) cursor)) + (setf (popup-cursor popup) cursor) + (popup-draw popup))) + +(defun popup-select (popup i) + "Select the item at I of POPUP and draw." + (setq i (+ i (popup-offset popup))) + (when (and (<= 0 i) (< i (popup-height popup))) + (setf (popup-cursor popup) i) + (popup-draw popup) + t)) + +(defun popup-next (popup) + "Select the next item of POPUP and draw." + (let ((height (popup-height popup)) + (cursor (1+ (popup-cursor popup))) + (scroll-top (popup-scroll-top popup)) + (length (length (popup-list popup)))) + (cond + ((>= cursor length) + ;; Back to first page + (setq cursor 0 + scroll-top 0)) + ((= cursor (+ scroll-top height)) + ;; Go to next page + (setq scroll-top (min (1+ scroll-top) (max (- length height) 0))))) + (setf (popup-cursor popup) cursor + (popup-scroll-top popup) scroll-top) + (popup-draw popup))) + +(defun popup-previous (popup) + "Select the previous item of POPUP and draw." + (let ((height (popup-height popup)) + (cursor (1- (popup-cursor popup))) + (scroll-top (popup-scroll-top popup)) + (length (length (popup-list popup)))) + (cond + ((< cursor 0) + ;; Go to last page + (setq cursor (1- length) + scroll-top (max (- length height) 0))) + ((= cursor (1- scroll-top)) + ;; Go to previous page + (cl-decf scroll-top))) + (setf (popup-cursor popup) cursor + (popup-scroll-top popup) scroll-top) + (popup-draw popup))) + +(defun popup-page-next (popup) + "Select next item of POPUP per `popup-height' range. +Pages down through POPUP." + (dotimes (counter (1- (popup-height popup))) + (popup-next popup))) + +(defun popup-page-previous (popup) + "Select previous item of POPUP per `popup-height' range. +Pages up through POPUP." + (dotimes (counter (1- (popup-height popup))) + (popup-previous popup))) + +(defun popup-scroll-down (popup &optional n) + "Scroll down N of POPUP and draw." + (let ((scroll-top (min (+ (popup-scroll-top popup) (or n 1)) + (- (length (popup-list popup)) (popup-height popup))))) + (setf (popup-cursor popup) scroll-top + (popup-scroll-top popup) scroll-top) + (popup-draw popup))) + +(defun popup-scroll-up (popup &optional n) + "Scroll up N of POPUP and draw." + (let ((scroll-top (max (- (popup-scroll-top popup) (or n 1)) + 0))) + (setf (popup-cursor popup) scroll-top + (popup-scroll-top popup) scroll-top) + (popup-draw popup))) + + + +;;; Popup Incremental Search + +(defface popup-isearch-match + '((t (:background "sky blue"))) + "Popup isearch match face." + :group 'popup) + +(defvar popup-isearch-cursor-color "blue") + +(defvar popup-isearch-keymap + (let ((map (make-sparse-keymap))) + ;(define-key map "\r" 'popup-isearch-done) + (define-key map "\C-g" 'popup-isearch-cancel) + (define-key map "\C-b" 'popup-isearch-close) + (define-key map [left] 'popup-isearch-close) + (define-key map "\C-h" 'popup-isearch-delete) + (define-key map (kbd "DEL") 'popup-isearch-delete) + map)) + +(defvar popup-menu-show-quick-help-function 'popup-menu-show-quick-help + "Function used for showing quick help by `popup-menu*'.") + +(defsubst popup-isearch-char-p (char) + (and (integerp char) + (<= 32 char) + (<= char 126))) + +(defun popup-isearch-filter-list (pattern list) + (cl-loop with regexp = (regexp-quote pattern) + for item in list + do + (unless (stringp item) + (setq item (popup-item-propertize (popup-x-to-string item) + 'value item))) + if (string-match regexp item) + collect + (let ((beg (match-beginning 0)) + (end (match-end 0))) + (alter-text-property 0 (length item) 'face + (lambda (prop) + (unless (eq prop 'popup-isearch-match) + prop)) + item) + (put-text-property beg end + 'face 'popup-isearch-match + item) + item))) + +(defun popup-isearch-prompt (popup pattern) + (format "Pattern: %s" (if (= (length (popup-list popup)) 0) + (propertize pattern 'face 'isearch-fail) + pattern))) + +(defun popup-isearch-update (popup pattern &optional callback) + (setf (popup-cursor popup) 0 + (popup-scroll-top popup) 0 + (popup-pattern popup) pattern) + (let ((list (popup-isearch-filter-list pattern (popup-original-list popup)))) + (popup-set-filtered-list popup list) + (if callback + (funcall callback list))) + (popup-draw popup)) + +(cl-defun popup-isearch (popup + &key + (cursor-color popup-isearch-cursor-color) + (keymap popup-isearch-keymap) + callback + help-delay) + "Start isearch on POPUP. This function is synchronized, meaning +event loop waits for quiting of isearch. + +CURSOR-COLOR is a cursor color during isearch. The default value +is `popup-isearch-cursor-color'. + +KEYMAP is a keymap which is used when processing events during +event loop. The default value is `popup-isearch-keymap'. + +CALLBACK is a function taking one argument. `popup-isearch' calls +CALLBACK, if specified, after isearch finished or isearch +canceled. The arguments is whole filtered list of items. + +HELP-DELAY is a delay of displaying helps." + (let ((list (popup-original-list popup)) + (pattern (or (popup-pattern popup) "")) + (old-cursor-color (frame-parameter (selected-frame) 'cursor-color)) + prompt key binding) + (unwind-protect + (cl-block nil + (if cursor-color + (set-cursor-color cursor-color)) + (while t + (setq prompt (popup-isearch-prompt popup pattern)) + (setq key (popup-menu-read-key-sequence keymap prompt help-delay)) + (if (null key) + (unless (funcall popup-menu-show-quick-help-function popup nil :prompt prompt) + (clear-this-command-keys) + (push (read-event prompt) unread-command-events)) + (setq binding (lookup-key keymap key)) + (cond + ((and (stringp key) + (popup-isearch-char-p (aref key 0))) + (setq pattern (concat pattern key))) + ((eq binding 'popup-isearch-done) + (cl-return nil)) + ((eq binding 'popup-isearch-cancel) + (popup-isearch-update popup "" callback) + (cl-return t)) + ((eq binding 'popup-isearch-close) + (popup-isearch-update popup "" callback) + (setq unread-command-events + (append (listify-key-sequence key) unread-command-events)) + (cl-return nil)) + ((eq binding 'popup-isearch-delete) + (if (> (length pattern) 0) + (setq pattern (substring pattern 0 (1- (length pattern)))))) + (t + (setq unread-command-events + (append (listify-key-sequence key) unread-command-events)) + (cl-return nil))) + (popup-isearch-update popup pattern callback)))) + (if old-cursor-color + (set-cursor-color old-cursor-color))))) + + + +;;; Popup Tip + +(defface popup-tip-face + '((t (:background "khaki1" :foreground "black"))) + "Face for popup tip." + :group 'popup) + +(defvar popup-tip-max-width 80) + +(cl-defun popup-tip (string + &key + point + (around t) + width + (height 15) + min-height + max-width + truncate + margin + margin-left + margin-right + scroll-bar + parent + parent-offset + nowait + nostrip + prompt + &aux tip lines) + "Show a tooltip of STRING at POINT. This function is +synchronized unless NOWAIT specified. Almost arguments are same +as `popup-create' except for TRUNCATE, NOWAIT, and PROMPT. + +If TRUNCATE is non-nil, the tooltip can be truncated. + +If NOWAIT is non-nil, this function immediately returns the +tooltip instance without entering event loop. + +If `NOSTRIP` is non-nil, `STRING` properties are not stripped. + +PROMPT is a prompt string when reading events during event loop." + (if (bufferp string) + (setq string (with-current-buffer string (buffer-string)))) + + (unless nostrip + ;; TODO strip text (mainly face) properties + (setq string (substring-no-properties string))) + + (and (eq margin t) (setq margin 1)) + (or margin-left (setq margin-left margin)) + (or margin-right (setq margin-right margin)) + + (let ((it (popup-fill-string string width popup-tip-max-width))) + (setq width (car it) + lines (cdr it))) + + (setq tip (popup-create point width height + :min-height min-height + :max-width max-width + :around around + :margin-left margin-left + :margin-right margin-right + :scroll-bar scroll-bar + :face 'popup-tip-face + :parent parent + :parent-offset parent-offset)) + + (unwind-protect + (when (> (popup-width tip) 0) ; not to be corrupted + (when (and (not (eq width (popup-width tip))) ; truncated + (not truncate)) + ;; Refill once again to lines be fitted to popup width + (setq width (popup-width tip)) + (setq lines (cdr (popup-fill-string string width width)))) + + (popup-set-list tip lines) + (popup-draw tip) + (if nowait + tip + (clear-this-command-keys) + (push (read-event prompt) unread-command-events) + t)) + (unless nowait + (popup-delete tip)))) + + + +;;; Popup Menu + +(defface popup-menu-face + '((t (:inherit popup-face))) + "Face for popup menu." + :group 'popup) + +(defface popup-menu-mouse-face + '((t (:background "blue" :foreground "white"))) + "Face for popup menu." + :group 'popup) + +(defface popup-menu-selection-face + '((t (:background "steelblue" :foreground "white"))) + "Face for popup menu selection." + :group 'popup) + +(defface popup-menu-summary-face + '((t (:inherit popup-summary-face))) + "Face for popup summary." + :group 'popup) + +(defvar popup-menu-show-tip-function 'popup-tip + "Function used for showing tooltip by `popup-menu-show-quick-help'.") + +(defun popup-menu-show-help (menu &optional persist item) + (popup-item-show-help (or item (popup-selected-item menu)) persist)) + +(defun popup-menu-documentation (menu &optional item) + (popup-item-documentation (or item (popup-selected-item menu)))) + +(defun popup-menu-show-quick-help (menu &optional item &rest args) + (let* ((point (plist-get args :point)) + (height (or (plist-get args :height) (popup-height menu))) + (min-height (min height (popup-current-height menu))) + (around nil) + (parent-offset (popup-offset menu)) + (doc (popup-menu-documentation menu item))) + (when (stringp doc) + (if (popup-hidden-p menu) + (setq around t + menu nil + parent-offset nil) + (setq point nil)) + (let ((popup-use-optimized-column-computation nil)) ; To avoid wrong positioning + (apply popup-menu-show-tip-function + doc + :point point + :height height + :min-height min-height + :around around + :parent menu + :parent-offset parent-offset + args))))) + +(defun popup-menu-item-of-mouse-event (event) + (when (and (consp event) + (memq (cl-first event) '(mouse-1 mouse-2 mouse-3 mouse-4 mouse-5))) + (let* ((position (cl-second event)) + (object (elt position 4))) + (when (consp object) + (get-text-property (cdr object) 'popup-item (car object)))))) + +(defun popup-menu-read-key-sequence (keymap &optional prompt timeout) + (catch 'timeout + (let ((timer (and timeout + (run-with-timer timeout nil + (lambda () + (if (zerop (length (this-command-keys))) + (throw 'timeout nil)))))) + (old-global-map (current-global-map)) + (temp-global-map (make-sparse-keymap)) + (overriding-terminal-local-map (make-sparse-keymap))) + (substitute-key-definition 'keyboard-quit 'keyboard-quit + temp-global-map old-global-map) + (define-key temp-global-map [menu-bar] (lookup-key old-global-map [menu-bar])) + (define-key temp-global-map [tool-bar] (lookup-key old-global-map [tool-bar])) + (set-keymap-parent overriding-terminal-local-map keymap) + (if (current-local-map) + (define-key overriding-terminal-local-map [menu-bar] + (lookup-key (current-local-map) [menu-bar]))) + (unwind-protect + (progn + (use-global-map temp-global-map) + (clear-this-command-keys) + (with-temp-message prompt + (read-key-sequence nil))) + (use-global-map old-global-map) + (if timer (cancel-timer timer)))))) + +(defun popup-menu-fallback (event default)) + +(cl-defun popup-menu-event-loop (menu + keymap + fallback + &key + prompt + help-delay + isearch + isearch-cursor-color + isearch-keymap + isearch-callback + &aux key binding) + (cl-block nil + (while (popup-live-p menu) + (and isearch + (popup-isearch menu + :cursor-color isearch-cursor-color + :keymap isearch-keymap + :callback isearch-callback + :help-delay help-delay) + (keyboard-quit)) + (setq key (popup-menu-read-key-sequence keymap prompt help-delay)) + (setq binding (and key (lookup-key keymap key))) + (cond + ((or (null key) (zerop (length key))) + (unless (funcall popup-menu-show-quick-help-function menu nil :prompt prompt) + (clear-this-command-keys) + (push (read-event prompt) unread-command-events))) + ((eq (lookup-key (current-global-map) key) 'keyboard-quit) + (keyboard-quit) + (cl-return)) + ((eq binding 'popup-close) + (if (popup-parent menu) + (cl-return))) + ((memq binding '(popup-select popup-open)) + (let* ((item (or (popup-menu-item-of-mouse-event (elt key 0)) + (popup-selected-item menu))) + (index (cl-position item (popup-list menu))) + (sublist (popup-item-sublist item))) + (unless index (cl-return)) + (if sublist + (popup-aif (let (popup-use-optimized-column-computation) + (popup-cascade-menu sublist + :around nil + :margin-left (popup-margin-left menu) + :margin-right (popup-margin-right menu) + :scroll-bar (popup-scroll-bar menu) + :parent menu + :parent-offset index + :help-delay help-delay + :isearch isearch + :isearch-cursor-color isearch-cursor-color + :isearch-keymap isearch-keymap + :isearch-callback isearch-callback)) + (and it (cl-return it))) + (if (eq binding 'popup-select) + (cl-return (popup-item-value-or-self item)))))) + ((eq binding 'popup-next) + (popup-next menu)) + ((eq binding 'popup-previous) + (popup-previous menu)) + ((eq binding 'popup-page-next) + (popup-page-next menu)) + ((eq binding 'popup-page-previous) + (popup-page-previous menu)) + ((eq binding 'popup-help) + (popup-menu-show-help menu)) + ((eq binding 'popup-isearch) + (popup-isearch menu + :cursor-color isearch-cursor-color + :keymap isearch-keymap + :callback isearch-callback + :help-delay help-delay)) + ((commandp binding) + (call-interactively binding)) + (t + (funcall fallback key (key-binding key))))))) + +(defun popup-preferred-width (list) + "Return the preferred width to show LIST beautifully." + (cl-loop with tab-width = 4 + for item in list + for summary = (popup-item-summary item) + maximize (string-width (popup-x-to-string item)) into width + if (stringp summary) + maximize (+ (string-width summary) 2) into summary-width + finally return + (let ((total (+ (or width 0) (or summary-width 0)))) + (* (ceiling (/ total 10.0)) 10)))) + +(defvar popup-menu-keymap + (let ((map (make-sparse-keymap))) + (define-key map "\r" 'popup-select) + (define-key map "\C-f" 'popup-open) + (define-key map [right] 'popup-open) + (define-key map "\C-b" 'popup-close) + (define-key map [left] 'popup-close) + + (define-key map "\C-n" 'popup-next) + (define-key map [down] 'popup-next) + (define-key map "\C-p" 'popup-previous) + (define-key map [up] 'popup-previous) + + (define-key map [next] 'popup-page-next) + (define-key map [prior] 'popup-page-previous) + + (define-key map [f1] 'popup-help) + (define-key map (kbd "\C-?") 'popup-help) + + (define-key map "\C-s" 'popup-isearch) + + (define-key map [mouse-1] 'popup-select) + (define-key map [mouse-4] 'popup-previous) + (define-key map [mouse-5] 'popup-next) + map)) + +(cl-defun popup-menu* (list + &key + point + (around t) + (width (popup-preferred-width list)) + (height 15) + max-width + margin + margin-left + margin-right + scroll-bar + symbol + parent + parent-offset + cursor + (keymap popup-menu-keymap) + (fallback 'popup-menu-fallback) + help-delay + nowait + prompt + isearch + (isearch-cursor-color popup-isearch-cursor-color) + (isearch-keymap popup-isearch-keymap) + isearch-callback + &aux menu event) + "Show a popup menu of LIST at POINT. This function returns a +value of the selected item. Almost arguments are same as +`popup-create' except for KEYMAP, FALLBACK, HELP-DELAY, PROMPT, +ISEARCH, ISEARCH-CURSOR-COLOR, ISEARCH-KEYMAP, and +ISEARCH-CALLBACK. + +If KEYMAP is a keymap which is used when processing events during +event loop. + +If FALLBACK is a function taking two arguments; a key and a +command. FALLBACK is called when no special operation is found on +the key. The default value is `popup-menu-fallback', which does +nothing. + +HELP-DELAY is a delay of displaying helps. + +If NOWAIT is non-nil, this function immediately returns the menu +instance without entering event loop. + +PROMPT is a prompt string when reading events during event loop. + +If ISEARCH is non-nil, do isearch as soon as displaying the popup +menu. + +ISEARCH-CURSOR-COLOR is a cursor color during isearch. The +default value is `popup-isearch-cursor-color'. + +ISEARCH-KEYMAP is a keymap which is used when processing events +during event loop. The default value is `popup-isearch-keymap'. + +ISEARCH-CALLBACK is a function taking one argument. `popup-menu' +calls ISEARCH-CALLBACK, if specified, after isearch finished or +isearch canceled. The arguments is whole filtered list of items." + (and (eq margin t) (setq margin 1)) + (or margin-left (setq margin-left margin)) + (or margin-right (setq margin-right margin)) + (if (and scroll-bar + (integerp margin-right) + (> margin-right 0)) + ;; Make scroll-bar space as margin-right + (cl-decf margin-right)) + (setq menu (popup-create point width height + :max-width max-width + :around around + :face 'popup-menu-face + :mouse-face 'popup-menu-mouse-face + :selection-face 'popup-menu-selection-face + :summary-face 'popup-menu-summary-face + :margin-left margin-left + :margin-right margin-right + :scroll-bar scroll-bar + :symbol symbol + :parent parent + :parent-offset parent-offset)) + (unwind-protect + (progn + (popup-set-list menu list) + (if cursor + (popup-jump menu cursor) + (popup-draw menu)) + (if nowait + menu + (popup-menu-event-loop menu keymap fallback + :prompt prompt + :help-delay help-delay + :isearch isearch + :isearch-cursor-color isearch-cursor-color + :isearch-keymap isearch-keymap + :isearch-callback isearch-callback))) + (unless nowait + (popup-delete menu)))) + +(defun popup-cascade-menu (list &rest args) + "Same as `popup-menu' except that an element of LIST can be +also a sub-menu if the element is a cons cell formed (ITEM +. SUBLIST) where ITEM is an usual item and SUBLIST is a list of +the sub menu." + (apply 'popup-menu* + (mapcar (lambda (item) + (if (consp item) + (popup-make-item (car item) + :sublist (cdr item) + :symbol ">") + item)) + list) + :symbol t + args)) + +(provide 'popup) +;;; popup.el ends here -- 2.47.3