Info Catalog elisp: Regexp Example elisp: Regular Expressions

elisp: Regexp Functions

 
 33.3.3 Regular Expression Functions
 -----------------------------------
 
 These functions operate on regular expressions.
 
  -- Function: regexp-quote string
      This function returns a regular expression whose only exact match
      is STRING.  Using this regular expression in ‘looking-at’ will
      succeed only if the next characters in the buffer are STRING; using
      it in a search function will succeed if the text being searched
      contains STRING.  Regexp Search.
 
      This allows you to request an exact string match or search when
      calling a function that wants a regular expression.
 
           (regexp-quote "^The cat$")
                ⇒ "\\^The cat\\$"
 
      One use of ‘regexp-quote’ is to combine an exact string match with
      context described as a regular expression.  For example, this
      searches for the string that is the value of STRING, surrounded by
      whitespace:
 
           (re-search-forward
            (concat "\\s-" (regexp-quote string) "\\s-"))
 
  -- Function: regexp-opt strings &optional paren
      This function returns an efficient regular expression that will
      match any of the strings in the list STRINGS.  This is useful when
      you need to make matching or searching as fast as possible—for
      example, for Font Lock mode(1).
 
      The optional argument PAREN can be any of the following:
 
      a string
           The resulting regexp is preceded by PAREN and followed by
           ‘\)’, e.g.  use ‘"\\(?1:"’ to produce an explicitly numbered
           group.
 
      ‘words’
           The resulting regexp is surrounded by ‘\<\(’ and ‘\)\>’.
 
      ‘symbols’
           The resulting regexp is surrounded by ‘\_<\(’ and ‘\)\_>’
           (this is often appropriate when matching programming-language
           keywords and the like).
 
      non-‘nil’
           The resulting regexp is surrounded by ‘\(’ and ‘\)’.
 
      ‘nil’
           The resulting regexp is surrounded by ‘\(?:’ and ‘\)’, if it
           is necessary to ensure that a postfix operator appended to it
           will apply to the whole expression.
 
      The resulting regexp of ‘regexp-opt’ is equivalent to but usually
      more efficient than that of a simplified version:
 
           (defun simplified-regexp-opt (strings &optional paren)
            (let ((parens
                   (cond
                    ((stringp paren)       (cons paren "\\)"))
                    ((eq paren 'words)    '("\\<\\(" . "\\)\\>"))
                    ((eq paren 'symbols) '("\\_<\\(" . "\\)\\_>"))
                    ((null paren)          '("\\(?:" . "\\)"))
                    (t                       '("\\(" . "\\)")))))
              (concat (car paren)
                      (mapconcat 'regexp-quote strings "\\|")
                      (cdr paren))))
 
  -- Function: regexp-opt-depth regexp
      This function returns the total number of grouping constructs
      (parenthesized expressions) in REGEXP.  This does not include shy
      groups (Regexp Backslash).
 
  -- Function: regexp-opt-charset chars
      This function returns a regular expression matching a character in
      the list of characters CHARS.
 
           (regexp-opt-charset '(?a ?b ?c ?d ?e))
                ⇒ "[a-e]"
 
    ---------- Footnotes ----------
 
    (1) Note that ‘regexp-opt’ does not guarantee that its result is
 absolutely the most efficient form possible.  A hand-tuned regular
 expression can sometimes be slightly more efficient, but is almost never
 worth the effort.
 

Info Catalog elisp: Regexp Example elisp: Regular Expressions