Aliased

Aliased

[nblanpain]

Hello,

I have a probleme with aliased variable :

-- Specification

package Test is

...

private

type T_Toto is ...;
type A_Toto is acess all T_Toto;

type T_Test is new T_Object with record
   Tab : aliased T_Toto;
   Ptr_Tab : A_Toto;
end record;

end Test;

-- Body

package body Test is

...

procedure Initialize is
begin
   Ptr_Tab := Tab'Access;  -- illegal instruction
end Initialize;

...

end Test;

Where is the problem and is there a solution to it?

Thanks,

Re: Aliased

[Martin Dowie]

nblanpain@hotmail.com wrote:
> Hello,
> 
> I have a probleme with aliased variable :
> 
> -- Specification
> 
> package Test is
> 
> ...
> 
> private
> 
> type T_Toto is ...;
> type A_Toto is acess all T_Toto;
> 
> type T_Test is new T_Object with record
>    Tab : aliased T_Toto;
>    Ptr_Tab : A_Toto;
> end record;
> 
> end Test;
> 
> -- Body
> 
> package body Test is
> 
> ...
> 
> procedure Initialize is
> begin
>    Ptr_Tab := Tab'Access;  -- illegal instruction
> end Initialize;
> 
> ...
> 
> end Test;
> 
> Where is the problem and is there a solution to it?

Tab is a component of a record type "T_Test" but you have not provided a 
data object of such a type.

On the assumption that you are creating a "singleton" data object of 
type "T_Test" within the package body of "Test", you need something
like:

package body Test is

    My_Test_Data : T_Test;

    procedure Initialise is
    begin
       My_Test_Data.Ptr_Tab := My_Test_Data.Tab'Access;
    end Initialise;

end Test;

Cheers

-- Martin

Re: Aliased

[nblanpain]

nblanpain@hotmail.com a écrit :
> Hello,
>
> I have a probleme with aliased variable :
>
> -- Specification
>
> package Test is
>
> ...
>
> private
>
> type T_Toto is ...;
> type A_Toto is acess all T_Toto;
>
> type T_Test is new T_Object with record
>    Tab : aliased T_Toto;
>    Ptr_Tab : A_Toto;
> end record;
>
> end Test;
>
> -- Body
>

>
> Where is the problem and is there a solution to it?
>
> Thanks,

Excuse me, there is an error in my program :

package body Test is

...

procedure Initialize (This : in out T_Test) is
begin
    This.Ptr_Tab := This.Tab'Access;  -- illegal instruction
end Initialize;

 ...

end Test;

So the same question : why is there a problem and how can i solve it?

thanks,

Re: Aliased

[Martin Dowie]

nblanpain@hotmail.com wrote:
> So the same question : why is there a problem and how can i solve it?

None, as far as GNAT 3.15p and ObjectAda 7.2.2 (U18) can tell. What 
compiler/OS are you using?

Cheers

-- Martin

Re: Aliased

[Steve]

<nblanpain@hotmail.com> wrote in message 
news:1118851601.345326.86640@g49g2000cwa.googlegroups.com...
> Hello,
>
> I have a probleme with aliased variable :
>
> -- Specification
>
> package Test is
>
> ...
>
> private
>
> type T_Toto is ...;
> type A_Toto is acess all T_Toto;
>
> type T_Test is new T_Object with record
>   Tab : aliased T_Toto;
>   Ptr_Tab : A_Toto;
> end record;
>
> end Test;
>
> -- Body
>
> package body Test is
>
> ...
>
> procedure Initialize is
> begin
>   Ptr_Tab := Tab'Access;  -- illegal instruction
> end Initialize;
>
> ...
>
> end Test;
>
> Where is the problem and is there a solution to it?
>
> Thanks,
>

For a question like this please post the smallest set of sources that 
compile, or give the compilation error such that it may easily be 
reproduced.  Otherwise you are wasting everyones time (including your own).

It is easy to spot a number of possible errors in your sample code, many of 
which are likely just errors in composing your post.  One must "guess" at 
the real source of the problem.

Steve
(The Duck)

Re: Aliased

[nblanpain]

So this is my sources and the compilation error :

------ Container.ads
generic
   type T_Item is private;
   Static_Size : Integer;
package Container is
   type T_Array is array (Integer range <>) of T_Item;
   type A_Array is access all T_Array;
   type T_Container is tagged record
      Obj_Array : aliased T_Array (1..Static_Size);
      Ptr_Array : A_Array;
   end record;
   procedure Initialize (This : in out T_Container; Dynamic_Size : in
Integer);
   function P_Array (This : in T_Container) return A_Array;
