path: root/gcc/ada/xnmake.adb

------------------------------------------------------------------------------
--                                                                          --
--                          GNAT SYSTEM UTILITIES                           --
--                                                                          --
--                               X N M A K E                                --
--                                                                          --
--                                 B o d y                                  --
--                                                                          --
--          Copyright (C) 1992-2008, 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.      --
--                                                                          --
------------------------------------------------------------------------------

--  Program to construct the spec and body of the Nmake package

--    Input files:

--       sinfo.ads     Spec of Sinfo package
--       nmake.adt     Template for Nmake package

--    Output files:

--       nmake.ads     Spec of Nmake package
--       nmake.adb     Body of Nmake package

--  Note: this program assumes that sinfo.ads has passed the error checks that
--  are carried out by the csinfo utility, so it does not duplicate these
--  checks and assumes that sinfo.ads has the correct form.

--   In the absence of any switches, both the ads and adb files are output.
--   The switch -s or /s indicates that only the ads file is to be output.
--   The switch -b or /b indicates that only the adb file is to be output.

--   If a file name argument is given, then the output is written to this file
--   rather than to nmake.ads or nmake.adb. A file name can only be given if
--   exactly one of the -s or -b options is present.

with Ada.Command_Line;              use Ada.Command_Line;
with Ada.Strings.Unbounded;         use Ada.Strings.Unbounded;
with Ada.Strings.Unbounded.Text_IO; use Ada.Strings.Unbounded.Text_IO;
with Ada.Strings.Maps;              use Ada.Strings.Maps;
with Ada.Strings.Maps.Constants;    use Ada.Strings.Maps.Constants;
with Ada.Streams.Stream_IO;         use Ada.Streams.Stream_IO;
with Ada.Text_IO;                   use Ada.Text_IO;

with GNAT.Spitbol;                  use GNAT.Spitbol;
with GNAT.Spitbol.Patterns;         use GNAT.Spitbol.Patterns;

with XUtil;

procedure XNmake is

   Err : exception;
   --  Raised to terminate execution

   A        : VString := Nul;
   Arg      : VString := Nul;
   Arg_List : VString := Nul;
   Comment  : VString := Nul;
   Default  : VString := Nul;
   Field    : VString := Nul;
   Line     : VString := Nul;
   Node     : VString := Nul;
   Op_Name  : VString := Nul;
   Prevl    : VString := Nul;
   Synonym  : VString := Nul;
   X        : VString := Nul;

   NWidth : Natural;

   FileS : VString := V ("nmake.ads");
   FileB : VString := V ("nmake.adb");
   --  Set to null if corresponding file not to be generated

   Given_File : VString := Nul;
   --  File name given by command line argument

   subtype Sfile is Ada.Streams.Stream_IO.File_Type;

   InS,  InT  : Ada.Text_IO.File_Type;
   OutS, OutB : Sfile;

   wsp : constant Pattern := Span (' ' & ASCII.HT);

   Body_Only : constant Pattern := BreakX (' ') * X
                                   & Span (' ') & "--  body only";
   Spec_Only : constant Pattern := BreakX (' ') * X
                                   & Span (' ') & "--  spec only";

   Node_Hdr  : constant Pattern := wsp & "--  N_" & Rest * Node;
   Punc      : constant Pattern := BreakX (" .,");

   Binop     : constant Pattern := wsp
                                   & "--  plus fields for binary operator";
   Unop      : constant Pattern := wsp
                                   & "--  plus fields for unary operator";
   Syn       : constant Pattern := wsp & "--  " & Break (' ') * Synonym
                                   & " (" & Break (')') * Field
                                   & Rest * Comment;

   Templ     : constant Pattern := BreakX ('T') * A & "T e m p l a t e";
   Spec      : constant Pattern := BreakX ('S') * A & "S p e c";

   Sem_Field : constant Pattern := BreakX ('-') & "-Sem";
   Lib_Field : constant Pattern := BreakX ('-') & "-Lib";

   Get_Field : constant Pattern := BreakX (Decimal_Digit_Set) * Field;

   Get_Dflt  : constant Pattern := BreakX ('(') & "(set to "
                                   & Break (" ") * Default & " if";

   Next_Arg  : constant Pattern := Break (',') * Arg & ',';

   Op_Node   : constant Pattern := "Op_" & Rest * Op_Name;

   Shft_Rot  : constant Pattern := "Shift_" or "Rotate_";

   No_Ent    : constant Pattern := "Or_Else" or "And_Then"
                                     or "In" or "Not_In";

   M : Match_Result;

   V_String_Id : constant VString := V ("String_Id");
   V_Node_Id   : constant VString := V ("Node_Id");
   V_Name_Id   : constant VString := V ("Name_Id");
   V_List_Id   : constant VString := V ("List_Id");
   V_Elist_Id  : constant VString := V ("Elist_Id");
   V_Boolean   : constant VString := V ("Boolean");

   procedure Put_Line (F : Sfile; S : String)  renames XUtil.Put_Line;
   procedure Put_Line (F : Sfile; S : VString) renames XUtil.Put_Line;
   --  Local version of Put_Line ensures Unix style line endings

   procedure WriteS  (S : String);
   procedure WriteB  (S : String);
   procedure WriteBS (S : String);
   procedure WriteS  (S : VString);
   procedure WriteB  (S : VString);
   procedure WriteBS (S : VString);
   --  Write given line to spec or body file or both if active

   procedure WriteB (S : String) is
   begin
      if FileB /= Nul then
         Put_Line (OutB, S);
      end if;
   end WriteB;

   procedure WriteB (S : VString) is
   begin
      if FileB /= Nul then
         Put_Line (OutB, S);
      end if;
   end WriteB;

   procedure WriteBS (S : String) is
   begin
      if FileB /= Nul then
         Put_Line (OutB, S);
      end if;

      if FileS /= Nul then
         Put_Line (OutS, S);
      end if;
   end WriteBS;

   procedure WriteBS (S : VString) is
   begin
      if FileB /= Nul then
         Put_Line (OutB, S);
      end if;

      if FileS /= Nul then
         Put_Line (OutS, S);
      end if;
   end WriteBS;

   procedure WriteS (S : String) is
   begin
      if FileS /= Nul then
         Put_Line (OutS, S);
      end if;
   end WriteS;

   procedure WriteS (S : VString) is
   begin
      if FileS /= Nul then
         Put_Line (OutS, S);
      end if;
   end WriteS;

