ZLE and handling of MARK

ZLE and handling of MARK

[Bart Schaefer]

If one sets the mark in zle and then delete characters to the left of it
by assigning to a slice of $BUFFER in a user-defined widget, the mark
remains in the same numeric position rather than the same logical position.

If instead one deletes characters by using the builtin widgets, the mark
stays in the same logical position (its numeric position changes as the
line gets shorter).  The two cases should be consistent, no?

One other observation:

If one sets the mark and then moves around in the history, the mark stays
at the same numeric position in each recalled line, moving only if a line
is too short for it to stay in that position AND some reference to the mark
is made (such as invoking exchange-point-and-mark).  I'm not sure whether
such behavior makes sense or not ... and if it changes, some functions in
Functions/Zle will have to change, too.

-- 
Bart Schaefer                                 Brass Lantern Enterprises
http://www.well.com/user/barts              http://www.brasslantern.com

Zsh: http://www.zsh.org | PHPerl Project: http://phperl.sourceforge.net   

Re: ZLE and handling of MARK

[Peter Stephenson]

"Bart Schaefer" wrote:
> If one sets the mark in zle and then delete characters to the left of it
> by assigning to a slice of $BUFFER in a user-defined widget, the mark
> remains in the same numeric position rather than the same logical position.

This is presumably wrong one.  I have a vague memory of adjusting the way
the mark was remembered at some point.  I certainly didn't make any
explicit change for user-defined widgets, so I suppose they got forgotten
about.

-- 
Peter Stephenson <pws@pwstephenson.fsnet.co.uk>
Work: pws@csr.com
Web: http://www.pwstephenson.fsnet.co.uk

Re: ZLE and handling of MARK

[Bart Schaefer]

On Oct 5, 10:18am, Sven Wischnowsky wrote:
} 
} Bart Schaefer wrote:
} 
} > If one sets the mark in zle and then delete characters to the left
} > of it by assigning to a slice of $BUFFER in a user-defined widget,
} > the mark remains in the same numeric position rather than the same
} > logical position.
}
} The only `secure' change I can see is to update the position of the
} mark if it is in $RBUFFER and only $LBUFFER is changed.

We perhaps should have forseen this problem with editing by assignment
rather than by function (builtin command) call.  Really, I suppose, an
assignment to (|L|R)BUFFER should clear the mark entirely, and should
be documented to do so ... and do what, with CURSOR ...?

Hmm, is there perhaps some way that we could detect assignment to a
slice (e.g. BUFFER[x,y]=...) and automatically recompute the mark based
on the endpoints of the slice?  Assigning to the entire variable would
be treated like assigning to BUFFER[1,-1], which would probably end up
moving both the mark and the cursor to the end of the buffer; assigning
to LBUFFER is like assigning to BUFFER[1,$#LBUFFER], etc.  All we need
is to be able to hook into the slice range.

The advantage here is that if one really did want to preserve the numeric
MARK and CURSOR across the assignment, all that's necessary is to declare
them "local +h".

} > If one sets the mark and then moves around in the history, the mark stays
} > at the same numeric position in each recalled line
} 
} It's a bit like emacs' line-movement, isn't it?

Not really.  The position of the cursor is like emacs' line-movement, but:

} (I always thought the mark should be either attached to a history line 
} so that exchange-p-a-m would toggle between lines

*That* would be like emacs' line-movement; but since you can't actually
do editing operations (like copy-region) across multiple history lines,
I suppose that behavior doesn't make much sense for zle.

} or it should be per-line. Maybe.)

That the mark is global is very convenient for things like searches on
a common prefix of history lines (see Functions/Zle/history-search-end).
Without that, the widget function would have to make use of global non-
special shell parameters (as it did before MARK existed).

So I guess the conclusion is that the current behavior does make as much
sense as anything else.

-- 
Bart Schaefer                                 Brass Lantern Enterprises
http://www.well.com/user/barts              http://www.brasslantern.com

Zsh: http://www.zsh.org | PHPerl Project: http://phperl.sourceforge.net   

Re: ZLE and handling of MARK

[Sven Wischnowsky]

Bart Schaefer wrote:

> If one sets the mark in zle and then delete characters to the left of it
> by assigning to a slice of $BUFFER in a user-defined widget, the mark
> remains in the same numeric position rather than the same logical position.
> 
> If instead one deletes characters by using the builtin widgets, the mark
> stays in the same logical position (its numeric position changes as the
> line gets shorter).  The two cases should be consistent, no?

Yes, but how? The only `secure' change I can see is to update the
position of the mark if it is in $RBUFFER and only $LBUFFER is
changed. Otherwise we would need some, probably complicated, code to
check how $(|L|R)BUFFER was changed (ok, for deletion/insertion of
characters or short strings from/to the end/beginning of L/RBUFFER
this seems doable).

> One other observation:
> 
> If one sets the mark and then moves around in the history, the mark stays
> at the same numeric position in each recalled line, moving only if a line
> is too short for it to stay in that position AND some reference to the mark
> is made (such as invoking exchange-point-and-mark).  I'm not sure whether
> such behavior makes sense or not ... and if it changes, some functions in
> Functions/Zle will have to change, too.

It's a bit like emacs' line-movement, isn't it?

(I always thought the mark should be either attached to a history line 
so that exchange-p-a-m would toggle between lines, or it should be
per-line. Maybe.)

Bye
 Sven


--
Sven Wischnowsky                         wischnow@informatik.hu-berlin.de