| ------------------------------------------------------------------------------ |
| -- -- |
| -- GNAT COMPILER COMPONENTS -- |
| -- -- |
| -- S E M _ P R A G -- |
| -- -- |
| -- B o d y -- |
| -- -- |
| -- $Revision$ |
| -- -- |
| -- Copyright (C) 1992-2001, 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, 59 Temple Place - Suite 330, Boston, -- |
| -- MA 02111-1307, USA. -- |
| -- -- |
| -- GNAT was originally developed by the GNAT team at New York University. -- |
| -- It is now maintained by Ada Core Technologies Inc (http://www.gnat.com). -- |
| -- -- |
| ------------------------------------------------------------------------------ |
| |
| -- This unit contains the semantic processing for all pragmas, both language |
| -- and implementation defined. For most pragmas, the parser only does the |
| -- most basic job of checking the syntax, so Sem_Prag also contains the code |
| -- to complete the syntax checks. Certain pragmas are handled partially or |
| -- completely by the parser (see Par.Prag for further details). |
| |
| with Atree; use Atree; |
| with Casing; use Casing; |
| with Csets; use Csets; |
| with Debug; use Debug; |
| with Einfo; use Einfo; |
| with Elists; use Elists; |
| with Errout; use Errout; |
| with Expander; use Expander; |
| with Exp_Dist; use Exp_Dist; |
| with Fname; use Fname; |
| with Hostparm; use Hostparm; |
| with Lib; use Lib; |
| with Namet; use Namet; |
| with Nlists; use Nlists; |
| with Nmake; use Nmake; |
| with Opt; use Opt; |
| with Output; use Output; |
| with Restrict; use Restrict; |
| with Rtsfind; use Rtsfind; |
| with Sem; use Sem; |
| with Sem_Ch8; use Sem_Ch8; |
| with Sem_Ch13; use Sem_Ch13; |
| with Sem_Disp; use Sem_Disp; |
| with Sem_Elim; use Sem_Elim; |
| with Sem_Eval; use Sem_Eval; |
| with Sem_Intr; use Sem_Intr; |
| with Sem_Mech; use Sem_Mech; |
| with Sem_Res; use Sem_Res; |
| with Sem_Type; use Sem_Type; |
| with Sem_Util; use Sem_Util; |
| with Sem_VFpt; use Sem_VFpt; |
| with Stand; use Stand; |
| with Sinfo; use Sinfo; |
| with Sinfo.CN; use Sinfo.CN; |
| with Sinput; use Sinput; |
| with Snames; use Snames; |
| with Stringt; use Stringt; |
| with Stylesw; use Stylesw; |
| with Targparm; use Targparm; |
| with Tbuild; use Tbuild; |
| with Ttypes; |
| with Uintp; use Uintp; |
| with Urealp; use Urealp; |
| with Validsw; use Validsw; |
| |
| package body Sem_Prag is |
| |
| ---------------------------------------------- |
| -- Common Handling of Import-Export Pragmas -- |
| ---------------------------------------------- |
| |
| -- In the following section, a number of Import_xxx and Export_xxx |
| -- pragmas are defined by GNAT. These are compatible with the DEC |
| -- pragmas of the same name, and all have the following common |
| -- form and processing: |
| |
| -- pragma Export_xxx |
| -- [Internal =>] LOCAL_NAME, |
| -- [, [External =>] EXTERNAL_SYMBOL] |
| -- [, other optional parameters ]); |
| |
| -- pragma Import_xxx |
| -- [Internal =>] LOCAL_NAME, |
| -- [, [External =>] EXTERNAL_SYMBOL] |
| -- [, other optional parameters ]); |
| |
| -- EXTERNAL_SYMBOL ::= |
| -- IDENTIFIER |
| -- | static_string_EXPRESSION |
| |
| -- The internal LOCAL_NAME designates the entity that is imported or |
| -- exported, and must refer to an entity in the current declarative |
| -- part (as required by the rules for LOCAL_NAME). |
| |
| -- The external linker name is designated by the External parameter |
| -- if given, or the Internal parameter if not (if there is no External |
| -- parameter, the External parameter is a copy of the Internal name). |
| |
| -- If the External parameter is given as a string, then this string |
| -- is treated as an external name (exactly as though it had been given |
| -- as an External_Name parameter for a normal Import pragma). |
| |
| -- If the External parameter is given as an identifier (or there is no |
| -- External parameter, so that the Internal identifier is used), then |
| -- the external name is the characters of the identifier, translated |
| -- to all upper case letters for OpenVMS versions of GNAT, and to all |
| -- lower case letters for all other versions |
| |
| -- Note: the external name specified or implied by any of these special |
| -- Import_xxx or Export_xxx pragmas override an external or link name |
| -- specified in a previous Import or Export pragma. |
| |
| -- Note: these and all other DEC-compatible GNAT pragmas allow full |
| -- use of named notation, following the standard rules for subprogram |
| -- calls, i.e. parameters can be given in any order if named notation |
| -- is used, and positional and named notation can be mixed, subject to |
| -- the rule that all positional parameters must appear first. |
| |
| -- Note: All these pragmas are implemented exactly following the DEC |
| -- design and implementation and are intended to be fully compatible |
| -- with the use of these pragmas in the DEC Ada compiler. |
| |
| ------------------------------------- |
| -- Local Subprograms and Variables -- |
| ------------------------------------- |
| |
| function Adjust_External_Name_Case (N : Node_Id) return Node_Id; |
| -- This routine is used for possible casing adjustment of an explicit |
| -- external name supplied as a string literal (the node N), according |
| -- to the casing requirement of Opt.External_Name_Casing. If this is |
| -- set to As_Is, then the string literal is returned unchanged, but if |
| -- it is set to Uppercase or Lowercase, then a new string literal with |
| -- appropriate casing is constructed. |
| |
| function Is_Generic_Subprogram (Id : Entity_Id) return Boolean; |
| -- Return True if Id is a generic procedure or a function |
| |
| function Get_Base_Subprogram (Def_Id : Entity_Id) return Entity_Id; |
| -- If Def_Id refers to a renamed subprogram, then the base subprogram |
| -- (the original one, following the renaming chain) is returned. |
| -- Otherwise the entity is returned unchanged. Should be in Einfo??? |
| |
| procedure Set_Unit_Name (N : Node_Id; With_Item : Node_Id); |
| -- Place semantic information on the argument of an Elaborate or |
| -- Elaborate_All pragma. Entity name for unit and its parents is |
| -- taken from item in previous with_clause that mentions the unit. |
| |
| Locking_Policy_Sloc : Source_Ptr := No_Location; |
| Queuing_Policy_Sloc : Source_Ptr := No_Location; |
| Task_Dispatching_Policy_Sloc : Source_Ptr := No_Location; |
| -- These global variables remember the location of a previous locking, |
| -- queuing or task dispatching policy pragma, so that appropriate error |
| -- messages can be generated for inconsistent pragmas. Note that it is |
| -- fine that these are global locations, because the check for consistency |
| -- is over the entire program. |
| |
| ------------------------------- |
| -- Adjust_External_Name_Case -- |
| ------------------------------- |
| |
| function Adjust_External_Name_Case (N : Node_Id) return Node_Id is |
| CC : Char_Code; |
| |
| begin |
| -- Adjust case of literal if required |
| |
| if Opt.External_Name_Exp_Casing = As_Is then |
| return N; |
| |
| else |
| -- Copy existing string |
| |
| Start_String; |
| |
| -- Set proper casing |
| |
| for J in 1 .. String_Length (Strval (N)) loop |
| CC := Get_String_Char (Strval (N), J); |
| |
| if Opt.External_Name_Exp_Casing = Uppercase |
| and then CC >= Get_Char_Code ('a') |
| and then CC <= Get_Char_Code ('z') |
| then |
| Store_String_Char (CC - 32); |
| |
| elsif Opt.External_Name_Exp_Casing = Lowercase |
| and then CC >= Get_Char_Code ('A') |
| and then CC <= Get_Char_Code ('Z') |
| then |
| Store_String_Char (CC + 32); |
| |
| else |
| Store_String_Char (CC); |
| end if; |
| end loop; |
| |
| return |
| Make_String_Literal (Sloc (N), |
| Strval => End_String); |
| end if; |
| end Adjust_External_Name_Case; |
| |
| -------------------- |
| -- Analyze_Pragma -- |
| -------------------- |
| |
| procedure Analyze_Pragma (N : Node_Id) is |
| Loc : constant Source_Ptr := Sloc (N); |
| Prag_Id : Pragma_Id; |
| |
| Pragma_Exit : exception; |
| -- This exception is used to exit pragma processing completely. It |
| -- is used when an error is detected, and in other situations where |
| -- it is known that no further processing is required. |
| |
| Arg_Count : Nat; |
| -- Number of pragma argument associations |
| |
| Arg1 : Node_Id; |
| Arg2 : Node_Id; |
| Arg3 : Node_Id; |
| Arg4 : Node_Id; |
| -- First four pragma arguments (pragma argument association nodes, |
| -- or Empty if the corresponding argument does not exist). |
| |
| procedure Check_Ada_83_Warning; |
| -- Issues a warning message for the current pragma if operating in Ada |
| -- 83 mode (used for language pragmas that are not a standard part of |
| -- Ada 83). This procedure does not raise Error_Pragma. Also notes use |
| -- of 95 pragma. |
| |
| procedure Check_Arg_Count (Required : Nat); |
| -- Check argument count for pragma is equal to given parameter. |
| -- If not, then issue an error message and raise Pragma_Exit. |
| |
| -- Note: all routines whose name is Check_Arg_Is_xxx take an |
| -- argument Arg which can either be a pragma argument association, |
| -- in which case the check is applied to the expression of the |
| -- association or an expression directly. |
| |
| procedure Check_Arg_Is_Identifier (Arg : Node_Id); |
| -- Check the specified argument Arg to make sure that it is an |
| -- identifier. If not give error and raise Pragma_Exit. |
| |
| procedure Check_Arg_Is_Integer_Literal (Arg : Node_Id); |
| -- Check the specified argument Arg to make sure that it is an |
| -- integer literal. If not give error and raise Pragma_Exit. |
| |
| procedure Check_Arg_Is_Library_Level_Local_Name (Arg : Node_Id); |
| -- Check the specified argument Arg to make sure that it has the |
| -- proper syntactic form for a local name and meets the semantic |
| -- requirements for a local name. The local name is analyzed as |
| -- part of the processing for this call. In addition, the local |
| -- name is required to represent an entity at the library level. |
| |
| procedure Check_Arg_Is_Local_Name (Arg : Node_Id); |
| -- Check the specified argument Arg to make sure that it has the |
| -- proper syntactic form for a local name and meets the semantic |
| -- requirements for a local name. The local name is analyzed as |
| -- part of the processing for this call. |
| |
| procedure Check_Arg_Is_Locking_Policy (Arg : Node_Id); |
| -- Check the specified argument Arg to make sure that it is a valid |
| -- locking policy name. If not give error and raise Pragma_Exit. |
| |
| procedure Check_Arg_Is_One_Of (Arg : Node_Id; N1, N2 : Name_Id); |
| procedure Check_Arg_Is_One_Of (Arg : Node_Id; N1, N2, N3 : Name_Id); |
| -- Check the specified argument Arg to make sure that it is an |
| -- identifier whose name matches either N1 or N2 (or N3 if present). |
| -- If not then give error and raise Pragma_Exit. |
| |
| procedure Check_Arg_Is_Queuing_Policy (Arg : Node_Id); |
| -- Check the specified argument Arg to make sure that it is a valid |
| -- queuing policy name. If not give error and raise Pragma_Exit. |
| |
| procedure Check_Arg_Is_Static_Expression |
| (Arg : Node_Id; |
| Typ : Entity_Id); |
| -- Check the specified argument Arg to make sure that it is a static |
| -- expression of the given type (i.e. it will be analyzed and resolved |
| -- using this type, which can be any valid argument to Resolve, e.g. |
| -- Any_Integer is OK). If not, given error and raise Pragma_Exit. |
| |
| procedure Check_Arg_Is_String_Literal (Arg : Node_Id); |
| -- Check the specified argument Arg to make sure that it is a |
| -- string literal. If not give error and raise Pragma_Exit |
| |
| procedure Check_Arg_Is_Task_Dispatching_Policy (Arg : Node_Id); |
| -- Check the specified argument Arg to make sure that it is a valid |
| -- valid task dispatching policy name. If not give error and raise |
| -- Pragma_Exit. |
| |
| procedure Check_At_Least_N_Arguments (N : Nat); |
| -- Check there are at least N arguments present |
| |
| procedure Check_At_Most_N_Arguments (N : Nat); |
| -- Check there are no more than N arguments present |
| |
| procedure Check_First_Subtype (Arg : Node_Id); |
| -- Checks that Arg, whose expression is an entity name referencing |
| -- a subtype, does not reference a type that is not a first subtype. |
| |
| procedure Check_In_Main_Program; |
| -- Common checks for pragmas that appear within a main program |
| -- (Priority, Main_Storage, Time_Slice). |
| |
| procedure Check_Interrupt_Or_Attach_Handler; |
| -- Common processing for first argument of pragma Interrupt_Handler |
| -- or pragma Attach_Handler. |
| |
| procedure Check_Is_In_Decl_Part_Or_Package_Spec; |
| -- Check that pragma appears in a declarative part, or in a package |
| -- specification, i.e. that it does not occur in a statement sequence |
| -- in a body. |
| |
| procedure Check_No_Identifier (Arg : Node_Id); |
| -- Checks that the given argument does not have an identifier. If |
| -- an identifier is present, then an error message is issued, and |
| -- Pragma_Exit is raised. |
| |
| procedure Check_No_Identifiers; |
| -- Checks that none of the arguments to the pragma has an identifier. |
| -- If any argument has an identifier, then an error message is issued, |
| -- and Pragma_Exit is raised. |
| |
| procedure Check_Non_Overloaded_Function (Arg : Node_Id); |
| -- Check that the given argument is the name of a local function of |
| -- one argument that is not overloaded in the current local scope. |
| |
| procedure Check_Optional_Identifier (Arg : Node_Id; Id : Name_Id); |
| -- Checks if the given argument has an identifier, and if so, requires |
| -- it to match the given identifier name. If there is a non-matching |
| -- identifier, then an error message is given and Error_Pragmas raised. |
| |
| procedure Check_Optional_Identifier (Arg : Node_Id; Id : String); |
| -- Checks if the given argument has an identifier, and if so, requires |
| -- it to match the given identifier name. If there is a non-matching |
| -- identifier, then an error message is given and Error_Pragmas raised. |
| -- In this version of the procedure, the identifier name is given as |
| -- a string with lower case letters. |
| |
| procedure Check_Static_Constraint (Constr : Node_Id); |
| -- Constr is a constraint from an N_Subtype_Indication node from a |
| -- component constraint in an Unchecked_Union type. This routine checks |
| -- that the constraint is static as required by the restrictions for |
| -- Unchecked_Union. |
| |
| procedure Check_Valid_Configuration_Pragma; |
| -- Legality checks for placement of a configuration pragma |
| |
| procedure Check_Valid_Library_Unit_Pragma; |
| -- Legality checks for library unit pragmas. A special case arises for |
| -- pragmas in generic instances that come from copies of the original |
| -- library unit pragmas in the generic templates. In the case of other |
| -- than library level instantiations these can appear in contexts which |
| -- would normally be invalid (they only apply to the original template |
| -- and to library level instantiations), and they are simply ignored, |
| -- which is implemented by rewriting them as null statements. |
| |
| procedure Error_Pragma (Msg : String); |
| pragma No_Return (Error_Pragma); |
| -- Outputs error message for current pragma. The message contains an % |
| -- that will be replaced with the pragma name, and the flag is placed |
| -- on the pragma itself. Pragma_Exit is then raised. |
| |
| procedure Error_Pragma_Arg (Msg : String; Arg : Node_Id); |
| pragma No_Return (Error_Pragma_Arg); |
| -- Outputs error message for current pragma. The message may contain |
| -- a % that will be replaced with the pragma name. The parameter Arg |
| -- may either be a pragma argument association, in which case the flag |
| -- is placed on the expression of this association, or an expression, |
| -- in which case the flag is placed directly on the expression. The |
| -- message is placed using Error_Msg_N, so the message may also contain |
| -- an & insertion character which will reference the given Arg value. |
| -- After placing the message, Pragma_Exit is raised. |
| |
| procedure Error_Pragma_Arg (Msg1, Msg2 : String; Arg : Node_Id); |
| pragma No_Return (Error_Pragma_Arg); |
| -- Similar to above form of Error_Pragma_Arg except that two messages |
| -- are provided, the second is a continuation comment starting with \. |
| |
| procedure Error_Pragma_Arg_Ident (Msg : String; Arg : Node_Id); |
| pragma No_Return (Error_Pragma_Arg_Ident); |
| -- Outputs error message for current pragma. The message may contain |
| -- a % that will be replaced with the pragma name. The parameter Arg |
| -- must be a pragma argument association with a non-empty identifier |
| -- (i.e. its Chars field must be set), and the error message is placed |
| -- on the identifier. The message is placed using Error_Msg_N so |
| -- the message may also contain an & insertion character which will |
| -- reference the identifier. After placing the message, Pragma_Exit |
| -- is raised. |
| |
| function Find_Lib_Unit_Name return Entity_Id; |
| -- Used for a library unit pragma to find the entity to which the |
| -- library unit pragma applies, returns the entity found. |
| |
| procedure Find_Program_Unit_Name (Id : Node_Id); |
| -- If the pragma is a compilation unit pragma, the id must denote the |
| -- compilation unit in the same compilation, and the pragma must appear |
| -- in the list of preceding or trailing pragmas. If it is a program |
| -- unit pragma that is not a compilation unit pragma, then the |
| -- identifier must be visible. |
| |
| type Name_List is array (Natural range <>) of Name_Id; |
| type Args_List is array (Natural range <>) of Node_Id; |
| procedure Gather_Associations |
| (Names : Name_List; |
| Args : out Args_List); |
| -- This procedure is used to gather the arguments for a pragma that |
| -- permits arbitrary ordering of parameters using the normal rules |
| -- for named and positional parameters. The Names argument is a list |
| -- of Name_Id values that corresponds to the allowed pragma argument |
| -- association identifiers in order. The result returned in Args is |
| -- a list of corresponding expressions that are the pragma arguments. |
| -- Note that this is a list of expressions, not of pragma argument |
| -- associations (Gather_Associations has completely checked all the |
| -- optional identifiers when it returns). An entry in Args is Empty |
| -- on return if the corresponding argument is not present. |
| |
| function Get_Pragma_Arg (Arg : Node_Id) return Node_Id; |
| -- All the routines that check pragma arguments take either a pragma |
| -- argument association (in which case the expression of the argument |
| -- association is checked), or the expression directly. The function |
| -- Get_Pragma_Arg is a utility used to deal with these two cases. If |
| -- Arg is a pragma argument association node, then its expression is |
| -- returned, otherwise Arg is returned unchanged. |
| |
| procedure GNAT_Pragma; |
| -- Called for all GNAT defined pragmas to note the use of the feature, |
| -- and also check the relevant restriction (No_Implementation_Pragmas). |
| |
| function Is_Before_First_Decl |
| (Pragma_Node : Node_Id; |
| Decls : List_Id) |
| return Boolean; |
| -- Return True if Pragma_Node is before the first declarative item in |
| -- Decls where Decls is the list of declarative items. |
| |
| function Is_Configuration_Pragma return Boolean; |
| -- Deterermines if the placement of the current pragma is appropriate |
| -- for a configuration pragma (precedes the current compilation unit) |
| |
| procedure Pragma_Misplaced; |
| -- Issue fatal error message for misplaced pragma |
| |
| procedure Process_Atomic_Shared_Volatile; |
| -- Common processing for pragmas Atomic, Shared, Volatile. Note that |
| -- Shared is an obsolete Ada 83 pragma, treated as being identical |
| -- in effect to pragma Atomic. |
| |
| procedure Process_Convention (C : out Convention_Id; E : out Entity_Id); |
| -- Common procesing for Convention, Interface, Import and Export. |
| -- Checks first two arguments of pragma, and sets the appropriate |
| -- convention value in the specified entity or entities. On return |
| -- C is the convention, E is the referenced entity. |
| |
| procedure Process_Extended_Import_Export_Exception_Pragma |
| (Arg_Internal : Node_Id; |
| Arg_External : Node_Id; |
| Arg_Form : Node_Id; |
| Arg_Code : Node_Id); |
| -- Common processing for the pragmas Import/Export_Exception. |
| -- The three arguments correspond to the three named parameters of |
| -- the pragma. An argument is empty if the corresponding parameter |
| -- is not present in the pragma. |
| |
| procedure Process_Extended_Import_Export_Object_Pragma |
| (Arg_Internal : Node_Id; |
| Arg_External : Node_Id; |
| Arg_Size : Node_Id); |
| -- Common processing for the pragmass Import/Export_Object. |
| -- The three arguments correspond to the three named parameters |
| -- of the pragmas. An argument is empty if the corresponding |
| -- parameter is not present in the pragma. |
| |
| procedure Process_Extended_Import_Export_Internal_Arg |
| (Arg_Internal : Node_Id := Empty); |
| -- Common processing for all extended Import and Export pragmas. The |
| -- argument is the pragma parameter for the Internal argument. If |
| -- Arg_Internal is empty or inappropriate, an error message is posted. |
| -- Otherwise, on normal return, the Entity_Field of Arg_Internal is |
| -- set to identify the referenced entity. |
| |
| procedure Process_Extended_Import_Export_Subprogram_Pragma |
| (Arg_Internal : Node_Id; |
| Arg_External : Node_Id; |
| Arg_Parameter_Types : Node_Id; |
| Arg_Result_Type : Node_Id := Empty; |
| Arg_Mechanism : Node_Id; |
| Arg_Result_Mechanism : Node_Id := Empty; |
| Arg_First_Optional_Parameter : Node_Id := Empty); |
| -- Common processing for all extended Import and Export pragmas |
| -- applying to subprograms. The caller omits any arguments that do |
| -- bnot apply to the pragma in question (for example, Arg_Result_Type |
| -- can be non-Empty only in the Import_Function and Export_Function |
| -- cases). The argument names correspond to the allowed pragma |
| -- association identifiers. |
| |
| procedure Process_Generic_List; |
| -- Common processing for Share_Generic and Inline_Generic |
| |
| procedure Process_Import_Or_Interface; |
| -- Common processing for Import of Interface |
| |
| procedure Process_Inline (Active : Boolean); |
| -- Common processing for Inline and Inline_Always. The parameter |
| -- indicates if the inline pragma is active, i.e. if it should |
| -- actually cause inlining to occur. |
| |
| procedure Process_Interface_Name |
| (Subprogram_Def : Entity_Id; |
| Ext_Arg : Node_Id; |
| Link_Arg : Node_Id); |
| -- Given the last two arguments of pragma Import, pragma Export, or |
| -- pragma Interface_Name, performs validity checks and sets the |
| -- Interface_Name field of the given subprogram entity to the |
| -- appropriate external or link name, depending on the arguments |
| -- given. Ext_Arg is always present, but Link_Arg may be missing. |
| -- Note that Ext_Arg may represent the Link_Name if Link_Arg is |
| -- missing, and appropriate named notation is used for Ext_Arg. |
| -- If neither Ext_Arg nor Link_Arg is present, the interface name |
| -- is set to the default from the subprogram name. |
| |
| procedure Process_Interrupt_Or_Attach_Handler; |
| -- Attach the pragmas to the rep item chain. |
| |
| procedure Process_Suppress_Unsuppress (Suppress_Case : Boolean); |
| -- Common processing for Suppress and Unsuppress. The boolean parameter |
| -- Suppress_Case is True for the Suppress case, and False for the |
| -- Unsuppress case. |
| |
| procedure Set_Exported (E : Entity_Id; Arg : Node_Id); |
| -- This procedure sets the Is_Exported flag for the given entity, |
| -- checking that the entity was not previously imported. Arg is |
| -- the argument that specified the entity. |
| |
| procedure Set_Extended_Import_Export_External_Name |
| (Internal_Ent : Entity_Id; |
| Arg_External : Node_Id); |
| -- Common processing for all extended import export pragmas. The first |
| -- argument, Internal_Ent, is the internal entity, which has already |
| -- been checked for validity by the caller. Arg_External is from the |
| -- Import or Export pragma, and may be null if no External parameter |
| -- was present. If Arg_External is present and is a non-null string |
| -- (a null string is treated as the default), then the Interface_Name |
| -- field of Internal_Ent is set appropriately. |
| |
| procedure Set_Imported (E : Entity_Id); |
| -- This procedure sets the Is_Imported flag for the given entity, |
| -- checking that it is not previously exported or imported. |
| |
| procedure Set_Mechanism_Value (Ent : Entity_Id; Mech_Name : Node_Id); |
| -- Mech is a parameter passing mechanism (see Import_Function syntax |
| -- for MECHANISM_NAME). This routine checks that the mechanism argument |
| -- has the right form, and if not issues an error message. If the |
| -- argument has the right form then the Mechanism field of Ent is |
| -- set appropriately. |
| |
| -------------------------- |
| -- Check_Ada_83_Warning -- |
| -------------------------- |
| |
| procedure Check_Ada_83_Warning is |
| begin |
| GNAT_Pragma; |
| |
| if Ada_83 and then Comes_From_Source (N) then |
| Error_Msg_N ("(Ada 83) pragma& is non-standard?", N); |
| end if; |
| end Check_Ada_83_Warning; |
| |
| --------------------- |
| -- Check_Arg_Count -- |
| --------------------- |
| |
| procedure Check_Arg_Count (Required : Nat) is |
| begin |
| if Arg_Count /= Required then |
| Error_Pragma ("wrong number of arguments for pragma%"); |
| end if; |
| end Check_Arg_Count; |
| |
| ----------------------------- |
| -- Check_Arg_Is_Identifier -- |
| ----------------------------- |
| |
| procedure Check_Arg_Is_Identifier (Arg : Node_Id) is |
| Argx : constant Node_Id := Get_Pragma_Arg (Arg); |
| |
| begin |
| if Nkind (Argx) /= N_Identifier then |
| Error_Pragma_Arg |
| ("argument for pragma% must be identifier", Argx); |
| end if; |
| end Check_Arg_Is_Identifier; |
| |
| ---------------------------------- |
| -- Check_Arg_Is_Integer_Literal -- |
| ---------------------------------- |
| |
| procedure Check_Arg_Is_Integer_Literal (Arg : Node_Id) is |
| Argx : constant Node_Id := Get_Pragma_Arg (Arg); |
| |
| begin |
| if Nkind (Argx) /= N_Integer_Literal then |
| Error_Pragma_Arg |
| ("argument for pragma% must be integer literal", Argx); |
| end if; |
| end Check_Arg_Is_Integer_Literal; |
| |
| ------------------------------------------- |
| -- Check_Arg_Is_Library_Level_Local_Name -- |
| ------------------------------------------- |
| |
| -- LOCAL_NAME ::= |
| -- DIRECT_NAME |
| -- | DIRECT_NAME'ATTRIBUTE_DESIGNATOR |
| -- | library_unit_NAME |
| |
| procedure Check_Arg_Is_Library_Level_Local_Name (Arg : Node_Id) is |
| begin |
| Check_Arg_Is_Local_Name (Arg); |
| |
| if not Is_Library_Level_Entity (Entity (Expression (Arg))) |
| and then Comes_From_Source (N) |
| then |
| Error_Pragma_Arg |
| ("argument for pragma% must be library level entity", Arg); |
| end if; |
| end Check_Arg_Is_Library_Level_Local_Name; |
| |
| ----------------------------- |
| -- Check_Arg_Is_Local_Name -- |
| ----------------------------- |
| |
| -- LOCAL_NAME ::= |
| -- DIRECT_NAME |
| -- | DIRECT_NAME'ATTRIBUTE_DESIGNATOR |
| -- | library_unit_NAME |
| |
| procedure Check_Arg_Is_Local_Name (Arg : Node_Id) is |
| Argx : constant Node_Id := Get_Pragma_Arg (Arg); |
| |
| begin |
| Analyze (Argx); |
| |
| if Nkind (Argx) not in N_Direct_Name |
| and then (Nkind (Argx) /= N_Attribute_Reference |
| or else Present (Expressions (Argx)) |
| or else Nkind (Prefix (Argx)) /= N_Identifier) |
| and then (not Is_Entity_Name (Argx) |
| or else not Is_Compilation_Unit (Entity (Argx))) |
| then |
| Error_Pragma_Arg ("argument for pragma% must be local name", Argx); |
| end if; |
| |
| if Is_Entity_Name (Argx) |
| and then Scope (Entity (Argx)) /= Current_Scope |
| then |
| Error_Pragma_Arg |
| ("pragma% argument must be in same declarative part", Arg); |
| end if; |
| end Check_Arg_Is_Local_Name; |
| |
| --------------------------------- |
| -- Check_Arg_Is_Locking_Policy -- |
| --------------------------------- |
| |
| procedure Check_Arg_Is_Locking_Policy (Arg : Node_Id) is |
| Argx : constant Node_Id := Get_Pragma_Arg (Arg); |
| |
| begin |
| Check_Arg_Is_Identifier (Argx); |
| |
| if not Is_Locking_Policy_Name (Chars (Argx)) then |
| Error_Pragma_Arg |
| ("& is not a valid locking policy name", Argx); |
| end if; |
| end Check_Arg_Is_Locking_Policy; |
| |
| ------------------------- |
| -- Check_Arg_Is_One_Of -- |
| ------------------------- |
| |
| procedure Check_Arg_Is_One_Of (Arg : Node_Id; N1, N2 : Name_Id) is |
| Argx : constant Node_Id := Get_Pragma_Arg (Arg); |
| |
| begin |
| Check_Arg_Is_Identifier (Argx); |
| |
| if Chars (Argx) /= N1 and then Chars (Argx) /= N2 then |
| Error_Msg_Name_2 := N1; |
| Error_Msg_Name_3 := N2; |
| Error_Pragma_Arg ("argument for pragma% must be% or%", Argx); |
| end if; |
| end Check_Arg_Is_One_Of; |
| |
| procedure Check_Arg_Is_One_Of |
| (Arg : Node_Id; |
| N1, N2, N3 : Name_Id) |
| is |
| Argx : constant Node_Id := Get_Pragma_Arg (Arg); |
| |
| begin |
| Check_Arg_Is_Identifier (Argx); |
| |
| if Chars (Argx) /= N1 |
| and then Chars (Argx) /= N2 |
| and then Chars (Argx) /= N3 |
| then |
| Error_Pragma_Arg ("invalid argument for pragma%", Argx); |
| end if; |
| end Check_Arg_Is_One_Of; |
| |
| --------------------------------- |
| -- Check_Arg_Is_Queuing_Policy -- |
| --------------------------------- |
| |
| procedure Check_Arg_Is_Queuing_Policy (Arg : Node_Id) is |
| Argx : constant Node_Id := Get_Pragma_Arg (Arg); |
| |
| begin |
| Check_Arg_Is_Identifier (Argx); |
| |
| if not Is_Queuing_Policy_Name (Chars (Argx)) then |
| Error_Pragma_Arg |
| ("& is not a valid queuing policy name", Argx); |
| end if; |
| end Check_Arg_Is_Queuing_Policy; |
| |
| ------------------------------------ |
| -- Check_Arg_Is_Static_Expression -- |
| ------------------------------------ |
| |
| procedure Check_Arg_Is_Static_Expression |
| (Arg : Node_Id; |
| Typ : Entity_Id) |
| is |
| Argx : constant Node_Id := Get_Pragma_Arg (Arg); |
| |
| begin |
| Analyze_And_Resolve (Argx, Typ); |
| |
| if Is_OK_Static_Expression (Argx) then |
| return; |
| |
| elsif Etype (Argx) = Any_Type then |
| raise Pragma_Exit; |
| |
| -- An interesting special case, if we have a string literal and |
| -- we are in Ada 83 mode, then we allow it even though it will |
| -- not be flagged as static. This allows the use of Ada 95 |
| -- pragmas like Import in Ada 83 mode. They will of course be |
| -- flagged with warnings as usual, but will not cause errors. |
| |
| elsif Ada_83 and then Nkind (Argx) = N_String_Literal then |
| return; |
| |
| -- Static expression that raises Constraint_Error. This has |
| -- already been flagged, so just exit from pragma processing. |
| |
| elsif Is_Static_Expression (Argx) then |
| raise Pragma_Exit; |
| |
| -- Finally, we have a real error |
| |
| else |
| Error_Pragma_Arg |
| ("argument for pragma% must be a static expression", Argx); |
| end if; |
| |
| end Check_Arg_Is_Static_Expression; |
| |
| --------------------------------- |
| -- Check_Arg_Is_String_Literal -- |
| --------------------------------- |
| |
| procedure Check_Arg_Is_String_Literal (Arg : Node_Id) is |
| Argx : constant Node_Id := Get_Pragma_Arg (Arg); |
| |
| begin |
| if Nkind (Argx) /= N_String_Literal then |
| Error_Pragma_Arg |
| ("argument for pragma% must be string literal", Argx); |
| end if; |
| |
| end Check_Arg_Is_String_Literal; |
| |
| ------------------------------------------ |
| -- Check_Arg_Is_Task_Dispatching_Policy -- |
| ------------------------------------------ |
| |
| procedure Check_Arg_Is_Task_Dispatching_Policy (Arg : Node_Id) is |
| Argx : constant Node_Id := Get_Pragma_Arg (Arg); |
| |
| begin |
| Check_Arg_Is_Identifier (Argx); |
| |
| if not Is_Task_Dispatching_Policy_Name (Chars (Argx)) then |
| Error_Pragma_Arg |
| ("& is not a valid task dispatching policy name", Argx); |
| end if; |
| end Check_Arg_Is_Task_Dispatching_Policy; |
| |
| -------------------------------- |
| -- Check_At_Least_N_Arguments -- |
| -------------------------------- |
| |
| procedure Check_At_Least_N_Arguments (N : Nat) is |
| begin |
| if Arg_Count < N then |
| Error_Pragma ("too few arguments for pragma%"); |
| end if; |
| end Check_At_Least_N_Arguments; |
| |
| ------------------------------- |
| -- Check_At_Most_N_Arguments -- |
| ------------------------------- |
| |
| procedure Check_At_Most_N_Arguments (N : Nat) is |
| Arg : Node_Id; |
| |
| begin |
| if Arg_Count > N then |
| Arg := Arg1; |
| |
| for J in 1 .. N loop |
| Next (Arg); |
| Error_Pragma_Arg ("too many arguments for pragma%", Arg); |
| end loop; |
| end if; |
| end Check_At_Most_N_Arguments; |
| |
| ------------------------- |
| -- Check_First_Subtype -- |
| ------------------------- |
| |
| procedure Check_First_Subtype (Arg : Node_Id) is |
| Argx : constant Node_Id := Get_Pragma_Arg (Arg); |
| |
| begin |
| if not Is_First_Subtype (Entity (Argx)) then |
| Error_Pragma_Arg |
| ("pragma% cannot apply to subtype", Argx); |
| end if; |
| end Check_First_Subtype; |
| |
| --------------------------- |
| -- Check_In_Main_Program -- |
| --------------------------- |
| |
| procedure Check_In_Main_Program is |
| P : constant Node_Id := Parent (N); |
| |
| begin |
| -- Must be at in subprogram body |
| |
| if Nkind (P) /= N_Subprogram_Body then |
| Error_Pragma ("% pragma allowed only in subprogram"); |
| |
| -- Otherwise warn if obviously not main program |
| |
| elsif Present (Parameter_Specifications (Specification (P))) |
| or else not Is_Library_Level_Entity (Defining_Entity (P)) |
| then |
| Error_Msg_Name_1 := Chars (N); |
| Error_Msg_N |
| ("?pragma% is only effective in main program", N); |
| end if; |
| end Check_In_Main_Program; |
| |
| --------------------------------------- |
| -- Check_Interrupt_Or_Attach_Handler -- |
| --------------------------------------- |
| |
| procedure Check_Interrupt_Or_Attach_Handler is |
| Arg1_X : constant Node_Id := Expression (Arg1); |
| |
| begin |
| Analyze (Arg1_X); |
| |
| if not Is_Entity_Name (Arg1_X) then |
| Error_Pragma_Arg |
| ("argument of pragma% must be entity name", Arg1); |
| |
| elsif Prag_Id = Pragma_Interrupt_Handler then |
| Check_Restriction (No_Dynamic_Interrupts, N); |
| end if; |
| |
| declare |
| Prot_Proc : Entity_Id := Empty; |
| Prot_Type : Entity_Id; |
| Found : Boolean := False; |
| |
| begin |
| if not Is_Overloaded (Arg1_X) then |
| Prot_Proc := Entity (Arg1_X); |
| |
| else |
| declare |
| It : Interp; |
| Index : Interp_Index; |
| |
| begin |
| Get_First_Interp (Arg1_X, Index, It); |
| while Present (It.Nam) loop |
| Prot_Proc := It.Nam; |
| |
| if Ekind (Prot_Proc) = E_Procedure |
| and then No (First_Formal (Prot_Proc)) |
| then |
| if not Found then |
| Found := True; |
| Set_Entity (Arg1_X, Prot_Proc); |
| Set_Is_Overloaded (Arg1_X, False); |
| else |
| Error_Pragma_Arg |
| ("ambiguous handler name for pragma% ", Arg1); |
| end if; |
| end if; |
| |
| Get_Next_Interp (Index, It); |
| end loop; |
| |
| if not Found then |
| Error_Pragma_Arg |
| ("argument of pragma% must be parameterless procedure", |
| Arg1); |
| else |
| Prot_Proc := Entity (Arg1_X); |
| end if; |
| end; |
| end if; |
| |
| Prot_Type := Scope (Prot_Proc); |
| |
| if Ekind (Prot_Proc) /= E_Procedure |
| or else Ekind (Prot_Type) /= E_Protected_Type |
| then |
| Error_Pragma_Arg |
| ("argument of pragma% must be protected procedure", |
| Arg1); |
| end if; |
| |
| if not Is_Library_Level_Entity (Prot_Type) then |
| Error_Pragma_Arg |
| ("pragma% requires library level entity", Arg1); |
| end if; |
| |
| if Present (First_Formal (Prot_Proc)) then |
| Error_Pragma_Arg |
| ("argument of pragma% must be parameterless procedure", |
| Arg1); |
| end if; |
| |
| if Parent (N) /= |
| Protected_Definition (Parent (Prot_Type)) |
| then |
| Error_Pragma ("pragma% must be in protected definition"); |
| end if; |
| |
| end; |
| end Check_Interrupt_Or_Attach_Handler; |
| |
| ------------------------------------------- |
| -- Check_Is_In_Decl_Part_Or_Package_Spec -- |
| ------------------------------------------- |
| |
| procedure Check_Is_In_Decl_Part_Or_Package_Spec is |
| P : Node_Id; |
| |
| begin |
| P := Parent (N); |
| loop |
| if No (P) then |
| exit; |
| |
| elsif Nkind (P) = N_Handled_Sequence_Of_Statements then |
| exit; |
| |
| elsif Nkind (P) = N_Package_Specification then |
| return; |
| |
| elsif Nkind (P) = N_Block_Statement then |
| return; |
| |
| -- Note: the following tests seem a little peculiar, because |
| -- they test for bodies, but if we were in the statement part |
| -- of the body, we would already have hit the handled statement |
| -- sequence, so the only way we get here is by being in the |
| -- declarative part of the body. |
| |
| elsif Nkind (P) = N_Subprogram_Body |
| or else Nkind (P) = N_Package_Body |
| or else Nkind (P) = N_Task_Body |
| or else Nkind (P) = N_Entry_Body |
| then |
| return; |
| end if; |
| |
| P := Parent (P); |
| end loop; |
| |
| Error_Pragma ("pragma% is not in declarative part or package spec"); |
| |
| end Check_Is_In_Decl_Part_Or_Package_Spec; |
| |
| ------------------------- |
| -- Check_No_Identifier -- |
| ------------------------- |
| |
| procedure Check_No_Identifier (Arg : Node_Id) is |
| begin |
| if Chars (Arg) /= No_Name then |
| Error_Pragma_Arg_Ident |
| ("pragma% does not permit identifier& here", Arg); |
| end if; |
| end Check_No_Identifier; |
| |
| -------------------------- |
| -- Check_No_Identifiers -- |
| -------------------------- |
| |
| procedure Check_No_Identifiers is |
| Arg_Node : Node_Id; |
| |
| begin |
| if Arg_Count > 0 then |
| Arg_Node := Arg1; |
| |
| while Present (Arg_Node) loop |
| Check_No_Identifier (Arg_Node); |
| Next (Arg_Node); |
| end loop; |
| end if; |
| end Check_No_Identifiers; |
| |
| ----------------------------------- |
| -- Check_Non_Overloaded_Function -- |
| ----------------------------------- |
| |
| procedure Check_Non_Overloaded_Function (Arg : Node_Id) is |
| Ent : Entity_Id; |
| |
| begin |
| Check_Arg_Is_Local_Name (Arg); |
| Ent := Entity (Expression (Arg)); |
| |
| if Present (Homonym (Ent)) |
| and then Scope (Homonym (Ent)) = Current_Scope |
| then |
| Error_Pragma_Arg |
| ("argument for pragma% may not be overloaded", Arg); |
| end if; |
| |
| if Ekind (Ent) /= E_Function |
| or else No (First_Formal (Ent)) |
| or else Present (Next_Formal (First_Formal (Ent))) |
| then |
| Error_Pragma_Arg |
| ("argument for pragma% must be function of one argument", Arg); |
| end if; |
| end Check_Non_Overloaded_Function; |
| |
| ------------------------------- |
| -- Check_Optional_Identifier -- |
| ------------------------------- |
| |
| procedure Check_Optional_Identifier (Arg : Node_Id; Id : Name_Id) is |
| begin |
| if Present (Arg) and then Chars (Arg) /= No_Name then |
| if Chars (Arg) /= Id then |
| Error_Msg_Name_1 := Chars (N); |
| Error_Msg_Name_2 := Id; |
| Error_Msg_N ("pragma% argument expects identifier%", Arg); |
| raise Pragma_Exit; |
| end if; |
| end if; |
| end Check_Optional_Identifier; |
| |
| procedure Check_Optional_Identifier (Arg : Node_Id; Id : String) is |
| begin |
| Name_Buffer (1 .. Id'Length) := Id; |
| Name_Len := Id'Length; |
| Check_Optional_Identifier (Arg, Name_Find); |
| end Check_Optional_Identifier; |
| |
| ----------------------------- |
| -- Check_Static_Constraint -- |
| ----------------------------- |
| |
| -- Note: for convenience in writing this procedure, in addition to |
| -- the officially (i.e. by spec) allowed argument which is always |
| -- a constraint, it also allows ranges and discriminant associations. |
| |
| procedure Check_Static_Constraint (Constr : Node_Id) is |
| |
| -------------------- |
| -- Require_Static -- |
| -------------------- |
| |
| procedure Require_Static (E : Node_Id); |
| -- Require given expression to be static expression |
| |
| procedure Require_Static (E : Node_Id) is |
| begin |
| if not Is_OK_Static_Expression (E) then |
| Error_Msg_N |
| ("non-static constraint not allowed in Unchecked_Union", E); |
| raise Pragma_Exit; |
| end if; |
| end Require_Static; |
| |
| -- Start of processing for Check_Static_Constraint |
| |
| begin |
| case Nkind (Constr) is |
| when N_Discriminant_Association => |
| Require_Static (Expression (Constr)); |
| |
| when N_Range => |
| Require_Static (Low_Bound (Constr)); |
| Require_Static (High_Bound (Constr)); |
| |
| when N_Attribute_Reference => |
| Require_Static (Type_Low_Bound (Etype (Prefix (Constr)))); |
| Require_Static (Type_High_Bound (Etype (Prefix (Constr)))); |
| |
| when N_Range_Constraint => |
| Check_Static_Constraint (Range_Expression (Constr)); |
| |
| when N_Index_Or_Discriminant_Constraint => |
| declare |
| IDC : Entity_Id := First (Constraints (Constr)); |
| |
| begin |
| while Present (IDC) loop |
| Check_Static_Constraint (IDC); |
| Next (IDC); |
| end loop; |
| end; |
| |
| when others => |
| null; |
| end case; |
| end Check_Static_Constraint; |
| |
| -------------------------------------- |
| -- Check_Valid_Configuration_Pragma -- |
| -------------------------------------- |
| |
| -- A configuration pragma must appear in the context clause of |
| -- a compilation unit, at the start of the list (i.e. only other |
| -- pragmas may precede it). |
| |
| procedure Check_Valid_Configuration_Pragma is |
| begin |
| if not Is_Configuration_Pragma then |
| Error_Pragma ("incorrect placement for configuration pragma%"); |
| end if; |
| end Check_Valid_Configuration_Pragma; |
| |
| ------------------------------------- |
| -- Check_Valid_Library_Unit_Pragma -- |
| ------------------------------------- |
| |
| procedure Check_Valid_Library_Unit_Pragma is |
| Plist : List_Id; |
| Parent_Node : Node_Id; |
| Unit_Name : Entity_Id; |
| Valid : Boolean := True; |
| Unit_Kind : Node_Kind; |
| Unit_Node : Node_Id; |
| Sindex : Source_File_Index; |
| |
| begin |
| if not Is_List_Member (N) then |
| Pragma_Misplaced; |
| Valid := False; |
| |
| else |
| Plist := List_Containing (N); |
| Parent_Node := Parent (Plist); |
| |
| if Parent_Node = Empty then |
| Pragma_Misplaced; |
| |
| -- Case of pragma appearing after a compilation unit. In this |
| -- case it must have an argument with the corresponding name |
| -- and must be part of the following pragmas of its parent. |
| |
| elsif Nkind (Parent_Node) = N_Compilation_Unit_Aux then |
| if Plist /= Pragmas_After (Parent_Node) then |
| Pragma_Misplaced; |
| |
| elsif Arg_Count = 0 then |
| Error_Pragma |
| ("argument required if outside compilation unit"); |
| |
| else |
| Check_No_Identifiers; |
| Check_Arg_Count (1); |
| Unit_Node := Unit (Parent (Parent_Node)); |
| Unit_Kind := Nkind (Unit_Node); |
| |
| Analyze (Expression (Arg1)); |
| |
| if Unit_Kind = N_Generic_Subprogram_Declaration |
| or else Unit_Kind = N_Subprogram_Declaration |
| then |
| Unit_Name := Defining_Entity (Unit_Node); |
| |
| elsif Unit_Kind = N_Function_Instantiation |
| or else Unit_Kind = N_Package_Instantiation |
| or else Unit_Kind = N_Procedure_Instantiation |
| then |
| Unit_Name := Defining_Entity (Unit_Node); |
| |
| else |
| Unit_Name := Cunit_Entity (Current_Sem_Unit); |
| end if; |
| |
| if Chars (Unit_Name) /= |
| Chars (Entity (Expression (Arg1))) |
| then |
| Error_Pragma_Arg |
| ("pragma% argument is not current unit name", Arg1); |
| end if; |
| |
| if Ekind (Unit_Name) = E_Package |
| and then Present (Renamed_Entity (Unit_Name)) |
| then |
| Error_Pragma ("pragma% not allowed for renamed package"); |
| end if; |
| end if; |
| |
| -- Pragma appears other than after a compilation unit |
| |
| else |
| -- Here we check for the generic instantiation case and also |
| -- for the case of processing a generic formal package. We |
| -- detect these cases by noting that the Sloc on the node |
| -- does not belong to the current compilation unit. |
| |
| Sindex := Source_Index (Current_Sem_Unit); |
| |
| if Loc not in Source_First (Sindex) .. Source_Last (Sindex) then |
| Rewrite (N, Make_Null_Statement (Loc)); |
| return; |
| |
| -- If before first declaration, the pragma applies to the |
| -- enclosing unit, and the name if present must be this name. |
| |
| elsif Is_Before_First_Decl (N, Plist) then |
| Unit_Node := Unit_Declaration_Node (Current_Scope); |
| Unit_Kind := Nkind (Unit_Node); |
| |
| if Nkind (Parent (Unit_Node)) /= N_Compilation_Unit then |
| Pragma_Misplaced; |
| |
| elsif Unit_Kind = N_Subprogram_Body |
| and then not Acts_As_Spec (Unit_Node) |
| then |
| Pragma_Misplaced; |
| |
| elsif Nkind (Parent_Node) = N_Package_Body then |
| Pragma_Misplaced; |
| |
| elsif Nkind (Parent_Node) = N_Package_Specification |
| and then Plist = Private_Declarations (Parent_Node) |
| then |
| Pragma_Misplaced; |
| |
| elsif (Nkind (Parent_Node) = N_Generic_Package_Declaration |
| or else Nkind (Parent_Node) |
| = N_Generic_Subprogram_Declaration) |
| and then Plist = Generic_Formal_Declarations (Parent_Node) |
| then |
| Pragma_Misplaced; |
| |
| elsif Arg_Count > 0 then |
| Analyze (Expression (Arg1)); |
| |
| if Entity (Expression (Arg1)) /= Current_Scope then |
| Error_Pragma_Arg |
| ("name in pragma% must be enclosing unit", Arg1); |
| end if; |
| |
| -- It is legal to have no argument in this context |
| |
| else |
| return; |
| end if; |
| |
| -- Error if not before first declaration. This is because a |
| -- library unit pragma argument must be the name of a library |
| -- unit (RM 10.1.5(7)), but the only names permitted in this |
| -- context are (RM 10.1.5(6)) names of subprogram declarations, |
| -- generic subprogram declarations or generic instantiations. |
| |
| else |
| Error_Pragma |
| ("pragma% misplaced, must be before first declaration"); |
| end if; |
| end if; |
| end if; |
| |
| end Check_Valid_Library_Unit_Pragma; |
| |
| ------------------ |
| -- Error_Pragma -- |
| ------------------ |
| |
| procedure Error_Pragma (Msg : String) is |
| begin |
| Error_Msg_Name_1 := Chars (N); |
| Error_Msg_N (Msg, N); |
| raise Pragma_Exit; |
| end Error_Pragma; |
| |
| ---------------------- |
| -- Error_Pragma_Arg -- |
| ---------------------- |
| |
| procedure Error_Pragma_Arg (Msg : String; Arg : Node_Id) is |
| begin |
| Error_Msg_Name_1 := Chars (N); |
| Error_Msg_N (Msg, Get_Pragma_Arg (Arg)); |
| raise Pragma_Exit; |
| end Error_Pragma_Arg; |
| |
| procedure Error_Pragma_Arg (Msg1, Msg2 : String; Arg : Node_Id) is |
| begin |
| Error_Msg_Name_1 := Chars (N); |
| Error_Msg_N (Msg1, Get_Pragma_Arg (Arg)); |
| Error_Pragma_Arg (Msg2, Arg); |
| end Error_Pragma_Arg; |
| |
| ---------------------------- |
| -- Error_Pragma_Arg_Ident -- |
| ---------------------------- |
| |
| procedure Error_Pragma_Arg_Ident (Msg : String; Arg : Node_Id) is |
| begin |
| Error_Msg_Name_1 := Chars (N); |
| Error_Msg_N (Msg, Arg); |
| raise Pragma_Exit; |
| end Error_Pragma_Arg_Ident; |
| |
| ------------------------ |
| -- Find_Lib_Unit_Name -- |
| ------------------------ |
| |
| function Find_Lib_Unit_Name return Entity_Id is |
| begin |
| -- Return inner compilation unit entity, for case of nested |
| -- categorization pragmas. This happens in generic unit. |
| |
| if Nkind (Parent (N)) = N_Package_Specification |
| and then Defining_Entity (Parent (N)) /= Current_Scope |
| then |
| return Defining_Entity (Parent (N)); |
| |
| else |
| return Current_Scope; |
| end if; |
| end Find_Lib_Unit_Name; |
| |
| ---------------------------- |
| -- Find_Program_Unit_Name -- |
| ---------------------------- |
| |
| procedure Find_Program_Unit_Name (Id : Node_Id) is |
| Unit_Name : Entity_Id; |
| Unit_Kind : Node_Kind; |
| P : constant Node_Id := Parent (N); |
| |
| begin |
| if Nkind (P) = N_Compilation_Unit then |
| Unit_Kind := Nkind (Unit (P)); |
| |
| if Unit_Kind = N_Subprogram_Declaration |
| or else Unit_Kind = N_Package_Declaration |
| or else Unit_Kind in N_Generic_Declaration |
| then |
| Unit_Name := Defining_Entity (Unit (P)); |
| |
| if Chars (Id) = Chars (Unit_Name) then |
| Set_Entity (Id, Unit_Name); |
| Set_Etype (Id, Etype (Unit_Name)); |
| else |
| Set_Etype (Id, Any_Type); |
| Error_Pragma |
| ("cannot find program unit referenced by pragma%"); |
| end if; |
| |
| else |
| Set_Etype (Id, Any_Type); |
| Error_Pragma ("pragma% inapplicable to this unit"); |
| end if; |
| |
| else |
| Analyze (Id); |
| end if; |
| |
| end Find_Program_Unit_Name; |
| |
| ------------------------- |
| -- Gather_Associations -- |
| ------------------------- |
| |
| procedure Gather_Associations |
| (Names : Name_List; |
| Args : out Args_List) |
| is |
| Arg : Node_Id; |
| |
| begin |
| -- Initialize all parameters to Empty |
| |
| for J in Args'Range loop |
| Args (J) := Empty; |
| end loop; |
| |
| -- That's all we have to do if there are no argument associations |
| |
| if No (Pragma_Argument_Associations (N)) then |
| return; |
| end if; |
| |
| -- Otherwise first deal with any positional parameters present |
| |
| Arg := First (Pragma_Argument_Associations (N)); |
| |
| for Index in Args'Range loop |
| exit when No (Arg) or else Chars (Arg) /= No_Name; |
| Args (Index) := Expression (Arg); |
| Next (Arg); |
| end loop; |
| |
| -- Positional parameters all processed, if any left, then we |
| -- have too many positional parameters. |
| |
| if Present (Arg) and then Chars (Arg) = No_Name then |
| Error_Pragma_Arg |
| ("too many positional associations for pragma%", Arg); |
| end if; |
| |
| -- Process named parameters if any are present |
| |
| while Present (Arg) loop |
| if Chars (Arg) = No_Name then |
| Error_Pragma_Arg |
| ("positional association cannot follow named association", |
| Arg); |
| |
| else |
| for Index in Names'Range loop |
| if Names (Index) = Chars (Arg) then |
| if Present (Args (Index)) then |
| Error_Pragma_Arg |
| ("duplicate argument association for pragma%", Arg); |
| else |
| Args (Index) := Expression (Arg); |
| exit; |
| end if; |
| end if; |
| |
| if Index = Names'Last then |
| Error_Pragma_Arg_Ident |
| ("pragma% does not allow & argument", Arg); |
| end if; |
| end loop; |
| end if; |
| |
| Next (Arg); |
| end loop; |
| end Gather_Associations; |
| |
| -------------------- |
| -- Get_Pragma_Arg -- |
| -------------------- |
| |
| function Get_Pragma_Arg (Arg : Node_Id) return Node_Id is |
| begin |
| if Nkind (Arg) = N_Pragma_Argument_Association then |
| return Expression (Arg); |
| else |
| return Arg; |
| end if; |
| end Get_Pragma_Arg; |
| |
| ----------------- |
| -- GNAT_Pragma -- |
| ----------------- |
| |
| procedure GNAT_Pragma is |
| begin |
| Check_Restriction (No_Implementation_Pragmas, N); |
| end GNAT_Pragma; |
| |
| -------------------------- |
| -- Is_Before_First_Decl -- |
| -------------------------- |
| |
| function Is_Before_First_Decl |
| (Pragma_Node : Node_Id; |
| Decls : List_Id) |
| return Boolean |
| is |
| Item : Node_Id := First (Decls); |
| |
| begin |
| -- Only other pragmas can come before this pragma |
| |
| loop |
| if No (Item) or else Nkind (Item) /= N_Pragma then |
| return False; |
| |
| elsif Item = Pragma_Node then |
| return True; |
| end if; |
| |
| Next (Item); |
| end loop; |
| |
| end Is_Before_First_Decl; |
| |
| ----------------------------- |
| -- Is_Configuration_Pragma -- |
| ----------------------------- |
| |
| -- A configuration pragma must appear in the context clause of |
| -- a compilation unit, at the start of the list (i.e. only other |
| -- pragmas may precede it). |
| |
| function Is_Configuration_Pragma return Boolean is |
| Lis : constant List_Id := List_Containing (N); |
| Par : constant Node_Id := Parent (N); |
| Prg : Node_Id; |
| |
| begin |
| -- If no parent, then we are in the configuration pragma file, |
| -- so the placement is definitely appropriate. |
| |
| if No (Par) then |
| return True; |
| |
| -- Otherwise we must be in the context clause of a compilation unit |
| -- and the only thing allowed before us in the context list is more |
| -- configuration pragmas. |
| |
| elsif Nkind (Par) = N_Compilation_Unit |
| and then Context_Items (Par) = Lis |
| then |
| Prg := First (Lis); |
| |
| loop |
| if Prg = N then |
| return True; |
| elsif Nkind (Prg) /= N_Pragma then |
| return False; |
| end if; |
| |
| Next (Prg); |
| end loop; |
| |
| else |
| return False; |
| end if; |
| |
| end Is_Configuration_Pragma; |
| |
| ---------------------- |
| -- Pragma_Misplaced -- |
| ---------------------- |
| |
| procedure Pragma_Misplaced is |
| begin |
| Error_Pragma ("incorrect placement of pragma%"); |
| end Pragma_Misplaced; |
| |
| ------------------------------------ |
| -- Process Atomic_Shared_Volatile -- |
| ------------------------------------ |
| |
| procedure Process_Atomic_Shared_Volatile is |
| E_Id : Node_Id; |
| E : Entity_Id; |
| D : Node_Id; |
| K : Node_Kind; |
| |
| begin |
| GNAT_Pragma; |
| Check_Ada_83_Warning; |
| Check_No_Identifiers; |
| Check_Arg_Count (1); |
| Check_Arg_Is_Local_Name (Arg1); |
| E_Id := Expression (Arg1); |
| |
| if Etype (E_Id) = Any_Type then |
| return; |
| end if; |
| |
| E := Entity (E_Id); |
| D := Declaration_Node (E); |
| K := Nkind (D); |
| |
| if Is_Type (E) then |
| if Rep_Item_Too_Early (E, N) |
| or else |
| Rep_Item_Too_Late (E, N) |
| then |
| return; |
| else |
| Check_First_Subtype (Arg1); |
| end if; |
| |
| if Prag_Id /= Pragma_Volatile then |
| Set_Is_Atomic (E); |
| Set_Is_Atomic (Underlying_Type (E)); |
| end if; |
| |
| Set_Is_Volatile (E); |
| Set_Is_Volatile (Underlying_Type (E)); |
| |
| elsif K = N_Object_Declaration |
| or else (K = N_Component_Declaration |
| and then Original_Record_Component (E) = E) |
| then |
| if Rep_Item_Too_Late (E, N) then |
| return; |
| end if; |
| |
| if Prag_Id /= Pragma_Volatile then |
| Set_Is_Atomic (E); |
| end if; |
| |
| Set_Is_Volatile (E); |
| |
| else |
| Error_Pragma_Arg |
| ("inappropriate entity for pragma%", Arg1); |
| end if; |
| end Process_Atomic_Shared_Volatile; |
| |
| ------------------------ |
| -- Process_Convention -- |
| ------------------------ |
| |
| procedure Process_Convention |
| (C : out Convention_Id; |
| E : out Entity_Id) |
| is |
| Id : Node_Id; |
| E1 : Entity_Id; |
| Comp_Unit : Unit_Number_Type; |
| Cname : Name_Id; |
| |
| procedure Set_Convention_From_Pragma (E : Entity_Id); |
| -- Set convention in entity E, and also flag that the entity has a |
| -- convention pragma. If entity is for a private or incomplete type, |
| -- also set convention and flag on underlying type. This procedure |
| -- also deals with the special case of C_Pass_By_Copy convention. |
| |
| -------------------------------- |
| -- Set_Convention_From_Pragma -- |
| -------------------------------- |
| |
| procedure Set_Convention_From_Pragma (E : Entity_Id) is |
| begin |
| Set_Convention (E, C); |
| Set_Has_Convention_Pragma (E); |
| |
| if Is_Incomplete_Or_Private_Type (E) then |
| Set_Convention (Underlying_Type (E), C); |
| Set_Has_Convention_Pragma (Underlying_Type (E), True); |
| end if; |
| |
| -- A class-wide type should inherit the convention of |
| -- the specific root type (although this isn't specified |
| -- clearly by the RM). |
| |
| if Is_Type (E) and then Present (Class_Wide_Type (E)) then |
| Set_Convention (Class_Wide_Type (E), C); |
| end if; |
| |
| -- If the entity is a record type, then check for special case |
| -- of C_Pass_By_Copy, which is treated the same as C except that |
| -- the special record flag is set. This convention is also only |
| -- permitted on record types (see AI95-00131). |
| |
| if Cname = Name_C_Pass_By_Copy then |
| if Is_Record_Type (E) then |
| Set_C_Pass_By_Copy (Base_Type (E)); |
| elsif Is_Incomplete_Or_Private_Type (E) |
| and then Is_Record_Type (Underlying_Type (E)) |
| then |
| Set_C_Pass_By_Copy (Base_Type (Underlying_Type (E))); |
| else |
| Error_Pragma_Arg |
| ("C_Pass_By_Copy convention allowed only for record type", |
| Arg2); |
| end if; |
| end if; |
| |
| -- If the entity is a derived boolean type, check for the |
| -- special case of convention C, C++, or Fortran, where we |
| -- consider any nonzero value to represent true. |
| |
| if Is_Discrete_Type (E) |
| and then Root_Type (Etype (E)) = Standard_Boolean |
| and then |
| (C = Convention_C |
| or else |
| C = Convention_CPP |
| or else |
| C = Convention_Fortran) |
| then |
| Set_Nonzero_Is_True (Base_Type (E)); |
| end if; |
| end Set_Convention_From_Pragma; |
| |
| -- Start of processing for Process_Convention |
| |
| begin |
| Check_At_Least_N_Arguments (2); |
| Check_Arg_Is_Identifier (Arg1); |
| Check_Optional_Identifier (Arg1, Name_Convention); |
| Cname := Chars (Expression (Arg1)); |
| |
| -- C_Pass_By_Copy is treated as a synonym for convention C |
| -- (this is tested again below to set the critical flag) |
| |
| if Cname = Name_C_Pass_By_Copy then |
| C := Convention_C; |
| |
| -- Otherwise we must have something in the standard convention list |
| |
| elsif Is_Convention_Name (Cname) then |
| C := Get_Convention_Id (Chars (Expression (Arg1))); |
| |
| -- In DEC VMS, it seems that there is an undocumented feature |
| -- that any unrecognized convention is treated as the default, |
| -- which for us is convention C. It does not seem so terrible |
| -- to do this unconditionally, silently in the VMS case, and |
| -- with a warning in the non-VMS case. |
| |
| else |
| if not OpenVMS_On_Target then |
| Error_Msg_N |
| ("?unrecognized convention name, C assumed", |
| Expression (Arg1)); |
| end if; |
| |
| C := Convention_C; |
| end if; |
| |
| Check_Arg_Is_Local_Name (Arg2); |
| Check_Optional_Identifier (Arg2, Name_Entity); |
| |
| Id := Expression (Arg2); |
| Analyze (Id); |
| |
| if not Is_Entity_Name (Id) then |
| Error_Pragma_Arg ("entity name required", Arg2); |
| end if; |
| |
| E := Entity (Id); |
| |
| -- Go to renamed subprogram if present, since convention applies |
| -- to the actual renamed entity, not to the renaming entity. |
| |
| if Is_Subprogram (E) |
| and then Present (Alias (E)) |
| and then Nkind (Parent (Declaration_Node (E))) = |
| N_Subprogram_Renaming_Declaration |
| then |
| E := Alias (E); |
| end if; |
| |
| -- Check that we not applying this to a specless body |
| |
| if Is_Subprogram (E) |
| and then Nkind (Parent (Declaration_Node (E))) = N_Subprogram_Body |
| then |
| Error_Pragma |
| ("pragma% requires separate spec and must come before body"); |
| end if; |
| |
| -- Check that we are not applying this to a named constant |
| |
| if Ekind (E) = E_Named_Integer |
| or else |
| Ekind (E) = E_Named_Real |
| then |
| Error_Msg_Name_1 := Chars (N); |
| Error_Msg_N |
| ("cannot apply pragma% to named constant!", |
| Get_Pragma_Arg (Arg2)); |
| Error_Pragma_Arg |
| ("\supply appropriate type for&!", Arg2); |
| end if; |
| |
| if Etype (E) = Any_Type |
| or else Rep_Item_Too_Early (E, N) |
| then |
| raise Pragma_Exit; |
| else |
| E := Underlying_Type (E); |
| end if; |
| |
| if Rep_Item_Too_Late (E, N) then |
| raise Pragma_Exit; |
| end if; |
| |
| if Has_Convention_Pragma (E) then |
| Error_Pragma_Arg |
| ("at most one Convention/Export/Import pragma is allowed", Arg2); |
| |
| elsif Convention (E) = Convention_Protected |
| or else Ekind (Scope (E)) = E_Protected_Type |
| then |
| Error_Pragma_Arg |
| ("a protected operation cannot be given a different convention", |
| Arg2); |
| end if; |
| |
| -- For Intrinsic, a subprogram is required |
| |
| if C = Convention_Intrinsic |
| and then not Is_Subprogram (E) |
| and then not Is_Generic_Subprogram (E) |
| then |
| Error_Pragma_Arg |
| ("second argument of pragma% must be a subprogram", Arg2); |
| end if; |
| |
| -- For Stdcall, a subprogram, variable or subprogram type is required |
| |
| if C = Convention_Stdcall |
| and then not Is_Subprogram (E) |
| and then not Is_Generic_Subprogram (E) |
| and then Ekind (E) /= E_Variable |
| and then not |
| (Is_Access_Type (E) |
| and then Ekind (Designated_Type (E)) = E_Subprogram_Type) |
| then |
| Error_Pragma_Arg |
| ("second argument of pragma% must be subprogram (type)", |
| Arg2); |
| end if; |
| |
| if not Is_Subprogram (E) |
| and then not Is_Generic_Subprogram (E) |
| then |
| Set_Convention_From_Pragma (E); |
| |
| if Is_Type (E) then |
| |
| Check_First_Subtype (Arg2); |
| Set_Convention_From_Pragma (Base_Type (E)); |
| |
| -- For subprograms, we must set the convention on the |
| -- internally generated directly designated type as well. |
| |
| if Ekind (E) = E_Access_Subprogram_Type then |
| Set_Convention_From_Pragma (Directly_Designated_Type (E)); |
| end if; |
| end if; |
| |
| -- For the subprogram case, set proper convention for all homonyms |
| -- in same compilation unit. |
| -- Is the test of compilation unit really necessary ??? |
| -- What about subprogram renamings here??? |
| |
| else |
| Comp_Unit := Get_Source_Unit (E); |
| Set_Convention_From_Pragma (E); |
| |
| E1 := E; |
| loop |
| E1 := Homonym (E1); |
| exit when No (E1) or else Scope (E1) /= Current_Scope; |
| |
| -- Note: below we are missing a check for Rep_Item_Too_Late. |
| -- That is deliberate, we cannot chain the rep item on more |
| -- than one Rep_Item chain, to be fixed later ??? |
| |
| if Comp_Unit = Get_Source_Unit (E1) then |
| Set_Convention_From_Pragma (E1); |
| end if; |
| end loop; |
| end if; |
| |
| end Process_Convention; |
| |
| ----------------------------------------------------- |
| -- Process_Extended_Import_Export_Exception_Pragma -- |
| ----------------------------------------------------- |
| |
| procedure Process_Extended_Import_Export_Exception_Pragma |
| (Arg_Internal : Node_Id; |
| Arg_External : Node_Id; |
| Arg_Form : Node_Id; |
| Arg_Code : Node_Id) |
| is |
| Def_Id : Entity_Id; |
| Code_Val : Uint; |
| |
| begin |
| Process_Extended_Import_Export_Internal_Arg (Arg_Internal); |
| Def_Id := Entity (Arg_Internal); |
| |
| if Ekind (Def_Id) /= E_Exception then |
| Error_Pragma_Arg |
| ("pragma% must refer to declared exception", Arg_Internal); |
| end if; |
| |
| Set_Extended_Import_Export_External_Name (Def_Id, Arg_External); |
| |
| if Present (Arg_Form) then |
| Check_Arg_Is_One_Of (Arg_Form, Name_Ada, Name_VMS); |
| end if; |
| |
| if Present (Arg_Form) |
| and then Chars (Arg_Form) = Name_Ada |
| then |
| null; |
| else |
| Set_Is_VMS_Exception (Def_Id); |
| Set_Exception_Code (Def_Id, No_Uint); |
| end if; |
| |
| if Present (Arg_Code) then |
| if not Is_VMS_Exception (Def_Id) then |
| Error_Pragma_Arg |
| ("Code option for pragma% not allowed for Ada case", |
| Arg_Code); |
| end if; |
| |
| Check_Arg_Is_Static_Expression (Arg_Code, Any_Integer); |
| Code_Val := Expr_Value (Arg_Code); |
| |
| if not UI_Is_In_Int_Range (Code_Val) then |
| Error_Pragma_Arg |
| ("Code option for pragma% must be in 32-bit range", |
| Arg_Code); |
| |
| else |
| Set_Exception_Code (Def_Id, Code_Val); |
| end if; |
| end if; |
| |
| end Process_Extended_Import_Export_Exception_Pragma; |
| |
| ------------------------------------------------- |
| -- Process_Extended_Import_Export_Internal_Arg -- |
| ------------------------------------------------- |
| |
| procedure Process_Extended_Import_Export_Internal_Arg |
| (Arg_Internal : Node_Id := Empty) |
| is |
| begin |
| GNAT_Pragma; |
| |
| if No (Arg_Internal) then |
| Error_Pragma ("Internal parameter required for pragma%"); |
| end if; |
| |
| if Nkind (Arg_Internal) = N_Identifier then |
| null; |
| |
| elsif Nkind (Arg_Internal) = N_Operator_Symbol |
| and then (Prag_Id = Pragma_Import_Function |
| or else |
| Prag_Id = Pragma_Export_Function) |
| then |
| null; |
| |
| else |
| Error_Pragma_Arg |
| ("wrong form for Internal parameter for pragma%", Arg_Internal); |
| end if; |
| |
| Check_Arg_Is_Local_Name (Arg_Internal); |
| |
| end Process_Extended_Import_Export_Internal_Arg; |
| |
| -------------------------------------------------- |
| -- Process_Extended_Import_Export_Object_Pragma -- |
| -------------------------------------------------- |
| |
| procedure Process_Extended_Import_Export_Object_Pragma |
| (Arg_Internal : Node_Id; |
| Arg_External : Node_Id; |
| Arg_Size : Node_Id) |
| is |
| Def_Id : Entity_Id; |
| |
| begin |
| Process_Extended_Import_Export_Internal_Arg (Arg_Internal); |
| Def_Id := Entity (Arg_Internal); |
| |
| if Ekind (Def_Id) /= E_Constant |
| and then Ekind (Def_Id) /= E_Variable |
| then |
| Error_Pragma_Arg |
| ("pragma% must designate an object", Arg_Internal); |
| end if; |
| |
| if Is_Psected (Def_Id) then |
| Error_Pragma_Arg |
| ("previous Psect_Object applies, pragma % not permitted", |
| Arg_Internal); |
| end if; |
| |
| if Rep_Item_Too_Late (Def_Id, N) then |
| raise Pragma_Exit; |
| end if; |
| |
| Set_Extended_Import_Export_External_Name (Def_Id, Arg_External); |
| |
| if Present (Arg_Size) |
| and then Nkind (Arg_Size) /= N_Identifier |
| and then Nkind (Arg_Size) /= N_String_Literal |
| then |
| Error_Pragma_Arg |
| ("pragma% Size argument must be identifier or string literal", |
| Arg_Size); |
| end if; |
| |
| -- Export_Object case |
| |
| if Prag_Id = Pragma_Export_Object then |
| |
| if not Is_Library_Level_Entity (Def_Id) then |
| Error_Pragma_Arg |
| ("argument for pragma% must be library level entity", |
| Arg_Internal); |
| end if; |
| |
| if Ekind (Current_Scope) = E_Generic_Package then |
| Error_Pragma ("pragma& cannot appear in a generic unit"); |
| end if; |
| |
| if not Size_Known_At_Compile_Time (Etype (Def_Id)) then |
| Error_Pragma_Arg |
| ("exported object must have compile time known size", |
| Arg_Internal); |
| end if; |
| |
| if Is_Exported (Def_Id) then |
| Error_Msg_N |
| ("?duplicate Export_Object pragma", N); |
| else |
| Set_Exported (Def_Id, Arg_Internal); |
| end if; |
| |
| -- Import_Object case |
| |
| else |
| if Is_Concurrent_Type (Etype (Def_Id)) then |
| Error_Pragma_Arg |
| ("cannot use pragma% for task/protected object", |
| Arg_Internal); |
| end if; |
| |
| if Ekind (Def_Id) = E_Constant then |
| Error_Pragma_Arg |
| ("cannot import a constant", Arg_Internal); |
| end if; |
| |
| if Has_Discriminants (Etype (Def_Id)) then |
| Error_Msg_N |
| ("imported value must be initialized?", Arg_Internal); |
| end if; |
| |
| if Is_Access_Type (Etype (Def_Id)) then |
| Error_Pragma_Arg |
| ("cannot import object of an access type?", Arg_Internal); |
| end if; |
| |
| if Is_Imported (Def_Id) then |
| Error_Msg_N |
| ("?duplicate Import_Object pragma", N); |
| else |
| Set_Imported (Def_Id); |
| end if; |
| end if; |
| |
| end Process_Extended_Import_Export_Object_Pragma; |
| |
| ------------------------------------------------------ |
| -- Process_Extended_Import_Export_Subprogram_Pragma -- |
| ------------------------------------------------------ |
| |
| procedure Process_Extended_Import_Export_Subprogram_Pragma |
| (Arg_Internal : Node_Id; |
| Arg_External : Node_Id; |
| Arg_Parameter_Types : Node_Id; |
| Arg_Result_Type : Node_Id := Empty; |
| Arg_Mechanism : Node_Id; |
| Arg_Result_Mechanism : Node_Id := Empty; |
| Arg_First_Optional_Parameter : Node_Id := Empty) |
| is |
| Ent : Entity_Id; |
| Def_Id : Entity_Id; |
| Hom_Id : Entity_Id; |
| Formal : Entity_Id; |
| Ambiguous : Boolean; |
| Match : Boolean; |
| Dval : Node_Id; |
| |
| function Same_Base_Type (Ptype, Formal : Entity_Id) return Boolean; |
| -- Determines if Ptype references the type of Formal. Note that |
| -- only the base types need to match according to the spec. |
| |
| function Same_Base_Type (Ptype, Formal : Entity_Id) return Boolean is |
| begin |
| Find_Type (Ptype); |
| |
| if not Is_Entity_Name (Ptype) |
| or else Entity (Ptype) = Any_Type |
| then |
| raise Pragma_Exit; |
| end if; |
| |
| return Base_Type (Entity (Ptype)) = Base_Type (Etype (Formal)); |
| end Same_Base_Type; |
| |
| -- Start of processing for |
| -- Process_Extended_Import_Export_Subprogram_Pragma |
| |
| begin |
| Process_Extended_Import_Export_Internal_Arg (Arg_Internal); |
| Hom_Id := Entity (Arg_Internal); |
| Ent := Empty; |
| Ambiguous := False; |
| |
| -- Loop through homonyms (overloadings) of Hom_Id |
| |
| while Present (Hom_Id) loop |
| Def_Id := Get_Base_Subprogram (Hom_Id); |
| |
| -- We need a subprogram in the current scope |
| |
| if not Is_Subprogram (Def_Id) |
| or else Scope (Def_Id) /= Current_Scope |
| then |
| null; |
| |
| else |
| Match := True; |
| |
| -- Pragma cannot apply to subprogram body |
| |
| if Is_Subprogram (Def_Id) |
| and then |
| Nkind (Parent |
| (Declaration_Node (Def_Id))) = N_Subprogram_Body |
| then |
| Error_Pragma |
| ("pragma% requires separate spec" |
| & " and must come before body"); |
| end if; |
| |
| -- Test result type if given, note that the result type |
| -- parameter can only be present for the function cases. |
| |
| if Present (Arg_Result_Type) |
| and then not Same_Base_Type (Arg_Result_Type, Def_Id) |
| then |
| Match := False; |
| |
| -- Test parameter types if given. Note that this parameter |
| -- has not been analyzed (and must not be, since it is |
| -- semantic nonsense), so we get it as the parser left it. |
| |
| elsif Present (Arg_Parameter_Types) then |
| Check_Matching_Types : declare |
| Formal : Entity_Id; |
| Ptype : Node_Id; |
| |
| begin |
| Formal := First_Formal (Def_Id); |
| |
| if Nkind (Arg_Parameter_Types) = N_Null then |
| if Present (Formal) then |
| Match := False; |
| end if; |
| |
| -- A list of one type, e.g. (List) is parsed as |
| -- a parenthesized expression. |
| |
| elsif Nkind (Arg_Parameter_Types) /= N_Aggregate |
| and then Paren_Count (Arg_Parameter_Types) = 1 |
| then |
| if No (Formal) |
| or else Present (Next_Formal (Formal)) |
| then |
| Match := False; |
| else |
| Match := |
| Same_Base_Type (Arg_Parameter_Types, Formal); |
| end if; |
| |
| -- A list of more than one type is parsed as a aggregate |
| |
| elsif Nkind (Arg_Parameter_Types) = N_Aggregate |
| and then Paren_Count (Arg_Parameter_Types) = 0 |
| then |
| Ptype := First (Expressions (Arg_Parameter_Types)); |
| |
| while Present (Ptype) or else Present (Formal) loop |
| if No (Ptype) |
| or else No (Formal) |
| or else not Same_Base_Type (Ptype, Formal) |
| then |
| Match := False; |
| exit; |
| else |
| Next_Formal (Formal); |
| Next (Ptype); |
| end if; |
| end loop; |
| |
| -- Anything else is of the wrong form |
| |
| else |
| Error_Pragma_Arg |
| ("wrong form for Parameter_Types parameter", |
| Arg_Parameter_Types); |
| end if; |
| end Check_Matching_Types; |
| end if; |
| |
| -- Match is now False if the entry we found did not match |
| -- either a supplied Parameter_Types or Result_Types argument |
| |
| if Match then |
| if No (Ent) then |
| Ent := Def_Id; |
| |
| -- Ambiguous case, the flag Ambiguous shows if we already |
| -- detected this and output the initial messages. |
| |
| else |
| if not Ambiguous then |
| Ambiguous := True; |
| Error_Msg_Name_1 := Chars (N); |
| Error_Msg_N |
| ("pragma% does not uniquely identify subprogram!", |
| N); |
| Error_Msg_Sloc := Sloc (Ent); |
| Error_Msg_N ("matching subprogram #!", N); |
| Ent := Empty; |
| end if; |
| |
| Error_Msg_Sloc := Sloc (Def_Id); |
| Error_Msg_N ("matching subprogram #!", N); |
| end if; |
| end if; |
| end if; |
| |
| Hom_Id := Homonym (Hom_Id); |
| end loop; |
| |
| -- See if we found an entry |
| |
| if No (Ent) then |
| if not Ambiguous then |
| if Is_Generic_Subprogram (Entity (Arg_Internal)) then |
| Error_Pragma |
| ("pragma% cannot be given for generic subprogram"); |
| |
| else |
| Error_Pragma |
| ("pragma% does not identify local subprogram"); |
| end if; |
| end if; |
| |
| return; |
| end if; |
| |
| -- Import pragmas must be be for imported entities |
| |
| if (Prag_Id = Pragma_Import_Function |
| or else |
| Prag_Id = Pragma_Import_Procedure |
| or else |
| Prag_Id = Pragma_Import_Valued_Procedure) |
| then |
| if not Is_Imported (Ent) then |
| Error_Pragma |
| ("pragma Import or Interface must precede pragma%"); |
| end if; |
| |
| -- For the Export cases, the pragma Export is sufficient to set |
| -- the entity as exported, if it is not exported already. We |
| -- leave the default Ada convention in this case. |
| |
| else |
| Set_Exported (Ent, Arg_Internal); |
| end if; |
| |
| -- Special processing for Valued_Procedure cases |
| |
| if Prag_Id = Pragma_Import_Valued_Procedure |
| or else |
| Prag_Id = Pragma_Export_Valued_Procedure |
| then |
| Formal := First_Formal (Ent); |
| |
| if No (Formal) then |
| Error_Pragma |
| ("at least one parameter required for pragma%"); |
| |
| elsif Ekind (Formal) /= E_Out_Parameter then |
| Error_Pragma |
| ("first parameter must have mode out for pragma%"); |
| |
| else |
| Set_Is_Valued_Procedure (Ent); |
| end if; |
| end if; |
| |
| Set_Extended_Import_Export_External_Name (Ent, Arg_External); |
| |
| -- Process Result_Mechanism argument if present. We have already |
| -- checked that this is only allowed for the function case. |
| |
| if Present (Arg_Result_Mechanism) then |
| Set_Mechanism_Value (Ent, Arg_Result_Mechanism); |
| end if; |
| |
| -- Process Mechanism parameter if present. Note that this parameter |
| -- is not analyzed, and must not be analyzed since it is semantic |
| -- nonsense, so we get it in exactly as the parser left it. |
| |
| if Present (Arg_Mechanism) then |
| |
| declare |
| Formal : Entity_Id; |
| Massoc : Node_Id; |
| Mname : Node_Id; |
| Choice : Node_Id; |
| |
| begin |
| -- A single mechanism association without a formal parameter |
| -- name is parsed as a parenthesized expression. All other |
| -- cases are parsed as aggregates, so we rewrite the single |
| -- parameter case as an aggregate for consistency. |
| |
| if Nkind (Arg_Mechanism) /= N_Aggregate |
| and then Paren_Count (Arg_Mechanism) = 1 |
| then |
| Rewrite (Arg_Mechanism, |
| Make_Aggregate (Sloc (Arg_Mechanism), |
| Expressions => New_List ( |
| Relocate_Node (Arg_Mechanism)))); |
| end if; |
| |
| -- Case of only mechanism name given, applies to all formals |
| |
| if Nkind (Arg_Mechanism) /= N_Aggregate then |
| Formal := First_Formal (Ent); |
| while Present (Formal) loop |
| Set_Mechanism_Value (Formal, Arg_Mechanism); |
| Next_Formal (Formal); |
| end loop; |
| |
| -- Case of list of mechanism associations given |
| |
| else |
| if Null_Record_Present (Arg_Mechanism) then |
| Error_Pragma_Arg |
| ("inappropriate form for Mechanism parameter", |
| Arg_Mechanism); |
| end if; |
| |
| -- Deal with positional ones first |
| |
| Formal := First_Formal (Ent); |
| if Present (Expressions (Arg_Mechanism)) then |
| Mname := First (Expressions (Arg_Mechanism)); |
| |
| while Present (Mname) loop |
| if No (Formal) then |
| Error_Pragma_Arg |
| ("too many mechanism associations", Mname); |
| end if; |
| |
| Set_Mechanism_Value (Formal, Mname); |
| Next_Formal (Formal); |
| Next (Mname); |
| end loop; |
| end if; |
| |
| -- Deal with named entries |
| |
| if Present (Component_Associations (Arg_Mechanism)) then |
| Massoc := First (Component_Associations (Arg_Mechanism)); |
| |
| while Present (Massoc) loop |
| Choice := First (Choices (Massoc)); |
| |
| if Nkind (Choice) /= N_Identifier |
| or else Present (Next (Choice)) |
| then |
| Error_Pragma_Arg |
| ("incorrect form for mechanism association", |
| Massoc); |
| end if; |
| |
| Formal := First_Formal (Ent); |
| loop |
| if No (Formal) then |
| Error_Pragma_Arg |
| ("parameter name & not present", Choice); |
| end if; |
| |
| if Chars (Choice) = Chars (Formal) then |
| Set_Mechanism_Value |
| (Formal, Expression (Massoc)); |
| exit; |
| end if; |
| |
| Next_Formal (Formal); |
| end loop; |
| |
| Next (Massoc); |
| end loop; |
| end if; |
| end if; |
| end; |
| end if; |
| |
| -- Process First_Optional_Parameter argument if present. We have |
| -- already checked that this is only allowed for the Import case. |
| |
| if Present (Arg_First_Optional_Parameter) then |
| if Nkind (Arg_First_Optional_Parameter) /= N_Identifier then |
| Error_Pragma_Arg |
| ("first optional parameter must be formal parameter name", |
| Arg_First_Optional_Parameter); |
| end if; |
| |
| Formal := First_Formal (Ent); |
| loop |
| if No (Formal) then |
| Error_Pragma_Arg |
| ("specified formal parameter& not found", |
| Arg_First_Optional_Parameter); |
| end if; |
| |
| exit when Chars (Formal) = |
| Chars (Arg_First_Optional_Parameter); |
| |
| Next_Formal (Formal); |
| end loop; |
| |
| Set_First_Optional_Parameter (Ent, Formal); |
| |
| -- Check specified and all remaining formals have right form |
| |
| while Present (Formal) loop |
| if Ekind (Formal) /= E_In_Parameter then |
| Error_Msg_NE |
| ("optional formal& is not of mode in!", |
| Arg_First_Optional_Parameter, Formal); |
| |
| else |
| Dval := Default_Value (Formal); |
| |
| if not Present (Dval) then |
| Error_Msg_NE |
| ("optional formal& does not have default value!", |
| Arg_First_Optional_Parameter, Formal); |
| |
| elsif Compile_Time_Known_Value_Or_Aggr (Dval) then |
| null; |
| |
| else |
| Error_Msg_NE |
| ("default value for optional formal& is non-static!", |
| Arg_First_Optional_Parameter, Formal); |
| end if; |
| end if; |
| |
| Set_Is_Optional_Parameter (Formal); |
| Next_Formal (Formal); |
| end loop; |
| end if; |
| |
| end Process_Extended_Import_Export_Subprogram_Pragma; |
| |
| -------------------------- |
| -- Process_Generic_List -- |
| -------------------------- |
| |
| procedure Process_Generic_List is |
| Arg : Node_Id; |
| Exp : Node_Id; |
| |
| begin |
| GNAT_Pragma; |
| Check_No_Identifiers; |
| Check_At_Least_N_Arguments (1); |
| |
| Arg := Arg1; |
| while Present (Arg) loop |
| Exp := Expression (Arg); |
| Analyze (Exp); |
| |
| if not Is_Entity_Name (Exp) |
| or else |
| (not Is_Generic_Instance (Entity (Exp)) |
| and then |
| not Is_Generic_Unit (Entity (Exp))) |
| then |
| Error_Pragma_Arg |
| ("pragma% argument must be name of generic unit/instance", |
| Arg); |
| end if; |
| |
| Next (Arg); |
| end loop; |
| end Process_Generic_List; |
| |
| --------------------------------- |
| -- Process_Import_Or_Interface -- |
| --------------------------------- |
| |
| procedure Process_Import_Or_Interface is |
| C : Convention_Id; |
| Def_Id : Entity_Id; |
| Hom_Id : Entity_Id; |
| |
| begin |
| Process_Convention (C, Def_Id); |
| Kill_Size_Check_Code (Def_Id); |
| Note_Possible_Modification (Expression (Arg2)); |
| |
| if Ekind (Def_Id) = E_Variable |
| or else |
| Ekind (Def_Id) = E_Constant |
| then |
| -- User initialization is not allowed for imported object, but |
| -- the object declaration may contain a default initialization, |
| -- that will be discarded. |
| |
| if Present (Expression (Parent (Def_Id))) |
| and then Comes_From_Source (Expression (Parent (Def_Id))) |
| then |
| Error_Msg_Sloc := Sloc (Def_Id); |
| Error_Pragma_Arg |
| ("no initialization allowed for declaration of& #", |
| "\imported entities cannot be initialized ('R'M' 'B.1(24))", |
| Arg2); |
| |
| else |
| Set_Imported (Def_Id); |
| Set_Is_Public (Def_Id); |
| Process_Interface_Name (Def_Id, Arg3, Arg4); |
| end if; |
| |
| elsif Is_Subprogram (Def_Id) |
| or else Is_Generic_Subprogram (Def_Id) |
| then |
| -- If the name is overloaded, pragma applies to all of the |
| -- denoted entities in the same declarative part. |
| |
| Hom_Id := Def_Id; |
| |
| while Present (Hom_Id) loop |
| Def_Id := Get_Base_Subprogram (Hom_Id); |
| |
| -- Ignore inherited subprograms because the pragma will |
| -- apply to the parent operation, which is the one called. |
| |
| if Is_Overloadable (Def_Id) |
| and then Present (Alias (Def_Id)) |
| then |
| null; |
| |
| -- Verify that the homonym is in the same declarative |
| -- part (not just the same scope). |
| |
| elsif Parent (Unit_Declaration_Node (Def_Id)) /= Parent (N) |
| and then Nkind (Parent (N)) /= N_Compilation_Unit_Aux |
| then |
| exit; |
| |
| else |
| Set_Imported (Def_Id); |
| |
| -- If Import intrinsic, set intrinsic flag |
| -- and verify that it is known as such. |
| |
| if C = Convention_Intrinsic then |
| Set_Is_Intrinsic_Subprogram (Def_Id); |
| Check_Intrinsic_Subprogram |
| (Def_Id, Expression (Arg2)); |
| end if; |
| |
| -- All interfaced procedures need an external |
| -- symbol created for them since they are |
| -- always referenced from another object file. |
| |
| Set_Is_Public (Def_Id); |
| Set_Has_Completion (Def_Id); |
| Process_Interface_Name (Def_Id, Arg3, Arg4); |
| end if; |
| |
| if Is_Compilation_Unit (Hom_Id) then |
| |
| -- Its possible homonyms are not affected by the pragma. |
| -- Such homonyms might be present in the context of other |
| -- units being compiled. |
| |
| exit; |
| |
| else |
| Hom_Id := Homonym (Hom_Id); |
| end if; |
| end loop; |
| |
| -- When the convention is Java, we also allow Import to be given |
| -- for packages, exceptions, and record components. |
| |
| elsif C = Convention_Java |
| and then (Ekind (Def_Id) = E_Package |
| or else Ekind (Def_Id) = E_Exception |
| or else Nkind (Parent (Def_Id)) = N_Component_Declaration) |
| then |
| Set_Imported (Def_Id); |
| Set_Is_Public (Def_Id); |
| Process_Interface_Name (Def_Id, Arg3, Arg4); |
| |
| else |
| Error_Pragma_Arg |
| ("second argument of pragma% must be object or subprogram", |
| Arg2); |
| end if; |
| |
| -- If this pragma applies to a compilation unit, then the unit, |
| -- which is a subprogram, does not require (or allow) a body. |
| -- We also do not need to elaborate imported procedures. |
| |
| if Nkind (Parent (N)) = N_Compilation_Unit_Aux then |
| declare |
| Cunit : constant Node_Id := Parent (Parent (N)); |
| |
| begin |
| Set_Body_Required (Cunit, False); |
| end; |
| end if; |
| |
| end Process_Import_Or_Interface; |
| |
| -------------------- |
| -- Process_Inline -- |
| -------------------- |
| |
| procedure Process_Inline (Active : Boolean) is |
| Assoc : Node_Id; |
| Decl : Node_Id; |
| Subp_Id : Node_Id; |
| Subp : Entity_Id; |
| Applies : Boolean; |
| |
| procedure Make_Inline (Subp : Entity_Id); |
| -- Subp is the defining unit name of the subprogram |
| -- declaration. Set the flag, as well as the flag in the |
| -- corresponding body, if there is one present. |
| |
| procedure Set_Inline_Flags (Subp : Entity_Id); |
| -- Sets Is_Inlined and Has_Pragma_Inline flags for Subp |
| |
| ----------------- |
| -- Make_Inline -- |
| ----------------- |
| |
| procedure Make_Inline (Subp : Entity_Id) is |
| Kind : Entity_Kind := Ekind (Subp); |
| Inner_Subp : Entity_Id := Subp; |
| |
| begin |
| if Etype (Subp) = Any_Type then |
| return; |
| |
| -- Here we have a candidate for inlining, but we must exclude |
| -- derived operations. Otherwise we will end up trying to |
| -- inline a phantom declaration, and the result would be to |
| -- drag in a body which has no direct inlining associated with |
| -- it. That would not only be inefficient but would also result |
| -- in the backend doing cross-unit inlining in cases where it |
| -- was definitely inappropriate to do so. |
| |
| -- However, a simple Comes_From_Source test is insufficient, |
| -- since we do want to allow inlining of generic instances, |
| -- which also do not come from source. Predefined operators do |
| -- not come from source but are not inlineable either. |
| |
| elsif not Comes_From_Source (Subp) |
| and then not Is_Generic_Instance (Subp) |
| and then Scope (Subp) /= Standard_Standard |
| then |
| Applies := True; |
| return; |
| |
| -- The referenced entity must either be the enclosing entity, |
| -- or an entity declared within the current open scope. |
| |
| elsif Present (Scope (Subp)) |
| and then Scope (Subp) /= Current_Scope |
| and then Subp /= Current_Scope |
| then |
| Error_Pragma_Arg |
| ("argument of% must be entity in current scope", Assoc); |
| return; |
| end if; |
| |
| -- Processing for procedure, operator or function. |
| -- If subprogram is aliased (as for an instance) indicate |
| -- that the renamed entity is inlined. |
| |
| if Kind = E_Procedure |
| or else Kind = E_Function |
| or else Kind = E_Operator |
| then |
| while Present (Alias (Inner_Subp)) loop |
| Inner_Subp := Alias (Inner_Subp); |
| end loop; |
| |
| Set_Inline_Flags (Inner_Subp); |
| |
| Decl := Parent (Parent (Inner_Subp)); |
| |
| if Nkind (Decl) = N_Subprogram_Declaration |
| and then Present (Corresponding_Body (Decl)) |
| then |
| Set_Inline_Flags (Corresponding_Body (Decl)); |
| end if; |
| |
| Applies := True; |
| |
| -- For a generic subprogram set flag as well, for use at |
| -- the point of instantiation, to determine whether the |
| -- body should be generated. |
| |
| elsif Kind = E_Generic_Procedure |
| or else Kind = E_Generic_Function |
| then |
| Set_Inline_Flags (Subp); |
| Applies := True; |
| |
| -- Literals are by definition inlined. |
| |
| elsif Kind = E_Enumeration_Literal then |
| null; |
| |
| -- Anything else is an error |
| |
| else |
| Error_Pragma_Arg |
| ("expect subprogram name for pragma%", Assoc); |
| end if; |
| end Make_Inline; |
| |
| ---------------------- |
| -- Set_Inline_Flags -- |
| ---------------------- |
| |
| procedure Set_Inline_Flags (Subp : Entity_Id) is |
| begin |
| if Active then |
| Set_Is_Inlined (Subp, True); |
| end if; |
| |
| if not Has_Pragma_Inline (Subp) then |
| Set_Has_Pragma_Inline (Subp); |
| Set_Next_Rep_Item (N, First_Rep_Item (Subp)); |
| Set_First_Rep_Item (Subp, N); |
| end if; |
| end Set_Inline_Flags; |
| |
| -- Start of processing for Process_Inline |
| |
| begin |
| Check_No_Identifiers; |
| Check_At_Least_N_Arguments (1); |
| |
| if Active then |
| Inline_Processing_Required := True; |
| end if; |
| |
| Assoc := Arg1; |
| while Present (Assoc) loop |
| Subp_Id := Expression (Assoc); |
| Analyze (Subp_Id); |
| Applies := False; |
| |
| if Is_Entity_Name (Subp_Id) then |
| Subp := Entity (Subp_Id); |
| |
| if Subp = Any_Id then |
| Applies := True; |
| |
| else |
| Make_Inline (Subp); |
| |
| while Present (Homonym (Subp)) |
| and then Scope (Homonym (Subp)) = Current_Scope |
| loop |
| Make_Inline (Homonym (Subp)); |
| Subp := Homonym (Subp); |
| end loop; |
| end if; |
| end if; |
| |
| if not Applies then |
| Error_Pragma_Arg |
| ("inappropriate argument for pragma%", Assoc); |
| end if; |
| |
| Next (Assoc); |
| end loop; |
| |
| end Process_Inline; |
| |
| ---------------------------- |
| -- Process_Interface_Name -- |
| ---------------------------- |
| |
| procedure Process_Interface_Name |
| (Subprogram_Def : Entity_Id; |
| Ext_Arg : Node_Id; |
| Link_Arg : Node_Id) |
| is |
| Ext_Nam : Node_Id; |
| Link_Nam : Node_Id; |
| String_Val : String_Id; |
| |
| procedure Check_Form_Of_Interface_Name (SN : Node_Id); |
| -- SN is a string literal node for an interface name. This routine |
| -- performs some minimal checks that the name is reasonable. In |
| -- particular that no spaces or other obviously incorrect characters |
| -- appear. This is only a warning, since any characters are allowed. |
| |
| procedure Check_Form_Of_Interface_Name (SN : Node_Id) is |
| S : constant String_Id := Strval (Expr_Value_S (SN)); |
| SL : constant Nat := String_Length (S); |
| C : Char_Code; |
| |
| begin |
| if SL = 0 then |
| Error_Msg_N ("interface name cannot be null string", SN); |
| end if; |
| |
| for J in 1 .. SL loop |
| C := Get_String_Char (S, J); |
| |
| if not In_Character_Range (C) |
| or else Get_Character (C) = ' ' |
| or else Get_Character (C) = ',' |
| then |
| Error_Msg_N |
| ("?interface name contains illegal character", SN); |
| end if; |
| end loop; |
| end Check_Form_Of_Interface_Name; |
| |
| -- Start of processing for Process_Interface_Name |
| |
| begin |
| if No (Link_Arg) then |
| if No (Ext_Arg) then |
| return; |
| |
| elsif Chars (Ext_Arg) = Name_Link_Name then |
| Ext_Nam := Empty; |
| Link_Nam := Expression (Ext_Arg); |
| |
| else |
| Check_Optional_Identifier (Ext_Arg, Name_External_Name); |
| Ext_Nam := Expression (Ext_Arg); |
| Link_Nam := Empty; |
| end if; |
| |
| else |
| Check_Optional_Identifier (Ext_Arg, Name_External_Name); |
| Check_Optional_Identifier (Link_Arg, Name_Link_Name); |
| Ext_Nam := Expression (Ext_Arg); |
| Link_Nam := Expression (Link_Arg); |
| end if; |
| |
| -- Check expressions for external name and link name are static |
| |
| if Present (Ext_Nam) then |
| Check_Arg_Is_Static_Expression (Ext_Nam, Standard_String); |
| Check_Form_Of_Interface_Name (Ext_Nam); |
| |
| -- Verify that the external name is not the name of a local |
| -- entity, which would hide the imported one and lead to |
| -- run-time surprises. The problem can only arise for entities |
| -- declared in a package body (otherwise the external name is |
| -- fully qualified and won't conflict). |
| |
| declare |
| Nam : Name_Id; |
| E : Entity_Id; |
| Par : Node_Id; |
| |
| begin |
| if Prag_Id = Pragma_Import then |
| String_To_Name_Buffer (Strval (Expr_Value_S (Ext_Nam))); |
| Nam := Name_Find; |
| E := Entity_Id (Get_Name_Table_Info (Nam)); |
| |
| if Nam /= Chars (Subprogram_Def) |
| and then Present (E) |
| and then not Is_Overloadable (E) |
| and then Is_Immediately_Visible (E) |
| and then not Is_Imported (E) |
| and then Ekind (Scope (E)) = E_Package |
| then |
| Par := Parent (E); |
| |
| while Present (Par) loop |
| if Nkind (Par) = N_Package_Body then |
| Error_Msg_Sloc := Sloc (E); |
| Error_Msg_NE |
| ("imported entity is hidden by & declared#", |
| Ext_Arg, E); |
| exit; |
| end if; |
| |
| Par := Parent (Par); |
| end loop; |
| end if; |
| end if; |
| end; |
| end if; |
| |
| if Present (Link_Nam) then |
| Check_Arg_Is_Static_Expression (Link_Nam, Standard_String); |
| Check_Form_Of_Interface_Name (Link_Nam); |
| end if; |
| |
| -- If there is no link name, just set the external name |
| |
| if No (Link_Nam) then |
| Set_Encoded_Interface_Name |
| (Get_Base_Subprogram (Subprogram_Def), |
| Adjust_External_Name_Case (Expr_Value_S (Ext_Nam))); |
| |
| -- For the Link_Name case, the given literal is preceded by an |
| -- asterisk, which indicates to GCC that the given name should |
| -- be taken literally, and in particular that no prepending of |
| -- underlines should occur, even in systems where this is the |
| -- normal default. |
| |
| else |
| Start_String; |
| Store_String_Char (Get_Char_Code ('*')); |
| String_Val := Strval (Expr_Value_S (Link_Nam)); |
| |
| for J in 1 .. String_Length (String_Val) loop |
| Store_String_Char (Get_String_Char (String_Val, J)); |
| end loop; |
| |
| Link_Nam := |
| Make_String_Literal (Sloc (Link_Nam), End_String); |
| |
| Set_Encoded_Interface_Name |
| (Get_Base_Subprogram (Subprogram_Def), Link_Nam); |
| end if; |
| end Process_Interface_Name; |
| |
| ----------------------------------------- |
| -- Process_Interrupt_Or_Attach_Handler -- |
| ----------------------------------------- |
| |
| procedure Process_Interrupt_Or_Attach_Handler is |
| Arg1_X : constant Node_Id := Expression (Arg1); |
| Prot_Proc : constant Entity_Id := Entity (Arg1_X); |
| Prot_Type : constant Entity_Id := Scope (Prot_Proc); |
| |
| begin |
| Set_Is_Interrupt_Handler (Prot_Proc); |
| |
| if Prag_Id = Pragma_Interrupt_Handler |
| or Prag_Id = Pragma_Attach_Handler |
| then |
| Record_Rep_Item (Prot_Type, N); |
| end if; |
| |
| end Process_Interrupt_Or_Attach_Handler; |
| |
| --------------------------------- |
| -- Process_Suppress_Unsuppress -- |
| --------------------------------- |
| |
| procedure Process_Suppress_Unsuppress (Suppress_Case : Boolean) is |
| C : Check_Id; |
| E_Id : Node_Id; |
| E : Entity_Id; |
| Effective : Boolean; |
| |
| procedure Suppress_Unsuppress_Echeck (E : Entity_Id; C : Check_Id); |
| -- Used to suppress a single check on the given entity |
| |
| procedure Suppress_Unsuppress_Echeck (E : Entity_Id; C : Check_Id) is |
| begin |
| -- First set appropriate suppress flags in the entity |
| |
| case C is |
| when Access_Check => |
| Effective := Suppress_Access_Checks (E); |
| Set_Suppress_Access_Checks (E, Suppress_Case); |
| |
| when Accessibility_Check => |
| Effective := Suppress_Accessibility_Checks (E); |
| Set_Suppress_Accessibility_Checks (E, Suppress_Case); |
| |
| when Discriminant_Check => |
| Effective := Suppress_Discriminant_Checks (E); |
| Set_Suppress_Discriminant_Checks (E, Suppress_Case); |
| |
| when Division_Check => |
| Effective := Suppress_Division_Checks (E); |
| Set_Suppress_Division_Checks (E, Suppress_Case); |
| |
| when Elaboration_Check => |
| Effective := Suppress_Elaboration_Checks (E); |
| Set_Suppress_Elaboration_Checks (E, Suppress_Case); |
| |
| when Index_Check => |
| Effective := Suppress_Index_Checks (E); |
| Set_Suppress_Index_Checks (E, Suppress_Case); |
| |
| when Length_Check => |
| Effective := Suppress_Length_Checks (E); |
| Set_Suppress_Length_Checks (E, Suppress_Case); |
| |
| when Overflow_Check => |
| Effective := Suppress_Overflow_Checks (E); |
| Set_Suppress_Overflow_Checks (E, Suppress_Case); |
| |
| when Range_Check => |
| Effective := Suppress_Range_Checks (E); |
| Set_Suppress_Range_Checks (E, Suppress_Case); |
| |
| when Storage_Check => |
| Effective := Suppress_Storage_Checks (E); |
| Set_Suppress_Storage_Checks (E, Suppress_Case); |
| |
| when Tag_Check => |
| Effective := Suppress_Tag_Checks (E); |
| Set_Suppress_Tag_Checks (E, Suppress_Case); |
| |
| when All_Checks => |
| Suppress_Unsuppress_Echeck (E, Access_Check); |
| Suppress_Unsuppress_Echeck (E, Accessibility_Check); |
| Suppress_Unsuppress_Echeck (E, Discriminant_Check); |
| Suppress_Unsuppress_Echeck (E, Division_Check); |
| Suppress_Unsuppress_Echeck (E, Elaboration_Check); |
| Suppress_Unsuppress_Echeck (E, Index_Check); |
| Suppress_Unsuppress_Echeck (E, Length_Check); |
| Suppress_Unsuppress_Echeck (E, Overflow_Check); |
| Suppress_Unsuppress_Echeck (E, Range_Check); |
| Suppress_Unsuppress_Echeck (E, Storage_Check); |
| Suppress_Unsuppress_Echeck (E, Tag_Check); |
| end case; |
| |
| -- If the entity is not declared in the current scope, then we |
| -- make an entry in the Entity_Suppress table so that the flag |
| -- will be removed on exit. This entry is only made if the |
| -- suppress did something (i.e. the flag was not already set). |
| |
| if Effective and then Scope (E) /= Current_Scope then |
| Entity_Suppress.Increment_Last; |
| Entity_Suppress.Table |
| (Entity_Suppress.Last).Entity := E; |
| Entity_Suppress.Table |
| (Entity_Suppress.Last).Check := C; |
| end if; |
| |
| -- If this is a first subtype, and the base type is distinct, |
| -- then also set the suppress flags on the base type. |
| |
| if Is_First_Subtype (E) |
| and then Etype (E) /= E |
| then |
| Suppress_Unsuppress_Echeck (Etype (E), C); |
| end if; |
| end Suppress_Unsuppress_Echeck; |
| |
| -- Start of processing for Process_Suppress_Unsuppress |
| |
| begin |
| -- Suppress/Unsuppress can appear as a configuration pragma, |
| -- or in a declarative part or a package spec (RM 11.5(5)) |
| |
| if not Is_Configuration_Pragma then |
| Check_Is_In_Decl_Part_Or_Package_Spec; |
| end if; |
| |
| Check_At_Least_N_Arguments (1); |
| Check_At_Most_N_Arguments (2); |
| Check_No_Identifier (Arg1); |
| Check_Arg_Is_Identifier (Arg1); |
| |
| if not Is_Check_Name (Chars (Expression (Arg1))) then |
| Error_Pragma_Arg |
| ("argument of pragma% is not valid check name", Arg1); |
| |
| else |
| C := Get_Check_Id (Chars (Expression (Arg1))); |
| end if; |
| |
| if Arg_Count = 1 then |
| case C is |
| when Access_Check => |
| Scope_Suppress.Access_Checks := Suppress_Case; |
| |
| when Accessibility_Check => |
| Scope_Suppress.Accessibility_Checks := Suppress_Case; |
| |
| when Discriminant_Check => |
| Scope_Suppress.Discriminant_Checks := Suppress_Case; |
| |
| when Division_Check => |
| Scope_Suppress.Division_Checks := Suppress_Case; |
| |
| when Elaboration_Check => |
| Scope_Suppress.Elaboration_Checks := Suppress_Case; |
| |
| when Index_Check => |
| Scope_Suppress.Index_Checks := Suppress_Case; |
| |
| when Length_Check => |
| Scope_Suppress.Length_Checks := Suppress_Case; |
| |
| when Overflow_Check => |
| Scope_Suppress.Overflow_Checks := Suppress_Case; |
| |
| when Range_Check => |
| Scope_Suppress.Range_Checks := Suppress_Case; |
| |
| when Storage_Check => |
| Scope_Suppress.Storage_Checks := Suppress_Case; |
| |
| when Tag_Check => |
| Scope_Suppress.Tag_Checks := Suppress_Case; |
| |
| when All_Checks => |
| Scope_Suppress := (others => Suppress_Case); |
| |
| end case; |
| |
| -- Case of two arguments present, where the check is |
| -- suppressed for a specified entity (given as the second |
| -- argument of the pragma) |
| |
| else |
| Check_Optional_Identifier (Arg2, Name_On); |
| E_Id := Expression (Arg2); |
| Analyze (E_Id); |
| |
| if not Is_Entity_Name (E_Id) then |
| Error_Pragma_Arg |
| ("second argument of pragma% must be entity name", Arg2); |
| end if; |
| |
| E := Entity (E_Id); |
| |
| if E = Any_Id then |
| return; |
| else |
| loop |
| Suppress_Unsuppress_Echeck (E, C); |
| |
| if Is_Generic_Instance (E) |
| and then Is_Subprogram (E) |
| and then Present (Alias (E)) |
| then |
| Suppress_Unsuppress_Echeck (Alias (E), C); |
| end if; |
| |
| if C = Elaboration_Check and then Suppress_Case then |
| Set_Suppress_Elaboration_Warnings (E); |
| end if; |
| |
| -- If we are within a package specification, the |
| -- pragma only applies to homonyms in the same scope. |
| |
| exit when No (Homonym (E)) |
| or else (Scope (Homonym (E)) /= Current_Scope |
| and then Ekind (Current_Scope) = E_Package |
| and then not In_Package_Body (Current_Scope)); |
| |
| E := Homonym (E); |
| end loop; |
| end if; |
| end if; |
| |
| end Process_Suppress_Unsuppress; |
| |
| ------------------ |
| -- Set_Exported -- |
| ------------------ |
| |
| procedure Set_Exported (E : Entity_Id; Arg : Node_Id) is |
| begin |
| if Is_Imported (E) then |
| Error_Pragma_Arg |
| ("cannot export entity& that was previously imported", Arg); |
| |
| elsif Present (Address_Clause (E)) then |
| Error_Pragma_Arg |
| ("cannot export entity& that has an address clause", Arg); |
| end if; |
| |
| Set_Is_Exported (E); |
| |
| -- Deal with exporting non-library level entity |
| |
| if not Is_Library_Level_Entity (E) then |
| |
| -- Not allowed at all for subprograms |
| |
| if Is_Subprogram (E) then |
| Error_Pragma_Arg ("local subprogram& cannot be exported", Arg); |
| |
| -- Otherwise set public and statically allocated |
| |
| else |
| Set_Is_Public (E); |
| Set_Is_Statically_Allocated (E); |
| end if; |
| end if; |
| |
| if Inside_A_Generic then |
| Error_Msg_NE |
| ("all instances of& will have the same external name?", Arg, E); |
| end if; |
| |
| end Set_Exported; |
| |
| ---------------------------------------------- |
| -- Set_Extended_Import_Export_External_Name -- |
| ---------------------------------------------- |
| |
| procedure Set_Extended_Import_Export_External_Name |
| (Internal_Ent : Entity_Id; |
| Arg_External : Node_Id) |
| is |
| Old_Name : constant Node_Id := Interface_Name (Internal_Ent); |
| New_Name : Node_Id; |
| |
| begin |
| if No (Arg_External) then |
| return; |
| |
| elsif Nkind (Arg_External) = N_String_Literal then |
| if String_Length (Strval (Arg_External)) = 0 then |
| return; |
| else |
| New_Name := Adjust_External_Name_Case (Arg_External); |
| end if; |
| |
| elsif Nkind (Arg_External) = N_Identifier then |
| New_Name := Get_Default_External_Name (Arg_External); |
| |
| else |
| Error_Pragma_Arg |
| ("incorrect form for External parameter for pragma%", |
| Arg_External); |
| end if; |
| |
| -- If we already have an external name set (by a prior normal |
| -- Import or Export pragma), then the external names must match |
| |
| if Present (Interface_Name (Internal_Ent)) then |
| declare |
| S1 : constant String_Id := Strval (Old_Name); |
| S2 : constant String_Id := Strval (New_Name); |
| |
| procedure Mismatch; |
| -- Called if names do not match |
| |
| procedure Mismatch is |
| begin |
| Error_Msg_Sloc := Sloc (Old_Name); |
| Error_Pragma_Arg |
| ("external name does not match that given #", |
| Arg_External); |
| end Mismatch; |
| |
| begin |
| if String_Length (S1) /= String_Length (S2) then |
| Mismatch; |
| |
| else |
| for J in 1 .. String_Length (S1) loop |
| if Get_String_Char (S1, J) /= Get_String_Char (S2, J) then |
| Mismatch; |
| end if; |
| end loop; |
| end if; |
| end; |
| |
| -- Otherwise set the given name |
| |
| else |
| Set_Encoded_Interface_Name (Internal_Ent, New_Name); |
| end if; |
| |
| end Set_Extended_Import_Export_External_Name; |
| |
| ------------------ |
| -- Set_Imported -- |
| ------------------ |
| |
| procedure Set_Imported (E : Entity_Id) is |
| begin |
| Error_Msg_Sloc := Sloc (E); |
| |
| if Is_Exported (E) or else Is_Imported (E) then |
| Error_Msg_NE ("import of& declared# not allowed", N, E); |
| |
| if Is_Exported (E) then |
| Error_Msg_N ("\entity was previously exported", N); |
| else |
| Error_Msg_N ("\entity was previously imported", N); |
| end if; |
| |
| Error_Pragma ("\(pragma% applies to all previous entities)"); |
| |
| else |
| Set_Is_Imported (E); |
| |
| -- If the entity is an object that is not at the library |
| -- level, then it is statically allocated. We do not worry |
| -- about objects with address clauses in this context since |
| -- they are not really imported in the linker sense. |
| |
| if Is_Object (E) |
| and then not Is_Library_Level_Entity (E) |
| and then No (Address_Clause (E)) |
| then |
| Set_Is_Statically_Allocated (E); |
| end if; |
| end if; |
| end Set_Imported; |
| |
| ------------------------- |
| -- Set_Mechanism_Value -- |
| ------------------------- |
| |
| -- Note: the mechanism name has not been analyzed (and cannot indeed |
| -- be analyzed, since it is semantic nonsense), so we get it in the |
| -- exact form created by the parser. |
| |
| procedure Set_Mechanism_Value (Ent : Entity_Id; Mech_Name : Node_Id) is |
| Class : Node_Id; |
| Param : Node_Id; |
| |
| procedure Bad_Class; |
| -- Signal bad descriptor class name |
| |
| procedure Bad_Mechanism; |
| -- Signal bad mechanism name |
| |
| procedure Bad_Class is |
| begin |
| Error_Pragma_Arg ("unrecognized descriptor class name", Class); |
| end Bad_Class; |
| |
| procedure Bad_Mechanism is |
| begin |
| Error_Pragma_Arg ("unrecognized mechanism name", Mech_Name); |
| end Bad_Mechanism; |
| |
| -- Start of processing for Set_Mechanism_Value |
| |
| begin |
| if Mechanism (Ent) /= Default_Mechanism then |
| Error_Msg_NE |
| ("mechanism for & has already been set", Mech_Name, Ent); |
| end if; |
| |
| -- MECHANISM_NAME ::= value | reference | descriptor |
| |
| if Nkind (Mech_Name) = N_Identifier then |
| if Chars (Mech_Name) = Name_Value then |
| Set_Mechanism (Ent, By_Copy); |
| return; |
| |
| elsif Chars (Mech_Name) = Name_Reference then |
| Set_Mechanism (Ent, By_Reference); |
| return; |
| |
| elsif Chars (Mech_Name) = Name_Descriptor then |
| Check_VMS (Mech_Name); |
| Set_Mechanism (Ent, By_Descriptor); |
| return; |
| |
| elsif Chars (Mech_Name) = Name_Copy then |
| Error_Pragma_Arg |
| ("bad mechanism name, Value assumed", Mech_Name); |
| |
| else |
| Bad_Mechanism; |
| end if; |
| |
| -- MECHANISM_NAME ::= descriptor (CLASS_NAME) |
| -- CLASS_NAME ::= ubs | ubsb | uba | s | sb | a | nca |
| |
| -- Note: this form is parsed as an indexed component |
| |
| elsif Nkind (Mech_Name) = N_Indexed_Component then |
| Class := First (Expressions (Mech_Name)); |
| |
| if Nkind (Prefix (Mech_Name)) /= N_Identifier |
| or else Chars (Prefix (Mech_Name)) /= Name_Descriptor |
| or else Present (Next (Class)) |
| then |
| Bad_Mechanism; |
| end if; |
| |
| -- MECHANISM_NAME ::= descriptor (Class => CLASS_NAME) |
| -- CLASS_NAME ::= ubs | ubsb | uba | s | sb | a | nca |
| |
| -- Note: this form is parsed as a function call |
| |
| elsif Nkind (Mech_Name) = N_Function_Call then |
| |
| Param := First (Parameter_Associations (Mech_Name)); |
| |
| if Nkind (Name (Mech_Name)) /= N_Identifier |
| or else Chars (Name (Mech_Name)) /= Name_Descriptor |
| or else Present (Next (Param)) |
| or else No (Selector_Name (Param)) |
| or else Chars (Selector_Name (Param)) /= Name_Class |
| then |
| Bad_Mechanism; |
| else |
| Class := Explicit_Actual_Parameter (Param); |
| end if; |
| |
| else |
| Bad_Mechanism; |
| end if; |
| |
| -- Fall through here with Class set to descriptor class name |
| |
| Check_VMS (Mech_Name); |
| |
| if Nkind (Class) /= N_Identifier then |
| Bad_Class; |
| |
| elsif Chars (Class) = Name_UBS then |
| Set_Mechanism (Ent, By_Descriptor_UBS); |
| |
| elsif Chars (Class) = Name_UBSB then |
| Set_Mechanism (Ent, By_Descriptor_UBSB); |
| |
| elsif Chars (Class) = Name_UBA then |
| Set_Mechanism (Ent, By_Descriptor_UBA); |
| |
| elsif Chars (Class) = Name_S then |
| Set_Mechanism (Ent, By_Descriptor_S); |
| |
| elsif Chars (Class) = Name_SB then |
| Set_Mechanism (Ent, By_Descriptor_SB); |
| |
| elsif Chars (Class) = Name_A then |
| Set_Mechanism (Ent, By_Descriptor_A); |
| |
| elsif Chars (Class) = Name_NCA then |
| Set_Mechanism (Ent, By_Descriptor_NCA); |
| |
| else |
| Bad_Class; |
| end if; |
| |
| end Set_Mechanism_Value; |
| |
| -- Start of processing for Analyze_Pragma |
| |
| begin |
| if not Is_Pragma_Name (Chars (N)) then |
| Error_Pragma ("unrecognized pragma%!?"); |
| else |
| Prag_Id := Get_Pragma_Id (Chars (N)); |
| end if; |
| |
| -- Preset arguments |
| |
| Arg1 := Empty; |
| Arg2 := Empty; |
| Arg3 := Empty; |
| Arg4 := Empty; |
| |
| if Present (Pragma_Argument_Associations (N)) then |
| Arg1 := First (Pragma_Argument_Associations (N)); |
| |
| if Present (Arg1) then |
| Arg2 := Next (Arg1); |
| |
| if Present (Arg2) then |
| Arg3 := Next (Arg2); |
| |
| if Present (Arg3) then |
| Arg4 := Next (Arg3); |
| end if; |
| end if; |
| end if; |
| end if; |
| |
| -- Count number of arguments |
| |
| declare |
| Arg_Node : Node_Id; |
| |
| begin |
| Arg_Count := 0; |
| Arg_Node := Arg1; |
| |
| while Present (Arg_Node) loop |
| Arg_Count := Arg_Count + 1; |
| Next (Arg_Node); |
| end loop; |
| end; |
| |
| -- An enumeration type defines the pragmas that are supported by the |
| -- implementation. Get_Pragma_Id (in package Prag) transorms a name |
| -- into the corresponding enumeration value for the following case. |
| |
| case Prag_Id is |
| |
| ----------------- |
| -- Abort_Defer -- |
| ----------------- |
| |
| -- pragma Abort_Defer; |
| |
| when Pragma_Abort_Defer => |
| GNAT_Pragma; |
| Check_Arg_Count (0); |
| |
| -- The only required semantic processing is to check the |
| -- placement. This pragma must appear at the start of the |
| -- statement sequence of a handled sequence of statements. |
| |
| if Nkind (Parent (N)) /= N_Handled_Sequence_Of_Statements |
| or else N /= First (Statements (Parent (N))) |
| then |
| Pragma_Misplaced; |
| end if; |
| |
| ------------ |
| -- Ada_83 -- |
| ------------ |
| |
| -- pragma Ada_83; |
| |
| -- Note: this pragma also has some specific processing in Par.Prag |
| -- because we want to set the Ada 83 mode switch during parsing. |
| |
| when Pragma_Ada_83 => |
| GNAT_Pragma; |
| Ada_83 := True; |
| Ada_95 := False; |
| Check_Arg_Count (0); |
| |
| ------------ |
| -- Ada_95 -- |
| ------------ |
| |
| -- pragma Ada_95; |
| |
| -- Note: this pragma also has some specific processing in Par.Prag |
| -- because we want to set the Ada 83 mode switch during parsing. |
| |
| when Pragma_Ada_95 => |
| GNAT_Pragma; |
| Ada_83 := False; |
| Ada_95 := True; |
| Check_Arg_Count (0); |
| |
| ---------------------- |
| -- All_Calls_Remote -- |
| ---------------------- |
| |
| -- pragma All_Calls_Remote [(library_package_NAME)]; |
| |
| when Pragma_All_Calls_Remote => All_Calls_Remote : declare |
| Lib_Entity : Entity_Id; |
| |
| begin |
| Check_Ada_83_Warning; |
| Check_Valid_Library_Unit_Pragma; |
| |
| if Nkind (N) = N_Null_Statement then |
| return; |
| end if; |
| |
| Lib_Entity := Find_Lib_Unit_Name; |
| |
| -- This pragma should only apply to a RCI unit (RM E.2.3(23)). |
| |
| if Present (Lib_Entity) |
| and then not Debug_Flag_U |
| then |
| if not Is_Remote_Call_Interface (Lib_Entity) then |
| Error_Pragma ("pragma% only apply to rci unit"); |
| |
| -- Set flag for entity of the library unit |
| |
| else |
| Set_Has_All_Calls_Remote (Lib_Entity); |
| end if; |
| |
| end if; |
| end All_Calls_Remote; |
| |
| -------------- |
| -- Annotate -- |
| -------------- |
| |
| -- pragma Annotate (IDENTIFIER {, ARG}); |
| -- ARG ::= NAME | EXPRESSION |
| |
| when Pragma_Annotate => Annotate : begin |
| GNAT_Pragma; |
| Check_At_Least_N_Arguments (1); |
| Check_Arg_Is_Identifier (Arg1); |
| |
| declare |
| Arg : Node_Id := Arg2; |
| Exp : Node_Id; |
| |
| begin |
| while Present (Arg) loop |
| Exp := Expression (Arg); |
| Analyze (Exp); |
| |
| if Is_Entity_Name (Exp) then |
| null; |
| |
| elsif Nkind (Exp) = N_String_Literal then |
| Resolve (Exp, Standard_String); |
| |
| elsif Is_Overloaded (Exp) then |
| Error_Pragma_Arg ("ambiguous argument for pragma%", Exp); |
| |
| else |
| Resolve (Exp, Etype (Exp)); |
| end if; |
| |
| Next (Arg); |
| end loop; |
| end; |
| end Annotate; |
| |
| ------------ |
| -- Assert -- |
| ------------ |
| |
| -- pragma Assert (Boolean_EXPRESSION [, static_string_EXPRESSION]); |
| |
| when Pragma_Assert => |
| GNAT_Pragma; |
| Check_No_Identifiers; |
| |
| if Arg_Count > 1 then |
| Check_Arg_Count (2); |
| Check_Arg_Is_Static_Expression (Arg2, Standard_String); |
| end if; |
| |
| -- If expansion is active and assertions are inactive, then |
| -- we rewrite the Assertion as: |
| |
| -- if False and then condition then |
| -- null; |
| -- end if; |
| |
| -- The reason we do this rewriting during semantic analysis |
| -- rather than as part of normal expansion is that we cannot |
| -- analyze and expand the code for the boolean expression |
| -- directly, or it may cause insertion of actions that would |
| -- escape the attempt to suppress the assertion code. |
| |
| if Expander_Active and not Assertions_Enabled then |
| Rewrite (N, |
| Make_If_Statement (Loc, |
| Condition => |
| Make_And_Then (Loc, |
| Left_Opnd => New_Occurrence_Of (Standard_False, Loc), |
| Right_Opnd => Get_Pragma_Arg (Arg1)), |
| Then_Statements => New_List ( |
| Make_Null_Statement (Loc)))); |
| |
| Analyze (N); |
| |
| -- Otherwise (if assertions are enabled, or if we are not |
| -- operating with expansion active), then we just analyze |
| -- and resolve the expression. |
| |
| else |
| Analyze_And_Resolve (Expression (Arg1), Any_Boolean); |
| end if; |
| |
| --------------- |
| -- AST_Entry -- |
| --------------- |
| |
| -- pragma AST_Entry (entry_IDENTIFIER); |
| |
| when Pragma_AST_Entry => AST_Entry : declare |
| Ent : Node_Id; |
| |
| begin |
| GNAT_Pragma; |
| Check_VMS (N); |
| Check_Arg_Count (1); |
| Check_No_Identifiers; |
| Check_Arg_Is_Local_Name (Arg1); |
| Ent := Entity (Expression (Arg1)); |
| |
| -- Note: the implementation of the AST_Entry pragma could handle |
| -- the entry family case fine, but for now we are consistent with |
| -- the DEC rules, and do not allow the pragma, which of course |
| -- has the effect of also forbidding the attribute. |
| |
| if Ekind (Ent) /= E_Entry then |
| Error_Pragma_Arg |
| ("pragma% argument must be simple entry name", Arg1); |
| |
| elsif Is_AST_Entry (Ent) then |
| Error_Pragma_Arg |
| ("duplicate % pragma for entry", Arg1); |
| |
| elsif Has_Homonym (Ent) then |
| Error_Pragma_Arg |
| ("pragma% argument cannot specify overloaded entry", Arg1); |
| |
| else |
| declare |
| FF : constant Entity_Id := First_Formal (Ent); |
| |
| begin |
| if Present (FF) then |
| if Present (Next_Formal (FF)) then |
| Error_Pragma_Arg |
| ("entry for pragma% can have only one argument", |
| Arg1); |
| |
| elsif Parameter_Mode (FF) /= E_In_Parameter then |
| Error_Pragma_Arg |
| ("entry parameter for pragma% must have mode IN", |
| Arg1); |
| end if; |
| end if; |
| end; |
| |
| Set_Is_AST_Entry (Ent); |
| end if; |
| end AST_Entry; |
| |
| ------------------ |
| -- Asynchronous -- |
| ------------------ |
| |
| -- pragma Asynchronous (LOCAL_NAME); |
| |
| when Pragma_Asynchronous => Asynchronous : declare |
| Nm : Entity_Id; |
| C_Ent : Entity_Id; |
| L : List_Id; |
| S : Node_Id; |
| N : Node_Id; |
| Formal : Entity_Id; |
| |
| procedure Process_Async_Pragma; |
| -- Common processing for procedure and access-to-procedure case |
| |
| -------------------------- |
| -- Process_Async_Pragma -- |
| -------------------------- |
| |
| procedure Process_Async_Pragma is |
| begin |
| if not Present (L) then |
| Set_Is_Asynchronous (Nm); |
| return; |
| end if; |
| |
| -- The formals should be of mode IN (RM E.4.1(6)) |
| |
| S := First (L); |
| while Present (S) loop |
| Formal := Defining_Identifier (S); |
| |
| if Nkind (Formal) = N_Defining_Identifier |
| and then Ekind (Formal) /= E_In_Parameter |
| then |
| Error_Pragma_Arg |
| ("pragma% procedure can only have IN parameter", |
| Arg1); |
| end if; |
| |
| Next (S); |
| end loop; |
| |
| Set_Is_Asynchronous (Nm); |
| end Process_Async_Pragma; |
| |
| -- Start of processing for pragma Asynchronous |
| |
| begin |
| Check_Ada_83_Warning; |
| Check_No_Identifiers; |
| Check_Arg_Count (1); |
| Check_Arg_Is_Local_Name (Arg1); |
| |
| if Debug_Flag_U then |
| return; |
| end if; |
| |
| C_Ent := Cunit_Entity (Current_Sem_Unit); |
| Analyze (Expression (Arg1)); |
| Nm := Entity (Expression (Arg1)); |
| |
| if not Is_Remote_Call_Interface (C_Ent) |
| and then not Is_Remote_Types (C_Ent) |
| then |
| -- This pragma should only appear in an RCI or Remote Types |
| -- unit (RM E.4.1(4)) |
| |
| Error_Pragma |
| ("pragma% not in Remote_Call_Interface or " & |
| "Remote_Types unit"); |
| end if; |
| |
| if Ekind (Nm) = E_Procedure |
| and then Nkind (Parent (Nm)) = N_Procedure_Specification |
| then |
| if not Is_Remote_Call_Interface (Nm) then |
| Error_Pragma_Arg |
| ("pragma% cannot be applied on non-remote procedure", |
| Arg1); |
| end if; |
| |
| L := Parameter_Specifications (Parent (Nm)); |
| Process_Async_Pragma; |
| return; |
| |
| elsif Ekind (Nm) = E_Function then |
| Error_Pragma_Arg |
| ("pragma% cannot be applied to function", Arg1); |
| |
| elsif Ekind (Nm) = E_Record_Type |
| and then Present (Corresponding_Remote_Type (Nm)) |
| then |
| N := Declaration_Node (Corresponding_Remote_Type (Nm)); |
| |
| if Nkind (N) = N_Full_Type_Declaration |
| and then Nkind (Type_Definition (N)) = |
| N_Access_Procedure_Definition |
| then |
| L := Parameter_Specifications (Type_Definition (N)); |
| Process_Async_Pragma; |
| |
| else |
| Error_Pragma_Arg |
| ("pragma% cannot reference access-to-function type", |
| Arg1); |
| end if; |
| |
| -- Only other possibility is Access-to-class-wide type |
| |
| elsif Is_Access_Type (Nm) |
| and then Is_Class_Wide_Type (Designated_Type (Nm)) |
| then |
| Check_First_Subtype (Arg1); |
| Set_Is_Asynchronous (Nm); |
| if Expander_Active then |
| RACW_Type_Is_Asynchronous (Nm); |
| end if; |
| |
| else |
| Error_Pragma_Arg ("inappropriate argument for pragma%", Arg1); |
| end if; |
| |
| end Asynchronous; |
| |
| ------------ |
| -- Atomic -- |
| ------------ |
| |
| -- pragma Atomic (LOCAL_NAME); |
| |
| when Pragma_Atomic => |
| Process_Atomic_Shared_Volatile; |
| |
| ----------------------- |
| -- Atomic_Components -- |
| ----------------------- |
| |
| -- pragma Atomic_Components (array_LOCAL_NAME); |
| |
| -- This processing is shared by Volatile_Components |
| |
| when Pragma_Atomic_Components | |
| Pragma_Volatile_Components => |
| |
| Atomic_Components : declare |
| E_Id : Node_Id; |
| E : Entity_Id; |
| D : Node_Id; |
| K : Node_Kind; |
| |
| begin |
| GNAT_Pragma; |
| Check_Ada_83_Warning; |
| Check_No_Identifiers; |
| Check_Arg_Count (1); |
| Check_Arg_Is_Local_Name (Arg1); |
| E_Id := Expression (Arg1); |
| |
| if Etype (E_Id) = Any_Type then |
| return; |
| end if; |
| |
| E := Entity (E_Id); |
| |
| if Rep_Item_Too_Early (E, N) |
| or else |
| Rep_Item_Too_Late (E, N) |
| then |
| return; |
| end if; |
| |
| D := Declaration_Node (E); |
| K := Nkind (D); |
| |
| if (K = N_Full_Type_Declaration and then Is_Array_Type (E)) |
| or else |
| ((Ekind (E) = E_Constant or else Ekind (E) = E_Variable) |
| and then Nkind (D) = N_Object_Declaration |
| and then Nkind (Object_Definition (D)) = |
| N_Constrained_Array_Definition) |
| then |
| -- The flag is set on the object, or on the base type |
| |
| if Nkind (D) /= N_Object_Declaration then |
| E := Base_Type (E); |
| end if; |
| |
| Set_Has_Volatile_Components (E); |
| |
| if Prag_Id = Pragma_Atomic_Components then |
| Set_Has_Atomic_Components (E); |
| |
| if Is_Packed (E) then |
| Set_Is_Packed (E, False); |
| |
| Error_Pragma_Arg |
| ("?Pack canceled, cannot pack atomic components", |
| Arg1); |
| end if; |
| end if; |
| |
| else |
| Error_Pragma_Arg ("inappropriate entity for pragma%", Arg1); |
| end if; |
| end Atomic_Components; |
| |
| -------------------- |
| -- Attach_Handler -- |
| -------------------- |
| |
| -- pragma Attach_Handler (handler_NAME, EXPRESSION); |
| |
| when Pragma_Attach_Handler => |
| Check_Ada_83_Warning; |
| Check_No_Identifiers; |
| Check_Arg_Count (2); |
| Check_Interrupt_Or_Attach_Handler; |
| Analyze_And_Resolve (Expression (Arg2), RTE (RE_Interrupt_Id)); |
| Process_Interrupt_Or_Attach_Handler; |
| |
| -------------------- |
| -- C_Pass_By_Copy -- |
| -------------------- |
| |
| -- pragma C_Pass_By_Copy ([Max_Size =>] static_integer_EXPRESSION); |
| |
| when Pragma_C_Pass_By_Copy => C_Pass_By_Copy : declare |
| Arg : Node_Id; |
| Val : Uint; |
| |
| begin |
| GNAT_Pragma; |
| Check_Valid_Configuration_Pragma; |
| Check_Arg_Count (1); |
| Check_Optional_Identifier (Arg1, "max_size"); |
| |
| Arg := Expression (Arg1); |
| Check_Arg_Is_Static_Expression (Arg, Any_Integer); |
| |
| Val := Expr_Value (Arg); |
| |
| if Val <= 0 then |
| Error_Pragma_Arg |
| ("maximum size for pragma% must be positive", Arg1); |
| |
| elsif UI_Is_In_Int_Range (Val) then |
| Default_C_Record_Mechanism := UI_To_Int (Val); |
| |
| -- If a giant value is given, Int'Last will do well enough. |
| -- If sometime someone complains that a record larger than |
| -- two gigabytes is not copied, we will worry about it then! |
| |
| else |
| Default_C_Record_Mechanism := Mechanism_Type'Last; |
| end if; |
| end C_Pass_By_Copy; |
| |
| ------------- |
| -- Comment -- |
| ------------- |
| |
| -- pragma Comment (static_string_EXPRESSION) |
| |
| -- Processing for pragma Comment shares the circuitry for |
| -- pragma Ident. The only differences are that Ident enforces |
| -- a limit of 31 characters on its argument, and also enforces |
| -- limitations on placement for DEC compatibility. Pragma |
| -- Comment shares neither of these restrictions. |
| |
| ------------------- |
| -- Common_Object -- |
| ------------------- |
| |
| -- pragma Common_Object ( |
| -- [Internal =>] LOCAL_NAME, |
| -- [, [External =>] EXTERNAL_SYMBOL] |
| -- [, [Size =>] EXTERNAL_SYMBOL]); |
| |
| -- Processing for this pragma is shared with Psect_Object |
| |
| ---------------------------- |
| -- Complex_Representation -- |
| ---------------------------- |
| |
| -- pragma Complex_Representation ([Entity =>] LOCAL_NAME); |
| |
| when Pragma_Complex_Representation => Complex_Representation : declare |
| E_Id : Entity_Id; |
| E : Entity_Id; |
| Ent : Entity_Id; |
| |
| begin |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_Optional_Identifier (Arg1, Name_Entity); |
| Check_Arg_Is_Local_Name (Arg1); |
| E_Id := Expression (Arg1); |
| |
| if Etype (E_Id) = Any_Type then |
| return; |
| end if; |
| |
| E := Entity (E_Id); |
| |
| if not Is_Record_Type (E) then |
| Error_Pragma_Arg |
| ("argument for pragma% must be record type", Arg1); |
| end if; |
| |
| Ent := First_Entity (E); |
| |
| if No (Ent) |
| or else No (Next_Entity (Ent)) |
| or else Present (Next_Entity (Next_Entity (Ent))) |
| or else not Is_Floating_Point_Type (Etype (Ent)) |
| or else Etype (Ent) /= Etype (Next_Entity (Ent)) |
| then |
| Error_Pragma_Arg |
| ("record for pragma% must have two fields of same fpt type", |
| Arg1); |
| |
| else |
| Set_Has_Complex_Representation (Base_Type (E)); |
| end if; |
| end Complex_Representation; |
| |
| ------------------------- |
| -- Component_Alignment -- |
| ------------------------- |
| |
| -- pragma Component_Alignment ( |
| -- [Form =>] ALIGNMENT_CHOICE |
| -- [, [Name =>] type_LOCAL_NAME]); |
| -- |
| -- ALIGNMENT_CHOICE ::= |
| -- Component_Size |
| -- | Component_Size_4 |
| -- | Storage_Unit |
| -- | Default |
| |
| when Pragma_Component_Alignment => Component_AlignmentP : declare |
| Args : Args_List (1 .. 2); |
| Names : Name_List (1 .. 2) := ( |
| Name_Form, |
| Name_Name); |
| |
| Form : Node_Id renames Args (1); |
| Name : Node_Id renames Args (2); |
| |
| Atype : Component_Alignment_Kind; |
| Typ : Entity_Id; |
| |
| begin |
| GNAT_Pragma; |
| Gather_Associations (Names, Args); |
| |
| if No (Form) then |
| Error_Pragma ("missing Form argument for pragma%"); |
| end if; |
| |
| Check_Arg_Is_Identifier (Form); |
| |
| -- Get proper alignment, note that Default = Component_Size |
| -- on all machines we have so far, and we want to set this |
| -- value rather than the default value to indicate that it |
| -- has been explicitly set (and thus will not get overridden |
| -- by the default component alignment for the current scope) |
| |
| if Chars (Form) = Name_Component_Size then |
| Atype := Calign_Component_Size; |
| |
| elsif Chars (Form) = Name_Component_Size_4 then |
| Atype := Calign_Component_Size_4; |
| |
| elsif Chars (Form) = Name_Default then |
| Atype := Calign_Component_Size; |
| |
| elsif Chars (Form) = Name_Storage_Unit then |
| Atype := Calign_Storage_Unit; |
| |
| else |
| Error_Pragma_Arg |
| ("invalid Form parameter for pragma%", Form); |
| end if; |
| |
| -- Case with no name, supplied, affects scope table entry |
| |
| if No (Name) then |
| Scope_Stack.Table |
| (Scope_Stack.Last).Component_Alignment_Default := Atype; |
| |
| -- Case of name supplied |
| |
| else |
| Check_Arg_Is_Local_Name (Name); |
| Find_Type (Name); |
| Typ := Entity (Name); |
| |
| if Typ = Any_Type |
| or else Rep_Item_Too_Early (Typ, N) |
| then |
| return; |
| else |
| Typ := Underlying_Type (Typ); |
| end if; |
| |
| if not Is_Record_Type (Typ) |
| and then not Is_Array_Type (Typ) |
| then |
| Error_Pragma_Arg |
| ("Name parameter of pragma% must identify record or " & |
| "array type", Name); |
| end if; |
| |
| -- An explicit Component_Alignment pragma overrides an |
| -- implicit pragma Pack, but not an explicit one. |
| |
| if not Has_Pragma_Pack (Base_Type (Typ)) then |
| Set_Is_Packed (Base_Type (Typ), False); |
| Set_Component_Alignment (Base_Type (Typ), Atype); |
| end if; |
| end if; |
| |
| end Component_AlignmentP; |
| |
| ---------------- |
| -- Controlled -- |
| ---------------- |
| |
| -- pragma Controlled (first_subtype_LOCAL_NAME); |
| |
| when Pragma_Controlled => Controlled : declare |
| Arg : Node_Id; |
| |
| begin |
| Check_No_Identifiers; |
| Check_Arg_Count (1); |
| Check_Arg_Is_Local_Name (Arg1); |
| Arg := Expression (Arg1); |
| |
| if not Is_Entity_Name (Arg) |
| or else not Is_Access_Type (Entity (Arg)) |
| then |
| Error_Pragma_Arg ("pragma% requires access type", Arg1); |
| else |
| Set_Has_Pragma_Controlled (Base_Type (Entity (Arg))); |
| end if; |
| end Controlled; |
| |
| ---------------- |
| -- Convention -- |
| ---------------- |
| |
| -- pragma Convention ([Convention =>] convention_IDENTIFIER, |
| -- [Entity =>] LOCAL_NAME); |
| |
| when Pragma_Convention => Convention : declare |
| C : Convention_Id; |
| E : Entity_Id; |
| |
| begin |
| Check_Ada_83_Warning; |
| Check_Arg_Count (2); |
| Process_Convention (C, E); |
| end Convention; |
| |
| --------------- |
| -- CPP_Class -- |
| --------------- |
| |
| -- pragma CPP_Class ([Entity =>] local_NAME) |
| |
| when Pragma_CPP_Class => CPP_Class : declare |
| Arg : Node_Id; |
| Typ : Entity_Id; |
| Default_DTC : Entity_Id := Empty; |
| VTP_Type : constant Entity_Id := RTE (RE_Vtable_Ptr); |
| C : Entity_Id; |
| Tag_C : Entity_Id; |
| |
| begin |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_Optional_Identifier (Arg1, Name_Entity); |
| Check_Arg_Is_Local_Name (Arg1); |
| |
| Arg := Expression (Arg1); |
| Analyze (Arg); |
| |
| if Etype (Arg) = Any_Type then |
| return; |
| end if; |
| |
| if not Is_Entity_Name (Arg) |
| or else not Is_Type (Entity (Arg)) |
| then |
| Error_Pragma_Arg ("pragma% requires a type mark", Arg1); |
| end if; |
| |
| Typ := Entity (Arg); |
| |
| if not Is_Record_Type (Typ) then |
| Error_Pragma_Arg ("pragma% applicable to a record, " |
| & "tagged record or record extension", Arg1); |
| end if; |
| |
| Default_DTC := First_Component (Typ); |
| while Present (Default_DTC) |
| and then Etype (Default_DTC) /= VTP_Type |
| loop |
| Next_Component (Default_DTC); |
| end loop; |
| |
| -- Case of non tagged type |
| |
| if not Is_Tagged_Type (Typ) then |
| Set_Is_CPP_Class (Typ); |
| |
| if Present (Default_DTC) then |
| Error_Pragma_Arg |
| ("only tagged records can contain vtable pointers", Arg1); |
| end if; |
| |
| -- Case of tagged type with no vtable ptr |
| |
| -- What is test for Typ = Root_Typ (Typ) about here ??? |
| |
| elsif Is_Tagged_Type (Typ) |
| and then Typ = Root_Type (Typ) |
| and then No (Default_DTC) |
| then |
| Error_Pragma_Arg |
| ("a cpp_class must contain a vtable pointer", Arg1); |
| |
| -- Tagged type that has a vtable ptr |
| |
| elsif Present (Default_DTC) then |
| Set_Is_CPP_Class (Typ); |
| Set_Is_Limited_Record (Typ); |
| Set_Is_Tag (Default_DTC); |
| Set_DT_Entry_Count (Default_DTC, No_Uint); |
| |
| -- Since a CPP type has no direct link to its associated tag |
| -- most tags checks cannot be performed |
| |
| Set_Suppress_Tag_Checks (Typ); |
| Set_Suppress_Tag_Checks (Class_Wide_Type (Typ)); |
| |
| -- Get rid of the _tag component when there was one. |
| -- It is only useful for regular tagged types |
| |
| if Expander_Active and then Typ = Root_Type (Typ) then |
| |
| Tag_C := Tag_Component (Typ); |
| C := First_Entity (Typ); |
| |
| if C = Tag_C then |
| Set_First_Entity (Typ, Next_Entity (Tag_C)); |
| |
| else |
| while Next_Entity (C) /= Tag_C loop |
| Next_Entity (C); |
| end loop; |
| |
| Set_Next_Entity (C, Next_Entity (Tag_C)); |
| end if; |
| end if; |
| end if; |
| end CPP_Class; |
| |
| --------------------- |
| -- CPP_Constructor -- |
| --------------------- |
| |
| -- pragma CPP_Constructor ([Entity =>] LOCAL_NAME); |
| |
| when Pragma_CPP_Constructor => CPP_Constructor : declare |
| Id : Entity_Id; |
| Def_Id : Entity_Id; |
| |
| begin |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_Optional_Identifier (Arg1, Name_Entity); |
| Check_Arg_Is_Local_Name (Arg1); |
| |
| Id := Expression (Arg1); |
| Find_Program_Unit_Name (Id); |
| |
| -- If we did not find the name, we are done |
| |
| if Etype (Id) = Any_Type then |
| return; |
| end if; |
| |
| Def_Id := Entity (Id); |
| |
| if Ekind (Def_Id) = E_Function |
| and then Is_Class_Wide_Type (Etype (Def_Id)) |
| and then Is_CPP_Class (Etype (Etype (Def_Id))) |
| then |
| -- What the heck is this??? this pragma allows only 1 arg |
| |
| if Arg_Count >= 2 then |
| Check_At_Most_N_Arguments (3); |
| Process_Interface_Name (Def_Id, Arg2, Arg3); |
| end if; |
| |
| if No (Parameter_Specifications (Parent (Def_Id))) then |
| Set_Has_Completion (Def_Id); |
| Set_Is_Constructor (Def_Id); |
| else |
| Error_Pragma_Arg |
| ("non-default constructors not implemented", Arg1); |
| end if; |
| |
| else |
| Error_Pragma_Arg |
| ("pragma% requires function returning a 'C'P'P_Class type", |
| Arg1); |
| end if; |
| end CPP_Constructor; |
| |
| ----------------- |
| -- CPP_Virtual -- |
| ----------------- |
| |
| -- pragma CPP_Virtual |
| -- [Entity =>] LOCAL_NAME |
| -- [ [Vtable_Ptr =>] LOCAL_NAME, |
| -- [Position =>] static_integer_EXPRESSION]); |
| |
| when Pragma_CPP_Virtual => CPP_Virtual : declare |
| Arg : Node_Id; |
| Typ : Entity_Id; |
| Subp : Entity_Id; |
| VTP_Type : constant Entity_Id := RTE (RE_Vtable_Ptr); |
| DTC : Entity_Id; |
| V : Uint; |
| |
| begin |
| GNAT_Pragma; |
| |
| if Arg_Count = 3 then |
| Check_Optional_Identifier (Arg2, "vtable_ptr"); |
| |
| -- We allow Entry_Count as well as Position for the third |
| -- parameter for back compatibility with versions of GNAT |
| -- before version 3.12. The documentation has always said |
| -- Position, but the code up to 3.12 said Entry_Count. |
| |
| if Chars (Arg3) /= Name_Position then |
| Check_Optional_Identifier (Arg3, "entry_count"); |
| end if; |
| |
| else |
| Check_Arg_Count (1); |
| end if; |
| |
| Check_Optional_Identifier (Arg1, Name_Entity); |
| Check_Arg_Is_Local_Name (Arg1); |
| |
| -- First argument must be a subprogram name |
| |
| Arg := Expression (Arg1); |
| Find_Program_Unit_Name (Arg); |
| |
| if Etype (Arg) = Any_Type then |
| return; |
| else |
| Subp := Entity (Arg); |
| end if; |
| |
| if not (Is_Subprogram (Subp) |
| and then Is_Dispatching_Operation (Subp)) |
| then |
| Error_Pragma_Arg |
| ("pragma% must reference a primitive operation", Arg1); |
| end if; |
| |
| Typ := Find_Dispatching_Type (Subp); |
| |
| -- If only one Argument defaults are : |
| -- . DTC_Entity is the default Vtable pointer |
| -- . DT_Position will be set at the freezing point |
| |
| if Arg_Count = 1 then |
| Set_DTC_Entity (Subp, Tag_Component (Typ)); |
| return; |
| end if; |
| |
| -- Second argument is a component name of type Vtable_Ptr |
| |
| Arg := Expression (Arg2); |
| |
| if Nkind (Arg) /= N_Identifier then |
| Error_Msg_NE ("must be a& component name", Arg, Typ); |
| raise Pragma_Exit; |
| end if; |
| |
| DTC := First_Component (Typ); |
| while Present (DTC) and then Chars (DTC) /= Chars (Arg) loop |
| Next_Component (DTC); |
| end loop; |
| |
| if No (DTC) then |
| Error_Msg_NE ("must be a& component name", Arg, Typ); |
| raise Pragma_Exit; |
| |
| elsif Etype (DTC) /= VTP_Type then |
| Wrong_Type (Arg, VTP_Type); |
| return; |
| end if; |
| |
| -- Third argument is an integer (DT_Position) |
| |
| Arg := Expression (Arg3); |
| Analyze_And_Resolve (Arg, Any_Integer); |
| |
| if not Is_Static_Expression (Arg) then |
| Error_Pragma_Arg |
| ("third argument of pragma% must be a static expression", |
| Arg3); |
| |
| else |
| V := Expr_Value (Expression (Arg3)); |
| |
| if V <= 0 then |
| Error_Pragma_Arg |
| ("third argument of pragma% must be positive", |
| Arg3); |
| |
| else |
| Set_DTC_Entity (Subp, DTC); |
| Set_DT_Position (Subp, V); |
| end if; |
| end if; |
| end CPP_Virtual; |
| |
| ---------------- |
| -- CPP_Vtable -- |
| ---------------- |
| |
| -- pragma CPP_Vtable ( |
| -- [Entity =>] LOCAL_NAME |
| -- [Vtable_Ptr =>] LOCAL_NAME, |
| -- [Entry_Count =>] static_integer_EXPRESSION); |
| |
| when Pragma_CPP_Vtable => CPP_Vtable : declare |
| Arg : Node_Id; |
| Typ : Entity_Id; |
| VTP_Type : constant Entity_Id := RTE (RE_Vtable_Ptr); |
| DTC : Entity_Id; |
| V : Uint; |
| Elmt : Elmt_Id; |
| |
| begin |
| GNAT_Pragma; |
| Check_Arg_Count (3); |
| Check_Optional_Identifier (Arg1, Name_Entity); |
| Check_Optional_Identifier (Arg2, "vtable_ptr"); |
| Check_Optional_Identifier (Arg3, "entry_count"); |
| Check_Arg_Is_Local_Name (Arg1); |
| |
| -- First argument is a record type name |
| |
| Arg := Expression (Arg1); |
| Analyze (Arg); |
| |
| if Etype (Arg) = Any_Type then |
| return; |
| else |
| Typ := Entity (Arg); |
| end if; |
| |
| if not (Is_Tagged_Type (Typ) and then Is_CPP_Class (Typ)) then |
| Error_Pragma_Arg ("'C'P'P_Class tagged type expected", Arg1); |
| end if; |
| |
| -- Second argument is a component name of type Vtable_Ptr |
| |
| Arg := Expression (Arg2); |
| |
| if Nkind (Arg) /= N_Identifier then |
| Error_Msg_NE ("must be a& component name", Arg, Typ); |
| raise Pragma_Exit; |
| end if; |
| |
| DTC := First_Component (Typ); |
| while Present (DTC) and then Chars (DTC) /= Chars (Arg) loop |
| Next_Component (DTC); |
| end loop; |
| |
| if No (DTC) then |
| Error_Msg_NE ("must be a& component name", Arg, Typ); |
| raise Pragma_Exit; |
| |
| elsif Etype (DTC) /= VTP_Type then |
| Wrong_Type (DTC, VTP_Type); |
| return; |
| |
| -- If it is the first pragma Vtable, This becomes the default tag |
| |
| elsif (not Is_Tag (DTC)) |
| and then DT_Entry_Count (Tag_Component (Typ)) = No_Uint |
| then |
| Set_Is_Tag (Tag_Component (Typ), False); |
| Set_Is_Tag (DTC, True); |
| Set_DT_Entry_Count (DTC, No_Uint); |
| end if; |
| |
| -- Those pragmas must appear before any primitive operation |
| -- definition (except inherited ones) otherwise the default |
| -- may be wrong |
| |
| Elmt := First_Elmt (Primitive_Operations (Typ)); |
| while Present (Elmt) loop |
| if No (Alias (Node (Elmt))) then |
| Error_Msg_Sloc := Sloc (Node (Elmt)); |
| Error_Pragma |
| ("pragma% must appear before this primitive operation"); |
| end if; |
| |
| Next_Elmt (Elmt); |
| end loop; |
| |
| -- Third argument is an integer (DT_Entry_Count) |
| |
| Arg := Expression (Arg3); |
| Analyze_And_Resolve (Arg, Any_Integer); |
| |
| if not Is_Static_Expression (Arg) then |
| Error_Pragma_Arg |
| ("entry count for pragma% must be a static expression", Arg3); |
| |
| else |
| V := Expr_Value (Expression (Arg3)); |
| |
| if V <= 0 then |
| Error_Pragma_Arg |
| ("entry count for pragma% must be positive", Arg3); |
| else |
| Set_DT_Entry_Count (DTC, V); |
| end if; |
| end if; |
| |
| end CPP_Vtable; |
| |
| ----------- |
| -- Debug -- |
| ----------- |
| |
| -- pragma Debug (PROCEDURE_CALL_STATEMENT); |
| |
| when Pragma_Debug => Debug : begin |
| GNAT_Pragma; |
| |
| -- If assertions are enabled, and we are expanding code, then |
| -- we rewrite the pragma with its corresponding procedure call |
| -- and then analyze the call. |
| |
| if Assertions_Enabled and Expander_Active then |
| Rewrite (N, Relocate_Node (Debug_Statement (N))); |
| Analyze (N); |
| |
| -- Otherwise we work a bit to get a tree that makes sense |
| -- for ASIS purposes, namely a pragma with an analyzed |
| -- argument that looks like a procedure call. |
| |
| else |
| Expander_Mode_Save_And_Set (False); |
| Rewrite (N, Relocate_Node (Debug_Statement (N))); |
| Analyze (N); |
| Rewrite (N, |
| Make_Pragma (Loc, |
| Chars => Name_Debug, |
| Pragma_Argument_Associations => |
| New_List (Relocate_Node (N)))); |
| Expander_Mode_Restore; |
| end if; |
| end Debug; |
| |
| ------------------- |
| -- Discard_Names -- |
| ------------------- |
| |
| -- pragma Discard_Names [([On =>] LOCAL_NAME)]; |
| |
| when Pragma_Discard_Names => Discard_Names : declare |
| E_Id : Entity_Id; |
| E : Entity_Id; |
| |
| begin |
| GNAT_Pragma; |
| Check_Ada_83_Warning; |
| |
| -- Deal with configuration pragma case |
| |
| if Arg_Count = 0 and then Is_Configuration_Pragma then |
| Global_Discard_Names := True; |
| return; |
| |
| -- Otherwise, check correct appropriate context |
| |
| else |
| Check_Is_In_Decl_Part_Or_Package_Spec; |
| |
| if Arg_Count = 0 then |
| |
| -- If there is no parameter, then from now on this pragma |
| -- applies to any enumeration, exception or tagged type |
| -- defined in the current declarative part. |
| |
| Set_Discard_Names (Current_Scope); |
| return; |
| |
| else |
| Check_Arg_Count (1); |
| Check_Optional_Identifier (Arg1, Name_On); |
| Check_Arg_Is_Local_Name (Arg1); |
| E_Id := Expression (Arg1); |
| |
| if Etype (E_Id) = Any_Type then |
| return; |
| else |
| E := Entity (E_Id); |
| end if; |
| |
| if (Is_First_Subtype (E) |
| and then (Is_Enumeration_Type (E) |
| or else Is_Tagged_Type (E))) |
| or else Ekind (E) = E_Exception |
| then |
| Set_Discard_Names (E); |
| else |
| Error_Pragma_Arg |
| ("inappropriate entity for pragma%", Arg1); |
| end if; |
| end if; |
| end if; |
| end Discard_Names; |
| |
| --------------- |
| -- Elaborate -- |
| --------------- |
| |
| -- pragma Elaborate (library_unit_NAME {, library_unit_NAME}); |
| |
| when Pragma_Elaborate => Elaborate : declare |
| Plist : List_Id; |
| Parent_Node : Node_Id; |
| Arg : Node_Id; |
| Citem : Node_Id; |
| |
| begin |
| -- Pragma must be in context items list of a compilation unit |
| |
| if not Is_List_Member (N) then |
| Pragma_Misplaced; |
| return; |
| |
| else |
| Plist := List_Containing (N); |
| Parent_Node := Parent (Plist); |
| |
| if Parent_Node = Empty |
| or else Nkind (Parent_Node) /= N_Compilation_Unit |
| or else Context_Items (Parent_Node) /= Plist |
| then |
| Pragma_Misplaced; |
| return; |
| end if; |
| end if; |
| |
| -- Must be at least one argument |
| |
| if Arg_Count = 0 then |
| Error_Pragma ("pragma% requires at least one argument"); |
| end if; |
| |
| -- In Ada 83 mode, there can be no items following it in the |
| -- context list except other pragmas and implicit with clauses |
| -- (e.g. those added by use of Rtsfind). In Ada 95 mode, this |
| -- placement rule does not apply. |
| |
| if Ada_83 and then Comes_From_Source (N) then |
| Citem := Next (N); |
| |
| while Present (Citem) loop |
| if Nkind (Citem) = N_Pragma |
| or else (Nkind (Citem) = N_With_Clause |
| and then Implicit_With (Citem)) |
| then |
| null; |
| else |
| Error_Pragma |
| ("(Ada 83) pragma% must be at end of context clause"); |
| end if; |
| |
| Next (Citem); |
| end loop; |
| end if; |
| |
| -- Finally, the arguments must all be units mentioned in a with |
| -- clause in the same context clause. Note we already checked |
| -- (in Par.Prag) that the arguments are either identifiers or |
| |
| Arg := Arg1; |
| Outer : while Present (Arg) loop |
| Citem := First (Plist); |
| |
| Inner : while Citem /= N loop |
| if Nkind (Citem) = N_With_Clause |
| and then Same_Name (Name (Citem), Expression (Arg)) |
| then |
| Set_Elaborate_Present (Citem, True); |
| Set_Unit_Name (Expression (Arg), Name (Citem)); |
| Set_Suppress_Elaboration_Warnings (Entity (Name (Citem))); |
| exit Inner; |
| end if; |
| |
| Next (Citem); |
| end loop Inner; |
| |
| if Citem = N then |
| Error_Pragma_Arg |
| ("argument of pragma% is not with'ed unit", Arg); |
| end if; |
| |
| Next (Arg); |
| end loop Outer; |
| end Elaborate; |
| |
| ------------------- |
| -- Elaborate_All -- |
| ------------------- |
| |
| -- pragma Elaborate_All (library_unit_NAME {, library_unit_NAME}); |
| |
| when Pragma_Elaborate_All => Elaborate_All : declare |
| Plist : List_Id; |
| Parent_Node : Node_Id; |
| Arg : Node_Id; |
| Citem : Node_Id; |
| |
| begin |
| Check_Ada_83_Warning; |
| |
| -- Pragma must be in context items list of a compilation unit |
| |
| if not Is_List_Member (N) then |
| Pragma_Misplaced; |
| return; |
| |
| else |
| Plist := List_Containing (N); |
| Parent_Node := Parent (Plist); |
| |
| if Parent_Node = Empty |
| or else Nkind (Parent_Node) /= N_Compilation_Unit |
| or else Context_Items (Parent_Node) /= Plist |
| then |
| Pragma_Misplaced; |
| return; |
| end if; |
| end if; |
| |
| -- Must be at least one argument |
| |
| if Arg_Count = 0 then |
| Error_Pragma ("pragma% requires at least one argument"); |
| end if; |
| |
| -- Note: unlike pragma Elaborate, pragma Elaborate_All does not |
| -- have to appear at the end of the context clause, but may |
| -- appear mixed in with other items, even in Ada 83 mode. |
| |
| -- Final check: the arguments must all be units mentioned in |
| -- a with clause in the same context clause. Note that we |
| -- already checked (in Par.Prag) that all the arguments are |
| -- either identifiers or selected components. |
| |
| Arg := Arg1; |
| Outr : while Present (Arg) loop |
| Citem := First (Plist); |
| |
| Innr : while Citem /= N loop |
| if Nkind (Citem) = N_With_Clause |
| and then Same_Name (Name (Citem), Expression (Arg)) |
| then |
| Set_Elaborate_All_Present (Citem, True); |
| Set_Unit_Name (Expression (Arg), Name (Citem)); |
| Set_Suppress_Elaboration_Warnings (Entity (Name (Citem))); |
| exit Innr; |
| end if; |
| |
| Next (Citem); |
| end loop Innr; |
| |
| if Citem = N then |
| Error_Pragma_Arg |
| ("argument of pragma% is not with'ed unit", Arg); |
| end if; |
| |
| Next (Arg); |
| end loop Outr; |
| end Elaborate_All; |
| |
| -------------------- |
| -- Elaborate_Body -- |
| -------------------- |
| |
| -- pragma Elaborate_Body [( library_unit_NAME )]; |
| |
| when Pragma_Elaborate_Body => Elaborate_Body : declare |
| Cunit_Node : Node_Id; |
| Cunit_Ent : Entity_Id; |
| |
| begin |
| Check_Ada_83_Warning; |
| Check_Valid_Library_Unit_Pragma; |
| |
| if Nkind (N) = N_Null_Statement then |
| return; |
| end if; |
| |
| Cunit_Node := Cunit (Current_Sem_Unit); |
| Cunit_Ent := Cunit_Entity (Current_Sem_Unit); |
| |
| if Nkind (Unit (Cunit_Node)) = N_Package_Body |
| or else |
| Nkind (Unit (Cunit_Node)) = N_Subprogram_Body |
| then |
| Error_Pragma ("pragma% must refer to a spec, not a body"); |
| else |
| Set_Body_Required (Cunit_Node, True); |
| Set_Has_Pragma_Elaborate_Body (Cunit_Ent); |
| |
| -- If we are in dynamic elaboration mode, then we suppress |
| -- elaboration warnings for the unit, since it is definitely |
| -- fine NOT to do dynamic checks at the first level (and such |
| -- checks will be suppressed because no elaboration boolean |
| -- is created for Elaborate_Body packages). |
| |
| -- But in the static model of elaboration, Elaborate_Body is |
| -- definitely NOT good enough to ensure elaboration safety on |
| -- its own, since the body may WITH other units that are not |
| -- safe from an elaboration point of view, so a client must |
| -- still do an Elaborate_All on such units. |
| |
| -- Debug flag -gnatdD restores the old behavior of 3.13, |
| -- where Elaborate_Body always suppressed elab warnings. |
| |
| if Dynamic_Elaboration_Checks or Debug_Flag_DD then |
| Set_Suppress_Elaboration_Warnings (Cunit_Ent); |
| end if; |
| end if; |
| end Elaborate_Body; |
| |
| ------------------------ |
| -- Elaboration_Checks -- |
| ------------------------ |
| |
| -- pragma Elaboration_Checks (Static | Dynamic); |
| |
| when Pragma_Elaboration_Checks => |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_Arg_Is_One_Of (Arg1, Name_Static, Name_Dynamic); |
| Dynamic_Elaboration_Checks := |
| (Chars (Get_Pragma_Arg (Arg1)) = Name_Dynamic); |
| |
| --------------- |
| -- Eliminate -- |
| --------------- |
| |
| -- pragma Eliminate ( |
| -- [Unit_Name =>] IDENTIFIER | |
| -- SELECTED_COMPONENT |
| -- [,[Entity =>] IDENTIFIER | |
| -- SELECTED_COMPONENT | |
| -- STRING_LITERAL] |
| -- [,[Parameter_Types =>] PARAMETER_TYPES] |
| -- [,[Result_Type =>] result_SUBTYPE_MARK]); |
| |
| -- PARAMETER_TYPES ::= |
| -- null |
| -- (SUBTYPE_MARK, SUBTYPE_MARK, ...) |
| |
| when Pragma_Eliminate => Eliminate : begin |
| GNAT_Pragma; |
| Check_Ada_83_Warning; |
| Check_Valid_Configuration_Pragma; |
| Check_At_Least_N_Arguments (1); |
| Check_At_Most_N_Arguments (4); |
| |
| if Arg_Count = 3 |
| and then Chars (Arg3) = Name_Result_Type |
| then |
| Arg4 := Arg3; |
| Arg3 := Empty; |
| |
| else |
| Check_Optional_Identifier (Arg1, "unit_name"); |
| Check_Optional_Identifier (Arg2, Name_Entity); |
| Check_Optional_Identifier (Arg3, Name_Parameter_Types); |
| Check_Optional_Identifier (Arg4, Name_Result_Type); |
| end if; |
| |
| Process_Eliminate_Pragma (Arg1, Arg2, Arg3, Arg4); |
| end Eliminate; |
| |
| ------------ |
| -- Export -- |
| ------------ |
| |
| -- pragma Export ( |
| -- [ Convention =>] convention_IDENTIFIER, |
| -- [ Entity =>] local_NAME |
| -- [, [External_Name =>] static_string_EXPRESSION ] |
| -- [, [Link_Name =>] static_string_EXPRESSION ]); |
| |
| when Pragma_Export => Export : declare |
| C : Convention_Id; |
| Def_Id : Entity_Id; |
| |
| begin |
| Check_Ada_83_Warning; |
| Check_At_Least_N_Arguments (2); |
| Check_At_Most_N_Arguments (4); |
| Process_Convention (C, Def_Id); |
| |
| if Ekind (Def_Id) /= E_Constant then |
| Note_Possible_Modification (Expression (Arg2)); |
| end if; |
| |
| Process_Interface_Name (Def_Id, Arg3, Arg4); |
| Set_Exported (Def_Id, Arg2); |
| end Export; |
| |
| ---------------------- |
| -- Export_Exception -- |
| ---------------------- |
| |
| -- pragma Export_Exception ( |
| -- [Internal =>] LOCAL_NAME, |
| -- [, [External =>] EXTERNAL_SYMBOL,] |
| -- [, [Form =>] Ada | VMS] |
| -- [, [Code =>] static_integer_EXPRESSION]); |
| |
| when Pragma_Export_Exception => Export_Exception : declare |
| Args : Args_List (1 .. 4); |
| Names : Name_List (1 .. 4) := ( |
| Name_Internal, |
| Name_External, |
| Name_Form, |
| Name_Code); |
| |
| Internal : Node_Id renames Args (1); |
| External : Node_Id renames Args (2); |
| Form : Node_Id renames Args (3); |
| Code : Node_Id renames Args (4); |
| |
| begin |
| GNAT_Pragma; |
| |
| if Inside_A_Generic then |
| Error_Pragma ("pragma% cannot be used for generic entities"); |
| end if; |
| |
| Gather_Associations (Names, Args); |
| Process_Extended_Import_Export_Exception_Pragma ( |
| Arg_Internal => Internal, |
| Arg_External => External, |
| Arg_Form => Form, |
| Arg_Code => Code); |
| |
| if not Is_VMS_Exception (Entity (Internal)) then |
| Set_Exported (Entity (Internal), Internal); |
| end if; |
| |
| end Export_Exception; |
| |
| --------------------- |
| -- Export_Function -- |
| --------------------- |
| |
| -- pragma Export_Function ( |
| -- [Internal =>] LOCAL_NAME, |
| -- [, [External =>] EXTERNAL_SYMBOL,] |
| -- [, [Parameter_Types =>] (PARAMETER_TYPES)] |
| -- [, [Result_Type =>] SUBTYPE_MARK] |
| -- [, [Mechanism =>] MECHANISM] |
| -- [, [Result_Mechanism =>] MECHANISM_NAME]); |
| |
| when Pragma_Export_Function => Export_Function : declare |
| Args : Args_List (1 .. 6); |
| Names : Name_List (1 .. 6) := ( |
| Name_Internal, |
| Name_External, |
| Name_Parameter_Types, |
| Name_Result_Type, |
| Name_Mechanism, |
| Name_Result_Mechanism); |
| |
| Internal : Node_Id renames Args (1); |
| External : Node_Id renames Args (2); |
| Parameter_Types : Node_Id renames Args (3); |
| Result_Type : Node_Id renames Args (4); |
| Mechanism : Node_Id renames Args (5); |
| Result_Mechanism : Node_Id renames Args (6); |
| |
| begin |
| GNAT_Pragma; |
| Gather_Associations (Names, Args); |
| Process_Extended_Import_Export_Subprogram_Pragma ( |
| Arg_Internal => Internal, |
| Arg_External => External, |
| Arg_Parameter_Types => Parameter_Types, |
| Arg_Result_Type => Result_Type, |
| Arg_Mechanism => Mechanism, |
| Arg_Result_Mechanism => Result_Mechanism); |
| end Export_Function; |
| |
| ------------------- |
| -- Export_Object -- |
| ------------------- |
| |
| -- pragma Export_Object ( |
| -- [Internal =>] LOCAL_NAME, |
| -- [, [External =>] EXTERNAL_SYMBOL] |
| -- [, [Size =>] EXTERNAL_SYMBOL]); |
| |
| when Pragma_Export_Object => Export_Object : declare |
| Args : Args_List (1 .. 3); |
| Names : Name_List (1 .. 3) := ( |
| Name_Internal, |
| Name_External, |
| Name_Size); |
| |
| Internal : Node_Id renames Args (1); |
| External : Node_Id renames Args (2); |
| Size : Node_Id renames Args (3); |
| |
| begin |
| GNAT_Pragma; |
| Gather_Associations (Names, Args); |
| Process_Extended_Import_Export_Object_Pragma ( |
| Arg_Internal => Internal, |
| Arg_External => External, |
| Arg_Size => Size); |
| end Export_Object; |
| |
| ---------------------- |
| -- Export_Procedure -- |
| ---------------------- |
| |
| -- pragma Export_Procedure ( |
| -- [Internal =>] LOCAL_NAME, |
| -- [, [External =>] EXTERNAL_SYMBOL,] |
| -- [, [Parameter_Types =>] (PARAMETER_TYPES)] |
| -- [, [Mechanism =>] MECHANISM]); |
| |
| when Pragma_Export_Procedure => Export_Procedure : declare |
| Args : Args_List (1 .. 4); |
| Names : Name_List (1 .. 4) := ( |
| Name_Internal, |
| Name_External, |
| Name_Parameter_Types, |
| Name_Mechanism); |
| |
| Internal : Node_Id renames Args (1); |
| External : Node_Id renames Args (2); |
| Parameter_Types : Node_Id renames Args (3); |
| Mechanism : Node_Id renames Args (4); |
| |
| begin |
| GNAT_Pragma; |
| Gather_Associations (Names, Args); |
| Process_Extended_Import_Export_Subprogram_Pragma ( |
| Arg_Internal => Internal, |
| Arg_External => External, |
| Arg_Parameter_Types => Parameter_Types, |
| Arg_Mechanism => Mechanism); |
| end Export_Procedure; |
| |
| ----------------------------- |
| -- Export_Valued_Procedure -- |
| ----------------------------- |
| |
| -- pragma Export_Valued_Procedure ( |
| -- [Internal =>] LOCAL_NAME, |
| -- [, [External =>] EXTERNAL_SYMBOL,] |
| -- [, [Parameter_Types =>] (PARAMETER_TYPES)] |
| -- [, [Mechanism =>] MECHANISM]); |
| |
| when Pragma_Export_Valued_Procedure => |
| Export_Valued_Procedure : declare |
| Args : Args_List (1 .. 4); |
| Names : Name_List (1 .. 4) := ( |
| Name_Internal, |
| Name_External, |
| Name_Parameter_Types, |
| Name_Mechanism); |
| |
| Internal : Node_Id renames Args (1); |
| External : Node_Id renames Args (2); |
| Parameter_Types : Node_Id renames Args (3); |
| Mechanism : Node_Id renames Args (4); |
| |
| begin |
| GNAT_Pragma; |
| Gather_Associations (Names, Args); |
| Process_Extended_Import_Export_Subprogram_Pragma ( |
| Arg_Internal => Internal, |
| Arg_External => External, |
| Arg_Parameter_Types => Parameter_Types, |
| Arg_Mechanism => Mechanism); |
| end Export_Valued_Procedure; |
| |
| ------------------- |
| -- Extend_System -- |
| ------------------- |
| |
| -- pragma Extend_System ([Name =>] Identifier); |
| |
| when Pragma_Extend_System => Extend_System : declare |
| begin |
| GNAT_Pragma; |
| Check_Valid_Configuration_Pragma; |
| Check_Arg_Count (1); |
| Check_Optional_Identifier (Arg1, Name_Name); |
| Check_Arg_Is_Identifier (Arg1); |
| |
| Get_Name_String (Chars (Expression (Arg1))); |
| |
| if Name_Len > 4 |
| and then Name_Buffer (1 .. 4) = "aux_" |
| then |
| if Present (System_Extend_Pragma_Arg) then |
| if Chars (Expression (Arg1)) = |
| Chars (Expression (System_Extend_Pragma_Arg)) |
| then |
| null; |
| else |
| Error_Msg_Sloc := Sloc (System_Extend_Pragma_Arg); |
| Error_Pragma ("pragma% conflicts with that at#"); |
| end if; |
| |
| else |
| System_Extend_Pragma_Arg := Arg1; |
| end if; |
| else |
| Error_Pragma ("incorrect name for pragma%, must be Aux_xxx"); |
| end if; |
| end Extend_System; |
| |
| ------------------------ |
| -- Extensions_Allowed -- |
| ------------------------ |
| |
| -- pragma Extensions_Allowed (ON | OFF); |
| |
| when Pragma_Extensions_Allowed => |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_No_Identifiers; |
| Check_Arg_Is_One_Of (Arg1, Name_On, Name_Off); |
| Extensions_Allowed := (Chars (Expression (Arg1)) = Name_On); |
| |
| -------------- |
| -- External -- |
| -------------- |
| |
| -- pragma External ( |
| -- [ Convention =>] convention_IDENTIFIER, |
| -- [ Entity =>] local_NAME |
| -- [, [External_Name =>] static_string_EXPRESSION ] |
| -- [, [Link_Name =>] static_string_EXPRESSION ]); |
| |
| when Pragma_External => External : declare |
| C : Convention_Id; |
| Def_Id : Entity_Id; |
| |
| begin |
| GNAT_Pragma; |
| Check_At_Least_N_Arguments (2); |
| Check_At_Most_N_Arguments (4); |
| Process_Convention (C, Def_Id); |
| Note_Possible_Modification (Expression (Arg2)); |
| Process_Interface_Name (Def_Id, Arg3, Arg4); |
| Set_Exported (Def_Id, Arg2); |
| end External; |
| |
| -------------------------- |
| -- External_Name_Casing -- |
| -------------------------- |
| |
| -- pragma External_Name_Casing ( |
| -- UPPERCASE | LOWERCASE |
| -- [, AS_IS | UPPERCASE | LOWERCASE]); |
| |
| when Pragma_External_Name_Casing => |
| |
| External_Name_Casing : declare |
| begin |
| GNAT_Pragma; |
| Check_No_Identifiers; |
| |
| if Arg_Count = 2 then |
| Check_Arg_Is_One_Of |
| (Arg2, Name_As_Is, Name_Uppercase, Name_Lowercase); |
| |
| case Chars (Get_Pragma_Arg (Arg2)) is |
| when Name_As_Is => |
| Opt.External_Name_Exp_Casing := As_Is; |
| |
| when Name_Uppercase => |
| Opt.External_Name_Exp_Casing := Uppercase; |
| |
| when Name_Lowercase => |
| Opt.External_Name_Exp_Casing := Lowercase; |
| |
| when others => |
| null; |
| end case; |
| |
| else |
| Check_Arg_Count (1); |
| end if; |
| |
| Check_Arg_Is_One_Of (Arg1, Name_Uppercase, Name_Lowercase); |
| |
| case Chars (Get_Pragma_Arg (Arg1)) is |
| when Name_Uppercase => |
| Opt.External_Name_Imp_Casing := Uppercase; |
| |
| when Name_Lowercase => |
| Opt.External_Name_Imp_Casing := Lowercase; |
| |
| when others => |
| null; |
| end case; |
| |
| end External_Name_Casing; |
| |
| --------------------------- |
| -- Finalize_Storage_Only -- |
| --------------------------- |
| |
| -- pragma Finalize_Storage_Only (first_subtype_LOCAL_NAME); |
| |
| when Pragma_Finalize_Storage_Only => Finalize_Storage : declare |
| Assoc : Node_Id := Arg1; |
| Type_Id : Node_Id := Expression (Assoc); |
| Typ : Entity_Id; |
| |
| begin |
| Check_No_Identifiers; |
| Check_Arg_Count (1); |
| Check_Arg_Is_Local_Name (Arg1); |
| |
| Find_Type (Type_Id); |
| Typ := Entity (Type_Id); |
| |
| if Typ = Any_Type |
| or else Rep_Item_Too_Early (Typ, N) |
| then |
| return; |
| else |
| Typ := Underlying_Type (Typ); |
| end if; |
| |
| if not Is_Controlled (Typ) then |
| Error_Pragma ("pragma% must specify controlled type"); |
| end if; |
| |
| Check_First_Subtype (Arg1); |
| |
| if Finalize_Storage_Only (Typ) then |
| Error_Pragma ("duplicate pragma%, only one allowed"); |
| |
| elsif not Rep_Item_Too_Late (Typ, N) then |
| Set_Finalize_Storage_Only (Typ, True); |
| end if; |
| end Finalize_Storage; |
| |
| -------------------------- |
| -- Float_Representation -- |
| -------------------------- |
| |
| -- pragma Float_Representation (VAX_Float | IEEE_Float); |
| |
| when Pragma_Float_Representation => Float_Representation : declare |
| Argx : Node_Id; |
| Digs : Nat; |
| Ent : Entity_Id; |
| |
| begin |
| GNAT_Pragma; |
| |
| if Arg_Count = 1 then |
| Check_Valid_Configuration_Pragma; |
| else |
| Check_Arg_Count (2); |
| Check_Optional_Identifier (Arg2, Name_Entity); |
| Check_Arg_Is_Local_Name (Arg2); |
| end if; |
| |
| Check_No_Identifier (Arg1); |
| Check_Arg_Is_One_Of (Arg1, Name_VAX_Float, Name_IEEE_Float); |
| |
| if not OpenVMS_On_Target then |
| if Chars (Expression (Arg1)) = Name_VAX_Float then |
| Error_Pragma |
| ("?pragma% ignored (applies only to Open'V'M'S)"); |
| end if; |
| |
| return; |
| end if; |
| |
| -- One argument case |
| |
| if Arg_Count = 1 then |
| |
| if Chars (Expression (Arg1)) = Name_VAX_Float then |
| |
| if Opt.Float_Format = 'I' then |
| Error_Pragma ("'I'E'E'E format previously specified"); |
| end if; |
| |
| Opt.Float_Format := 'V'; |
| |
| else |
| if Opt.Float_Format = 'V' then |
| Error_Pragma ("'V'A'X format previously specified"); |
| end if; |
| |
| Opt.Float_Format := 'I'; |
| end if; |
| |
| Set_Standard_Fpt_Formats; |
| |
| -- Two argument case |
| |
| else |
| Argx := Get_Pragma_Arg (Arg2); |
| |
| if not Is_Entity_Name (Argx) |
| or else not Is_Floating_Point_Type (Entity (Argx)) |
| then |
| Error_Pragma_Arg |
| ("second argument of% pragma must be floating-point type", |
| Arg2); |
| end if; |
| |
| Ent := Entity (Argx); |
| Digs := UI_To_Int (Digits_Value (Ent)); |
| |
| -- Two arguments, VAX_Float case |
| |
| if Chars (Expression (Arg1)) = Name_VAX_Float then |
| |
| case Digs is |
| when 6 => Set_F_Float (Ent); |
| when 9 => Set_D_Float (Ent); |
| when 15 => Set_G_Float (Ent); |
| |
| when others => |
| Error_Pragma_Arg |
| ("wrong digits value, must be 6,9 or 15", Arg2); |
| end case; |
| |
| -- Two arguments, IEEE_Float case |
| |
| else |
| case Digs is |
| when 6 => Set_IEEE_Short (Ent); |
| when 15 => Set_IEEE_Long (Ent); |
| |
| when others => |
| Error_Pragma_Arg |
| ("wrong digits value, must be 6 or 15", Arg2); |
| end case; |
| end if; |
| end if; |
| |
| end Float_Representation; |
| |
| ----------- |
| -- Ident -- |
| ----------- |
| |
| -- pragma Ident (static_string_EXPRESSION) |
| |
| -- Note: pragma Comment shares this processing. Pragma Comment |
| -- is identical to Ident, except that the restriction of the |
| -- argument to 31 characters and the placement restrictions |
| -- are not enforced for pragma Comment. |
| |
| when Pragma_Ident | Pragma_Comment => Ident : declare |
| Str : Node_Id; |
| |
| begin |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_No_Identifiers; |
| Check_Arg_Is_Static_Expression (Arg1, Standard_String); |
| |
| -- For pragma Ident, preserve DEC compatibility by requiring |
| -- the pragma to appear in a declarative part or package spec. |
| |
| if Prag_Id = Pragma_Ident then |
| Check_Is_In_Decl_Part_Or_Package_Spec; |
| end if; |
| |
| Str := Expr_Value_S (Expression (Arg1)); |
| |
| -- For pragma Ident, preserve DEC compatibility by limiting |
| -- the length to 31 characters. |
| |
| if Prag_Id = Pragma_Ident |
| and then String_Length (Strval (Str)) > 31 |
| then |
| Error_Pragma_Arg |
| ("argument for pragma% is too long, maximum is 31", Arg1); |
| end if; |
| |
| declare |
| CS : Node_Id; |
| GP : Node_Id; |
| |
| begin |
| GP := Parent (Parent (N)); |
| |
| if Nkind (GP) = N_Package_Declaration |
| or else |
| Nkind (GP) = N_Generic_Package_Declaration |
| then |
| GP := Parent (GP); |
| end if; |
| |
| -- If we have a compilation unit, then record the ident |
| -- value, checking for improper duplication. |
| |
| if Nkind (GP) = N_Compilation_Unit then |
| CS := Ident_String (Current_Sem_Unit); |
| |
| if Present (CS) then |
| |
| -- For Ident, we do not permit multiple instances |
| |
| if Prag_Id = Pragma_Ident then |
| Error_Pragma ("duplicate% pragma not permitted"); |
| |
| -- For Comment, we concatenate the string, unless we |
| -- want to preserve the tree structure for ASIS. |
| |
| elsif not Tree_Output then |
| Start_String (Strval (CS)); |
| Store_String_Char (' '); |
| Store_String_Chars (Strval (Str)); |
| Set_Strval (CS, End_String); |
| end if; |
| |
| else |
| -- In VMS, the effect of IDENT is achieved by passing |
| -- IDENTIFICATION=name as a --for-linker switch. |
| |
| if OpenVMS_On_Target then |
| Start_String; |
| Store_String_Chars |
| ("--for-linker=IDENTIFICATION="); |
| String_To_Name_Buffer (Strval (Str)); |
| Store_String_Chars (Name_Buffer (1 .. Name_Len)); |
| |
| -- Only the last processed IDENT is saved. The main |
| -- purpose is so an IDENT associated with a main |
| -- procedure will be used in preference to an IDENT |
| -- associated with a with'd package. |
| |
| Replace_Linker_Option_String |
| (End_String, "--for-linker=IDENTIFICATION="); |
| end if; |
| |
| Set_Ident_String (Current_Sem_Unit, Str); |
| end if; |
| |
| -- For subunits, we just ignore the Ident, since in GNAT |
| -- these are not separate object files, and hence not |
| -- separate units in the unit table. |
| |
| elsif Nkind (GP) = N_Subunit then |
| null; |
| |
| -- Otherwise we have a misplaced pragma Ident, but we ignore |
| -- this if we are in an instantiation, since it comes from |
| -- a generic, and has no relevance to the instantiation. |
| |
| elsif Prag_Id = Pragma_Ident then |
| if Instantiation_Location (Loc) = No_Location then |
| Error_Pragma ("pragma% only allowed at outer level"); |
| end if; |
| end if; |
| end; |
| end Ident; |
| |
| ------------ |
| -- Import -- |
| ------------ |
| |
| -- pragma Import ( |
| -- [ Convention =>] convention_IDENTIFIER, |
| -- [ Entity =>] local_NAME |
| -- [, [External_Name =>] static_string_EXPRESSION ] |
| -- [, [Link_Name =>] static_string_EXPRESSION ]); |
| |
| when Pragma_Import => |
| Check_Ada_83_Warning; |
| Check_At_Least_N_Arguments (2); |
| Check_At_Most_N_Arguments (4); |
| Process_Import_Or_Interface; |
| |
| ---------------------- |
| -- Import_Exception -- |
| ---------------------- |
| |
| -- pragma Import_Exception ( |
| -- [Internal =>] LOCAL_NAME, |
| -- [, [External =>] EXTERNAL_SYMBOL,] |
| -- [, [Form =>] Ada | VMS] |
| -- [, [Code =>] static_integer_EXPRESSION]); |
| |
| when Pragma_Import_Exception => Import_Exception : declare |
| Args : Args_List (1 .. 4); |
| Names : Name_List (1 .. 4) := ( |
| Name_Internal, |
| Name_External, |
| Name_Form, |
| Name_Code); |
| |
| Internal : Node_Id renames Args (1); |
| External : Node_Id renames Args (2); |
| Form : Node_Id renames Args (3); |
| Code : Node_Id renames Args (4); |
| |
| begin |
| GNAT_Pragma; |
| Gather_Associations (Names, Args); |
| |
| if Present (External) and then Present (Code) then |
| Error_Pragma |
| ("cannot give both External and Code options for pragma%"); |
| end if; |
| |
| Process_Extended_Import_Export_Exception_Pragma ( |
| Arg_Internal => Internal, |
| Arg_External => External, |
| Arg_Form => Form, |
| Arg_Code => Code); |
| |
| if not Is_VMS_Exception (Entity (Internal)) then |
| Set_Imported (Entity (Internal)); |
| end if; |
| |
| end Import_Exception; |
| |
| --------------------- |
| -- Import_Function -- |
| --------------------- |
| |
| -- pragma Import_Function ( |
| -- [Internal =>] LOCAL_NAME, |
| -- [, [External =>] EXTERNAL_SYMBOL] |
| -- [, [Parameter_Types =>] (PARAMETER_TYPES)] |
| -- [, [Result_Type =>] SUBTYPE_MARK] |
| -- [, [Mechanism =>] MECHANISM] |
| -- [, [Result_Mechanism =>] MECHANISM_NAME] |
| -- [, [First_Optional_Parameter =>] IDENTIFIER]); |
| |
| when Pragma_Import_Function => Import_Function : declare |
| Args : Args_List (1 .. 7); |
| Names : Name_List (1 .. 7) := ( |
| Name_Internal, |
| Name_External, |
| Name_Parameter_Types, |
| Name_Result_Type, |
| Name_Mechanism, |
| Name_Result_Mechanism, |
| Name_First_Optional_Parameter); |
| |
| Internal : Node_Id renames Args (1); |
| External : Node_Id renames Args (2); |
| Parameter_Types : Node_Id renames Args (3); |
| Result_Type : Node_Id renames Args (4); |
| Mechanism : Node_Id renames Args (5); |
| Result_Mechanism : Node_Id renames Args (6); |
| First_Optional_Parameter : Node_Id renames Args (7); |
| |
| begin |
| GNAT_Pragma; |
| Gather_Associations (Names, Args); |
| Process_Extended_Import_Export_Subprogram_Pragma ( |
| Arg_Internal => Internal, |
| Arg_External => External, |
| Arg_Parameter_Types => Parameter_Types, |
| Arg_Result_Type => Result_Type, |
| Arg_Mechanism => Mechanism, |
| Arg_Result_Mechanism => Result_Mechanism, |
| Arg_First_Optional_Parameter => First_Optional_Parameter); |
| end Import_Function; |
| |
| ------------------- |
| -- Import_Object -- |
| ------------------- |
| |
| -- pragma Import_Object ( |
| -- [Internal =>] LOCAL_NAME, |
| -- [, [External =>] EXTERNAL_SYMBOL] |
| -- [, [Size =>] EXTERNAL_SYMBOL]); |
| |
| when Pragma_Import_Object => Import_Object : declare |
| Args : Args_List (1 .. 3); |
| Names : Name_List (1 .. 3) := ( |
| Name_Internal, |
| Name_External, |
| Name_Size); |
| |
| Internal : Node_Id renames Args (1); |
| External : Node_Id renames Args (2); |
| Size : Node_Id renames Args (3); |
| |
| begin |
| GNAT_Pragma; |
| Gather_Associations (Names, Args); |
| Process_Extended_Import_Export_Object_Pragma ( |
| Arg_Internal => Internal, |
| Arg_External => External, |
| Arg_Size => Size); |
| end Import_Object; |
| |
| ---------------------- |
| -- Import_Procedure -- |
| ---------------------- |
| |
| -- pragma Import_Procedure ( |
| -- [Internal =>] LOCAL_NAME, |
| -- [, [External =>] EXTERNAL_SYMBOL] |
| -- [, [Parameter_Types =>] (PARAMETER_TYPES)] |
| -- [, [Mechanism =>] MECHANISM] |
| -- [, [First_Optional_Parameter =>] IDENTIFIER]); |
| |
| when Pragma_Import_Procedure => Import_Procedure : declare |
| Args : Args_List (1 .. 5); |
| Names : Name_List (1 .. 5) := ( |
| Name_Internal, |
| Name_External, |
| Name_Parameter_Types, |
| Name_Mechanism, |
| Name_First_Optional_Parameter); |
| |
| Internal : Node_Id renames Args (1); |
| External : Node_Id renames Args (2); |
| Parameter_Types : Node_Id renames Args (3); |
| Mechanism : Node_Id renames Args (4); |
| First_Optional_Parameter : Node_Id renames Args (5); |
| |
| begin |
| GNAT_Pragma; |
| Gather_Associations (Names, Args); |
| Process_Extended_Import_Export_Subprogram_Pragma ( |
| Arg_Internal => Internal, |
| Arg_External => External, |
| Arg_Parameter_Types => Parameter_Types, |
| Arg_Mechanism => Mechanism, |
| Arg_First_Optional_Parameter => First_Optional_Parameter); |
| end Import_Procedure; |
| |
| ----------------------------- |
| -- Import_Valued_Procedure -- |
| ----------------------------- |
| |
| -- pragma Import_Valued_Procedure ( |
| -- [Internal =>] LOCAL_NAME, |
| -- [, [External =>] EXTERNAL_SYMBOL] |
| -- [, [Parameter_Types =>] (PARAMETER_TYPES)] |
| -- [, [Mechanism =>] MECHANISM] |
| -- [, [First_Optional_Parameter =>] IDENTIFIER]); |
| |
| when Pragma_Import_Valued_Procedure => |
| Import_Valued_Procedure : declare |
| Args : Args_List (1 .. 5); |
| Names : Name_List (1 .. 5) := ( |
| Name_Internal, |
| Name_External, |
| Name_Parameter_Types, |
| Name_Mechanism, |
| Name_First_Optional_Parameter); |
| |
| Internal : Node_Id renames Args (1); |
| External : Node_Id renames Args (2); |
| Parameter_Types : Node_Id renames Args (3); |
| Mechanism : Node_Id renames Args (4); |
| First_Optional_Parameter : Node_Id renames Args (5); |
| |
| begin |
| GNAT_Pragma; |
| Gather_Associations (Names, Args); |
| Process_Extended_Import_Export_Subprogram_Pragma ( |
| Arg_Internal => Internal, |
| Arg_External => External, |
| Arg_Parameter_Types => Parameter_Types, |
| Arg_Mechanism => Mechanism, |
| Arg_First_Optional_Parameter => First_Optional_Parameter); |
| end Import_Valued_Procedure; |
| |
| ------------------------ |
| -- Initialize_Scalars -- |
| ------------------------ |
| |
| -- pragma Initialize_Scalars; |
| |
| when Pragma_Initialize_Scalars => |
| GNAT_Pragma; |
| Check_Arg_Count (0); |
| Check_Valid_Configuration_Pragma; |
| Init_Or_Norm_Scalars := True; |
| Initialize_Scalars := True; |
| |
| ------------ |
| -- Inline -- |
| ------------ |
| |
| -- pragma Inline ( NAME {, NAME} ); |
| |
| when Pragma_Inline => |
| |
| -- Pragma is active if inlining option is active |
| |
| if Inline_Active then |
| Process_Inline (True); |
| |
| -- Pragma is active in a predefined file in no run time mode |
| |
| elsif No_Run_Time |
| and then |
| Is_Predefined_File_Name (Unit_File_Name (Current_Sem_Unit)) |
| then |
| Process_Inline (True); |
| |
| else |
| Process_Inline (False); |
| end if; |
| |
| ------------------- |
| -- Inline_Always -- |
| ------------------- |
| |
| -- pragma Inline_Always ( NAME {, NAME} ); |
| |
| when Pragma_Inline_Always => |
| Process_Inline (True); |
| |
| -------------------- |
| -- Inline_Generic -- |
| -------------------- |
| |
| -- pragma Inline_Generic (NAME {, NAME}); |
| |
| when Pragma_Inline_Generic => |
| Process_Generic_List; |
| |
| ---------------------- |
| -- Inspection_Point -- |
| ---------------------- |
| |
| -- pragma Inspection_Point [(object_NAME {, object_NAME})]; |
| |
| when Pragma_Inspection_Point => Inspection_Point : declare |
| Arg : Node_Id; |
| Exp : Node_Id; |
| |
| begin |
| if Arg_Count > 0 then |
| Arg := Arg1; |
| loop |
| Exp := Expression (Arg); |
| Analyze (Exp); |
| |
| if not Is_Entity_Name (Exp) |
| or else not Is_Object (Entity (Exp)) |
| then |
| Error_Pragma_Arg ("object name required", Arg); |
| end if; |
| |
| Next (Arg); |
| exit when No (Arg); |
| end loop; |
| end if; |
| end Inspection_Point; |
| |
| --------------- |
| -- Interface -- |
| --------------- |
| |
| -- pragma Interface ( |
| -- convention_IDENTIFIER, |
| -- local_NAME ); |
| |
| when Pragma_Interface => |
| GNAT_Pragma; |
| Check_Arg_Count (2); |
| Check_No_Identifiers; |
| Process_Import_Or_Interface; |
| |
| -------------------- |
| -- Interface_Name -- |
| -------------------- |
| |
| -- pragma Interface_Name ( |
| -- [ Entity =>] local_NAME |
| -- [,[External_Name =>] static_string_EXPRESSION ] |
| -- [,[Link_Name =>] static_string_EXPRESSION ]); |
| |
| when Pragma_Interface_Name => Interface_Name : declare |
| Id : Node_Id; |
| Def_Id : Entity_Id; |
| Hom_Id : Entity_Id; |
| Found : Boolean; |
| |
| begin |
| GNAT_Pragma; |
| Check_At_Least_N_Arguments (2); |
| Check_At_Most_N_Arguments (3); |
| Id := Expression (Arg1); |
| Analyze (Id); |
| |
| if not Is_Entity_Name (Id) then |
| Error_Pragma_Arg |
| ("first argument for pragma% must be entity name", Arg1); |
| elsif Etype (Id) = Any_Type then |
| return; |
| else |
| Def_Id := Entity (Id); |
| end if; |
| |
| -- Special DEC-compatible processing for the object case, |
| -- forces object to be imported. |
| |
| if Ekind (Def_Id) = E_Variable then |
| Kill_Size_Check_Code (Def_Id); |
| Note_Possible_Modification (Id); |
| |
| -- Initialization is not allowed for imported variable |
| |
| if Present (Expression (Parent (Def_Id))) |
| and then Comes_From_Source (Expression (Parent (Def_Id))) |
| then |
| Error_Msg_Sloc := Sloc (Def_Id); |
| Error_Pragma_Arg |
| ("no initialization allowed for declaration of& #", |
| Arg2); |
| |
| else |
| -- For compatibility, support VADS usage of providing both |
| -- pragmas Interface and Interface_Name to obtain the effect |
| -- of a single Import pragma. |
| |
| if Is_Imported (Def_Id) |
| and then Present (First_Rep_Item (Def_Id)) |
| and then Nkind (First_Rep_Item (Def_Id)) = N_Pragma |
| and then Chars (First_Rep_Item (Def_Id)) = Name_Interface |
| then |
| null; |
| else |
| Set_Imported (Def_Id); |
| end if; |
| |
| Set_Is_Public (Def_Id); |
| Process_Interface_Name (Def_Id, Arg2, Arg3); |
| end if; |
| |
| -- Otherwise must be subprogram |
| |
| elsif not Is_Subprogram (Def_Id) then |
| Error_Pragma_Arg |
| ("argument of pragma% is not subprogram", Arg1); |
| |
| else |
| Check_At_Most_N_Arguments (3); |
| Hom_Id := Def_Id; |
| Found := False; |
| |
| -- Loop through homonyms |
| |
| loop |
| Def_Id := Get_Base_Subprogram (Hom_Id); |
| |
| if Is_Imported (Def_Id) then |
| Process_Interface_Name (Def_Id, Arg2, Arg3); |
| Found := True; |
| end if; |
| |
| Hom_Id := Homonym (Hom_Id); |
| |
| exit when No (Hom_Id) |
| or else Scope (Hom_Id) /= Current_Scope; |
| end loop; |
| |
| if not Found then |
| Error_Pragma_Arg |
| ("argument of pragma% is not imported subprogram", |
| Arg1); |
| end if; |
| end if; |
| end Interface_Name; |
| |
| ----------------------- |
| -- Interrupt_Handler -- |
| ----------------------- |
| |
| -- pragma Interrupt_Handler (handler_NAME); |
| |
| when Pragma_Interrupt_Handler => |
| Check_Ada_83_Warning; |
| Check_Arg_Count (1); |
| Check_No_Identifiers; |
| Check_Interrupt_Or_Attach_Handler; |
| Process_Interrupt_Or_Attach_Handler; |
| |
| ------------------------ |
| -- Interrupt_Priority -- |
| ------------------------ |
| |
| -- pragma Interrupt_Priority [(EXPRESSION)]; |
| |
| when Pragma_Interrupt_Priority => Interrupt_Priority : declare |
| P : constant Node_Id := Parent (N); |
| Arg : Node_Id; |
| |
| begin |
| Check_Ada_83_Warning; |
| |
| if Arg_Count /= 0 then |
| Arg := Expression (Arg1); |
| Check_Arg_Count (1); |
| Check_No_Identifiers; |
| |
| -- Set In_Default_Expression for per-object case??? |
| |
| Analyze_And_Resolve (Arg, Standard_Integer); |
| if Expander_Active then |
| Rewrite (Arg, |
| Convert_To (RTE (RE_Interrupt_Priority), Arg)); |
| end if; |
| end if; |
| |
| if Nkind (P) /= N_Task_Definition |
| and then Nkind (P) /= N_Protected_Definition |
| then |
| Pragma_Misplaced; |
| return; |
| |
| elsif Has_Priority_Pragma (P) then |
| Error_Pragma ("duplicate pragma% not allowed"); |
| |
| else |
| Set_Has_Priority_Pragma (P, True); |
| Record_Rep_Item (Defining_Identifier (Parent (P)), N); |
| end if; |
| end Interrupt_Priority; |
| |
| ---------------------- |
| -- Java_Constructor -- |
| ---------------------- |
| |
| -- pragma Java_Constructor ([Entity =>] LOCAL_NAME); |
| |
| when Pragma_Java_Constructor => Java_Constructor : declare |
| Id : Entity_Id; |
| Def_Id : Entity_Id; |
| Hom_Id : Entity_Id; |
| |
| begin |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_Optional_Identifier (Arg1, Name_Entity); |
| Check_Arg_Is_Local_Name (Arg1); |
| |
| Id := Expression (Arg1); |
| Find_Program_Unit_Name (Id); |
| |
| -- If we did not find the name, we are done |
| |
| if Etype (Id) = Any_Type then |
| return; |
| end if; |
| |
| Hom_Id := Entity (Id); |
| |
| -- Loop through homonyms |
| |
| loop |
| Def_Id := Get_Base_Subprogram (Hom_Id); |
| |
| -- The constructor is required to be a function returning |
| -- an access type whose designated type has convention Java. |
| |
| if Ekind (Def_Id) = E_Function |
| and then Ekind (Etype (Def_Id)) in Access_Kind |
| and then |
| (Atree.Convention |
| (Designated_Type (Etype (Def_Id))) = Convention_Java |
| or else |
| Atree.Convention |
| (Root_Type (Designated_Type (Etype (Def_Id)))) |
| = Convention_Java) |
| then |
| Set_Is_Constructor (Def_Id); |
| Set_Convention (Def_Id, Convention_Java); |
| |
| else |
| Error_Pragma_Arg |
| ("pragma% requires function returning a 'Java access type", |
| Arg1); |
| end if; |
| |
| Hom_Id := Homonym (Hom_Id); |
| |
| exit when No (Hom_Id) or else Scope (Hom_Id) /= Current_Scope; |
| end loop; |
| end Java_Constructor; |
| |
| ---------------------- |
| -- Java_Interface -- |
| ---------------------- |
| |
| -- pragma Java_Interface ([Entity =>] LOCAL_NAME); |
| |
| when Pragma_Java_Interface => Java_Interface : declare |
| Arg : Node_Id; |
| Typ : Entity_Id; |
| |
| begin |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_Optional_Identifier (Arg1, Name_Entity); |
| Check_Arg_Is_Local_Name (Arg1); |
| |
| Arg := Expression (Arg1); |
| Analyze (Arg); |
| |
| if Etype (Arg) = Any_Type then |
| return; |
| end if; |
| |
| if not Is_Entity_Name (Arg) |
| or else not Is_Type (Entity (Arg)) |
| then |
| Error_Pragma_Arg ("pragma% requires a type mark", Arg1); |
| end if; |
| |
| Typ := Underlying_Type (Entity (Arg)); |
| |
| -- For now we simply check some of the semantic constraints |
| -- on the type. This currently leaves out some restrictions |
| -- on interface types, namely that the parent type must be |
| -- java.lang.Object.Typ and that all primitives of the type |
| -- should be declared abstract. ??? |
| |
| if not Is_Tagged_Type (Typ) or else not Is_Abstract (Typ) then |
| Error_Pragma_Arg ("pragma% requires an abstract " |
| & "tagged type", Arg1); |
| |
| elsif not Has_Discriminants (Typ) |
| or else Ekind (Etype (First_Discriminant (Typ))) |
| /= E_Anonymous_Access_Type |
| or else |
| not Is_Class_Wide_Type |
| (Designated_Type (Etype (First_Discriminant (Typ)))) |
| then |
| Error_Pragma_Arg |
| ("type must have a class-wide access discriminant", Arg1); |
| end if; |
| end Java_Interface; |
| |
| ------------- |
| -- License -- |
| ------------- |
| |
| -- pragma License (RESTRICTED | UNRESRICTED | GPL | MODIFIED_GPL); |
| |
| when Pragma_License => |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_No_Identifiers; |
| Check_Valid_Configuration_Pragma; |
| Check_Arg_Is_Identifier (Arg1); |
| |
| declare |
| Sind : constant Source_File_Index := |
| Source_Index (Current_Sem_Unit); |
| |
| begin |
| case Chars (Get_Pragma_Arg (Arg1)) is |
| when Name_GPL => |
| Set_License (Sind, GPL); |
| |
| when Name_Modified_GPL => |
| Set_License (Sind, Modified_GPL); |
| |
| when Name_Restricted => |
| Set_License (Sind, Restricted); |
| |
| when Name_Unrestricted => |
| Set_License (Sind, Unrestricted); |
| |
| when others => |
| Error_Pragma_Arg ("invalid license name", Arg1); |
| end case; |
| end; |
| |
| --------------- |
| -- Link_With -- |
| --------------- |
| |
| -- pragma Link_With (string_EXPRESSION {, string_EXPRESSION}); |
| |
| when Pragma_Link_With => Link_With : declare |
| Arg : Node_Id; |
| |
| begin |
| GNAT_Pragma; |
| |
| if Operating_Mode = Generate_Code |
| and then In_Extended_Main_Source_Unit (N) |
| then |
| Check_At_Least_N_Arguments (1); |
| Check_No_Identifiers; |
| Check_Is_In_Decl_Part_Or_Package_Spec; |
| Check_Arg_Is_Static_Expression (Arg1, Standard_String); |
| Start_String; |
| |
| Arg := Arg1; |
| while Present (Arg) loop |
| Check_Arg_Is_Static_Expression (Arg, Standard_String); |
| |
| -- Store argument, converting sequences of spaces to |
| -- a single null character (this is the difference in |
| -- processing between Link_With, and Linker_Options). |
| |
| declare |
| C : constant Char_Code := Get_Char_Code (' '); |
| S : constant String_Id := |
| Strval (Expr_Value_S (Expression (Arg))); |
| |
| F : Nat := 1; |
| L : Nat := String_Length (S); |
| |
| procedure Skip_Spaces; |
| -- Advance F past any spaces |
| |
| procedure Skip_Spaces is |
| begin |
| while F <= L and then Get_String_Char (S, F) = C loop |
| F := F + 1; |
| end loop; |
| end Skip_Spaces; |
| |
| begin |
| Skip_Spaces; -- skip leading spaces |
| |
| -- Loop through characters, changing any embedded |
| -- sequence of spaces to a single null character |
| -- (this is how Link_With/Linker_Options differ) |
| |
| while F <= L loop |
| if Get_String_Char (S, F) = C then |
| Skip_Spaces; |
| exit when F > L; |
| Store_String_Char (ASCII.NUL); |
| |
| else |
| Store_String_Char (Get_String_Char (S, F)); |
| F := F + 1; |
| end if; |
| end loop; |
| end; |
| |
| Arg := Next (Arg); |
| |
| if Present (Arg) then |
| Store_String_Char (ASCII.NUL); |
| end if; |
| end loop; |
| |
| Store_Linker_Option_String (End_String); |
| end if; |
| end Link_With; |
| |
| ------------------ |
| -- Linker_Alias -- |
| ------------------ |
| |
| -- pragma Linker_Alias ( |
| -- [Entity =>] LOCAL_NAME |
| -- [Alias =>] static_string_EXPRESSION); |
| |
| when Pragma_Linker_Alias => |
| GNAT_Pragma; |
| Check_Arg_Count (2); |
| Check_Optional_Identifier (Arg1, Name_Entity); |
| Check_Optional_Identifier (Arg2, "alias"); |
| Check_Arg_Is_Library_Level_Local_Name (Arg1); |
| Check_Arg_Is_Static_Expression (Arg2, Standard_String); |
| |
| -- The only processing required is to link this item on to the |
| -- list of rep items for the given entity. This is accomplished |
| -- by the call to Rep_Item_Too_Late (when no error is detected |
| -- and False is returned). |
| |
| if Rep_Item_Too_Late (Entity (Expression (Arg1)), N) then |
| return; |
| else |
| Set_Has_Gigi_Rep_Item (Entity (Expression (Arg1))); |
| end if; |
| |
| -------------------- |
| -- Linker_Options -- |
| -------------------- |
| |
| -- pragma Linker_Options (string_EXPRESSION {, string_EXPRESSION}); |
| |
| -- Note: the use of multiple arguments is a GNAT extension |
| |
| when Pragma_Linker_Options => Linker_Options : declare |
| Arg : Node_Id; |
| |
| begin |
| if Operating_Mode = Generate_Code |
| and then In_Extended_Main_Source_Unit (N) |
| then |
| Check_Ada_83_Warning; |
| Check_At_Least_N_Arguments (1); |
| Check_No_Identifiers; |
| Check_Is_In_Decl_Part_Or_Package_Spec; |
| Check_Arg_Is_Static_Expression (Arg1, Standard_String); |
| Start_String (Strval (Expr_Value_S (Expression (Arg1)))); |
| |
| Arg := Arg2; |
| while Present (Arg) loop |
| Check_Arg_Is_Static_Expression (Arg, Standard_String); |
| Store_String_Char (ASCII.NUL); |
| Store_String_Chars |
| (Strval (Expr_Value_S (Expression (Arg)))); |
| Arg := Next (Arg); |
| end loop; |
| |
| Store_Linker_Option_String (End_String); |
| end if; |
| end Linker_Options; |
| |
| -------------------- |
| -- Linker_Section -- |
| -------------------- |
| |
| -- pragma Linker_Section ( |
| -- [Entity =>] LOCAL_NAME |
| -- [Section =>] static_string_EXPRESSION); |
| |
| when Pragma_Linker_Section => |
| GNAT_Pragma; |
| Check_Arg_Count (2); |
| Check_Optional_Identifier (Arg1, Name_Entity); |
| Check_Optional_Identifier (Arg2, Name_Section); |
| Check_Arg_Is_Library_Level_Local_Name (Arg1); |
| Check_Arg_Is_Static_Expression (Arg2, Standard_String); |
| |
| -- The only processing required is to link this item on to the |
| -- list of rep items for the given entity. This is accomplished |
| -- by the call to Rep_Item_Too_Late (when no error is detected |
| -- and False is returned). |
| |
| if Rep_Item_Too_Late (Entity (Expression (Arg1)), N) then |
| return; |
| else |
| Set_Has_Gigi_Rep_Item (Entity (Expression (Arg1))); |
| end if; |
| |
| ---------- |
| -- List -- |
| ---------- |
| |
| -- pragma List (On | Off) |
| |
| -- There is nothing to do here, since we did all the processing |
| -- for this pragma in Par.Prag (so that it works properly even in |
| -- syntax only mode) |
| |
| when Pragma_List => |
| null; |
| |
| -------------------- |
| -- Locking_Policy -- |
| -------------------- |
| |
| -- pragma Locking_Policy (policy_IDENTIFIER); |
| |
| when Pragma_Locking_Policy => declare |
| LP : Character; |
| |
| begin |
| Check_Ada_83_Warning; |
| Check_Arg_Count (1); |
| Check_No_Identifiers; |
| Check_Arg_Is_Locking_Policy (Arg1); |
| Check_Valid_Configuration_Pragma; |
| Get_Name_String (Chars (Expression (Arg1))); |
| LP := Fold_Upper (Name_Buffer (1)); |
| |
| if Locking_Policy /= ' ' |
| and then Locking_Policy /= LP |
| then |
| Error_Msg_Sloc := Locking_Policy_Sloc; |
| Error_Pragma ("locking policy incompatible with policy#"); |
| else |
| Locking_Policy := LP; |
| Locking_Policy_Sloc := Loc; |
| end if; |
| end; |
| |
| ---------------- |
| -- Long_Float -- |
| ---------------- |
| |
| -- pragma Long_Float (D_Float | G_Float); |
| |
| when Pragma_Long_Float => |
| GNAT_Pragma; |
| Check_Valid_Configuration_Pragma; |
| Check_Arg_Count (1); |
| Check_No_Identifier (Arg1); |
| Check_Arg_Is_One_Of (Arg1, Name_D_Float, Name_G_Float); |
| |
| if not OpenVMS_On_Target then |
| Error_Pragma ("?pragma% ignored (applies only to Open'V'M'S)"); |
| end if; |
| |
| -- D_Float case |
| |
| if Chars (Expression (Arg1)) = Name_D_Float then |
| if Opt.Float_Format_Long = 'G' then |
| Error_Pragma ("G_Float previously specified"); |
| end if; |
| |
| Opt.Float_Format_Long := 'D'; |
| |
| -- G_Float case (this is the default, does not need overriding) |
| |
| else |
| if Opt.Float_Format_Long = 'D' then |
| Error_Pragma ("D_Float previously specified"); |
| end if; |
| |
| Opt.Float_Format_Long := 'G'; |
| end if; |
| |
| Set_Standard_Fpt_Formats; |
| |
| ----------------------- |
| -- Machine_Attribute -- |
| ----------------------- |
| |
| -- pragma Machine_Attribute ( |
| -- [Entity =>] LOCAL_NAME, |
| -- [Attribute_Name =>] static_string_EXPRESSION |
| -- [,[Info =>] static_string_EXPRESSION] ); |
| |
| when Pragma_Machine_Attribute => Machine_Attribute : declare |
| Def_Id : Entity_Id; |
| |
| begin |
| GNAT_Pragma; |
| |
| if Arg_Count = 3 then |
| Check_Optional_Identifier (Arg3, "info"); |
| Check_Arg_Is_Static_Expression (Arg3, Standard_String); |
| else |
| Check_Arg_Count (2); |
| end if; |
| |
| Check_Arg_Is_Local_Name (Arg1); |
| Check_Optional_Identifier (Arg2, "attribute_name"); |
| Check_Optional_Identifier (Arg1, Name_Entity); |
| Check_Arg_Is_Static_Expression (Arg2, Standard_String); |
| Def_Id := Entity (Expression (Arg1)); |
| |
| if Is_Access_Type (Def_Id) then |
| Def_Id := Designated_Type (Def_Id); |
| end if; |
| |
| if Rep_Item_Too_Early (Def_Id, N) then |
| return; |
| end if; |
| |
| Def_Id := Underlying_Type (Def_Id); |
| |
| -- The only processing required is to link this item on to the |
| -- list of rep items for the given entity. This is accomplished |
| -- by the call to Rep_Item_Too_Late (when no error is detected |
| -- and False is returned). |
| |
| if Rep_Item_Too_Late (Def_Id, N) then |
| return; |
| else |
| Set_Has_Gigi_Rep_Item (Entity (Expression (Arg1))); |
| end if; |
| end Machine_Attribute; |
| |
| ---------- |
| -- Main -- |
| ---------- |
| |
| -- pragma Main_Storage |
| -- (MAIN_STORAGE_OPTION [, MAIN_STORAGE_OPTION]); |
| |
| -- MAIN_STORAGE_OPTION ::= |
| -- [WORKING_STORAGE =>] static_SIMPLE_EXPRESSION |
| -- | [TOP_GUARD =>] static_SIMPLE_EXPRESSION |
| |
| when Pragma_Main => Main : declare |
| Args : Args_List (1 .. 3); |
| Names : Name_List (1 .. 3) := ( |
| Name_Stack_Size, |
| Name_Task_Stack_Size_Default, |
| Name_Time_Slicing_Enabled); |
| |
| Nod : Node_Id; |
| |
| begin |
| GNAT_Pragma; |
| Gather_Associations (Names, Args); |
| |
| for J in 1 .. 2 loop |
| if Present (Args (J)) then |
| Check_Arg_Is_Static_Expression (Args (J), Any_Integer); |
| end if; |
| end loop; |
| |
| if Present (Args (3)) then |
| Check_Arg_Is_Static_Expression (Args (3), Standard_Boolean); |
| end if; |
| |
| Nod := Next (N); |
| while Present (Nod) loop |
| if Nkind (Nod) = N_Pragma |
| and then Chars (Nod) = Name_Main |
| then |
| Error_Msg_Name_1 := Chars (N); |
| Error_Msg_N ("duplicate pragma% not permitted", Nod); |
| end if; |
| |
| Next (Nod); |
| end loop; |
| end Main; |
| |
| ------------------ |
| -- Main_Storage -- |
| ------------------ |
| |
| -- pragma Main_Storage |
| -- (MAIN_STORAGE_OPTION [, MAIN_STORAGE_OPTION]); |
| |
| -- MAIN_STORAGE_OPTION ::= |
| -- [WORKING_STORAGE =>] static_SIMPLE_EXPRESSION |
| -- | [TOP_GUARD =>] static_SIMPLE_EXPRESSION |
| |
| when Pragma_Main_Storage => Main_Storage : declare |
| Args : Args_List (1 .. 2); |
| Names : Name_List (1 .. 2) := ( |
| Name_Working_Storage, |
| Name_Top_Guard); |
| |
| Nod : Node_Id; |
| |
| begin |
| GNAT_Pragma; |
| Gather_Associations (Names, Args); |
| |
| for J in 1 .. 2 loop |
| if Present (Args (J)) then |
| Check_Arg_Is_Static_Expression (Args (J), Any_Integer); |
| end if; |
| end loop; |
| |
| Check_In_Main_Program; |
| |
| Nod := Next (N); |
| while Present (Nod) loop |
| if Nkind (Nod) = N_Pragma |
| and then Chars (Nod) = Name_Main_Storage |
| then |
| Error_Msg_Name_1 := Chars (N); |
| Error_Msg_N ("duplicate pragma% not permitted", Nod); |
| end if; |
| |
| Next (Nod); |
| end loop; |
| |
| end Main_Storage; |
| |
| ----------------- |
| -- Memory_Size -- |
| ----------------- |
| |
| -- pragma Memory_Size (NUMERIC_LITERAL) |
| |
| when Pragma_Memory_Size => |
| GNAT_Pragma; |
| |
| -- Memory size is simply ignored |
| |
| Check_No_Identifiers; |
| Check_Arg_Count (1); |
| Check_Arg_Is_Integer_Literal (Arg1); |
| |
| --------------- |
| -- No_Return -- |
| --------------- |
| |
| -- pragma No_Return (procedure_LOCAL_NAME); |
| |
| when Pragma_No_Return => declare |
| Id : Node_Id; |
| E : Entity_Id; |
| Found : Boolean; |
| |
| begin |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_No_Identifiers; |
| Check_Arg_Is_Local_Name (Arg1); |
| Id := Expression (Arg1); |
| Analyze (Id); |
| |
| if not Is_Entity_Name (Id) then |
| Error_Pragma_Arg ("entity name required", Arg1); |
| end if; |
| |
| if Etype (Id) = Any_Type then |
| raise Pragma_Exit; |
| end if; |
| |
| E := Entity (Id); |
| |
| Found := False; |
| while Present (E) |
| and then Scope (E) = Current_Scope |
| loop |
| if Ekind (E) = E_Procedure |
| or else Ekind (E) = E_Generic_Procedure |
| then |
| Set_No_Return (E); |
| Found := True; |
| end if; |
| |
| E := Homonym (E); |
| end loop; |
| |
| if not Found then |
| Error_Pragma ("no procedures found for pragma%"); |
| end if; |
| end; |
| |
| ----------------- |
| -- No_Run_Time -- |
| ----------------- |
| |
| -- pragma No_Run_Time |
| |
| when Pragma_No_Run_Time => |
| GNAT_Pragma; |
| Check_Valid_Configuration_Pragma; |
| Check_Arg_Count (0); |
| Set_No_Run_Time_Mode; |
| |
| ----------------------- |
| -- Normalize_Scalars -- |
| ----------------------- |
| |
| -- pragma Normalize_Scalars; |
| |
| when Pragma_Normalize_Scalars => |
| Check_Ada_83_Warning; |
| Check_Arg_Count (0); |
| Check_Valid_Configuration_Pragma; |
| Normalize_Scalars := True; |
| Init_Or_Norm_Scalars := True; |
| |
| -------------- |
| -- Optimize -- |
| -------------- |
| |
| -- pragma Optimize (Time | Space); |
| |
| -- The actual check for optimize is done in Gigi. Note that this |
| -- pragma does not actually change the optimization setting, it |
| -- simply checks that it is consistent with the pragma. |
| |
| when Pragma_Optimize => |
| Check_No_Identifiers; |
| Check_Arg_Count (1); |
| Check_Arg_Is_One_Of (Arg1, Name_Time, Name_Space, Name_Off); |
| |
| ---------- |
| -- Pack -- |
| ---------- |
| |
| -- pragma Pack (first_subtype_LOCAL_NAME); |
| |
| when Pragma_Pack => Pack : declare |
| Assoc : Node_Id := Arg1; |
| Type_Id : Node_Id; |
| Typ : Entity_Id; |
| |
| begin |
| Check_No_Identifiers; |
| Check_Arg_Count (1); |
| Check_Arg_Is_Local_Name (Arg1); |
| |
| Type_Id := Expression (Assoc); |
| Find_Type (Type_Id); |
| Typ := Entity (Type_Id); |
| |
| if Typ = Any_Type |
| or else Rep_Item_Too_Early (Typ, N) |
| then |
| return; |
| else |
| Typ := Underlying_Type (Typ); |
| end if; |
| |
| if not Is_Array_Type (Typ) and then not Is_Record_Type (Typ) then |
| Error_Pragma ("pragma% must specify array or record type"); |
| end if; |
| |
| Check_First_Subtype (Arg1); |
| |
| if Has_Pragma_Pack (Typ) then |
| Error_Pragma ("duplicate pragma%, only one allowed"); |
| |
| -- Array type. We set the Has_Pragma_Pack flag, and Is_Packed, |
| -- but not Has_Non_Standard_Rep, because we don't actually know |
| -- till freeze time if the array can have packed representation. |
| -- That's because in the general case we do not know enough about |
| -- the component type until it in turn is frozen, which certainly |
| -- happens before the array type is frozen, but not necessarily |
| -- till that point (i.e. right now it may be unfrozen). |
| |
| elsif Is_Array_Type (Typ) then |
| |
| if Has_Aliased_Components (Base_Type (Typ)) then |
| Error_Pragma |
| ("pragma% ignored, cannot pack aliased components?"); |
| |
| elsif Has_Atomic_Components (Typ) then |
| Error_Pragma |
| ("?pragma% ignored, cannot pack atomic components"); |
| |
| elsif not Rep_Item_Too_Late (Typ, N) then |
| Set_Is_Packed (Base_Type (Typ)); |
| Set_Has_Pragma_Pack (Base_Type (Typ)); |
| Set_Has_Non_Standard_Rep (Base_Type (Typ)); |
| end if; |
| |
| -- Record type. For record types, the pack is always effective |
| |
| else -- Is_Record_Type (Typ) |
| if not Rep_Item_Too_Late (Typ, N) then |
| Set_Has_Pragma_Pack (Base_Type (Typ)); |
| Set_Is_Packed (Base_Type (Typ)); |
| Set_Has_Non_Standard_Rep (Base_Type (Typ)); |
| end if; |
| end if; |
| end Pack; |
| |
| ---------- |
| -- Page -- |
| ---------- |
| |
| -- pragma Page; |
| |
| -- There is nothing to do here, since we did all the processing |
| -- for this pragma in Par.Prag (so that it works properly even in |
| -- syntax only mode) |
| |
| when Pragma_Page => |
| null; |
| |
| ------------- |
| -- Passive -- |
| ------------- |
| |
| -- pragma Passive [(PASSIVE_FORM)]; |
| |
| -- PASSIVE_FORM ::= Semaphore | No |
| |
| when Pragma_Passive => |
| GNAT_Pragma; |
| |
| if Nkind (Parent (N)) /= N_Task_Definition then |
| Error_Pragma ("pragma% must be within task definition"); |
| end if; |
| |
| if Arg_Count /= 0 then |
| Check_Arg_Count (1); |
| Check_Arg_Is_One_Of (Arg1, Name_Semaphore, Name_No); |
| end if; |
| |
| ------------- |
| -- Polling -- |
| ------------- |
| |
| -- pragma Polling (ON | OFF); |
| |
| when Pragma_Polling => |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_No_Identifiers; |
| Check_Arg_Is_One_Of (Arg1, Name_On, Name_Off); |
| Polling_Required := (Chars (Expression (Arg1)) = Name_On); |
| |
| ------------------ |
| -- Preelaborate -- |
| ------------------ |
| |
| -- pragma Preelaborate [(library_unit_NAME)]; |
| |
| -- Set the flag Is_Preelaborated of program unit name entity |
| |
| when Pragma_Preelaborate => Preelaborate : declare |
| Ent : Entity_Id; |
| Pa : Node_Id := Parent (N); |
| Pk : Node_Kind := Nkind (Pa); |
| |
| begin |
| Check_Ada_83_Warning; |
| Check_Valid_Library_Unit_Pragma; |
| |
| if Nkind (N) = N_Null_Statement then |
| return; |
| end if; |
| |
| Ent := Find_Lib_Unit_Name; |
| |
| -- This filters out pragmas inside generic parent then |
| -- show up inside instantiation |
| |
| if Present (Ent) |
| and then not (Pk = N_Package_Specification |
| and then Present (Generic_Parent (Pa))) |
| then |
| if not Debug_Flag_U then |
| Set_Is_Preelaborated (Ent); |
| Set_Suppress_Elaboration_Warnings (Ent); |
| end if; |
| end if; |
| end Preelaborate; |
| |
| -------------- |
| -- Priority -- |
| -------------- |
| |
| -- pragma Priority (EXPRESSION); |
| |
| when Pragma_Priority => Priority : declare |
| P : constant Node_Id := Parent (N); |
| Arg : Node_Id; |
| |
| begin |
| Check_No_Identifiers; |
| Check_Arg_Count (1); |
| |
| Arg := Expression (Arg1); |
| Analyze_And_Resolve (Arg, Standard_Integer); |
| |
| if not Is_Static_Expression (Arg) then |
| Check_Restriction (Static_Priorities, Arg); |
| end if; |
| |
| -- Subprogram case |
| |
| if Nkind (P) = N_Subprogram_Body then |
| Check_In_Main_Program; |
| |
| -- Must be static |
| |
| if not Is_Static_Expression (Arg) then |
| Error_Pragma_Arg |
| ("main subprogram priority is not static", Arg1); |
| |
| -- If constraint error, then we already signalled an error |
| |
| elsif Raises_Constraint_Error (Arg) then |
| null; |
| |
| -- Otherwise check in range |
| |
| else |
| declare |
| Val : constant Uint := Expr_Value (Arg); |
| |
| begin |
| if Val < 0 |
| or else Val > Expr_Value (Expression |
| (Parent (RTE (RE_Max_Priority)))) |
| then |
| Error_Pragma_Arg |
| ("main subprogram priority is out of range", Arg1); |
| end if; |
| end; |
| end if; |
| |
| Set_Main_Priority |
| (Current_Sem_Unit, UI_To_Int (Expr_Value (Arg))); |
| |
| -- Task or Protected, must be of type Integer |
| |
| elsif Nkind (P) = N_Protected_Definition |
| or else |
| Nkind (P) = N_Task_Definition |
| then |
| if Expander_Active then |
| Rewrite (Arg, |
| Convert_To (RTE (RE_Any_Priority), Arg)); |
| end if; |
| |
| -- Anything else is incorrect |
| |
| else |
| Pragma_Misplaced; |
| end if; |
| |
| if Has_Priority_Pragma (P) then |
| Error_Pragma ("duplicate pragma% not allowed"); |
| else |
| Set_Has_Priority_Pragma (P, True); |
| |
| if Nkind (P) = N_Protected_Definition |
| or else |
| Nkind (P) = N_Task_Definition |
| then |
| Record_Rep_Item (Defining_Identifier (Parent (P)), N); |
| -- exp_ch9 should use this ??? |
| end if; |
| end if; |
| |
| end Priority; |
| |
| -------------------------- |
| -- Propagate_Exceptions -- |
| -------------------------- |
| |
| -- pragma Propagate_Exceptions; |
| |
| when Pragma_Propagate_Exceptions => |
| GNAT_Pragma; |
| Check_Arg_Count (0); |
| |
| if In_Extended_Main_Source_Unit (N) then |
| Propagate_Exceptions := True; |
| end if; |
| |
| ------------------ |
| -- Psect_Object -- |
| ------------------ |
| |
| -- pragma Psect_Object ( |
| -- [Internal =>] LOCAL_NAME, |
| -- [, [External =>] EXTERNAL_SYMBOL] |
| -- [, [Size =>] EXTERNAL_SYMBOL]); |
| |
| when Pragma_Psect_Object | Pragma_Common_Object => |
| Psect_Object : declare |
| Args : Args_List (1 .. 3); |
| Names : Name_List (1 .. 3) := ( |
| Name_Internal, |
| Name_External, |
| Name_Size); |
| |
| Internal : Node_Id renames Args (1); |
| External : Node_Id renames Args (2); |
| Size : Node_Id renames Args (3); |
| |
| R_Internal : Node_Id; |
| R_External : Node_Id; |
| |
| MA : Node_Id; |
| Str : String_Id; |
| |
| Def_Id : Entity_Id; |
| |
| procedure Check_Too_Long (Arg : Node_Id); |
| -- Posts message if the argument is an identifier with more |
| -- than 31 characters, or a string literal with more than |
| -- 31 characters, and we are operating under VMS |
| |
| procedure Check_Too_Long (Arg : Node_Id) is |
| X : Node_Id := Original_Node (Arg); |
| |
| begin |
| if Nkind (X) /= N_String_Literal |
| and then |
| Nkind (X) /= N_Identifier |
| then |
| Error_Pragma_Arg |
| ("inappropriate argument for pragma %", Arg); |
| end if; |
| |
| if OpenVMS_On_Target then |
| if (Nkind (X) = N_String_Literal |
| and then String_Length (Strval (X)) > 31) |
| or else |
| (Nkind (X) = N_Identifier |
| and then Length_Of_Name (Chars (X)) > 31) |
| then |
| Error_Pragma_Arg |
| ("argument for pragma % is longer than 31 characters", |
| Arg); |
| end if; |
| end if; |
| end Check_Too_Long; |
| |
| -- Start of processing for Common_Object/Psect_Object |
| |
| begin |
| GNAT_Pragma; |
| Gather_Associations (Names, Args); |
| Process_Extended_Import_Export_Internal_Arg (Internal); |
| |
| R_Internal := Relocate_Node (Internal); |
| |
| Def_Id := Entity (R_Internal); |
| |
| if Ekind (Def_Id) /= E_Constant |
| and then Ekind (Def_Id) /= E_Variable |
| then |
| Error_Pragma_Arg |
| ("pragma% must designate an object", Internal); |
| end if; |
| |
| Check_Too_Long (R_Internal); |
| |
| if Is_Imported (Def_Id) or else Is_Exported (Def_Id) then |
| Error_Pragma_Arg |
| ("cannot use pragma% for imported/exported object", |
| R_Internal); |
| end if; |
| |
| if Is_Concurrent_Type (Etype (R_Internal)) then |
| Error_Pragma_Arg |
| ("cannot specify pragma % for task/protected object", |
| R_Internal); |
| end if; |
| |
| if Is_Psected (Def_Id) then |
| Error_Msg_N ("?duplicate Psect_Object pragma", N); |
| else |
| Set_Is_Psected (Def_Id); |
| end if; |
| |
| if Ekind (Def_Id) = E_Constant then |
| Error_Pragma_Arg |
| ("cannot specify pragma % for a constant", R_Internal); |
| end if; |
| |
| if Is_Record_Type (Etype (R_Internal)) then |
| declare |
| Ent : Entity_Id; |
| Decl : Entity_Id; |
| |
| begin |
| Ent := First_Entity (Etype (R_Internal)); |
| while Present (Ent) loop |
| Decl := Declaration_Node (Ent); |
| |
| if Ekind (Ent) = E_Component |
| and then Nkind (Decl) = N_Component_Declaration |
| and then Present (Expression (Decl)) |
| then |
| Error_Msg_N |
| ("?object for pragma % has defaults", R_Internal); |
| exit; |
| |
| else |
| Next_Entity (Ent); |
| end if; |
| end loop; |
| end; |
| end if; |
| |
| if Present (Size) then |
| Check_Too_Long (Size); |
| end if; |
| |
| -- Make Psect case-insensitive. |
| |
| if Present (External) then |
| Check_Too_Long (External); |
| |
| if Nkind (External) = N_String_Literal then |
| String_To_Name_Buffer (Strval (External)); |
| else |
| Get_Name_String (Chars (External)); |
| end if; |
| |
| Set_All_Upper_Case; |
| Start_String; |
| Store_String_Chars (Name_Buffer (1 .. Name_Len)); |
| Str := End_String; |
| R_External := Make_String_Literal |
| (Sloc => Sloc (External), Strval => Str); |
| else |
| Get_Name_String (Chars (Internal)); |
| Set_All_Upper_Case; |
| Start_String; |
| Store_String_Chars (Name_Buffer (1 .. Name_Len)); |
| Str := End_String; |
| R_External := Make_String_Literal |
| (Sloc => Sloc (Internal), Strval => Str); |
| end if; |
| |
| -- Transform into pragma Linker_Section, add attributes to |
| -- match what DEC Ada does. Ignore size for now? |
| |
| Rewrite (N, |
| Make_Pragma |
| (Sloc (N), |
| Name_Linker_Section, |
| New_List |
| (Make_Pragma_Argument_Association |
| (Sloc => Sloc (R_Internal), |
| Expression => R_Internal), |
| Make_Pragma_Argument_Association |
| (Sloc => Sloc (R_External), |
| Expression => R_External)))); |
| |
| Analyze (N); |
| |
| -- Add Machine_Attribute of "overlaid", so the section overlays |
| -- other sections of the same name. |
| |
| Start_String; |
| Store_String_Chars ("overlaid"); |
| Str := End_String; |
| |
| MA := |
| Make_Pragma |
| (Sloc (N), |
| Name_Machine_Attribute, |
| New_List |
| (Make_Pragma_Argument_Association |
| (Sloc => Sloc (R_Internal), |
| Expression => R_Internal), |
| Make_Pragma_Argument_Association |
| (Sloc => Sloc (R_External), |
| Expression => |
| Make_String_Literal |
| (Sloc => Sloc (R_External), |
| Strval => Str)))); |
| Analyze (MA); |
| |
| -- Add Machine_Attribute of "global", so the section is visible |
| -- everywhere |
| |
| Start_String; |
| Store_String_Chars ("global"); |
| Str := End_String; |
| |
| MA := |
| Make_Pragma |
| (Sloc (N), |
| Name_Machine_Attribute, |
| New_List |
| (Make_Pragma_Argument_Association |
| (Sloc => Sloc (R_Internal), |
| Expression => R_Internal), |
| Make_Pragma_Argument_Association |
| (Sloc => Sloc (R_External), |
| Expression => |
| Make_String_Literal |
| (Sloc => Sloc (R_External), |
| Strval => Str)))); |
| Analyze (MA); |
| |
| -- Add Machine_Attribute of "initialize", so the section is |
| -- demand zeroed. |
| |
| Start_String; |
| Store_String_Chars ("initialize"); |
| Str := End_String; |
| |
| MA := |
| Make_Pragma |
| (Sloc (N), |
| Name_Machine_Attribute, |
| New_List |
| (Make_Pragma_Argument_Association |
| (Sloc => Sloc (R_Internal), |
| Expression => R_Internal), |
| Make_Pragma_Argument_Association |
| (Sloc => Sloc (R_External), |
| Expression => |
| Make_String_Literal |
| (Sloc => Sloc (R_External), |
| Strval => Str)))); |
| Analyze (MA); |
| |
| end Psect_Object; |
| |
| ---------- |
| -- Pure -- |
| ---------- |
| |
| -- pragma Pure [(library_unit_NAME)]; |
| |
| when Pragma_Pure => Pure : declare |
| Ent : Entity_Id; |
| begin |
| Check_Ada_83_Warning; |
| Check_Valid_Library_Unit_Pragma; |
| |
| if Nkind (N) = N_Null_Statement then |
| return; |
| end if; |
| |
| Ent := Find_Lib_Unit_Name; |
| Set_Is_Pure (Ent); |
| Set_Suppress_Elaboration_Warnings (Ent); |
| end Pure; |
| |
| ------------------- |
| -- Pure_Function -- |
| ------------------- |
| |
| -- pragma Pure_Function ([Entity =>] function_LOCAL_NAME); |
| |
| when Pragma_Pure_Function => Pure_Function : declare |
| E_Id : Node_Id; |
| E : Entity_Id; |
| Def_Id : Entity_Id; |
| |
| begin |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_Optional_Identifier (Arg1, Name_Entity); |
| Check_Arg_Is_Local_Name (Arg1); |
| E_Id := Expression (Arg1); |
| |
| if Error_Posted (E_Id) then |
| return; |
| end if; |
| |
| -- Loop through homonyms (overloadings) of referenced entity |
| |
| E := Entity (E_Id); |
| while Present (E) loop |
| Def_Id := Get_Base_Subprogram (E); |
| |
| if Ekind (Def_Id) /= E_Function |
| and then Ekind (Def_Id) /= E_Generic_Function |
| and then Ekind (Def_Id) /= E_Operator |
| then |
| Error_Pragma_Arg ("pragma% requires a function name", Arg1); |
| end if; |
| |
| Set_Is_Pure (Def_Id); |
| Set_Has_Pragma_Pure_Function (Def_Id); |
| E := Homonym (E); |
| end loop; |
| end Pure_Function; |
| |
| -------------------- |
| -- Queuing_Policy -- |
| -------------------- |
| |
| -- pragma Queuing_Policy (policy_IDENTIFIER); |
| |
| when Pragma_Queuing_Policy => declare |
| QP : Character; |
| |
| begin |
| Check_Ada_83_Warning; |
| Check_Arg_Count (1); |
| Check_No_Identifiers; |
| Check_Arg_Is_Queuing_Policy (Arg1); |
| Check_Valid_Configuration_Pragma; |
| Get_Name_String (Chars (Expression (Arg1))); |
| QP := Fold_Upper (Name_Buffer (1)); |
| |
| if Queuing_Policy /= ' ' |
| and then Queuing_Policy /= QP |
| then |
| Error_Msg_Sloc := Queuing_Policy_Sloc; |
| Error_Pragma ("queuing policy incompatible with policy#"); |
| else |
| Queuing_Policy := QP; |
| Queuing_Policy_Sloc := Loc; |
| end if; |
| end; |
| |
| --------------------------- |
| -- Remote_Call_Interface -- |
| --------------------------- |
| |
| -- pragma Remote_Call_Interface [(library_unit_NAME)]; |
| |
| when Pragma_Remote_Call_Interface => Remote_Call_Interface : declare |
| Cunit_Node : Node_Id; |
| Cunit_Ent : Entity_Id; |
| K : Node_Kind; |
| |
| begin |
| Check_Ada_83_Warning; |
| Check_Valid_Library_Unit_Pragma; |
| |
| if Nkind (N) = N_Null_Statement then |
| return; |
| end if; |
| |
| Cunit_Node := Cunit (Current_Sem_Unit); |
| K := Nkind (Unit (Cunit_Node)); |
| Cunit_Ent := Cunit_Entity (Current_Sem_Unit); |
| |
| if K = N_Package_Declaration |
| or else K = N_Generic_Package_Declaration |
| or else K = N_Subprogram_Declaration |
| or else K = N_Generic_Subprogram_Declaration |
| or else (K = N_Subprogram_Body |
| and then Acts_As_Spec (Unit (Cunit_Node))) |
| then |
| null; |
| else |
| Error_Pragma ( |
| "pragma% must apply to package or subprogram declaration"); |
| end if; |
| |
| Set_Is_Remote_Call_Interface (Cunit_Ent); |
| end Remote_Call_Interface; |
| |
| ------------------ |
| -- Remote_Types -- |
| ------------------ |
| |
| -- pragma Remote_Types [(library_unit_NAME)]; |
| |
| when Pragma_Remote_Types => Remote_Types : declare |
| Cunit_Node : Node_Id; |
| Cunit_Ent : Entity_Id; |
| |
| begin |
| Check_Ada_83_Warning; |
| Check_Valid_Library_Unit_Pragma; |
| |
| if Nkind (N) = N_Null_Statement then |
| return; |
| end if; |
| |
| Cunit_Node := Cunit (Current_Sem_Unit); |
| Cunit_Ent := Cunit_Entity (Current_Sem_Unit); |
| |
| if Nkind (Unit (Cunit_Node)) /= N_Package_Declaration |
| and then |
| Nkind (Unit (Cunit_Node)) /= N_Generic_Package_Declaration |
| then |
| Error_Pragma ( |
| "pragma% can only apply to a package declaration"); |
| end if; |
| |
| Set_Is_Remote_Types (Cunit_Ent); |
| end Remote_Types; |
| |
| --------------- |
| -- Ravenscar -- |
| --------------- |
| |
| when Pragma_Ravenscar => |
| GNAT_Pragma; |
| Check_Arg_Count (0); |
| Check_Valid_Configuration_Pragma; |
| Set_Ravenscar; |
| |
| ------------------------- |
| -- Restricted_Run_Time -- |
| ------------------------- |
| |
| when Pragma_Restricted_Run_Time => |
| GNAT_Pragma; |
| Check_Arg_Count (0); |
| Check_Valid_Configuration_Pragma; |
| Set_Restricted_Profile; |
| |
| ------------------ |
| -- Restrictions -- |
| ------------------ |
| |
| -- pragma Restrictions (RESTRICTION {, RESTRICTION}); |
| |
| -- RESTRICTION ::= |
| -- restriction_IDENTIFIER |
| -- | restriction_parameter_IDENTIFIER => EXPRESSION |
| |
| when Pragma_Restrictions => Restrictions_Pragma : declare |
| Arg : Node_Id; |
| R_Id : Restriction_Id; |
| RP_Id : Restriction_Parameter_Id; |
| Id : Name_Id; |
| Expr : Node_Id; |
| Val : Uint; |
| |
| begin |
| Check_Ada_83_Warning; |
| Check_At_Least_N_Arguments (1); |
| Check_Valid_Configuration_Pragma; |
| |
| Arg := Arg1; |
| |
| while Present (Arg) loop |
| Id := Chars (Arg); |
| Expr := Expression (Arg); |
| |
| -- Case of no restriction identifier |
| |
| if Id = No_Name then |
| if Nkind (Expr) /= N_Identifier then |
| Error_Pragma_Arg |
| ("invalid form for restriction", Arg); |
| |
| else |
| R_Id := Get_Restriction_Id (Chars (Expr)); |
| |
| if R_Id = Not_A_Restriction_Id then |
| Error_Pragma_Arg |
| ("invalid restriction identifier", Arg); |
| |
| -- Restriction is active |
| |
| else |
| Restrictions (R_Id) := True; |
| Restrictions_Loc (R_Id) := Sloc (N); |
| |
| -- Record the restriction if we are in the main unit, |
| -- or in the extended main unit. The reason that we |
| -- test separately for Main_Unit is that gnat.adc is |
| -- processed with Current_Sem_Unit = Main_Unit, but |
| -- nodes in gnat.adc do not appear to be the extended |
| -- main source unit (they probably should do ???) |
| |
| if Current_Sem_Unit = Main_Unit |
| or else In_Extended_Main_Source_Unit (N) |
| then |
| Main_Restrictions (R_Id) := True; |
| end if; |
| |
| -- A very special case that must be processed here: |
| -- pragma Restrictions (No_Exceptions) turns off all |
| -- run-time checking. This is a bit dubious in terms |
| -- of the formal language definition, but it is what |
| -- is intended by the wording of RM H.4(12). |
| |
| if R_Id = No_Exceptions then |
| Scope_Suppress := (others => True); |
| end if; |
| end if; |
| end if; |
| |
| -- Case of restriction identifier present |
| |
| else |
| RP_Id := Get_Restriction_Parameter_Id (Id); |
| Analyze_And_Resolve (Expr, Any_Integer); |
| |
| if RP_Id = Not_A_Restriction_Parameter_Id then |
| Error_Pragma_Arg |
| ("invalid restriction parameter identifier", Arg); |
| |
| elsif not Is_OK_Static_Expression (Expr) |
| or else not Is_Integer_Type (Etype (Expr)) |
| or else Expr_Value (Expr) < 0 |
| then |
| Error_Pragma_Arg |
| ("value must be non-negative static integer", Arg); |
| |
| -- Restriction pragma is active |
| |
| else |
| Val := Expr_Value (Expr); |
| |
| -- Record pragma if most restrictive so far |
| |
| if Restriction_Parameters (RP_Id) = No_Uint |
| or else Val < Restriction_Parameters (RP_Id) |
| then |
| Restriction_Parameters (RP_Id) := Expr_Value (Expr); |
| Restriction_Parameters_Loc (RP_Id) := Sloc (N); |
| end if; |
| end if; |
| end if; |
| |
| Next (Arg); |
| end loop; |
| end Restrictions_Pragma; |
| |
| ---------------- |
| -- Reviewable -- |
| ---------------- |
| |
| -- pragma Reviewable; |
| |
| when Pragma_Reviewable => |
| Check_Ada_83_Warning; |
| Check_Arg_Count (0); |
| |
| ------------------- |
| -- Share_Generic -- |
| ------------------- |
| |
| -- pragma Share_Generic (NAME {, NAME}); |
| |
| when Pragma_Share_Generic => |
| GNAT_Pragma; |
| Process_Generic_List; |
| |
| ------------ |
| -- Shared -- |
| ------------ |
| |
| -- pragma Shared (LOCAL_NAME); |
| |
| when Pragma_Shared => |
| Process_Atomic_Shared_Volatile; |
| |
| -------------------- |
| -- Shared_Passive -- |
| -------------------- |
| |
| -- pragma Shared_Passive [(library_unit_NAME)]; |
| |
| -- Set the flag Is_Shared_Passive of program unit name entity |
| |
| when Pragma_Shared_Passive => Shared_Passive : declare |
| Cunit_Node : Node_Id; |
| Cunit_Ent : Entity_Id; |
| |
| begin |
| Check_Ada_83_Warning; |
| Check_Valid_Library_Unit_Pragma; |
| |
| if Nkind (N) = N_Null_Statement then |
| return; |
| end if; |
| |
| Cunit_Node := Cunit (Current_Sem_Unit); |
| Cunit_Ent := Cunit_Entity (Current_Sem_Unit); |
| |
| if Nkind (Unit (Cunit_Node)) /= N_Package_Declaration |
| and then |
| Nkind (Unit (Cunit_Node)) /= N_Generic_Package_Declaration |
| then |
| Error_Pragma ( |
| "pragma% can only apply to a package declaration"); |
| end if; |
| |
| Set_Is_Shared_Passive (Cunit_Ent); |
| end Shared_Passive; |
| |
| ---------------------- |
| -- Source_File_Name -- |
| ---------------------- |
| |
| -- pragma Source_File_Name ( |
| -- [UNIT_NAME =>] unit_NAME, |
| -- [BODY_FILE_NAME | SPEC_FILE_NAME] => STRING_LITERAL); |
| |
| -- No processing here. Processing was completed during parsing, |
| -- since we need to have file names set as early as possible. |
| -- Units are loaded well before semantic processing starts. |
| |
| -- The only processing we defer to this point is the check |
| -- for correct placement. |
| |
| when Pragma_Source_File_Name => |
| GNAT_Pragma; |
| Check_Valid_Configuration_Pragma; |
| |
| ---------------------- |
| -- Source_Reference -- |
| ---------------------- |
| |
| -- pragma Source_Reference (INTEGER_LITERAL [, STRING_LITERAL]); |
| |
| -- Nothing to do, all processing completed in Par.Prag, since we |
| -- need the information for possible parser messages that are output |
| |
| when Pragma_Source_Reference => |
| GNAT_Pragma; |
| |
| ------------------ |
| -- Storage_Size -- |
| ------------------ |
| |
| -- pragma Storage_Size (EXPRESSION); |
| |
| when Pragma_Storage_Size => Storage_Size : declare |
| P : constant Node_Id := Parent (N); |
| X : Node_Id; |
| |
| begin |
| Check_No_Identifiers; |
| Check_Arg_Count (1); |
| |
| -- Set In_Default_Expression for per-object case??? |
| |
| X := Expression (Arg1); |
| Analyze_And_Resolve (X, Any_Integer); |
| |
| if not Is_Static_Expression (X) then |
| Check_Restriction (Static_Storage_Size, X); |
| end if; |
| |
| if Nkind (P) /= N_Task_Definition then |
| Pragma_Misplaced; |
| return; |
| |
| else |
| if Has_Storage_Size_Pragma (P) then |
| Error_Pragma ("duplicate pragma% not allowed"); |
| else |
| Set_Has_Storage_Size_Pragma (P, True); |
| end if; |
| |
| Record_Rep_Item (Defining_Identifier (Parent (P)), N); |
| -- ??? exp_ch9 should use this! |
| end if; |
| end Storage_Size; |
| |
| ------------------ |
| -- Storage_Unit -- |
| ------------------ |
| |
| -- pragma Storage_Unit (NUMERIC_LITERAL); |
| |
| -- Only permitted argument is System'Storage_Unit value |
| |
| when Pragma_Storage_Unit => |
| Check_No_Identifiers; |
| Check_Arg_Count (1); |
| Check_Arg_Is_Integer_Literal (Arg1); |
| |
| if Intval (Expression (Arg1)) /= |
| UI_From_Int (Ttypes.System_Storage_Unit) |
| then |
| Error_Msg_Uint_1 := UI_From_Int (Ttypes.System_Storage_Unit); |
| Error_Pragma_Arg |
| ("the only allowed argument for pragma% is ^", Arg1); |
| end if; |
| |
| -------------------- |
| -- Stream_Convert -- |
| -------------------- |
| |
| -- pragma Stream_Convert ( |
| -- [Entity =>] type_LOCAL_NAME, |
| -- [Read =>] function_NAME, |
| -- [Write =>] function NAME); |
| |
| when Pragma_Stream_Convert => Stream_Convert : begin |
| GNAT_Pragma; |
| Check_Arg_Count (3); |
| Check_Optional_Identifier (Arg1, Name_Entity); |
| Check_Optional_Identifier (Arg2, Name_Read); |
| Check_Optional_Identifier (Arg3, Name_Write); |
| Check_Arg_Is_Local_Name (Arg1); |
| Check_Non_Overloaded_Function (Arg2); |
| Check_Non_Overloaded_Function (Arg3); |
| |
| declare |
| Typ : constant Entity_Id := |
| Underlying_Type (Entity (Expression (Arg1))); |
| Read : constant Entity_Id := Entity (Expression (Arg2)); |
| Write : constant Entity_Id := Entity (Expression (Arg3)); |
| |
| begin |
| if Etype (Typ) = Any_Type |
| or else |
| Etype (Read) = Any_Type |
| or else |
| Etype (Write) = Any_Type |
| then |
| return; |
| end if; |
| |
| Check_First_Subtype (Arg1); |
| |
| if Rep_Item_Too_Early (Typ, N) |
| or else |
| Rep_Item_Too_Late (Typ, N) |
| then |
| return; |
| end if; |
| |
| if Underlying_Type (Etype (Read)) /= Typ then |
| Error_Pragma_Arg |
| ("incorrect return type for function&", Arg2); |
| end if; |
| |
| if Underlying_Type (Etype (First_Formal (Write))) /= Typ then |
| Error_Pragma_Arg |
| ("incorrect parameter type for function&", Arg3); |
| end if; |
| |
| if Underlying_Type (Etype (First_Formal (Read))) /= |
| Underlying_Type (Etype (Write)) |
| then |
| Error_Pragma_Arg |
| ("result type of & does not match Read parameter type", |
| Arg3); |
| end if; |
| end; |
| end Stream_Convert; |
| |
| ------------------------- |
| -- Style_Checks (GNAT) -- |
| ------------------------- |
| |
| -- pragma Style_Checks (On | Off | ALL_CHECKS | STRING_LITERAL); |
| |
| -- This is processed by the parser since some of the style |
| -- checks take place during source scanning and parsing. This |
| -- means that we don't need to issue error messages here. |
| |
| when Pragma_Style_Checks => Style_Checks : declare |
| A : constant Node_Id := Expression (Arg1); |
| S : String_Id; |
| C : Char_Code; |
| |
| begin |
| GNAT_Pragma; |
| Check_No_Identifiers; |
| |
| -- Two argument form |
| |
| if Arg_Count = 2 then |
| Check_Arg_Is_One_Of (Arg1, Name_On, Name_Off); |
| |
| declare |
| E_Id : Node_Id; |
| E : Entity_Id; |
| |
| begin |
| E_Id := Expression (Arg2); |
| Analyze (E_Id); |
| |
| if not Is_Entity_Name (E_Id) then |
| Error_Pragma_Arg |
| ("second argument of pragma% must be entity name", |
| Arg2); |
| end if; |
| |
| E := Entity (E_Id); |
| |
| if E = Any_Id then |
| return; |
| else |
| loop |
| Set_Suppress_Style_Checks (E, |
| (Chars (Expression (Arg1)) = Name_Off)); |
| exit when No (Homonym (E)); |
| E := Homonym (E); |
| end loop; |
| end if; |
| end; |
| |
| -- One argument form |
| |
| else |
| Check_Arg_Count (1); |
| |
| if Nkind (A) = N_String_Literal then |
| S := Strval (A); |
| |
| declare |
| Slen : Natural := Natural (String_Length (S)); |
| Options : String (1 .. Slen); |
| J : Natural; |
| |
| begin |
| J := 1; |
| loop |
| C := Get_String_Char (S, Int (J)); |
| exit when not In_Character_Range (C); |
| Options (J) := Get_Character (C); |
| |
| if J = Slen then |
| Set_Style_Check_Options (Options); |
| exit; |
| else |
| J := J + 1; |
| end if; |
| end loop; |
| end; |
| |
| elsif Nkind (A) = N_Identifier then |
| |
| if Chars (A) = Name_All_Checks then |
| Set_Default_Style_Check_Options; |
| |
| elsif Chars (A) = Name_On then |
| Style_Check := True; |
| |
| elsif Chars (A) = Name_Off then |
| Style_Check := False; |
| |
| end if; |
| end if; |
| end if; |
| end Style_Checks; |
| |
| -------------- |
| -- Subtitle -- |
| -------------- |
| |
| -- pragma Subtitle ([Subtitle =>] STRING_LITERAL); |
| |
| when Pragma_Subtitle => |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_Optional_Identifier (Arg1, Name_Subtitle); |
| Check_Arg_Is_String_Literal (Arg1); |
| |
| -------------- |
| -- Suppress -- |
| -------------- |
| |
| -- pragma Suppress (IDENTIFIER [, [On =>] NAME]); |
| |
| when Pragma_Suppress => |
| Process_Suppress_Unsuppress (True); |
| |
| ------------------ |
| -- Suppress_All -- |
| ------------------ |
| |
| -- pragma Suppress_All; |
| |
| -- The only check made here is that the pragma appears in the |
| -- proper place, i.e. following a compilation unit. If indeed |
| -- it appears in this context, then the parser has already |
| -- inserted an equivalent pragma Suppress (All_Checks) to get |
| -- the required effect. |
| |
| when Pragma_Suppress_All => |
| GNAT_Pragma; |
| Check_Arg_Count (0); |
| |
| if Nkind (Parent (N)) /= N_Compilation_Unit_Aux |
| or else not Is_List_Member (N) |
| or else List_Containing (N) /= Pragmas_After (Parent (N)) |
| then |
| Error_Pragma |
| ("misplaced pragma%, must follow compilation unit"); |
| end if; |
| |
| ------------------------- |
| -- Suppress_Debug_Info -- |
| ------------------------- |
| |
| -- pragma Suppress_Debug_Info ([Entity =>] LOCAL_NAME); |
| |
| when Pragma_Suppress_Debug_Info => |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_Arg_Is_Local_Name (Arg1); |
| Check_Optional_Identifier (Arg1, Name_Entity); |
| Set_Debug_Info_Off (Entity (Get_Pragma_Arg (Arg1))); |
| |
| ----------------------------- |
| -- Suppress_Initialization -- |
| ----------------------------- |
| |
| -- pragma Suppress_Initialization ([Entity =>] type_Name); |
| |
| when Pragma_Suppress_Initialization => Suppress_Init : declare |
| E_Id : Node_Id; |
| E : Entity_Id; |
| |
| begin |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_Optional_Identifier (Arg1, Name_Entity); |
| Check_Arg_Is_Local_Name (Arg1); |
| |
| E_Id := Expression (Arg1); |
| |
| if Etype (E_Id) = Any_Type then |
| return; |
| end if; |
| |
| E := Entity (E_Id); |
| |
| if Is_Type (E) then |
| if Is_Incomplete_Or_Private_Type (E) then |
| if No (Full_View (Base_Type (E))) then |
| Error_Pragma_Arg |
| ("argument of pragma% cannot be an incomplete type", |
| Arg1); |
| else |
| Set_Suppress_Init_Proc (Full_View (Base_Type (E))); |
| end if; |
| else |
| Set_Suppress_Init_Proc (Base_Type (E)); |
| end if; |
| |
| else |
| Error_Pragma_Arg |
| ("pragma% requires argument that is a type name", Arg1); |
| end if; |
| end Suppress_Init; |
| |
| ----------------- |
| -- System_Name -- |
| ----------------- |
| |
| -- pragma System_Name (DIRECT_NAME); |
| |
| -- Syntax check: one argument, which must be the identifier GNAT |
| -- or the identifier GCC, no other identifiers are acceptable. |
| |
| when Pragma_System_Name => |
| Check_No_Identifiers; |
| Check_Arg_Count (1); |
| Check_Arg_Is_One_Of (Arg1, Name_Gcc, Name_Gnat); |
| |
| ----------------------------- |
| -- Task_Dispatching_Policy -- |
| ----------------------------- |
| |
| -- pragma Task_Dispatching_Policy (policy_IDENTIFIER); |
| |
| when Pragma_Task_Dispatching_Policy => declare |
| DP : Character; |
| |
| begin |
| Check_Ada_83_Warning; |
| Check_Arg_Count (1); |
| Check_No_Identifiers; |
| Check_Arg_Is_Task_Dispatching_Policy (Arg1); |
| Check_Valid_Configuration_Pragma; |
| Get_Name_String (Chars (Expression (Arg1))); |
| DP := Fold_Upper (Name_Buffer (1)); |
| |
| if Task_Dispatching_Policy /= ' ' |
| and then Task_Dispatching_Policy /= DP |
| then |
| Error_Msg_Sloc := Task_Dispatching_Policy_Sloc; |
| Error_Pragma |
| ("task dispatching policy incompatible with policy#"); |
| else |
| Task_Dispatching_Policy := DP; |
| Task_Dispatching_Policy_Sloc := Loc; |
| end if; |
| end; |
| |
| -------------- |
| -- Task_Info -- |
| -------------- |
| |
| -- pragma Task_Info (EXPRESSION); |
| |
| when Pragma_Task_Info => Task_Info : declare |
| P : constant Node_Id := Parent (N); |
| |
| begin |
| GNAT_Pragma; |
| |
| if Nkind (P) /= N_Task_Definition then |
| Error_Pragma ("pragma% must appear in task definition"); |
| end if; |
| |
| Check_No_Identifiers; |
| Check_Arg_Count (1); |
| |
| Analyze_And_Resolve (Expression (Arg1), RTE (RE_Task_Info_Type)); |
| |
| if Etype (Expression (Arg1)) = Any_Type then |
| return; |
| end if; |
| |
| if Has_Task_Info_Pragma (P) then |
| Error_Pragma ("duplicate pragma% not allowed"); |
| else |
| Set_Has_Task_Info_Pragma (P, True); |
| end if; |
| |
| end Task_Info; |
| |
| --------------- |
| -- Task_Name -- |
| --------------- |
| |
| -- pragma Task_Name (string_EXPRESSION); |
| |
| when Pragma_Task_Name => Task_Name : declare |
| -- pragma Priority (EXPRESSION); |
| |
| P : constant Node_Id := Parent (N); |
| Arg : Node_Id; |
| |
| begin |
| Check_No_Identifiers; |
| Check_Arg_Count (1); |
| |
| Arg := Expression (Arg1); |
| Analyze_And_Resolve (Arg, Standard_String); |
| |
| if Nkind (P) /= N_Task_Definition then |
| Pragma_Misplaced; |
| end if; |
| |
| if Has_Task_Name_Pragma (P) then |
| Error_Pragma ("duplicate pragma% not allowed"); |
| else |
| Set_Has_Task_Name_Pragma (P, True); |
| Record_Rep_Item (Defining_Identifier (Parent (P)), N); |
| end if; |
| |
| end Task_Name; |
| |
| ------------------ |
| -- Task_Storage -- |
| ------------------ |
| |
| -- pragma Task_Storage ( |
| -- [Task_Type =>] LOCAL_NAME, |
| -- [Top_Guard =>] static_integer_EXPRESSION); |
| |
| when Pragma_Task_Storage => Task_Storage : declare |
| Args : Args_List (1 .. 2); |
| Names : Name_List (1 .. 2) := ( |
| Name_Task_Type, |
| Name_Top_Guard); |
| |
| Task_Type : Node_Id renames Args (1); |
| Top_Guard : Node_Id renames Args (2); |
| |
| Ent : Entity_Id; |
| |
| begin |
| GNAT_Pragma; |
| Gather_Associations (Names, Args); |
| Check_Arg_Is_Local_Name (Task_Type); |
| |
| Ent := Entity (Task_Type); |
| |
| if not Is_Task_Type (Ent) then |
| Error_Pragma_Arg |
| ("argument for pragma% must be task type", Task_Type); |
| end if; |
| |
| if No (Top_Guard) then |
| Error_Pragma_Arg |
| ("pragma% takes two arguments", Task_Type); |
| else |
| Check_Arg_Is_Static_Expression (Top_Guard, Any_Integer); |
| end if; |
| |
| Check_First_Subtype (Task_Type); |
| |
| if Rep_Item_Too_Late (Ent, N) then |
| raise Pragma_Exit; |
| end if; |
| |
| end Task_Storage; |
| |
| ---------------- |
| -- Time_Slice -- |
| ---------------- |
| |
| -- pragma Time_Slice (static_duration_EXPRESSION); |
| |
| when Pragma_Time_Slice => Time_Slice : declare |
| Val : Ureal; |
| Nod : Node_Id; |
| |
| begin |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_No_Identifiers; |
| Check_In_Main_Program; |
| Check_Arg_Is_Static_Expression (Arg1, Standard_Duration); |
| |
| if not Error_Posted (Arg1) then |
| Nod := Next (N); |
| while Present (Nod) loop |
| if Nkind (Nod) = N_Pragma |
| and then Chars (Nod) = Name_Time_Slice |
| then |
| Error_Msg_Name_1 := Chars (N); |
| Error_Msg_N ("duplicate pragma% not permitted", Nod); |
| end if; |
| |
| Next (Nod); |
| end loop; |
| end if; |
| |
| -- Process only if in main unit |
| |
| if Get_Source_Unit (Loc) = Main_Unit then |
| Opt.Time_Slice_Set := True; |
| Val := Expr_Value_R (Expression (Arg1)); |
| |
| if Val <= Ureal_0 then |
| Opt.Time_Slice_Value := 0; |
| |
| elsif Val > UR_From_Uint (UI_From_Int (1000)) then |
| Opt.Time_Slice_Value := 1_000_000_000; |
| |
| else |
| Opt.Time_Slice_Value := |
| UI_To_Int (UR_To_Uint (Val * UI_From_Int (1_000_000))); |
| end if; |
| end if; |
| end Time_Slice; |
| |
| ----------- |
| -- Title -- |
| ----------- |
| |
| -- pragma Title (TITLING_OPTION [, TITLING OPTION]); |
| |
| -- TITLING_OPTION ::= |
| -- [Title =>] STRING_LITERAL |
| -- | [Subtitle =>] STRING_LITERAL |
| |
| when Pragma_Title => Title : declare |
| Args : Args_List (1 .. 2); |
| Names : Name_List (1 .. 2) := ( |
| Name_Title, |
| Name_Subtitle); |
| |
| begin |
| GNAT_Pragma; |
| Gather_Associations (Names, Args); |
| |
| for J in 1 .. 2 loop |
| if Present (Args (J)) then |
| Check_Arg_Is_String_Literal (Args (J)); |
| end if; |
| end loop; |
| end Title; |
| |
| --------------------- |
| -- Unchecked_Union -- |
| --------------------- |
| |
| -- pragma Unchecked_Union (first_subtype_LOCAL_NAME) |
| |
| when Pragma_Unchecked_Union => Unchecked_Union : declare |
| Assoc : Node_Id := Arg1; |
| Type_Id : Node_Id := Expression (Assoc); |
| Typ : Entity_Id; |
| Discr : Entity_Id; |
| Tdef : Node_Id; |
| Clist : Node_Id; |
| Vpart : Node_Id; |
| Comp : Node_Id; |
| Variant : Node_Id; |
| |
| begin |
| GNAT_Pragma; |
| Check_No_Identifiers; |
| Check_Arg_Count (1); |
| Check_Arg_Is_Local_Name (Arg1); |
| |
| Find_Type (Type_Id); |
| Typ := Entity (Type_Id); |
| |
| if Typ = Any_Type |
| or else Rep_Item_Too_Early (Typ, N) |
| then |
| return; |
| else |
| Typ := Underlying_Type (Typ); |
| end if; |
| |
| if Rep_Item_Too_Late (Typ, N) then |
| return; |
| end if; |
| |
| Check_First_Subtype (Arg1); |
| |
| -- Note remaining cases are references to a type in the current |
| -- declarative part. If we find an error, we post the error on |
| -- the relevant type declaration at an appropriate point. |
| |
| if not Is_Record_Type (Typ) then |
| Error_Msg_N ("Unchecked_Union must be record type", Typ); |
| return; |
| |
| elsif Is_Tagged_Type (Typ) then |
| Error_Msg_N ("Unchecked_Union must not be tagged", Typ); |
| return; |
| |
| elsif Is_Limited_Type (Typ) then |
| Error_Msg_N |
| ("Unchecked_Union must not be limited record type", Typ); |
| return; |
| |
| else |
| if not Has_Discriminants (Typ) then |
| Error_Msg_N |
| ("Unchecked_Union must have one discriminant", Typ); |
| return; |
| end if; |
| |
| Discr := First_Discriminant (Typ); |
| |
| if Present (Next_Discriminant (Discr)) then |
| Error_Msg_N |
| ("Unchecked_Union must have exactly one discriminant", |
| Next_Discriminant (Discr)); |
| return; |
| end if; |
| |
| if No (Discriminant_Default_Value (Discr)) then |
| Error_Msg_N |
| ("Unchecked_Union discriminant must have default value", |
| Discr); |
| end if; |
| |
| Tdef := Type_Definition (Declaration_Node (Typ)); |
| Clist := Component_List (Tdef); |
| |
| if No (Clist) or else No (Variant_Part (Clist)) then |
| Error_Msg_N |
| ("Unchecked_Union must have variant part", |
| Tdef); |
| return; |
| end if; |
| |
| Vpart := Variant_Part (Clist); |
| |
| if Is_Non_Empty_List (Component_Items (Clist)) then |
| Error_Msg_N |
| ("components before variant not allowed " & |
| "in Unchecked_Union", |
| First (Component_Items (Clist))); |
| end if; |
| |
| Variant := First (Variants (Vpart)); |
| while Present (Variant) loop |
| Clist := Component_List (Variant); |
| |
| if Present (Variant_Part (Clist)) then |
| Error_Msg_N |
| ("Unchecked_Union may not have nested variants", |
| Variant_Part (Clist)); |
| end if; |
| |
| if not Is_Non_Empty_List (Component_Items (Clist)) then |
| Error_Msg_N |
| ("Unchecked_Union may not have empty component list", |
| Variant); |
| return; |
| end if; |
| |
| Comp := First (Component_Items (Clist)); |
| |
| if Nkind (Comp) = N_Component_Declaration then |
| |
| if Present (Expression (Comp)) then |
| Error_Msg_N |
| ("default initialization not allowed " & |
| "in Unchecked_Union", |
| Expression (Comp)); |
| end if; |
| |
| declare |
| Sindic : constant Node_Id := |
| Subtype_Indication (Comp); |
| |
| begin |
| if Nkind (Sindic) = N_Subtype_Indication then |
| Check_Static_Constraint (Constraint (Sindic)); |
| end if; |
| end; |
| end if; |
| |
| if Present (Next (Comp)) then |
| Error_Msg_N |
| ("Unchecked_Union variant can have only one component", |
| Next (Comp)); |
| end if; |
| |
| Next (Variant); |
| end loop; |
| end if; |
| |
| Set_Is_Unchecked_Union (Typ, True); |
| Set_Suppress_Discriminant_Checks (Typ, True); |
| Set_Convention (Typ, Convention_C); |
| |
| Set_Has_Unchecked_Union (Base_Type (Typ), True); |
| Set_Is_Unchecked_Union (Base_Type (Typ), True); |
| |
| end Unchecked_Union; |
| |
| ------------------------ |
| -- Unimplemented_Unit -- |
| ------------------------ |
| |
| -- pragma Unimplemented_Unit; |
| |
| -- Note: this only gives an error if we are generating code, |
| -- or if we are in a generic library unit (where the pragma |
| -- appears in the body, not in the spec). |
| |
| when Pragma_Unimplemented_Unit => Unimplemented_Unit : declare |
| Cunitent : Entity_Id := Cunit_Entity (Get_Source_Unit (Loc)); |
| Ent_Kind : Entity_Kind := Ekind (Cunitent); |
| |
| begin |
| GNAT_Pragma; |
| Check_Arg_Count (0); |
| |
| if Operating_Mode = Generate_Code |
| or else Ent_Kind = E_Generic_Function |
| or else Ent_Kind = E_Generic_Procedure |
| or else Ent_Kind = E_Generic_Package |
| then |
| Get_Name_String (Chars (Cunitent)); |
| Set_Casing (Mixed_Case); |
| Write_Str (Name_Buffer (1 .. Name_Len)); |
| Write_Str (" is not implemented"); |
| Write_Eol; |
| raise Unrecoverable_Error; |
| end if; |
| end Unimplemented_Unit; |
| |
| ------------------------------ |
| -- Unreserve_All_Interrupts -- |
| ------------------------------ |
| |
| -- pragma Unreserve_All_Interrupts; |
| |
| when Pragma_Unreserve_All_Interrupts => |
| GNAT_Pragma; |
| Check_Arg_Count (0); |
| |
| if In_Extended_Main_Code_Unit (Main_Unit_Entity) then |
| Unreserve_All_Interrupts := True; |
| end if; |
| |
| ---------------- |
| -- Unsuppress -- |
| ---------------- |
| |
| -- pragma Unsuppress (IDENTIFIER [, [On =>] NAME]); |
| |
| when Pragma_Unsuppress => |
| GNAT_Pragma; |
| Process_Suppress_Unsuppress (False); |
| |
| ------------------- |
| -- Use_VADS_Size -- |
| ------------------- |
| |
| -- pragma Use_VADS_Size; |
| |
| when Pragma_Use_VADS_Size => |
| GNAT_Pragma; |
| Check_Arg_Count (0); |
| Check_Valid_Configuration_Pragma; |
| Use_VADS_Size := True; |
| |
| --------------------- |
| -- Validity_Checks -- |
| --------------------- |
| |
| -- pragma Validity_Checks (On | Off | ALL_CHECKS | STRING_LITERAL); |
| |
| when Pragma_Validity_Checks => Validity_Checks : declare |
| A : constant Node_Id := Expression (Arg1); |
| S : String_Id; |
| C : Char_Code; |
| |
| begin |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_No_Identifiers; |
| |
| if Nkind (A) = N_String_Literal then |
| S := Strval (A); |
| |
| declare |
| Slen : Natural := Natural (String_Length (S)); |
| Options : String (1 .. Slen); |
| J : Natural; |
| |
| begin |
| J := 1; |
| loop |
| C := Get_String_Char (S, Int (J)); |
| exit when not In_Character_Range (C); |
| Options (J) := Get_Character (C); |
| |
| if J = Slen then |
| Set_Validity_Check_Options (Options); |
| exit; |
| else |
| J := J + 1; |
| end if; |
| end loop; |
| end; |
| |
| elsif Nkind (A) = N_Identifier then |
| |
| if Chars (A) = Name_All_Checks then |
| Set_Validity_Check_Options ("a"); |
| |
| elsif Chars (A) = Name_On then |
| Validity_Checks_On := True; |
| |
| elsif Chars (A) = Name_Off then |
| Validity_Checks_On := False; |
| |
| end if; |
| end if; |
| end Validity_Checks; |
| |
| -------------- |
| -- Volatile -- |
| -------------- |
| |
| -- pragma Volatile (LOCAL_NAME); |
| |
| when Pragma_Volatile => |
| Process_Atomic_Shared_Volatile; |
| |
| ------------------------- |
| -- Volatile_Components -- |
| ------------------------- |
| |
| -- pragma Volatile_Components (array_LOCAL_NAME); |
| |
| -- Volatile is handled by the same circuit as Atomic_Components |
| |
| -------------- |
| -- Warnings -- |
| -------------- |
| |
| -- pragma Warnings (On | Off, [LOCAL_NAME]) |
| |
| when Pragma_Warnings => |
| GNAT_Pragma; |
| Check_At_Least_N_Arguments (1); |
| Check_At_Most_N_Arguments (2); |
| Check_No_Identifiers; |
| |
| -- One argument case was processed by parser in Par.Prag |
| |
| if Arg_Count /= 1 then |
| Check_Arg_Is_One_Of (Arg1, Name_On, Name_Off); |
| Check_Arg_Count (2); |
| |
| declare |
| E_Id : Node_Id; |
| E : Entity_Id; |
| |
| begin |
| E_Id := Expression (Arg2); |
| Analyze (E_Id); |
| |
| if not Is_Entity_Name (E_Id) then |
| Error_Pragma_Arg |
| ("second argument of pragma% must be entity name", |
| Arg2); |
| end if; |
| |
| E := Entity (E_Id); |
| |
| if E = Any_Id then |
| return; |
| else |
| loop |
| Set_Warnings_Off (E, |
| (Chars (Expression (Arg1)) = Name_Off)); |
| |
| if Is_Enumeration_Type (E) then |
| declare |
| Lit : Entity_Id := First_Literal (E); |
| |
| begin |
| while Present (Lit) loop |
| Set_Warnings_Off (Lit); |
| Next_Literal (Lit); |
| end loop; |
| end; |
| end if; |
| |
| exit when No (Homonym (E)); |
| E := Homonym (E); |
| end loop; |
| end if; |
| end; |
| end if; |
| |
| ------------------- |
| -- Weak_External -- |
| ------------------- |
| |
| -- pragma Weak_External ([Entity =>] LOCAL_NAME); |
| |
| when Pragma_Weak_External => Weak_External : declare |
| Ent : Entity_Id; |
| |
| begin |
| GNAT_Pragma; |
| Check_Arg_Count (1); |
| Check_Optional_Identifier (Arg1, Name_Entity); |
| Check_Arg_Is_Library_Level_Local_Name (Arg1); |
| Ent := Entity (Expression (Arg1)); |
| |
| if Rep_Item_Too_Early (Ent, N) then |
| return; |
| else |
| Ent := Underlying_Type (Ent); |
| end if; |
| |
| -- The only processing required is to link this item on to the |
| -- list of rep items for the given entity. This is accomplished |
| -- by the call to Rep_Item_Too_Late (when no error is detected |
| -- and False is returned). |
| |
| if Rep_Item_Too_Late (Ent, N) then |
| return; |
| else |
| Set_Has_Gigi_Rep_Item (Ent); |
| end if; |
| end Weak_External; |
| |
| end case; |
| |
| exception |
| when Pragma_Exit => null; |
| |
| end Analyze_Pragma; |
| |
| ------------------------- |
| -- Get_Base_Subprogram -- |
| ------------------------- |
| |
| function Get_Base_Subprogram (Def_Id : Entity_Id) return Entity_Id is |
| Result : Entity_Id; |
| |
| begin |
| Result := Def_Id; |
| |
| -- Follow subprogram renaming chain |
| |
| while Is_Subprogram (Result) |
| and then |
| (Is_Generic_Instance (Result) |
| or else Nkind (Parent (Declaration_Node (Result))) = |
| N_Subprogram_Renaming_Declaration) |
| and then Present (Alias (Result)) |
| loop |
| Result := Alias (Result); |
| end loop; |
| |
| return Result; |
| end Get_Base_Subprogram; |
| |
| --------------------------- |
| -- Is_Generic_Subprogram -- |
| --------------------------- |
| |
| function Is_Generic_Subprogram (Id : Entity_Id) return Boolean is |
| begin |
| return Ekind (Id) = E_Generic_Procedure |
| or else Ekind (Id) = E_Generic_Function; |
| end Is_Generic_Subprogram; |
| |
| ------------------------------ |
| -- Is_Pragma_String_Literal -- |
| ------------------------------ |
| |
| -- This function returns true if the corresponding pragma argument is |
| -- a static string expression. These are the only cases in which string |
| -- literals can appear as pragma arguments. We also allow a string |
| -- literal as the first argument to pragma Assert (although it will |
| -- of course always generate a type error). |
| |
| function Is_Pragma_String_Literal (Par : Node_Id) return Boolean is |
| Pragn : constant Node_Id := Parent (Par); |
| Assoc : constant List_Id := Pragma_Argument_Associations (Pragn); |
| Pname : constant Name_Id := Chars (Pragn); |
| Argn : Natural; |
| N : Node_Id; |
| |
| begin |
| Argn := 1; |
| N := First (Assoc); |
| loop |
| exit when N = Par; |
| Argn := Argn + 1; |
| Next (N); |
| end loop; |
| |
| if Pname = Name_Assert then |
| return True; |
| |
| elsif Pname = Name_Export then |
| return Argn > 2; |
| |
| elsif Pname = Name_Ident then |
| return Argn = 1; |
| |
| elsif Pname = Name_Import then |
| return Argn > 2; |
| |
| elsif Pname = Name_Interface_Name then |
| return Argn > 1; |
| |
| elsif Pname = Name_Linker_Alias then |
| return Argn = 2; |
| |
| elsif Pname = Name_Linker_Section then |
| return Argn = 2; |
| |
| elsif Pname = Name_Machine_Attribute then |
| return Argn = 2; |
| |
| elsif Pname = Name_Source_File_Name then |
| return True; |
| |
| elsif Pname = Name_Source_Reference then |
| return Argn = 2; |
| |
| elsif Pname = Name_Title then |
| return True; |
| |
| elsif Pname = Name_Subtitle then |
| return True; |
| |
| else |
| return False; |
| end if; |
| |
| end Is_Pragma_String_Literal; |
| |
| -------------------------------------- |
| -- Process_Compilation_Unit_Pragmas -- |
| -------------------------------------- |
| |
| procedure Process_Compilation_Unit_Pragmas (N : Node_Id) is |
| begin |
| -- A special check for pragma Suppress_All. This is a strange DEC |
| -- pragma, strange because it comes at the end of the unit. If we |
| -- have a pragma Suppress_All in the Pragmas_After of the current |
| -- unit, then we insert a pragma Suppress (All_Checks) at the start |
| -- of the context clause to ensure the correct processing. |
| |
| declare |
| PA : constant List_Id := Pragmas_After (Aux_Decls_Node (N)); |
| P : Node_Id; |
| |
| begin |
| if Present (PA) then |
| P := First (PA); |
| while Present (P) loop |
| if Chars (P) = Name_Suppress_All then |
| Prepend_To (Context_Items (N), |
| Make_Pragma (Sloc (P), |
| Chars => Name_Suppress, |
| Pragma_Argument_Associations => New_List ( |
| Make_Pragma_Argument_Association (Sloc (P), |
| Expression => |
| Make_Identifier (Sloc (P), |
| Chars => Name_All_Checks))))); |
| exit; |
| end if; |
| |
| Next (P); |
| end loop; |
| end if; |
| end; |
| end Process_Compilation_Unit_Pragmas; |
| |
| -------------------------------- |
| -- Set_Encoded_Interface_Name -- |
| -------------------------------- |
| |
| procedure Set_Encoded_Interface_Name (E : Entity_Id; S : Node_Id) is |
| Str : constant String_Id := Strval (S); |
| Len : constant Int := String_Length (Str); |
| CC : Char_Code; |
| C : Character; |
| J : Int; |
| |
| Hex : constant array (0 .. 15) of Character := "0123456789abcdef"; |
| |
| procedure Encode; |
| -- Stores encoded value of character code CC. The encoding we |
| -- use an underscore followed by four lower case hex digits. |
| |
| procedure Encode is |
| begin |
| Store_String_Char (Get_Char_Code ('_')); |
| Store_String_Char |
| (Get_Char_Code (Hex (Integer (CC / 2 ** 12)))); |
| Store_String_Char |
| (Get_Char_Code (Hex (Integer (CC / 2 ** 8 and 16#0F#)))); |
| Store_String_Char |
| (Get_Char_Code (Hex (Integer (CC / 2 ** 4 and 16#0F#)))); |
| Store_String_Char |
| (Get_Char_Code (Hex (Integer (CC and 16#0F#)))); |
| end Encode; |
| |
| -- Start of processing for Set_Encoded_Interface_Name |
| |
| begin |
| -- If first character is asterisk, this is a link name, and we |
| -- leave it completely unmodified. We also ignore null strings |
| -- (the latter case happens only in error cases) and no encoding |
| -- should occur for Java interface names. |
| |
| if Len = 0 |
| or else Get_String_Char (Str, 1) = Get_Char_Code ('*') |
| or else Java_VM |
| then |
| Set_Interface_Name (E, S); |
| |
| else |
| J := 1; |
| loop |
| CC := Get_String_Char (Str, J); |
| |
| exit when not In_Character_Range (CC); |
| |
| C := Get_Character (CC); |
| |
| exit when C /= '_' and then C /= '$' |
| and then C not in '0' .. '9' |
| and then C not in 'a' .. 'z' |
| and then C not in 'A' .. 'Z'; |
| |
| if J = Len then |
| Set_Interface_Name (E, S); |
| return; |
| |
| else |
| J := J + 1; |
| end if; |
| end loop; |
| |
| -- Here we need to encode. The encoding we use as follows: |
| -- three underscores + four hex digits (lower case) |
| |
| Start_String; |
| |
| for J in 1 .. String_Length (Str) loop |
| CC := Get_String_Char (Str, J); |
| |
| if not In_Character_Range (CC) then |
| Encode; |
| else |
| C := Get_Character (CC); |
| |
| if C = '_' or else C = '$' |
| or else C in '0' .. '9' |
| or else C in 'a' .. 'z' |
| or else C in 'A' .. 'Z' |
| then |
| Store_String_Char (CC); |
| else |
| Encode; |
| end if; |
| end if; |
| end loop; |
| |
| Set_Interface_Name (E, |
| Make_String_Literal (Sloc (S), |
| Strval => End_String)); |
| end if; |
| end Set_Encoded_Interface_Name; |
| |
| ------------------- |
| -- Set_Unit_Name -- |
| ------------------- |
| |
| procedure Set_Unit_Name (N : Node_Id; With_Item : Node_Id) is |
| Pref : Node_Id; |
| Scop : Entity_Id; |
| |
| begin |
| if Nkind (N) = N_Identifier |
| and then Nkind (With_Item) = N_Identifier |
| then |
| Set_Entity (N, Entity (With_Item)); |
| |
| elsif Nkind (N) = N_Selected_Component then |
| Change_Selected_Component_To_Expanded_Name (N); |
| Set_Entity (N, Entity (With_Item)); |
| Set_Entity (Selector_Name (N), Entity (N)); |
| |
| Pref := Prefix (N); |
| Scop := Scope (Entity (N)); |
| |
| while Nkind (Pref) = N_Selected_Component loop |
| Change_Selected_Component_To_Expanded_Name (Pref); |
| Set_Entity (Selector_Name (Pref), Scop); |
| Set_Entity (Pref, Scop); |
| Pref := Prefix (Pref); |
| Scop := Scope (Scop); |
| end loop; |
| |
| Set_Entity (Pref, Scop); |
| end if; |
| end Set_Unit_Name; |
| |
| end Sem_Prag; |