--  Start of processing for XNmake

begin
   NWidth := 28;
   Anchored_Mode := True;

   for ArgN in 1 .. Argument_Count loop
      declare
         Arg : constant String := Argument (ArgN);

      begin
         if Arg (1) = '-' then
            if Arg'Length = 2
              and then (Arg (2) = 'b' or else Arg (2) = 'B')
            then
               FileS := Nul;

            elsif Arg'Length = 2
              and then (Arg (2) = 's' or else Arg (2) = 'S')
            then
               FileB := Nul;

            else
               raise Err;
            end if;

         else
            if Given_File /= Nul then
               raise Err;
            else
               Given_File := V (Arg);
            end if;
         end if;
      end;
   end loop;

   if FileS = Nul and then FileB = Nul then
      raise Err;

   elsif Given_File /= Nul then
      if FileB = Nul then
         FileS := Given_File;

      elsif FileS = Nul then
         FileB := Given_File;

      else
         raise Err;
      end if;
   end if;

   Open (InS, In_File, "sinfo.ads");
   Open (InT, In_File, "nmake.adt");

   if FileS /= Nul then
      Create (OutS, Out_File, S (FileS));
   end if;

   if FileB /= Nul then
      Create (OutB, Out_File, S (FileB));
   end if;

   Anchored_Mode := True;

   --  Copy initial part of template to spec and body

   loop
      Line := Get_Line (InT);

      --  Skip lines describing the template

      if Match (Line, "--  This file is a template") then
         loop
            Line := Get_Line (InT);
            exit when Line = "";
         end loop;
      end if;

      --  Loop keeps going until "package" keyword written

      exit when Match (Line, "package");

      --  Deal with WITH lines, writing to body or spec as appropriate

      if Match (Line, Body_Only, M) then
         Replace (M, X);
         WriteB (Line);

      elsif Match (Line, Spec_Only, M) then
         Replace (M, X);
         WriteS (Line);

      --  Change header from Template to Spec and write to spec file

      else
         if Match (Line, Templ, M) then
            Replace (M, A &  "    S p e c    ");
         end if;

         WriteS (Line);

         --  Write header line to body file

         if Match (Line, Spec, M) then
            Replace (M, A &  "B o d y");
         end if;

         WriteB (Line);
      end if;
   end loop;

   --  Package line reached

   WriteS ("package Nmake is");
   WriteB ("package body Nmake is");
   WriteB ("");

   --  Copy rest of lines up to template insert point to spec only

   loop
      Line := Get_Line (InT);
      exit when Match (Line, "!!TEMPLATE INSERTION POINT");
      WriteS (Line);
   end loop;

   --  Here we are doing the actual insertions, loop through node types

   loop
      Line := Get_Line (InS);

      if Match (Line, Node_Hdr)
        and then not Match (Node, Punc)
        and then Node /= "Unused"
      then
         exit when Node = "Empty";
         Prevl := "   function Make_" & Node & " (Sloc : Source_Ptr";
         Arg_List := Nul;

         --  Loop through fields of one node

         loop
            Line := Get_Line (InS);
            exit when Line = "";

            if Match (Line, Binop) then
               WriteBS (Prevl & ';');
               Append (Arg_List, "Left_Opnd,Right_Opnd,");
               WriteBS (
                 "      " & Rpad ("Left_Opnd",  NWidth) & " : Node_Id;");
               Prevl :=
                 "      " & Rpad ("Right_Opnd", NWidth) & " : Node_Id";

            elsif Match (Line, Unop) then
               WriteBS (Prevl & ';');
               Append (Arg_List, "Right_Opnd,");
               Prevl := "      " & Rpad ("Right_Opnd", NWidth) & " : Node_Id";

            elsif Match (Line, Syn) then
               if         Synonym /= "Prev_Ids"
                 and then Synonym /= "More_Ids"
                 and then Synonym /= "Comes_From_Source"
                 and then Synonym /= "Paren_Count"
                 and then not Match (Field, Sem_Field)
                 and then not Match (Field, Lib_Field)
               then
                  Match (Field, Get_Field);

                  if    Field = "Str"   then
                     Field := V_String_Id;
                  elsif Field = "Node"  then
                     Field := V_Node_Id;
                  elsif Field = "Name"  then
                     Field := V_Name_Id;
                  elsif Field = "List"  then
                     Field := V_List_Id;
                  elsif Field = "Elist" then
                     Field := V_Elist_Id;
                  elsif Field = "Flag"  then
                     Field := V_Boolean;
                  end if;

                  if Field = "Boolean" then
                     Default := V ("False");
                  else
                     Default := Nul;
                  end if;

                  Match (Comment, Get_Dflt);

                  WriteBS (Prevl & ';');
                  Append (Arg_List, Synonym & ',');
                  Rpad (Synonym, NWidth);

                  if Default = "" then
                     Prevl := "      " & Synonym & " : " & Field;
                  else
                     Prevl :=
                       "      " & Synonym & " : " & Field & " := " & Default;
                  end if;
               end if;
            end if;
         end loop;

         WriteBS (Prevl & ')');
         WriteS ("      return Node_Id;");
         WriteS ("   pragma Inline (Make_" & Node & ");");
         WriteB ("      return Node_Id");
         WriteB ("   is");
         WriteB ("      N : constant Node_Id :=");

         if Match (Node, "Defining_Identifier") or else
            Match (Node, "Defining_Character")  or else
            Match (Node, "Defining_Operator")
         then
            WriteB ("            New_Entity (N_" & Node & ", Sloc);");
         else
            WriteB ("            New_Node (N_" & Node & ", Sloc);");
         end if;

         WriteB ("   begin");

         while Match (Arg_List, Next_Arg, "") loop
            if Length (Arg) < NWidth then
               WriteB ("      Set_" & Arg & " (N, " & Arg & ");");
            else
               WriteB ("      Set_" & Arg);
               WriteB ("        (N, " & Arg & ");");
            end if;
         end loop;

         if Match (Node, Op_Node) then
            if Node = "Op_Plus" then
               WriteB ("      Set_Chars (N, Name_Op_Add);");

            elsif Node = "Op_Minus" then
               WriteB ("      Set_Chars (N, Name_Op_Subtract);");

            elsif Match (Op_Name, Shft_Rot) then
               WriteB ("      Set_Chars (N, Name_" & Op_Name & ");");

            else
               WriteB ("      Set_Chars (N, Name_" & Node & ");");
            end if;

            if not Match (Op_Name, No_Ent) then
               WriteB ("      Set_Entity (N, Standard_" & Node & ");");
            end if;
         end if;

         WriteB ("      return N;");
         WriteB ("   end Make_" & Node & ';');
         WriteBS ("");
      end if;
   end loop;

   WriteBS ("end Nmake;");

exception

   when Err =>
      Put_Line (Standard_Error, "usage: xnmake [-b] [-s] [filename]");
      Set_Exit_Status (1);

end XNmake;