1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2020, Free Software Foundation, Inc. --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 3, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING3. If not, go to --
19 -- http://www.gnu.org/licenses for a complete copy of the license. --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 ------------------------------------------------------------------------------
26 pragma Style_Checks (All_Checks);
27 -- Turn off subprogram body ordering check. Subprograms are in order
28 -- by RM section rather than alphabetical
33 -- Local functions, used only in this chapter
35 function P_Component_Clause return Node_Id;
36 function P_Mod_Clause return Node_Id;
38 -----------------------------------
39 -- Aspect_Specifications_Present --
40 -----------------------------------
42 function Aspect_Specifications_Present
43 (Strict : Boolean := Ada_Version < Ada_2012) return Boolean
45 Scan_State : Saved_Scan_State;
48 function Possible_Misspelled_Aspect return Boolean;
49 -- Returns True, if Token_Name is a misspelling of some aspect name
51 function With_Present return Boolean;
52 -- Returns True if WITH is present, indicating presence of aspect
53 -- specifications. Also allows incorrect use of WHEN in place of WITH.
55 --------------------------------
56 -- Possible_Misspelled_Aspect --
57 --------------------------------
59 function Possible_Misspelled_Aspect return Boolean is
61 for J in Aspect_Id_Exclude_No_Aspect loop
62 if Is_Bad_Spelling_Of (Token_Name, Aspect_Names (J)) then
68 end Possible_Misspelled_Aspect;
74 function With_Present return Boolean is
76 if Token = Tok_With then
79 -- Check for WHEN used in place of WITH
81 elsif Token = Tok_When then
83 Scan_State : Saved_Scan_State;
86 Save_Scan_State (Scan_State);
89 if Token = Tok_Identifier
90 and then Get_Aspect_Id (Token_Name) /= No_Aspect
92 Error_Msg_SC ("WHEN should be WITH");
93 Restore_Scan_State (Scan_State);
97 Restore_Scan_State (Scan_State);
107 -- Start of processing for Aspect_Specifications_Present
110 -- Definitely must have WITH to consider aspect specs to be present
112 -- Note that this means that if we have a semicolon, we immediately
113 -- return False. There is a case in which this is not optimal, namely
116 -- type R is new Integer;
119 -- where the semicolon is redundant, but scanning forward for it would
120 -- be too expensive. Instead we pick up the aspect specifications later
121 -- as a bogus declaration, and diagnose the semicolon at that point.
123 if not With_Present then
127 -- Have a WITH or some token that we accept as a legitimate bad attempt
128 -- at writing WITH. See if it looks like an aspect specification
130 Save_Scan_State (Scan_State);
131 Scan; -- past WITH (or WHEN or other bad keyword)
133 -- If no identifier, then consider that we definitely do not have an
134 -- aspect specification.
136 if Token /= Tok_Identifier then
139 -- This is where we pay attention to the Strict mode. Normally when
140 -- we are in Ada 2012 mode, Strict is False, and we consider that we
141 -- have an aspect specification if the identifier is an aspect name
142 -- or a likely misspelling of one (even if not followed by =>) or
143 -- the identifier is not an aspect name but is followed by =>, by
144 -- a comma, or by a semicolon. The last two cases correspond to
145 -- (misspelled) Boolean aspects with a defaulted value of True.
146 -- P_Aspect_Specifications will generate messages if the aspect
147 -- specification is ill-formed.
149 elsif not Strict then
150 if Get_Aspect_Id (Token_Name) /= No_Aspect
151 or else Possible_Misspelled_Aspect
155 Scan; -- past identifier
157 Tok_Arrow | Tok_Comma | Tok_Is | Tok_Semicolon | Tok_Right_Paren;
160 -- If earlier than Ada 2012, check for valid aspect identifier (possibly
161 -- completed with 'CLASS) followed by an arrow, and consider that this
162 -- is still an aspect specification so we give an appropriate message.
165 if Get_Aspect_Id (Token_Name) = No_Aspect then
169 Scan; -- past aspect name
173 if Token = Tok_Arrow then
176 -- The identifier may be the name of a boolean aspect with a
177 -- defaulted True value. Further checks when analyzing aspect
178 -- specification, which may include further aspects.
180 elsif Token in Tok_Comma | Tok_Semicolon then
183 elsif Token = Tok_Apostrophe then
184 Scan; -- past apostrophe
186 if Token = Tok_Identifier
187 and then Token_Name = Name_Class
191 if Token = Tok_Arrow then
198 Restore_Scan_State (Scan_State);
199 Error_Msg_Ada_2012_Feature ("|aspect specification", Token_Ptr);
205 Restore_Scan_State (Scan_State);
207 end Aspect_Specifications_Present;
209 -------------------------------
210 -- Get_Aspect_Specifications --
211 -------------------------------
213 function Get_Aspect_Specifications
214 (Semicolon : Boolean := True) return List_Id
222 -- True if current aspect takes an optional argument
225 Aspects := Empty_List;
227 -- Check if aspect specification present
229 if not Aspect_Specifications_Present then
237 Scan; -- past WITH (or possible WHEN after error)
238 Aspects := Empty_List;
240 -- Loop to scan aspects
245 -- The aspect mark is not an identifier
247 if Token /= Tok_Identifier then
248 Error_Msg_SC ("aspect identifier expected");
250 -- Skip the whole aspect specification list
253 Resync_Past_Semicolon;
259 A_Id := Get_Aspect_Id (Token_Name);
261 Make_Aspect_Specification (Token_Ptr,
262 Identifier => Token_Node);
264 -- The aspect mark is not recognized
266 if A_Id = No_Aspect then
267 Error_Msg_Warn := not Debug_Flag_2;
268 Error_Msg_N ("<<& is not a valid aspect identifier", Token_Node);
271 -- Check bad spelling
273 for J in Aspect_Id_Exclude_No_Aspect loop
274 if Is_Bad_Spelling_Of (Token_Name, Aspect_Names (J)) then
275 Error_Msg_Name_1 := Aspect_Names (J);
276 Error_Msg_N -- CODEFIX
277 ("\<<possible misspelling of%", Token_Node);
282 Scan; -- past incorrect identifier
284 if Token = Tok_Apostrophe then
285 Scan; -- past apostrophe
286 Scan; -- past presumably CLASS
289 -- Attempt to parse the aspect definition by assuming it is an
292 if Token = Tok_Arrow then
294 Set_Expression (Aspect, P_Expression);
296 -- If we have a correct terminator (comma or semicolon, or a
297 -- reasonable likely missing comma), then just proceed.
299 elsif Token = Tok_Comma or else
300 Token = Tok_Semicolon or else
301 Token = Tok_Identifier
305 -- Otherwise the aspect contains a junk definition
309 Resync_Past_Semicolon;
318 Scan; -- past identifier
319 Opt := Aspect_Argument (A_Id) = Optional_Expression
321 Aspect_Argument (A_Id) = Optional_Name;
323 -- Check for 'Class present
325 if Token = Tok_Apostrophe then
326 if Class_Aspect_OK (A_Id) then
327 Scan; -- past apostrophe
329 if Token = Tok_Identifier
330 and then Token_Name = Name_Class
333 Set_Class_Present (Aspect);
335 Error_Msg_SC ("Class attribute expected here");
338 if Token = Tok_Identifier then
339 Scan; -- past identifier not CLASS
343 -- The aspect does not allow 'Class
346 Error_Msg_Node_1 := Identifier (Aspect);
347 Error_Msg_SC ("aspect& does not permit attribute here");
350 Scan; -- past apostrophe
351 Scan; -- past presumably CLASS
355 -- Check for a missing aspect definition. Aspects with optional
356 -- definitions are not considered.
358 if Token = Tok_Comma or else Token = Tok_Semicolon then
360 Error_Msg_Node_1 := Identifier (Aspect);
361 Error_Msg_AP ("aspect& requires an aspect definition");
365 -- Here we do not have a comma or a semicolon, we are done if we
366 -- do not have an arrow and the aspect does not need an argument
368 elsif Opt and then Token /= Tok_Arrow then
371 -- Here we have either an arrow, or an aspect that definitely
372 -- needs an aspect definition, and we will look for one even if
373 -- no arrow is preseant.
375 -- Otherwise we have an aspect definition
378 if Token = Tok_Arrow then
385 -- Detect a common error where the non-null definition of
386 -- aspect Depends, Global, Refined_Depends, Refined_Global
387 -- or Refined_State lacks enclosing parentheses.
389 if Token /= Tok_Left_Paren and then Token /= Tok_Null then
393 if A_Id = Aspect_Depends
395 A_Id = Aspect_Refined_Depends
397 Error_Msg_SC -- CODEFIX
399 Resync_Past_Malformed_Aspect;
401 -- Return when the current aspect is the last in the list
402 -- of specifications and the list applies to a body.
404 if Token = Tok_Is then
410 elsif A_Id = Aspect_Global
412 A_Id = Aspect_Refined_Global
415 Scan_State : Saved_Scan_State;
418 Save_Scan_State (Scan_State);
419 Scan; -- past item or mode_selector
421 -- Emit an error when the aspect has a mode_selector
422 -- as the moded_global_list must be parenthesized:
423 -- with Global => Output => Item
425 if Token = Tok_Arrow then
426 Restore_Scan_State (Scan_State);
427 Error_Msg_SC -- CODEFIX
429 Resync_Past_Malformed_Aspect;
431 -- Return when the current aspect is the last in
432 -- the list of specifications and the list applies
435 if Token = Tok_Is then
439 elsif Token = Tok_Comma then
442 -- An item followed by a comma does not need to
443 -- be parenthesized if the next token is a valid
445 -- with Global => Item,
448 if Token = Tok_Identifier
449 and then Get_Aspect_Id (Token_Name) /= No_Aspect
451 Restore_Scan_State (Scan_State);
453 -- Otherwise this is a list of items in which case
454 -- the list must be parenthesized.
457 Restore_Scan_State (Scan_State);
458 Error_Msg_SC -- CODEFIX
460 Resync_Past_Malformed_Aspect;
462 -- Return when the current aspect is the last
463 -- in the list of specifications and the list
464 -- applies to a body.
466 if Token = Tok_Is then
471 -- The definition of [Refined_]Global does not need to
475 Restore_Scan_State (Scan_State);
481 elsif A_Id = Aspect_Refined_State then
482 if Token = Tok_Identifier then
484 Scan_State : Saved_Scan_State;
487 Save_Scan_State (Scan_State);
490 -- The refinement contains a constituent, the whole
491 -- argument of Refined_State must be parenthesized.
493 -- with Refined_State => State => Constit
495 if Token = Tok_Arrow then
496 Restore_Scan_State (Scan_State);
497 Error_Msg_SC -- CODEFIX
499 Resync_Past_Malformed_Aspect;
501 -- Return when the current aspect is the last
502 -- in the list of specifications and the list
503 -- applies to a body.
505 if Token = Tok_Is then
509 -- The refinement lacks constituents. Do not flag
510 -- this case as the error would be misleading. The
511 -- diagnostic is left to the analysis.
513 -- with Refined_State => State
516 Restore_Scan_State (Scan_State);
523 -- Note if inside Depends or Refined_Depends aspect
525 if A_Id = Aspect_Depends
526 or else A_Id = Aspect_Refined_Depends
528 Inside_Depends := True;
531 -- Note that we have seen an Import aspect specification.
532 -- This matters only while parsing a subprogram.
534 if A_Id = Aspect_Import then
535 SIS_Aspect_Import_Seen := True;
536 -- Should do it only for subprograms
539 -- Parse the aspect definition depending on the expected
542 if Aspect_Argument (A_Id) = Name
543 or else Aspect_Argument (A_Id) = Optional_Name
545 Set_Expression (Aspect, P_Name);
549 (Aspect_Argument (A_Id) = Expression
551 Aspect_Argument (A_Id) = Optional_Expression);
552 Set_Expression (Aspect, P_Expression);
555 -- Unconditionally reset flag for Inside_Depends
557 Inside_Depends := False;
560 -- Add the aspect to the resulting list only when it was properly
564 Append (Aspect, Aspects);
568 -- Merge here after good or bad aspect (we should be at a comma
569 -- or a semicolon, but there might be other possible errors).
571 -- The aspect specification list contains more than one aspect
573 if Token = Tok_Comma then
577 -- Check for a missing comma between two aspects. Emit an error
578 -- and proceed to the next aspect.
580 elsif Token = Tok_Identifier
581 and then Get_Aspect_Id (Token_Name) /= No_Aspect
584 Scan_State : Saved_Scan_State;
587 Save_Scan_State (Scan_State);
588 Scan; -- past identifier
590 -- Attempt to detect ' or => following a potential aspect
593 if Token = Tok_Apostrophe or else Token = Tok_Arrow then
594 Restore_Scan_State (Scan_State);
595 Error_Msg_AP -- CODEFIX
599 -- The construct following the current aspect is not an
603 Restore_Scan_State (Scan_State);
607 -- Check for a mistyped semicolon in place of a comma between two
608 -- aspects. Emit an error and proceed to the next aspect.
610 elsif Token = Tok_Semicolon then
612 Scan_State : Saved_Scan_State;
615 Save_Scan_State (Scan_State);
616 Scan; -- past semicolon
618 if Token = Tok_Identifier
619 and then Get_Aspect_Id (Token_Name) /= No_Aspect
621 Scan; -- past identifier
623 -- Attempt to detect ' or => following potential aspect mark
625 if Token = Tok_Apostrophe or else Token = Tok_Arrow then
626 Restore_Scan_State (Scan_State);
627 Error_Msg_SC -- CODEFIX
628 ("|"";"" should be "",""");
629 Scan; -- past semicolon
634 -- Construct following the current aspect is not an aspect
636 Restore_Scan_State (Scan_State);
640 -- Require semicolon if caller expects to scan this out
653 end Get_Aspect_Specifications;
655 --------------------------------------------
656 -- 13.1 Representation Clause (also I.7) --
657 --------------------------------------------
659 -- REPRESENTATION_CLAUSE ::=
660 -- ATTRIBUTE_DEFINITION_CLAUSE
661 -- | ENUMERATION_REPRESENTATION_CLAUSE
662 -- | RECORD_REPRESENTATION_CLAUSE
665 -- ATTRIBUTE_DEFINITION_CLAUSE ::=
666 -- for LOCAL_NAME'ATTRIBUTE_DESIGNATOR use EXPRESSION;
667 -- | for LOCAL_NAME'ATTRIBUTE_DESIGNATOR use NAME;
669 -- Note: in Ada 83, the expression must be a simple expression
671 -- AT_CLAUSE ::= for DIRECT_NAME use at EXPRESSION;
673 -- Note: in Ada 83, the expression must be a simple expression
675 -- ENUMERATION_REPRESENTATION_CLAUSE ::=
676 -- for first_subtype_LOCAL_NAME use ENUMERATION_AGGREGATE;
678 -- ENUMERATION_AGGREGATE ::= ARRAY_AGGREGATE
680 -- RECORD_REPRESENTATION_CLAUSE ::=
681 -- for first_subtype_LOCAL_NAME use
682 -- record [MOD_CLAUSE]
683 -- {COMPONENT_CLAUSE}
686 -- Note: for now we allow only a direct name as the local name in the
687 -- above constructs. This probably needs changing later on ???
689 -- The caller has checked that the initial token is FOR
691 -- Error recovery: cannot raise Error_Resync, if an error occurs,
692 -- the scan is repositioned past the next semicolon.
694 function P_Representation_Clause return Node_Id is
695 For_Loc : Source_Ptr;
697 Prefix_Node : Node_Id;
699 Identifier_Node : Node_Id;
700 Rep_Clause_Node : Node_Id;
702 Record_Items : List_Id;
705 For_Loc := Token_Ptr;
708 -- Note that the name in a representation clause is always a simple
709 -- name, even in the attribute case, see AI-300 which made this so.
711 Identifier_Node := P_Identifier (C_Use);
713 -- Check case of qualified name to give good error message
715 if Token = Tok_Dot then
717 ("representation clause requires simple name!");
720 exit when Token /= Tok_Dot;
722 Discard_Junk_Node (P_Identifier);
726 -- Attribute Definition Clause
728 if Token = Tok_Apostrophe then
730 -- Allow local names of the form a'b'.... This enables
731 -- us to parse class-wide streams attributes correctly.
733 Name_Node := Identifier_Node;
734 while Token = Tok_Apostrophe loop
736 Scan; -- past apostrophe
738 Identifier_Node := Token_Node;
739 Attr_Name := No_Name;
741 if Token = Tok_Identifier then
742 Attr_Name := Token_Name;
744 -- Note that the parser must complain in case of an internal
745 -- attribute name that comes from source since internal names
746 -- are meant to be used only by the compiler.
748 if not Is_Attribute_Name (Attr_Name)
749 and then (not Is_Internal_Attribute_Name (Attr_Name)
750 or else Comes_From_Source (Token_Node))
752 Signal_Bad_Attribute;
756 Style.Check_Attribute_Name (False);
759 -- Here for case of attribute designator is not an identifier
762 if Token = Tok_Delta then
763 Attr_Name := Name_Delta;
765 elsif Token = Tok_Digits then
766 Attr_Name := Name_Digits;
768 elsif Token = Tok_Access then
769 Attr_Name := Name_Access;
772 Error_Msg_AP ("attribute designator expected");
777 Style.Check_Attribute_Name (True);
781 -- Here we have an OK attribute scanned, and the corresponding
782 -- Attribute identifier node is stored in Ident_Node.
784 Prefix_Node := Name_Node;
785 Name_Node := New_Node (N_Attribute_Reference, Prev_Token_Ptr);
786 Set_Prefix (Name_Node, Prefix_Node);
787 Set_Attribute_Name (Name_Node, Attr_Name);
790 -- Check for Address clause which needs to be marked for use in
791 -- optimizing performance of Exp_Util.Following_Address_Clause.
793 if Attr_Name = Name_Address
794 and then Nkind (Prefix_Node) = N_Identifier
796 Set_Name_Table_Boolean1 (Chars (Prefix_Node), True);
800 Rep_Clause_Node := New_Node (N_Attribute_Definition_Clause, For_Loc);
801 Set_Name (Rep_Clause_Node, Prefix_Node);
802 Set_Chars (Rep_Clause_Node, Attr_Name);
805 Expr_Node := P_Expression_No_Right_Paren;
806 Check_Simple_Expression_In_Ada_83 (Expr_Node);
807 Set_Expression (Rep_Clause_Node, Expr_Node);
811 Rep_Clause_Node := Empty;
813 -- AT follows USE (At Clause)
815 if Token = Tok_At then
817 Rep_Clause_Node := New_Node (N_At_Clause, For_Loc);
818 Set_Identifier (Rep_Clause_Node, Identifier_Node);
819 Expr_Node := P_Expression_No_Right_Paren;
820 Check_Simple_Expression_In_Ada_83 (Expr_Node);
821 Set_Expression (Rep_Clause_Node, Expr_Node);
823 -- Mark occurrence of address clause (used to optimize performance
824 -- of Exp_Util.Following_Address_Clause).
826 Set_Name_Table_Boolean1 (Chars (Identifier_Node), True);
828 -- RECORD follows USE (Record Representation Clause)
830 elsif Token = Tok_Record then
831 Record_Items := P_Pragmas_Opt;
833 New_Node (N_Record_Representation_Clause, For_Loc);
834 Set_Identifier (Rep_Clause_Node, Identifier_Node);
837 Scopes (Scope.Last).Etyp := E_Record;
838 Scopes (Scope.Last).Ecol := Start_Column;
839 Scopes (Scope.Last).Sloc := Token_Ptr;
841 Record_Items := P_Pragmas_Opt;
843 -- Possible Mod Clause
845 if Token = Tok_At then
846 Set_Mod_Clause (Rep_Clause_Node, P_Mod_Clause);
847 Set_Pragmas_Before (Mod_Clause (Rep_Clause_Node), Record_Items);
848 Record_Items := P_Pragmas_Opt;
851 if No (Record_Items) then
852 Record_Items := New_List;
855 Set_Component_Clauses (Rep_Clause_Node, Record_Items);
857 -- Loop through component clauses
860 if Token not in Token_Class_Name then
864 Append (P_Component_Clause, Record_Items);
865 P_Pragmas_Opt (Record_Items);
868 -- Left paren follows USE (Enumeration Representation Clause)
870 elsif Token = Tok_Left_Paren then
872 New_Node (N_Enumeration_Representation_Clause, For_Loc);
873 Set_Identifier (Rep_Clause_Node, Identifier_Node);
874 Set_Array_Aggregate (Rep_Clause_Node, P_Aggregate);
876 -- Some other token follows FOR (invalid representation clause)
879 Error_Msg_SC ("invalid representation clause");
885 return Rep_Clause_Node;
889 Resync_Past_Semicolon;
892 end P_Representation_Clause;
894 ----------------------
895 -- 13.1 Local Name --
896 ----------------------
898 -- Local name is always parsed by its parent. In the case of its use in
899 -- pragmas, the check for a local name is handled in Par.Prag and allows
900 -- all the possible forms of local name. For the uses in chapter 13, we
901 -- currently only allow a direct name, but this should probably change???
903 ---------------------------
904 -- 13.1 At Clause (I.7) --
905 ---------------------------
907 -- Parsed by P_Representation_Clause (13.1)
909 ---------------------------------------
910 -- 13.3 Attribute Definition Clause --
911 ---------------------------------------
913 -- Parsed by P_Representation_Clause (13.1)
915 --------------------------------
916 -- 13.1 Aspect Specification --
917 --------------------------------
919 -- ASPECT_SPECIFICATION ::=
920 -- with ASPECT_MARK [=> ASPECT_DEFINITION] {,
921 -- ASPECT_MARK [=> ASPECT_DEFINITION] }
923 -- ASPECT_MARK ::= aspect_IDENTIFIER['Class]
925 -- ASPECT_DEFINITION ::= NAME | EXPRESSION
927 -- Error recovery: cannot raise Error_Resync
929 procedure P_Aspect_Specifications
931 Semicolon : Boolean := True)
937 -- Aspect Specification is present
941 -- Here we have an aspect specification to scan, note that we don't
942 -- set the flag till later, because it may turn out that we have no
943 -- valid aspects in the list.
945 Aspects := Get_Aspect_Specifications (Semicolon);
947 -- Here if aspects present
949 if Is_Non_Empty_List (Aspects) then
951 -- If Decl is Empty, we just ignore the aspects (the caller in this
952 -- case has always issued an appropriate error message).
957 -- If Decl is Error, we ignore the aspects, and issue a message
960 or else not Permits_Aspect_Specifications (Decl)
962 Error_Msg ("aspect specifications not allowed here", Ptr);
964 -- Here aspects are allowed, and we store them
967 Set_Parent (Aspects, Decl);
968 Set_Aspect_Specifications (Decl, Aspects);
971 end P_Aspect_Specifications;
973 ---------------------------------------------
974 -- 13.4 Enumeration Representation Clause --
975 ---------------------------------------------
977 -- Parsed by P_Representation_Clause (13.1)
979 ---------------------------------
980 -- 13.4 Enumeration Aggregate --
981 ---------------------------------
983 -- Parsed by P_Representation_Clause (13.1)
985 ------------------------------------------
986 -- 13.5.1 Record Representation Clause --
987 ------------------------------------------
989 -- Parsed by P_Representation_Clause (13.1)
991 ------------------------------
992 -- 13.5.1 Mod Clause (I.8) --
993 ------------------------------
995 -- MOD_CLAUSE ::= at mod static_EXPRESSION;
997 -- Note: in Ada 83, the expression must be a simple expression
999 -- The caller has checked that the initial Token is AT
1001 -- Error recovery: cannot raise Error_Resync
1003 -- Note: the caller is responsible for setting the Pragmas_Before field
1005 function P_Mod_Clause return Node_Id is
1007 Expr_Node : Node_Id;
1010 Mod_Node := New_Node (N_Mod_Clause, Token_Ptr);
1013 Expr_Node := P_Expression_No_Right_Paren;
1014 Check_Simple_Expression_In_Ada_83 (Expr_Node);
1015 Set_Expression (Mod_Node, Expr_Node);
1020 ------------------------------
1021 -- 13.5.1 Component Clause --
1022 ------------------------------
1024 -- COMPONENT_CLAUSE ::=
1025 -- COMPONENT_CLAUSE_COMPONENT_NAME at POSITION
1026 -- range FIRST_BIT .. LAST_BIT;
1028 -- COMPONENT_CLAUSE_COMPONENT_NAME ::=
1029 -- component_DIRECT_NAME
1030 -- | component_DIRECT_NAME'ATTRIBUTE_DESIGNATOR
1031 -- | FIRST_SUBTYPE_DIRECT_NAME'ATTRIBUTE_DESIGNATOR
1033 -- POSITION ::= static_EXPRESSION
1035 -- Note: in Ada 83, the expression must be a simple expression
1037 -- FIRST_BIT ::= static_SIMPLE_EXPRESSION
1038 -- LAST_BIT ::= static_SIMPLE_EXPRESSION
1040 -- Note: the AARM V2.0 grammar has an error at this point, it uses
1041 -- EXPRESSION instead of SIMPLE_EXPRESSION for FIRST_BIT and LAST_BIT
1043 -- Error recovery: cannot raise Error_Resync
1045 function P_Component_Clause return Node_Id is
1046 Component_Node : Node_Id;
1047 Comp_Name : Node_Id;
1048 Expr_Node : Node_Id;
1051 Component_Node := New_Node (N_Component_Clause, Token_Ptr);
1052 Comp_Name := P_Name;
1054 if Nkind (Comp_Name) = N_Identifier
1055 or else Nkind (Comp_Name) = N_Attribute_Reference
1057 Set_Component_Name (Component_Node, Comp_Name);
1060 ("component name must be direct name or attribute", Comp_Name);
1061 Set_Component_Name (Component_Node, Error);
1064 Set_Sloc (Component_Node, Token_Ptr);
1066 Expr_Node := P_Expression_No_Right_Paren;
1067 Check_Simple_Expression_In_Ada_83 (Expr_Node);
1068 Set_Position (Component_Node, Expr_Node);
1070 Expr_Node := P_Expression_No_Right_Paren;
1071 Check_Simple_Expression_In_Ada_83 (Expr_Node);
1072 Set_First_Bit (Component_Node, Expr_Node);
1074 Expr_Node := P_Expression_No_Right_Paren;
1075 Check_Simple_Expression_In_Ada_83 (Expr_Node);
1076 Set_Last_Bit (Component_Node, Expr_Node);
1078 return Component_Node;
1079 end P_Component_Clause;
1081 ----------------------
1082 -- 13.5.1 Position --
1083 ----------------------
1085 -- Parsed by P_Component_Clause (13.5.1)
1087 -----------------------
1088 -- 13.5.1 First Bit --
1089 -----------------------
1091 -- Parsed by P_Component_Clause (13.5.1)
1093 ----------------------
1094 -- 13.5.1 Last Bit --
1095 ----------------------
1097 -- Parsed by P_Component_Clause (13.5.1)
1099 --------------------------
1100 -- 13.8 Code Statement --
1101 --------------------------
1103 -- CODE_STATEMENT ::= QUALIFIED_EXPRESSION
1105 -- On entry the caller has scanned the SUBTYPE_MARK (passed in as the
1106 -- single argument, and the scan points to the apostrophe.
1108 -- Error recovery: can raise Error_Resync
1110 function P_Code_Statement (Subtype_Mark : Node_Id) return Node_Id is
1114 Scan; -- past apostrophe
1116 -- If left paren, then we have a possible code statement
1118 if Token = Tok_Left_Paren then
1119 Node1 := New_Node (N_Code_Statement, Sloc (Subtype_Mark));
1120 Set_Expression (Node1, P_Qualified_Expression (Subtype_Mark));
1124 -- Otherwise we have an illegal range attribute. Note that P_Name
1125 -- ensures that Token = Tok_Range is the only possibility left here.
1128 Error_Msg_SC ("RANGE attribute illegal here!");
1131 end P_Code_Statement;