Subversion Repositories scarts

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

--                                                                          --

--                         GNAT COMPILER COMPONENTS                         --

--                                                                          --

--                            S T Y L E G . C                               --

--                                                                          --

--                                 B o d y                                  --

--                                                                          --

--          Copyright (C) 1992-2005 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 2,  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 COPYING.  If not, write --

-- to  the  Free Software Foundation,  51  Franklin  Street,  Fifth  Floor, --

-- Boston, MA 02110-1301, USA.                                              --

--                                                                          --

-- GNAT was originally developed  by the GNAT team at  New York University. --

-- Extensive contributions were provided by Ada Core Technologies Inc.      --

--                                                                          --

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

with Atree;    use Atree;

with Casing;   use Casing;

with Csets;    use Csets;

with Einfo;    use Einfo;

with Err_Vars; use Err_Vars;

with Namet;    use Namet;

with Sinfo;    use Sinfo;

with Sinput;   use Sinput;

with Stand;    use Stand;

with Stylesw;  use Stylesw;

package body Styleg.C is

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

   -- Body_With_No_Spec --

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

   --  If the check specs mode (-gnatys) is set, then all subprograms must

   --  have specs unless they are parameterless procedures that are not child

   --  units at the library level (i.e. they are possible main programs).

   procedure Body_With_No_Spec (N : Node_Id) is

   begin

      if Style_Check_Specs then

         if Nkind (Parent (N)) = N_Compilation_Unit then

            declare

               Spec  : constant Node_Id := Specification (N);

               Defnm : constant Node_Id := Defining_Unit_Name (Spec);

            begin

               if Nkind (Spec) = N_Procedure_Specification

                 and then Nkind (Defnm) = N_Defining_Identifier

                 and then No (First_Formal (Defnm))

               then

                  return;

               end if;

            end;

         end if;

         Error_Msg_N ("(style) subprogram body has no previous spec", N);

      end if;

   end Body_With_No_Spec;

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

   -- Check_Identifier --

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

   --  In check references mode (-gnatyr), identifier uses must be cased

   --  the same way as the corresponding identifier declaration.

   procedure Check_Identifier

     (Ref : Node_Or_Entity_Id;

      Def : Node_Or_Entity_Id)

   is

      Sref : Source_Ptr := Sloc (Ref);

      Sdef : Source_Ptr := Sloc (Def);

      Tref : Source_Buffer_Ptr;

      Tdef : Source_Buffer_Ptr;

      Nlen : Nat;

      Cas  : Casing_Type;

   begin

      --  If reference does not come from source, nothing to check

      if not Comes_From_Source (Ref) then

         return;

      --  If previous error on either node/entity, ignore

      elsif Error_Posted (Ref) or else Error_Posted (Def) then

         return;

      --  Case of definition comes from source

      elsif Comes_From_Source (Def) then

         --  Check same casing if we are checking references

         if Style_Check_References then

            Tref := Source_Text (Get_Source_File_Index (Sref));

            Tdef := Source_Text (Get_Source_File_Index (Sdef));

            --  Ignore operator name case completely. This also catches the

            --  case of where one is an operator and the other is not. This

            --  is a phenomenon from rewriting of operators as functions,

            --  and is to be ignored.

            if Tref (Sref) = '"' or else Tdef (Sdef) = '"' then

               return;

            else

               while Tref (Sref) = Tdef (Sdef) loop

                  --  If end of identifier, all done

                  if not Identifier_Char (Tref (Sref)) then

                     return;

                  --  Otherwise loop continues

                  else

                     Sref := Sref + 1;

                     Sdef := Sdef + 1;

                  end if;

               end loop;

               --  Fall through loop when mismatch between identifiers

               --  If either identifier is not terminated, error.

               if Identifier_Char (Tref (Sref))

                    or else

                  Identifier_Char (Tdef (Sdef))

               then

                  Error_Msg_Node_1 := Def;

                  Error_Msg_Sloc := Sloc (Def);

                  Error_Msg

                    ("(style) bad casing of & declared#", Sref);

                  return;

               --  Else end of identifiers, and they match

               else

                  return;

               end if;

            end if;

         end if;

      --  Case of definition in package Standard

      elsif Sdef = Standard_Location then

         --  Check case of identifiers in Standard

         if Style_Check_Standard then

            Tref := Source_Text (Get_Source_File_Index (Sref));

            --  Ignore operators

            if Tref (Sref) = '"' then

               null;

            --  Otherwise determine required casing of Standard entity

            else

               --  ASCII entities are in all upper case

               if Entity (Ref) = Standard_ASCII then

                  Cas := All_Upper_Case;

               --  Special names in ASCII are also all upper case

               elsif Entity (Ref) in SE (S_LC_A) .. SE (S_LC_Z)

                       or else

                     Entity (Ref) in SE (S_NUL) .. SE (S_US)

                       or else

                     Entity (Ref) = SE (S_DEL)

               then

                  Cas := All_Upper_Case;

               --  All other entities are in mixed case

               else

                  Cas := Mixed_Case;

               end if;

               Nlen := Length_Of_Name (Chars (Ref));

               --  Now check if we have the right casing

               if Determine_Casing

                    (Tref (Sref .. Sref + Source_Ptr (Nlen) - 1)) = Cas

               then

                  null;

               else

                  Name_Len := Integer (Nlen);

                  Name_Buffer (1 .. Name_Len) :=

                    String (Tref (Sref .. Sref + Source_Ptr (Nlen) - 1));

                  Set_Casing (Cas);

                  Error_Msg_Name_1 := Name_Enter;

                  Error_Msg_N

                    ("(style) bad casing of { declared in Standard", Ref);

               end if;

            end if;

         end if;

      end if;

   end Check_Identifier;

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

   -- Subprogram_Not_In_Alpha_Order --

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

   procedure Subprogram_Not_In_Alpha_Order (Name : Node_Id) is

   begin

      if Style_Check_Order_Subprograms then

         Error_Msg_N

           ("(style) subprogram body& not in alphabetical order", Name);

      end if;

   end Subprogram_Not_In_Alpha_Order;

end Styleg.C;