end Container;

------ Container.adb
package body Container is
   procedure Initialize (This : in out T_Container; Dynamic_Size : in
Integer) is
   begin
      if Dynamic_Size /= 0 then
         This.Ptr_Array := new T_Array (1.. Dynamic_Size);
     elsif Static_Size /= 0 then
        This.Ptr_Array := This.Obj_Array'Access; --- Compilation Error
     end if;
   end Initialize;
   function P_Array (This : in T_Container) return A_Array is
   begin
      return This.Ptr_Array;
   end P_Array;
end Container;

-- Compilation Error : Object subtype must statically match designated
subtype. No local pointer cannot point to local object.

I have tried to solve this problem using Unchecked_Access or To_Pointer
of System. I have found no solution.
Have you a solution to my problem?

Thanks,

Re: Aliased

[Simon Wright]

nblanpain@hotmail.com writes:

>      elsif Static_Size /= 0 then
>         This.Ptr_Array := This.Obj_Array'Access; --- Compilation Error

With GNAT, use 'Unrestricted_Access.

Re: Aliased

[Jeffrey Carter]

nblanpain@hotmail.com wrote:
> 
> ------ Container.ads
> generic
>    type T_Item is private;
>    Static_Size : Integer;
> package Container is
>    type T_Array is array (Integer range <>) of T_Item;
>    type A_Array is access all T_Array;
>    type T_Container is tagged record
>       Obj_Array : aliased T_Array (1..Static_Size);
>       Ptr_Array : A_Array;
>    end record;

>         This.Ptr_Array := This.Obj_Array'Access; --- Compilation Error
> 
> -- Compilation Error : Object subtype must statically match designated
> subtype. No local pointer cannot point to local object.

A_Array designates an unconstrained array type, T_Array. This.Obj_Array 
is a component of a constrained subtype of T_Array. 
This.Obj_Array'access does not designate the same subtype as A_Array. 
That's why this is illegal.

Change your type declaration to

type T_Array is array (1 .. Static_Size) of T_Item;

and this should work.

-- 
Jeff Carter
"I blow my nose on you."
Monty Python & the Holy Grail
03

Re: Aliased

[Steve]

<nblanpain@hotmail.com> wrote in message 
news:1118930589.514028.150340@g47g2000cwa.googlegroups.com...
> So this is my sources and the compilation error :
>
> ------ Container.ads
[snip]
>
> ------ Container.adb
[snip]
>
> -- Compilation Error : Object subtype must statically match designated
> subtype. No local pointer cannot point to local object.
>
> I have tried to solve this problem using Unchecked_Access or To_Pointer
> of System. I have found no solution.
> Have you a solution to my problem?
>
> Thanks,
>

Ahh... now I recognize the problem.  Here is (what I think is) a simpler 
example to illustrate:

procedure Simple_Case is

  type String_Acc is access all String;

  instance_1 : aliased String := "Hello";
  instance_2 : aliased String( 1..5 );
  accessor   : String_Acc;

begin
  instance_2 := "Hello";
  accessor   := instance_1'Unchecked_Access;
  accessor   := instance_2'Unchecked_Access;
end Simple_Case;

The error reads:
simple_case.adb:12:17 object subtype must statically match designated 
subtype

Generally speaking I really like Ada, but this is an example of one of the 
quirks that I think needs fixing (maybe it will be fixed in Ada 200x???).

In my example the type String_Acc is defined to access subtypes of String 
that are not bounded.
"instance_1" is defined a subtype of string that is not bounded, but with an 
initializer, so it is ok to assign an access to instance_1 to "accessor".
"instance_2" is defined as a fixed length subtype of string, which is 
bounded, so it is not ok to assign an access to instance_2 to accessor.

The Folks at AdaCore recognized that this was a silly requirement and 
created a special pragma that is more flexible for this case.

If you change the above code to read:

  accessor := instance_2'Unrestricted_Access;

GNAT is happy.  Unforutnately this is compiler specific.

In case my above example wasn't clear, the following code makes the compiler 
happy:

procedure Simple_Case is

  subtype String_5 is String( 1.. 5 );

  type String_Acc is access all String;
  type String_5_Acc is access all String_5;

  instance_1 : aliased String := "Hello";
  instance_2 : aliased String( 1..5 );
  accessor_1 : String_Acc;
  accessor_2 : String_5_Acc;

