According to Frank Heckenbach:

1. Is it safe to assume -- for all platforms, including possible future ones -- that SizeOf(a) = ((Ord(y)-Ord(x)+1) * SizeOf(t)?

I first thought that this would not be the case due to alignment problems, but ...:

That's *exactly* the way how GPC calculates the size of an array.

Why is this so, e.g. with an array of something which has 3 bytes?

Program Test;

Type r = packed record x: ShortWord; y: Byte; end (* r *);

Var x: packed array [ 1..1000 ] of r;

begin writeln ( SizeOf ( x ) ); writeln ( SizeOf ( x [ 1 ] ) ); end.

The output is 4000 and ... 4. To avoid alignment problems in an "array of r", the record `r' has size 4, not 3.

I conclude that the assumption is safe.

2. Is it safe to assume that Integer(@a[p])-Integer(@a[q]) = (p-q) * SizeOf(t)?

Yes, for the same reason. If the "natural" size of `t' would cause alignment problems, `t' is blown up by GPC.

(Is it generally allowed to cast a pointer into an integer, in the first place?)

I think so. The GNU coding standard says about GCC's (and thus GPC's) behaviour:

You can assume that all pointers have the same format, regardless of the type they point to, and that this is really an integer.

Greetings,

Peter

Dipl.-Phys. Peter Gerwinski, Essen, Germany, free physicist and programmer peter.gerwinski@uni-essen.de - http://home.pages.de/~peter.gerwinski/ [970201] maintainer GNU Pascal [970420] - http://home.pages.de/~gnu-pascal/ [970125]