paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-04-21 01:29:29 +02:00
Code Issues Packages Projects Releases Wiki Activity

* varset helpers completed

Browse Source 
git-svn-id: trunk@4635 -
This commit is contained in:
florian 2006-09-17 18:20:30 +00:00
parent d4bf6d2aed
commit 77193410b2
1 changed files with 80 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

166
rtl/inc/genset.inc
View File

@ -210,18 +210,14 @@ function fpc_set_unset_byte(const source: fpc_normal_set; b : byte): fpc_normal_
****************************************************************************}
{$ifndef FPC_SYSTEM_HAS_FPC_SET_LOAD_SMALL}
{ Error No pascal version of FPC_SET_LOAD_SMALL}
{ THIS DEPENDS ON THE ENDIAN OF THE ARCHITECTURE!
Not anymore PM}
function fpc_varset_load_small(l: fpc_small_set): fpc_normal_set; compilerproc;
{
{
load a normal set p from a smallset l
}
begin
result[0] := l;
FillDWord(result[1],7,0);
end;
}
procedure fpc_varset_load_small(l: fpc_small_set;var dest); compilerproc;
begin
move(l,plongint(@dest)^,4);
FillChar((@dest+4)^,size-4,0);
end;
{$endif ndef FPC_SYSTEM_HAS_FPC_SET_LOAD_SMALL}
@ -231,10 +227,10 @@ function fpc_varset_load_small(l: fpc_small_set): fpc_normal_set; compilerproc;
}
procedure fpc_varset_create_element(b,size : ptrint; var data); compilerproc;
type
longintarray = array [0..high(sizeint) div 4-1] of longint;
tbytearray = array[0..sizeof(sizeint)-1] of byte;
begin
FillChar(data,size,0);
longintarray(data)[b div 32]:=1 shl (b mod 32);
tbytearray(data)[b div 8]:=1 shl (b mod 8);
end;
{$endif ndef FPC_SYSTEM_HAS_FPC_VARSET_CREATE_ELEMENT}
@ -243,12 +239,12 @@ procedure fpc_varset_create_element(b,size : ptrint; var data); compilerproc;
{
add the element b to the set "source"
}
procedure fpc_varset_set_byte(var source,dest; b,size : ptrint); compilerproc;
procedure fpc_varset_set(var source,dest; b,size : ptrint); compilerproc;
type
longintarray = array [0..high(sizeint) div 4-1] of longint;
tbytearray = array[0..sizeof(sizeint)-1] of byte;
begin
move(source,dest,sizeof(source));
longintarray(dest)[b div 32]:=longintarray(dest)[b div 32] or (1 shl (b mod 32));
tbytearray(dest)[b div 8]:=tbytearray(dest)[b div 8] or (1 shl (b mod 8));
end;
{$endif ndef FPC_SYSTEM_HAS_FPC_VARSET_SET_BYTE}
@ -258,108 +254,106 @@ procedure fpc_varset_set_byte(var source,dest; b,size : ptrint); compilerproc;
suppresses the element b to the set pointed by p
used for exclude(set,element)
}
procedure fpc_varset_unset_byte(var source,dest; b,size : ptrint); compilerproc;
procedure fpc_varset_unset(var source,dest; b,size : ptrint); compilerproc;
type
longintarray = array [0..high(sizeint) div 4-1] of longint;
tbytearray = array[0..sizeof(sizeint)-1] of byte;
begin
move(source,dest,size);
longintarray(dest)[b div 32]:=longintarray(dest)[b div 32] and not (1 shl (b mod 32));
tbytearray(dest)[b div 8]:=tbytearray(dest)[b div 8] and not (1 shl (b mod 8));
end;
{$endif ndef FPC_SYSTEM_HAS_FPC_VARSET_UNSET_BYTE}
{$ifndef FPC_SYSTEM_HAS_FPC_VARSET_SET_RANGE}
function fpc_varset_set_range(const orgset: fpc_normal_set; l,h : byte): fpc_normal_set; compilerproc;
{
adds the range [l..h] to the set orgset
}
{
adds the range [l..h] to the set orgset
}
procedure fpc_varset_set_range(const orgset; var dest;l,h,size : ptrint); compilerproc;
type
tbytearray = array[0..sizeof(sizeint)-1] of byte;
var
i: integer;
c: longint;
i : ptrint;
begin
move(orgset,fpc_varset_set_range,sizeof(orgset));
move(orgset,dest,size);
for i:=l to h do
begin
c := fpc_varset_set_range[i div 32];
c := (1 shl (i mod 32)) or c;
fpc_varset_set_range[i div 32] := c;
end;
tbytearray(dest)[i div 8]:=(1 shl (i mod 8)) or tbytearray(dest)[i div 8];
end;
{$endif ndef FPC_SYSTEM_HAS_FPC_VARSET_SET_RANGE}
{$ifndef FPC_SYSTEM_HAS_FPC_VARSET_IN_BYTE}
function fpc_varset_in_byte(const p: fpc_normal_set; b: byte): boolean; compilerproc;
{
tests if the element b is in the set p the carryflag is set if it present
}
{
tests if the element b is in the set p the carryflag is set if it present
}
function fpc_varset_in(const p; b : ptrint): boolean; compilerproc;
type
tbytearray = array[0..sizeof(sizeint)-1] of byte;
begin
fpc_varset_in_byte := (p[b div 32] and (1 shl (b mod 32))) <> 0;
fpc_varset_in:=(tbytearray(p)[b div 8] and (1 shl (b mod 8)))<>0;
end;
{$endif ndef FPC_SYSTEM_HAS_FPC_VARSET_IN_BYTE}
{$ifndef FPC_SYSTEM_HAS_FPC_VARSET_ADD_SETS}
function fpc_varset_add_sets(const set1,set2: fpc_normal_set): fpc_normal_set; compilerproc;
var
dest: fpc_normal_set absolute fpc_varset_add_sets;
{
adds set1 and set2 into set dest
}
{
adds set1 and set2 into set dest
}
procedure fpc_varset_add_sets(const set1,set2; var dest;size : ptrint); compilerproc;
type
tbytearray = array[0..sizeof(sizeint)-1] of byte;
var
i: integer;
begin
for i:=0 to 7 do
dest[i] := set1[i] or set2[i];
i : ptrint;
begin
for i:=0 to size-1 do
tbytearray(dest)[i]:=tbytearray(set1)[i] or tbytearray(set2)[i];
end;
{$endif ndef FPC_SYSTEM_HAS_FPC_VARSET_ADD_SETS}
{$ifndef FPC_SYSTEM_HAS_FPC_VARSET_MUL_SETS}
function fpc_varset_mul_sets(const set1,set2: fpc_normal_set): fpc_normal_set; compilerproc;
var
dest: fpc_normal_set absolute fpc_varset_mul_sets;
{
multiplies (takes common elements of) set1 and set2 result put in dest
}
var
i: integer;
begin
for i:=0 to 7 do
dest[i] := set1[i] and set2[i];
end;
{
multiplies (takes common elements of) set1 and set2 result put in dest
}
procedure fpc_varset_mul_sets(const set1,set2; var dest;size : ptrint); compilerproc;
type
tbytearray = array[0..sizeof(sizeint)-1] of byte;
var
i : ptrint;
begin
for i:=0 to size-1 do
tbytearray(dest)[i]:=tbytearray(set1)[i] and tbytearray(set2)[i];
end;
{$endif ndef FPC_SYSTEM_HAS_FPC_VARSET_MUL_SETS}
{$ifndef FPC_SYSTEM_HAS_FPC_VARSET_SUB_SETS}
function fpc_varset_sub_sets(const set1,set2: fpc_normal_set): fpc_normal_set;[public,alias:'fpc_varset_SUB_SETS']; compilerproc;
var
dest: fpc_normal_set absolute fpc_varset_sub_sets;
{
{
computes the diff from set1 to set2 result in dest
}
var
i: integer;
begin
for i:=0 to 7 do
dest[i] := set1[i] and not set2[i];
end;
}
procedure fpc_varset_sub_sets(const set1,set2; var dest;size : ptrint); compilerproc;
type
tbytearray = array[0..sizeof(sizeint)-1] of byte;
var
i : ptrint;
begin
for i:=0 to size-1 do
tbytearray(dest)[i]:=tbytearray(set1)[i] and not tbytearray(set2)[i];
end;
{$endif ndef FPC_SYSTEM_HAS_FPC_VARSET_SUB_SETS}
{$ifndef FPC_SYSTEM_HAS_FPC_VARSET_SYMDIF_SETS}
function fpc_varset_symdif_sets(const set1,set2: fpc_normal_set): fpc_normal_set;[public,alias:'fpc_varset_SYMDIF_SETS']; compilerproc;
var
dest: fpc_normal_set absolute fpc_varset_symdif_sets;
{
{
computes the symetric diff from set1 to set2 result in dest
}
var
i: integer;
}
procedure fpc_varset_symdif_sets(const set1,set2; var dest;size : ptrint); compilerproc;
type
tbytearray = array[0..sizeof(sizeint)-1] of byte;
var
i : ptrint;
begin
for i:=0 to 7 do
dest[i] := set1[i] xor set2[i];
for i:=0 to size-1 do
tbytearray(dest)[i]:=tbytearray(set1)[i] xor tbytearray(set2)[i];
end;
{$endif ndef FPC_SYSTEM_HAS_FPC_VARSET_SYMDIF_SETS}
@ -368,15 +362,17 @@ procedure fpc_varset_unset_byte(var source,dest; b,size : ptrint); compilerproc;
{
compares set1 and set2 zeroflag is set if they are equal
}
function fpc_varset_comp_sets(const set1,set2 : fpc_normal_set):boolean;[public,alias:'fpc_varset_COMP_SETS'];compilerproc;
function fpc_varset_comp_sets(const set1,set2;size : ptrint):boolean; compilerproc;
type
tbytearray = array[0..sizeof(sizeint)-1] of byte;
var
i : ptrint;
begin
fpc_varset_comp_sets:= false;
for i:=0 to 7 do
if set1[i] <> set2[i] then
for i:=0 to size-1 do
if tbytearray(set1)[i]<>tbytearray(set2)[i] then
exit;
fpc_varset_comp_sets:= true;
fpc_varset_comp_sets:=true;
end;
{$endif ndef FPC_SYSTEM_HAS_FPC_VARSET_COMP_SETS}
@ -385,7 +381,7 @@ function fpc_varset_comp_sets(const set1,set2 : fpc_normal_set):boolean;[public,
{
on exit, zero flag is set if set1 <= set2 (set2 contains set1)
}
function fpc_varset_contains_sets(const set1,set2;size : ptrint):boolean;[public,alias:'fpc_varset_CONTAINS_SETS'];compilerproc;
function fpc_varset_contains_sets(const set1,set2;size : ptrint):boolean; compilerproc;
type
tbytearray = array[0..sizeof(sizeint)-1] of byte;
var
@ -398,5 +394,3 @@ function fpc_varset_contains_sets(const set1,set2;size : ptrint):boolean;[public
fpc_varset_contains_sets:=true;
end;
{$endif ndef FPC_SYSTEM_HAS_FPC_VARSET_CONTAINS_SET}