Subversion Repositories openrisc

------------------------------------------------------------------------------
--                                                                          --
--                         GNAT RUN-TIME COMPONENTS                         --
--                                                                          --
--                  ADA.WIDE_WIDE_TEXT_IO.ENUMERATION_AUX                   --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--          Copyright (C) 1992-2009, 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.                                     --
--                                                                          --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception,   --
-- version 3.1, as published by the Free Software Foundation.               --
--                                                                          --
-- You should have received a copy of the GNU General Public License and    --
-- a copy of the GCC Runtime Library Exception along with this program;     --
-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
-- <http://www.gnu.org/licenses/>.                                          --
--                                                                          --
-- GNAT was originally developed  by the GNAT team at  New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
--                                                                          --
------------------------------------------------------------------------------
 
with Ada.Wide_Wide_Text_IO.Generic_Aux; use Ada.Wide_Wide_Text_IO.Generic_Aux;
with Ada.Characters.Conversions;        use Ada.Characters.Conversions;
with Ada.Characters.Handling;           use Ada.Characters.Handling;
with Interfaces.C_Streams;              use Interfaces.C_Streams;
with System.WCh_Con;                    use System.WCh_Con;
 
package body Ada.Wide_Wide_Text_IO.Enumeration_Aux is
 
   subtype TFT is Ada.Wide_Wide_Text_IO.File_Type;
   --  File type required for calls to routines in Aux
 
   -----------------------
   -- Local Subprograms --
   -----------------------
 
   procedure Store_Char
     (WC  : Wide_Wide_Character;
      Buf : out Wide_Wide_String;
      Ptr : in out Integer);
   --  Store a single character in buffer, checking for overflow
 
   --  These definitions replace the ones in Ada.Characters.Handling, which
   --  do not seem to work for some strange not understood reason ??? at
   --  least in the OS/2 version.
 
   function To_Lower (C : Character) return Character;
 
   ------------------
   -- Get_Enum_Lit --
   ------------------
 
   procedure Get_Enum_Lit
     (File   : File_Type;
      Buf    : out Wide_Wide_String;
      Buflen : out Natural)
   is
      ch  : int;
      WC  : Wide_Wide_Character;
 
   begin
      Buflen := 0;
      Load_Skip (TFT (File));
      ch := Nextc (TFT (File));
 
      --  Character literal case. If the initial character is a quote, then
      --  we read as far as we can without backup (see ACVC test CE3905L)
 
      if ch = Character'Pos (''') then
         Get (File, WC);
         Store_Char (WC, Buf, Buflen);
 
         ch := Nextc (TFT (File));
 
         if ch = LM or else ch = EOF then
            return;
         end if;
 
         Get (File, WC);
         Store_Char (WC, Buf, Buflen);
 
         ch := Nextc (TFT (File));
 
         if ch /= Character'Pos (''') then
            return;
         end if;
 
         Get (File, WC);
         Store_Char (WC, Buf, Buflen);
 
      --  Similarly for identifiers, read as far as we can, in particular,
      --  do read a trailing underscore (again see ACVC test CE3905L to
      --  understand why we do this, although it seems somewhat peculiar).
 
      else
         --  Identifier must start with a letter. Any wide character value
         --  outside the normal Latin-1 range counts as a letter for this.
 
         if ch < 255 and then not Is_Letter (Character'Val (ch)) then
            return;
         end if;
 
         --  If we do have a letter, loop through the characters quitting on
         --  the first non-identifier character (note that this includes the
         --  cases of hitting a line mark or page mark).
 
         loop
            Get (File, WC);
            Store_Char (WC, Buf, Buflen);
 
            ch := Nextc (TFT (File));
 
            exit when ch = EOF;
 
            if ch = Character'Pos ('_') then
               exit when Buf (Buflen) = '_';
 
            elsif ch = Character'Pos (ASCII.ESC) then
               null;
 
            elsif File.WC_Method in WC_Upper_Half_Encoding_Method
              and then ch > 127
            then
               null;
 
            else
               exit when not Is_Letter (Character'Val (ch))
                           and then
                         not Is_Digit (Character'Val (ch));
            end if;
         end loop;
      end if;
   end Get_Enum_Lit;
 
   ---------
   -- Put --
   ---------
 
   procedure Put
     (File  : File_Type;
      Item  : Wide_Wide_String;
      Width : Field;
      Set   : Type_Set)
   is
      Actual_Width : constant Integer :=
                       Integer'Max (Integer (Width), Item'Length);
 
   begin
      Check_On_One_Line (TFT (File), Actual_Width);
 
      if Set = Lower_Case and then Item (Item'First) /= ''' then
         declare
            Iteml : Wide_Wide_String (Item'First .. Item'Last);
 
         begin
            for J in Item'Range loop
               if Is_Character (Item (J)) then
                  Iteml (J) :=
                    To_Wide_Wide_Character
                      (To_Lower (To_Character (Item (J))));
               else
                  Iteml (J) := Item (J);
               end if;
            end loop;
 
            Put (File, Iteml);
         end;
 
      else
         Put (File, Item);
      end if;
 
      for J in 1 .. Actual_Width - Item'Length loop
         Put (File, ' ');
      end loop;
   end Put;
 
   ----------
   -- Puts --
   ----------
 
   procedure Puts
     (To   : out Wide_Wide_String;
      Item : Wide_Wide_String;
      Set  : Type_Set)
   is
      Ptr : Natural;
 
   begin
      if Item'Length > To'Length then
         raise Layout_Error;
 
      else
         Ptr := To'First;
         for J in Item'Range loop
            if Set = Lower_Case
              and then Item (Item'First) /= '''
              and then Is_Character (Item (J))
            then
               To (Ptr) :=
                 To_Wide_Wide_Character (To_Lower (To_Character (Item (J))));
            else
               To (Ptr) := Item (J);
            end if;
 
            Ptr := Ptr + 1;
         end loop;
 
         while Ptr <= To'Last loop
            To (Ptr) := ' ';
            Ptr := Ptr + 1;
         end loop;
      end if;
   end Puts;
 
   -------------------
   -- Scan_Enum_Lit --
   -------------------
 
   procedure Scan_Enum_Lit
     (From  : Wide_Wide_String;
      Start : out Natural;
      Stop  : out Natural)
   is
      WC  : Wide_Wide_Character;
 
   --  Processing for Scan_Enum_Lit
 
   begin
      Start := From'First;
 
      loop
         if Start > From'Last then
            raise End_Error;
 
         elsif Is_Character (From (Start))
           and then not Is_Blank (To_Character (From (Start)))
         then
            exit;
 
         else
            Start := Start + 1;
         end if;
      end loop;
 
      --  Character literal case. If the initial character is a quote, then
      --  we read as far as we can without backup (see ACVC test CE3905L
      --  which is for the analogous case for reading from a file).
 
      if From (Start) = ''' then
         Stop := Start;
 
         if Stop = From'Last then
            raise Data_Error;
         else
            Stop := Stop + 1;
         end if;
 
         if From (Stop) in ' ' .. '~'
           or else From (Stop) >= Wide_Wide_Character'Val (16#80#)
         then
            if Stop = From'Last then
               raise Data_Error;
            else
               Stop := Stop + 1;
 
               if From (Stop) = ''' then
                  return;
               end if;
            end if;
         end if;
 
         raise Data_Error;
 
      --  Similarly for identifiers, read as far as we can, in particular,
      --  do read a trailing underscore (again see ACVC test CE3905L to
      --  understand why we do this, although it seems somewhat peculiar).
 
      else
         --  Identifier must start with a letter, any wide character outside
         --  the normal Latin-1 range is considered a letter for this test.
 
         if Is_Character (From (Start))
           and then not Is_Letter (To_Character (From (Start)))
         then
            raise Data_Error;
         end if;
 
         --  If we do have a letter, loop through the characters quitting on
         --  the first non-identifier character (note that this includes the
         --  cases of hitting a line mark or page mark).
 
         Stop := Start + 1;
         while Stop < From'Last loop
            WC := From (Stop + 1);
 
            exit when
              Is_Character (WC)
                and then
                  not Is_Letter (To_Character (WC))
                and then
                  not Is_Letter (To_Character (WC))
                and then
                  (WC /= '_' or else From (Stop - 1) = '_');
 
            Stop := Stop + 1;
         end loop;
      end if;
 
   end Scan_Enum_Lit;
 
   ----------------
   -- Store_Char --
   ----------------
 
   procedure Store_Char
     (WC  : Wide_Wide_Character;
      Buf : out Wide_Wide_String;
      Ptr : in out Integer)
   is
   begin
      if Ptr = Buf'Last then
         raise Data_Error;
      else
         Ptr := Ptr + 1;
         Buf (Ptr) := WC;
      end if;
   end Store_Char;
 
   --------------
   -- To_Lower --
   --------------
 
   function To_Lower (C : Character) return Character is
   begin
      if C in 'A' .. 'Z' then
         return Character'Val (Character'Pos (C) + 32);
      else
         return C;
      end if;
   end To_Lower;
 
end Ada.Wide_Wide_Text_IO.Enumeration_Aux;