Subversion Repositories openrisc

------------------------------------------------------------------------------
--                                                                          --
--                         GNAT COMPILER COMPONENTS                         --
--                                                                          --
--                                G P R E P                                 --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--          Copyright (C) 2002-2011, 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 Csets;
with Err_Vars; use Err_Vars;
with Errutil;
with Namet;    use Namet;
with Opt;
with Osint;    use Osint;
with Output;   use Output;
with Prep;     use Prep;
with Scng;
with Sinput.C;
with Snames;
with Stringt;  use Stringt;
with Switch;   use Switch;
with Types;    use Types;
 
with Ada.Text_IO;     use Ada.Text_IO;
 
with GNAT.Case_Util;            use GNAT.Case_Util;
with GNAT.Command_Line;
with GNAT.Directory_Operations; use GNAT.Directory_Operations;
 
with System.OS_Lib; use System.OS_Lib;
 
package body GPrep is
 
   Copyright_Displayed : Boolean := False;
   --  Used to prevent multiple displays of the copyright notice
 
   ------------------------
   -- Argument Line Data --
   ------------------------
 
   Unix_Line_Terminators : Boolean := False;
   --  Set to True with option -T
 
   type String_Array is array (Boolean) of String_Access;
   Yes_No : constant String_Array :=
     (False => new String'("YES"),
      True  => new String'("NO"));
 
   Infile_Name  : Name_Id := No_Name;
   Outfile_Name : Name_Id := No_Name;
   Deffile_Name : Name_Id := No_Name;
 
   Output_Directory : Name_Id := No_Name;
   --  Used when the specified output is an existing directory
 
   Input_Directory : Name_Id := No_Name;
   --  Used when the specified input and output are existing directories
 
   Source_Ref_Pragma : Boolean := False;
   --  Record command line options (set if -r switch set)
 
   Text_Outfile : aliased Ada.Text_IO.File_Type;
   Outfile      : constant File_Access := Text_Outfile'Access;
 
   File_Name_Buffer_Initial_Size : constant := 50;
   File_Name_Buffer : String_Access :=
                        new String (1 .. File_Name_Buffer_Initial_Size);
   --  A buffer to build output file names from input file names
 
   -----------------
   -- Subprograms --
   -----------------
 
   procedure Display_Copyright;
   --  Display the copyright notice
 
   procedure Post_Scan;
   --  Null procedure, needed by instantiation of Scng below
 
   package Scanner is new Scng
     (Post_Scan,
      Errutil.Error_Msg,
      Errutil.Error_Msg_S,
      Errutil.Error_Msg_SC,
      Errutil.Error_Msg_SP,
      Errutil.Style);
   --  The scanner for the preprocessor
 
   function Is_ASCII_Letter (C : Character) return Boolean;
   --  True if C is in 'a' .. 'z' or in 'A' .. 'Z'
 
   procedure Double_File_Name_Buffer;
   --  Double the size of the file name buffer
 
   procedure Preprocess_Infile_Name;
   --  When the specified output is a directory, preprocess the infile name
   --  for symbol substitution, to get the output file name.
 
   procedure Process_Files;
   --  Process the single input file or all the files in the directory tree
   --  rooted at the input directory.
 
   procedure Process_Command_Line_Symbol_Definition (S : String);
   --  Process a -D switch on the command line
 
   procedure Put_Char_To_Outfile (C : Character);
   --  Output one character to the output file. Used to initialize the
   --  preprocessor.
 
   procedure New_EOL_To_Outfile;
   --  Output a new line to the output file. Used to initialize the
   --  preprocessor.
 
   procedure Scan_Command_Line;
   --  Scan the switches and the file names
 
   procedure Usage;
   --  Display the usage
 
   -----------------------
   -- Display_Copyright --
   -----------------------
 
   procedure Display_Copyright is
   begin
      if not Copyright_Displayed then
         Display_Version ("GNAT Preprocessor", "1996");
         Copyright_Displayed := True;
      end if;
   end Display_Copyright;
 
   -----------------------------
   -- Double_File_Name_Buffer --
   -----------------------------
 
   procedure Double_File_Name_Buffer is
      New_Buffer : constant String_Access :=
                     new String (1 .. 2 * File_Name_Buffer'Length);
   begin
      New_Buffer (File_Name_Buffer'Range) := File_Name_Buffer.all;
      Free (File_Name_Buffer);
      File_Name_Buffer := New_Buffer;
   end Double_File_Name_Buffer;
 
   --------------
   -- Gnatprep --
   --------------
 
   procedure Gnatprep is
   begin
      --  Do some initializations (order is important here!)
 
      Csets.Initialize;
      Snames.Initialize;
      Stringt.Initialize;
      Prep.Initialize;
 
      --  Initialize the preprocessor
 
      Prep.Setup_Hooks
        (Error_Msg         => Errutil.Error_Msg'Access,
         Scan              => Scanner.Scan'Access,
         Set_Ignore_Errors => Errutil.Set_Ignore_Errors'Access,
         Put_Char          => Put_Char_To_Outfile'Access,
         New_EOL           => New_EOL_To_Outfile'Access);
 
      --  Set the scanner characteristics for the preprocessor
 
      Scanner.Set_Special_Character ('#');
      Scanner.Set_Special_Character ('$');
      Scanner.Set_End_Of_Line_As_Token (True);
 
      --  Initialize the mapping table of symbols to values
 
      Prep.Symbol_Table.Init (Prep.Mapping);
 
      --  Parse the switches and arguments
 
      Scan_Command_Line;
 
      if Opt.Verbose_Mode then
         Display_Copyright;
      end if;
 
      --  Test we had all the arguments needed
 
      if Infile_Name = No_Name then
 
         --  No input file specified, just output the usage and exit
 
         Usage;
         return;
 
      elsif Outfile_Name = No_Name then
 
         --  No output file specified, just output the usage and exit
 
         Usage;
         return;
      end if;
 
      --  If a pragma Source_File_Name, we need to keep line numbers. So, if
      --  the deleted lines are not put as comment, we must output them as
      --  blank lines.
 
      if Source_Ref_Pragma and (not Opt.Comment_Deleted_Lines) then
         Opt.Blank_Deleted_Lines := True;
      end if;
 
      --  If we have a definition file, parse it
 
      if Deffile_Name /= No_Name then
         declare
            Deffile : Source_File_Index;
 
         begin
            Errutil.Initialize;
            Deffile := Sinput.C.Load_File (Get_Name_String (Deffile_Name));
 
            --  Set Main_Source_File to the definition file for the benefit of
            --  Errutil.Finalize.
 
            Sinput.Main_Source_File := Deffile;
 
            if Deffile = No_Source_File then
               Fail ("unable to find definition file """
                     & Get_Name_String (Deffile_Name)
                     & """");
            end if;
 
            Scanner.Initialize_Scanner (Deffile);
 
            Prep.Parse_Def_File;
         end;
      end if;
 
      --  If there are errors in the definition file, output them and exit
 
      if Total_Errors_Detected > 0 then
         Errutil.Finalize (Source_Type => "definition");
         Fail ("errors in definition file """
               & Get_Name_String (Deffile_Name)
               & """");
      end if;
 
      --  If -s switch was specified, print a sorted list of symbol names and
      --  values, if any.
 
      if Opt.List_Preprocessing_Symbols then
         Prep.List_Symbols (Foreword => "");
      end if;
 
      Output_Directory := No_Name;
      Input_Directory  := No_Name;
 
      --  Check if the specified output is an existing directory
 
      if Is_Directory (Get_Name_String (Outfile_Name)) then
         Output_Directory := Outfile_Name;
 
         --  As the output is an existing directory, check if the input too
         --  is a directory.
 
         if Is_Directory (Get_Name_String (Infile_Name)) then
            Input_Directory := Infile_Name;
         end if;
      end if;
 
      --  And process the single input or the files in the directory tree
      --  rooted at the input directory.
 
      Process_Files;
   end Gnatprep;
 
   ---------------------
   -- Is_ASCII_Letter --
   ---------------------
 
   function Is_ASCII_Letter (C : Character) return Boolean is
   begin
      return C in 'A' .. 'Z' or else C in 'a' .. 'z';
   end Is_ASCII_Letter;
 
   ------------------------
   -- New_EOL_To_Outfile --
   ------------------------
 
   procedure New_EOL_To_Outfile is
   begin
      New_Line (Outfile.all);
   end New_EOL_To_Outfile;
 
   ---------------
   -- Post_Scan --
   ---------------
 
   procedure Post_Scan is
   begin
      null;
   end Post_Scan;
 
   ----------------------------
   -- Preprocess_Infile_Name --
   ----------------------------
 
   procedure Preprocess_Infile_Name is
      Len    : Natural;
      First  : Positive;
      Last   : Natural;
      Symbol : Name_Id;
      Data   : Symbol_Data;
 
   begin
      --  Initialize the buffer with the name of the input file
 
      Get_Name_String (Infile_Name);
      Len := Name_Len;
 
      while File_Name_Buffer'Length < Len loop
         Double_File_Name_Buffer;
      end loop;
 
      File_Name_Buffer (1 .. Len) := Name_Buffer (1 .. Len);
 
      --  Look for possible symbols in the file name
 
      First := 1;
      while First < Len loop
 
         --  A symbol starts with a dollar sign followed by a letter
 
         if File_Name_Buffer (First) = '$' and then
           Is_ASCII_Letter (File_Name_Buffer (First + 1))
         then
            Last := First + 1;
 
            --  Find the last letter of the symbol
 
            while Last < Len and then
               Is_ASCII_Letter (File_Name_Buffer (Last + 1))
            loop
               Last := Last + 1;
            end loop;
 
            --  Get the symbol name id
 
            Name_Len := Last - First;
            Name_Buffer (1 .. Name_Len) :=
              File_Name_Buffer (First + 1 .. Last);
            To_Lower (Name_Buffer (1 .. Name_Len));
            Symbol := Name_Find;
 
            --  And look for this symbol name in the symbol table
 
            for Index in 1 .. Symbol_Table.Last (Mapping) loop
               Data := Mapping.Table (Index);
 
               if Data.Symbol = Symbol then
 
                  --  We found the symbol. If its value is not a string,
                  --  replace the symbol in the file name with the value of
                  --  the symbol.
 
                  if not Data.Is_A_String then
                     String_To_Name_Buffer (Data.Value);
 
                     declare
                        Sym_Len : constant Positive := Last - First + 1;
                        Offset  : constant Integer := Name_Len - Sym_Len;
                        New_Len : constant Natural := Len + Offset;
 
                     begin
                        while New_Len > File_Name_Buffer'Length loop
                           Double_File_Name_Buffer;
                        end loop;
 
                        File_Name_Buffer (Last + 1 + Offset .. New_Len) :=
                          File_Name_Buffer (Last + 1 .. Len);
                        Len := New_Len;
                        Last := Last + Offset;
                        File_Name_Buffer (First .. Last) :=
                          Name_Buffer (1 .. Name_Len);
                     end;
                  end if;
 
                  exit;
               end if;
            end loop;
 
            --  Skip over the symbol name or its value: we are not checking
            --  for another symbol name in the value.
 
            First := Last + 1;
 
         else
            First := First + 1;
         end if;
      end loop;
 
      --  We now have the output file name in the buffer. Get the output
      --  path and put it in Outfile_Name.
 
      Get_Name_String (Output_Directory);
      Add_Char_To_Name_Buffer (Directory_Separator);
      Add_Str_To_Name_Buffer (File_Name_Buffer (1 .. Len));
      Outfile_Name := Name_Find;
   end Preprocess_Infile_Name;
 
   --------------------------------------------
   -- Process_Command_Line_Symbol_Definition --
   --------------------------------------------
 
   procedure Process_Command_Line_Symbol_Definition (S : String) is
      Data   : Symbol_Data;
      Symbol : Symbol_Id;
 
   begin
      --  Check the symbol definition and get the symbol and its value.
      --  Fail if symbol definition is illegal.
 
      Check_Command_Line_Symbol_Definition (S, Data);
 
      Symbol := Index_Of (Data.Symbol);
 
      --  If symbol does not already exist, create a new entry in the mapping
      --  table.
 
      if Symbol = No_Symbol then
         Symbol_Table.Increment_Last (Mapping);
         Symbol := Symbol_Table.Last (Mapping);
      end if;
 
      Mapping.Table (Symbol) := Data;
   end Process_Command_Line_Symbol_Definition;
 
   -------------------
   -- Process_Files --
   -------------------
 
   procedure Process_Files is
 
      procedure Process_One_File;
      --  Process input file Infile_Name and put the result in file
      --  Outfile_Name.
 
      procedure Recursive_Process (In_Dir : String; Out_Dir : String);
      --  Process recursively files in In_Dir. Results go to Out_Dir
 
      ----------------------
      -- Process_One_File --
      ----------------------
 
      procedure Process_One_File is
         Infile : Source_File_Index;
 
         Modified : Boolean;
         pragma Warnings (Off, Modified);
 
      begin
         --  Create the output file (fails if this does not work)
 
         begin
            Create
              (File => Text_Outfile,
               Mode => Out_File,
               Name => Get_Name_String (Outfile_Name),
               Form => "Text_Translation=" &
                       Yes_No (Unix_Line_Terminators).all);
 
         exception
            when others =>
               Fail
                 ("unable to create output file """
                  & Get_Name_String (Outfile_Name)
                  & """");
         end;
 
         --  Load the input file
 
         Infile := Sinput.C.Load_File (Get_Name_String (Infile_Name));
 
         if Infile = No_Source_File then
            Fail ("unable to find input file """
                  & Get_Name_String (Infile_Name)
                  & """");
         end if;
 
         --  Set Main_Source_File to the input file for the benefit of
         --  Errutil.Finalize.
 
         Sinput.Main_Source_File := Infile;
 
         Scanner.Initialize_Scanner (Infile);
 
         --  Output the pragma Source_Reference if asked to
 
         if Source_Ref_Pragma then
            Put_Line
              (Outfile.all,
               "pragma Source_Reference (1, """ &
                 Get_Name_String (Sinput.Full_File_Name (Infile)) & """);");
         end if;
 
         --  Preprocess the input file
 
         Prep.Preprocess (Modified);
 
         --  In verbose mode, if there is no error, report it
 
         if Opt.Verbose_Mode and then Err_Vars.Total_Errors_Detected = 0 then
            Errutil.Finalize (Source_Type => "input");
         end if;
 
         --  If we had some errors, delete the output file, and report them
 
         if Err_Vars.Total_Errors_Detected > 0 then
            if Outfile /= Standard_Output then
               Delete (Text_Outfile);
            end if;
 
            Errutil.Finalize (Source_Type => "input");
 
            OS_Exit (0);
 
         --  Otherwise, close the output file, and we are done
 
         elsif Outfile /= Standard_Output then
            Close (Text_Outfile);
         end if;
      end Process_One_File;
 
      -----------------------
      -- Recursive_Process --
      -----------------------
 
      procedure Recursive_Process (In_Dir : String; Out_Dir : String) is
         Dir_In : Dir_Type;
         Name : String (1 .. 255);
         Last : Natural;
         In_Dir_Name  : Name_Id;
         Out_Dir_Name : Name_Id;
 
         procedure Set_Directory_Names;
         --  Establish or reestablish the current input and output directories
 
         -------------------------
         -- Set_Directory_Names --
         -------------------------
 
         procedure Set_Directory_Names is
         begin
            Input_Directory := In_Dir_Name;
            Output_Directory := Out_Dir_Name;
         end Set_Directory_Names;
 
      --  Start of processing for Recursive_Process
 
      begin
         --  Open the current input directory
 
         begin
            Open (Dir_In, In_Dir);
 
         exception
            when Directory_Error =>
               Fail ("could not read directory " & In_Dir);
         end;
 
         --  Set the new input and output directory names
 
         Name_Len := In_Dir'Length;
         Name_Buffer (1 .. Name_Len) := In_Dir;
         In_Dir_Name := Name_Find;
         Name_Len := Out_Dir'Length;
         Name_Buffer (1 .. Name_Len) := Out_Dir;
         Out_Dir_Name := Name_Find;
 
         Set_Directory_Names;
 
         --  Traverse the input directory
         loop
            Read (Dir_In, Name, Last);
            exit when Last = 0;
 
            if Name (1 .. Last) /= "." and then Name (1 .. Last) /= ".." then
               declare
                  Input : constant String :=
                            In_Dir & Directory_Separator & Name (1 .. Last);
                  Output : constant String :=
                             Out_Dir & Directory_Separator & Name (1 .. Last);
 
               begin
                  --  If input is an ordinary file, process it
 
                  if Is_Regular_File (Input) then
                     --  First get the output file name
 
                     Name_Len := Last;
                     Name_Buffer (1 .. Name_Len) := Name (1 .. Last);
                     Infile_Name := Name_Find;
                     Preprocess_Infile_Name;
 
                     --  Set the input file name and process the file
 
                     Name_Len := Input'Length;
                     Name_Buffer (1 .. Name_Len) := Input;
                     Infile_Name := Name_Find;
                     Process_One_File;
 
                  elsif Is_Directory (Input) then
                     --  Input is a directory. If the corresponding output
                     --  directory does not already exist, create it.
 
                     if not Is_Directory (Output) then
                        begin
                           Make_Dir (Dir_Name => Output);
 
                        exception
                           when Directory_Error =>
                              Fail ("could not create directory """
                                    & Output
                                    & """");
                        end;
                     end if;
 
                     --  And process this new input directory
 
                     Recursive_Process (Input, Output);
 
                     --  Reestablish the input and output directory names
                     --  that have been modified by the recursive call.
 
                     Set_Directory_Names;
                  end if;
               end;
            end if;
         end loop;
      end Recursive_Process;
 
   --  Start of processing for Process_Files
 
   begin
      if Output_Directory = No_Name then
 
         --  If the output is not a directory, fail if the input is
         --  an existing directory, to avoid possible problems.
 
         if Is_Directory (Get_Name_String (Infile_Name)) then
            Fail ("input file """ & Get_Name_String (Infile_Name) &
                  """ is a directory");
         end if;
 
         --  Just process the single input file
 
         Process_One_File;
 
      elsif Input_Directory = No_Name then
 
         --  Get the output file name from the input file name, and process
         --  the single input file.
 
         Preprocess_Infile_Name;
         Process_One_File;
 
      else
         --  Recursively process files in the directory tree rooted at the
         --  input directory.
 
         Recursive_Process
           (In_Dir => Get_Name_String (Input_Directory),
            Out_Dir => Get_Name_String (Output_Directory));
      end if;
   end Process_Files;
 
   -------------------------
   -- Put_Char_To_Outfile --
   -------------------------
 
   procedure Put_Char_To_Outfile (C : Character) is
   begin
      Put (Outfile.all, C);
   end Put_Char_To_Outfile;
 
   -----------------------
   -- Scan_Command_Line --
   -----------------------
 
   procedure Scan_Command_Line is
      Switch : Character;
 
      procedure Check_Version_And_Help is new Check_Version_And_Help_G (Usage);
 
      --  Start of processing for Scan_Command_Line
 
   begin
      --  First check for --version or --help
 
      Check_Version_And_Help ("GNATPREP", "1996");
 
      --  Now scan the other switches
 
      GNAT.Command_Line.Initialize_Option_Scan;
 
      loop
         begin
            Switch := GNAT.Command_Line.Getopt ("D: b c C r s T u v");
 
            case Switch is
 
               when ASCII.NUL =>
                  exit;
 
               when 'D' =>
                  Process_Command_Line_Symbol_Definition
                    (S => GNAT.Command_Line.Parameter);
 
               when 'b' =>
                  Opt.Blank_Deleted_Lines := True;
 
               when 'c' =>
                  Opt.Comment_Deleted_Lines := True;
 
               when 'C' =>
                  Opt.Replace_In_Comments := True;
 
               when 'r' =>
                  Source_Ref_Pragma := True;
 
               when 's' =>
                  Opt.List_Preprocessing_Symbols := True;
 
               when 'T' =>
                  Unix_Line_Terminators := True;
 
               when 'u' =>
                  Opt.Undefined_Symbols_Are_False := True;
 
               when 'v' =>
                  Opt.Verbose_Mode := True;
 
               when others =>
                  Fail ("Invalid Switch: -" & Switch);
            end case;
 
         exception
            when GNAT.Command_Line.Invalid_Switch =>
               Write_Str ("Invalid Switch: -");
               Write_Line (GNAT.Command_Line.Full_Switch);
               Usage;
               OS_Exit (1);
         end;
      end loop;
 
      --  Get the file names
 
      loop
         declare
            S : constant String := GNAT.Command_Line.Get_Argument;
 
         begin
            exit when S'Length = 0;
 
            Name_Len := S'Length;
            Name_Buffer (1 .. Name_Len) := S;
 
            if Infile_Name = No_Name then
               Infile_Name := Name_Find;
            elsif Outfile_Name = No_Name then
               Outfile_Name := Name_Find;
            elsif Deffile_Name = No_Name then
               Deffile_Name := Name_Find;
            else
               Fail ("too many arguments specified");
            end if;
         end;
      end loop;
   end Scan_Command_Line;
 
   -----------
   -- Usage --
   -----------
 
   procedure Usage is
   begin
      Display_Copyright;
      Write_Line ("Usage: gnatprep [-bcrsuv] [-Dsymbol=value] " &
                    "infile outfile [deffile]");
      Write_Eol;
      Write_Line ("  infile     Name of the input file");
      Write_Line ("  outfile    Name of the output file");
      Write_Line ("  deffile    Name of the definition file");
      Write_Eol;
      Write_Line ("gnatprep switches:");
      Display_Usage_Version_And_Help;
      Write_Line ("   -b  Replace preprocessor lines by blank lines");
      Write_Line ("   -c  Keep preprocessor lines as comments");
      Write_Line ("   -C  Do symbol replacements within comments");
      Write_Line ("   -D  Associate symbol with value");
      Write_Line ("   -r  Generate Source_Reference pragma");
      Write_Line ("   -s  Print a sorted list of symbol names and values");
      Write_Line ("   -T  Use LF as line terminators");
      Write_Line ("   -u  Treat undefined symbols as FALSE");
      Write_Line ("   -v  Verbose mode");
      Write_Eol;
   end Usage;
 
end GPrep;