;;;; -*- 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 ;;;;
ViewGit