Permuted Index of cl-ppcre

J
K
O
X
Y
Z
                                                  *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)