*allow-named-registers* (variable)

                                                  *allow-quoting* (variable)

                                                  *end-pos* (variable)

                                                  *end-string-pos* (variable)

                                                  *extended-mode-p* (variable)

                                                  *hyperdoc-base-uri* (variable)

                                                  *last-pos-stores* (variable)

                                                  *real-start-pos* (variable)

                                                  *reg-ends* (variable)

                                                  *reg-starts* (variable)

                                                  *regex-char-code-limit* (variable)

                                                  *regs-maybe-start* (variable)

                                                  *rep-num* (variable)

                                                  *repeat-counters* (variable)

                                                  *special-optimize-settings* (variable)

                                                  *standard-optimize-settings* (variable)

                                                  *start-pos* (variable)

                                                  *string* (variable)

                                                  *string*-equal (function)

                                                  *string*= (function)

                                                  *syntax-error-string* (variable)

                                                  *use-bmh-matchers* (variable)

                                                  *zero-length-num* (variable)

                                                  +digit-hash+ (constant)

                                                  +whitespace-char-hash+ (constant)

                                                  +whitespace-char-string+ (constant)

                                                  +word-char-hash+ (constant)

                                            maybe-accumulate (function)

                                                  add-range-to-hash (function)

                                           insert-advance-fn (macro)

                                             incf-after (macro)

                                    regex-replace-all (function)

                                                  all-matches (function)

                                                  all-matches-as-strings (function)

                                                  alternation (class)

                                                  anchor (class)

                                            start-anchored-p (generic function)

                                            regex-apropos (function)

                                            regex-apropos-aux (macro)

                                            regex-apropos-list (function)

                                      all-matches-as-strings (function)

                                       do-matches-as-strings (macro)

                                          looking-at-p (function)

                                      bmh-matcher-aux (macro)

                                    char-searcher-aux (macro)

                                          convert-aux (function)

                                   create-matcher-aux (generic function)

                                   create-scanner-aux (function)

                                       end-string-aux (generic function)

                              parse-register-name-aux (function)

                                    regex-apropos-aux (macro)

                                          replace-aux (function)

                                                  back-reference (class)

                                        *hyperdoc-base-uri* (variable)

                                  register-groups-bind (macro)

                                           create-bmh-matcher (function)

                                                  bmh-matcher-aux (macro)

                                             *use-bmh-matchers* (variable)

                                             word-boundary (class)

                                             word-boundary-p (function)

                                                  branch (class)

                                                  build-replacement (function)

                                                  build-replacement-template (generic function)

                                                  case-insensitive-mode-p (macro)

                                                  case-mode (generic function)

                                           string-case-modifier (function)

                                             next-char (function)

                                         unescape-char (function)

                                                  char-class (class)

                                          collect-char-class (function)

                              map-char-to-special-char-class (function)

                                           insert-char-class-tester (macro)

                                          convert-char-class-to-hash (function)

                                           *regex-char-code-limit* (variable)

                                             make-char-from-code (function)

                                             make-char-hash (function)

                                      +whitespace-char-hash+ (constant)

                                            +word-char-hash+ (constant)

                                             next-char-non-extended (function)

                                             word-char-p (function)

                                           create-char-searcher (function)

                                                  char-searcher-aux (macro)

                                      +whitespace-char-string+ (constant)

                                              map-char-to-special-char-class (function)

                                       quote-meta-chars (function)

                                             char-class (class)

                                     collect-char-class (function)

                         map-char-to-special-char-class (function)

                                      insert-char-class-tester (macro)

                                     convert-char-class-to-hash (function)

                                                  clean-comments (function)

              constant-repetition-constant-length-closure (macro)

                           greedy-constant-length-closure (macro)

                       non-greedy-constant-length-closure (macro)

                                   make-char-from-code (function)

                                      *regex-char-code-limit* (variable)

                                            maybe-coerce-to-simple-string (macro)

                                                  collect-char-class (function)

                                            clean-comments (function)

                                                  compute-min-rest (generic function)

                                                  compute-offsets (generic function)

                              constant-repetition-constant-length-closure (macro)

                                           greedy-constant-length-closure (macro)

                                       non-greedy-constant-length-closure (macro)

                       create-constant-repetition-constant-length-matcher (generic function)

                                    create-greedy-constant-length-matcher (generic function)

                                create-non-greedy-constant-length-matcher (generic function)

                                                  constant-repetition-constant-length-closure (macro)

                                           create-constant-repetition-constant-length-matcher (generic function)

                                           create-constant-repetition-matcher (generic function)

                                                  convert (function)

                                                  convert-aux (function)

                                                  convert-char-class-to-hash (function)

                                                  copy-lexer (function)

                                                  copy-regex (generic function)

                                          *repeat-counters* (variable)

                                                  create-bmh-matcher (function)

                                                  create-char-searcher (function)

                                                  create-constant-repetition-constant-length-matcher (generic function)

                                                  create-constant-repetition-matcher (generic function)

                                                  create-greedy-constant-length-matcher (generic function)

                                                  create-greedy-everything-matcher (function)

                                                  create-greedy-matcher (generic function)

                                                  create-greedy-no-zero-matcher (generic function)

                                                  create-matcher-aux (generic function)

                                                  create-non-greedy-constant-length-matcher (generic function)

                                                  create-non-greedy-matcher (generic function)

                                                  create-non-greedy-no-zero-matcher (generic function)

                                                  create-ranges-from-hash (function)

                                                  create-scanner (generic function)

                                                  create-scanner-aux (function)

                                                  define-parse-tree-synonym (macro)

                                                  do-matches (macro)

                                                  do-matches-as-strings (macro)

                                                  do-register-groups (macro)

                                                  do-scans (macro)

                                                  end-of-string-p (function)

                                                  end-string (function)

                                                  end-string-aux (generic function)

                                         start-of-end-string-p (generic function)

                                             *reg-ends* (variable)

                                         *string*-equal (function)

                                            ppcre-error (condition)

                                 ppcre-invocation-error (condition)

                                     ppcre-syntax-error (condition)

                          signal-ppcre-invocation-error (macro)

                              signal-ppcre-syntax-error (macro)

                              signal-ppcre-syntax-error* (macro)

                                          *syntax-error-string* (variable)

                                                  everything (class)

                                    create-greedy-everything-matcher (function)

                                                  everythingp (generic function)

                                              reg-expr (function)

                                    next-char-non-extended (function)

                                                  fail (function)

                                                  filter (class)

                                              set-flag (function)

                                      maybe-parse-flags (function)

                                                  flatten (generic function)

                                   insert-advance-fn (macro)

                                        make-char-from-code (function)

                                    create-ranges-from-hash (function)

                                                  gather-strings (generic function)

                                                  get-number (function)

                                                  get-quantifier (function)

                                                  get-token (function)

                                                  greedy-constant-length-closure (macro)

                                              non-greedy-constant-length-closure (macro)

                                           create-greedy-constant-length-matcher (generic function)

                                       create-non-greedy-constant-length-matcher (generic function)

                                           create-greedy-everything-matcher (function)

                                           create-greedy-matcher (generic function)

                                       create-non-greedy-matcher (generic function)

                                           create-greedy-no-zero-matcher (generic function)

                                       create-non-greedy-no-zero-matcher (generic function)

                                                  greedy-quant (function)

                                                  group (function)

                                      do-register-groups (macro)

                                         register-groups-bind (macro)

                                     add-range-to-hash (function)

                            convert-char-class-to-hash (function)

                               create-ranges-from-hash (function)

                                        make-char-hash (function)

                                            merge-hash (function)

                                   merge-inverted-hash (function)

                                           +digit-hash+ (constant)

                                 +whitespace-char-hash+ (constant)

                                       +word-char-hash+ (constant)

                                                  hyperdoc-lookup (function)

                                                  incf-after (macro)

                                     print-symbol-info (function)

                                             case-insensitive-mode-p (macro)

                                                  insert-advance-fn (macro)

                                                  insert-char-class-tester (macro)

                                       make-lexer-internal (function)

                                            merge-inverted-hash (function)

                                            ppcre-invocation-error (condition)

                                     signal-ppcre-invocation-error (macro)

                                            lexer-last-pos (function)

                                                  len (generic function)

                                            lexer-len (function)

                                            regex-length (generic function)

                                        regex-min-length (generic function)

                     constant-repetition-constant-length-closure (macro)

                                  greedy-constant-length-closure (macro)

                              non-greedy-constant-length-closure (macro)

              create-constant-repetition-constant-length-matcher (generic function)

                           create-greedy-constant-length-matcher (generic function)

                       create-non-greedy-constant-length-matcher (generic function)

                                            *zero-length-num* (variable)

                                             copy-lexer (function)

                                             make-lexer (function)

                                             make-lexer-internal (function)

                                                  lexer-last-pos (function)

                                                  lexer-len (function)

                                                  lexer-p (function)

                                                  lexer-pos (function)

                                                  lexer-reg (function)

                                                  lexer-str (function)

                                 *regex-char-code-limit* (variable)

                                            multi-line-mode-p (macro)

                                           single-line-mode-p (macro)

                                    normalize-var-list (function)

                                    regex-apropos-list (function)

                                           string-list-to-simple-string (function)

                                                  lookahead (class)

                                                  lookbehind (class)

                                                  looking-at-p (function)

                                         hyperdoc-lookup (function)

                                                  make-char-from-code (function)

                                                  make-char-hash (function)

                                                  make-lexer (function)

                                                  make-lexer-internal (function)

                                                  map-char-to-special-char-class (function)

                                       create-bmh-matcher (function)

       create-constant-repetition-constant-length-matcher (generic function)

                       create-constant-repetition-matcher (generic function)

                    create-greedy-constant-length-matcher (generic function)

                         create-greedy-everything-matcher (function)

                                    create-greedy-matcher (generic function)

                            create-greedy-no-zero-matcher (generic function)

                create-non-greedy-constant-length-matcher (generic function)

                                create-non-greedy-matcher (generic function)

                        create-non-greedy-no-zero-matcher (generic function)

                                              bmh-matcher-aux (macro)

                                           create-matcher-aux (generic function)

                                         *use-bmh-matchers* (variable)

                                              all-matches (function)

                                               do-matches (macro)

                                              all-matches-as-strings (function)

                                               do-matches-as-strings (macro)

                                                  maybe-accumulate (function)

                                                  maybe-coerce-to-simple-string (macro)

                                                  maybe-parse-flags (function)

                                                  maybe-split-repetition (function)

                                            *regs-maybe-start* (variable)

                                                  merge-hash (function)

                                                  merge-inverted-hash (function)

                                            quote-meta-chars (function)

                                            regex-min-length (generic function)

                                          compute-min-rest (generic function)

                                             case-mode (generic function)

                                 case-insensitive-mode-p (macro)

                                       multi-line-mode-p (macro)

                                      single-line-mode-p (macro)

                                        *extended-mode-p* (variable)

                                      string-case-modifier (function)

                                                  multi-line-mode-p (macro)

                                   parse-register-name-aux (function)

                                           *allow-named-registers* (variable)

                                      with-unique-names (macro)

                                                  newline-skipper (function)

                                                  next-char (function)

                                                  next-char-non-extended (function)

                                    create-greedy-no-zero-matcher (generic function)

                                create-non-greedy-no-zero-matcher (generic function)

                                        next-char-non-extended (function)

                                                  non-greedy-constant-length-closure (macro)

                                           create-non-greedy-constant-length-matcher (generic function)

                                           create-non-greedy-matcher (generic function)

                                           create-non-greedy-no-zero-matcher (generic function)

                                                  normalize-var-list (function)

                                                  nsubseq (function)

                                             *rep-num* (variable)

                                     *zero-length-num* (variable)

                                              get-number (function)

                                              try-number (function)

                                            start-of-end-string-p (generic function)

                                              end-of-string-p (function)

                                            start-of-subexpr-p (function)

                                          compute-offsets (generic function)

                                         *special-optimize-settings* (variable)

                                        *standard-optimize-settings* (variable)

                            case-insensitive-mode-p (macro)

                                    end-of-string-p (function)

                                            lexer-p (function)

                                       looking-at-p (function)

                                  multi-line-mode-p (macro)

                                 single-line-mode-p (macro)

                                   start-anchored-p (generic function)

                              start-of-end-string-p (generic function)

                                 start-of-subexpr-p (function)

                                    word-boundary-p (function)

                                        word-char-p (function)

                                   *extended-mode-p* (variable)

                                            maybe-parse-flags (function)

                                                  parse-register-name-aux (function)

                                                  parse-string (function)

                                           define-parse-tree-synonym (macro)

                                                  parse-tree-synonym (function)

                                       lexer-last-pos (function)

                                            lexer-pos (function)

                                             *end-pos* (variable)

                                      *end-string-pos* (variable)

                                      *real-start-pos* (variable)

                                           *start-pos* (variable)

                                            *last-pos-stores* (variable)

                                                  ppcre-error (condition)

                                                  ppcre-invocation-error (condition)

                                           signal-ppcre-invocation-error (macro)

                                                  ppcre-syntax-error (condition)

                                           signal-ppcre-syntax-error (macro)

                                           signal-ppcre-syntax-error* (macro)

                                                  print-symbol-info (function)

                                           greedy-quant (function)

                                                  quant (function)

                                              get-quantifier (function)

                                                  quote-meta-chars (function)

                                                  quote-sections (function)

                                           *allow-quoting* (variable)

                                              add-range-to-hash (function)

                                           create-ranges-from-hash (function)

                                             with-rebinding (macro)

                                             back-reference (class)

                                            lexer-reg (function)

                                                  reg-expr (function)

                                                  reg-seen (variable)

                                             copy-regex (generic function)

                                                  regex (class)

                                                  regex-apropos (function)

                                                  regex-apropos-aux (macro)

                                                  regex-apropos-list (function)

                                                  regex-length (generic function)

                                                  regex-min-length (generic function)

                                                  regex-replace (function)

                                                  regex-replace-all (function)

                                                  register (class)

                                               do-register-groups (macro)

                                                  register-groups-bind (macro)

                                            parse-register-name-aux (function)

                                           remove-registers (generic function)

                                     *allow-named-registers* (variable)

                                                  remove-registers (generic function)

                                      maybe-split-repetition (function)

                                                  repetition (class)

                                         constant-repetition-constant-length-closure (macro)

                                  create-constant-repetition-constant-length-matcher (generic function)

                                  create-constant-repetition-matcher (generic function)

                                            regex-replace (function)

                                            regex-replace-all (function)

                                                  replace-aux (function)

                                            build-replacement (function)

                                            build-replacement-template (generic function)

                                      compute-min-rest (generic function)

                                                  reverse-strings (function)

                                                  scan (generic function)

                                                  scan-to-strings (function)

                                           create-scanner (generic function)

                                           create-scanner-aux (function)

                                               do-scans (macro)

                                      create-char-searcher (function)

                                             char-searcher-aux (macro)

                                            quote-sections (function)

                                              reg-seen (variable)

                                                  seq (function)

                                                  seq (class)

                                                  set-flag (function)

                                *special-optimize-settings* (variable)

                               *standard-optimize-settings* (variable)

                                                  signal-ppcre-invocation-error (macro)

                                                  signal-ppcre-syntax-error (macro)

                                                  signal-ppcre-syntax-error* (macro)

                                  maybe-coerce-to-simple-string (macro)

                                   string-list-to-simple-string (function)

                                                  single-line-mode-p (macro)

                                                  skip (generic function)

                                          newline-skipper (function)

                                      map-char-to-special-char-class (function)

                                                  split (function)

                                            maybe-split-repetition (function)

                                                  standalone (class)

                                      *regs-maybe-start* (variable)

                                                  start-anchored-p (generic function)

                                                  start-of-end-string-p (generic function)

                                                  start-of-subexpr-p (function)

                                            *real-start-pos* (variable)

                                             *reg-starts* (variable)

                                        *last-pos-stores* (variable)

                                            lexer-str (function)

                                                  str (generic function)

                                                  str (class)

                                              end-string (function)

                           maybe-coerce-to-simple-string (macro)

                                            parse-string (function)

                            string-list-to-simple-string (function)

                                    *syntax-error-string* (variable)

                                 +whitespace-char-string+ (constant)

                                              end-string-aux (generic function)

                                                  string-case-modifier (function)

                                                  string-list-to-simple-string (function)

                                           end-of-string-p (function)

                                     start-of-end-string-p (generic function)

                                             *end-string-pos* (variable)

                                   all-matches-as-strings (function)

                                    do-matches-as-strings (macro)

                                           gather-strings (generic function)

                                          reverse-strings (function)

                                          scan-to-strings (function)

                                         start-of-subexpr-p (function)

                                            print-symbol-info (function)

                                define-parse-tree-synonym (macro)

                                       parse-tree-synonym (function)

                                            ppcre-syntax-error (condition)

                                     signal-ppcre-syntax-error (macro)

                                     signal-ppcre-syntax-error* (macro)

                                build-replacement-template (generic function)

                                insert-char-class-tester (macro)

                                        add-range-to-hash (function)

                               convert-char-class-to-hash (function)

                                     maybe-coerce-to-simple-string (macro)

                                      string-list-to-simple-string (function)

                                         map-char-to-special-char-class (function)

                                             scan-to-strings (function)

                                              get-token (function)

                                            unget-token (function)

                                     define-parse-tree-synonym (macro)

                                            parse-tree-synonym (function)

                                                  try-number (function)

                                                  unescape-char (function)

                                                  unget-token (function)

                                             with-unique-names (macro)

                                   *hyperdoc-base-uri* (variable)

                                        normalize-var-list (function)

                                                  void (class)

                                                  whitespacep (function)

                                                  with-rebinding (macro)

                                                  with-unique-names (macro)

                                                  word-boundary (class)

                                                  word-boundary-p (function)

                                                  word-char-p (function)

                                 create-greedy-no-zero-matcher (generic function)

                             create-non-greedy-no-zero-matcher (generic function)