This is probably a stupid question, but I'll ask anyway ;-)

Is there any support from the compiler to create arrays of, say

type ttest=(one,two,three,four);

Afair, these states could be represented with 2 bits. 00,01,10,11

So four of these items could be represented in a byte (in an array of ttest).

I know that these enumerations take 4 bytes by default, and this can be reduced with {$Z1}

My queston: is there any support from the compiler to pack 4 ttest in 4 array items (using 1 byte) or do i have to fiddle with bit-shift operations on a byte type?

Does {$BITPACKING ON} have to do with it?

Thanks and sorry.

Theo

Declare the array as "bitpacked":

type
  ttestarray = bitpacked array[0..3] of ttest;

Note that dynamic arrays cannot be bitpacked.

Jonas

Thank you Jonas.

Now I was trying if something like this would work:

TTest=(one,two,three,four);
TTestarray = {bitpacked} array [1..100000] of ttest;
PTestarray = ^TTestarray;
var lMask: PTestarray;
begin
getmem(lMask, 25);
 lMask^[99]:=three;
 case lMask^[99] of
  one:writeln('one');
  two:writeln('two');
  three:writeln('three');
  four:writeln('four');
 end;
 freemem(lMask);
end;

It seems, to work, but it even works with commented "bitpacked". Shouldn't this fail? How can I test this? I have all checks on which Lazarus IDE offers, but it's still happy.

From what I understand, this would need 400 bytes in this scenario (not

bitpacked), isn't it?

Thank you
Theo

Uses new(lMask) instead, then the compiler will automatically allocate the right size for you.

You are writing into unallocated memory. The result of such an operation is "undefined". That means that it can to work, can crash, or anything in between.

How can I test this? I have all checks on which Lazarus IDE offers, but it's still happy.

Have you enabled heaptrc? (-gh)

Jonas

Hello theo,

Tuesday, July 20, 2010, 12:03:28 PM, you wrote:

t> Now I was trying if something like this would work: t> TTest=(one,two,three,four);
t> TTestarray = {bitpacked} array [1..100000] of ttest; t> PTestarray = ^TTestarray;
[...]
t> It seems, to work, but it even works with commented "bitpacked". t> Shouldn't this fail? How can I test this? I have all checks on which t> Lazarus IDE offers, but it's still happy.

>From what I understand, this would need 400 bytes in this scenario (not

t> bitpacked), isn't it?

Had you tried SizeOf(TTestarray) ?

José Mejuto wrote

Had you tried SizeOf(TTestarray) ?

Good idea. Now I can see that the theory is right. for: TTestarray = array [1..100] of ttest;
It goes down from 400 to 25 (using bitpacked).

Jonas Maebe wrote

Uses new(lMask) instead, then the compiler will automatically allocate

the right size for you.

I don't think this is going to solve my problem.
I need to define the
getmem(lMask, (Elements div 4) +1);
this should be possible, right?

Thank you both.
Theo

BTW, I think that bitpacked should be extended to support dynamic arrays -- it would be useful for bit vectors, for example.