Where is clipper.el's homepage today?

Where is clipper.el's homepage today?

[Lennart Borgman]

I was looking at some convenient way to paste some strings I often use 
personally. On EmacsWiki clipper.el was mentioned, but the link to it 
was broken. Where is it on the Internet today?

Is there maybe a better way to do this? (I have no use for template in 
my simple cases I believe.)

Re: Where is clipper.el's homepage today?

[greg.bognar]

Lennart Borgman wrote:
> I was looking at some convenient way to paste some strings I often use
> personally. On EmacsWiki clipper.el was mentioned, but the link to it
> was broken. Where is it on the Internet today?

If you use a Debian-based distro, clipper is included in the
emacs-goodies package.

Re: Where is clipper.el's homepage today?

[Mathias Dahl]

Lennart Borgman <lennart.borgman.073@student.lu.se> writes:

> I was looking at some convenient way to paste some strings I often
> use personally. On EmacsWiki clipper.el was mentioned, but the link
> to it was broken. Where is it on the Internet today?
>
> Is there maybe a better way to do this? (I have no use for template
> in my simple cases I believe.)

Have you tested using some global abbrevs? It's not "pasting" but it
types the text for you.

Abbrevs are really powerful!

Regular expression search

[vb]

let's say I need a function to find first printable character on the line 
where the pointer is. This is what I'm trying to use:

