Michael Van Canneyt wrote:
On Sat, 21 May 2005, listmember wrote:
Michael Van Canneyt wrote:
It's in SubVersion. 2 demo units are in packages/extra/uuid, with
testprograms.
http://svn.freepascal.org/svn/fpc/trunk/packages/extra/uuid/
It looks OK to me, except that it may be a little more optimized
for speed since GUIDs are CPU-expensive to begin with.
Feel free to submit patches and a testprogram to prove that your
implementation is significantly faster :-)
:-)
I did not mean it to be condescending; but it probably came out
that way. I apologize if it did sound like that.
So, let me start afresh.
I am wet behind-the-ears when it comes to Free Pascal, I don't
even know wehere, say, TGUID is declared in FPC (yet).
But, I am not that new to Pascal/Delphi, and I have used
them to write engine stuff mainly, in the past.
I have found that it can be easier, faster and more convenient
to use variant records to do some 'sub-atomic' operations.
So, in unit uuid, I'd use one of these variant record types in
a couple of routines, say, Procedure UUIDPack() instead of SHR
ops.
And in Function GetMacAddr() instead of
P:=Pchar(@ifr.ifru_hwaddr.sa_data);
Result:=(p[0]<>#0) or (p[1]<>#0) or (p[2]<>#0)
or (p[3]<>#0) or (p[4]<>#0) or (p[5]<>#0);
we'd have
Move(ifr.ifru_hwaddr.sa_data, P.Bytes[0], SizeOf(TInt128Splitter));
Result:= (p.Int640 <> 0) Or (p.Int641 <> 0);
where
p: TInt128Splitter;
etc.
You might or might not agree with the above, so independent
of all that, here is some more blurb promoting it :-)
These variant arrays are, IMHO, more pascal-like than
bitwise operations for general users, more convenient
(yu get to pick and choose the kind of value you want),
and faster sometimes (instead of many SGR/SHL ops), plus
they can be useful to convert between little-endian and
big-endian numbers etc.
Here below is what they look like, I wonder if you'd
consider them.
TWordSplitter = Packed Record
Case Split: Byte Of
0: Self: Word;
1: (
Byte0 : Byte;
Byte1 : Byte;
);
2: (
Bytes : Packed Array [0..1] Of Byte;
);
End;
TIntegerSplitter = Packed Record
Case Split: Byte Of
0: Self: Integer;
1: (
Byte0 : Byte;
Byte1 : Byte;
Byte2 : Byte;
Byte3 : Byte;
);
2: (
Word0 : Word;
Word1 : Word;
);
3: (
Bytes : Packed Array [0..3] Of Byte;
);
4: (
Words : Packed Array [0..1] Of Word;
);
End;
TInt64Splitter = Packed Record
Case Split: Byte Of
0: Self: Int64;
1: (
Byte0 : Byte;
Byte1 : Byte;
Byte2 : Byte;
Byte3 : Byte;
Byte4 : Byte;
Byte5 : Byte;
Byte6 : Byte;
Byte7 : Byte;
);
2: (
Word0 : Word;
Word1 : Word;
Word2 : Word;
Word3 : Word;
);
3: (
Integer0 : Integer;
Integer1 : Integer;
);
4: (
Bytes : Packed Array [0..7] Of Byte;
);
5: (
Words : Packed Array [0..3] Of Word;
);
6: (
Integers : Packed Array [0..1] Of Integers;
);
End;
{This would be useful for 128-bit stuf, like GUIDs :-) }
TInt128Splitter = Packed Record
Case Split: Byte Of
// 0: Self: Int128; //This does not exist
0: (
Byte0 : Byte;
Byte1 : Byte;
Byte2 : Byte;
Byte3 : Byte;
Byte4 : Byte;
Byte5 : Byte;
Byte6 : Byte;
Byte7 : Byte;
Byte8 : Byte;
Byte9 : Byte;
Byte10 : Byte;
Byte11 : Byte;
Byte12 : Byte;
Byte13 : Byte;
Byte14 : Byte;
Byte15 : Byte;
);
1: (
Word0 : Word;
Word1 : Word;
Word2 : Word;
Word3 : Word;
Word4 : Word;
Word5 : Word;
Word6 : Word;
Word7 : Word;
);
2: (
Integer0 : Integer;
Integer1 : Integer;
Integer2 : Integer;
Integer3 : Integer;
);
3: (
Int640 : Int64;
Int641 : Int64;
);
4: (
Bytes : Packed Array [0..15] Of Byte;
);
5: (
Words : Packed Array [0..7] Of Word;
);
6: (
Integers : Packed Array [0..3] Of Integers;
);
7: (
Int64s : Packed Array [0..1] Of Int64;
);
End;
Similar stuff can be made for single, double etc. just to
work on their byte content (not much more useful than that).
On all platforms, the default behaviour can be changed using
the OnCreateGUID event.
This is excellent. Thank you.
Cheers,
Basri
_______________________________________________
fpc-pascal maillist - fpc-pascal@lists.freepascal.org
http://lists.freepascal.org/mailman/listinfo/fpc-pascal
