(Loc : Source_Ptr;
Id_Ref : Node_Id;
A_Type : Entity_Id;
- Dyn : Boolean := False)
- return Node_Id;
+ Dyn : Boolean := False) return Node_Id;
-- Build function to generate the image string for a task that is an
-- array component, concatenating the images of each index. To avoid
-- storage leaks, the string is built with successive slice assignments.
(Loc : Source_Ptr;
Decls : List_Id;
Stats : List_Id;
- Res : Entity_Id)
- return Node_Id;
+ Res : Entity_Id) return Node_Id;
-- Common processing for Task_Array_Image and Task_Record_Image.
-- Build function body that computes image.
function Build_Task_Record_Image
(Loc : Source_Ptr;
Id_Ref : Node_Id;
- Dyn : Boolean := False)
- return Node_Id;
+ Dyn : Boolean := False) return Node_Id;
-- Build function to generate the image string for a task that is a
-- record component. Concatenate name of variable with that of selector.
-- The flag Dyn indicates whether this is called for the initialization
-- created task that is assigned to a selected component.
function Make_CW_Equivalent_Type
- (T : Entity_Id;
- E : Node_Id)
- return Entity_Id;
+ (T : Entity_Id;
+ E : Node_Id) return Entity_Id;
-- T is a class-wide type entity, E is the initial expression node that
-- constrains T in case such as: " X: T := E" or "new T'(E)"
-- This function returns the entity of the Equivalent type and inserts
function Make_Literal_Range
(Loc : Source_Ptr;
- Literal_Typ : Entity_Id)
- return Node_Id;
+ Literal_Typ : Entity_Id) return Node_Id;
-- Produce a Range node whose bounds are:
-- Low_Bound (Literal_Type) ..
-- Low_Bound (Literal_Type) + Length (Literal_Typ) - 1
function New_Class_Wide_Subtype
(CW_Typ : Entity_Id;
- N : Node_Id)
- return Entity_Id;
- -- Create an implicit subtype of CW_Typ attached to node N.
+ N : Node_Id) return Entity_Id;
+ -- Create an implicit subtype of CW_Typ attached to node N
----------------------
-- Adjust_Condition --
(Loc : Source_Ptr;
Id_Ref : Node_Id;
A_Type : Entity_Id;
- Dyn : Boolean := False)
- return Node_Id
+ Dyn : Boolean := False) return Node_Id
is
Dims : constant Nat := Number_Dimensions (A_Type);
- -- Number of dimensions for array of tasks.
+ -- Number of dimensions for array of tasks
Temps : array (1 .. Dims) of Entity_Id;
- -- Array of temporaries to hold string for each index.
+ -- Array of temporaries to hold string for each index
Indx : Node_Id;
-- Index expression
Defining_Identifier => Pref,
Object_Definition => New_Occurrence_Of (Standard_String, Loc),
Expression =>
- Make_String_Literal (Loc, Strval => String_From_Name_Buffer)));
+ Make_String_Literal (Loc,
+ Strval => String_From_Name_Buffer)));
else
Append_To (Decls,
function Build_Task_Image_Decls
(Loc : Source_Ptr;
Id_Ref : Node_Id;
- A_Type : Entity_Id)
- return List_Id
+ A_Type : Entity_Id) return List_Id
is
Decls : constant List_Id := New_List;
T_Id : Entity_Id := Empty;
Defining_Identifier => T_Id,
Object_Definition => New_Occurrence_Of (Standard_String, Loc),
Expression =>
- Make_String_Literal
- (Loc, Strval => String_From_Name_Buffer)));
+ Make_String_Literal (Loc,
+ Strval => String_From_Name_Buffer)));
else
if Nkind (Id_Ref) = N_Identifier
Get_Name_String (Chars (Id_Ref));
- Expr := Make_String_Literal
- (Loc, Strval => String_From_Name_Buffer);
+ Expr :=
+ Make_String_Literal (Loc,
+ Strval => String_From_Name_Buffer);
elsif Nkind (Id_Ref) = N_Selected_Component then
T_Id :=
(Loc : Source_Ptr;
Decls : List_Id;
Stats : List_Id;
- Res : Entity_Id)
- return Node_Id
+ Res : Entity_Id) return Node_Id
is
Spec : Node_Id;
function Build_Task_Record_Image
(Loc : Source_Ptr;
Id_Ref : Node_Id;
- Dyn : Boolean := False)
- return Node_Id
+ Dyn : Boolean := False) return Node_Id
is
Len : Entity_Id;
-- Total length of generated name
-- Name of enclosing variable, prefix of resulting name
Sum : Node_Id;
- -- Expression to compute total size of string.
+ -- Expression to compute total size of string
Sel : Entity_Id;
-- Entity for selector name
Defining_Identifier => Pref,
Object_Definition => New_Occurrence_Of (Standard_String, Loc),
Expression =>
- Make_String_Literal (Loc, Strval => String_From_Name_Buffer)));
+ Make_String_Literal (Loc,
+ Strval => String_From_Name_Buffer)));
else
Append_To (Decls,
Defining_Identifier => Sel,
Object_Definition => New_Occurrence_Of (Standard_String, Loc),
Expression =>
- Make_String_Literal (Loc, Strval => String_From_Name_Buffer)));
+ Make_String_Literal (Loc,
+ Strval => String_From_Name_Buffer)));
Sum := Make_Integer_Literal (Loc, Nat (Name_Len + 1));
function Duplicate_Subexpr
(Exp : Node_Id;
- Name_Req : Boolean := False)
- return Node_Id
+ Name_Req : Boolean := False) return Node_Id
is
begin
Remove_Side_Effects (Exp, Name_Req);
function Duplicate_Subexpr_No_Checks
(Exp : Node_Id;
- Name_Req : Boolean := False)
- return Node_Id
+ Name_Req : Boolean := False) return Node_Id
is
New_Exp : Node_Id;
function Duplicate_Subexpr_Move_Checks
(Exp : Node_Id;
- Name_Req : Boolean := False)
- return Node_Id
+ Name_Req : Boolean := False) return Node_Id
is
New_Exp : Node_Id;
-- in gigi.
P := Parent (N);
-
while Present (P)
and then Nkind (P) /= N_Subprogram_Body
loop
then
if Is_Itype (Exp_Typ) then
- -- No need to generate a new one.
+ -- No need to generate a new one
T := Exp_Typ;
-- condition, Sens is True if the condition is true and
-- False if it needs inverting.
- Cond := Condition (CV);
-
-- Deal with NOT operators, inverting sense
+ Cond := Condition (CV);
while Nkind (Cond) = N_Op_Not loop
Cond := Right_Opnd (Cond);
Sens := not Sens;
return;
end if;
- -- Statements, declarations, pragmas, representation clauses.
+ -- Statements, declarations, pragmas, representation clauses
when
-- Statements
else
declare
- Decl : Node_Id := Assoc_Node;
+ Decl : Node_Id;
begin
-- Check whether these actions were generated
-- by a declaration that is part of the loop_
-- actions for the component_association.
+ Decl := Assoc_Node;
while Present (Decl) loop
exit when Parent (Decl) = P
and then Is_List_Member (Decl)
if Result and then Nkind (P) = N_Indexed_Component then
Expr := First (Expressions (P));
-
while Present (Expr) loop
Force_Evaluation (Expr);
Next (Expr);
elsif Nkind (N) = N_Case_Statement then
declare
- Alt : Node_Id := First (Alternatives (N));
-
+ Alt : Node_Id;
begin
+ Alt := First (Alternatives (N));
while Present (Alt) loop
Kill_Dead_Code (Statements (Alt));
Next (Alt);
-- derived types
function Make_CW_Equivalent_Type
- (T : Entity_Id;
- E : Node_Id)
- return Entity_Id
+ (T : Entity_Id;
+ E : Node_Id) return Entity_Id
is
Loc : constant Source_Ptr := Sloc (E);
Root_Typ : constant Entity_Id := Root_Type (T);
function Make_Literal_Range
(Loc : Source_Ptr;
- Literal_Typ : Entity_Id)
- return Node_Id
+ Literal_Typ : Entity_Id) return Node_Id
is
Lo : constant Node_Id :=
New_Copy_Tree (String_Literal_Low_Bound (Literal_Typ));
function Make_Subtype_From_Expr
(E : Node_Id;
- Unc_Typ : Entity_Id)
- return Node_Id
+ Unc_Typ : Entity_Id) return Node_Id
is
Loc : constant Source_Ptr := Sloc (E);
List_Constr : constant List_Id := New_List;
function New_Class_Wide_Subtype
(CW_Typ : Entity_Id;
- N : Node_Id)
- return Entity_Id
+ N : Node_Id) return Entity_Id
is
Res : constant Entity_Id := Create_Itype (E_Void, N);
Res_Name : constant Name_Id := Chars (Res);
else
N := First (L);
-
while Present (N) loop
if not Side_Effect_Free (N) then
return False;
Set_Is_Renaming_Of_Object (Def_Id, False);
end if;
- -- If it is a scalar type, just make a copy.
+ -- If it is a scalar type, just make a copy
elsif Is_Elementary_Type (Exp_Type) then
Def_Id := Make_Defining_Identifier (Loc, New_Internal_Name ('R'));
then
return True;
- -- Otherwise, Gigi cannot handle this and we must make a temporary.
+ -- Otherwise, Gigi cannot handle this and we must make a temporary
else
return False;
function Target_Has_Fixed_Ops
(Left_Typ : Entity_Id;
Right_Typ : Entity_Id;
- Result_Typ : Entity_Id)
- return Boolean
+ Result_Typ : Entity_Id) return Boolean
is
function Is_Fractional_Type (Typ : Entity_Id) return Boolean;
-- Return True if the given type is a fixed-point type with a small
function Duplicate_Subexpr
(Exp : Node_Id;
- Name_Req : Boolean := False)
- return Node_Id;
+ Name_Req : Boolean := False) return Node_Id;
-- Given the node for a subexpression, this function makes a logical
-- copy of the subexpression, and returns it. This is intended for use
-- when the expansion of an expression needs to repeat part of it. For
function Duplicate_Subexpr_No_Checks
(Exp : Node_Id;
- Name_Req : Boolean := False)
- return Node_Id;
+ Name_Req : Boolean := False) return Node_Id;
-- Identical in effect to Duplicate_Subexpr, except that Remove_Checks
-- is called on the result, so that the duplicated expression does not
-- include checks. This is appropriate for use when Exp, the original
function Duplicate_Subexpr_Move_Checks
(Exp : Node_Id;
- Name_Req : Boolean := False)
- return Node_Id;
+ Name_Req : Boolean := False) return Node_Id;
-- Identical in effect to Duplicate_Subexpr, except that Remove_Checks
-- is called on Exp after the duplication is complete, so that the
-- original expression does not include checks. In this case the result
function Make_Subtype_From_Expr
(E : Node_Id;
- Unc_Typ : Entity_Id)
- return Node_Id;
+ Unc_Typ : Entity_Id) return Node_Id;
-- Returns a subtype indication corresponding to the actual type of an
-- expression E. Unc_Typ is an unconstrained array or record, or
-- a classwide type.
function Target_Has_Fixed_Ops
(Left_Typ : Entity_Id;
Right_Typ : Entity_Id;
- Result_Typ : Entity_Id)
- return Boolean;
+ Result_Typ : Entity_Id) return Boolean;
-- Returns True if and only if the target machine has direct support
-- for fixed-by-fixed multiplications and divisions for the given
-- operand and result types. This is called in package Exp_Fixd to
package body Interfaces.CPP is
+ -- The declarations below need (extensive) comments ???
+
subtype Cstring is String (Positive);
type Cstring_Ptr is access all Cstring;
type Tag_Table is array (Natural range <>) of Vtable_Ptr;
end record;
type Vtable_Entry is record
- Pfn : System.Address;
+ Pfn : System.Address;
end record;
type Type_Specific_Data_Ptr is access all Type_Specific_Data;
function CPP_CW_Membership
(Obj_Tag : Vtable_Ptr;
- Typ_Tag : Vtable_Ptr)
- return Boolean
+ Typ_Tag : Vtable_Ptr) return Boolean
is
Pos : constant Integer := Obj_Tag.TSD.Idepth - Typ_Tag.TSD.Idepth;
begin
function CPP_Get_Prim_Op_Address
(T : Vtable_Ptr;
- Position : Positive)
- return Address is
+ Position : Positive) return Address
+ is
begin
return T.Prims_Ptr (Position).Pfn;
end CPP_Get_Prim_Op_Address;
function CPP_Get_RC_Offset (T : Vtable_Ptr) return SSE.Storage_Offset is
pragma Warnings (Off, T);
-
begin
return 0;
end CPP_Get_RC_Offset;
function CPP_Get_Remotely_Callable (T : Vtable_Ptr) return Boolean is
pragma Warnings (Off, T);
-
begin
return True;
end CPP_Get_Remotely_Callable;
(Old_TSD : Address;
New_Tag : Vtable_Ptr)
is
- TSD : constant Type_Specific_Data_Ptr
- := To_Type_Specific_Data_Ptr (Old_TSD);
+ TSD : constant Type_Specific_Data_Ptr :=
+ To_Type_Specific_Data_Ptr (Old_TSD);
New_TSD : Type_Specific_Data renames New_Tag.TSD.all;
procedure CPP_Set_RC_Offset (T : Vtable_Ptr; Value : SSE.Storage_Offset) is
pragma Warnings (Off, T);
pragma Warnings (Off, Value);
-
begin
null;
end CPP_Set_RC_Offset;
procedure CPP_Set_Remotely_Callable (T : Vtable_Ptr; Value : Boolean) is
pragma Warnings (Off, T);
pragma Warnings (Off, Value);
-
begin
null;
end CPP_Set_Remotely_Callable;
function Expanded_Name (T : Vtable_Ptr) return String is
Result : constant Cstring_Ptr := T.TSD.Expanded_Name;
-
begin
return Result (1 .. Length (Result));
end Expanded_Name;
function External_Tag (T : Vtable_Ptr) return String is
Result : constant Cstring_Ptr := T.TSD.External_Tag;
-
begin
return Result (1 .. Length (Result));
end External_Tag;
return Len - 1;
end Length;
+
end Interfaces.CPP;
-- Definitions for interfacing to C++ classes
+-- This package corresponds to Ada.Tags but applied to tagged types which are
+-- are imported from C++ and correspond exactly to a C++ Class. The code that
+-- the GNAT front end generates does not know about the structure of the C++
+-- dispatch table (Vtable) but always accesses it through the procedural
+-- interface defined in this package, thus the implementation of this package
+-- (the body) can be customized to another C++ compiler without any change in
+-- the compiler code itself as long as this procedural interface is respected.
+-- Note that Ada.Tags defines a very similar procedural interface to the
+-- regular Ada Dispatch Table.
+
with System;
with System.Storage_Elements;
package S renames System;
package SSE renames System.Storage_Elements;
- -- This package corresponds to Ada.Tags but applied to tagged
- -- types which are 'imported' from C++ and correspond exactly to a
- -- C++ Class. GNAT doesn't know about the structure of the C++
- -- dispatch table (Vtable) but always accesses it through the
- -- procedural interface defined below, thus the implementation of
- -- this package (the body) can be customized to another C++
- -- compiler without any change in the compiler code itself as long
- -- as this procedural interface is respected. Note that Ada.Tags
- -- defines a very similar procedural interface to the regular Ada
- -- Dispatch Table.
-
type Vtable_Ptr is private;
function Expanded_Name (T : Vtable_Ptr) return String;
function External_Tag (T : Vtable_Ptr) return String;
private
+ -- These subprograms are in the private part. They are never accessed
+ -- directly except from compiler generated code, which has access to
+ -- private components of packages via the Rtsfind interface.
procedure CPP_Set_Prim_Op_Address
(T : Vtable_Ptr;
OSDN Git Service