(defun vb-first-printable ()
  (interactive)
  (let (limit-position)
    (beginning-of-line)
    (next-line 1)
    (setq limit-position (point))
    (previous-line 1)
    (re-search-forward "\\S" limit-position 't)))

when I try executing this, I get the following error:

====================================================
Debugger entered--Lisp error: (invalid-regexp "Premature end of regular 
expression")
  re-search-forward("\\S" 3543 t)
  (let (limit-position) (beginning-of-line) (next-line 1) (setq limit-position 
(point)) (previous-line 1) (re-search-forward "\\S" limit-position (quote 
t)))
  vb-first-printable()
  call-interactively(vb-first-printable)
===================================================

the same problem happens when I try re-search-forward from the command line: 
if I enter "\S" as the pattern to search, I get "premature end of regular 
expression" error,  but if I enter "\\S" as the regular expression pattern, 
the only thing it finds is this pattern (\\S) itself (as I try it on the same 
file where the source code is).

What am I missing here?

TIA,
\vb

Re: Regular expression search

[Kevin Rodgers]

vb wrote:
> let's say I need a function to find first printable character on the line 
> where the pointer is. This is what I'm trying to use:
> 
> (defun vb-first-printable ()
>   (interactive)
>   (let (limit-position)
>     (beginning-of-line)
>     (next-line 1)
>     (setq limit-position (point))
>     (previous-line 1)
>     (re-search-forward "\\S" limit-position 't)))
> 
> when I try executing this, I get the following error:
> 
> ====================================================
> Debugger entered--Lisp error: (invalid-regexp "Premature end of regular 
> expression")
>   re-search-forward("\\S" 3543 t)
>   (let (limit-position) (beginning-of-line) (next-line 1) (setq limit-position 
> (point)) (previous-line 1) (re-search-forward "\\S" limit-position (quote 
> t)))
>   vb-first-printable()
>   call-interactively(vb-first-printable)
> ===================================================
> 
> the same problem happens when I try re-search-forward from the command line: 
> if I enter "\S" as the pattern to search, I get "premature end of regular 
> expression" error,  but if I enter "\\S" as the regular expression pattern, 
> the only thing it finds is this pattern (\\S) itself (as I try it on the same 
> file where the source code is).
> 
> What am I missing here?

Commands that prompt you for a regexp allow you to enter it directly;
but when calling a Lisp function you have to specify the regexp as a
string, and in order to represent a backslash within a (double quote- 
delimited) string literal you must double it: "This string has 1 
backslash (here: \\) and 1 double quote (here: \")."  And of course
the `\\' regexp matches the backslash character itself.

The manual states:

,----
| `\sC'
|      matches any character whose syntax is C.  Here C is a character
|      that designates a particular syntax class: thus, `w' for word
|      constituent, `-' or ` ' for whitespace, `.' for ordinary
|      punctuation, etc.  *Note Syntax::.
|
| `\SC'
|      matches any character whose syntax is not C.
`----

So you must specify a syntax class `C', e.g. `w' for word constituent,
`-' or ` ' for whitespace, `.' for ordinary punctuation, etc.

But as there is no syntax class for printable or non-printable
characters, that seems like a dead end.  But there is the [:print:]
character class that you can use in regular expressions.

And finally, all that limit-position/next-line/point/previous-line stuff
can be replaced by line-end-position:

(defun vb-first-printable ()
   (interactive)
   (beginning-of-line)
   (re-search-forward "[[:print:]]" (line-end-position)))

-- 
Kevin

Re: Regular expression search

[vb]

Kevin,

thank you for your explanation. The [[:print:]] notation didn't quite work 
either, but following your suggestion I tried \\S- and it worked.

(defun vb-first-printable ()
  (interactive)
  (beginning-of-line)
  ( if (re-search-forward "\\S-" (line-end-position) 't)
      (backward-char)
    )
)


Boy, nothing is what it seems with emacs :-)

cheers,
/vb

On Wednesday 01 November 2006 12:04, Kevin Rodgers wrote:
> vb wrote:
> > let's say I need a function to find first printable character on the line
> > where the pointer is. This is what I'm trying to use:
> >
> > (defun vb-first-printable ()
> >   (interactive)
> >   (let (limit-position)
> >     (beginning-of-line)
> >     (next-line 1)
> >     (setq limit-position (point))
> >     (previous-line 1)
> >     (re-search-forward "\\S" limit-position 't)))
> >
> > when I try executing this, I get the following error:
> >
> > ====================================================
> > Debugger entered--Lisp error: (invalid-regexp "Premature end of regular
> > expression")
> >   re-search-forward("\\S" 3543 t)
> >   (let (limit-position) (beginning-of-line) (next-line 1) (setq
> > limit-position (point)) (previous-line 1) (re-search-forward "\\S"
> > limit-position (quote t)))
> >   vb-first-printable()
> >   call-interactively(vb-first-printable)
> > ===================================================
> >
> > the same problem happens when I try re-search-forward from the command
> > line: if I enter "\S" as the pattern to search, I get "premature end of
> > regular expression" error,  but if I enter "\\S" as the regular
> > expression pattern, the only thing it finds is this pattern (\\S) itself
> > (as I try it on the same file where the source code is).
> >
> > What am I missing here?
>
> Commands that prompt you for a regexp allow you to enter it directly;
> but when calling a Lisp function you have to specify the regexp as a
> string, and in order to represent a backslash within a (double quote-
> delimited) string literal you must double it: "This string has 1
> backslash (here: \\) and 1 double quote (here: \")."  And of course
> the `\\' regexp matches the backslash character itself.
>
> The manual states:
>
> ,----
>
> | `\sC'
> |      matches any character whose syntax is C.  Here C is a character
> |      that designates a particular syntax class: thus, `w' for word
> |      constituent, `-' or ` ' for whitespace, `.' for ordinary
> |      punctuation, etc.  *Note Syntax::.
> |
> | `\SC'
> |      matches any character whose syntax is not C.
>
> `----
>
> So you must specify a syntax class `C', e.g. `w' for word constituent,
> `-' or ` ' for whitespace, `.' for ordinary punctuation, etc.
>
> But as there is no syntax class for printable or non-printable
> characters, that seems like a dead end.  But there is the [:print:]
> character class that you can use in regular expressions.
>
> And finally, all that limit-position/next-line/point/previous-line stuff
> can be replaced by line-end-position:
>
> (defun vb-first-printable ()
>    (interactive)
>    (beginning-of-line)
>    (re-search-forward "[[:print:]]" (line-end-position)))

Re: Regular expression search

[Edward O'Connor]

> (defun vb-first-printable ()
> (interactive)
> (beginning-of-line)
> ( if (re-search-forward "\\S-" (line-end-position) 't)
> (backward-char)
> )
> )
>

I wonder if you know about M-m?

,----[ C-h k M-m ]
| M-m runs the command back-to-indentation
|    which is an interactive compiled Lisp function in `simple'.
| (back-to-indentation)
| 
| Move point to the first non-whitespace character on this line.
`----


-- 
Edward O'Connor
hober0@gmail.com

Ense petit placidam sub libertate quietem.

Re: Regular expression search

[vb]

On Wednesday 01 November 2006 14:23, Edward O'Connor wrote:
> > (defun vb-first-printable ()
> > (interactive)
> > (beginning-of-line)
> > ( if (re-search-forward "\\S-" (line-end-position) 't)
> > (backward-char)
> > )
> > )
>
> I wonder if you know about M-m?
>

This is a good question - no, I didn't! I suspected there was a command for 
that but did not find it in a brief search.

But it was educational to figure out the emacs regexp search idiosyncrasy 
anyways :-)

cheers,
/vb

> ,----[ C-h k M-m ]
>
> | M-m runs the command back-to-indentation
> |    which is an interactive compiled Lisp function in `simple'.
> | (back-to-indentation)
> |
> | Move point to the first non-whitespace character on this line.
>
> `----

Re: Regular expression search

[Kevin Rodgers]

[Please don't top-post.]

vb wrote:
> thank you for your explanation. The [[:print:]] notation didn't quite work 
> either, but following your suggestion I tried \\S- and it worked.

Ah, the [:foo:] character classes were introduced in Emacs 22.

> (defun vb-first-printable ()
>   (interactive)
>   (beginning-of-line)
>   ( if (re-search-forward "\\S-" (line-end-position) 't)
>       (backward-char)
>     )
> )

(eq t 't) => t

> Boy, nothing is what it seems with emacs :-)

?
-- 
Kevin