thing-before-point-utils.el 1.0

;;; thing-before-point-utils.el  --- more thing-at-point edit functions

;; Version: 1.0

;; Copyright (C) 2006, 2007 Andreas Roehler

;; Author: Andreas Roehler <andreas.roehler@xxxxxxxxxxxxx>

;; Keywords: convenience, lisp

;; This file 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, or (at your option)
;; any later version.

;; This file 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 GNU Emacs; see the file COPYING.  If not, write to
;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.

;;; Commentary:

;; Information is given with thingatpt-utils-base.el

(require 'thingatpt-utils-base)


;;;###autoload
(defsubst list-bfpt (&optional arg ispec) 
  "Returns list before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'list arg ispec))))

;;;###autoload
(defsubst bounds-of-list-bfpt (&optional arg ispec) 
  "Returns border of list before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'list arg ispec))))

;;;###autoload
(defsubst list-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of list before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'list arg ispec))))

;;;###autoload
(defsubst list-bfpt-end-position (&optional arg ispec) 
  "Returns end position of list before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'list arg ispec))))

;;;###autoload
(defsubst copy-list-bfpt (&optional arg ispec) 
  "Returns a copy of list before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'list arg ispec))))

;;;###autoload
(defsubst separate-list-bfpt (&optional arg ispec) 
  "Returns a copy of list before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'list arg ispec))))

;;;###autoload
(defsubst comment-list-bfpt (&optional arg ispec) 
  "Returns a copy of list before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'list arg ispec))))

;;;###autoload
(defsubst doublequote-list-bfpt (&optional arg ispec) 
  "Doublequotes list before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'list 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-list-bfpt (&optional arg ispec) 
  "Singlequotes list before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'list 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-list-bfpt (&optional arg ispec) 
  "Parentizes list before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'list 'parentize arg ispec))))

;;;###autoload
(defsubst brace-list-bfpt (&optional arg ispec) 
  "Braces list before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'list 'brace arg ispec))))

;;;###autoload
(defsubst bracket-list-bfpt (&optional arg ispec) 
  "Brackets list before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'list 'bracket arg ispec))))

;;;###autoload
(defsubst kill-list-bfpt ()
  "Kills list before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'list))))

;;;;

;;;###autoload
(defsubst symbol-bfpt (&optional arg ispec) 
  "Returns symbol before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'symbol arg ispec))))

;;;###autoload
(defsubst bounds-of-symbol-bfpt (&optional arg ispec) 
  "Returns border of symbol before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'symbol arg ispec))))

;;;###autoload
(defsubst symbol-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'symbol arg ispec))))

;;;###autoload
(defsubst symbol-bfpt-end-position (&optional arg ispec) 
  "Returns end position of symbol before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'symbol arg ispec))))

;;;###autoload
(defsubst copy-symbol-bfpt (&optional arg ispec) 
  "Returns a copy of symbol before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'symbol arg ispec))))

;;;###autoload
(defsubst separate-symbol-bfpt (&optional arg ispec) 
  "Returns a copy of symbol before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'symbol arg ispec))))

;;;###autoload
(defsubst comment-symbol-bfpt (&optional arg ispec) 
  "Returns a copy of symbol before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'symbol arg ispec))))

;;;###autoload
(defsubst doublequote-symbol-bfpt (&optional arg ispec) 
  "Doublequotes symbol before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'symbol 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-symbol-bfpt (&optional arg ispec) 
  "Singlequotes symbol before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'symbol 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-symbol-bfpt (&optional arg ispec) 
  "Parentizes symbol before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'symbol 'parentize arg ispec))))

;;;###autoload
(defsubst brace-symbol-bfpt (&optional arg ispec) 
  "Braces symbol before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'symbol 'brace arg ispec))))

;;;###autoload
(defsubst bracket-symbol-bfpt (&optional arg ispec) 
  "Brackets symbol before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'symbol 'bracket arg ispec))))

;;;###autoload
(defsubst kill-symbol-bfpt ()
  "Kills symbol before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'symbol))))

;;;;

;;;###autoload
(defsubst word-bfpt (&optional arg ispec) 
  "Returns word before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward "^[:word:]")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'word arg ispec))))

;;;###autoload
(defsubst bounds-of-word-bfpt (&optional arg ispec) 
  "Returns border of word before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:word:]")
      (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'word arg ispec))))

;;;###autoload
(defsubst word-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of word before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:word:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'word arg ispec))))

;;;###autoload
(defsubst word-bfpt-end-position (&optional arg ispec) 
  "Returns end position of word before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:word:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-end 'word arg ispec))))

;;;###autoload
(defsubst copy-word-bfpt (&optional arg ispec) 
  "Returns a copy of word before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:word:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-copy 'word arg ispec))))

;;;###autoload
(defsubst separate-word-bfpt (&optional arg ispec) 
  "Returns a copy of word before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:word:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-separate 'word arg ispec))))

;;;###autoload
(defsubst comment-word-bfpt (&optional arg ispec) 
  "Returns a copy of word before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:word:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-comment 'word arg ispec))))

;;;###autoload
(defsubst doublequote-word-bfpt (&optional arg ispec) 
  "Doublequotes word before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:word:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'word 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-word-bfpt (&optional arg ispec) 
  "Singlequotes word before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:word:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'word 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-word-bfpt (&optional arg ispec) 
  "Parentizes word before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:word:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'word 'parentize arg ispec))))

;;;###autoload
(defsubst brace-word-bfpt (&optional arg ispec) 
  "Braces word before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:word:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'word 'brace arg ispec))))

;;;###autoload
(defsubst bracket-word-bfpt (&optional arg ispec) 
  "Brackets word before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:word:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'word 'bracket arg ispec))))

;;;###autoload
(defsubst kill-word-bfpt ()
  "Kills word before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward "^[:word:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-kill 'word))))

;;;;

;;;###autoload
(defsubst sexp-bfpt (&optional arg ispec) 
  "Returns sexp before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'sexp arg ispec))))

;;;###autoload
(defsubst bounds-of-sexp-bfpt (&optional arg ispec) 
  "Returns border of sexp before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'sexp arg ispec))))

;;;###autoload
(defsubst sexp-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of sexp before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'sexp arg ispec))))

;;;###autoload
(defsubst sexp-bfpt-end-position (&optional arg ispec) 
  "Returns end position of sexp before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'sexp arg ispec))))

;;;###autoload
(defsubst copy-sexp-bfpt (&optional arg ispec) 
  "Returns a copy of sexp before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'sexp arg ispec))))

;;;###autoload
(defsubst separate-sexp-bfpt (&optional arg ispec) 
  "Returns a copy of sexp before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'sexp arg ispec))))

;;;###autoload
(defsubst comment-sexp-bfpt (&optional arg ispec) 
  "Returns a copy of sexp before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'sexp arg ispec))))

;;;###autoload
(defsubst doublequote-sexp-bfpt (&optional arg ispec) 
  "Doublequotes sexp before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'sexp 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-sexp-bfpt (&optional arg ispec) 
  "Singlequotes sexp before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'sexp 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-sexp-bfpt (&optional arg ispec) 
  "Parentizes sexp before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'sexp 'parentize arg ispec))))

;;;###autoload
(defsubst brace-sexp-bfpt (&optional arg ispec) 
  "Braces sexp before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'sexp 'brace arg ispec))))

;;;###autoload
(defsubst bracket-sexp-bfpt (&optional arg ispec) 
  "Brackets sexp before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'sexp 'bracket arg ispec))))

;;;###autoload
(defsubst kill-sexp-bfpt ()
  "Kills sexp before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'sexp))))

;;;;

;;;###autoload
(defsubst paragraph-bfpt (&optional arg ispec) 
  "Returns paragraph before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'paragraph arg ispec))))

;;;###autoload
(defsubst bounds-of-paragraph-bfpt (&optional arg ispec) 
  "Returns border of paragraph before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'paragraph arg ispec))))

;;;###autoload
(defsubst paragraph-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of paragraph before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'paragraph arg ispec))))

;;;###autoload
(defsubst paragraph-bfpt-end-position (&optional arg ispec) 
  "Returns end position of paragraph before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'paragraph arg ispec))))

;;;###autoload
(defsubst copy-paragraph-bfpt (&optional arg ispec) 
  "Returns a copy of paragraph before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'paragraph arg ispec))))

;;;###autoload
(defsubst separate-paragraph-bfpt (&optional arg ispec) 
  "Returns a copy of paragraph before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'paragraph arg ispec))))

;;;###autoload
(defsubst comment-paragraph-bfpt (&optional arg ispec) 
  "Returns a copy of paragraph before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'paragraph arg ispec))))

;;;###autoload
(defsubst doublequote-paragraph-bfpt (&optional arg ispec) 
  "Doublequotes paragraph before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'paragraph 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-paragraph-bfpt (&optional arg ispec) 
  "Singlequotes paragraph before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'paragraph 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-paragraph-bfpt (&optional arg ispec) 
  "Parentizes paragraph before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'paragraph 'parentize arg ispec))))

;;;###autoload
(defsubst brace-paragraph-bfpt (&optional arg ispec) 
  "Braces paragraph before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'paragraph 'brace arg ispec))))

;;;###autoload
(defsubst bracket-paragraph-bfpt (&optional arg ispec) 
  "Brackets paragraph before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'paragraph 'bracket arg ispec))))

;;;###autoload
(defsubst kill-paragraph-bfpt ()
  "Kills paragraph before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'paragraph))))

;;;;

;;;###autoload
(defsubst string-bfpt (&optional arg ispec) 
  "Returns string before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'string arg ispec))))

;;;###autoload
(defsubst bounds-of-string-bfpt (&optional arg ispec) 
  "Returns border of string before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'string arg ispec))))

;;;###autoload
(defsubst string-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of string before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'string arg ispec))))

;;;###autoload
(defsubst string-bfpt-end-position (&optional arg ispec) 
  "Returns end position of string before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'string arg ispec))))

;;;###autoload
(defsubst copy-string-bfpt (&optional arg ispec) 
  "Returns a copy of string before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'string arg ispec))))

;;;###autoload
(defsubst separate-string-bfpt (&optional arg ispec) 
  "Returns a copy of string before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'string arg ispec))))

;;;###autoload
(defsubst comment-string-bfpt (&optional arg ispec) 
  "Returns a copy of string before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'string arg ispec))))

;;;###autoload
(defsubst doublequote-string-bfpt (&optional arg ispec) 
  "Doublequotes string before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'string 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-string-bfpt (&optional arg ispec) 
  "Singlequotes string before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'string 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-string-bfpt (&optional arg ispec) 
  "Parentizes string before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'string 'parentize arg ispec))))

;;;###autoload
(defsubst brace-string-bfpt (&optional arg ispec) 
  "Braces string before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'string 'brace arg ispec))))

;;;###autoload
(defsubst bracket-string-bfpt (&optional arg ispec) 
  "Brackets string before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'string 'bracket arg ispec))))

;;;###autoload
(defsubst kill-string-bfpt ()
  "Kills string before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'string))))

;;;;

;;;###autoload
(defsubst line-bfpt (&optional arg ispec) 
  "Returns line before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'line arg ispec))))

;;;###autoload
(defsubst bounds-of-line-bfpt (&optional arg ispec) 
  "Returns border of line before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'line arg ispec))))

;;;###autoload
(defsubst line-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of line before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'line arg ispec))))

;;;###autoload
(defsubst line-bfpt-end-position (&optional arg ispec) 
  "Returns end position of line before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'line arg ispec))))

;;;###autoload
(defsubst copy-line-bfpt (&optional arg ispec) 
  "Returns a copy of line before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'line arg ispec))))

;;;###autoload
(defsubst separate-line-bfpt (&optional arg ispec) 
  "Returns a copy of line before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'line arg ispec))))

;;;###autoload
(defsubst comment-line-bfpt (&optional arg ispec) 
  "Returns a copy of line before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'line arg ispec))))

;;;###autoload
(defsubst doublequote-line-bfpt (&optional arg ispec) 
  "Doublequotes line before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'line 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-line-bfpt (&optional arg ispec) 
  "Singlequotes line before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'line 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-line-bfpt (&optional arg ispec) 
  "Parentizes line before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'line 'parentize arg ispec))))

;;;###autoload
(defsubst brace-line-bfpt (&optional arg ispec) 
  "Braces line before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'line 'brace arg ispec))))

;;;###autoload
(defsubst bracket-line-bfpt (&optional arg ispec) 
  "Brackets line before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'line 'bracket arg ispec))))

;;;###autoload
(defsubst kill-line-bfpt ()
  "Kills line before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'line))))

;;;;

;;;###autoload
(defsubst sentence-bfpt (&optional arg ispec) 
  "Returns sentence before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'sentence arg ispec))))

;;;###autoload
(defsubst bounds-of-sentence-bfpt (&optional arg ispec) 
  "Returns border of sentence before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'sentence arg ispec))))

;;;###autoload
(defsubst sentence-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of sentence before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'sentence arg ispec))))

;;;###autoload
(defsubst sentence-bfpt-end-position (&optional arg ispec) 
  "Returns end position of sentence before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'sentence arg ispec))))

;;;###autoload
(defsubst copy-sentence-bfpt (&optional arg ispec) 
  "Returns a copy of sentence before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'sentence arg ispec))))

;;;###autoload
(defsubst separate-sentence-bfpt (&optional arg ispec) 
  "Returns a copy of sentence before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'sentence arg ispec))))

;;;###autoload
(defsubst comment-sentence-bfpt (&optional arg ispec) 
  "Returns a copy of sentence before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'sentence arg ispec))))

;;;###autoload
(defsubst doublequote-sentence-bfpt (&optional arg ispec) 
  "Doublequotes sentence before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'sentence 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-sentence-bfpt (&optional arg ispec) 
  "Singlequotes sentence before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'sentence 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-sentence-bfpt (&optional arg ispec) 
  "Parentizes sentence before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'sentence 'parentize arg ispec))))

;;;###autoload
(defsubst brace-sentence-bfpt (&optional arg ispec) 
  "Braces sentence before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'sentence 'brace arg ispec))))

;;;###autoload
(defsubst bracket-sentence-bfpt (&optional arg ispec) 
  "Brackets sentence before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'sentence 'bracket arg ispec))))

;;;###autoload
(defsubst kill-sentence-bfpt ()
  "Kills sentence before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'sentence))))

;;;;

;;;###autoload
(defsubst defun-bfpt (&optional arg ispec) 
  "Returns defun before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'defun arg ispec))))

;;;###autoload
(defsubst bounds-of-defun-bfpt (&optional arg ispec) 
  "Returns border of defun before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'defun arg ispec))))

;;;###autoload
(defsubst defun-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of defun before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'defun arg ispec))))

;;;###autoload
(defsubst defun-bfpt-end-position (&optional arg ispec) 
  "Returns end position of defun before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'defun arg ispec))))

;;;###autoload
(defsubst copy-defun-bfpt (&optional arg ispec) 
  "Returns a copy of defun before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'defun arg ispec))))

;;;###autoload
(defsubst separate-defun-bfpt (&optional arg ispec) 
  "Returns a copy of defun before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'defun arg ispec))))

;;;###autoload
(defsubst comment-defun-bfpt (&optional arg ispec) 
  "Returns a copy of defun before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'defun arg ispec))))

;;;###autoload
(defsubst doublequote-defun-bfpt (&optional arg ispec) 
  "Doublequotes defun before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'defun 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-defun-bfpt (&optional arg ispec) 
  "Singlequotes defun before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'defun 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-defun-bfpt (&optional arg ispec) 
  "Parentizes defun before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'defun 'parentize arg ispec))))

;;;###autoload
(defsubst brace-defun-bfpt (&optional arg ispec) 
  "Braces defun before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'defun 'brace arg ispec))))

;;;###autoload
(defsubst bracket-defun-bfpt (&optional arg ispec) 
  "Brackets defun before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'defun 'bracket arg ispec))))

;;;###autoload
(defsubst kill-defun-bfpt ()
  "Kills defun before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'defun))))

;;;;

;;;###autoload
(defsubst email-bfpt (&optional arg ispec) 
  "Returns email before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'email arg ispec))))

;;;###autoload
(defsubst bounds-of-email-bfpt (&optional arg ispec) 
  "Returns border of email before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'email arg ispec))))

;;;###autoload
(defsubst email-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of email before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'email arg ispec))))

;;;###autoload
(defsubst email-bfpt-end-position (&optional arg ispec) 
  "Returns end position of email before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'email arg ispec))))

;;;###autoload
(defsubst copy-email-bfpt (&optional arg ispec) 
  "Returns a copy of email before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'email arg ispec))))

;;;###autoload
(defsubst separate-email-bfpt (&optional arg ispec) 
  "Returns a copy of email before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'email arg ispec))))

;;;###autoload
(defsubst comment-email-bfpt (&optional arg ispec) 
  "Returns a copy of email before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'email arg ispec))))

;;;###autoload
(defsubst doublequote-email-bfpt (&optional arg ispec) 
  "Doublequotes email before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'email 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-email-bfpt (&optional arg ispec) 
  "Singlequotes email before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'email 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-email-bfpt (&optional arg ispec) 
  "Parentizes email before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'email 'parentize arg ispec))))

;;;###autoload
(defsubst brace-email-bfpt (&optional arg ispec) 
  "Braces email before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'email 'brace arg ispec))))

;;;###autoload
(defsubst bracket-email-bfpt (&optional arg ispec) 
  "Brackets email before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'email 'bracket arg ispec))))

;;;###autoload
(defsubst kill-email-bfpt ()
  "Kills email before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'email))))

;;;;

;;;###autoload
(defsubst csv-bfpt (&optional arg ispec) 
  "Returns csv before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'csv arg ispec))))

;;;###autoload
(defsubst bounds-of-csv-bfpt (&optional arg ispec) 
  "Returns border of csv before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'csv arg ispec))))

;;;###autoload
(defsubst csv-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of csv before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'csv arg ispec))))

;;;###autoload
(defsubst csv-bfpt-end-position (&optional arg ispec) 
  "Returns end position of csv before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'csv arg ispec))))

;;;###autoload
(defsubst copy-csv-bfpt (&optional arg ispec) 
  "Returns a copy of csv before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'csv arg ispec))))

;;;###autoload
(defsubst separate-csv-bfpt (&optional arg ispec) 
  "Returns a copy of csv before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'csv arg ispec))))

;;;###autoload
(defsubst comment-csv-bfpt (&optional arg ispec) 
  "Returns a copy of csv before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'csv arg ispec))))

;;;###autoload
(defsubst doublequote-csv-bfpt (&optional arg ispec) 
  "Doublequotes csv before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'csv 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-csv-bfpt (&optional arg ispec) 
  "Singlequotes csv before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'csv 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-csv-bfpt (&optional arg ispec) 
  "Parentizes csv before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'csv 'parentize arg ispec))))

;;;###autoload
(defsubst brace-csv-bfpt (&optional arg ispec) 
  "Braces csv before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'csv 'brace arg ispec))))

;;;###autoload
(defsubst bracket-csv-bfpt (&optional arg ispec) 
  "Brackets csv before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'csv 'bracket arg ispec))))

;;;###autoload
(defsubst kill-csv-bfpt ()
  "Kills csv before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'csv))))

;;;;

;;;###autoload
(defsubst phone-bfpt (&optional arg ispec) 
  "Returns phone before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'phone arg ispec))))

;;;###autoload
(defsubst bounds-of-phone-bfpt (&optional arg ispec) 
  "Returns border of phone before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'phone arg ispec))))

;;;###autoload
(defsubst phone-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of phone before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'phone arg ispec))))

;;;###autoload
(defsubst phone-bfpt-end-position (&optional arg ispec) 
  "Returns end position of phone before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'phone arg ispec))))

;;;###autoload
(defsubst copy-phone-bfpt (&optional arg ispec) 
  "Returns a copy of phone before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'phone arg ispec))))

;;;###autoload
(defsubst separate-phone-bfpt (&optional arg ispec) 
  "Returns a copy of phone before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'phone arg ispec))))

;;;###autoload
(defsubst comment-phone-bfpt (&optional arg ispec) 
  "Returns a copy of phone before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'phone arg ispec))))

;;;###autoload
(defsubst doublequote-phone-bfpt (&optional arg ispec) 
  "Doublequotes phone before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'phone 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-phone-bfpt (&optional arg ispec) 
  "Singlequotes phone before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'phone 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-phone-bfpt (&optional arg ispec) 
  "Parentizes phone before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'phone 'parentize arg ispec))))

;;;###autoload
(defsubst brace-phone-bfpt (&optional arg ispec) 
  "Braces phone before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'phone 'brace arg ispec))))

;;;###autoload
(defsubst bracket-phone-bfpt (&optional arg ispec) 
  "Brackets phone before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'phone 'bracket arg ispec))))

;;;###autoload
(defsubst kill-phone-bfpt ()
  "Kills phone before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'phone))))

;;;;

;;;###autoload
(defsubst ml-text-bfpt (&optional arg ispec) 
  "Returns ml-text before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'ml-text arg ispec))))

;;;###autoload
(defsubst bounds-of-ml-text-bfpt (&optional arg ispec) 
  "Returns border of ml-text before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'ml-text arg ispec))))

;;;###autoload
(defsubst ml-text-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of ml-text before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'ml-text arg ispec))))

;;;###autoload
(defsubst ml-text-bfpt-end-position (&optional arg ispec) 
  "Returns end position of ml-text before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'ml-text arg ispec))))

;;;###autoload
(defsubst copy-ml-text-bfpt (&optional arg ispec) 
  "Returns a copy of ml-text before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'ml-text arg ispec))))

;;;###autoload
(defsubst separate-ml-text-bfpt (&optional arg ispec) 
  "Returns a copy of ml-text before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'ml-text arg ispec))))

;;;###autoload
(defsubst comment-ml-text-bfpt (&optional arg ispec) 
  "Returns a copy of ml-text before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'ml-text arg ispec))))

;;;###autoload
(defsubst doublequote-ml-text-bfpt (&optional arg ispec) 
  "Doublequotes ml-text before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'ml-text 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-ml-text-bfpt (&optional arg ispec) 
  "Singlequotes ml-text before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'ml-text 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-ml-text-bfpt (&optional arg ispec) 
  "Parentizes ml-text before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'ml-text 'parentize arg ispec))))

;;;###autoload
(defsubst brace-ml-text-bfpt (&optional arg ispec) 
  "Braces ml-text before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'ml-text 'brace arg ispec))))

;;;###autoload
(defsubst bracket-ml-text-bfpt (&optional arg ispec) 
  "Brackets ml-text before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'ml-text 'bracket arg ispec))))

;;;###autoload
(defsubst kill-ml-text-bfpt ()
  "Kills ml-text before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'ml-text))))

;;;;

;;;###autoload
(defsubst filename-bfpt (&optional arg ispec) 
  "Returns filename before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'filename arg ispec))))

;;;###autoload
(defsubst bounds-of-filename-bfpt (&optional arg ispec) 
  "Returns border of filename before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'filename arg ispec))))

;;;###autoload
(defsubst filename-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of filename before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'filename arg ispec))))

;;;###autoload
(defsubst filename-bfpt-end-position (&optional arg ispec) 
  "Returns end position of filename before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'filename arg ispec))))

;;;###autoload
(defsubst copy-filename-bfpt (&optional arg ispec) 
  "Returns a copy of filename before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'filename arg ispec))))

;;;###autoload
(defsubst separate-filename-bfpt (&optional arg ispec) 
  "Returns a copy of filename before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'filename arg ispec))))

;;;###autoload
(defsubst comment-filename-bfpt (&optional arg ispec) 
  "Returns a copy of filename before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'filename arg ispec))))

;;;###autoload
(defsubst doublequote-filename-bfpt (&optional arg ispec) 
  "Doublequotes filename before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'filename 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-filename-bfpt (&optional arg ispec) 
  "Singlequotes filename before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'filename 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-filename-bfpt (&optional arg ispec) 
  "Parentizes filename before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'filename 'parentize arg ispec))))

;;;###autoload
(defsubst brace-filename-bfpt (&optional arg ispec) 
  "Braces filename before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'filename 'brace arg ispec))))

;;;###autoload
(defsubst bracket-filename-bfpt (&optional arg ispec) 
  "Brackets filename before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'filename 'bracket arg ispec))))

;;;###autoload
(defsubst kill-filename-bfpt ()
  "Kills filename before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'filename))))

;;;;

;;;###autoload
(defsubst url-bfpt (&optional arg ispec) 
  "Returns url before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'url arg ispec))))

;;;###autoload
(defsubst bounds-of-url-bfpt (&optional arg ispec) 
  "Returns border of url before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'url arg ispec))))

;;;###autoload
(defsubst url-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of url before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'url arg ispec))))

;;;###autoload
(defsubst url-bfpt-end-position (&optional arg ispec) 
  "Returns end position of url before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'url arg ispec))))

;;;###autoload
(defsubst copy-url-bfpt (&optional arg ispec) 
  "Returns a copy of url before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'url arg ispec))))

;;;###autoload
(defsubst separate-url-bfpt (&optional arg ispec) 
  "Returns a copy of url before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'url arg ispec))))

;;;###autoload
(defsubst comment-url-bfpt (&optional arg ispec) 
  "Returns a copy of url before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'url arg ispec))))

;;;###autoload
(defsubst doublequote-url-bfpt (&optional arg ispec) 
  "Doublequotes url before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'url 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-url-bfpt (&optional arg ispec) 
  "Singlequotes url before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'url 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-url-bfpt (&optional arg ispec) 
  "Parentizes url before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'url 'parentize arg ispec))))

;;;###autoload
(defsubst brace-url-bfpt (&optional arg ispec) 
  "Braces url before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'url 'brace arg ispec))))

;;;###autoload
(defsubst bracket-url-bfpt (&optional arg ispec) 
  "Brackets url before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'url 'bracket arg ispec))))

;;;###autoload
(defsubst kill-url-bfpt ()
  "Kills url before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'url))))

;;;;

;;;###autoload
(defsubst number-bfpt (&optional arg ispec) 
  "Returns number before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'number arg ispec))))

;;;###autoload
(defsubst bounds-of-number-bfpt (&optional arg ispec) 
  "Returns border of number before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'number arg ispec))))

;;;###autoload
(defsubst number-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of number before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'number arg ispec))))

;;;###autoload
(defsubst number-bfpt-end-position (&optional arg ispec) 
  "Returns end position of number before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'number arg ispec))))

;;;###autoload
(defsubst copy-number-bfpt (&optional arg ispec) 
  "Returns a copy of number before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'number arg ispec))))

;;;###autoload
(defsubst separate-number-bfpt (&optional arg ispec) 
  "Returns a copy of number before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'number arg ispec))))

;;;###autoload
(defsubst comment-number-bfpt (&optional arg ispec) 
  "Returns a copy of number before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'number arg ispec))))

;;;###autoload
(defsubst doublequote-number-bfpt (&optional arg ispec) 
  "Doublequotes number before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'number 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-number-bfpt (&optional arg ispec) 
  "Singlequotes number before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'number 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-number-bfpt (&optional arg ispec) 
  "Parentizes number before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'number 'parentize arg ispec))))

;;;###autoload
(defsubst brace-number-bfpt (&optional arg ispec) 
  "Braces number before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'number 'brace arg ispec))))

;;;###autoload
(defsubst bracket-number-bfpt (&optional arg ispec) 
  "Brackets number before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'number 'bracket arg ispec))))

;;;###autoload
(defsubst kill-number-bfpt ()
  "Kills number before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'number))))

;;;;

;;;###autoload
(defsubst float-bfpt (&optional arg ispec) 
  "Returns float before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'float arg ispec))))

;;;###autoload
(defsubst bounds-of-float-bfpt (&optional arg ispec) 
  "Returns border of float before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'float arg ispec))))

;;;###autoload
(defsubst float-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of float before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'float arg ispec))))

;;;###autoload
(defsubst float-bfpt-end-position (&optional arg ispec) 
  "Returns end position of float before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'float arg ispec))))

;;;###autoload
(defsubst copy-float-bfpt (&optional arg ispec) 
  "Returns a copy of float before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'float arg ispec))))

;;;###autoload
(defsubst separate-float-bfpt (&optional arg ispec) 
  "Returns a copy of float before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'float arg ispec))))

;;;###autoload
(defsubst comment-float-bfpt (&optional arg ispec) 
  "Returns a copy of float before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'float arg ispec))))

;;;###autoload
(defsubst doublequote-float-bfpt (&optional arg ispec) 
  "Doublequotes float before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'float 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-float-bfpt (&optional arg ispec) 
  "Singlequotes float before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'float 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-float-bfpt (&optional arg ispec) 
  "Parentizes float before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'float 'parentize arg ispec))))

;;;###autoload
(defsubst brace-float-bfpt (&optional arg ispec) 
  "Braces float before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'float 'brace arg ispec))))

;;;###autoload
(defsubst bracket-float-bfpt (&optional arg ispec) 
  "Brackets float before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'float 'bracket arg ispec))))

;;;###autoload
(defsubst kill-float-bfpt ()
  "Kills float before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'float))))

;;;;

;;;###autoload
(defsubst page-bfpt (&optional arg ispec) 
  "Returns page before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'page arg ispec))))

;;;###autoload
(defsubst bounds-of-page-bfpt (&optional arg ispec) 
  "Returns border of page before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'page arg ispec))))

;;;###autoload
(defsubst page-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of page before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'page arg ispec))))

;;;###autoload
(defsubst page-bfpt-end-position (&optional arg ispec) 
  "Returns end position of page before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'page arg ispec))))

;;;###autoload
(defsubst copy-page-bfpt (&optional arg ispec) 
  "Returns a copy of page before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'page arg ispec))))

;;;###autoload
(defsubst separate-page-bfpt (&optional arg ispec) 
  "Returns a copy of page before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'page arg ispec))))

;;;###autoload
(defsubst comment-page-bfpt (&optional arg ispec) 
  "Returns a copy of page before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'page arg ispec))))

;;;###autoload
(defsubst doublequote-page-bfpt (&optional arg ispec) 
  "Doublequotes page before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'page 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-page-bfpt (&optional arg ispec) 
  "Singlequotes page before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'page 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-page-bfpt (&optional arg ispec) 
  "Parentizes page before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'page 'parentize arg ispec))))

;;;###autoload
(defsubst brace-page-bfpt (&optional arg ispec) 
  "Braces page before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'page 'brace arg ispec))))

;;;###autoload
(defsubst bracket-page-bfpt (&optional arg ispec) 
  "Brackets page before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'page 'bracket arg ispec))))

;;;###autoload
(defsubst kill-page-bfpt ()
  "Kills page before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'page))))

;;;;

;;;###autoload
(defsubst whitespace-bfpt (&optional arg ispec) 
  "Returns whitespace before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward " \t\n\r\f")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'whitespace arg ispec))))

;;;###autoload
(defsubst bounds-of-whitespace-bfpt (&optional arg ispec) 
  "Returns border of whitespace before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'whitespace arg ispec))))

;;;###autoload
(defsubst whitespace-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of whitespace before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'whitespace arg ispec))))

;;;###autoload
(defsubst whitespace-bfpt-end-position (&optional arg ispec) 
  "Returns end position of whitespace before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-end 'whitespace arg ispec))))

;;;###autoload
(defsubst copy-whitespace-bfpt (&optional arg ispec) 
  "Returns a copy of whitespace before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-copy 'whitespace arg ispec))))

;;;###autoload
(defsubst separate-whitespace-bfpt (&optional arg ispec) 
  "Returns a copy of whitespace before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-separate 'whitespace arg ispec))))

;;;###autoload
(defsubst comment-whitespace-bfpt (&optional arg ispec) 
  "Returns a copy of whitespace before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-comment 'whitespace arg ispec))))

;;;###autoload
(defsubst doublequote-whitespace-bfpt (&optional arg ispec) 
  "Doublequotes whitespace before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'whitespace 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-whitespace-bfpt (&optional arg ispec) 
  "Singlequotes whitespace before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'whitespace 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-whitespace-bfpt (&optional arg ispec) 
  "Parentizes whitespace before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'whitespace 'parentize arg ispec))))

;;;###autoload
(defsubst brace-whitespace-bfpt (&optional arg ispec) 
  "Braces whitespace before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'whitespace 'brace arg ispec))))

;;;###autoload
(defsubst bracket-whitespace-bfpt (&optional arg ispec) 
  "Brackets whitespace before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-delim 'whitespace 'bracket arg ispec))))

;;;###autoload
(defsubst kill-whitespace-bfpt ()
  "Kills whitespace before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward " \t\n\r\f")
       (unless (bobp)
  (forward-char -1)  (thatpt-kill 'whitespace))))

;;;;

;;;###autoload
(defsubst alnum-bfpt (&optional arg ispec) 
  "Returns alnum before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward "^[:alnum:]")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'alnum arg ispec))))

;;;###autoload
(defsubst bounds-of-alnum-bfpt (&optional arg ispec) 
  "Returns border of alnum before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alnum:]")
      (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'alnum arg ispec))))

;;;###autoload
(defsubst alnum-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of alnum before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alnum:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'alnum arg ispec))))

;;;###autoload
(defsubst alnum-bfpt-end-position (&optional arg ispec) 
  "Returns end position of alnum before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alnum:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-end 'alnum arg ispec))))

;;;###autoload
(defsubst copy-alnum-bfpt (&optional arg ispec) 
  "Returns a copy of alnum before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alnum:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-copy 'alnum arg ispec))))

;;;###autoload
(defsubst separate-alnum-bfpt (&optional arg ispec) 
  "Returns a copy of alnum before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alnum:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-separate 'alnum arg ispec))))

;;;###autoload
(defsubst comment-alnum-bfpt (&optional arg ispec) 
  "Returns a copy of alnum before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alnum:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-comment 'alnum arg ispec))))

;;;###autoload
(defsubst doublequote-alnum-bfpt (&optional arg ispec) 
  "Doublequotes alnum before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alnum:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'alnum 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-alnum-bfpt (&optional arg ispec) 
  "Singlequotes alnum before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alnum:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'alnum 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-alnum-bfpt (&optional arg ispec) 
  "Parentizes alnum before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alnum:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'alnum 'parentize arg ispec))))

;;;###autoload
(defsubst brace-alnum-bfpt (&optional arg ispec) 
  "Braces alnum before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alnum:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'alnum 'brace arg ispec))))

;;;###autoload
(defsubst bracket-alnum-bfpt (&optional arg ispec) 
  "Brackets alnum before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alnum:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'alnum 'bracket arg ispec))))

;;;###autoload
(defsubst kill-alnum-bfpt ()
  "Kills alnum before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward "^[:alnum:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-kill 'alnum))))

;;;;

;;;###autoload
(defsubst alpha-bfpt (&optional arg ispec) 
  "Returns alpha before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward "^[:alpha:]")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'alpha arg ispec))))

;;;###autoload
(defsubst bounds-of-alpha-bfpt (&optional arg ispec) 
  "Returns border of alpha before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alpha:]")
      (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'alpha arg ispec))))

;;;###autoload
(defsubst alpha-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of alpha before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alpha:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'alpha arg ispec))))

;;;###autoload
(defsubst alpha-bfpt-end-position (&optional arg ispec) 
  "Returns end position of alpha before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alpha:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-end 'alpha arg ispec))))

;;;###autoload
(defsubst copy-alpha-bfpt (&optional arg ispec) 
  "Returns a copy of alpha before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alpha:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-copy 'alpha arg ispec))))

;;;###autoload
(defsubst separate-alpha-bfpt (&optional arg ispec) 
  "Returns a copy of alpha before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alpha:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-separate 'alpha arg ispec))))

;;;###autoload
(defsubst comment-alpha-bfpt (&optional arg ispec) 
  "Returns a copy of alpha before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alpha:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-comment 'alpha arg ispec))))

;;;###autoload
(defsubst doublequote-alpha-bfpt (&optional arg ispec) 
  "Doublequotes alpha before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alpha:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'alpha 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-alpha-bfpt (&optional arg ispec) 
  "Singlequotes alpha before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alpha:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'alpha 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-alpha-bfpt (&optional arg ispec) 
  "Parentizes alpha before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alpha:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'alpha 'parentize arg ispec))))

;;;###autoload
(defsubst brace-alpha-bfpt (&optional arg ispec) 
  "Braces alpha before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alpha:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'alpha 'brace arg ispec))))

;;;###autoload
(defsubst bracket-alpha-bfpt (&optional arg ispec) 
  "Brackets alpha before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:alpha:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'alpha 'bracket arg ispec))))

;;;###autoload
(defsubst kill-alpha-bfpt ()
  "Kills alpha before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward "^[:alpha:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-kill 'alpha))))

;;;;

;;;###autoload
(defsubst ascii-bfpt (&optional arg ispec) 
  "Returns ascii before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward "^[:ascii:]")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'ascii arg ispec))))

;;;###autoload
(defsubst bounds-of-ascii-bfpt (&optional arg ispec) 
  "Returns border of ascii before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:ascii:]")
      (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'ascii arg ispec))))

;;;###autoload
(defsubst ascii-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of ascii before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:ascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'ascii arg ispec))))

;;;###autoload
(defsubst ascii-bfpt-end-position (&optional arg ispec) 
  "Returns end position of ascii before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:ascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-end 'ascii arg ispec))))

;;;###autoload
(defsubst copy-ascii-bfpt (&optional arg ispec) 
  "Returns a copy of ascii before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:ascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-copy 'ascii arg ispec))))

;;;###autoload
(defsubst separate-ascii-bfpt (&optional arg ispec) 
  "Returns a copy of ascii before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:ascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-separate 'ascii arg ispec))))

;;;###autoload
(defsubst comment-ascii-bfpt (&optional arg ispec) 
  "Returns a copy of ascii before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:ascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-comment 'ascii arg ispec))))

;;;###autoload
(defsubst doublequote-ascii-bfpt (&optional arg ispec) 
  "Doublequotes ascii before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:ascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'ascii 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-ascii-bfpt (&optional arg ispec) 
  "Singlequotes ascii before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:ascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'ascii 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-ascii-bfpt (&optional arg ispec) 
  "Parentizes ascii before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:ascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'ascii 'parentize arg ispec))))

;;;###autoload
(defsubst brace-ascii-bfpt (&optional arg ispec) 
  "Braces ascii before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:ascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'ascii 'brace arg ispec))))

;;;###autoload
(defsubst bracket-ascii-bfpt (&optional arg ispec) 
  "Brackets ascii before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:ascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'ascii 'bracket arg ispec))))

;;;###autoload
(defsubst kill-ascii-bfpt ()
  "Kills ascii before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward "^[:ascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-kill 'ascii))))

;;;;

;;;###autoload
(defsubst blank-bfpt (&optional arg ispec) 
  "Returns blank before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward "^[:blank:]")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'blank arg ispec))))

;;;###autoload
(defsubst bounds-of-blank-bfpt (&optional arg ispec) 
  "Returns border of blank before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:blank:]")
      (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'blank arg ispec))))

;;;###autoload
(defsubst blank-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of blank before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:blank:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'blank arg ispec))))

;;;###autoload
(defsubst blank-bfpt-end-position (&optional arg ispec) 
  "Returns end position of blank before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:blank:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-end 'blank arg ispec))))

;;;###autoload
(defsubst copy-blank-bfpt (&optional arg ispec) 
  "Returns a copy of blank before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:blank:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-copy 'blank arg ispec))))

;;;###autoload
(defsubst separate-blank-bfpt (&optional arg ispec) 
  "Returns a copy of blank before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:blank:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-separate 'blank arg ispec))))

;;;###autoload
(defsubst comment-blank-bfpt (&optional arg ispec) 
  "Returns a copy of blank before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:blank:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-comment 'blank arg ispec))))

;;;###autoload
(defsubst doublequote-blank-bfpt (&optional arg ispec) 
  "Doublequotes blank before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:blank:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'blank 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-blank-bfpt (&optional arg ispec) 
  "Singlequotes blank before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:blank:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'blank 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-blank-bfpt (&optional arg ispec) 
  "Parentizes blank before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:blank:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'blank 'parentize arg ispec))))

;;;###autoload
(defsubst brace-blank-bfpt (&optional arg ispec) 
  "Braces blank before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:blank:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'blank 'brace arg ispec))))

;;;###autoload
(defsubst bracket-blank-bfpt (&optional arg ispec) 
  "Brackets blank before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:blank:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'blank 'bracket arg ispec))))

;;;###autoload
(defsubst kill-blank-bfpt ()
  "Kills blank before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward "^[:blank:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-kill 'blank))))

;;;;

;;;###autoload
(defsubst cntrl-bfpt (&optional arg ispec) 
  "Returns cntrl before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward "^[:cntrl:]")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'cntrl arg ispec))))

;;;###autoload
(defsubst bounds-of-cntrl-bfpt (&optional arg ispec) 
  "Returns border of cntrl before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:cntrl:]")
      (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'cntrl arg ispec))))

;;;###autoload
(defsubst cntrl-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of cntrl before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:cntrl:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'cntrl arg ispec))))

;;;###autoload
(defsubst cntrl-bfpt-end-position (&optional arg ispec) 
  "Returns end position of cntrl before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:cntrl:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-end 'cntrl arg ispec))))

;;;###autoload
(defsubst copy-cntrl-bfpt (&optional arg ispec) 
  "Returns a copy of cntrl before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:cntrl:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-copy 'cntrl arg ispec))))

;;;###autoload
(defsubst separate-cntrl-bfpt (&optional arg ispec) 
  "Returns a copy of cntrl before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:cntrl:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-separate 'cntrl arg ispec))))

;;;###autoload
(defsubst comment-cntrl-bfpt (&optional arg ispec) 
  "Returns a copy of cntrl before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:cntrl:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-comment 'cntrl arg ispec))))

;;;###autoload
(defsubst doublequote-cntrl-bfpt (&optional arg ispec) 
  "Doublequotes cntrl before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:cntrl:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'cntrl 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-cntrl-bfpt (&optional arg ispec) 
  "Singlequotes cntrl before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:cntrl:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'cntrl 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-cntrl-bfpt (&optional arg ispec) 
  "Parentizes cntrl before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:cntrl:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'cntrl 'parentize arg ispec))))

;;;###autoload
(defsubst brace-cntrl-bfpt (&optional arg ispec) 
  "Braces cntrl before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:cntrl:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'cntrl 'brace arg ispec))))

;;;###autoload
(defsubst bracket-cntrl-bfpt (&optional arg ispec) 
  "Brackets cntrl before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:cntrl:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'cntrl 'bracket arg ispec))))

;;;###autoload
(defsubst kill-cntrl-bfpt ()
  "Kills cntrl before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward "^[:cntrl:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-kill 'cntrl))))

;;;;

;;;###autoload
(defsubst digit-bfpt (&optional arg ispec) 
  "Returns digit before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward "^[:digit:]")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'digit arg ispec))))

;;;###autoload
(defsubst bounds-of-digit-bfpt (&optional arg ispec) 
  "Returns border of digit before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:digit:]")
      (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'digit arg ispec))))

;;;###autoload
(defsubst digit-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of digit before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:digit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'digit arg ispec))))

;;;###autoload
(defsubst digit-bfpt-end-position (&optional arg ispec) 
  "Returns end position of digit before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:digit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-end 'digit arg ispec))))

;;;###autoload
(defsubst copy-digit-bfpt (&optional arg ispec) 
  "Returns a copy of digit before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:digit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-copy 'digit arg ispec))))

;;;###autoload
(defsubst separate-digit-bfpt (&optional arg ispec) 
  "Returns a copy of digit before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:digit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-separate 'digit arg ispec))))

;;;###autoload
(defsubst comment-digit-bfpt (&optional arg ispec) 
  "Returns a copy of digit before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:digit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-comment 'digit arg ispec))))

;;;###autoload
(defsubst doublequote-digit-bfpt (&optional arg ispec) 
  "Doublequotes digit before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:digit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'digit 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-digit-bfpt (&optional arg ispec) 
  "Singlequotes digit before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:digit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'digit 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-digit-bfpt (&optional arg ispec) 
  "Parentizes digit before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:digit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'digit 'parentize arg ispec))))

;;;###autoload
(defsubst brace-digit-bfpt (&optional arg ispec) 
  "Braces digit before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:digit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'digit 'brace arg ispec))))

;;;###autoload
(defsubst bracket-digit-bfpt (&optional arg ispec) 
  "Brackets digit before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:digit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'digit 'bracket arg ispec))))

;;;###autoload
(defsubst kill-digit-bfpt ()
  "Kills digit before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward "^[:digit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-kill 'digit))))

;;;;

;;;###autoload
(defsubst graph-bfpt (&optional arg ispec) 
  "Returns graph before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward "^[:graph:]")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'graph arg ispec))))

;;;###autoload
(defsubst bounds-of-graph-bfpt (&optional arg ispec) 
  "Returns border of graph before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:graph:]")
      (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'graph arg ispec))))

;;;###autoload
(defsubst graph-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of graph before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:graph:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'graph arg ispec))))

;;;###autoload
(defsubst graph-bfpt-end-position (&optional arg ispec) 
  "Returns end position of graph before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:graph:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-end 'graph arg ispec))))

;;;###autoload
(defsubst copy-graph-bfpt (&optional arg ispec) 
  "Returns a copy of graph before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:graph:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-copy 'graph arg ispec))))

;;;###autoload
(defsubst separate-graph-bfpt (&optional arg ispec) 
  "Returns a copy of graph before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:graph:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-separate 'graph arg ispec))))

;;;###autoload
(defsubst comment-graph-bfpt (&optional arg ispec) 
  "Returns a copy of graph before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:graph:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-comment 'graph arg ispec))))

;;;###autoload
(defsubst doublequote-graph-bfpt (&optional arg ispec) 
  "Doublequotes graph before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:graph:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'graph 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-graph-bfpt (&optional arg ispec) 
  "Singlequotes graph before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:graph:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'graph 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-graph-bfpt (&optional arg ispec) 
  "Parentizes graph before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:graph:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'graph 'parentize arg ispec))))

;;;###autoload
(defsubst brace-graph-bfpt (&optional arg ispec) 
  "Braces graph before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:graph:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'graph 'brace arg ispec))))

;;;###autoload
(defsubst bracket-graph-bfpt (&optional arg ispec) 
  "Brackets graph before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:graph:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'graph 'bracket arg ispec))))

;;;###autoload
(defsubst kill-graph-bfpt ()
  "Kills graph before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward "^[:graph:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-kill 'graph))))

;;;;

;;;###autoload
(defsubst lower-bfpt (&optional arg ispec) 
  "Returns lower before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward "^[:lower:]")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'lower arg ispec))))

;;;###autoload
(defsubst bounds-of-lower-bfpt (&optional arg ispec) 
  "Returns border of lower before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:lower:]")
      (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'lower arg ispec))))

;;;###autoload
(defsubst lower-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of lower before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:lower:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'lower arg ispec))))

;;;###autoload
(defsubst lower-bfpt-end-position (&optional arg ispec) 
  "Returns end position of lower before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:lower:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-end 'lower arg ispec))))

;;;###autoload
(defsubst copy-lower-bfpt (&optional arg ispec) 
  "Returns a copy of lower before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:lower:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-copy 'lower arg ispec))))

;;;###autoload
(defsubst separate-lower-bfpt (&optional arg ispec) 
  "Returns a copy of lower before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:lower:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-separate 'lower arg ispec))))

;;;###autoload
(defsubst comment-lower-bfpt (&optional arg ispec) 
  "Returns a copy of lower before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:lower:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-comment 'lower arg ispec))))

;;;###autoload
(defsubst doublequote-lower-bfpt (&optional arg ispec) 
  "Doublequotes lower before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:lower:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'lower 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-lower-bfpt (&optional arg ispec) 
  "Singlequotes lower before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:lower:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'lower 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-lower-bfpt (&optional arg ispec) 
  "Parentizes lower before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:lower:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'lower 'parentize arg ispec))))

;;;###autoload
(defsubst brace-lower-bfpt (&optional arg ispec) 
  "Braces lower before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:lower:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'lower 'brace arg ispec))))

;;;###autoload
(defsubst bracket-lower-bfpt (&optional arg ispec) 
  "Brackets lower before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:lower:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'lower 'bracket arg ispec))))

;;;###autoload
(defsubst kill-lower-bfpt ()
  "Kills lower before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward "^[:lower:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-kill 'lower))))

;;;;

;;;###autoload
(defsubst multibyte-bfpt (&optional arg ispec) 
  "Returns multibyte before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward "^[:multibyte:]")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'multibyte arg ispec))))

;;;###autoload
(defsubst bounds-of-multibyte-bfpt (&optional arg ispec) 
  "Returns border of multibyte before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:multibyte:]")
      (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'multibyte arg ispec))))

;;;###autoload
(defsubst multibyte-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of multibyte before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:multibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'multibyte arg ispec))))

;;;###autoload
(defsubst multibyte-bfpt-end-position (&optional arg ispec) 
  "Returns end position of multibyte before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:multibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-end 'multibyte arg ispec))))

;;;###autoload
(defsubst copy-multibyte-bfpt (&optional arg ispec) 
  "Returns a copy of multibyte before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:multibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-copy 'multibyte arg ispec))))

;;;###autoload
(defsubst separate-multibyte-bfpt (&optional arg ispec) 
  "Returns a copy of multibyte before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:multibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-separate 'multibyte arg ispec))))

;;;###autoload
(defsubst comment-multibyte-bfpt (&optional arg ispec) 
  "Returns a copy of multibyte before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:multibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-comment 'multibyte arg ispec))))

;;;###autoload
(defsubst doublequote-multibyte-bfpt (&optional arg ispec) 
  "Doublequotes multibyte before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:multibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'multibyte 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-multibyte-bfpt (&optional arg ispec) 
  "Singlequotes multibyte before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:multibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'multibyte 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-multibyte-bfpt (&optional arg ispec) 
  "Parentizes multibyte before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:multibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'multibyte 'parentize arg ispec))))

;;;###autoload
(defsubst brace-multibyte-bfpt (&optional arg ispec) 
  "Braces multibyte before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:multibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'multibyte 'brace arg ispec))))

;;;###autoload
(defsubst bracket-multibyte-bfpt (&optional arg ispec) 
  "Brackets multibyte before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:multibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'multibyte 'bracket arg ispec))))

;;;###autoload
(defsubst kill-multibyte-bfpt ()
  "Kills multibyte before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward "^[:multibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-kill 'multibyte))))

;;;;

;;;###autoload
(defsubst nonascii-bfpt (&optional arg ispec) 
  "Returns nonascii before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward "^[:nonascii:]")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'nonascii arg ispec))))

;;;###autoload
(defsubst bounds-of-nonascii-bfpt (&optional arg ispec) 
  "Returns border of nonascii before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:nonascii:]")
      (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'nonascii arg ispec))))

;;;###autoload
(defsubst nonascii-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of nonascii before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:nonascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'nonascii arg ispec))))

;;;###autoload
(defsubst nonascii-bfpt-end-position (&optional arg ispec) 
  "Returns end position of nonascii before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:nonascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-end 'nonascii arg ispec))))

;;;###autoload
(defsubst copy-nonascii-bfpt (&optional arg ispec) 
  "Returns a copy of nonascii before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:nonascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-copy 'nonascii arg ispec))))

;;;###autoload
(defsubst separate-nonascii-bfpt (&optional arg ispec) 
  "Returns a copy of nonascii before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:nonascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-separate 'nonascii arg ispec))))

;;;###autoload
(defsubst comment-nonascii-bfpt (&optional arg ispec) 
  "Returns a copy of nonascii before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:nonascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-comment 'nonascii arg ispec))))

;;;###autoload
(defsubst doublequote-nonascii-bfpt (&optional arg ispec) 
  "Doublequotes nonascii before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:nonascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'nonascii 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-nonascii-bfpt (&optional arg ispec) 
  "Singlequotes nonascii before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:nonascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'nonascii 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-nonascii-bfpt (&optional arg ispec) 
  "Parentizes nonascii before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:nonascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'nonascii 'parentize arg ispec))))

;;;###autoload
(defsubst brace-nonascii-bfpt (&optional arg ispec) 
  "Braces nonascii before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:nonascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'nonascii 'brace arg ispec))))

;;;###autoload
(defsubst bracket-nonascii-bfpt (&optional arg ispec) 
  "Brackets nonascii before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:nonascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'nonascii 'bracket arg ispec))))

;;;###autoload
(defsubst kill-nonascii-bfpt ()
  "Kills nonascii before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward "^[:nonascii:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-kill 'nonascii))))

;;;;

;;;###autoload
(defsubst print-bfpt (&optional arg ispec) 
  "Returns print before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward "^[:print:]")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'print arg ispec))))

;;;###autoload
(defsubst bounds-of-print-bfpt (&optional arg ispec) 
  "Returns border of print before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:print:]")
      (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'print arg ispec))))

;;;###autoload
(defsubst print-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of print before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:print:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'print arg ispec))))

;;;###autoload
(defsubst print-bfpt-end-position (&optional arg ispec) 
  "Returns end position of print before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:print:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-end 'print arg ispec))))

;;;###autoload
(defsubst copy-print-bfpt (&optional arg ispec) 
  "Returns a copy of print before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:print:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-copy 'print arg ispec))))

;;;###autoload
(defsubst separate-print-bfpt (&optional arg ispec) 
  "Returns a copy of print before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:print:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-separate 'print arg ispec))))

;;;###autoload
(defsubst comment-print-bfpt (&optional arg ispec) 
  "Returns a copy of print before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:print:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-comment 'print arg ispec))))

;;;###autoload
(defsubst doublequote-print-bfpt (&optional arg ispec) 
  "Doublequotes print before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:print:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'print 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-print-bfpt (&optional arg ispec) 
  "Singlequotes print before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:print:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'print 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-print-bfpt (&optional arg ispec) 
  "Parentizes print before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:print:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'print 'parentize arg ispec))))

;;;###autoload
(defsubst brace-print-bfpt (&optional arg ispec) 
  "Braces print before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:print:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'print 'brace arg ispec))))

;;;###autoload
(defsubst bracket-print-bfpt (&optional arg ispec) 
  "Brackets print before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:print:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'print 'bracket arg ispec))))

;;;###autoload
(defsubst kill-print-bfpt ()
  "Kills print before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward "^[:print:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-kill 'print))))

;;;;

;;;###autoload
(defsubst punct-bfpt (&optional arg ispec) 
  "Returns punct before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward "^[:punct:]")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'punct arg ispec))))

;;;###autoload
(defsubst bounds-of-punct-bfpt (&optional arg ispec) 
  "Returns border of punct before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:punct:]")
      (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'punct arg ispec))))

;;;###autoload
(defsubst punct-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of punct before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:punct:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'punct arg ispec))))

;;;###autoload
(defsubst punct-bfpt-end-position (&optional arg ispec) 
  "Returns end position of punct before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:punct:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-end 'punct arg ispec))))

;;;###autoload
(defsubst copy-punct-bfpt (&optional arg ispec) 
  "Returns a copy of punct before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:punct:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-copy 'punct arg ispec))))

;;;###autoload
(defsubst separate-punct-bfpt (&optional arg ispec) 
  "Returns a copy of punct before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:punct:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-separate 'punct arg ispec))))

;;;###autoload
(defsubst comment-punct-bfpt (&optional arg ispec) 
  "Returns a copy of punct before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:punct:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-comment 'punct arg ispec))))

;;;###autoload
(defsubst doublequote-punct-bfpt (&optional arg ispec) 
  "Doublequotes punct before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:punct:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'punct 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-punct-bfpt (&optional arg ispec) 
  "Singlequotes punct before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:punct:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'punct 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-punct-bfpt (&optional arg ispec) 
  "Parentizes punct before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:punct:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'punct 'parentize arg ispec))))

;;;###autoload
(defsubst brace-punct-bfpt (&optional arg ispec) 
  "Braces punct before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:punct:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'punct 'brace arg ispec))))

;;;###autoload
(defsubst bracket-punct-bfpt (&optional arg ispec) 
  "Brackets punct before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:punct:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'punct 'bracket arg ispec))))

;;;###autoload
(defsubst kill-punct-bfpt ()
  "Kills punct before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward "^[:punct:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-kill 'punct))))

;;;;

;;;###autoload
(defsubst space-bfpt (&optional arg ispec) 
  "Returns space before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward "^[:space:]")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'space arg ispec))))

;;;###autoload
(defsubst bounds-of-space-bfpt (&optional arg ispec) 
  "Returns border of space before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:space:]")
      (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'space arg ispec))))

;;;###autoload
(defsubst space-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of space before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:space:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'space arg ispec))))

;;;###autoload
(defsubst space-bfpt-end-position (&optional arg ispec) 
  "Returns end position of space before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:space:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-end 'space arg ispec))))

;;;###autoload
(defsubst copy-space-bfpt (&optional arg ispec) 
  "Returns a copy of space before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:space:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-copy 'space arg ispec))))

;;;###autoload
(defsubst separate-space-bfpt (&optional arg ispec) 
  "Returns a copy of space before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:space:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-separate 'space arg ispec))))

;;;###autoload
(defsubst comment-space-bfpt (&optional arg ispec) 
  "Returns a copy of space before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:space:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-comment 'space arg ispec))))

;;;###autoload
(defsubst doublequote-space-bfpt (&optional arg ispec) 
  "Doublequotes space before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:space:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'space 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-space-bfpt (&optional arg ispec) 
  "Singlequotes space before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:space:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'space 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-space-bfpt (&optional arg ispec) 
  "Parentizes space before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:space:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'space 'parentize arg ispec))))

;;;###autoload
(defsubst brace-space-bfpt (&optional arg ispec) 
  "Braces space before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:space:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'space 'brace arg ispec))))

;;;###autoload
(defsubst bracket-space-bfpt (&optional arg ispec) 
  "Brackets space before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:space:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'space 'bracket arg ispec))))

;;;###autoload
(defsubst kill-space-bfpt ()
  "Kills space before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward "^[:space:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-kill 'space))))

;;;;

;;;###autoload
(defsubst unibyte-bfpt (&optional arg ispec) 
  "Returns unibyte before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward "^[:unibyte:]")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'unibyte arg ispec))))

;;;###autoload
(defsubst bounds-of-unibyte-bfpt (&optional arg ispec) 
  "Returns border of unibyte before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:unibyte:]")
      (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'unibyte arg ispec))))

;;;###autoload
(defsubst unibyte-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of unibyte before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:unibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'unibyte arg ispec))))

;;;###autoload
(defsubst unibyte-bfpt-end-position (&optional arg ispec) 
  "Returns end position of unibyte before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:unibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-end 'unibyte arg ispec))))

;;;###autoload
(defsubst copy-unibyte-bfpt (&optional arg ispec) 
  "Returns a copy of unibyte before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:unibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-copy 'unibyte arg ispec))))

;;;###autoload
(defsubst separate-unibyte-bfpt (&optional arg ispec) 
  "Returns a copy of unibyte before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:unibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-separate 'unibyte arg ispec))))

;;;###autoload
(defsubst comment-unibyte-bfpt (&optional arg ispec) 
  "Returns a copy of unibyte before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:unibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-comment 'unibyte arg ispec))))

;;;###autoload
(defsubst doublequote-unibyte-bfpt (&optional arg ispec) 
  "Doublequotes unibyte before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:unibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'unibyte 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-unibyte-bfpt (&optional arg ispec) 
  "Singlequotes unibyte before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:unibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'unibyte 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-unibyte-bfpt (&optional arg ispec) 
  "Parentizes unibyte before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:unibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'unibyte 'parentize arg ispec))))

;;;###autoload
(defsubst brace-unibyte-bfpt (&optional arg ispec) 
  "Braces unibyte before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:unibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'unibyte 'brace arg ispec))))

;;;###autoload
(defsubst bracket-unibyte-bfpt (&optional arg ispec) 
  "Brackets unibyte before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:unibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'unibyte 'bracket arg ispec))))

;;;###autoload
(defsubst kill-unibyte-bfpt ()
  "Kills unibyte before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward "^[:unibyte:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-kill 'unibyte))))

;;;;

;;;###autoload
(defsubst upper-bfpt (&optional arg ispec) 
  "Returns upper before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward "^[:upper:]")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'upper arg ispec))))

;;;###autoload
(defsubst bounds-of-upper-bfpt (&optional arg ispec) 
  "Returns border of upper before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:upper:]")
      (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'upper arg ispec))))

;;;###autoload
(defsubst upper-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of upper before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:upper:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'upper arg ispec))))

;;;###autoload
(defsubst upper-bfpt-end-position (&optional arg ispec) 
  "Returns end position of upper before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:upper:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-end 'upper arg ispec))))

;;;###autoload
(defsubst copy-upper-bfpt (&optional arg ispec) 
  "Returns a copy of upper before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:upper:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-copy 'upper arg ispec))))

;;;###autoload
(defsubst separate-upper-bfpt (&optional arg ispec) 
  "Returns a copy of upper before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:upper:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-separate 'upper arg ispec))))

;;;###autoload
(defsubst comment-upper-bfpt (&optional arg ispec) 
  "Returns a copy of upper before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:upper:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-comment 'upper arg ispec))))

;;;###autoload
(defsubst doublequote-upper-bfpt (&optional arg ispec) 
  "Doublequotes upper before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:upper:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'upper 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-upper-bfpt (&optional arg ispec) 
  "Singlequotes upper before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:upper:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'upper 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-upper-bfpt (&optional arg ispec) 
  "Parentizes upper before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:upper:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'upper 'parentize arg ispec))))

;;;###autoload
(defsubst brace-upper-bfpt (&optional arg ispec) 
  "Braces upper before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:upper:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'upper 'brace arg ispec))))

;;;###autoload
(defsubst bracket-upper-bfpt (&optional arg ispec) 
  "Brackets upper before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:upper:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'upper 'bracket arg ispec))))

;;;###autoload
(defsubst kill-upper-bfpt ()
  "Kills upper before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward "^[:upper:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-kill 'upper))))

;;;;

;;;###autoload
(defsubst xdigit-bfpt (&optional arg ispec) 
  "Returns xdigit before point if any, nil otherwise"
  (interactive "p\np")
  (save-excursion
    (skip-chars-backward "^[:xdigit:]")
 (unless (bobp)
               (forward-char -1) 
               (thatpt 'xdigit arg ispec))))

;;;###autoload
(defsubst bounds-of-xdigit-bfpt (&optional arg ispec) 
  "Returns border of xdigit before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:xdigit:]")
      (unless (bobp)
  (forward-char -1)
  (thatpt-bounds 'xdigit arg ispec))))

;;;###autoload
(defsubst xdigit-bfpt-beginning-position (&optional arg ispec) 
  "Returns beginning of xdigit before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:xdigit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-beginning 'xdigit arg ispec))))

;;;###autoload
(defsubst xdigit-bfpt-end-position (&optional arg ispec) 
  "Returns end position of xdigit before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:xdigit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-end 'xdigit arg ispec))))

;;;###autoload
(defsubst copy-xdigit-bfpt (&optional arg ispec) 
  "Returns a copy of xdigit before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:xdigit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-copy 'xdigit arg ispec))))

;;;###autoload
(defsubst separate-xdigit-bfpt (&optional arg ispec) 
  "Returns a copy of xdigit before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:xdigit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-separate 'xdigit arg ispec))))

;;;###autoload
(defsubst comment-xdigit-bfpt (&optional arg ispec) 
  "Returns a copy of xdigit before point if any, nil otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:xdigit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-comment 'xdigit arg ispec))))

;;;###autoload
(defsubst doublequote-xdigit-bfpt (&optional arg ispec) 
  "Doublequotes xdigit before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:xdigit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'xdigit 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-xdigit-bfpt (&optional arg ispec) 
  "Singlequotes xdigit before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:xdigit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'xdigit 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-xdigit-bfpt (&optional arg ispec) 
  "Parentizes xdigit before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:xdigit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'xdigit 'parentize arg ispec))))

;;;###autoload
(defsubst brace-xdigit-bfpt (&optional arg ispec) 
  "Braces xdigit before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:xdigit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'xdigit 'brace arg ispec))))

;;;###autoload
(defsubst bracket-xdigit-bfpt (&optional arg ispec) 
  "Brackets xdigit before point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-backward "^[:xdigit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-delim 'xdigit 'bracket arg ispec))))

;;;###autoload
(defsubst kill-xdigit-bfpt ()
  "Kills xdigit before point if any, does nothing otherwise "
  (interactive "*")
  (save-excursion  
     (skip-chars-backward "^[:xdigit:]")
      (unless (bobp)
  (forward-char -1)  (thatpt-kill 'xdigit))))


;;; thing-before-point-utils.el ends here
(provide 'thing-before-point-utils)