;;;; -*- mode: emacs-lisp; coding: utf-8 -*-
;;;;****************************************************************************
;;;;FILE: pjb-cl-face.el
;;;;LANGUAGE: emacs lisp
;;;;SYSTEM: POSIX
;;;;USER-INTERFACE: NONE
;;;;DESCRIPTION
;;;;
;;;; Defines font-lock faces for COMMON-LISP symbols.
;;;;
;;;;AUTHORS
;;;; <PJB> Pascal Bourguignon <pjb@informatimago.com>
;;;;MODIFICATIONS
;;;; 2004-01-26 <PJB> Created.
;;;;BUGS
;;;;LEGAL
;;;; GPL
;;;;
;;;; Copyright Pascal Bourguignon 2004 - 2011
;;;;
;;;; This program is free software; you can redistribute it and/or
;;;; modify it under the terms of the GNU General Public License
;;;; as published by the Free Software Foundation; either version
;;;; 2 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, write to the Free
;;;; Software Foundation, Inc., 59 Temple Place, Suite 330,
;;;; Boston, MA 02111-1307 USA
;;;;****************************************************************************
(require 'font-lock)
(require 'custom)
(require 'lisp-mode)
(require 'cc-engine)
(require 'pjb-cl)
(require 'pjb-sources)
;; font-lock-builtin-face
;; font-lock-comment-face
;; font-lock-constant-face
;; font-lock-doc-face
;; font-lock-function-name-face
;; font-lock-keyword-face
;; font-lock-string-face
;; font-lock-type-face
;; font-lock-variable-name-face
;; font-lock-warning-face
;;; (mapcar
;;; (lambda (kind)
;;; (insert (format "%S\n"
;;; (list kind
;;; (intern
;;; (concatenate 'string
;;; "font-lock-cl-"
;;; (replace-regexp-in-string
;;; " " "-" (string-downcase kind))
;;; "-face"))
;;; '(spec tty glight gdark clight cdark default)))))
;;; (delete-duplicates (mapcar (function second) *common-lisp-symbols*)
;;; :test (function string=)))
(defmacro ident-list (&rest args)
`(list ,@(mapcar (lambda (x) (list 'quote x)) args))
) ;;ident-list
(defmacro spec (tty gray-light gray-dark color-light color-dark default)
`(ident-list
(((type tty) (class color)) ,tty)
(((class grayscale) (background light)) ,gray-light)
(((class grayscale) (background dark)) ,gray-dark)
(((class color) (background light)) ,color-light)
(((class color) (background dark)) ,color-dark)
(t ,default))
) ;;spec
;; :family :width :height
;; :weight :slant :underline :overline :strike-through :box
;; :foreground :background :stipple :inverse-video :inherit
;; cyan blue
;; magenta red
;; yellow green
;; white black
(defmacro kf-kind (x) `(first ,x))
(defmacro kf-lock (x) `(second ,x))
(defmacro kf-face (x) `(third ,x))
(defmacro kf-spec (x) `(fourth ,x))
(defparameter *kind-to-face-map*
`(
;; ("Comment"
;; (;;pjb-cl$find-comment
;; ("\\(\\(;.*$\\)\\|\\(#|\\(\n\\|.\\)*?|#\\)\\)"
;; (0 font-lock-cl-comment-face t))
;; font-lock-cl-comment-face
;; ,(spec (:foreground "green")
;; (:foreground "DimGray" :slant italic)
;; (:foreground "LightGray" :slant italic)
;; (:foreground "coral" :slant italic)
;; (:foreground "coral" :slant italic)
;; ()))
;; ("String"
;; (pjb-cl$find-string
;; (0 font-lock-cl-string-face t))
;; font-lock-cl-string-face
;; ,(spec (:foreground "green")
;; (:foreground "DimGray" :slant italic)
;; (:foreground "LightGray" :slant italic)
;; (:foreground "SeaGreen3" :slant italic)
;; (:foreground "SeaGreen3" :slant italic)
;; ()))
("Warning"
nil
font-lock-cl-warning-face
,(spec (:underline nil :bold t :foreground "red" :bold t)
(:underline nil :bold t :foreground "DimGray" :bold t)
(:underline nil :bold t :foreground "LightGray" :bold t)
(:underline nil :bold t :foreground "Red" :bold t)
(:underline nil :bold t :foreground "Red" :bold t)
(:underline nil :bold t )))
("Variable"
nil
font-lock-cl-variable-face
,(spec (:underline nil :bold t :foreground "yellow")
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "goldenrod")
(:underline nil :bold t :foreground "goldenrod")
(:underline nil :bold t )))
("Constant Variable"
nil
font-lock-cl-constant-variable-face
,(spec (:underline nil :bold t :foreground "yellow")
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "gold" :bold t)
(:underline nil :bold t :foreground "gold" :bold t)
(:underline nil :bold t )))
("Symbol"
nil
font-lock-cl-symbol-face
,(spec (:underline nil :bold t :foreground "green")
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "ForestGreen")
(:underline nil :bold t :foreground "LimeGreen")
(:underline nil :bold t )))
;; ("Pipe-Symbol"
;; (pjb-cl$find-symbol
;; (0 font-lock-cl-symbol-face t))
;; font-lock-cl-symbol-face
;; ,(spec (:underline nil :bold t :foreground "green")
;; (:underline nil :bold t :foreground "DimGray")
;; (:underline nil :bold t :foreground "LightGray")
;; (:underline nil :bold t :foreground "ForestGreen")
;; (:underline nil :bold t :foreground "LimeGreen")
;; (:underline nil :bold t )))
("System Class"
nil
font-lock-cl-system-class-face
,(spec (:underline nil :bold t :foreground "green")
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "LightSeaGreen" :bold t)
(:underline nil :bold t :foreground "LightSeaGreen" :bold t)
(:underline nil :bold t )))
("Class"
nil
font-lock-cl-class-face
,(spec (:underline nil :bold t :foreground "green")
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "LightSeaGreen")
(:underline nil :bold t :foreground "LightSeaGreen")
(:underline nil :bold t )))
("Condition Type"
nil
font-lock-cl-condition-type-face
,(spec (:underline nil :bold t :foreground "green")
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "DarkKhaki")
(:underline nil :bold t :foreground "GreenYellow")
(:underline nil :bold t )))
("Type"
nil
font-lock-cl-type-face
,(spec (:underline nil :bold t :foreground "green")
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "MediumSeaGreen")
(:underline nil :bold t :foreground "MediumSeaGreen")
(:underline nil :bold t )))
("Type Specifier"
nil
font-lock-cl-type-specifier-face
,(spec (:underline nil :bold t :foreground "green")
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "MediumSeaGreen")
(:underline nil :bold t :foreground "MediumSeaGreen")
(:underline nil :bold t )))
("Declaration"
nil
font-lock-cl-declaration-face
,(spec (:underline nil :bold t :foreground "red")
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "DeepPink" :bold t)
(:underline nil :bold t :foreground "DeepPink" :bold t)
(:underline nil :bold t )))
("Restart"
nil
font-lock-cl-restart-face
,(spec (:underline nil :bold t :foreground "magenta")
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "purple")
(:underline nil :bold t :foreground "purple")
(:underline nil :bold t )))
("Special Operator"
nil
font-lock-cl-special-operator-face
,(spec (:underline nil :bold t :foreground "blue" :bold t)
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "BlueViolet")
(:underline nil :bold t :foreground "BlueViolet")
(:underline nil :bold t )))
("Special Form"
nil
font-lock-cl-special-form-face
,(spec (:underline nil :bold t :foreground "blue" :bold t)
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "BlueViolet")
(:underline nil :bold t :foreground "BlueViolet")
(:underline nil :bold t )))
("Local Macro"
nil
font-lock-cl-local-macro-face
,(spec (:underline nil :bold t :foreground "blue" :bold t)
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "orchid")
(:underline nil :bold t :foreground "plum")
(:underline nil :bold t )))
("Macro"
nil
font-lock-cl-macro-face
,(spec (:underline nil :bold t :foreground "blue" :bold t)
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "maroon")
(:underline nil :bold t :foreground "PaleVioletRed")
(:underline nil :bold t )))
("Accessor"
nil
font-lock-cl-accessor-face
,(spec (:underline nil :bold t :foreground "blue")
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "CadetBlue")
(:underline nil :bold t :foreground "DarkTurquoise")
(:underline nil :bold t )))
("Local Function"
nil
font-lock-cl-local-function-face
,(spec (:underline nil :bold t :foreground "blue")
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "SlateBlue")
(:underline nil :bold t :foreground "LightBlue")
(:underline nil :bold t )))
("Standard Generic Function"
nil
font-lock-cl-standard-generic-function-face
,(spec (:underline nil :bold t :foreground "blue")
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "MediumBlue" :bold t)
(:underline nil :bold t :foreground "CornflowerBlue" :bold t)
(:underline nil :bold t )))
("Function"
nil
font-lock-cl-function-face
,(spec (:underline nil :bold t :foreground "blue")
(:underline nil :bold t :foreground "DimGray")
(:underline nil :bold t :foreground "LightGray")
(:underline nil :bold t :foreground "MediumBlue")
(:underline nil :bold t :foreground "CornflowerBlue")
(:underline nil :bold t )))
("Keyword" ;; from the KEYWORD package
("\\(\\<:\\sw\\sw+\\>\\)"
(0 font-lock-cl-keyword-face t))
font-lock-cl-keyword-face
,(spec (:foreground "magenta")
(:foreground "DimGray" :bold t)
(:foreground "LightGray" :bold t)
(:foreground "Magenta")
(:foreground "Magenta")
()))
) ;;*kind-to-face-map*
) ;;*kind-to-face-map*
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; (defvar pjb-cl$*state*)
;;; (make-local-variable 'pjb-cl$*state*)
;;; (defmacro clfss-modified (x) `(first ,x))
;;; (defmacro clfss-strings (x) `(second ,x))
;;; (defmacro clfss-symbols (x) `(third ,x))
;;; (defmacro clfss-comments (x) `(fourth ,x))
;;; (defun pjb-cl$rla (list)
;;; (make-array (list (length list)) :initial-contents (nreverse list))
;;; );;pjb-cl$rla
;;; (defun pjb-cl$update-cache ()
;;; (when (or (not (boundp 'pjb-cl$*state*)) (null pjb-cl$*state*))
;;; (setf pjb-cl$*state* (list 0 nil nil nil)))
;;; (when (/= (clfss-modified pjb-cl$*state*) (buffer-modified-tick))
;;; (save-excursion
;;; (goto-char (point-min))
;;; (do ((state :out)
;;; (level 0)
;;; (strings '())
;;; (symbols '())
;;; (comments '())
;;; (start))
;;; ((>= (point) (point-max))
;;; (setf (clfss-modified pjb-cl$*state*) (buffer-modified-tick)
;;; (clfss-strings pjb-cl$*state*) (pjb-cl$rla strings)
;;; (clfss-symbols pjb-cl$*state*) (pjb-cl$rla symbols)
;;; (clfss-comments pjb-cl$*state*) (pjb-cl$rla comments)))
;;; (case state
;;; ((:out)
;;; (cond
;;; ((looking-at "\\\\."))
;;; ((looking-at ";.*$")
;;; (push (cons (match-beginning 0) (match-end 0)) comments))
;;; ((looking-at "\\(\"\\([^\"]\\|\\\\\"\\)*?\"\\)")
;;; (push (cons (match-beginning 0) (match-end 0)) strings))
;;; ((looking-at "\\(|\\([^|]\\|\\\\.\\)*?|\\)")
;;; (push (cons (match-beginning 0) (match-end 0)) symbols))
;;; ((looking-at "#|")
;;; (setf state :sharp-comment level (1+ level)
;;; start (match-beginning 0)))
;;; ((looking-at "\\([^;#|\"\\\\]\\|#[^;#|\"\\\\]\\)*"))
;;; ((looking-at "."))))
;;; ((:sharp-comment)
;;; (cond
;;; ((looking-at "#|")
;;; (setf state :sharp-comment level (1+ level))
;;; (goto-char (match-end 0)))
;;; ((looking-at "|#")
;;; (decf level)
;;; (when (= 0 level)
;;; (push (cons start (match-end 0)) comments)
;;; (setf state :out))
;;; (goto-char (match-end 0)))
;;; ((looking-at "\\([^#|]*\\|#[^#|]\\||[^#|]\\)*"))
;;; ((looking-at ".")))))
;;; (goto-char (match-end 0)))))
;;; );;pjb-cl$update-cache
;; dichotomy (vector value compare &optional start end key)
;; PRE: entry is the element to be searched in the table.
;; (<= start end)
;; RETURN: (values found index order)
;; POST: (<= start index end)
;; +-------------------+----------+-------+----------+----------------+
;; | Case | found | index | order | Error |
;; +-------------------+----------+-------+----------+----------------+
;; | x < a[min] | FALSE | min | less | 0 |
;; | a[i] < x < a[i+1] | FALSE | i | greater | 0 |
;; | x = a[i] | TRUE | i | equal | 0 |
;; | a[max] < x | FALSE | max | greater | 0 |
;; +-------------------+----------+-------+----------+----------------+
;;; (defun pjb-cl$find-in-cache (min max cache)
;;; (multiple-value-bind (found index order)
;;; (dichotomy cache min (lambda (a b) (cond ((< a b) -1)
;;; ((= a b) 0)
;;; (t 1)))
;;; 0 (length cache) (function car))
;;; (let ((se))
;;; (cond
;;; ((< order 0) (setf se (aref cache 0)))
;;; ((= index max) (setf se nil))
;;; (t (if (<= (cdr (aref cache index)) min)
;;; (setf se nil)
;;; (setf se (aref cache index)))))
;;; (if se
;;; (let ((range (- (cdr se) (car se))))
;;; (goto-char (car se))
;;; (re-search-forward (format ".{%d,%d}" (- (cdr se) (car se)))))
;;; (re-search-forward (format ".{%d}" (1+ (buffer-size)))))))
;;; );;pjb-cl$find-in-cache
(defstruct fo-cache
limit kind found start end)
(defvar *fo-cache* (make-fo-cache))
(defvar *fo-cache-counter-match* 0)
(defvar *fo-cache-counter-miss* 0)
(defun fo-cache (limit kind)
(if (and (equal limit (fo-cache-limit *fo-cache*))
(equal kind (fo-cache-kind *fo-cache*)))
(progn (incf *fo-cache-counter-match*)
(if (fo-cache-found *fo-cache*)
(progn
(goto-char (fo-cache-start *fo-cache*))
(looking-at (format ".{%d}" (- (fo-cache-end *fo-cache*)
(fo-cache-start *fo-cache*))))
(values t t))
(values t nil)))
(progn
(incf *fo-cache-counter-miss*)
(values nil nil)))) ;;fo-cache
(defun fo-put-in-cache (limit kind found start end)
(setf (fo-cache-limit *fo-cache*) limit
(fo-cache-kind *fo-cache*) kind
(fo-cache-found *fo-cache*) found
(fo-cache-start *fo-cache*) start
(fo-cache-end *fo-cache*) end)) ;;fo-put-in-cache
(defun pjb-cl$find-object (limit kind)
(multiple-value-bind (in-cache result) (fo-cache limit kind)
(if in-cache
result
(progn
(garbage-collect)
(message "pjb-cl$find-object %S %S" limit kind)
(do ((state :out)
(from (point))
(level 0)
(start)
(found nil)
(done nil))
(done
(progn
(message "pjb-cl$find-object done found=%S" found)
(fo-put-in-cache limit kind found
(if found (match-beginning 0) from)
(if found (match-end 0) from))
(unless found
;; we must reset the matches
(goto-char from)
(looking-at (regexp-quote
(buffer-substring-no-properties from (1+ from)))))
found))
(case state
((:out)
(cond
((looking-at "\\\\."))
((looking-at ";.*$")
(when (eq kind 'comment) (setf done t found t)))
((looking-at "\\(\"\\([^\\\\\"]\\|\\\\\.\\)*?\"\\)")
(when (eq kind 'string) (setf done t found t)))
((looking-at "\\(|\\([^|]\\|\\\\.\\)*?|\\)")
(when (eq kind 'symbol) (setf done t found t)))
((looking-at "#|")
(setf state :sharp-comment level (1+ level)
start (match-beginning 0)))
((looking-at "\\([^;#|\"\\\\]\\|#[^;#|\"\\\\]\\)*"))
((looking-at ".")))
(goto-char (match-end 0))
(setf done (or done (<= limit (point)))))
((:sharp-comment)
(cond
((looking-at "#|")
(setf state :sharp-comment level (1+ level))
(goto-char (match-end 0)))
((looking-at "|#")
(decf level)
(when (= 0 level)
(goto-char start)
(looking-at (format ".{%d}" (- (match-end 0) start)))
(setf done t found t))
(goto-char (match-end 0)))
((looking-at "\\([^#|]*\\|#[^#|]\\||[^#|]\\)*"))
((looking-at ".")))
(goto-char (match-end 0))
(setf done (or done (<= (point-max) (point)))))))
)))) ;;pjb-cl$find-object
(defun pjb-cl$find-string (limit)
(pjb-cl$find-object limit 'string)
;; (pjb-cl$update-cache)
;; (pjb-cl$find-in-cache (point) limit (clfss-strings pjb-cl$*state*))
) ;;pjb-cl$find-string
(defun pjb-cl$find-symbol (limit)
(pjb-cl$find-object limit 'symbol)
;; (pjb-cl$update-cache)
;; (pjb-cl$find-in-cache (point) limit (clfss-symbols pjb-cl$*state*))
) ;;pjb-cl$find-symbol
(defun pjb-cl$find-comment (limit)
(pjb-cl$find-object limit 'comment)
;; (pjb-cl$update-cache)
;; (pjb-cl$find-in-cache (point) limit (clfss-comments pjb-cl$*state*))
) ;;pjb-cl$find-comment
(custom-declare-group
'common-lisp-faces
(mapcar (lambda (kf) (list (kf-face kf) 'custom-face)) *kind-to-face-map*)
"COMMON-LISP Faces"
:group 'faces)
(map nil
(lambda (kf)
(let ((kind (kf-kind kf))
(face (kf-face kf))
(spec (kf-spec kf)) )
(set face face)
(custom-declare-face
face spec
(format "Face for COMMON-LISP %s." kind)
:group 'common-lisp-faces)))
*kind-to-face-map*)
(defparameter *common-lisp-symbols*
'(
(* "Function")
(* "Variable")
(** "Variable")
(*** "Variable")
(*BREAK-ON-SIGNALS* "Variable")
(*COMPILE-FILE-PATHNAME* "Variable")
(*COMPILE-FILE-TRUENAME* "Variable")
(*COMPILE-PRINT* "Variable")
(*COMPILE-VERBOSE* "Variable")
(*DEBUG-IO* "Variable")
(*DEBUGGER-HOOK* "Variable")
(*DEFAULT-PATHNAME-DEFAULTS* "Variable")
(*ERROR-OUTPUT* "Variable")
(*FEATURES* "Variable")
(*GENSYM-COUNTER* "Variable")
(*LOAD-PATHNAME* "Variable")
(*LOAD-PRINT* "Variable")
(*LOAD-TRUENAME* "Variable")
(*LOAD-VERBOSE* "Variable")
(*MACROEXPAND-HOOK* "Variable")
(*MODULES* "Variable")
(*PACKAGE* "Variable")
(*PRINT-ARRAY* "Variable")
(*PRINT-BASE* "Variable")
(*PRINT-CASE* "Variable")
(*PRINT-CIRCLE* "Variable")
(*PRINT-ESCAPE* "Variable")
(*PRINT-GENSYM* "Variable")
(*PRINT-LENGTH* "Variable")
(*PRINT-LEVEL* "Variable")
(*PRINT-LINES* "Variable")
(*PRINT-MISER-WIDTH* "Variable")
(*PRINT-PPRINT-DISPATCH* "Variable")
(*PRINT-PRETTY* "Variable")
(*PRINT-RADIX* "Variable")
(*PRINT-READABLY* "Variable")
(*PRINT-RIGHT-MARGIN* "Variable")
(*QUERY-IO* "Variable")
(*RANDOM-STATE* "Variable")
(*READ-BASE* "Variable")
(*READ-DEFAULT-FLOAT-FORMAT* "Variable")
(*READ-EVAL* "Variable")
(*READ-SUPPRESS* "Variable")
(*READTABLE* "Variable")
(*STANDARD-INPUT* "Variable")
(*STANDARD-OUTPUT* "Variable")
(*TERMINAL-IO* "Variable")
(*TRACE-OUTPUT* "Variable")
(+ "Function")
(+ "Variable")
(++ "Variable")
(+++ "Variable")
(- "Function")
(- "Variable")
(/ "Function")
(/ "Variable")
(// "Variable")
(/// "Variable")
(/= "Function")
(1+ "Function")
(1- "Function")
(< "Function")
(<= "Function")
(= "Function")
(> "Function")
(>= "Function")
(ABORT "Function")
(ABORT "Restart")
(ABS "Function")
(ACONS "Function")
(ACOS "Function")
(ACOSH "Function")
(ADD-METHOD "Standard Generic Function")
(ADJOIN "Function")
(ADJUST-ARRAY "Function")
(ADJUSTABLE-ARRAY-P "Function")
(ALLOCATE-INSTANCE "Standard Generic Function")
(ALPHA-CHAR-P "Function")
(ALPHANUMERICP "Function")
(AND "Macro")
(AND "Type Specifier")
(APPEND "Function")
(APPLY "Function")
(APROPOS "Function")
(APROPOS-LIST "Function")
(AREF "Accessor")
(ARITHMETIC-ERROR "Condition Type")
(ARITHMETIC-ERROR-OPERANDS "Function")
(ARITHMETIC-ERROR-OPERATION "Function")
(ARRAY "System Class")
(ARRAY-DIMENSION "Function")
(ARRAY-DIMENSION-LIMIT "Constant Variable")
(ARRAY-DIMENSIONS "Function")
(ARRAY-DISPLACEMENT "Function")
(ARRAY-ELEMENT-TYPE "Function")
(ARRAY-HAS-FILL-POINTER-P "Function")
(ARRAY-IN-BOUNDS-P "Function")
(ARRAY-RANK "Function")
(ARRAY-RANK-LIMIT "Constant Variable")
(ARRAY-ROW-MAJOR-INDEX "Function")
(ARRAY-TOTAL-SIZE "Function")
(ARRAY-TOTAL-SIZE-LIMIT "Constant Variable")
(ARRAYP "Function")
(ASH "Function")
(ASIN "Function")
(ASINH "Function")
(ASSERT "Macro")
(ASSOC "Function")
(ASSOC-IF "Function")
(ASSOC-IF-NOT "Function")
(ATAN "Function")
(ATANH "Function")
(ATOM "Function")
(ATOM "Type")
(BASE-CHAR "Type")
(BASE-STRING "Type")
(BIGNUM "Type")
(BIT "Accessor")
(BIT "Type")
(BIT-AND "Function")
(BIT-ANDC1 "Function")
(BIT-ANDC2 "Function")
(BIT-EQV "Function")
(BIT-IOR "Function")
(BIT-NAND "Function")
(BIT-NOR "Function")
(BIT-NOT "Function")
(BIT-ORC1 "Function")
(BIT-ORC2 "Function")
(BIT-VECTOR "System Class")
(BIT-VECTOR-P "Function")
(BIT-XOR "Function")
(BLOCK "Special Operator")
(BOOLE "Function")
(BOOLE-1 "Constant Variable")
(BOOLE-2 "Constant Variable")
(BOOLE-AND "Constant Variable")
(BOOLE-ANDC1 "Constant Variable")
(BOOLE-ANDC2 "Constant Variable")
(BOOLE-C1 "Constant Variable")
(BOOLE-C2 "Constant Variable")
(BOOLE-CLR "Constant Variable")
(BOOLE-EQV "Constant Variable")
(BOOLE-IOR "Constant Variable")
(BOOLE-NAND "Constant Variable")
(BOOLE-NOR "Constant Variable")
(BOOLE-ORC1 "Constant Variable")
(BOOLE-ORC2 "Constant Variable")
(BOOLE-SET "Constant Variable")
(BOOLE-XOR "Constant Variable")
(BOOLEAN "Type")
(BOTH-CASE-P "Function")
(BOUNDP "Function")
(BREAK "Function")
(BROADCAST-STREAM "System Class")
(BROADCAST-STREAM-STREAMS "Function")
(BUILT-IN-CLASS "System Class")
(BUTLAST "Function")
(BYTE "Function")
(BYTE-POSITION "Function")
(BYTE-SIZE "Function")
(CAAAAR "Accessor")
(CAAADR "Accessor")
(CAAAR "Accessor")
(CAADAR "Accessor")
(CAADDR "Accessor")
(CAADR "Accessor")
(CAAR "Accessor")
(CADAAR "Accessor")
(CADADR "Accessor")
(CADAR "Accessor")
(CADDAR "Accessor")
(CADDDR "Accessor")
(CADDR "Accessor")
(CADR "Accessor")
(CALL-ARGUMENTS-LIMIT "Constant Variable")
(CALL-METHOD "Local Macro")
(CALL-NEXT-METHOD "Local Function")
(CAR "Accessor")
(CASE "Macro")
(CATCH "Special Operator")
(CCASE "Macro")
(CDAAAR "Accessor")
(CDAADR "Accessor")
(CDAAR "Accessor")
(CDADAR "Accessor")
(CDADDR "Accessor")
(CDADR "Accessor")
(CDAR "Accessor")
(CDDAAR "Accessor")
(CDDADR "Accessor")
(CDDAR "Accessor")
(CDDDAR "Accessor")
(CDDDDR "Accessor")
(CDDDR "Accessor")
(CDDR "Accessor")
(CDR "Accessor")
(CEILING "Function")
(CELL-ERROR "Condition Type")
(CELL-ERROR-NAME "Function")
(CERROR "Function")
(CHANGE-CLASS "Standard Generic Function")
(CHAR "Accessor")
(CHAR-CODE "Function")
(CHAR-CODE-LIMIT "Constant Variable")
(CHAR-DOWNCASE "Function")
(CHAR-EQUAL "Function")
(CHAR-GREATERP "Function")
(CHAR-INT "Function")
(CHAR-LESSP "Function")
(CHAR-NAME "Function")
(CHAR-NOT-EQUAL "Function")
(CHAR-NOT-GREATERP "Function")
(CHAR-NOT-LESSP "Function")
(CHAR-UPCASE "Function")
(CHAR/= "Function")
(CHAR< "Function")
(CHAR<= "Function")
(CHAR= "Function")
(CHAR> "Function")
(CHAR>= "Function")
(CHARACTER "Function")
(CHARACTER "System Class")
(CHARACTERP "Function")
(CHECK-TYPE "Macro")
(CIS "Function")
(CLASS "System Class")
(CLASS-NAME "Standard Generic Function")
(CLASS-OF "Function")
(CLEAR-INPUT "Function")
(CLEAR-OUTPUT "Function")
(CLOSE "Function")
(CLRHASH "Function")
(CODE-CHAR "Function")
(COERCE "Function")
(COMPILE "Function")
(COMPILE-FILE "Function")
(COMPILE-FILE-PATHNAME "Function")
(COMPILED-FUNCTION "Type")
(COMPILED-FUNCTION-P "Function")
(COMPILER-MACRO-FUNCTION "Accessor")
(COMPLEMENT "Function")
(COMPLEX "Function")
(COMPLEX "System Class")
(COMPLEXP "Function")
(COMPUTE-APPLICABLE-METHODS "Standard Generic Function")
(COMPUTE-RESTARTS "Function")
(CONCATENATE "Function")
(CONCATENATED-STREAM "System Class")
(CONCATENATED-STREAM-STREAMS "Function")
(COND "Macro")
(CONDITION "Condition Type")
(CONJUGATE "Function")
(CONS "Function")
(CONS "System Class")
(CONSP "Function")
(CONSTANTLY "Function")
(CONSTANTP "Function")
(CONTINUE "Function")
(CONTINUE "Restart")
(CONTROL-ERROR "Condition Type")
(COPY-ALIST "Function")
(COPY-LIST "Function")
(COPY-PPRINT-DISPATCH "Function")
(COPY-READTABLE "Function")
(COPY-SEQ "Function")
(COPY-STRUCTURE "Function")
(COPY-SYMBOL "Function")
(COPY-TREE "Function")
(COS "Function")
(COSH "Function")
(COUNT "Function")
(COUNT-IF "Function")
(COUNT-IF-NOT "Function")
(CTYPECASE "Macro")
(DECF "Macro")
(DECLAIM "Macro")
(DECLARATION "Declaration")
(DECLARE "Symbol")
(DECODE-FLOAT "Function")
(DECODE-UNIVERSAL-TIME "Function")
(DEFCLASS "Macro")
(DEFCONSTANT "Macro")
(DEFGENERIC "Macro")
(DEFINE-COMPILER-MACRO "Macro")
(DEFINE-CONDITION "Macro")
(DEFINE-METHOD-COMBINATION "Macro")
(DEFINE-MODIFY-MACRO "Macro")
(DEFINE-SETF-EXPANDER "Macro")
(DEFINE-SYMBOL-MACRO "Macro")
(DEFMACRO "Macro")
(DEFMETHOD "Macro")
(DEFPACKAGE "Macro")
(DEFPARAMETER "Macro")
(DEFSETF "Macro")
(DEFSTRUCT "Macro")
(DEFTYPE "Macro")
(DEFUN "Macro")
(DEFVAR "Macro")
(DELETE "Function")
(DELETE-DUPLICATES "Function")
(DELETE-FILE "Function")
(DELETE-IF "Function")
(DELETE-IF-NOT "Function")
(DELETE-PACKAGE "Function")
(DENOMINATOR "Function")
(DEPOSIT-FIELD "Function")
(DESCRIBE "Function")
(DESCRIBE-OBJECT "Standard Generic Function")
(DESTRUCTURING-BIND "Macro")
(DIGIT-CHAR "Function")
(DIGIT-CHAR-P "Function")
(DIRECTORY "Function")
(DIRECTORY-NAMESTRING "Function")
(DISASSEMBLE "Function")
(DIVISION-BY-ZERO "Condition Type")
(DO "Macro")
(DO* "Macro")
(DO-ALL-SYMBOLS "Macro")
(DO-EXTERNAL-SYMBOLS "Macro")
(DO-SYMBOLS "Macro")
(DOCUMENTATION "Standard Generic Function")
(DOLIST "Macro")
(DOTIMES "Macro")
(DOUBLE-FLOAT "Type")
(DOUBLE-FLOAT-EPSILON "Constant Variable")
(DOUBLE-FLOAT-NEGATIVE-EPSILON "Constant Variable")
(DPB "Function")
(DRIBBLE "Function")
(DYNAMIC-EXTENT "Declaration")
(ECASE "Macro")
(ECHO-STREAM "System Class")
(ECHO-STREAM-INPUT-STREAM "Function")
(ECHO-STREAM-OUTPUT-STREAM "Function")
(ED "Function")
(EIGHTH "Accessor")
(ELT "Accessor")
(END-OF-FILE "Condition Type")
(ENDP "Function")
(ENOUGH-NAMESTRING "Function")
(ENSURE-DIRECTORIES-EXIST "Function")
(ENSURE-GENERIC-FUNCTION "Function")
(EQ "Function")
(EQL "Function")
(EQL "Type Specifier")
(EQUAL "Function")
(EQUALP "Function")
(ERROR "Condition Type")
(ERROR "Function")
(ETYPECASE "Macro")
(EVAL "Function")
(EVAL-WHEN "Special Operator")
(EVENP "Function")
(EVERY "Function")
(EXP "Function")
(EXPORT "Function")
(EXPT "Function")
(EXTENDED-CHAR "Type")
(FBOUNDP "Function")
(FCEILING "Function")
(FDEFINITION "Accessor")
(FFLOOR "Function")
(FIFTH "Accessor")
(FILE-AUTHOR "Function")
(FILE-ERROR "Condition Type")
(FILE-ERROR-PATHNAME "Function")
(FILE-LENGTH "Function")
(FILE-NAMESTRING "Function")
(FILE-POSITION "Function")
(FILE-STREAM "System Class")
(FILE-STRING-LENGTH "Function")
(FILE-WRITE-DATE "Function")
(FILL "Function")
(FILL-POINTER "Accessor")
(FIND "Function")
(FIND-ALL-SYMBOLS "Function")
(FIND-CLASS "Accessor")
(FIND-IF "Function")
(FIND-IF-NOT "Function")
(FIND-METHOD "Standard Generic Function")
(FIND-PACKAGE "Function")
(FIND-RESTART "Function")
(FIND-SYMBOL "Function")
(FINISH-OUTPUT "Function")
(FIRST "Accessor")
(FIXNUM "Type")
(FLET "Special Operator")
(FLOAT "Function")
(FLOAT "System Class")
(FLOAT-DIGITS "Function")
(FLOAT-PRECISION "Function")
(FLOAT-RADIX "Function")
(FLOAT-SIGN "Function")
(FLOATING-POINT-INEXACT "Condition Type")
(FLOATING-POINT-INVALID-OPERATION "Condition Type")
(FLOATING-POINT-OVERFLOW "Condition Type")
(FLOATING-POINT-UNDERFLOW "Condition Type")
(FLOATP "Function")
(FLOOR "Function")
(FMAKUNBOUND "Function")
(FORCE-OUTPUT "Function")
(FORMAT "Function")
(FORMATTER "Macro")
(FOURTH "Accessor")
(FRESH-LINE "Function")
(FROUND "Function")
(FTRUNCATE "Function")
(FTYPE "Declaration")
(FUNCALL "Function")
(FUNCTION "Special Operator")
(FUNCTION "System Class")
(FUNCTION-KEYWORDS "Standard Generic Function")
(FUNCTION-LAMBDA-EXPRESSION "Function")
(FUNCTIONP "Function")
(GCD "Function")
(GENERIC-FUNCTION "System Class")
(GENSYM "Function")
(GENTEMP "Function")
(GET "Accessor")
(GET-DECODED-TIME "Function")
(GET-DISPATCH-MACRO-CHARACTER "Function")
(GET-INTERNAL-REAL-TIME "Function")
(GET-INTERNAL-RUN-TIME "Function")
(GET-MACRO-CHARACTER "Function")
(GET-OUTPUT-STREAM-STRING "Function")
(GET-PROPERTIES "Function")
(GET-SETF-EXPANSION "Function")
(GET-UNIVERSAL-TIME "Function")
(GETF "Accessor")
(GETHASH "Accessor")
(GO "Special Operator")
(GRAPHIC-CHAR-P "Function")
(HANDLER-BIND "Macro")
(HANDLER-CASE "Macro")
(HASH-TABLE "System Class")
(HASH-TABLE-COUNT "Function")
(HASH-TABLE-P "Function")
(HASH-TABLE-REHASH-SIZE "Function")
(HASH-TABLE-REHASH-THRESHOLD "Function")
(HASH-TABLE-SIZE "Function")
(HASH-TABLE-TEST "Function")
(HOST-NAMESTRING "Function")
(IDENTITY "Function")
(IF "Special Operator")
(IGNORABLE "Declaration")
(IGNORE "Declaration")
(IGNORE-ERRORS "Macro")
(IMAGPART "Function")
(IMPORT "Function")
(IN-PACKAGE "Macro")
(INCF "Macro")
(INITIALIZE-INSTANCE "Standard Generic Function")
(INLINE "Declaration")
(INPUT-STREAM-P "Function")
(INSPECT "Function")
(INTEGER "System Class")
(INTEGER-DECODE-FLOAT "Function")
(INTEGER-LENGTH "Function")
(INTEGERP "Function")
(INTERACTIVE-STREAM-P "Function")
(INTERN "Function")
(INTERNAL-TIME-UNITS-PER-SECOND "Constant Variable")
(INTERSECTION "Function")
(INVALID-METHOD-ERROR "Function")
(INVOKE-DEBUGGER "Function")
(INVOKE-RESTART "Function")
(INVOKE-RESTART-INTERACTIVELY "Function")
(ISQRT "Function")
(KEYWORD "Type")
(KEYWORDP "Function")
(LABELS "Special Operator")
(LAMBDA "Macro")
(LAMBDA "Symbol")
(LAMBDA-LIST-KEYWORDS "Constant Variable")
(LAMBDA-PARAMETERS-LIMIT "Constant Variable")
(LAST "Function")
(LCM "Function")
(LDB "Accessor")
(LDB-TEST "Function")
(LDIFF "Function")
(LEAST-NEGATIVE-DOUBLE-FLOAT "Constant Variable")
(LEAST-NEGATIVE-LONG-FLOAT "Constant Variable")
(LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT "Constant Variable")
(LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT "Constant Variable")
(LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT "Constant Variable")
(LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT "Constant Variable")
(LEAST-NEGATIVE-SHORT-FLOAT "Constant Variable")
(LEAST-NEGATIVE-SINGLE-FLOAT "Constant Variable")
(LEAST-POSITIVE-DOUBLE-FLOAT "Constant Variable")
(LEAST-POSITIVE-LONG-FLOAT "Constant Variable")
(LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT "Constant Variable")
(LEAST-POSITIVE-NORMALIZED-LONG-FLOAT "Constant Variable")
(LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT "Constant Variable")
(LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT "Constant Variable")
(LEAST-POSITIVE-SHORT-FLOAT "Constant Variable")
(LEAST-POSITIVE-SINGLE-FLOAT "Constant Variable")
(LENGTH "Function")
(LET "Special Operator")
(LET* "Special Operator")
(LISP-IMPLEMENTATION-TYPE "Function")
(LISP-IMPLEMENTATION-VERSION "Function")
(LIST "Function")
(LIST "System Class")
(LIST* "Function")
(LIST-ALL-PACKAGES "Function")
(LIST-LENGTH "Function")
(LISTEN "Function")
(LISTP "Function")
(LOAD "Function")
(LOAD-LOGICAL-PATHNAME-TRANSLATIONS "Function")
(LOAD-TIME-VALUE "Special Operator")
(LOCALLY "Special Operator")
(LOG "Function")
(LOGAND "Function")
(LOGANDC1 "Function")
(LOGANDC2 "Function")
(LOGBITP "Function")
(LOGCOUNT "Function")
(LOGEQV "Function")
(LOGICAL-PATHNAME "Function")
(LOGICAL-PATHNAME "System Class")
(LOGICAL-PATHNAME-TRANSLATIONS "Accessor")
(LOGIOR "Function")
(LOGNAND "Function")
(LOGNOR "Function")
(LOGNOT "Function")
(LOGORC1 "Function")
(LOGORC2 "Function")
(LOGTEST "Function")
(LOGXOR "Function")
(LONG-FLOAT "Type")
(LONG-FLOAT-EPSILON "Constant Variable")
(LONG-FLOAT-NEGATIVE-EPSILON "Constant Variable")
(LONG-SITE-NAME "Function")
(LOOP "Macro")
(LOOP-FINISH "Local Macro")
(LOWER-CASE-P "Function")
(MACHINE-INSTANCE "Function")
(MACHINE-TYPE "Function")
(MACHINE-VERSION "Function")
(MACRO-FUNCTION "Accessor")
(MACROEXPAND "Function")
(MACROEXPAND-1 "Function")
(MACROLET "Special Operator")
(MAKE-ARRAY "Function")
(MAKE-BROADCAST-STREAM "Function")
(MAKE-CONCATENATED-STREAM "Function")
(MAKE-CONDITION "Function")
(MAKE-DISPATCH-MACRO-CHARACTER "Function")
(MAKE-ECHO-STREAM "Function")
(MAKE-HASH-TABLE "Function")
(MAKE-INSTANCE "Standard Generic Function")
(MAKE-INSTANCES-OBSOLETE "Standard Generic Function")
(MAKE-LIST "Function")
(MAKE-LOAD-FORM "Standard Generic Function")
(MAKE-LOAD-FORM-SAVING-SLOTS "Function")
(MAKE-METHOD "Local Macro")
(MAKE-PACKAGE "Function")
(MAKE-PATHNAME "Function")
(MAKE-RANDOM-STATE "Function")
(MAKE-SEQUENCE "Function")
(MAKE-STRING "Function")
(MAKE-STRING-INPUT-STREAM "Function")
(MAKE-STRING-OUTPUT-STREAM "Function")
(MAKE-SYMBOL "Function")
(MAKE-SYNONYM-STREAM "Function")
(MAKE-TWO-WAY-STREAM "Function")
(MAKUNBOUND "Function")
(MAP "Function")
(MAP-INTO "Function")
(MAPC "Function")
(MAPCAN "Function")
(MAPCAR "Function")
(MAPCON "Function")
(MAPHASH "Function")
(MAPL "Function")
(MAPLIST "Function")
(MASK-FIELD "Accessor")
(MAX "Function")
(MEMBER "Function")
(MEMBER "Type Specifier")
(MEMBER-IF "Function")
(MEMBER-IF-NOT "Function")
(MERGE "Function")
(MERGE-PATHNAMES "Function")
(METHOD "System Class")
(METHOD-COMBINATION "System Class")
(METHOD-COMBINATION-ERROR "Function")
(METHOD-QUALIFIERS "Standard Generic Function")
(MIN "Function")
(MINUSP "Function")
(MISMATCH "Function")
(MOD "Function")
(MOD "Type Specifier")
(MOST-NEGATIVE-DOUBLE-FLOAT "Constant Variable")
(MOST-NEGATIVE-FIXNUM "Constant Variable")
(MOST-NEGATIVE-LONG-FLOAT "Constant Variable")
(MOST-NEGATIVE-SHORT-FLOAT "Constant Variable")
(MOST-NEGATIVE-SINGLE-FLOAT "Constant Variable")
(MOST-POSITIVE-DOUBLE-FLOAT "Constant Variable")
(MOST-POSITIVE-FIXNUM "Constant Variable")
(MOST-POSITIVE-LONG-FLOAT "Constant Variable")
(MOST-POSITIVE-SHORT-FLOAT "Constant Variable")
(MOST-POSITIVE-SINGLE-FLOAT "Constant Variable")
(MUFFLE-WARNING "Function")
(MUFFLE-WARNING "Restart")
(MULTIPLE-VALUE-BIND "Macro")
(MULTIPLE-VALUE-CALL "Special Operator")
(MULTIPLE-VALUE-LIST "Macro")
(MULTIPLE-VALUE-PROG1 "Special Operator")
(MULTIPLE-VALUE-SETQ "Macro")
(MULTIPLE-VALUES-LIMIT "Constant Variable")
(NAME-CHAR "Function")
(NAMESTRING "Function")
(NBUTLAST "Function")
(NCONC "Function")
(NEXT-METHOD-P "Local Function")
(NIL "Constant Variable")
(NIL "Type")
(NINTERSECTION "Function")
(NINTH "Accessor")
(NO-APPLICABLE-METHOD "Standard Generic Function")
(NO-NEXT-METHOD "Standard Generic Function")
(NOT "Function")
(NOT "Type Specifier")
(NOTANY "Function")
(NOTEVERY "Function")
(NOTINLINE "Declaration")
(NRECONC "Function")
(NREVERSE "Function")
(NSET-DIFFERENCE "Function")
(NSET-EXCLUSIVE-OR "Function")
(NSTRING-CAPITALIZE "Function")
(NSTRING-DOWNCASE "Function")
(NSTRING-UPCASE "Function")
(NSUBLIS "Function")
(NSUBST "Function")
(NSUBST-IF "Function")
(NSUBST-IF-NOT "Function")
(NSUBSTITUTE "Function")
(NSUBSTITUTE-IF "Function")
(NSUBSTITUTE-IF-NOT "Function")
(NTH "Accessor")
(NTH-VALUE "Macro")
(NTHCDR "Function")
(NULL "Function")
(NULL "System Class")
(NUMBER "System Class")
(NUMBERP "Function")
(NUMERATOR "Function")
(NUNION "Function")
(ODDP "Function")
(OPEN "Function")
(OPEN-STREAM-P "Function")
(OPTIMIZE "Declaration")
(OR "Macro")
(OR "Type Specifier")
(OUTPUT-STREAM-P "Function")
(PACKAGE "System Class")
(PACKAGE-ERROR "Condition Type")
(PACKAGE-ERROR-PACKAGE "Function")
(PACKAGE-NAME "Function")
(PACKAGE-NICKNAMES "Function")
(PACKAGE-SHADOWING-SYMBOLS "Function")
(PACKAGE-USE-LIST "Function")
(PACKAGE-USED-BY-LIST "Function")
(PACKAGEP "Function")
(PAIRLIS "Function")
(PARSE-ERROR "Condition Type")
(PARSE-INTEGER "Function")
(PARSE-NAMESTRING "Function")
(PATHNAME "Function")
(PATHNAME "System Class")
(PATHNAME-DEVICE "Function")
(PATHNAME-DIRECTORY "Function")
(PATHNAME-HOST "Function")
(PATHNAME-MATCH-P "Function")
(PATHNAME-NAME "Function")
(PATHNAME-TYPE "Function")
(PATHNAME-VERSION "Function")
(PATHNAMEP "Function")
(PEEK-CHAR "Function")
(PHASE "Function")
(PI "Constant Variable")
(PLUSP "Function")
(POP "Macro")
(POSITION "Function")
(POSITION-IF "Function")
(POSITION-IF-NOT "Function")
(PPRINT "Function")
(PPRINT-DISPATCH "Function")
(PPRINT-EXIT-IF-LIST-EXHAUSTED "Local Macro")
(PPRINT-FILL "Function")
(PPRINT-INDENT "Function")
(PPRINT-LINEAR "Function")
(PPRINT-LOGICAL-BLOCK "Macro")
(PPRINT-NEWLINE "Function")
(PPRINT-POP "Local Macro")
(PPRINT-TAB "Function")
(PPRINT-TABULAR "Function")
(PRIN1 "Function")
(PRIN1-TO-STRING "Function")
(PRINC "Function")
(PRINC-TO-STRING "Function")
(PRINT "Function")
(PRINT-NOT-READABLE "Condition Type")
(PRINT-NOT-READABLE-OBJECT "Function")
(PRINT-OBJECT "Standard Generic Function")
(PRINT-UNREADABLE-OBJECT "Macro")
(PROBE-FILE "Function")
(PROCLAIM "Function")
(PROG "Macro")
(PROG* "Macro")
(PROG1 "Macro")
(PROG2 "Macro")
(PROGN "Special Operator")
(PROGRAM-ERROR "Condition Type")
(PROGV "Special Operator")
(PROVIDE "Function")
(PSETF "Macro")
(PSETQ "Macro")
(PUSH "Macro")
(PUSHNEW "Macro")
(QUOTE "Special Operator")
(RANDOM "Function")
(RANDOM-STATE "System Class")
(RANDOM-STATE-P "Function")
(RASSOC "Function")
(RASSOC-IF "Function")
(RASSOC-IF-NOT "Function")
(RATIO "System Class")
(RATIONAL "Function")
(RATIONAL "System Class")
(RATIONALIZE "Function")
(RATIONALP "Function")
(READ "Function")
(READ-BYTE "Function")
(READ-CHAR "Function")
(READ-CHAR-NO-HANG "Function")
(READ-DELIMITED-LIST "Function")
(READ-FROM-STRING "Function")
(READ-LINE "Function")
(READ-PRESERVING-WHITESPACE "Function")
(READ-SEQUENCE "Function")
(READER-ERROR "Condition Type")
(READTABLE "System Class")
(READTABLE-CASE "Accessor")
(READTABLEP "Function")
(REAL "System Class")
(REALP "Function")
(REALPART "Function")
(REDUCE "Function")
(REINITIALIZE-INSTANCE "Standard Generic Function")
(REM "Function")
(REMF "Macro")
(REMHASH "Function")
(REMOVE "Function")
(REMOVE-DUPLICATES "Function")
(REMOVE-IF "Function")
(REMOVE-IF-NOT "Function")
(REMOVE-METHOD "Standard Generic Function")
(REMPROP "Function")
(RENAME-FILE "Function")
(RENAME-PACKAGE "Function")
(REPLACE "Function")
(REQUIRE "Function")
(REST "Accessor")
(RESTART "System Class")
(RESTART-BIND "Macro")
(RESTART-CASE "Macro")
(RESTART-NAME "Function")
(RETURN "Macro")
(RETURN-FROM "Special Operator")
(REVAPPEND "Function")
(REVERSE "Function")
(ROOM "Function")
(ROTATEF "Macro")
(ROUND "Function")
(ROW-MAJOR-AREF "Accessor")
(RPLACA "Function")
(RPLACD "Function")
(SATISFIES "Type Specifier")
(SBIT "Accessor")
(SCALE-FLOAT "Function")
(SCHAR "Accessor")
(SEARCH "Function")
(SECOND "Accessor")
(SEQUENCE "System Class")
(SERIOUS-CONDITION "Condition Type")
(SET "Function")
(SET-DIFFERENCE "Function")
(SET-DISPATCH-MACRO-CHARACTER "Function")
(SET-EXCLUSIVE-OR "Function")
(SET-MACRO-CHARACTER "Function")
(SET-PPRINT-DISPATCH "Function")
(SET-SYNTAX-FROM-CHAR "Function")
(SETF "Macro")
(SETQ "Special Form")
(SEVENTH "Accessor")
(SHADOW "Function")
(SHADOWING-IMPORT "Function")
(SHARED-INITIALIZE "Standard Generic Function")
(SHIFTF "Macro")
(SHORT-FLOAT "Type")
(SHORT-FLOAT-EPSILON "Constant Variable")
(SHORT-FLOAT-NEGATIVE-EPSILON "Constant Variable")
(SHORT-SITE-NAME "Function")
(SIGNAL "Function")
(SIGNED-BYTE "Type")
(SIGNUM "Function")
(SIMPLE-ARRAY "Type")
(SIMPLE-BASE-STRING "Type")
(SIMPLE-BIT-VECTOR "Type")
(SIMPLE-BIT-VECTOR-P "Function")
(SIMPLE-CONDITION "Condition Type")
(SIMPLE-CONDITION-FORMAT-ARGUMENTS "Function")
(SIMPLE-CONDITION-FORMAT-CONTROL "Function")
(SIMPLE-ERROR "Condition Type")
(SIMPLE-STRING "Type")
(SIMPLE-STRING-P "Function")
(SIMPLE-TYPE-ERROR "Condition Type")
(SIMPLE-VECTOR "Type")
(SIMPLE-VECTOR-P "Function")
(SIMPLE-WARNING "Condition Type")
(SIN "Function")
(SINGLE-FLOAT "Type")
(SINGLE-FLOAT-EPSILON "Constant Variable")
(SINGLE-FLOAT-NEGATIVE-EPSILON "Constant Variable")
(SINH "Function")
(SIXTH "Accessor")
(SLEEP "Function")
(SLOT-BOUNDP "Function")
(SLOT-EXISTS-P "Function")
(SLOT-MAKUNBOUND "Function")
(SLOT-MISSING "Standard Generic Function")
(SLOT-UNBOUND "Standard Generic Function")
(SLOT-VALUE "Function")
(SOFTWARE-TYPE "Function")
(SOFTWARE-VERSION "Function")
(SOME "Function")
(SORT "Function")
(SPECIAL "Declaration")
(SPECIAL-OPERATOR-P "Function")
(SQRT "Function")
(STABLE-SORT "Function")
(STANDARD-CHAR "Type")
(STANDARD-CHAR-P "Function")
(STANDARD-CLASS "System Class")
(STANDARD-GENERIC-FUNCTION "System Class")
(STANDARD-METHOD "System Class")
(STANDARD-OBJECT "Class")
(STEP "Macro")
(STORAGE-CONDITION "Condition Type")
(STORE-VALUE "Function")
(STORE-VALUE "Restart")
(STREAM "System Class")
(STREAM-ELEMENT-TYPE "Function")
(STREAM-ERROR "Condition Type")
(STREAM-ERROR-STREAM "Function")
(STREAM-EXTERNAL-FORMAT "Function")
(STREAMP "Function")
(STRING "Function")
(STRING "System Class")
(STRING-CAPITALIZE "Function")
(STRING-DOWNCASE "Function")
(STRING-EQUAL "Function")
(STRING-GREATERP "Function")
(STRING-LEFT-TRIM "Function")
(STRING-LESSP "Function")
(STRING-NOT-EQUAL "Function")
(STRING-NOT-GREATERP "Function")
(STRING-NOT-LESSP "Function")
(STRING-RIGHT-TRIM "Function")
(STRING-STREAM "System Class")
(STRING-TRIM "Function")
(STRING-UPCASE "Function")
(STRING/= "Function")
(STRING< "Function")
(STRING<= "Function")
(STRING= "Function")
(STRING> "Function")
(STRING>= "Function")
(STRINGP "Function")
(STRUCTURE-CLASS "System Class")
(STRUCTURE-OBJECT "Class")
(STYLE-WARNING "Condition Type")
(SUBLIS "Function")
(SUBSEQ "Accessor")
(SUBSETP "Function")
(SUBST "Function")
(SUBST-IF "Function")
(SUBST-IF-NOT "Function")
(SUBSTITUTE "Function")
(SUBSTITUTE-IF "Function")
(SUBSTITUTE-IF-NOT "Function")
(SUBTYPEP "Function")
(SVREF "Accessor")
(SXHASH "Function")
(SYMBOL "System Class")
(SYMBOL-FUNCTION "Accessor")
(SYMBOL-MACROLET "Special Operator")
(SYMBOL-NAME "Function")
(SYMBOL-PACKAGE "Function")
(SYMBOL-PLIST "Accessor")
(SYMBOL-VALUE "Accessor")
(SYMBOLP "Function")
(SYNONYM-STREAM "System Class")
(SYNONYM-STREAM-SYMBOL "Function")
(T "Constant Variable")
(T "System Class")
(TAGBODY "Special Operator")
(TAILP "Function")
(TAN "Function")
(TANH "Function")
(TENTH "Accessor")
(TERPRI "Function")
(THE "Special Operator")
(THIRD "Accessor")
(THROW "Special Operator")
(TIME "Macro")
(TRACE "Macro")
(TRANSLATE-LOGICAL-PATHNAME "Function")
(TRANSLATE-PATHNAME "Function")
(TREE-EQUAL "Function")
(TRUENAME "Function")
(TRUNCATE "Function")
(TWO-WAY-STREAM "System Class")
(TWO-WAY-STREAM-INPUT-STREAM "Function")
(TWO-WAY-STREAM-OUTPUT-STREAM "Function")
(TYPE "Declaration")
(TYPE-ERROR "Condition Type")
(TYPE-ERROR-DATUM "Function")
(TYPE-ERROR-EXPECTED-TYPE "Function")
(TYPE-OF "Function")
(TYPECASE "Macro")
(TYPEP "Function")
(UNBOUND-SLOT "Condition Type")
(UNBOUND-SLOT-INSTANCE "Function")
(UNBOUND-VARIABLE "Condition Type")
(UNDEFINED-FUNCTION "Condition Type")
(UNEXPORT "Function")
(UNINTERN "Function")
(UNION "Function")
(UNLESS "Macro")
(UNREAD-CHAR "Function")
(UNSIGNED-BYTE "Type")
(UNTRACE "Macro")
(UNUSE-PACKAGE "Function")
(UNWIND-PROTECT "Special Operator")
(UPDATE-INSTANCE-FOR-DIFFERENT-CLASS "Standard Generic Function")
(UPDATE-INSTANCE-FOR-REDEFINED-CLASS "Standard Generic Function")
(UPGRADED-ARRAY-ELEMENT-TYPE "Function")
(UPGRADED-COMPLEX-PART-TYPE "Function")
(UPPER-CASE-P "Function")
(USE-PACKAGE "Function")
(USE-VALUE "Function")
(USE-VALUE "Restart")
(USER-HOMEDIR-PATHNAME "Function")
(VALUES "Accessor")
(VALUES "Type Specifier")
(VALUES-LIST "Function")
(VECTOR "Function")
(VECTOR "System Class")
(VECTOR-POP "Function")
(VECTOR-PUSH "Function")
(VECTOR-PUSH-EXTEND "Function")
(VECTORP "Function")
(WARN "Function")
(WARNING "Condition Type")
(WHEN "Macro")
(WILD-PATHNAME-P "Function")
(WITH-ACCESSORS "Macro")
(WITH-COMPILATION-UNIT "Macro")
(WITH-CONDITION-RESTARTS "Macro")
(WITH-HASH-TABLE-ITERATOR "Macro")
(WITH-INPUT-FROM-STRING "Macro")
(WITH-OPEN-STREAM "Macro")
(WITH-OUTPUT-TO-STRING "Macro")
(WITH-PACKAGE-ITERATOR "Macro")
(WITH-SIMPLE-RESTART "Macro")
(WITH-SLOTS "Macro")
(WITH-STANDARD-IO-SYNTAX "Macro")
(WRITE "Function")
(WRITE-BYTE "Function")
(WRITE-CHAR "Function")
(WRITE-LINE "Function")
(WRITE-SEQUENCE "Function")
(WRITE-STRING "Function")
(WRITE-TO-STRING "Function")
(Y-OR-N-P "Function")
(YES-OR-NO-P "Function")
(ZEROP "Function")
(WITH-OPEN-FILE "Macro")
(VARIABLE "Symbol")
(STRUCTURE "Symbol")
(STANDARD "Symbol")
(SPEED "Symbol")
(SPACE "Symbol")
(SAFETY "Symbol")
(OTHERWISE "Symbol")
(ENCODE-UNIVERSAL-TIME "Function")
(COMPILER-MACRO "Symbol")
(DEBUG "Symbol")
(COMPILATION-SPEED "Symbol")
(&WHOLE "Symbol")
(&REST "Symbol")
(&OPTIONAL "Symbol")
(&KEY "Symbol")
(&ENVIRONMENT "Symbol")
(&BODY "Symbol")
(&AUX "Symbol")
(&ALLOW-OTHER-KEYS "Symbol")
)) ;;*common-lisp-symbols*
(defconstant *common-lisp-exports*
'(
&ALLOW-OTHER-KEYS *PRINT-MISER-WIDTH* &AUX *PRINT-PPRINT-DISPATCH*
&BODY *PRINT-PRETTY* &ENVIRONMENT *PRINT-RADIX* &KEY *PRINT-READABLY*
&OPTIONAL *PRINT-RIGHT-MARGIN* &REST *QUERY-IO* &WHOLE *RANDOM-STATE*
* *READ-BASE* ** *READ-DEFAULT-FLOAT-FORMAT* *** *READ-EVAL*
*BREAK-ON-SIGNALS* *READ-SUPPRESS* *COMPILE-FILE-PATHNAME* *READTABLE*
*COMPILE-FILE-TRUENAME* *STANDARD-INPUT* *COMPILE-PRINT*
*STANDARD-OUTPUT* *COMPILE-VERBOSE* *TERMINAL-IO* *DEBUG-IO*
*TRACE-OUTPUT* *DEBUGGER-HOOK* + *DEFAULT-PATHNAME-DEFAULTS* ++
*ERROR-OUTPUT* +++ *FEATURES* - *GENSYM-COUNTER* / *LOAD-PATHNAME* //
*LOAD-PRINT* /// *LOAD-TRUENAME* /= *LOAD-VERBOSE* 1+
*MACROEXPAND-HOOK* 1- *MODULES* < *PACKAGE* <= *PRINT-ARRAY* =
*PRINT-BASE* > *PRINT-CASE* >= *PRINT-CIRCLE* ABORT *PRINT-ESCAPE* ABS
*PRINT-GENSYM* ACONS *PRINT-LENGTH* ACOS *PRINT-LEVEL* ACOSH
*PRINT-LINES* ADD-METHOD ADJOIN ATOM BOUNDP ADJUST-ARRAY BASE-CHAR
BREAK ADJUSTABLE-ARRAY-P BASE-STRING BROADCAST-STREAM
ALLOCATE-INSTANCE BIGNUM BROADCAST-STREAM-STREAMS ALPHA-CHAR-P BIT
BUILT-IN-CLASS ALPHANUMERICP BIT-AND BUTLAST AND BIT-ANDC1 BYTE APPEND
BIT-ANDC2 BYTE-POSITION APPLY BIT-EQV BYTE-SIZE APROPOS BIT-IOR CAAAAR
APROPOS-LIST BIT-NAND CAAADR AREF BIT-NOR CAAAR ARITHMETIC-ERROR
BIT-NOT CAADAR ARITHMETIC-ERROR-OPERANDS BIT-ORC1 CAADDR
ARITHMETIC-ERROR-OPERATION BIT-ORC2 CAADR ARRAY BIT-VECTOR CAAR
ARRAY-DIMENSION BIT-VECTOR-P CADAAR ARRAY-DIMENSION-LIMIT BIT-XOR
CADADR ARRAY-DIMENSIONS BLOCK CADAR ARRAY-DISPLACEMENT BOOLE CADDAR
ARRAY-ELEMENT-TYPE BOOLE-1 CADDDR ARRAY-HAS-FILL-POINTER-P BOOLE-2
CADDR ARRAY-IN-BOUNDS-P BOOLE-AND CADR ARRAY-RANK BOOLE-ANDC1
CALL-ARGUMENTS-LIMIT ARRAY-RANK-LIMIT BOOLE-ANDC2 CALL-METHOD
ARRAY-ROW-MAJOR-INDEX BOOLE-C1 CALL-NEXT-METHOD ARRAY-TOTAL-SIZE
BOOLE-C2 CAR ARRAY-TOTAL-SIZE-LIMIT BOOLE-CLR CASE ARRAYP BOOLE-EQV
CATCH ASH BOOLE-IOR CCASE ASIN BOOLE-NAND CDAAAR ASINH BOOLE-NOR
CDAADR ASSERT BOOLE-ORC1 CDAAR ASSOC BOOLE-ORC2 CDADAR ASSOC-IF
BOOLE-SET CDADDR ASSOC-IF-NOT BOOLE-XOR CDADR ATAN BOOLEAN CDAR ATANH
BOTH-CASE-P CDDAAR CDDADR CLEAR-INPUT COPY-TREE CDDAR CLEAR-OUTPUT COS
CDDDAR CLOSE COSH CDDDDR CLRHASH COUNT CDDDR CODE-CHAR COUNT-IF CDDR
COERCE COUNT-IF-NOT CDR COMPILATION-SPEED CTYPECASE CEILING COMPILE
DEBUG CELL-ERROR COMPILE-FILE DECF CELL-ERROR-NAME
COMPILE-FILE-PATHNAME DECLAIM CERROR COMPILED-FUNCTION DECLARATION
CHANGE-CLASS COMPILED-FUNCTION-P DECLARE CHAR COMPILER-MACRO
DECODE-FLOAT CHAR-CODE COMPILER-MACRO-FUNCTION DECODE-UNIVERSAL-TIME
CHAR-CODE-LIMIT COMPLEMENT DEFCLASS CHAR-DOWNCASE COMPLEX DEFCONSTANT
CHAR-EQUAL COMPLEXP DEFGENERIC CHAR-GREATERP
COMPUTE-APPLICABLE-METHODS DEFINE-COMPILER-MACRO CHAR-INT
COMPUTE-RESTARTS DEFINE-CONDITION CHAR-LESSP CONCATENATE
DEFINE-METHOD-COMBINATION CHAR-NAME CONCATENATED-STREAM
DEFINE-MODIFY-MACRO CHAR-NOT-EQUAL CONCATENATED-STREAM-STREAMS
DEFINE-SETF-EXPANDER CHAR-NOT-GREATERP COND DEFINE-SYMBOL-MACRO
CHAR-NOT-LESSP CONDITION DEFMACRO CHAR-UPCASE CONJUGATE DEFMETHOD
CHAR/= CONS DEFPACKAGE CHAR< CONSP DEFPARAMETER CHAR<= CONSTANTLY
DEFSETF CHAR= CONSTANTP DEFSTRUCT CHAR> CONTINUE DEFTYPE CHAR>=
CONTROL-ERROR DEFUN CHARACTER COPY-ALIST DEFVAR CHARACTERP COPY-LIST
DELETE CHECK-TYPE COPY-PPRINT-DISPATCH DELETE-DUPLICATES CIS
COPY-READTABLE DELETE-FILE CLASS COPY-SEQ DELETE-IF CLASS-NAME
COPY-STRUCTURE DELETE-IF-NOT CLASS-OF COPY-SYMBOL DELETE-PACKAGE
DENOMINATOR EQ DEPOSIT-FIELD EQL DESCRIBE EQUAL DESCRIBE-OBJECT EQUALP
DESTRUCTURING-BIND ERROR DIGIT-CHAR ETYPECASE DIGIT-CHAR-P EVAL
DIRECTORY EVAL-WHEN DIRECTORY-NAMESTRING EVENP DISASSEMBLE EVERY
DIVISION-BY-ZERO EXP DO EXPORT DO* EXPT DO-ALL-SYMBOLS EXTENDED-CHAR
DO-EXTERNAL-SYMBOLS FBOUNDP DO-SYMBOLS FCEILING DOCUMENTATION
FDEFINITION DOLIST FFLOOR DOTIMES FIFTH DOUBLE-FLOAT FILE-AUTHOR
DOUBLE-FLOAT-EPSILON FILE-ERROR DOUBLE-FLOAT-NEGATIVE-EPSILON
FILE-ERROR-PATHNAME DPB FILE-LENGTH DRIBBLE FILE-NAMESTRING
DYNAMIC-EXTENT FILE-POSITION ECASE FILE-STREAM ECHO-STREAM
FILE-STRING-LENGTH ECHO-STREAM-INPUT-STREAM FILE-WRITE-DATE
ECHO-STREAM-OUTPUT-STREAM FILL ED FILL-POINTER EIGHTH FIND ELT
FIND-ALL-SYMBOLS ENCODE-UNIVERSAL-TIME FIND-CLASS END-OF-FILE FIND-IF
ENDP FIND-IF-NOT ENOUGH-NAMESTRING FIND-METHOD
ENSURE-DIRECTORIES-EXIST FIND-PACKAGE ENSURE-GENERIC-FUNCTION
FIND-RESTART FIND-SYMBOL GET-INTERNAL-RUN-TIME FINISH-OUTPUT
GET-MACRO-CHARACTER FIRST GET-OUTPUT-STREAM-STRING FIXNUM
GET-PROPERTIES FLET GET-SETF-EXPANSION FLOAT GET-UNIVERSAL-TIME
FLOAT-DIGITS GETF FLOAT-PRECISION GETHASH FLOAT-RADIX GO FLOAT-SIGN
GRAPHIC-CHAR-P FLOATING-POINT-INEXACT HANDLER-BIND
FLOATING-POINT-INVALID-OPERATION HANDLER-CASE FLOATING-POINT-OVERFLOW
HASH-TABLE FLOATING-POINT-UNDERFLOW HASH-TABLE-COUNT FLOATP
HASH-TABLE-P FLOOR HASH-TABLE-REHASH-SIZE FMAKUNBOUND
HASH-TABLE-REHASH-THRESHOLD FORCE-OUTPUT HASH-TABLE-SIZE FORMAT
HASH-TABLE-TEST FORMATTER HOST-NAMESTRING FOURTH IDENTITY FRESH-LINE
IF FROUND IGNORABLE FTRUNCATE IGNORE FTYPE IGNORE-ERRORS FUNCALL
IMAGPART FUNCTION IMPORT FUNCTION-KEYWORDS IN-PACKAGE
FUNCTION-LAMBDA-EXPRESSION INCF FUNCTIONP INITIALIZE-INSTANCE GCD
INLINE GENERIC-FUNCTION INPUT-STREAM-P GENSYM INSPECT GENTEMP INTEGER
GET INTEGER-DECODE-FLOAT GET-DECODED-TIME INTEGER-LENGTH
GET-DISPATCH-MACRO-CHARACTER INTEGERP GET-INTERNAL-REAL-TIME
INTERACTIVE-STREAM-P INTERN LISP-IMPLEMENTATION-TYPE
INTERNAL-TIME-UNITS-PER-SECOND LISP-IMPLEMENTATION-VERSION
INTERSECTION LIST INVALID-METHOD-ERROR LIST* INVOKE-DEBUGGER
LIST-ALL-PACKAGES INVOKE-RESTART LIST-LENGTH
INVOKE-RESTART-INTERACTIVELY LISTEN ISQRT LISTP KEYWORD LOAD KEYWORDP
LOAD-LOGICAL-PATHNAME-TRANSLATIONS LABELS LOAD-TIME-VALUE LAMBDA
LOCALLY LAMBDA-LIST-KEYWORDS LOG LAMBDA-PARAMETERS-LIMIT LOGAND LAST
LOGANDC1 LCM LOGANDC2 LDB LOGBITP LDB-TEST LOGCOUNT LDIFF LOGEQV
LEAST-NEGATIVE-DOUBLE-FLOAT LOGICAL-PATHNAME LEAST-NEGATIVE-LONG-FLOAT
LOGICAL-PATHNAME-TRANSLATIONS LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT
LOGIOR LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT LOGNAND
LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT LOGNOR
LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT LOGNOT
LEAST-NEGATIVE-SHORT-FLOAT LOGORC1 LEAST-NEGATIVE-SINGLE-FLOAT LOGORC2
LEAST-POSITIVE-DOUBLE-FLOAT LOGTEST LEAST-POSITIVE-LONG-FLOAT LOGXOR
LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT LONG-FLOAT
LEAST-POSITIVE-NORMALIZED-LONG-FLOAT LONG-FLOAT-EPSILON
LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT LONG-FLOAT-NEGATIVE-EPSILON
LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT LONG-SITE-NAME
LEAST-POSITIVE-SHORT-FLOAT LOOP LEAST-POSITIVE-SINGLE-FLOAT
LOOP-FINISH LENGTH LOWER-CASE-P LET MACHINE-INSTANCE LET* MACHINE-TYPE
MACHINE-VERSION MASK-FIELD MACRO-FUNCTION MAX MACROEXPAND MEMBER
MACROEXPAND-1 MEMBER-IF MACROLET MEMBER-IF-NOT MAKE-ARRAY MERGE
MAKE-BROADCAST-STREAM MERGE-PATHNAMES MAKE-CONCATENATED-STREAM METHOD
MAKE-CONDITION METHOD-COMBINATION MAKE-DISPATCH-MACRO-CHARACTER
METHOD-COMBINATION-ERROR MAKE-ECHO-STREAM METHOD-QUALIFIERS
MAKE-HASH-TABLE MIN MAKE-INSTANCE MINUSP MAKE-INSTANCES-OBSOLETE
MISMATCH MAKE-LIST MOD MAKE-LOAD-FORM MOST-NEGATIVE-DOUBLE-FLOAT
MAKE-LOAD-FORM-SAVING-SLOTS MOST-NEGATIVE-FIXNUM MAKE-METHOD
MOST-NEGATIVE-LONG-FLOAT MAKE-PACKAGE MOST-NEGATIVE-SHORT-FLOAT
MAKE-PATHNAME MOST-NEGATIVE-SINGLE-FLOAT MAKE-RANDOM-STATE
MOST-POSITIVE-DOUBLE-FLOAT MAKE-SEQUENCE MOST-POSITIVE-FIXNUM
MAKE-STRING MOST-POSITIVE-LONG-FLOAT MAKE-STRING-INPUT-STREAM
MOST-POSITIVE-SHORT-FLOAT MAKE-STRING-OUTPUT-STREAM
MOST-POSITIVE-SINGLE-FLOAT MAKE-SYMBOL MUFFLE-WARNING
MAKE-SYNONYM-STREAM MULTIPLE-VALUE-BIND MAKE-TWO-WAY-STREAM
MULTIPLE-VALUE-CALL MAKUNBOUND MULTIPLE-VALUE-LIST MAP
MULTIPLE-VALUE-PROG1 MAP-INTO MULTIPLE-VALUE-SETQ MAPC
MULTIPLE-VALUES-LIMIT MAPCAN NAME-CHAR MAPCAR NAMESTRING MAPCON
NBUTLAST MAPHASH NCONC MAPL NEXT-METHOD-P MAPLIST NIL NINTERSECTION
PACKAGE-ERROR NINTH PACKAGE-ERROR-PACKAGE NO-APPLICABLE-METHOD
PACKAGE-NAME NO-NEXT-METHOD PACKAGE-NICKNAMES NOT
PACKAGE-SHADOWING-SYMBOLS NOTANY PACKAGE-USE-LIST NOTEVERY
PACKAGE-USED-BY-LIST NOTINLINE PACKAGEP NRECONC PAIRLIS NREVERSE
PARSE-ERROR NSET-DIFFERENCE PARSE-INTEGER NSET-EXCLUSIVE-OR
PARSE-NAMESTRING NSTRING-CAPITALIZE PATHNAME NSTRING-DOWNCASE
PATHNAME-DEVICE NSTRING-UPCASE PATHNAME-DIRECTORY NSUBLIS
PATHNAME-HOST NSUBST PATHNAME-MATCH-P NSUBST-IF PATHNAME-NAME
NSUBST-IF-NOT PATHNAME-TYPE NSUBSTITUTE PATHNAME-VERSION
NSUBSTITUTE-IF PATHNAMEP NSUBSTITUTE-IF-NOT PEEK-CHAR NTH PHASE
NTH-VALUE PI NTHCDR PLUSP NULL POP NUMBER POSITION NUMBERP POSITION-IF
NUMERATOR POSITION-IF-NOT NUNION PPRINT ODDP PPRINT-DISPATCH OPEN
PPRINT-EXIT-IF-LIST-EXHAUSTED OPEN-STREAM-P PPRINT-FILL OPTIMIZE
PPRINT-INDENT OR PPRINT-LINEAR OTHERWISE PPRINT-LOGICAL-BLOCK
OUTPUT-STREAM-P PPRINT-NEWLINE PACKAGE PPRINT-POP PPRINT-TAB READ-CHAR
PPRINT-TABULAR READ-CHAR-NO-HANG PRIN1 READ-DELIMITED-LIST
PRIN1-TO-STRING READ-FROM-STRING PRINC READ-LINE PRINC-TO-STRING
READ-PRESERVING-WHITESPACE PRINT READ-SEQUENCE PRINT-NOT-READABLE
READER-ERROR PRINT-NOT-READABLE-OBJECT READTABLE PRINT-OBJECT
READTABLE-CASE PRINT-UNREADABLE-OBJECT READTABLEP PROBE-FILE REAL
PROCLAIM REALP PROG REALPART PROG* REDUCE PROG1 REINITIALIZE-INSTANCE
PROG2 REM PROGN REMF PROGRAM-ERROR REMHASH PROGV REMOVE PROVIDE
REMOVE-DUPLICATES PSETF REMOVE-IF PSETQ REMOVE-IF-NOT PUSH
REMOVE-METHOD PUSHNEW REMPROP QUOTE RENAME-FILE RANDOM RENAME-PACKAGE
RANDOM-STATE REPLACE RANDOM-STATE-P REQUIRE RASSOC REST RASSOC-IF
RESTART RASSOC-IF-NOT RESTART-BIND RATIO RESTART-CASE RATIONAL
RESTART-NAME RATIONALIZE RETURN RATIONALP RETURN-FROM READ REVAPPEND
READ-BYTE REVERSE ROOM SIMPLE-BIT-VECTOR ROTATEF SIMPLE-BIT-VECTOR-P
ROUND SIMPLE-CONDITION ROW-MAJOR-AREF
SIMPLE-CONDITION-FORMAT-ARGUMENTS RPLACA
SIMPLE-CONDITION-FORMAT-CONTROL RPLACD SIMPLE-ERROR SAFETY
SIMPLE-STRING SATISFIES SIMPLE-STRING-P SBIT SIMPLE-TYPE-ERROR
SCALE-FLOAT SIMPLE-VECTOR SCHAR SIMPLE-VECTOR-P SEARCH SIMPLE-WARNING
SECOND SIN SEQUENCE SINGLE-FLOAT SERIOUS-CONDITION
SINGLE-FLOAT-EPSILON SET SINGLE-FLOAT-NEGATIVE-EPSILON SET-DIFFERENCE
SINH SET-DISPATCH-MACRO-CHARACTER SIXTH SET-EXCLUSIVE-OR SLEEP
SET-MACRO-CHARACTER SLOT-BOUNDP SET-PPRINT-DISPATCH SLOT-EXISTS-P
SET-SYNTAX-FROM-CHAR SLOT-MAKUNBOUND SETF SLOT-MISSING SETQ
SLOT-UNBOUND SEVENTH SLOT-VALUE SHADOW SOFTWARE-TYPE SHADOWING-IMPORT
SOFTWARE-VERSION SHARED-INITIALIZE SOME SHIFTF SORT SHORT-FLOAT SPACE
SHORT-FLOAT-EPSILON SPECIAL SHORT-FLOAT-NEGATIVE-EPSILON
SPECIAL-OPERATOR-P SHORT-SITE-NAME SPEED SIGNAL SQRT SIGNED-BYTE
STABLE-SORT SIGNUM STANDARD SIMPLE-ARRAY STANDARD-CHAR
SIMPLE-BASE-STRING STANDARD-CHAR-P STANDARD-CLASS SUBLIS
STANDARD-GENERIC-FUNCTION SUBSEQ STANDARD-METHOD SUBSETP
STANDARD-OBJECT SUBST STEP SUBST-IF STORAGE-CONDITION SUBST-IF-NOT
STORE-VALUE SUBSTITUTE STREAM SUBSTITUTE-IF STREAM-ELEMENT-TYPE
SUBSTITUTE-IF-NOT STREAM-ERROR SUBTYPEP STREAM-ERROR-STREAM SVREF
STREAM-EXTERNAL-FORMAT SXHASH STREAMP SYMBOL STRING SYMBOL-FUNCTION
STRING-CAPITALIZE SYMBOL-MACROLET STRING-DOWNCASE SYMBOL-NAME
STRING-EQUAL SYMBOL-PACKAGE STRING-GREATERP SYMBOL-PLIST
STRING-LEFT-TRIM SYMBOL-VALUE STRING-LESSP SYMBOLP STRING-NOT-EQUAL
SYNONYM-STREAM STRING-NOT-GREATERP SYNONYM-STREAM-SYMBOL
STRING-NOT-LESSP T STRING-RIGHT-TRIM TAGBODY STRING-STREAM TAILP
STRING-TRIM TAN STRING-UPCASE TANH STRING/= TENTH STRING< TERPRI
STRING<= THE STRING= THIRD STRING> THROW STRING>= TIME STRINGP TRACE
STRUCTURE TRANSLATE-LOGICAL-PATHNAME STRUCTURE-CLASS
TRANSLATE-PATHNAME STRUCTURE-OBJECT TREE-EQUAL STYLE-WARNING TRUENAME
TRUNCATE VALUES-LIST TWO-WAY-STREAM VARIABLE
TWO-WAY-STREAM-INPUT-STREAM VECTOR TWO-WAY-STREAM-OUTPUT-STREAM
VECTOR-POP TYPE VECTOR-PUSH TYPE-ERROR VECTOR-PUSH-EXTEND
TYPE-ERROR-DATUM VECTORP TYPE-ERROR-EXPECTED-TYPE WARN TYPE-OF WARNING
TYPECASE WHEN TYPEP WILD-PATHNAME-P UNBOUND-SLOT WITH-ACCESSORS
UNBOUND-SLOT-INSTANCE WITH-COMPILATION-UNIT UNBOUND-VARIABLE
WITH-CONDITION-RESTARTS UNDEFINED-FUNCTION WITH-HASH-TABLE-ITERATOR
UNEXPORT WITH-INPUT-FROM-STRING UNINTERN WITH-OPEN-FILE UNION
WITH-OPEN-STREAM UNLESS WITH-OUTPUT-TO-STRING UNREAD-CHAR
WITH-PACKAGE-ITERATOR UNSIGNED-BYTE WITH-SIMPLE-RESTART UNTRACE
WITH-SLOTS UNUSE-PACKAGE WITH-STANDARD-IO-SYNTAX UNWIND-PROTECT WRITE
UPDATE-INSTANCE-FOR-DIFFERENT-CLASS WRITE-BYTE
UPDATE-INSTANCE-FOR-REDEFINED-CLASS WRITE-CHAR
UPGRADED-ARRAY-ELEMENT-TYPE WRITE-LINE UPGRADED-COMPLEX-PART-TYPE
WRITE-SEQUENCE UPPER-CASE-P WRITE-STRING USE-PACKAGE WRITE-TO-STRING
USE-VALUE Y-OR-N-P USER-HOMEDIR-PATHNAME YES-OR-NO-P VALUES ZEROP
)) ;;*common-lisp-exports*
(defun up-down-case (sym)
"
RETURN: A list containg the name of sym in down case and in up case.
"
(list (string-downcase (symbol-name sym))
(string-upcase (symbol-name sym))))
(defconst +separator-regexp+ "[ \"',`()\n\t]")
(defun token-regexp (regexp)
"
RETURN: A regexp that match the given REGEXP, but
only if standing alone as a single lisp token.
"
(format "\\<\\(%s\\)\\>" regexp))
;; MATCH-ANCHORED in C-h v font-lock-keywords
(defun clfl-nop () nil)
(defun clfl-front () (message "clfl-front") (goto-char (match-beginning 0)))
(defun clfl-back () (message "clfl-back") (goto-char (match-end 1)))
(defun common-lisp-font-lock ()
(mapcan
(lambda (kf)
(let* ((kind (kf-kind kf))
(lock (kf-lock kf))
(face (kf-face kf))
(symbols (mapcar (function first)
(remove* kind *common-lisp-symbols*
:test (function cl:string/=)
:key (function second)))))
(labels ((format-regexp-in (tree)
(cond
((and (stringp tree) (string-match "%s" tree))
(format tree
(token-regexp
(regexp-opt
(mapcar (lambda (x) (string-upcase (symbol-name x))) symbols)
;; (mapcan (function up-down-case) symbols)
'words))))
((consp tree) (cons (format-regexp-in (car tree))
(format-regexp-in (cdr tree))))
(t tree)))
(some-format-p (tree)
(cond
((and (stringp tree) (string-match "%s" tree)) t)
((consp tree) (or (some-format-p (car tree))
(some-format-p (cdr tree))))
(t nil))))
(cond
(symbols
(setf lock (copy-seq (or lock `("%s" (0 ,face t)))))
;; ("%s" (goto-char (match-beginning 0))
;; (goto-char (match-end 1))
;; ;;,(function clfl-front)
;; ;;,(function clfl-back)
;; (1 ,face t))))))
(list (format-regexp-in lock)))
((null lock)
;; "Warning"
;; (error "No lock and no symbols")
nil)
((some-format-p (car lock))
(error "No symbol to fill %%s in lock regexp"))
(t
(list lock)) ))))
*kind-to-face-map*))
(defvar *common-lisp-font-lock-cache* '(:undef :undef nil))
(defvar *common-lisp-font-lock-keywords* '())
(defun common-lisp-font-lock-keywords ()
(third
(if (and (eq window-system (first *common-lisp-font-lock-cache*))
(eq pretty-greek (second *common-lisp-font-lock-cache*)))
*common-lisp-font-lock-cache*
(setf *common-lisp-font-lock-cache*
(list
window-system
pretty-greek
(nconc
(when (and (eq 'x window-system) pretty-greek)
(greek-letter-font-lock))
(copy-list
`(
(,(format "(%s[ ']*\\(\\sw+\\)?"
(regexp-opt
(mapcar (function cl:string)
'(catch throw block return-from))
;; (mapcan (function up-down-case)
;; '(catch throw block return-from))
'words))
(1 font-lock-cl-special-operator-face t)
(2 font-lock-constant-face nil t))
(,(format "(%s[ ']*\\(\\sw+\\)?"
(regexp-opt
(mapcar (function cl:string)
'(provide require))
;; (mapcan (function up-down-case) '(provide require))
'words))
(1 font-lock-cl-function-face t)
(2 font-lock-constant-face nil t))
(,(format "(%s"
(regexp-opt
(mapcar (function cl:string)
'(abort assert error signal))
;; (mapcan (function up-down-case)
;; '(abort assert error signal))
'words))
(1 font-lock-cl-warning-face t))))
(common-lisp-font-lock)))))))
;; (remove* 'font-lock-cl-string-face *common-lisp-font-lock-keywords*
;; :test (lambda (x y) (not (eq x y))) :key (lambda (x) (second (second x))))
(defun common-lisp-font-lock-hook ()
(interactive)
(setf *common-lisp-font-lock-keywords* (common-lisp-font-lock-keywords))
(setq font-lock-defaults
(list '*common-lisp-font-lock-keywords*
nil ; keyword only
t ; case fold
'(("!#$%&*+,-./:<=>?@[]^_{}~áâãäÃ¥æçèéêëìÃÂîïðñòóôõö÷øùúûüýþÿÃÂ÷"
. "w"))))
(setq font-lock-keywords
*common-lisp-font-lock-keywords*))
;;;; THE END ;;;;