Subversion Repositories openrisc

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

--                                                                          --

--                         GNAT COMPILER COMPONENTS                         --

--                                                                          --

--                    S Y M B O L S . P R O C E S S I N G                   --

--                                                                          --

--                                 B o d y                                  --

--                                                                          --

--          Copyright (C) 2003-2010, 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.      --

--                                                                          --

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

--  This is the VMS Alpha version of this package

separate (Symbols)

package body Processing is

   type Number is mod 2**16;

   --  16 bits unsigned number for number of characters

   EMH : constant Number := 8;

   --  Code for the Module Header section

   GSD : constant Number := 10;

   --  Code for the Global Symbol Definition section

   C_SYM : constant Number := 1;

   --  Code for a Symbol subsection

   V_DEF_Mask  : constant Number := 2 ** 1;

   V_NORM_Mask : constant Number := 2 ** 6;

   --  Comments ???

   B : Byte;

   Number_Of_Characters : Natural := 0;

   --  The number of characters of each section

   Native_Format : Boolean;

   --  True if records are decoded by the system (like on VMS)

   Has_Pad : Boolean;

   --  If true, a pad byte must be skipped before reading the next record

   --  The following variables are used by procedure Process when reading an

   --  object file.

   Code   : Number := 0;

   Length : Natural := 0;

   Dummy : Number;

   Nchars : Natural := 0;

   Flags  : Number  := 0;

   Symbol : String (1 .. 255);

   LSymb  : Natural;

   procedure Get (N : out Number);

   --  Read two bytes from the object file LSB first as unsigned 16 bit number

   procedure Get (N : out Natural);

   --  Read two bytes from the object file, LSByte first, as a Natural

   ---------

   -- Get --

   ---------

   procedure Get (N : out Number) is

      C : Byte;

      LSByte : Number;

   begin

      Read (File, C);

      LSByte := Byte'Pos (C);

      Read (File, C);

      N := LSByte + (256 * Byte'Pos (C));

   end Get;

   procedure Get (N : out Natural) is

      Result : Number;

   begin

      Get (Result);

      N := Natural (Result);

   end Get;

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

   -- Process --

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

   procedure Process

     (Object_File : String;

      Success     : out Boolean)

   is

      OK : Boolean := True;

   begin

      --  Open the object file with Byte_IO. Return with Success = False if

      --  this fails.

      begin

         Open (File, In_File, Object_File);

      exception

         when others =>

            Put_Line

              ("*** Unable to open object file """ & Object_File & """");

            Success := False;

            return;

      end;

      --  Assume that the object file has a correct format

      Success := True;

      --  Check the file format in case of cross-tool

      Get (Code);

      Get (Number_Of_Characters);

      Get (Dummy);

      if Code = Dummy and then Number_Of_Characters = Natural (EMH) then

         --  Looks like a cross tool

         Native_Format := False;

         Number_Of_Characters := Natural (Dummy) - 4;

         Has_Pad := (Number_Of_Characters mod 2) = 1;

      elsif Code = EMH then

         Native_Format := True;

         Number_Of_Characters := Number_Of_Characters - 6;

         Has_Pad := False;

      else

         Put_Line ("file """ & Object_File & """ is not an object file");

         Close (File);

         Success := False;

         return;

      end if;

      --  Skip the EMH section

      for J in 1 .. Number_Of_Characters loop

         Read (File, B);

      end loop;

      --  Get the different sections one by one from the object file

      while not End_Of_File (File) loop

         if not Native_Format then

            --  Skip pad byte if present

            if Has_Pad then

               Get (B);

            end if;

            --  Skip record length

            Get (Dummy);

         end if;

         Get (Code);

         Get (Number_Of_Characters);

         if not Native_Format then

            if Natural (Dummy) /= Number_Of_Characters then

               --  Format error

               raise Constraint_Error;

            end if;

            Has_Pad := (Number_Of_Characters mod 2) = 1;

         end if;

         --  The header is 4 bytes length

         Number_Of_Characters := Number_Of_Characters - 4;

         --  If this is not a Global Symbol Definition section, skip to the

         --  next section.

         if Code /= GSD then

            for J in 1 .. Number_Of_Characters loop

               Read (File, B);

            end loop;

         else

            --  Skip over the next 4 bytes

            Get (Dummy);

            Get (Dummy);

            Number_Of_Characters := Number_Of_Characters - 4;

            --  Get each subsection in turn

            loop

               Get (Code);

               Get (Nchars);

               Get (Dummy);

               Get (Flags);

               Number_Of_Characters := Number_Of_Characters - 8;

               Nchars := Nchars - 8;

               --  If this is a symbol and the V_DEF flag is set, get symbol

               if Code = C_SYM and then ((Flags and V_DEF_Mask) /= 0) then

                  --  First, reach the symbol length

                  for J in 1 .. 25 loop

                     Read (File, B);

                     Nchars := Nchars - 1;

                     Number_Of_Characters := Number_Of_Characters - 1;

                  end loop;

                  Length := Byte'Pos (B);

                  LSymb := 0;

                  --  Get the symbol characters

                  for J in 1 .. Nchars loop

                     Read (File, B);

                     Number_Of_Characters := Number_Of_Characters - 1;

                     if Length > 0 then

                        LSymb := LSymb + 1;

                        Symbol (LSymb) := B;

                        Length := Length - 1;

                     end if;

                  end loop;

                  --  Check if it is a symbol from a generic body

                  OK := True;

                  for J in 1 .. LSymb - 2 loop

                     if Symbol (J) = 'G' and then Symbol (J + 1) = 'P'

                       and then Symbol (J + 2) in '0' .. '9'

                     then

                        OK := False;

                        exit;

                     end if;

                  end loop;

                  if OK then

                     --  Create the new Symbol

                     declare

                        S_Data : Symbol_Data;

                     begin

                        S_Data.Name := new String'(Symbol (1 .. LSymb));

                        --  The symbol kind (Data or Procedure) depends on the

                        --  V_NORM flag.

                        if (Flags and V_NORM_Mask) = 0 then

                           S_Data.Kind := Data;

                        else

                           S_Data.Kind := Proc;

                        end if;

                        --  Put the new symbol in the table

                        Symbol_Table.Append (Complete_Symbols, S_Data);

                     end;

                  end if;

               else

                  --  As it is not a symbol subsection, skip to the next

                  --  subsection.

                  for J in 1 .. Nchars loop

                     Read (File, B);

                     Number_Of_Characters := Number_Of_Characters - 1;

                  end loop;

               end if;

               --  Exit the GSD section when number of characters reaches zero

               exit when Number_Of_Characters = 0;

            end loop;

         end if;

      end loop;

      --  The object file has been processed, close it

      Close (File);

   exception

      --  For any exception, output an error message, close the object file

      --  and return with Success = False.

      when X : others =>

         Put_Line ("unexpected exception raised while processing """

                   & Object_File & """");

         Put_Line (Exception_Information (X));

         Close (File);

         Success := False;

   end Process;

end Processing;