--- /dev/null
+;;; auto-complete-autoloads.el --- automatically extracted autoloads
+;;
+;;; Code:
+
+\f
+;;;### (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)
+
+;;;***
+\f
+;;;### (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)
+
+;;;***
+\f
+;;;### (autoloads nil nil ("auto-complete-pkg.el") (21446 8669 72090
+;;;;;; 0))
+
+;;;***
+\f
+(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
--- /dev/null
+;;; auto-complete-config.el --- auto-complete additional configuations
+
+;; Copyright (C) 2009, 2010 Tomohiro Matsuyama
+
+;; Author: Tomohiro Matsuyama <m2ym.pubNOSPAMgmail.com>
+;; 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 <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;;
+
+;;; Code:
+
+(eval-when-compile
+ (require 'cl))
+
+(require 'auto-complete)
+
+\f
+
+;;;; 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)))
+
+\f
+
+;;;; 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))))))
+
+\f
+
+;;;; 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
--- /dev/null
+(define-package "auto-complete" "20140618.2217" "Auto Completion for GNU Emacs"
+ '((popup "0.5.0")))
--- /dev/null
+;;; auto-complete.el --- Auto Completion for GNU Emacs
+
+;; Copyright (C) 2008, 2009, 2010, 2011, 2012, 2013 Tomohiro Matsuyama
+
+;; Author: Tomohiro Matsuyama <m2ym.pubNOSPAMgmail.com>
+;; 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 <http://www.gnu.org/licenses/>.
+
+;;; 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:
+
+\f
+
+(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))
+
+\f
+
+;;;; 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'.")
+
+\f
+
+;;;; 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)
+
+\f
+
+;;;; 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))))
+
+\f
+
+;;;; 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))))))
+
+\f
+
+;;;; 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)))
+
+\f
+
+;;;; 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))))
+
+\f
+
+;;;; 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))))
+
+\f
+
+;;;; 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))))
+
+\f
+
+;;;; 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)
+
+\f
+
+;;;; 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)))
+
+\f
+
+;;;; 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
--- /dev/null
+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
--- /dev/null
+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
--- /dev/null
+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
--- /dev/null
+# 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
+||
+~
+~+
+~+.
+~-
+~-.
--- /dev/null
+*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
--- /dev/null
+*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
--- /dev/null
+# 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
--- /dev/null
+!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
--- /dev/null
+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
--- /dev/null
+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
--- /dev/null
+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
--- /dev/null
+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
--- /dev/null
+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
--- /dev/null
+and
+break
+do
+else
+elseif
+end
+false
+for
+function
+if
+in
+local
+nil
+not
+or
+repeat
+return
+then
+true
+until
+while
--- /dev/null
+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
--- /dev/null
+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
--- /dev/null
+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
--- /dev/null
+$!
+$"
+$$
+$&
+$'
+$*
+$+
+$,
+$-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
--- /dev/null
+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-ci>=?
+char-ci>?
+char-downcase
+char-lower-case?
+char-numeric?
+char-ready?
+char-upcase
+char-upper-case?
+char-whitespace?
+char<=?
+char<?
+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-ci>=?
+string-ci>?
+string-copy
+string-fill!
+string-length
+string-ref
+string-set!
+string<=?
+string<?
+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!
--- /dev/null
+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
--- /dev/null
+# 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
--- /dev/null
+after\r
+append\r
+apply\r
+array\r
+auto_execok\r
+auto_import\r
+auto_load\r
+auto_load_index\r
+auto_mkindex\r
+auto_mkindex_old\r
+auto_qualify\r
+auto_reset\r
+bell\r
+binary\r
+bind\r
+bindtags\r
+break\r
+button\r
+canvas\r
+case\r
+catch\r
+cd\r
+chan\r
+checkbutton\r
+clipboard\r
+clock\r
+close\r
+concat\r
+continue\r
+destroy\r
+dict\r
+encoding\r
+entry\r
+eof\r
+error\r
+eval\r
+event\r
+exec\r
+exit\r
+expr\r
+fblocked\r
+fconfigure\r
+fcopy\r
+file\r
+fileevent\r
+flush\r
+focus\r
+font\r
+for\r
+foreach\r
+format\r
+frame\r
+gets\r
+glob\r
+global\r
+grab\r
+grid\r
+if\r
+image\r
+incr\r
+info\r
+interp\r
+join\r
+label\r
+labelframe\r
+lappend\r
+lassign\r
+lindex\r
+linsert\r
+list\r
+listbox\r
+llength\r
+load\r
+lower\r
+lrange\r
+lrepeat\r
+lreplace\r
+lreverse\r
+lsearch\r
+lset\r
+lsort\r
+menu\r
+menubutton\r
+message\r
+namespace\r
+open\r
+option\r
+pack\r
+package\r
+panedwindow\r
+pid\r
+pkg_mkIndex\r
+place\r
+proc\r
+puts\r
+pwd\r
+radiobutton\r
+raise\r
+read\r
+regexp\r
+registry\r
+regsub\r
+rename\r
+return\r
+scale\r
+scan\r
+scrollbar\r
+seek\r
+selection\r
+set\r
+socket\r
+source\r
+spinbox\r
+split\r
+string\r
+subst\r
+switch\r
+tclLog\r
+tclPkgSetup\r
+tclPkgUnknown\r
+tcl_findLibrary\r
+tell\r
+text\r
+time\r
+tk\r
+tk_chooseColor\r
+tk_chooseDirectory\r
+tk_getOpenFile\r
+tk_getSaveFile\r
+tk_menuSetFocus\r
+tk_messageBox\r
+tk_popup\r
+tk_textCopy\r
+tk_textCut\r
+tk_textPaste\r
+tkwait\r
+toplevel\r
+ttk::button\r
+ttk::checkbutton\r
+ttk::combobox\r
+ttk::entry\r
+ttk::focusFirst\r
+ttk::frame\r
+ttk::label\r
+ttk::labelframe\r
+ttk::menubutton\r
+ttk::notebook\r
+ttk::paned\r
+ttk::panedwindow\r
+ttk::progressbar\r
+ttk::radiobutton\r
+ttk::scale\r
+ttk::scrollbar\r
+ttk::separator\r
+ttk::setTheme\r
+ttk::sizegrip\r
+ttk::style\r
+ttk::takefocus\r
+ttk::themes\r
+ttk::treeview\r
+trace\r
+unknown\r
+unload\r
+unset\r
+update\r
+uplevel\r
+upvar\r
+variable\r
+vwait\r
+while\r
+winfo\r
+wm\r
--- /dev/null
+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
--- /dev/null
+# 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
+||
+~
+~+
+~+.
+~-
+~-.
--- /dev/null
+`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
--- /dev/null
+You can install this by (require 'auto-complete-auctex).
+Feel free to contribute better documentation!
--- /dev/null
+(require 'auto-complete-c-headers)
+(add-to-list 'ac-sources 'ac-source-c-headers)
--- /dev/null
+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"))))
--- /dev/null
+Auto Completion source for clang.
+Uses a "completion server" process to utilize libclang.
+Also provides flymake syntax checking.
--- /dev/null
+Auto Completion source for clang. Most of codes are taken from
+company-clang.el and modified and enhanced for Auto Completion.
--- /dev/null
+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.
--- /dev/null
+This extension provides completion by auto-complete.el on nXML-mode.
+About auto-complete.el, see <https://github.com/auto-complete/auto-complete>.
--- /dev/null
+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!
--- /dev/null
+Usage:
+ (eval-after-load "rst" '(auto-complete-rst-init))
--- /dev/null
+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.
--- /dev/null
+;;; popup-autoloads.el --- automatically extracted autoloads
+;;
+;;; Code:
+
+\f
+;;;### (autoloads nil nil ("popup-pkg.el" "popup.el") (21446 8667
+;;;;;; 508939 0))
+
+;;;***
+\f
+(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
--- /dev/null
+(define-package "popup" "20140207.1702" "Visual Popup User Interface" (quote ((cl-lib "0.3"))))
--- /dev/null
+;;; popup.el --- Visual Popup User Interface
+
+;; Copyright (C) 2009, 2010, 2011, 2012, 2013 Tomohiro Matsuyama
+
+;; Author: Tomohiro Matsuyama <tomoNOSPAMcx4a.org>
+;; 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 <http://www.gnu.org/licenses/>.
+
+;;; 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")
+
+\f
+
+;;; 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))))))))
+
+\f
+
+;;; 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)))
+
+\f
+
+;;; 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)))))
+
+\f
+
+;;; 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))))
+
+\f
+
+;;; 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
projects / emacsconfig.git / commitdiff