Re: [PATCH] Removed arbitrary limitations on array accesses

[Mikael Magnusson <mikachu@gmail.com>]

2010/1/5 Bart Schaefer <schaefer@brasslantern.com>:
> On Jan 5,  9:48am, Peter Stephenson wrote:
> }
> } Those have been there for a long time. I don't have any evidence that
> } they're doing a lot of good but we have had people creating positional
> } parameters with <long_number>=something and wondering why it uses a
> } lot of memory. I suppose this is similar. The arbitrary limit is not
> } very useful and also undocumented; most people wouldn't miss it if it
> } wasn't there, certainly.
>
> I have a vague memory of when this was added, but it appears to have been
> sometime longer ago than when the zsh-workers archive begins and after
> the last zsh-2 archive I kept -- which means it was late 1994 or early
> 1995.
>
> My recollection, such as it is, is that attempting to read an array
> slice from N to some huge number would allocate a temporary array with
> empty slots for all the intervening positions, causing the shell to
> crash with an out-of-memory error or to DoS attack the university time-
> share system by attempting to consume all memory.  The arbitrary 262144
> number was chosen based on some computation of the space occupied by
> one of those empty slots, to assure that the resulting temporary would
> be smaller than the typical VM limitations of a machine of the era.
>
> It seems like we need SOME kind of limit here to prevent the user from
> accidentally consuming huge amounts of memory, but it's probably useful
> for it to become a computed value based on process limits.

echo $path[1,100000000000000000] appears to work fine here (though
$path[1,1000000000000000000] seems to expand to nothing) without using
any noticable memory. If you mean an array that is actually that size,
then the memory is already used, so the worst would be doubling what
is already used? If it only affects slices, could single element
access still be unlimited?

I notice that even before the patch, using [-n]  to access the last
element seems to work for larger arrays.

% test=({1..300000})
% echo $test[270000]
zsh: subscript too big: 270000
% echo $test[-1]
300000
% echo $test[-2]
299999
% echo $test[-100]
299901
% echo $test[-100,-90]
299901 299902 299903 299904 299905 299906 299907 299908 299909 299910 299911
% echo $test[-270000]
zsh: subscript too small: -270000

-- 
Mikael Magnusson