| ------------------------------------------------------------------------------ |
| -- -- |
| -- GNAT COMPILER COMPONENTS -- |
| -- -- |
| -- N A M E T . S P -- |
| -- -- |
| -- B o d y -- |
| -- -- |
| -- Copyright (C) 2008-2022, Free Software Foundation, Inc. -- |
| -- -- |
| -- GNAT is free software; you can redistribute it and/or modify it under -- |
| -- terms of the GNU General Public License as published by the Free Soft- -- |
| -- ware Foundation; either version 3, or (at your option) any later ver- -- |
| -- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- |
| -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- |
| -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- |
| -- for more details. You should have received a copy of the GNU General -- |
| -- Public License distributed with GNAT; see file COPYING3. If not, go to -- |
| -- http://www.gnu.org/licenses for a complete copy of the license. -- |
| -- -- |
| -- GNAT was originally developed by the GNAT team at New York University. -- |
| -- Extensive contributions were provided by Ada Core Technologies Inc. -- |
| -- -- |
| ------------------------------------------------------------------------------ |
| |
| with Aspects; |
| with Snames; |
| with System.WCh_Cnv; use System.WCh_Cnv; |
| |
| with GNAT.UTF_32_Spelling_Checker; |
| |
| package body Namet.Sp is |
| |
| ----------------------- |
| -- Local Subprograms -- |
| ----------------------- |
| |
| procedure Get_Name_String_UTF_32 |
| (Id : Name_Id; |
| Result : out UTF_32_String; |
| Length : out Natural); |
| -- This procedure is similar to Get_Decoded_Name except that the output |
| -- is stored in the given Result array as single codes, so in particular |
| -- any Uhh, Whhhh, or WWhhhhhhhh sequences are decoded to appear as a |
| -- single value in the output. This call does not affect the contents of |
| -- either Name_Buffer or Name_Len. The result is in Result (1 .. Length). |
| -- The caller must ensure that the result buffer is long enough. |
| |
| ------------------------ |
| -- Aspect_Spell_Check -- |
| ------------------------ |
| |
| function Aspect_Spell_Check (Name : Name_Id) return Boolean is |
| (Aspect_Spell_Check (Name) /= No_Name); |
| |
| function Aspect_Spell_Check (Name : Name_Id) return Name_Id is |
| use Aspects; |
| begin |
| for J in Aspect_Id_Exclude_No_Aspect loop |
| if Is_Bad_Spelling_Of (Name, Aspect_Names (J)) then |
| return Aspect_Names (J); |
| end if; |
| end loop; |
| |
| return No_Name; |
| end Aspect_Spell_Check; |
| |
| --------------------------- |
| -- Attribute_Spell_Check -- |
| --------------------------- |
| |
| function Attribute_Spell_Check (N : Name_Id) return Boolean is |
| (Attribute_Spell_Check (N) /= No_Name); |
| |
| function Attribute_Spell_Check (N : Name_Id) return Name_Id is |
| use Snames; |
| begin |
| for J in First_Attribute_Name .. Last_Attribute_Name loop |
| if Is_Bad_Spelling_Of (N, J) then |
| return J; |
| end if; |
| end loop; |
| |
| return No_Name; |
| end Attribute_Spell_Check; |
| |
| ---------------------------- |
| -- Get_Name_String_UTF_32 -- |
| ---------------------------- |
| |
| procedure Get_Name_String_UTF_32 |
| (Id : Name_Id; |
| Result : out UTF_32_String; |
| Length : out Natural) |
| is |
| pragma Assert (Result'First = 1); |
| |
| SPtr : Int := Name_Entries.Table (Id).Name_Chars_Index + 1; |
| -- Index through characters of name in Name_Chars table. Initial value |
| -- points to first character of the name. |
| |
| SLen : constant Nat := Nat (Name_Entries.Table (Id).Name_Len); |
| -- Length of the name |
| |
| SLast : constant Int := SPtr + SLen - 1; |
| -- Last index in Name_Chars table for name |
| |
| C : Character; |
| -- Current character from Name_Chars table |
| |
| procedure Store_Hex (N : Natural); |
| -- Read and store next N characters starting at SPtr and store result |
| -- in next character of Result. Update SPtr past characters read. |
| |
| --------------- |
| -- Store_Hex -- |
| --------------- |
| |
| procedure Store_Hex (N : Natural) is |
| T : UTF_32_Code; |
| C : Character; |
| |
| begin |
| T := 0; |
| for J in 1 .. N loop |
| C := Name_Chars.Table (SPtr); |
| SPtr := SPtr + 1; |
| |
| if C in '0' .. '9' then |
| T := 16 * T + Character'Pos (C) - Character'Pos ('0'); |
| else |
| pragma Assert (C in 'a' .. 'f'); |
| |
| T := 16 * T + Character'Pos (C) - (Character'Pos ('a') - 10); |
| end if; |
| end loop; |
| |
| Length := Length + 1; |
| pragma Assert (Length <= Result'Length); |
| Result (Length) := T; |
| end Store_Hex; |
| |
| -- Start of processing for Get_Name_String_UTF_32 |
| |
| begin |
| Length := 0; |
| while SPtr <= SLast loop |
| C := Name_Chars.Table (SPtr); |
| |
| -- Uhh encoding |
| |
| if C = 'U' |
| and then SPtr <= SLast - 2 |
| and then Name_Chars.Table (SPtr + 1) not in 'A' .. 'Z' |
| then |
| SPtr := SPtr + 1; |
| Store_Hex (2); |
| |
| -- Whhhh encoding |
| |
| elsif C = 'W' |
| and then SPtr <= SLast - 4 |
| and then Name_Chars.Table (SPtr + 1) not in 'A' .. 'Z' |
| then |
| SPtr := SPtr + 1; |
| Store_Hex (4); |
| |
| -- WWhhhhhhhh encoding |
| |
| elsif C = 'W' |
| and then SPtr <= SLast - 8 |
| and then Name_Chars.Table (SPtr + 1) = 'W' |
| then |
| SPtr := SPtr + 2; |
| Store_Hex (8); |
| |
| -- Q encoding (character literal) |
| |
| elsif C = 'Q' and then SPtr < SLast then |
| |
| -- Put apostrophes around character |
| |
| pragma Assert (Length <= Result'Last - 3); |
| Result (Length + 1) := UTF_32_Code'Val (Character'Pos (''')); |
| Result (Length + 2) := |
| UTF_32_Code (Get_Char_Code (Name_Chars.Table (SPtr + 1))); |
| Result (Length + 3) := UTF_32_Code'Val (Character'Pos (''')); |
| SPtr := SPtr + 2; |
| Length := Length + 3; |
| |
| -- Unencoded case |
| |
| else |
| SPtr := SPtr + 1; |
| Length := Length + 1; |
| pragma Assert (Length <= Result'Last); |
| Result (Length) := UTF_32_Code (Get_Char_Code (C)); |
| end if; |
| end loop; |
| end Get_Name_String_UTF_32; |
| |
| ------------------------ |
| -- Is_Bad_Spelling_Of -- |
| ------------------------ |
| |
| function Is_Bad_Spelling_Of (Found, Expect : Name_Id) return Boolean is |
| FL : constant Natural := Natural (Length_Of_Name (Found)); |
| EL : constant Natural := Natural (Length_Of_Name (Expect)); |
| -- Length of input names |
| |
| FB : UTF_32_String (1 .. 2 * FL); |
| EB : UTF_32_String (1 .. 2 * EL); |
| -- Buffers for results, a factor of 2 is more than enough, the only |
| -- sequence which expands is Q (character literal) by 1.5 times. |
| |
| FBL : Natural; |
| EBL : Natural; |
| -- Length of decoded names |
| |
| begin |
| Get_Name_String_UTF_32 (Found, FB, FBL); |
| Get_Name_String_UTF_32 (Expect, EB, EBL); |
| |
| -- For an exact match, return False, otherwise check bad spelling. We |
| -- need this special test because the library routine returns True for |
| -- an exact match. |
| |
| if FB (1 .. FBL) = EB (1 .. EBL) then |
| return False; |
| else |
| return |
| GNAT.UTF_32_Spelling_Checker.Is_Bad_Spelling_Of |
| (FB (1 .. FBL), EB (1 .. EBL)); |
| end if; |
| end Is_Bad_Spelling_Of; |
| |
| end Namet.Sp; |
