1------------------------------------------------------------------------------ 2-- -- 3-- GNAT RUN-TIME LIBRARY COMPONENTS -- 4-- -- 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 -- 6-- -- 7-- B o d y -- 8-- -- 9-- Copyright (C) 2002-2013, Free Software Foundation, Inc. -- 10-- -- 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 3, 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. -- 17-- -- 18-- As a special exception under Section 7 of GPL version 3, you are granted -- 19-- additional permissions described in the GCC Runtime Library Exception, -- 20-- version 3.1, as published by the Free Software Foundation. -- 21-- -- 22-- You should have received a copy of the GNU General Public License and -- 23-- a copy of the GCC Runtime Library Exception along with this program; -- 24-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- 25-- <http://www.gnu.org/licenses/>. -- 26-- -- 27-- GNAT was originally developed by the GNAT team at New York University. -- 28-- Extensive contributions were provided by Ada Core Technologies Inc. -- 29-- -- 30------------------------------------------------------------------------------ 31 32pragma Compiler_Unit_Warning; 33 34with System.Address_Operations; use System.Address_Operations; 35 36with Ada.Unchecked_Conversion; 37 38package body System.Compare_Array_Unsigned_8 is 39 40 type Word is mod 2 ** 32; 41 -- Used to process operands by words 42 43 type Big_Words is array (Natural) of Word; 44 type Big_Words_Ptr is access Big_Words; 45 for Big_Words_Ptr'Storage_Size use 0; 46 -- Array type used to access by words 47 48 type Byte is mod 2 ** 8; 49 -- Used to process operands by bytes 50 51 type Big_Bytes is array (Natural) of Byte; 52 type Big_Bytes_Ptr is access Big_Bytes; 53 for Big_Bytes_Ptr'Storage_Size use 0; 54 -- Array type used to access by bytes 55 56 function To_Big_Words is new 57 Ada.Unchecked_Conversion (System.Address, Big_Words_Ptr); 58 59 function To_Big_Bytes is new 60 Ada.Unchecked_Conversion (System.Address, Big_Bytes_Ptr); 61 62 ---------------------- 63 -- Compare_Array_U8 -- 64 ---------------------- 65 66 function Compare_Array_U8 67 (Left : System.Address; 68 Right : System.Address; 69 Left_Len : Natural; 70 Right_Len : Natural) return Integer 71 is 72 Compare_Len : constant Natural := Natural'Min (Left_Len, Right_Len); 73 74 begin 75 -- If operands are non-aligned, or length is too short, go by bytes 76 77 if (ModA (OrA (Left, Right), 4) /= 0) or else Compare_Len < 4 then 78 return Compare_Array_U8_Unaligned (Left, Right, Left_Len, Right_Len); 79 end if; 80 81 -- Here we can go by words 82 83 declare 84 LeftP : constant Big_Words_Ptr := 85 To_Big_Words (Left); 86 RightP : constant Big_Words_Ptr := 87 To_Big_Words (Right); 88 Words_To_Compare : constant Natural := Compare_Len / 4; 89 Bytes_Compared_As_Words : constant Natural := Words_To_Compare * 4; 90 91 begin 92 for J in 0 .. Words_To_Compare - 1 loop 93 if LeftP (J) /= RightP (J) then 94 return Compare_Array_U8_Unaligned 95 (AddA (Left, Address (4 * J)), 96 AddA (Right, Address (4 * J)), 97 4, 4); 98 end if; 99 end loop; 100 101 return Compare_Array_U8_Unaligned 102 (AddA (Left, Address (Bytes_Compared_As_Words)), 103 AddA (Right, Address (Bytes_Compared_As_Words)), 104 Left_Len - Bytes_Compared_As_Words, 105 Right_Len - Bytes_Compared_As_Words); 106 end; 107 end Compare_Array_U8; 108 109 -------------------------------- 110 -- Compare_Array_U8_Unaligned -- 111 -------------------------------- 112 113 function Compare_Array_U8_Unaligned 114 (Left : System.Address; 115 Right : System.Address; 116 Left_Len : Natural; 117 Right_Len : Natural) return Integer 118 is 119 Compare_Len : constant Natural := Natural'Min (Left_Len, Right_Len); 120 121 LeftP : constant Big_Bytes_Ptr := To_Big_Bytes (Left); 122 RightP : constant Big_Bytes_Ptr := To_Big_Bytes (Right); 123 124 begin 125 for J in 0 .. Compare_Len - 1 loop 126 if LeftP (J) /= RightP (J) then 127 if LeftP (J) > RightP (J) then 128 return +1; 129 else 130 return -1; 131 end if; 132 end if; 133 end loop; 134 135 if Left_Len = Right_Len then 136 return 0; 137 elsif Left_Len > Right_Len then 138 return +1; 139 else 140 return -1; 141 end if; 142 end Compare_Array_U8_Unaligned; 143 144end System.Compare_Array_Unsigned_8; 145