Path: utzoo!utgpu!jarvis.csri.toronto.edu!mailrus!tut.cis.ohio-state.edu!ucbvax!hplabs!hpfcdc!hpislx!hplvli!boyne
From: boyne@hplvli.HP.COM (Art Boyne)
Newsgroups: comp.lang.c
Subject: Re: Sizes, alignments, and maxima (was: Contiguous Arrays)
Message-ID: <340009@hplvli.HP.COM>
Date: 23 Feb 89 15:29:11 GMT
References: <2508@ssc-vax.UUCP>
Organization: Loveland Inst. Div
Lines: 40

badri@valhalla.ee.rochester.edu (Badri Lokanathan) writes:
>For instance, if the array was to be x[101] to x[110] instead of
>x[0] to x[9], what is the easiest way to do it?
>For automatic arrays one could do
>int space[10], *x; 
>x = &space[0] - 101;
>
>In article <1989Feb22.171441.7957@utzoo.uucp>, henry@utzoo.uucp (Henry Spencer) writes:
>> No one couldn't, not if one wants to be portable.  There is absolutely no
>> guarantee that x[101] will be the same as space[0], and in fact there is
>> no guarantee that the computation of x won't trap and give you a core dump.
                         ^^^^^^^^^^^
>> On a sufficiently odd segmented machine it might.  Even K&R1 warns you that
>> pointer arithmetic won't necessarily do what you think unless you keep it
>> within an array.
>
>Henry is probably referring to the comments on pages 98 and 189 of K&R1.
>My argument is, since x is an independent variable (a pointer, but
>still a variable,) there is no way of checking any array bounds.
>Thus in order for consistency with the definition of pointer
>arithmetic,
>x -= i; x += i;
>should result in the original value of x (provided the resulting
>intermediate values are within pointer ranges.)
>Since x can be initialized to any value, this should always be possible,
>the result after each operation being an address appropriately offset
>from the original object. Yes, accessing the contents of an illegal location
                                ^^^^^^^^^
>will almost certainly screw things up, but there is no access happening.

Sorry, but read Henry's response more carefully:  it is possible that the
*computation* of x-=i will cause an abort/trap/etc - without attempting
any *access*.  This is especially likely if x=-i would result in x pointing
to a negative-index array location (consider a machine whose address
registers trapped on a negative segment offset and whose compiler put
the array into a separate segment, perhaps due to segment size limitations).  
Henry is correct: pointer arithmetice isn't guaranteed unless you keep it
*within* an array.

Art Boyne, boyne@hplvla.HP.COM