begin
  instance_2 := "Hello";
  accessor_1 := instance_1'Unchecked_Access;
  accessor_2 := instance_2'Unchecked_Access;
end Simple_Case;

Unfortunately it doesn't solve your problem.

Steve
(The Duck) 

Re: Aliased

[Christoph Grein]

For a reference manual exegesis why this does not work:

  type D is array (Integer range <>) of ...;
  type A is access all D;

  X : aliased D (1..3);
  AX: A           := X'Access;
  BX: A (X'Range) := X'Access;

see 
<http://www.christ-usch-grein.homepage.t-online.de/AdaMagica/ThickThin.html>

IANLL, so I do not know why it must be like this.

Re: Aliased

[nblanpain]

It is Ok but only with Gnat, I search a general solution.

Re: Aliased

[nblanpain]

KO : If T_Array is constraint, in Initialize :
 This.Ptr_Array := new T_Array (1.. Dynamic_Size); -- KO

Re: Aliased

[Dmitry A. Kazakov]

On Thu, 16 Jun 2005 19:35:31 -0700, Steve wrote:

> <nblanpain@hotmail.com> wrote in message 
> news:1118930589.514028.150340@g47g2000cwa.googlegroups.com...
>> So this is my sources and the compilation error :
>>
>> ------ Container.ads
> [snip]
>>
>> ------ Container.adb
> [snip]
>>
>> -- Compilation Error : Object subtype must statically match designated
>> subtype. No local pointer cannot point to local object.
>>
>> I have tried to solve this problem using Unchecked_Access or To_Pointer
>> of System. I have found no solution.
>> Have you a solution to my problem?
>>
>> Thanks,
>>
> 
> Ahh... now I recognize the problem.  Here is (what I think is) a simpler 
> example to illustrate:
> 
> procedure Simple_Case is
> 
>   type String_Acc is access all String;
> 
>   instance_1 : aliased String := "Hello";
>   instance_2 : aliased String( 1..5 );
>   accessor   : String_Acc;
> 
> begin
>   instance_2 := "Hello";
>   accessor   := instance_1'Unchecked_Access;
>   accessor   := instance_2'Unchecked_Access;
> end Simple_Case;
> 
> The error reads:
> simple_case.adb:12:17 object subtype must statically match designated 
> subtype
> 
> Generally speaking I really like Ada, but this is an example of one of the 
> quirks that I think needs fixing (maybe it will be fixed in Ada 200x???).

I think it is reasonable. A fix should be rather introducing 'Class for all
types. Then one could:

   type String_Acc is access all String'Class;
      -- Fat pointer containing the bounds, can point to string slices!
   instance_1 : aliased String := "Hello";
   instance_2 : aliased String( 1..5 );
   accessor   : String_Acc;

begin
   instance_2 := "Hello";
   accessor   := instance_1'Unchecked_Access;
   accessor   := instance_2'Unchecked_Access;

> In my example the type String_Acc is defined to access subtypes of String 
> that are not bounded.
> "instance_1" is defined a subtype of string that is not bounded, but with an 
> initializer, so it is ok to assign an access to instance_1 to "accessor".
> "instance_2" is defined as a fixed length subtype of string, which is 
> bounded, so it is not ok to assign an access to instance_2 to accessor.
> 
> The Folks at AdaCore recognized that this was a silly requirement and 
> created a special pragma that is more flexible for this case.

I don't know GNAT implementation details, but if there were no difference
between pointers to bounded and unbounded objects, then either every
pointer should contain the bounds or every object should. Either choice has
disadvantages of its own. Ada's idea to separate these cases looks to me
perfectly good.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Aliased

[Larry Kilgallen]

In article <1118991665.365498.233060@z14g2000cwz.googlegroups.com>, nblanpain@hotmail.com writes:
> It is Ok but only with Gnat, I search a general solution.

What is Ok ?

Please specify context and the author to whom you are replying in your posts.

Please do not presume that everybody's newsreader interface is the same
as your own.

Re: Aliased

[nblanpain]

Except using Unrestricted_Access is there a solution to my problem?

Re: Aliased

[Jeffrey Carter]

nblanpain@hotmail.com wrote:
> Except using Unrestricted_Access is there a solution to my problem?

Yes. Use an access type that designates the same constrained subtype of 
the array type used by your aliased component.

-- 
Jeff Carter
"Blessed is just about anyone with a vested interest in the status quo."
Monty Python's Life of Brian
73

Re: Aliased

[nblanpain]

But in this case, i can't implement the procedure Initialize :
"This.Ptr_Array := new T_Array (1.. Dynamic_Size);" is illegal
(Ptr_array is constrained).
Isn't it?

Re: Aliased

[Jeffrey Carter]

nblanpain@hotmail.com wrote:
> But in this case, i can't implement the procedure Initialize :
> "This.Ptr_Array := new T_Array (1.. Dynamic_Size);" is illegal
> (Ptr_array is constrained).

If T_Array is constrained, or Ptr_Array designates a constrained subtype 
of T_Array, then this would be illegal.

It would help if you quoted some context in your replies.

It would also help if we knew what you were trying to accomplish, not 
just how you were trying to do it. This looks as if you want a 
variable-size array, but you're asking about access types and aliased 
components. Variable arrays in Ada are usually implemented using an 
unconstrained variable, a variant record with a default discriminant:

Max_Size : constant := 100; -- or whatever
-- It's a good idea to specify a max to avoid Storage_Error,
-- since most compilers will allocate enough storage for the
-- maximum possible size.

subtype Index is Positive range 1 .. Max_Size;

type Fixed is array (Index range <>) of ...;

type Variable_Array (Size : Index := Max_Size) is record
    Value : Fixed (1 .. Size);
end record;

R : Variable_Array;

R := Variable_Array'(Size  => 32,
                      Value => Fixed'(1 .. 32 => ...) );

This provides a bounded array, which can vary between 1 and Max_Size 
elements. An alternative is an unbounded array, usually implemented 
using access and controlled types:

type Fixed is array (Positive range <>) of ...;

type Unbounded_Array is private;

function To_Unbounded (Item : Fixed) return Unbounded_Array;
function To_Fixed (Item : Unbounded_Array) return Fixed;

This would be implemented as

type Fixed_Ptr is access Fixed;

type Unbounded_Array is new Ada.Finalization.Controlled with record
    Ptr : Fixed_Ptr;
end record;

procedure Adjust (Object : in out Unbounded_Array);
procedure Finalize (Object : in out Unbounded_Array);

Of course you hide the use of access types from your client to avoid 
dangling references. Adjust handles deallocation on assignment, and 
Finalize on finalization.

If you really need an unbounded array abstraction, though, you should 
look at the Vector container that will be part of the Ada 0X revision (X 
will probably equal 6). An Ada-95 version is available somewhere; check 
adapower.com or adaworld.com.

-- 
Jeff Carter
"Blessed is just about anyone with a vested interest in the status quo."
Monty Python's Life of Brian
73

Re: Aliased

[Robert A Duff]

nblanpain@hotmail.com writes:

> So this is my sources and the compilation error :
>
> ------ Container.ads
> generic
>    type T_Item is private;
>    Static_Size : Integer;
> package Container is
>    type T_Array is array (Integer range <>) of T_Item;
>    type A_Array is access all T_Array;
>    type T_Container is tagged record
>       Obj_Array : aliased T_Array (1..Static_Size);
>       Ptr_Array : A_Array;
>    end record;
>    procedure Initialize (This : in out T_Container; Dynamic_Size : in
> Integer);
>    function P_Array (This : in T_Container) return A_Array;
> end Container;

I have a package that tries to do something similar.
Try wrapping the array in a record:

    type T_Rec(Length: Natural) is
        record
            A: T_Array(1..Length);
        end record;
    type T_Rec_Ptr is access all T_Rec;
    type T_Container is tagged record
        Obj_Array : aliased T_Rec (Length => Static_Size);
        Ptr_Array : T_Rec_Ptr;
    end record;

Then Initialize can set Ptr_Array to either "new T_Rec(Length =>
Dynamic_Size)" or "This.Obj_Array'Access".

Well, you'll want to change the names of things to make sense...
    
> ------ Container.adb
> package body Container is
>    procedure Initialize (This : in out T_Container; Dynamic_Size : in
> Integer) is
>    begin
>       if Dynamic_Size /= 0 then
>          This.Ptr_Array := new T_Array (1.. Dynamic_Size);
>      elsif Static_Size /= 0 then
>         This.Ptr_Array := This.Obj_Array'Access; --- Compilation Error
>      end if;
>    end Initialize;
>    function P_Array (This : in T_Container) return A_Array is
>    begin
>       return This.Ptr_Array;
>    end P_Array;
> end Container;
> 
> -- Compilation Error : Object subtype must statically match designated
> subtype. No local pointer cannot point to local object.

- Bob