From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me
X-Spam-Level: 
X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00
	autolearn=unavailable autolearn_force=no version=3.4.4
Path: 
 eternal-september.org!reader01.eternal-september.org!feeder.eternal-september.org!nntp-feed.chiark.greenend.org.uk!ewrotcd!newsfeed.xs3.de!io.xs3.de!news.jacob-sparre.dk!franka.jacob-sparre.dk!pnx.dk!.POSTED.rrsoftware.com!not-for-mail
From: "Randy Brukardt" <randy@rrsoftware.com>
Newsgroups: comp.lang.ada
Subject: Re: ? Is ok return a  type derived from ada.finalization.controlled
 from a "Pure_Function" ? thanks.
Date: Fri, 25 Jan 2019 15:20:47 -0600
Organization: JSA Research & Innovation
Message-ID: <q2fujg$mu1$1@franka.jacob-sparre.dk>
References: <db66050e-9606-4c79-bd21-6c0164913181@googlegroups.com>
Injection-Date: Fri, 25 Jan 2019 21:20:48 -0000 (UTC)
Injection-Info: franka.jacob-sparre.dk;
 posting-host="rrsoftware.com:24.196.82.226";
	logging-data="23489"; mail-complaints-to="news@jacob-sparre.dk"
X-Priority: 3
X-MSMail-Priority: Normal
X-Newsreader: Microsoft Outlook Express 6.00.2900.5931
X-RFC2646: Format=Flowed; Original
X-MimeOLE: Produced By Microsoft MimeOLE V6.00.2900.7246
Xref: reader01.eternal-september.org comp.lang.ada:55371
Date: 2019-01-25T15:20:47-06:00
List-Id: <comp.lang.ada>

Of course it's OK, "Pure_Function" is some GNAT-specific nonsense. :-)

My recollection is that GNAT does not check if Pure_Function makes sense, so 
the only question is whether you can live with the possible implications. 
(And I don't know why you would want to use Pure_Function anyway.)

Note that in Ada 2020, you would use the Global aspect to declare the usage 
of globals by your subprogram, and those are checked, so either the aspect 
is legal or your program won't compile. But GNAT hasn't implemented that 
yet, so far as I know.

                         Randy.

<danielcheagle@gmail.com> wrote in message 
news:db66050e-9606-4c79-bd21-6c0164913181@googlegroups.com...
>  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. :-)
>
>
>