Subversion Repositories openrisc

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

--                                                                          --

--                         GNAT COMPILER COMPONENTS                         --

--                                                                          --

--                             P A R . C H 1 3                              --

--                                                                          --

--                                 B o d y                                  --

--                                                                          --

--          Copyright (C) 1992-2007, 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.      --

--                                                                          --

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

pragma Style_Checks (All_Checks);

--  Turn off subprogram body ordering check. Subprograms are in order

--  by RM section rather than alphabetical

separate (Par)

package body Ch13 is

   --  Local functions, used only in this chapter

   function P_Component_Clause return Node_Id;

   function P_Mod_Clause return Node_Id;

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

   -- 13.1  Representation Clause (also I.7) --

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

   --  REPRESENTATION_CLAUSE ::=

   --    ATTRIBUTE_DEFINITION_CLAUSE

   --  | ENUMERATION_REPRESENTATION_CLAUSE

   --  | RECORD_REPRESENTATION_CLAUSE

   --  | AT_CLAUSE

   --  ATTRIBUTE_DEFINITION_CLAUSE ::=

   --    for LOCAL_NAME'ATTRIBUTE_DESIGNATOR use EXPRESSION;

   --  | for LOCAL_NAME'ATTRIBUTE_DESIGNATOR use NAME;

   --  Note: in Ada 83, the expression must be a simple expression

   --  AT_CLAUSE ::= for DIRECT_NAME use at EXPRESSION;

   --  Note: in Ada 83, the expression must be a simple expression

   --  ENUMERATION_REPRESENTATION_CLAUSE ::=

   --    for first_subtype_LOCAL_NAME use ENUMERATION_AGGREGATE;

   --  ENUMERATION_AGGREGATE ::= ARRAY_AGGREGATE

   --  RECORD_REPRESENTATION_CLAUSE ::=

   --    for first_subtype_LOCAL_NAME use

   --      record [MOD_CLAUSE]

   --        {COMPONENT_CLAUSE}

   --      end record;

   --  Note: for now we allow only a direct name as the local name in the

   --  above constructs. This probably needs changing later on ???

   --  The caller has checked that the initial token is FOR

   --  Error recovery: cannot raise Error_Resync, if an error occurs,

   --  the scan is repositioned past the next semicolon.

   function P_Representation_Clause return Node_Id is

      For_Loc         : Source_Ptr;

      Name_Node       : Node_Id;

      Prefix_Node     : Node_Id;

      Attr_Name       : Name_Id;

      Identifier_Node : Node_Id;

      Rep_Clause_Node : Node_Id;

      Expr_Node       : Node_Id;

      Record_Items    : List_Id;

   begin

      For_Loc := Token_Ptr;

      Scan; -- past FOR

      --  Note that the name in a representation clause is always a simple

      --  name, even in the attribute case, see AI-300 which made this so!

      Identifier_Node := P_Identifier (C_Use);

      --  Check case of qualified name to give good error message

      if Token = Tok_Dot then

         Error_Msg_SC

            ("representation clause requires simple name!");

         loop

            exit when Token /= Tok_Dot;

            Scan; -- past dot

            Discard_Junk_Node (P_Identifier);

         end loop;

      end if;

      --  Attribute Definition Clause

      if Token = Tok_Apostrophe then

         --  Allow local names of the form a'b'.... This enables

         --  us to parse class-wide streams attributes correctly.

         Name_Node := Identifier_Node;

         while Token = Tok_Apostrophe loop

            Scan; -- past apostrophe

            Identifier_Node := Token_Node;

            Attr_Name := No_Name;

            if Token = Tok_Identifier then

               Attr_Name := Token_Name;

               if not Is_Attribute_Name (Attr_Name) then

                  Signal_Bad_Attribute;

               end if;

               if Style_Check then

                  Style.Check_Attribute_Name (False);

               end if;

            --  Here for case of attribute designator is not an identifier

            else

               if Token = Tok_Delta then

                  Attr_Name := Name_Delta;

               elsif Token = Tok_Digits then

                  Attr_Name := Name_Digits;

               elsif Token = Tok_Access then

                  Attr_Name := Name_Access;

               else

                  Error_Msg_AP ("attribute designator expected");

                  raise Error_Resync;

               end if;

               if Style_Check then

                  Style.Check_Attribute_Name (True);

               end if;

            end if;

            --  We come here with an OK attribute scanned, and the

            --  corresponding Attribute identifier node stored in Ident_Node.

            Prefix_Node := Name_Node;

            Name_Node := New_Node (N_Attribute_Reference, Prev_Token_Ptr);

            Set_Prefix (Name_Node, Prefix_Node);

            Set_Attribute_Name (Name_Node, Attr_Name);

            Scan;

         end loop;

         Rep_Clause_Node := New_Node (N_Attribute_Definition_Clause, For_Loc);

         Set_Name (Rep_Clause_Node, Prefix_Node);

         Set_Chars (Rep_Clause_Node, Attr_Name);

         T_Use;

         Expr_Node := P_Expression_No_Right_Paren;

         Check_Simple_Expression_In_Ada_83 (Expr_Node);

         Set_Expression (Rep_Clause_Node, Expr_Node);

      else

         TF_Use;

         Rep_Clause_Node := Empty;

         --  AT follows USE (At Clause)

         if Token = Tok_At then

            Scan; -- past AT

            Rep_Clause_Node := New_Node (N_At_Clause, For_Loc);

            Set_Identifier (Rep_Clause_Node, Identifier_Node);

            Expr_Node := P_Expression_No_Right_Paren;

            Check_Simple_Expression_In_Ada_83 (Expr_Node);

            Set_Expression (Rep_Clause_Node, Expr_Node);

         --  RECORD follows USE (Record Representation Clause)

         elsif Token = Tok_Record then

            Record_Items := P_Pragmas_Opt;

            Rep_Clause_Node :=

              New_Node (N_Record_Representation_Clause, For_Loc);

            Set_Identifier (Rep_Clause_Node, Identifier_Node);

            Push_Scope_Stack;

            Scope.Table (Scope.Last).Etyp := E_Record;

            Scope.Table (Scope.Last).Ecol := Start_Column;

            Scope.Table (Scope.Last).Sloc := Token_Ptr;

            Scan; -- past RECORD

            Record_Items := P_Pragmas_Opt;

            --  Possible Mod Clause

            if Token = Tok_At then

               Set_Mod_Clause (Rep_Clause_Node, P_Mod_Clause);

               Set_Pragmas_Before (Mod_Clause (Rep_Clause_Node), Record_Items);

               Record_Items := P_Pragmas_Opt;

            end if;

            if No (Record_Items) then

               Record_Items := New_List;

            end if;

            Set_Component_Clauses (Rep_Clause_Node, Record_Items);

            --  Loop through component clauses

            loop

               if Token not in Token_Class_Name then

                  exit when Check_End;

               end if;

               Append (P_Component_Clause, Record_Items);

               P_Pragmas_Opt (Record_Items);

            end loop;

         --  Left paren follows USE (Enumeration Representation Clause)

         elsif Token = Tok_Left_Paren then

            Rep_Clause_Node :=

              New_Node (N_Enumeration_Representation_Clause, For_Loc);

            Set_Identifier (Rep_Clause_Node, Identifier_Node);

            Set_Array_Aggregate (Rep_Clause_Node, P_Aggregate);

         --  Some other token follows FOR (invalid representation clause)

         else

            Error_Msg_SC ("invalid representation clause");

            raise Error_Resync;

         end if;

      end if;

      TF_Semicolon;

      return Rep_Clause_Node;

   exception

      when Error_Resync =>

         Resync_Past_Semicolon;

         return Error;

   end P_Representation_Clause;

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

   -- 13.1  Local Name --

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

   --  Local name is always parsed by its parent. In the case of its use in

   --  pragmas, the check for a local name is handled in Par.Prag and allows

   --  all the possible forms of local name. For the uses in chapter 13, we

   --  currently only allow a direct name, but this should probably change???

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

   -- 13.1  At Clause (I.7) --

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

   --  Parsed by P_Representation_Clause (13.1)

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

   -- 13.3  Attribute Definition Clause --

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

   --  Parsed by P_Representation_Clause (13.1)

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

   -- 13.4  Enumeration Representation Clause --

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

   --  Parsed by P_Representation_Clause (13.1)

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

   -- 13.4  Enumeration Aggregate --

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

   --  Parsed by P_Representation_Clause (13.1)

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

   -- 13.5.1  Record Representation Clause --

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

   --  Parsed by P_Representation_Clause (13.1)

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

   -- 13.5.1  Mod Clause (I.8) --

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

   --  MOD_CLAUSE ::= at mod static_EXPRESSION;

   --  Note: in Ada 83, the expression must be a simple expression

   --  The caller has checked that the initial Token is AT

   --  Error recovery: cannot raise Error_Resync

   --  Note: the caller is responsible for setting the Pragmas_Before field

   function P_Mod_Clause return Node_Id is

      Mod_Node  : Node_Id;

      Expr_Node : Node_Id;

   begin

      Mod_Node := New_Node (N_Mod_Clause, Token_Ptr);

      Scan; -- past AT

      T_Mod;

      Expr_Node := P_Expression_No_Right_Paren;

      Check_Simple_Expression_In_Ada_83 (Expr_Node);

      Set_Expression (Mod_Node, Expr_Node);

      TF_Semicolon;

      return Mod_Node;

   end P_Mod_Clause;

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

   -- 13.5.1  Component Clause --

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

   --  COMPONENT_CLAUSE ::=

   --    COMPONENT_CLAUSE_COMPONENT_NAME at POSITION

   --      range FIRST_BIT .. LAST_BIT;

   --  COMPONENT_CLAUSE_COMPONENT_NAME ::=

   --    component_DIRECT_NAME

   --  | component_DIRECT_NAME'ATTRIBUTE_DESIGNATOR

   --  | FIRST_SUBTYPE_DIRECT_NAME'ATTRIBUTE_DESIGNATOR

   --  POSITION ::= static_EXPRESSION

   --  Note: in Ada 83, the expression must be a simple expression

   --  FIRST_BIT ::= static_SIMPLE_EXPRESSION

   --  LAST_BIT ::= static_SIMPLE_EXPRESSION

   --  Note: the AARM V2.0 grammar has an error at this point, it uses

   --  EXPRESSION instead of SIMPLE_EXPRESSION for FIRST_BIT and LAST_BIT

   --  Error recovery: cannot raise Error_Resync

   function P_Component_Clause return Node_Id is

      Component_Node : Node_Id;

      Comp_Name      : Node_Id;

      Expr_Node      : Node_Id;

   begin

      Component_Node := New_Node (N_Component_Clause, Token_Ptr);

      Comp_Name := P_Name;

      if Nkind (Comp_Name) = N_Identifier

        or else Nkind (Comp_Name) = N_Attribute_Reference

      then

         Set_Component_Name (Component_Node, Comp_Name);

      else

         Error_Msg_N

           ("component name must be direct name or attribute", Comp_Name);

         Set_Component_Name (Component_Node, Error);

      end if;

      Set_Sloc (Component_Node, Token_Ptr);

      T_At;

      Expr_Node := P_Expression_No_Right_Paren;

      Check_Simple_Expression_In_Ada_83 (Expr_Node);

      Set_Position (Component_Node, Expr_Node);

      T_Range;

      Expr_Node := P_Expression_No_Right_Paren;

      Check_Simple_Expression_In_Ada_83 (Expr_Node);

      Set_First_Bit (Component_Node, Expr_Node);

      T_Dot_Dot;

      Expr_Node := P_Expression_No_Right_Paren;

      Check_Simple_Expression_In_Ada_83 (Expr_Node);

      Set_Last_Bit (Component_Node, Expr_Node);

      TF_Semicolon;

      return Component_Node;

   end P_Component_Clause;

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

   -- 13.5.1  Position --

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

   --  Parsed by P_Component_Clause (13.5.1)

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

   -- 13.5.1  First Bit --

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

   --  Parsed by P_Component_Clause (13.5.1)

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

   -- 13.5.1  Last Bit --

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

   --  Parsed by P_Component_Clause (13.5.1)

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

   -- 13.8  Code Statement --

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

   --  CODE_STATEMENT ::= QUALIFIED_EXPRESSION

   --  On entry the caller has scanned the SUBTYPE_MARK (passed in as the

   --  single argument, and the scan points to the apostrophe.

   --  Error recovery: can raise Error_Resync

   function P_Code_Statement (Subtype_Mark : Node_Id) return Node_Id is

      Node1 : Node_Id;

   begin

      Scan; -- past apostrophe

      --  If left paren, then we have a possible code statement

      if Token = Tok_Left_Paren then

         Node1 := New_Node (N_Code_Statement, Sloc (Subtype_Mark));

         Set_Expression (Node1, P_Qualified_Expression (Subtype_Mark));

         TF_Semicolon;

         return Node1;

      --  Otherwise we have an illegal range attribute. Note that P_Name

      --  ensures that Token = Tok_Range is the only possibility left here.

      else -- Token = Tok_Range

         Error_Msg_SC ("RANGE attribute illegal here!");

         raise Error_Resync;

      end if;

   end P_Code_Statement;

end Ch13;