Subversion Repositories openrisc_me

------------------------------------------------------------------------------

--                                                                          --

--                         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;