Re: ? Is ok return a type derived from ada.finalization.controlled from a "Pure_Function" ? thanks.

[Daniel Norte Moraes <danielcheagle@gmail.com>]

Em quinta-feira, 24 de janeiro de 2019 21:56:12 UTC-2, Daniel Norte Moraes  escreveu:
> Hi!
> 
>   Is ok return a type derived from ada.finalization.controlled 
> from a function declared "Pure_Function" ?
> 
>   Or yet, is ok declare a fuction returning a 
> controlled type as "pure_function" ?
> 
>   Thanks in Advance!!!
>   
> []'s Dani. :-)
> 
>  note1 : the type has a access value.
>  note2 : initialize, adjust and finalize overrided and working :-)
> 
>  fragment example code:
> 
> ---------------------------------
> pragma Ada_2012;
> pragma Detect_Blocking;
> 
> with Ada.Finalization;
> 
> package Arbitrary
>   with preelaborate
> is
> 
>    type Arbitrary_Type (size : Positive) is
>      new Ada.Finalization.Controlled with private;
> 
>    function To_Arbitrary (value : Integer; precision : Integer)
>      return Arbitrary_Type
>       with inline; -- Can I add "pure_function" ?
> 
> private
> 
>   type Mantissa_Type is array (Positive range <>) of Integer;
>   type Mantissa_Pointer is access Mantissa_Type;
> 
>   type Arbitrary_Type (size : Positive) is
>     new Ada.Finalization.Controlled with record
>       mantissa    : Mantissa_Pointer;
>       exponent    : Integer;
>       sign        : Integer range -1 .. 1;
>       precision   : Positive := size;
>    end record;
> 
> end arbitrary;
> 
> -----------------------------------------------
> 
> 
> pragma Ada_2012;
> pragma Detect_Blocking;
> 
> with Ada.Unchecked_Deallocation;
> 
> package body Arbitrary is
> 
>   procedure Delete is new Ada.Unchecked_Deallocation (Mantissa_Type,
>     Mantissa_Pointer);
> 
>   -----------------------------------------------------------------------
>   -- Initialize an Arbitrary_Type
>   -----------------------------------------------------------------------
>   procedure Initialize (Object : in out Arbitrary_Type) is
>   begin
>     Object.mantissa     := new Mantissa_Type (1 .. Object.precision);
>     Object.exponent     := 0;
>     Object.sign         := 1;
>     -- "here" for diminish race condition from OS' s
>     Object.mantissa.all := (others => 0);
>   end Initialize;
> 
>   -----------------------------------------------------------------------
>   -- Fix an Arbitrary_Type after being assigned a value
>   -----------------------------------------------------------------------
>   procedure Adjust (Object : in out Arbitrary_Type) is
>   begin
>     Object.mantissa := new Mantissa_Type'(Object.mantissa.all);
>   end Adjust;
> 
>   -----------------------------------------------------------------------
>   -- Release an Arbitrary_Type;
>   -----------------------------------------------------------------------
>   procedure Finalize (Object : in out Arbitrary_Type) is
>   begin
>     if Object.mantissa /= null then
>       Delete (Object.mantissa);
>     end if;
>     Object.mantissa := null;
>   end Finalize;
>   
>   -----------------------------------------------------------------------
>   -- Convert an Integer type to an Arbitrary_Type
>   -----------------------------------------------------------------------
>   function To_Arbitrary (value : Integer; precision : Integer)
>     return Arbitrary_Type is
>     result    : Arbitrary_Type (precision);
>   begin
>     result.mantissa (result.exponent + 1) := value;
>     Normalize (result);
>     return result;
>   end To_Arbitrary;
> 
> end arbitrary;
> -------------------------------------------------------------------
> 
>  Really Thanks! :-)
>  []'s Dani. :-)

Thanks Randy,Shark8 and Simon! :-)

Continuing the work, I tested including pure_function and the craziest mistakes popped up.
gdb showed that pure_function interfered with "adjust" and "initialize" horribly. (I.e.
Thanks for the advice! at least in "to_arbitrary" add "Pure_Function" is a bad idea.