thing-at-point-utils.el 1.0

;;; thing-at-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-atpt (&optional arg ispec) 
  "Returns list at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'list arg ispec))

;;;###autoload
(defsubst bounds-of-list-atpt (&optional arg ispec) 
  "Returns borders of list at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'list arg ispec))

;;;###autoload
(defsubst list-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class list at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'list arg ispec))

;;;###autoload
(defsubst list-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class list at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'list arg ispec))

;;;###autoload
(defsubst copy-list-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class list at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'list arg ispec))

;;;###autoload
(defsubst separate-list-atpt (&optional arg ispec) 
  "Separates list at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'list arg ispec))

;;;###autoload
(defsubst comment-list-atpt (&optional arg ispec) 
  "Comments list at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'list arg ispec))

;;;###autoload
(defsubst doublequote-list-atpt (&optional arg ispec) 
  "Doublequotes list at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'list 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-list-atpt (&optional arg ispec) 
  "Singlequotes list at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'list 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-list-atpt (&optional arg ispec) 
  "Parentizes list at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'list 'parentize arg ispec))

;;;###autoload
(defsubst brace-list-atpt (&optional arg ispec) 
  "Braces list at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'list 'brace arg ispec))

;;;###autoload
(defsubst bracket-list-atpt (&optional arg ispec) 
  "Brackets list after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'list 'bracket arg ispec))

;;;###autoload
(defsubst kill-list-atpt ()
  "Kills list at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'list))

;;;###autoload
(defsubst forward-list-atpt (&optional arg ispec) 
  "Moves forward over list at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'list arg ispec)))

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

;;;###autoload
(defsubst symbol-atpt (&optional arg ispec) 
  "Returns symbol at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'symbol arg ispec))

;;;###autoload
(defsubst bounds-of-symbol-atpt (&optional arg ispec) 
  "Returns borders of symbol at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'symbol arg ispec))

;;;###autoload
(defsubst symbol-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class symbol at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'symbol arg ispec))

;;;###autoload
(defsubst symbol-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class symbol at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'symbol arg ispec))

;;;###autoload
(defsubst copy-symbol-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class symbol at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'symbol arg ispec))

;;;###autoload
(defsubst separate-symbol-atpt (&optional arg ispec) 
  "Separates symbol at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'symbol arg ispec))

;;;###autoload
(defsubst comment-symbol-atpt (&optional arg ispec) 
  "Comments symbol at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'symbol arg ispec))

;;;###autoload
(defsubst doublequote-symbol-atpt (&optional arg ispec) 
  "Doublequotes symbol at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'symbol 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-symbol-atpt (&optional arg ispec) 
  "Singlequotes symbol at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'symbol 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-symbol-atpt (&optional arg ispec) 
  "Parentizes symbol at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'symbol 'parentize arg ispec))

;;;###autoload
(defsubst brace-symbol-atpt (&optional arg ispec) 
  "Braces symbol at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'symbol 'brace arg ispec))

;;;###autoload
(defsubst bracket-symbol-atpt (&optional arg ispec) 
  "Brackets symbol after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'symbol 'bracket arg ispec))

;;;###autoload
(defsubst kill-symbol-atpt ()
  "Kills symbol at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'symbol))

;;;###autoload
(defsubst forward-symbol-atpt (&optional arg ispec) 
  "Moves forward over symbol at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'symbol arg ispec)))

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

;;;###autoload
(defsubst word-atpt (&optional arg ispec) 
  "Returns word at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'word arg ispec))

;;;###autoload
(defsubst bounds-of-word-atpt (&optional arg ispec) 
  "Returns borders of word at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'word arg ispec))

;;;###autoload
(defsubst word-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class word at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'word arg ispec))

;;;###autoload
(defsubst word-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class word at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'word arg ispec))

;;;###autoload
(defsubst copy-word-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class word at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'word arg ispec))

;;;###autoload
(defsubst separate-word-atpt (&optional arg ispec) 
  "Separates word at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'word arg ispec))

;;;###autoload
(defsubst comment-word-atpt (&optional arg ispec) 
  "Comments word at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'word arg ispec))

;;;###autoload
(defsubst doublequote-word-atpt (&optional arg ispec) 
  "Doublequotes word at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'word 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-word-atpt (&optional arg ispec) 
  "Singlequotes word at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'word 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-word-atpt (&optional arg ispec) 
  "Parentizes word at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'word 'parentize arg ispec))

;;;###autoload
(defsubst brace-word-atpt (&optional arg ispec) 
  "Braces word at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'word 'brace arg ispec))

;;;###autoload
(defsubst bracket-word-atpt (&optional arg ispec) 
  "Brackets word after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'word 'bracket arg ispec))

;;;###autoload
(defsubst kill-word-atpt ()
  "Kills word at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'word))

;;;###autoload
(defsubst forward-word-atpt (&optional arg ispec) 
  "Moves forward over word at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:word:]")
     ;; (forward-char 1)
  (thatpt-forward 'word arg ispec)))

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

;;;###autoload
(defsubst sexp-atpt (&optional arg ispec) 
  "Returns sexp at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'sexp arg ispec))

;;;###autoload
(defsubst bounds-of-sexp-atpt (&optional arg ispec) 
  "Returns borders of sexp at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'sexp arg ispec))

;;;###autoload
(defsubst sexp-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class sexp at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'sexp arg ispec))

;;;###autoload
(defsubst sexp-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class sexp at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'sexp arg ispec))

;;;###autoload
(defsubst copy-sexp-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class sexp at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'sexp arg ispec))

;;;###autoload
(defsubst separate-sexp-atpt (&optional arg ispec) 
  "Separates sexp at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'sexp arg ispec))

;;;###autoload
(defsubst comment-sexp-atpt (&optional arg ispec) 
  "Comments sexp at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'sexp arg ispec))

;;;###autoload
(defsubst doublequote-sexp-atpt (&optional arg ispec) 
  "Doublequotes sexp at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'sexp 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-sexp-atpt (&optional arg ispec) 
  "Singlequotes sexp at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'sexp 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-sexp-atpt (&optional arg ispec) 
  "Parentizes sexp at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'sexp 'parentize arg ispec))

;;;###autoload
(defsubst brace-sexp-atpt (&optional arg ispec) 
  "Braces sexp at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'sexp 'brace arg ispec))

;;;###autoload
(defsubst bracket-sexp-atpt (&optional arg ispec) 
  "Brackets sexp after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'sexp 'bracket arg ispec))

;;;###autoload
(defsubst kill-sexp-atpt ()
  "Kills sexp at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'sexp))

;;;###autoload
(defsubst forward-sexp-atpt (&optional arg ispec) 
  "Moves forward over sexp at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'sexp arg ispec)))

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

;;;###autoload
(defsubst paragraph-atpt (&optional arg ispec) 
  "Returns paragraph at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'paragraph arg ispec))

;;;###autoload
(defsubst bounds-of-paragraph-atpt (&optional arg ispec) 
  "Returns borders of paragraph at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'paragraph arg ispec))

;;;###autoload
(defsubst paragraph-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class paragraph at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'paragraph arg ispec))

;;;###autoload
(defsubst paragraph-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class paragraph at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'paragraph arg ispec))

;;;###autoload
(defsubst copy-paragraph-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class paragraph at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-copy 'paragraph arg ispec))

;;;###autoload
(defsubst separate-paragraph-atpt (&optional arg ispec) 
  "Separates paragraph at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'paragraph arg ispec))

;;;###autoload
(defsubst comment-paragraph-atpt (&optional arg ispec) 
  "Comments paragraph at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'paragraph arg ispec))

;;;###autoload
(defsubst doublequote-paragraph-atpt (&optional arg ispec) 
  "Doublequotes paragraph at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'paragraph 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-paragraph-atpt (&optional arg ispec) 
  "Singlequotes paragraph at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'paragraph 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-paragraph-atpt (&optional arg ispec) 
  "Parentizes paragraph at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'paragraph 'parentize arg ispec))

;;;###autoload
(defsubst brace-paragraph-atpt (&optional arg ispec) 
  "Braces paragraph at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'paragraph 'brace arg ispec))

;;;###autoload
(defsubst bracket-paragraph-atpt (&optional arg ispec) 
  "Brackets paragraph after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'paragraph 'bracket arg ispec))

;;;###autoload
(defsubst kill-paragraph-atpt ()
  "Kills paragraph at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'paragraph))

;;;###autoload
(defsubst forward-paragraph-atpt (&optional arg ispec) 
  "Moves forward over paragraph at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'paragraph arg ispec)))

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

;;;###autoload
(defsubst string-atpt (&optional arg ispec) 
  "Returns string at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'string arg ispec))

;;;###autoload
(defsubst bounds-of-string-atpt (&optional arg ispec) 
  "Returns borders of string at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'string arg ispec))

;;;###autoload
(defsubst string-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class string at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'string arg ispec))

;;;###autoload
(defsubst string-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class string at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'string arg ispec))

;;;###autoload
(defsubst copy-string-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class string at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'string arg ispec))

;;;###autoload
(defsubst separate-string-atpt (&optional arg ispec) 
  "Separates string at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'string arg ispec))

;;;###autoload
(defsubst comment-string-atpt (&optional arg ispec) 
  "Comments string at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'string arg ispec))

;;;###autoload
(defsubst doublequote-string-atpt (&optional arg ispec) 
  "Doublequotes string at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'string 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-string-atpt (&optional arg ispec) 
  "Singlequotes string at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'string 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-string-atpt (&optional arg ispec) 
  "Parentizes string at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'string 'parentize arg ispec))

;;;###autoload
(defsubst brace-string-atpt (&optional arg ispec) 
  "Braces string at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'string 'brace arg ispec))

;;;###autoload
(defsubst bracket-string-atpt (&optional arg ispec) 
  "Brackets string after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'string 'bracket arg ispec))

;;;###autoload
(defsubst kill-string-atpt ()
  "Kills string at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'string))

;;;###autoload
(defsubst forward-string-atpt (&optional arg ispec) 
  "Moves forward over string at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'string arg ispec)))

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

;;;###autoload
(defsubst line-atpt (&optional arg ispec) 
  "Returns line at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'line arg ispec))

;;;###autoload
(defsubst bounds-of-line-atpt (&optional arg ispec) 
  "Returns borders of line at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'line arg ispec))

;;;###autoload
(defsubst line-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class line at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'line arg ispec))

;;;###autoload
(defsubst line-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class line at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'line arg ispec))

;;;###autoload
(defsubst copy-line-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class line at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'line arg ispec))

;;;###autoload
(defsubst separate-line-atpt (&optional arg ispec) 
  "Separates line at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'line arg ispec))

;;;###autoload
(defsubst comment-line-atpt (&optional arg ispec) 
  "Comments line at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'line arg ispec))

;;;###autoload
(defsubst doublequote-line-atpt (&optional arg ispec) 
  "Doublequotes line at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'line 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-line-atpt (&optional arg ispec) 
  "Singlequotes line at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'line 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-line-atpt (&optional arg ispec) 
  "Parentizes line at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'line 'parentize arg ispec))

;;;###autoload
(defsubst brace-line-atpt (&optional arg ispec) 
  "Braces line at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'line 'brace arg ispec))

;;;###autoload
(defsubst bracket-line-atpt (&optional arg ispec) 
  "Brackets line after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'line 'bracket arg ispec))

;;;###autoload
(defsubst kill-line-atpt ()
  "Kills line at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'line))

;;;###autoload
(defsubst forward-line-atpt (&optional arg ispec) 
  "Moves forward over line at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'line arg ispec)))

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

;;;###autoload
(defsubst sentence-atpt (&optional arg ispec) 
  "Returns sentence at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'sentence arg ispec))

;;;###autoload
(defsubst bounds-of-sentence-atpt (&optional arg ispec) 
  "Returns borders of sentence at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'sentence arg ispec))

;;;###autoload
(defsubst sentence-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class sentence at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'sentence arg ispec))

;;;###autoload
(defsubst sentence-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class sentence at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'sentence arg ispec))

;;;###autoload
(defsubst copy-sentence-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class sentence at point if any, nil otherwise 
"
  (interactive "p\np")
  (thatpt-copy 'sentence arg ispec))

;;;###autoload
(defsubst separate-sentence-atpt (&optional arg ispec) 
  "Separates sentence at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'sentence arg ispec))

;;;###autoload
(defsubst comment-sentence-atpt (&optional arg ispec) 
  "Comments sentence at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'sentence arg ispec))

;;;###autoload
(defsubst doublequote-sentence-atpt (&optional arg ispec) 
  "Doublequotes sentence at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'sentence 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-sentence-atpt (&optional arg ispec) 
  "Singlequotes sentence at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'sentence 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-sentence-atpt (&optional arg ispec) 
  "Parentizes sentence at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'sentence 'parentize arg ispec))

;;;###autoload
(defsubst brace-sentence-atpt (&optional arg ispec) 
  "Braces sentence at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'sentence 'brace arg ispec))

;;;###autoload
(defsubst bracket-sentence-atpt (&optional arg ispec) 
  "Brackets sentence after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'sentence 'bracket arg ispec))

;;;###autoload
(defsubst kill-sentence-atpt ()
  "Kills sentence at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'sentence))

;;;###autoload
(defsubst forward-sentence-atpt (&optional arg ispec) 
  "Moves forward over sentence at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'sentence arg ispec)))

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

;;;###autoload
(defsubst defun-atpt (&optional arg ispec) 
  "Returns defun at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'defun arg ispec))

;;;###autoload
(defsubst bounds-of-defun-atpt (&optional arg ispec) 
  "Returns borders of defun at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'defun arg ispec))

;;;###autoload
(defsubst defun-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class defun at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'defun arg ispec))

;;;###autoload
(defsubst defun-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class defun at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'defun arg ispec))

;;;###autoload
(defsubst copy-defun-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class defun at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'defun arg ispec))

;;;###autoload
(defsubst separate-defun-atpt (&optional arg ispec) 
  "Separates defun at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'defun arg ispec))

;;;###autoload
(defsubst comment-defun-atpt (&optional arg ispec) 
  "Comments defun at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'defun arg ispec))

;;;###autoload
(defsubst doublequote-defun-atpt (&optional arg ispec) 
  "Doublequotes defun at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'defun 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-defun-atpt (&optional arg ispec) 
  "Singlequotes defun at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'defun 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-defun-atpt (&optional arg ispec) 
  "Parentizes defun at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'defun 'parentize arg ispec))

;;;###autoload
(defsubst brace-defun-atpt (&optional arg ispec) 
  "Braces defun at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'defun 'brace arg ispec))

;;;###autoload
(defsubst bracket-defun-atpt (&optional arg ispec) 
  "Brackets defun after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'defun 'bracket arg ispec))

;;;###autoload
(defsubst kill-defun-atpt ()
  "Kills defun at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'defun))

;;;###autoload
(defsubst forward-defun-atpt (&optional arg ispec) 
  "Moves forward over defun at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'defun arg ispec)))

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

;;;###autoload
(defsubst email-atpt (&optional arg ispec) 
  "Returns email at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'email arg ispec))

;;;###autoload
(defsubst bounds-of-email-atpt (&optional arg ispec) 
  "Returns borders of email at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'email arg ispec))

;;;###autoload
(defsubst email-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class email at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'email arg ispec))

;;;###autoload
(defsubst email-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class email at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'email arg ispec))

;;;###autoload
(defsubst copy-email-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class email at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'email arg ispec))

;;;###autoload
(defsubst separate-email-atpt (&optional arg ispec) 
  "Separates email at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'email arg ispec))

;;;###autoload
(defsubst comment-email-atpt (&optional arg ispec) 
  "Comments email at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'email arg ispec))

;;;###autoload
(defsubst doublequote-email-atpt (&optional arg ispec) 
  "Doublequotes email at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'email 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-email-atpt (&optional arg ispec) 
  "Singlequotes email at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'email 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-email-atpt (&optional arg ispec) 
  "Parentizes email at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'email 'parentize arg ispec))

;;;###autoload
(defsubst brace-email-atpt (&optional arg ispec) 
  "Braces email at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'email 'brace arg ispec))

;;;###autoload
(defsubst bracket-email-atpt (&optional arg ispec) 
  "Brackets email after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'email 'bracket arg ispec))

;;;###autoload
(defsubst kill-email-atpt ()
  "Kills email at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'email))

;;;###autoload
(defsubst forward-email-atpt (&optional arg ispec) 
  "Moves forward over email at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'email arg ispec)))

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

;;;###autoload
(defsubst csv-atpt (&optional arg ispec) 
  "Returns csv at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'csv arg ispec))

;;;###autoload
(defsubst bounds-of-csv-atpt (&optional arg ispec) 
  "Returns borders of csv at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'csv arg ispec))

;;;###autoload
(defsubst csv-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class csv at point if any, nil otherwise 
"
  (interactive "p\np")
  (thatpt-beginning 'csv arg ispec))

;;;###autoload
(defsubst csv-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class csv at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'csv arg ispec))

;;;###autoload
(defsubst copy-csv-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class csv at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'csv arg ispec))

;;;###autoload
(defsubst separate-csv-atpt (&optional arg ispec) 
  "Separates csv at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'csv arg ispec))

;;;###autoload
(defsubst comment-csv-atpt (&optional arg ispec) 
  "Comments csv at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'csv arg ispec))

;;;###autoload
(defsubst doublequote-csv-atpt (&optional arg ispec) 
  "Doublequotes csv at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'csv 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-csv-atpt (&optional arg ispec) 
  "Singlequotes csv at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'csv 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-csv-atpt (&optional arg ispec) 
  "Parentizes csv at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'csv 'parentize arg ispec))

;;;###autoload
(defsubst brace-csv-atpt (&optional arg ispec) 
  "Braces csv at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'csv 'brace arg ispec))

;;;###autoload
(defsubst bracket-csv-atpt (&optional arg ispec) 
  "Brackets csv after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'csv 'bracket arg ispec))

;;;###autoload
(defsubst kill-csv-atpt ()
  "Kills csv at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'csv))

;;;###autoload
(defsubst forward-csv-atpt (&optional arg ispec) 
  "Moves forward over csv at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'csv arg ispec)))

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

;;;###autoload
(defsubst phone-atpt (&optional arg ispec) 
  "Returns phone at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'phone arg ispec))

;;;###autoload
(defsubst bounds-of-phone-atpt (&optional arg ispec) 
  "Returns borders of phone at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'phone arg ispec))

;;;###autoload
(defsubst phone-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class phone at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'phone arg ispec))

;;;###autoload
(defsubst phone-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class phone at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'phone arg ispec))

;;;###autoload
(defsubst copy-phone-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class phone at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'phone arg ispec))

;;;###autoload
(defsubst separate-phone-atpt (&optional arg ispec) 
  "Separates phone at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'phone arg ispec))

;;;###autoload
(defsubst comment-phone-atpt (&optional arg ispec) 
  "Comments phone at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'phone arg ispec))

;;;###autoload
(defsubst doublequote-phone-atpt (&optional arg ispec) 
  "Doublequotes phone at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'phone 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-phone-atpt (&optional arg ispec) 
  "Singlequotes phone at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'phone 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-phone-atpt (&optional arg ispec) 
  "Parentizes phone at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'phone 'parentize arg ispec))

;;;###autoload
(defsubst brace-phone-atpt (&optional arg ispec) 
  "Braces phone at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'phone 'brace arg ispec))

;;;###autoload
(defsubst bracket-phone-atpt (&optional arg ispec) 
  "Brackets phone after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'phone 'bracket arg ispec))

;;;###autoload
(defsubst kill-phone-atpt ()
  "Kills phone at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'phone))

;;;###autoload
(defsubst forward-phone-atpt (&optional arg ispec) 
  "Moves forward over phone at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'phone arg ispec)))

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

;;;###autoload
(defsubst ml-text-atpt (&optional arg ispec) 
  "Returns ml-text at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'ml-text arg ispec))

;;;###autoload
(defsubst bounds-of-ml-text-atpt (&optional arg ispec) 
  "Returns borders of ml-text at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'ml-text arg ispec))

;;;###autoload
(defsubst ml-text-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class ml-text at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'ml-text arg ispec))

;;;###autoload
(defsubst ml-text-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class ml-text at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'ml-text arg ispec))

;;;###autoload
(defsubst copy-ml-text-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class ml-text at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'ml-text arg ispec))

;;;###autoload
(defsubst separate-ml-text-atpt (&optional arg ispec) 
  "Separates ml-text at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'ml-text arg ispec))

;;;###autoload
(defsubst comment-ml-text-atpt (&optional arg ispec) 
  "Comments ml-text at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'ml-text arg ispec))

;;;###autoload
(defsubst doublequote-ml-text-atpt (&optional arg ispec) 
  "Doublequotes ml-text at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'ml-text 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-ml-text-atpt (&optional arg ispec) 
  "Singlequotes ml-text at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'ml-text 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-ml-text-atpt (&optional arg ispec) 
  "Parentizes ml-text at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'ml-text 'parentize arg ispec))

;;;###autoload
(defsubst brace-ml-text-atpt (&optional arg ispec) 
  "Braces ml-text at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'ml-text 'brace arg ispec))

;;;###autoload
(defsubst bracket-ml-text-atpt (&optional arg ispec) 
  "Brackets ml-text after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'ml-text 'bracket arg ispec))

;;;###autoload
(defsubst kill-ml-text-atpt ()
  "Kills ml-text at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'ml-text))

;;;###autoload
(defsubst forward-ml-text-atpt (&optional arg ispec) 
  "Moves forward over ml-text at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'ml-text arg ispec)))

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

;;;###autoload
(defsubst filename-atpt (&optional arg ispec) 
  "Returns filename at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'filename arg ispec))

;;;###autoload
(defsubst bounds-of-filename-atpt (&optional arg ispec) 
  "Returns borders of filename at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'filename arg ispec))

;;;###autoload
(defsubst filename-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class filename at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'filename arg ispec))

;;;###autoload
(defsubst filename-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class filename at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'filename arg ispec))

;;;###autoload
(defsubst copy-filename-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class filename at point if any, nil otherwise 
"
  (interactive "p\np")
  (thatpt-copy 'filename arg ispec))

;;;###autoload
(defsubst separate-filename-atpt (&optional arg ispec) 
  "Separates filename at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'filename arg ispec))

;;;###autoload
(defsubst comment-filename-atpt (&optional arg ispec) 
  "Comments filename at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'filename arg ispec))

;;;###autoload
(defsubst doublequote-filename-atpt (&optional arg ispec) 
  "Doublequotes filename at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'filename 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-filename-atpt (&optional arg ispec) 
  "Singlequotes filename at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'filename 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-filename-atpt (&optional arg ispec) 
  "Parentizes filename at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'filename 'parentize arg ispec))

;;;###autoload
(defsubst brace-filename-atpt (&optional arg ispec) 
  "Braces filename at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'filename 'brace arg ispec))

;;;###autoload
(defsubst bracket-filename-atpt (&optional arg ispec) 
  "Brackets filename after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'filename 'bracket arg ispec))

;;;###autoload
(defsubst kill-filename-atpt ()
  "Kills filename at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'filename))

;;;###autoload
(defsubst forward-filename-atpt (&optional arg ispec) 
  "Moves forward over filename at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'filename arg ispec)))

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

;;;###autoload
(defsubst url-atpt (&optional arg ispec) 
  "Returns url at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'url arg ispec))

;;;###autoload
(defsubst bounds-of-url-atpt (&optional arg ispec) 
  "Returns borders of url at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'url arg ispec))

;;;###autoload
(defsubst url-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class url at point if any, nil otherwise 
"
  (interactive "p\np")
  (thatpt-beginning 'url arg ispec))

;;;###autoload
(defsubst url-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class url at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'url arg ispec))

;;;###autoload
(defsubst copy-url-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class url at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'url arg ispec))

;;;###autoload
(defsubst separate-url-atpt (&optional arg ispec) 
  "Separates url at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'url arg ispec))

;;;###autoload
(defsubst comment-url-atpt (&optional arg ispec) 
  "Comments url at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'url arg ispec))

;;;###autoload
(defsubst doublequote-url-atpt (&optional arg ispec) 
  "Doublequotes url at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'url 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-url-atpt (&optional arg ispec) 
  "Singlequotes url at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'url 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-url-atpt (&optional arg ispec) 
  "Parentizes url at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'url 'parentize arg ispec))

;;;###autoload
(defsubst brace-url-atpt (&optional arg ispec) 
  "Braces url at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'url 'brace arg ispec))

;;;###autoload
(defsubst bracket-url-atpt (&optional arg ispec) 
  "Brackets url after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'url 'bracket arg ispec))

;;;###autoload
(defsubst kill-url-atpt ()
  "Kills url at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'url))

;;;###autoload
(defsubst forward-url-atpt (&optional arg ispec) 
  "Moves forward over url at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'url arg ispec)))

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

;;;###autoload
(defsubst number-atpt (&optional arg ispec) 
  "Returns number at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'number arg ispec))

;;;###autoload
(defsubst bounds-of-number-atpt (&optional arg ispec) 
  "Returns borders of number at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'number arg ispec))

;;;###autoload
(defsubst number-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class number at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'number arg ispec))

;;;###autoload
(defsubst number-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class number at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'number arg ispec))

;;;###autoload
(defsubst copy-number-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class number at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'number arg ispec))

;;;###autoload
(defsubst separate-number-atpt (&optional arg ispec) 
  "Separates number at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'number arg ispec))

;;;###autoload
(defsubst comment-number-atpt (&optional arg ispec) 
  "Comments number at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'number arg ispec))

;;;###autoload
(defsubst doublequote-number-atpt (&optional arg ispec) 
  "Doublequotes number at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'number 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-number-atpt (&optional arg ispec) 
  "Singlequotes number at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'number 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-number-atpt (&optional arg ispec) 
  "Parentizes number at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'number 'parentize arg ispec))

;;;###autoload
(defsubst brace-number-atpt (&optional arg ispec) 
  "Braces number at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'number 'brace arg ispec))

;;;###autoload
(defsubst bracket-number-atpt (&optional arg ispec) 
  "Brackets number after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'number 'bracket arg ispec))

;;;###autoload
(defsubst kill-number-atpt ()
  "Kills number at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'number))

;;;###autoload
(defsubst forward-number-atpt (&optional arg ispec) 
  "Moves forward over number at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'number arg ispec)))

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

;;;###autoload
(defsubst float-atpt (&optional arg ispec) 
  "Returns float at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'float arg ispec))

;;;###autoload
(defsubst bounds-of-float-atpt (&optional arg ispec) 
  "Returns borders of float at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'float arg ispec))

;;;###autoload
(defsubst float-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class float at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'float arg ispec))

;;;###autoload
(defsubst float-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class float at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'float arg ispec))

;;;###autoload
(defsubst copy-float-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class float at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'float arg ispec))

;;;###autoload
(defsubst separate-float-atpt (&optional arg ispec) 
  "Separates float at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'float arg ispec))

;;;###autoload
(defsubst comment-float-atpt (&optional arg ispec) 
  "Comments float at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'float arg ispec))

;;;###autoload
(defsubst doublequote-float-atpt (&optional arg ispec) 
  "Doublequotes float at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'float 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-float-atpt (&optional arg ispec) 
  "Singlequotes float at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'float 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-float-atpt (&optional arg ispec) 
  "Parentizes float at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'float 'parentize arg ispec))

;;;###autoload
(defsubst brace-float-atpt (&optional arg ispec) 
  "Braces float at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'float 'brace arg ispec))

;;;###autoload
(defsubst bracket-float-atpt (&optional arg ispec) 
  "Brackets float after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'float 'bracket arg ispec))

;;;###autoload
(defsubst kill-float-atpt ()
  "Kills float at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'float))

;;;###autoload
(defsubst forward-float-atpt (&optional arg ispec) 
  "Moves forward over float at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'float arg ispec)))

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

;;;###autoload
(defsubst page-atpt (&optional arg ispec) 
  "Returns page at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'page arg ispec))

;;;###autoload
(defsubst bounds-of-page-atpt (&optional arg ispec) 
  "Returns borders of page at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'page arg ispec))

;;;###autoload
(defsubst page-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class page at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'page arg ispec))

;;;###autoload
(defsubst page-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class page at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'page arg ispec))

;;;###autoload
(defsubst copy-page-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class page at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'page arg ispec))

;;;###autoload
(defsubst separate-page-atpt (&optional arg ispec) 
  "Separates page at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'page arg ispec))

;;;###autoload
(defsubst comment-page-atpt (&optional arg ispec) 
  "Comments page at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'page arg ispec))

;;;###autoload
(defsubst doublequote-page-atpt (&optional arg ispec) 
  "Doublequotes page at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'page 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-page-atpt (&optional arg ispec) 
  "Singlequotes page at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'page 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-page-atpt (&optional arg ispec) 
  "Parentizes page at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'page 'parentize arg ispec))

;;;###autoload
(defsubst brace-page-atpt (&optional arg ispec) 
  "Braces page at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'page 'brace arg ispec))

;;;###autoload
(defsubst bracket-page-atpt (&optional arg ispec) 
  "Brackets page after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'page 'bracket arg ispec))

;;;###autoload
(defsubst kill-page-atpt ()
  "Kills page at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'page))

;;;###autoload
(defsubst forward-page-atpt (&optional arg ispec) 
  "Moves forward over page at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'page arg ispec)))

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

;;;###autoload
(defsubst whitespace-atpt (&optional arg ispec) 
  "Returns whitespace at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'whitespace arg ispec))

;;;###autoload
(defsubst bounds-of-whitespace-atpt (&optional arg ispec) 
  "Returns borders of whitespace at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'whitespace arg ispec))

;;;###autoload
(defsubst whitespace-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class whitespace at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'whitespace arg ispec))

;;;###autoload
(defsubst whitespace-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class whitespace at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'whitespace arg ispec))

;;;###autoload
(defsubst copy-whitespace-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class whitespace at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-copy 'whitespace arg ispec))

;;;###autoload
(defsubst separate-whitespace-atpt (&optional arg ispec) 
  "Separates whitespace at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'whitespace arg ispec))

;;;###autoload
(defsubst comment-whitespace-atpt (&optional arg ispec) 
  "Comments whitespace at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'whitespace arg ispec))

;;;###autoload
(defsubst doublequote-whitespace-atpt (&optional arg ispec) 
  "Doublequotes whitespace at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'whitespace 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-whitespace-atpt (&optional arg ispec) 
  "Singlequotes whitespace at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'whitespace 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-whitespace-atpt (&optional arg ispec) 
  "Parentizes whitespace at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'whitespace 'parentize arg ispec))

;;;###autoload
(defsubst brace-whitespace-atpt (&optional arg ispec) 
  "Braces whitespace at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'whitespace 'brace arg ispec))

;;;###autoload
(defsubst bracket-whitespace-atpt (&optional arg ispec) 
  "Brackets whitespace after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'whitespace 'bracket arg ispec))

;;;###autoload
(defsubst kill-whitespace-atpt ()
  "Kills whitespace at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'whitespace))

;;;###autoload
(defsubst forward-whitespace-atpt (&optional arg ispec) 
  "Moves forward over whitespace at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'whitespace arg ispec)))

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

;;;###autoload
(defsubst alnum-atpt (&optional arg ispec) 
  "Returns alnum at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'alnum arg ispec))

;;;###autoload
(defsubst bounds-of-alnum-atpt (&optional arg ispec) 
  "Returns borders of alnum at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'alnum arg ispec))

;;;###autoload
(defsubst alnum-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class alnum at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'alnum arg ispec))

;;;###autoload
(defsubst alnum-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class alnum at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'alnum arg ispec))

;;;###autoload
(defsubst copy-alnum-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class alnum at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'alnum arg ispec))

;;;###autoload
(defsubst separate-alnum-atpt (&optional arg ispec) 
  "Separates alnum at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'alnum arg ispec))

;;;###autoload
(defsubst comment-alnum-atpt (&optional arg ispec) 
  "Comments alnum at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'alnum arg ispec))

;;;###autoload
(defsubst doublequote-alnum-atpt (&optional arg ispec) 
  "Doublequotes alnum at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'alnum 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-alnum-atpt (&optional arg ispec) 
  "Singlequotes alnum at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'alnum 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-alnum-atpt (&optional arg ispec) 
  "Parentizes alnum at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'alnum 'parentize arg ispec))

;;;###autoload
(defsubst brace-alnum-atpt (&optional arg ispec) 
  "Braces alnum at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'alnum 'brace arg ispec))

;;;###autoload
(defsubst bracket-alnum-atpt (&optional arg ispec) 
  "Brackets alnum after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'alnum 'bracket arg ispec))

;;;###autoload
(defsubst kill-alnum-atpt ()
  "Kills alnum at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'alnum))

;;;###autoload
(defsubst forward-alnum-atpt (&optional arg ispec) 
  "Moves forward over alnum at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:alnum:]")
     ;; (forward-char 1)
  (thatpt-forward 'alnum arg ispec)))

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

;;;###autoload
(defsubst alpha-atpt (&optional arg ispec) 
  "Returns alpha at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'alpha arg ispec))

;;;###autoload
(defsubst bounds-of-alpha-atpt (&optional arg ispec) 
  "Returns borders of alpha at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'alpha arg ispec))

;;;###autoload
(defsubst alpha-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class alpha at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'alpha arg ispec))

;;;###autoload
(defsubst alpha-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class alpha at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'alpha arg ispec))

;;;###autoload
(defsubst copy-alpha-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class alpha at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'alpha arg ispec))

;;;###autoload
(defsubst separate-alpha-atpt (&optional arg ispec) 
  "Separates alpha at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'alpha arg ispec))

;;;###autoload
(defsubst comment-alpha-atpt (&optional arg ispec) 
  "Comments alpha at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'alpha arg ispec))

;;;###autoload
(defsubst doublequote-alpha-atpt (&optional arg ispec) 
  "Doublequotes alpha at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'alpha 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-alpha-atpt (&optional arg ispec) 
  "Singlequotes alpha at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'alpha 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-alpha-atpt (&optional arg ispec) 
  "Parentizes alpha at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'alpha 'parentize arg ispec))

;;;###autoload
(defsubst brace-alpha-atpt (&optional arg ispec) 
  "Braces alpha at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'alpha 'brace arg ispec))

;;;###autoload
(defsubst bracket-alpha-atpt (&optional arg ispec) 
  "Brackets alpha after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'alpha 'bracket arg ispec))

;;;###autoload
(defsubst kill-alpha-atpt ()
  "Kills alpha at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'alpha))

;;;###autoload
(defsubst forward-alpha-atpt (&optional arg ispec) 
  "Moves forward over alpha at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:alpha:]")
     ;; (forward-char 1)
  (thatpt-forward 'alpha arg ispec)))

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

;;;###autoload
(defsubst ascii-atpt (&optional arg ispec) 
  "Returns ascii at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'ascii arg ispec))

;;;###autoload
(defsubst bounds-of-ascii-atpt (&optional arg ispec) 
  "Returns borders of ascii at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'ascii arg ispec))

;;;###autoload
(defsubst ascii-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class ascii at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'ascii arg ispec))

;;;###autoload
(defsubst ascii-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class ascii at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'ascii arg ispec))

;;;###autoload
(defsubst copy-ascii-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class ascii at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'ascii arg ispec))

;;;###autoload
(defsubst separate-ascii-atpt (&optional arg ispec) 
  "Separates ascii at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'ascii arg ispec))

;;;###autoload
(defsubst comment-ascii-atpt (&optional arg ispec) 
  "Comments ascii at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'ascii arg ispec))

;;;###autoload
(defsubst doublequote-ascii-atpt (&optional arg ispec) 
  "Doublequotes ascii at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'ascii 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-ascii-atpt (&optional arg ispec) 
  "Singlequotes ascii at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'ascii 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-ascii-atpt (&optional arg ispec) 
  "Parentizes ascii at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'ascii 'parentize arg ispec))

;;;###autoload
(defsubst brace-ascii-atpt (&optional arg ispec) 
  "Braces ascii at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'ascii 'brace arg ispec))

;;;###autoload
(defsubst bracket-ascii-atpt (&optional arg ispec) 
  "Brackets ascii after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'ascii 'bracket arg ispec))

;;;###autoload
(defsubst kill-ascii-atpt ()
  "Kills ascii at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'ascii))

;;;###autoload
(defsubst forward-ascii-atpt (&optional arg ispec) 
  "Moves forward over ascii at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:ascii:]")
     ;; (forward-char 1)
  (thatpt-forward 'ascii arg ispec)))

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

;;;###autoload
(defsubst blank-atpt (&optional arg ispec) 
  "Returns blank at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'blank arg ispec))

;;;###autoload
(defsubst bounds-of-blank-atpt (&optional arg ispec) 
  "Returns borders of blank at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'blank arg ispec))

;;;###autoload
(defsubst blank-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class blank at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'blank arg ispec))

;;;###autoload
(defsubst blank-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class blank at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'blank arg ispec))

;;;###autoload
(defsubst copy-blank-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class blank at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'blank arg ispec))

;;;###autoload
(defsubst separate-blank-atpt (&optional arg ispec) 
  "Separates blank at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'blank arg ispec))

;;;###autoload
(defsubst comment-blank-atpt (&optional arg ispec) 
  "Comments blank at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'blank arg ispec))

;;;###autoload
(defsubst doublequote-blank-atpt (&optional arg ispec) 
  "Doublequotes blank at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'blank 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-blank-atpt (&optional arg ispec) 
  "Singlequotes blank at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'blank 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-blank-atpt (&optional arg ispec) 
  "Parentizes blank at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'blank 'parentize arg ispec))

;;;###autoload
(defsubst brace-blank-atpt (&optional arg ispec) 
  "Braces blank at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'blank 'brace arg ispec))

;;;###autoload
(defsubst bracket-blank-atpt (&optional arg ispec) 
  "Brackets blank after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'blank 'bracket arg ispec))

;;;###autoload
(defsubst kill-blank-atpt ()
  "Kills blank at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'blank))

;;;###autoload
(defsubst forward-blank-atpt (&optional arg ispec) 
  "Moves forward over blank at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:blank:]")
     ;; (forward-char 1)
  (thatpt-forward 'blank arg ispec)))

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

;;;###autoload
(defsubst cntrl-atpt (&optional arg ispec) 
  "Returns cntrl at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'cntrl arg ispec))

;;;###autoload
(defsubst bounds-of-cntrl-atpt (&optional arg ispec) 
  "Returns borders of cntrl at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'cntrl arg ispec))

;;;###autoload
(defsubst cntrl-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class cntrl at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'cntrl arg ispec))

;;;###autoload
(defsubst cntrl-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class cntrl at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'cntrl arg ispec))

;;;###autoload
(defsubst copy-cntrl-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class cntrl at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'cntrl arg ispec))

;;;###autoload
(defsubst separate-cntrl-atpt (&optional arg ispec) 
  "Separates cntrl at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'cntrl arg ispec))

;;;###autoload
(defsubst comment-cntrl-atpt (&optional arg ispec) 
  "Comments cntrl at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'cntrl arg ispec))

;;;###autoload
(defsubst doublequote-cntrl-atpt (&optional arg ispec) 
  "Doublequotes cntrl at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'cntrl 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-cntrl-atpt (&optional arg ispec) 
  "Singlequotes cntrl at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'cntrl 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-cntrl-atpt (&optional arg ispec) 
  "Parentizes cntrl at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'cntrl 'parentize arg ispec))

;;;###autoload
(defsubst brace-cntrl-atpt (&optional arg ispec) 
  "Braces cntrl at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'cntrl 'brace arg ispec))

;;;###autoload
(defsubst bracket-cntrl-atpt (&optional arg ispec) 
  "Brackets cntrl after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'cntrl 'bracket arg ispec))

;;;###autoload
(defsubst kill-cntrl-atpt ()
  "Kills cntrl at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'cntrl))

;;;###autoload
(defsubst forward-cntrl-atpt (&optional arg ispec) 
  "Moves forward over cntrl at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:cntrl:]")
     ;; (forward-char 1)
  (thatpt-forward 'cntrl arg ispec)))

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

;;;###autoload
(defsubst digit-atpt (&optional arg ispec) 
  "Returns digit at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'digit arg ispec))

;;;###autoload
(defsubst bounds-of-digit-atpt (&optional arg ispec) 
  "Returns borders of digit at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'digit arg ispec))

;;;###autoload
(defsubst digit-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class digit at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'digit arg ispec))

;;;###autoload
(defsubst digit-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class digit at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'digit arg ispec))

;;;###autoload
(defsubst copy-digit-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class digit at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'digit arg ispec))

;;;###autoload
(defsubst separate-digit-atpt (&optional arg ispec) 
  "Separates digit at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'digit arg ispec))

;;;###autoload
(defsubst comment-digit-atpt (&optional arg ispec) 
  "Comments digit at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'digit arg ispec))

;;;###autoload
(defsubst doublequote-digit-atpt (&optional arg ispec) 
  "Doublequotes digit at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'digit 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-digit-atpt (&optional arg ispec) 
  "Singlequotes digit at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'digit 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-digit-atpt (&optional arg ispec) 
  "Parentizes digit at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'digit 'parentize arg ispec))

;;;###autoload
(defsubst brace-digit-atpt (&optional arg ispec) 
  "Braces digit at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'digit 'brace arg ispec))

;;;###autoload
(defsubst bracket-digit-atpt (&optional arg ispec) 
  "Brackets digit after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'digit 'bracket arg ispec))

;;;###autoload
(defsubst kill-digit-atpt ()
  "Kills digit at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'digit))

;;;###autoload
(defsubst forward-digit-atpt (&optional arg ispec) 
  "Moves forward over digit at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:digit:]")
     ;; (forward-char 1)
  (thatpt-forward 'digit arg ispec)))

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

;;;###autoload
(defsubst graph-atpt (&optional arg ispec) 
  "Returns graph at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'graph arg ispec))

;;;###autoload
(defsubst bounds-of-graph-atpt (&optional arg ispec) 
  "Returns borders of graph at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'graph arg ispec))

;;;###autoload
(defsubst graph-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class graph at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'graph arg ispec))

;;;###autoload
(defsubst graph-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class graph at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'graph arg ispec))

;;;###autoload
(defsubst copy-graph-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class graph at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'graph arg ispec))

;;;###autoload
(defsubst separate-graph-atpt (&optional arg ispec) 
  "Separates graph at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'graph arg ispec))

;;;###autoload
(defsubst comment-graph-atpt (&optional arg ispec) 
  "Comments graph at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'graph arg ispec))

;;;###autoload
(defsubst doublequote-graph-atpt (&optional arg ispec) 
  "Doublequotes graph at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'graph 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-graph-atpt (&optional arg ispec) 
  "Singlequotes graph at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'graph 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-graph-atpt (&optional arg ispec) 
  "Parentizes graph at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'graph 'parentize arg ispec))

;;;###autoload
(defsubst brace-graph-atpt (&optional arg ispec) 
  "Braces graph at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'graph 'brace arg ispec))

;;;###autoload
(defsubst bracket-graph-atpt (&optional arg ispec) 
  "Brackets graph after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'graph 'bracket arg ispec))

;;;###autoload
(defsubst kill-graph-atpt ()
  "Kills graph at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'graph))

;;;###autoload
(defsubst forward-graph-atpt (&optional arg ispec) 
  "Moves forward over graph at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:graph:]")
     ;; (forward-char 1)
  (thatpt-forward 'graph arg ispec)))

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

;;;###autoload
(defsubst lower-atpt (&optional arg ispec) 
  "Returns lower at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'lower arg ispec))

;;;###autoload
(defsubst bounds-of-lower-atpt (&optional arg ispec) 
  "Returns borders of lower at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'lower arg ispec))

;;;###autoload
(defsubst lower-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class lower at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'lower arg ispec))

;;;###autoload
(defsubst lower-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class lower at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'lower arg ispec))

;;;###autoload
(defsubst copy-lower-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class lower at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'lower arg ispec))

;;;###autoload
(defsubst separate-lower-atpt (&optional arg ispec) 
  "Separates lower at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'lower arg ispec))

;;;###autoload
(defsubst comment-lower-atpt (&optional arg ispec) 
  "Comments lower at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'lower arg ispec))

;;;###autoload
(defsubst doublequote-lower-atpt (&optional arg ispec) 
  "Doublequotes lower at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'lower 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-lower-atpt (&optional arg ispec) 
  "Singlequotes lower at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'lower 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-lower-atpt (&optional arg ispec) 
  "Parentizes lower at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'lower 'parentize arg ispec))

;;;###autoload
(defsubst brace-lower-atpt (&optional arg ispec) 
  "Braces lower at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'lower 'brace arg ispec))

;;;###autoload
(defsubst bracket-lower-atpt (&optional arg ispec) 
  "Brackets lower after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'lower 'bracket arg ispec))

;;;###autoload
(defsubst kill-lower-atpt ()
  "Kills lower at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'lower))

;;;###autoload
(defsubst forward-lower-atpt (&optional arg ispec) 
  "Moves forward over lower at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:lower:]")
     ;; (forward-char 1)
  (thatpt-forward 'lower arg ispec)))

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

;;;###autoload
(defsubst multibyte-atpt (&optional arg ispec) 
  "Returns multibyte at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'multibyte arg ispec))

;;;###autoload
(defsubst bounds-of-multibyte-atpt (&optional arg ispec) 
  "Returns borders of multibyte at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'multibyte arg ispec))

;;;###autoload
(defsubst multibyte-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class multibyte at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'multibyte arg ispec))

;;;###autoload
(defsubst multibyte-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class multibyte at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'multibyte arg ispec))

;;;###autoload
(defsubst copy-multibyte-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class multibyte at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-copy 'multibyte arg ispec))

;;;###autoload
(defsubst separate-multibyte-atpt (&optional arg ispec) 
  "Separates multibyte at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'multibyte arg ispec))

;;;###autoload
(defsubst comment-multibyte-atpt (&optional arg ispec) 
  "Comments multibyte at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'multibyte arg ispec))

;;;###autoload
(defsubst doublequote-multibyte-atpt (&optional arg ispec) 
  "Doublequotes multibyte at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'multibyte 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-multibyte-atpt (&optional arg ispec) 
  "Singlequotes multibyte at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'multibyte 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-multibyte-atpt (&optional arg ispec) 
  "Parentizes multibyte at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'multibyte 'parentize arg ispec))

;;;###autoload
(defsubst brace-multibyte-atpt (&optional arg ispec) 
  "Braces multibyte at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'multibyte 'brace arg ispec))

;;;###autoload
(defsubst bracket-multibyte-atpt (&optional arg ispec) 
  "Brackets multibyte after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'multibyte 'bracket arg ispec))

;;;###autoload
(defsubst kill-multibyte-atpt ()
  "Kills multibyte at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'multibyte))

;;;###autoload
(defsubst forward-multibyte-atpt (&optional arg ispec) 
  "Moves forward over multibyte at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:multibyte:]")
     ;; (forward-char 1)
  (thatpt-forward 'multibyte arg ispec)))

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

;;;###autoload
(defsubst nonascii-atpt (&optional arg ispec) 
  "Returns nonascii at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'nonascii arg ispec))

;;;###autoload
(defsubst bounds-of-nonascii-atpt (&optional arg ispec) 
  "Returns borders of nonascii at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'nonascii arg ispec))

;;;###autoload
(defsubst nonascii-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class nonascii at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'nonascii arg ispec))

;;;###autoload
(defsubst nonascii-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class nonascii at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'nonascii arg ispec))

;;;###autoload
(defsubst copy-nonascii-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class nonascii at point if any, nil otherwise 
"
  (interactive "p\np")
  (thatpt-copy 'nonascii arg ispec))

;;;###autoload
(defsubst separate-nonascii-atpt (&optional arg ispec) 
  "Separates nonascii at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'nonascii arg ispec))

;;;###autoload
(defsubst comment-nonascii-atpt (&optional arg ispec) 
  "Comments nonascii at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'nonascii arg ispec))

;;;###autoload
(defsubst doublequote-nonascii-atpt (&optional arg ispec) 
  "Doublequotes nonascii at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'nonascii 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-nonascii-atpt (&optional arg ispec) 
  "Singlequotes nonascii at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'nonascii 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-nonascii-atpt (&optional arg ispec) 
  "Parentizes nonascii at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'nonascii 'parentize arg ispec))

;;;###autoload
(defsubst brace-nonascii-atpt (&optional arg ispec) 
  "Braces nonascii at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'nonascii 'brace arg ispec))

;;;###autoload
(defsubst bracket-nonascii-atpt (&optional arg ispec) 
  "Brackets nonascii after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'nonascii 'bracket arg ispec))

;;;###autoload
(defsubst kill-nonascii-atpt ()
  "Kills nonascii at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'nonascii))

;;;###autoload
(defsubst forward-nonascii-atpt (&optional arg ispec) 
  "Moves forward over nonascii at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:nonascii:]")
     ;; (forward-char 1)
  (thatpt-forward 'nonascii arg ispec)))

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

;;;###autoload
(defsubst print-atpt (&optional arg ispec) 
  "Returns print at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'print arg ispec))

;;;###autoload
(defsubst bounds-of-print-atpt (&optional arg ispec) 
  "Returns borders of print at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'print arg ispec))

;;;###autoload
(defsubst print-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class print at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'print arg ispec))

;;;###autoload
(defsubst print-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class print at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'print arg ispec))

;;;###autoload
(defsubst copy-print-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class print at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'print arg ispec))

;;;###autoload
(defsubst separate-print-atpt (&optional arg ispec) 
  "Separates print at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'print arg ispec))

;;;###autoload
(defsubst comment-print-atpt (&optional arg ispec) 
  "Comments print at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'print arg ispec))

;;;###autoload
(defsubst doublequote-print-atpt (&optional arg ispec) 
  "Doublequotes print at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'print 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-print-atpt (&optional arg ispec) 
  "Singlequotes print at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'print 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-print-atpt (&optional arg ispec) 
  "Parentizes print at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'print 'parentize arg ispec))

;;;###autoload
(defsubst brace-print-atpt (&optional arg ispec) 
  "Braces print at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'print 'brace arg ispec))

;;;###autoload
(defsubst bracket-print-atpt (&optional arg ispec) 
  "Brackets print after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'print 'bracket arg ispec))

;;;###autoload
(defsubst kill-print-atpt ()
  "Kills print at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'print))

;;;###autoload
(defsubst forward-print-atpt (&optional arg ispec) 
  "Moves forward over print at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:print:]")
     ;; (forward-char 1)
  (thatpt-forward 'print arg ispec)))

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

;;;###autoload
(defsubst punct-atpt (&optional arg ispec) 
  "Returns punct at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'punct arg ispec))

;;;###autoload
(defsubst bounds-of-punct-atpt (&optional arg ispec) 
  "Returns borders of punct at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'punct arg ispec))

;;;###autoload
(defsubst punct-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class punct at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'punct arg ispec))

;;;###autoload
(defsubst punct-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class punct at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'punct arg ispec))

;;;###autoload
(defsubst copy-punct-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class punct at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'punct arg ispec))

;;;###autoload
(defsubst separate-punct-atpt (&optional arg ispec) 
  "Separates punct at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'punct arg ispec))

;;;###autoload
(defsubst comment-punct-atpt (&optional arg ispec) 
  "Comments punct at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'punct arg ispec))

;;;###autoload
(defsubst doublequote-punct-atpt (&optional arg ispec) 
  "Doublequotes punct at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'punct 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-punct-atpt (&optional arg ispec) 
  "Singlequotes punct at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'punct 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-punct-atpt (&optional arg ispec) 
  "Parentizes punct at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'punct 'parentize arg ispec))

;;;###autoload
(defsubst brace-punct-atpt (&optional arg ispec) 
  "Braces punct at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'punct 'brace arg ispec))

;;;###autoload
(defsubst bracket-punct-atpt (&optional arg ispec) 
  "Brackets punct after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'punct 'bracket arg ispec))

;;;###autoload
(defsubst kill-punct-atpt ()
  "Kills punct at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'punct))

;;;###autoload
(defsubst forward-punct-atpt (&optional arg ispec) 
  "Moves forward over punct at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:punct:]")
     ;; (forward-char 1)
  (thatpt-forward 'punct arg ispec)))

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

;;;###autoload
(defsubst space-atpt (&optional arg ispec) 
  "Returns space at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'space arg ispec))

;;;###autoload
(defsubst bounds-of-space-atpt (&optional arg ispec) 
  "Returns borders of space at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'space arg ispec))

;;;###autoload
(defsubst space-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class space at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'space arg ispec))

;;;###autoload
(defsubst space-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class space at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'space arg ispec))

;;;###autoload
(defsubst copy-space-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class space at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'space arg ispec))

;;;###autoload
(defsubst separate-space-atpt (&optional arg ispec) 
  "Separates space at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'space arg ispec))

;;;###autoload
(defsubst comment-space-atpt (&optional arg ispec) 
  "Comments space at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'space arg ispec))

;;;###autoload
(defsubst doublequote-space-atpt (&optional arg ispec) 
  "Doublequotes space at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'space 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-space-atpt (&optional arg ispec) 
  "Singlequotes space at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'space 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-space-atpt (&optional arg ispec) 
  "Parentizes space at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'space 'parentize arg ispec))

;;;###autoload
(defsubst brace-space-atpt (&optional arg ispec) 
  "Braces space at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'space 'brace arg ispec))

;;;###autoload
(defsubst bracket-space-atpt (&optional arg ispec) 
  "Brackets space after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'space 'bracket arg ispec))

;;;###autoload
(defsubst kill-space-atpt ()
  "Kills space at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'space))

;;;###autoload
(defsubst forward-space-atpt (&optional arg ispec) 
  "Moves forward over space at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:space:]")
     ;; (forward-char 1)
  (thatpt-forward 'space arg ispec)))

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

;;;###autoload
(defsubst unibyte-atpt (&optional arg ispec) 
  "Returns unibyte at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'unibyte arg ispec))

;;;###autoload
(defsubst bounds-of-unibyte-atpt (&optional arg ispec) 
  "Returns borders of unibyte at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'unibyte arg ispec))

;;;###autoload
(defsubst unibyte-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class unibyte at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'unibyte arg ispec))

;;;###autoload
(defsubst unibyte-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class unibyte at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'unibyte arg ispec))

;;;###autoload
(defsubst copy-unibyte-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class unibyte at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'unibyte arg ispec))

;;;###autoload
(defsubst separate-unibyte-atpt (&optional arg ispec) 
  "Separates unibyte at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'unibyte arg ispec))

;;;###autoload
(defsubst comment-unibyte-atpt (&optional arg ispec) 
  "Comments unibyte at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'unibyte arg ispec))

;;;###autoload
(defsubst doublequote-unibyte-atpt (&optional arg ispec) 
  "Doublequotes unibyte at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'unibyte 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-unibyte-atpt (&optional arg ispec) 
  "Singlequotes unibyte at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'unibyte 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-unibyte-atpt (&optional arg ispec) 
  "Parentizes unibyte at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'unibyte 'parentize arg ispec))

;;;###autoload
(defsubst brace-unibyte-atpt (&optional arg ispec) 
  "Braces unibyte at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'unibyte 'brace arg ispec))

;;;###autoload
(defsubst bracket-unibyte-atpt (&optional arg ispec) 
  "Brackets unibyte after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'unibyte 'bracket arg ispec))

;;;###autoload
(defsubst kill-unibyte-atpt ()
  "Kills unibyte at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'unibyte))

;;;###autoload
(defsubst forward-unibyte-atpt (&optional arg ispec) 
  "Moves forward over unibyte at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:unibyte:]")
     ;; (forward-char 1)
  (thatpt-forward 'unibyte arg ispec)))

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

;;;###autoload
(defsubst upper-atpt (&optional arg ispec) 
  "Returns upper at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'upper arg ispec))

;;;###autoload
(defsubst bounds-of-upper-atpt (&optional arg ispec) 
  "Returns borders of upper at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'upper arg ispec))

;;;###autoload
(defsubst upper-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class upper at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'upper arg ispec))

;;;###autoload
(defsubst upper-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class upper at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'upper arg ispec))

;;;###autoload
(defsubst copy-upper-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class upper at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'upper arg ispec))

;;;###autoload
(defsubst separate-upper-atpt (&optional arg ispec) 
  "Separates upper at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'upper arg ispec))

;;;###autoload
(defsubst comment-upper-atpt (&optional arg ispec) 
  "Comments upper at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'upper arg ispec))

;;;###autoload
(defsubst doublequote-upper-atpt (&optional arg ispec) 
  "Doublequotes upper at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'upper 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-upper-atpt (&optional arg ispec) 
  "Singlequotes upper at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'upper 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-upper-atpt (&optional arg ispec) 
  "Parentizes upper at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'upper 'parentize arg ispec))

;;;###autoload
(defsubst brace-upper-atpt (&optional arg ispec) 
  "Braces upper at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'upper 'brace arg ispec))

;;;###autoload
(defsubst bracket-upper-atpt (&optional arg ispec) 
  "Brackets upper after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'upper 'bracket arg ispec))

;;;###autoload
(defsubst kill-upper-atpt ()
  "Kills upper at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'upper))

;;;###autoload
(defsubst forward-upper-atpt (&optional arg ispec) 
  "Moves forward over upper at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:upper:]")
     ;; (forward-char 1)
  (thatpt-forward 'upper arg ispec)))

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

;;;###autoload
(defsubst xdigit-atpt (&optional arg ispec) 
  "Returns xdigit at point if any, nil otherwise"
  (interactive "p\np")
  (thatpt 'xdigit arg ispec))

;;;###autoload
(defsubst bounds-of-xdigit-atpt (&optional arg ispec) 
  "Returns borders of xdigit at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-bounds 'xdigit arg ispec))

;;;###autoload
(defsubst xdigit-atpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol or char-class xdigit at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-beginning 'xdigit arg ispec))

;;;###autoload
(defsubst xdigit-atpt-end-position (&optional arg ispec) 
  "Returns end position of symbol or char-class xdigit at point if any, nil 
otherwise "
  (interactive "p\np")
  (thatpt-end 'xdigit arg ispec))

;;;###autoload
(defsubst copy-xdigit-atpt (&optional arg ispec) 
  "Makes a copy of symbol or char-class xdigit at point if any, nil otherwise "
  (interactive "p\np")
  (thatpt-copy 'xdigit arg ispec))

;;;###autoload
(defsubst separate-xdigit-atpt (&optional arg ispec) 
  "Separates xdigit at point if any, does nothing otherwise
inserts newlines, borders are the beginning or the end of buffer "
  (interactive "p\np")
  (thatpt-separate 'xdigit arg ispec))

;;;###autoload
(defsubst comment-xdigit-atpt (&optional arg ispec) 
  "Comments xdigit at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-comment 'xdigit arg ispec))

;;;###autoload
(defsubst doublequote-xdigit-atpt (&optional arg ispec) 
  "Doublequotes xdigit at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'xdigit 'doublequote arg ispec))

;;;###autoload
(defsubst singlequote-xdigit-atpt (&optional arg ispec) 
  "Singlequotes xdigit at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'xdigit 'singlequote arg ispec))

;;;###autoload
(defsubst parentize-xdigit-atpt (&optional arg ispec) 
  "Parentizes xdigit at point if any, does nothing otherwise"
  (interactive "p\np")
  (thatpt-delim 'xdigit 'parentize arg ispec))

;;;###autoload
(defsubst brace-xdigit-atpt (&optional arg ispec) 
  "Braces xdigit at point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'xdigit 'brace arg ispec))

;;;###autoload
(defsubst bracket-xdigit-atpt (&optional arg ispec) 
  "Brackets xdigit after point if any, does nothing otherwise "
  (interactive "p\np")
  (thatpt-delim 'xdigit 'bracket arg ispec))

;;;###autoload
(defsubst kill-xdigit-atpt ()
  "Kills xdigit at point if any, does nothing otherwise "
  (interactive "*")
  (thatpt-kill 'xdigit))

;;;###autoload
(defsubst forward-xdigit-atpt (&optional arg ispec) 
  "Moves forward over xdigit at point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:xdigit:]")
     ;; (forward-char 1)
  (thatpt-forward 'xdigit arg ispec)))

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

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