1 ------------------------------------------------------------------------------
3 -- GNAT RUN-TIME LIBRARY COMPONENTS --
5 -- S Y S T E M . C O M P A R E _ A R R A Y _ U N S I G N E D _ 8 --
9 -- Copyright (C) 2002-2008, Free Software Foundation, Inc. --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 2, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING. If not, write --
19 -- to the Free Software Foundation, 51 Franklin Street, Fifth Floor, --
20 -- Boston, MA 02110-1301, USA. --
22 -- As a special exception, if other files instantiate generics from this --
23 -- unit, or you link this unit with other files to produce an executable, --
24 -- this unit does not by itself cause the resulting executable to be --
25 -- covered by the GNU General Public License. This exception does not --
26 -- however invalidate any other reasons why the executable file might be --
27 -- covered by the GNU Public License. --
29 -- GNAT was originally developed by the GNAT team at New York University. --
30 -- Extensive contributions were provided by Ada Core Technologies Inc. --
32 ------------------------------------------------------------------------------
34 pragma Warnings
(Off
);
38 with System
.Address_Operations
; use System
.Address_Operations
;
40 with Ada
.Unchecked_Conversion
;
42 package body System
.Compare_Array_Unsigned_8
is
44 type Word
is mod 2 ** 32;
45 -- Used to process operands by words
47 type Big_Words
is array (Natural) of Word
;
48 type Big_Words_Ptr
is access Big_Words
;
49 for Big_Words_Ptr
'Storage_Size use 0;
50 -- Array type used to access by words
52 type Byte
is mod 2 ** 8;
53 -- Used to process operands by bytes
55 type Big_Bytes
is array (Natural) of Byte
;
56 type Big_Bytes_Ptr
is access Big_Bytes
;
57 for Big_Bytes_Ptr
'Storage_Size use 0;
58 -- Array type used to access by bytes
60 function To_Big_Words
is new
61 Ada
.Unchecked_Conversion
(System
.Address
, Big_Words_Ptr
);
63 function To_Big_Bytes
is new
64 Ada
.Unchecked_Conversion
(System
.Address
, Big_Bytes_Ptr
);
66 ----------------------
67 -- Compare_Array_U8 --
68 ----------------------
70 function Compare_Array_U8
71 (Left
: System
.Address
;
72 Right
: System
.Address
;
74 Right_Len
: Natural) return Integer
76 Compare_Len
: constant Natural := Natural'Min (Left_Len
, Right_Len
);
79 -- If operands are non-aligned, or length is too short, go by bytes
81 if (ModA
(OrA
(Left
, Right
), 4) /= 0) or else Compare_Len
< 4 then
82 return Compare_Array_U8_Unaligned
(Left
, Right
, Left_Len
, Right_Len
);
85 -- Here we can go by words
88 LeftP
: constant Big_Words_Ptr
:=
90 RightP
: constant Big_Words_Ptr
:=
92 Words_To_Compare
: constant Natural := Compare_Len
/ 4;
93 Bytes_Compared_As_Words
: constant Natural := Words_To_Compare
* 4;
96 for J
in 0 .. Words_To_Compare
- 1 loop
97 if LeftP
(J
) /= RightP
(J
) then
98 return Compare_Array_U8_Unaligned
99 (AddA
(Left
, Address
(4 * J
)),
100 AddA
(Right
, Address
(4 * J
)),
105 return Compare_Array_U8_Unaligned
106 (AddA
(Left
, Address
(Bytes_Compared_As_Words
)),
107 AddA
(Right
, Address
(Bytes_Compared_As_Words
)),
108 Left_Len
- Bytes_Compared_As_Words
,
109 Right_Len
- Bytes_Compared_As_Words
);
111 end Compare_Array_U8
;
113 --------------------------------
114 -- Compare_Array_U8_Unaligned --
115 --------------------------------
117 function Compare_Array_U8_Unaligned
118 (Left
: System
.Address
;
119 Right
: System
.Address
;
121 Right_Len
: Natural) return Integer
123 Compare_Len
: constant Natural := Natural'Min (Left_Len
, Right_Len
);
125 LeftP
: constant Big_Bytes_Ptr
:= To_Big_Bytes
(Left
);
126 RightP
: constant Big_Bytes_Ptr
:= To_Big_Bytes
(Right
);
129 for J
in 0 .. Compare_Len
- 1 loop
130 if LeftP
(J
) /= RightP
(J
) then
131 if LeftP
(J
) > RightP
(J
) then
139 if Left_Len
= Right_Len
then
141 elsif Left_Len
> Right_Len
then
146 end Compare_Array_U8_Unaligned
;
148 end System
.Compare_Array_Unsigned_8
;