Preelaborable address clause?

Preelaborable address clause?

[Rod Chapman]

Does anyone know if it's possible to construct a Pre-Elaborable
Address representation clause?

I find that

  A : Integer
  for A'Address use System.Storage_Elements.To_Address(16#00001000#);

if rejected when pragma Preelaboreate is applied to the enclosing
unit, since To_Address is not a static function (LRM 10.2.1(7))

 Thanks,  
   Rod Chapman
   Praxis Critical Systems
   rod@praxis-cs.co.uk

Re: Preelaborable address clause?

[Niklas Holsti]

Rod Chapman wrote:
> 
> Does anyone know if it's possible to construct a Pre-Elaborable
> Address representation clause?
> 
> I find that
> 
>   A : Integer
>   for A'Address use System.Storage_Elements.To_Address(16#00001000#);
> 
> if rejected when pragma Preelaboreate is applied to the enclosing
> unit, since To_Address is not a static function (LRM 10.2.1(7))

Probably you already rejected this possibility, but I'll state
it anyway: if System.Address is not a private type on your system,
you could supply a direct literal of that type, instead of a
To_Address conversion. Of course, it would not be portable.

Niklas Holsti
Working at but not speaking for Space Systems Finland Ltd.

Re: Preelaborable address clause?

[Nick Roberts]

Niklas Holsti wrote in message <36C20210.4C8B494B@icon.fi>...
|Rod Chapman wrote:
|>
|> Does anyone know if it's possible to construct a Pre-Elaborable
|> Address representation clause?
|>
|> I find that
|>
|>   A : Integer
|>   for A'Address use System.Storage_Elements.To_Address(16#00001000#);
|>
|> if rejected when pragma Preelaboreate is applied to the enclosing
|> unit, since To_Address is not a static function (LRM 10.2.1(7))
|
|Probably you already rejected this possibility, but I'll state
|it anyway: if System.Address is not a private type on your system,
|you could supply a direct literal of that type, instead of a
|To_Address conversion. Of course, it would not be portable.


But, since System.Storage_Elements.To_Address is implementation-dependent
anyway, portability is not an issue.

I would suggest (to Rod) that if your compiler does have a private
System.Address type (and does not support any other means of supplying a
static address to an address representation clause), you try another
compiler.

|Niklas Holsti
|Working at but not speaking for Space Systems Finland Ltd.

-------------------------------------------
Nick Roberts    "The Prophylactic Didactic"
-------------------------------------------

Re: Preelaborable address clause?

[robert_dewar]

In article <7a3qmo$e66$4@plug.news.pipex.net>,
  "Nick Roberts" <Nick.Roberts@dial.pipex.com> wrote:
> I would suggest (to Rod) that if your compiler does have
> a private System.Address type (and does not support any
> other means of supplying a static address to an address
> representation clause), you try another compiler.

Note that the RM specifically recommends (for very good
reasons!) that Address be a private type, so if your
compiler does NOT make it a private type, then it is not
following this advice.

As for a method of supplying a static address, there is
obviously no way of doing this within the language. It may
well be useful to add an implementation dependent attribute
to achieve this effect, but of course use of such an
attribute would most certainly be non-portable (To_Address
is much more portable than Nick implies, it is likely that
on a given architecture it has a predictable portable
effect).

-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/       Search, Read, Discuss, or Start Your Own