discriminant in constraint must appear alone

discriminant in constraint must appear alone

[Vincent Smeets]

Hallo,

I want to define a discriminated record type with two arrays. One array only half the size of the other. Below is the type definition that I want to use.

   type R (D : Positive) is
      record
         A : String (1 .. D);
         B : String (1 .. D / 2);
      end record;

This type definition can't be compiled by the GNAT compiler. It gives the error message
    "discriminant in constraint must appear alone"
for the record component B. I know this isn't correct Ada, but how should I define the type in a correct way?

I have defined B as
    B : String (1 .. D);
and only used the first half of it, but this way I waist memory and can't have any Ada constraint checks for component B. So this is not the way I want to do it.

Are there other possiblities?


-- 
Thanks,
Vincent Smeets

Re: discriminant in constraint must appear alone

[Randy Brukardt]

"Vincent Smeets" <No.Spam@T-Online.de> wrote in message
news:bqiq1m$uis$00$1@news.t-online.com...
> Hallo,
>
> I want to define a discriminated record type with two arrays. One array
only half the size
> of the other. Below is the type definition that I want to use.
>
>   type R (D : Positive) is
>      record
>         A : String (1 .. D);
>         B : String (1 .. D / 2);
>      end record;
>
> This type definition can't be compiled by the GNAT compiler. It gives the
error message
>    "discriminant in constraint must appear alone"
>for the record component B. I know this isn't correct Ada, but how should I
define the type
>in a correct way?

I don't think you can.

>I have defined B as
>    B : String (1 .. D);
>and only used the first half of it, but this way I waist memory and can't
have any Ada
>constraint checks for component B. So this is not the way I want to do it.
>
>Are there other possiblities?

The only thing that comes to mind is to have a second discriminant. The
problem with that is that the relationship between them can't be defined
formally.

   type R (D1, D2 : Positive) is
     record
        A : String (1 .. D1);
        B : String (1 .. D2);
     end record;

  Obj : R (Max_Size, Max_Size/2);

I suppose you could have Initialize check if they don't match and raise an
exception:

   type R (D1, D2 : Positive) is new Ada.Finalization.Controlled with
     record
        A : String (1 .. D1);
        B : String (1 .. D2);
     end record;

   procedure Initialize (Obj : in out R);

   procedure Initialize (Obj : in out R) is
   begin
      if Obj.D1 /= Obj.D2*2 then
          raise Constraint_Error;
         -- Or better Ada.Exceptions.Raise_with_Message
(Constraint_Error'Identity, "D2 is not half of D1");
      end if;
   end Initialize;

  Obj : R (Max_Size, Max_Size/2);
  Obj2 : R (Max_Size, Max_Size); -- Would raise Constraint_Error.

But that seems like a lot of mechanism for a simple check. (OTOH, my theory
is that virtually all types ought to be derived from Controlled or
Limited_Controlled anyway, so this doesn't add much in that case.)

                      Randy.

Re: discriminant in constraint must appear alone

[tmoran]

> > I want to define a discriminated record type with two arrays. One array
> only half the size
> > of the other. Below is the type definition that I want to use.
> >
> >   type R (D : Positive) is
> >      record
> >         A : String (1 .. D);
> >         B : String (1 .. D / 2);
> >      end record;
> >Are there other possiblities?

>    type R (D1, D2 : Positive) is new Ada.Finalization.Controlled with

  If you use Controlled, then this could be one of those occasions where
access types are really useful.

  type String_Ptr_Type is access String;
  procedure Free is new Ada.Unchecked_Conversion(String, String_Ptr_Type);
  type R (D : Positive) is
     record
        A : String_Ptr_Type;
        B : String_Ptr_Type;
     end record;

Then "R.A" needs to be "R.A.all", but R.A(i) can stay untouched.

   procedure Initialize (Obj : in out R) is
   begin
     A := new String(1 .. Obj.D);
     B := new String(1 .. Obj.D/2);
   end Initialize;
   procedure Finalize (Obj : in out R) is
   begin
     Free(Obj.B);
     Free(Obj.A);
   end Finalize;

Re: discriminant in constraint must appear alone

[Robert I. Eachus]

Vincent Smeets wrote:

> Are there other possiblities?

There are always other possibilities. ;-)

In this case the rule (RM 3.8(12) is clear on how discriminants can 
appear in a record type.  You could try:

    type R (D2 : Positive) is
       record
          A1 : String (1 .. D);
          A2 : String (1 .. D);
          B  : String (1 .. D);
       end record;

Where A = A1 & A2, and D2 = D/2, or you could use aliasing to map a 
string on top of an array (1..D) of Integer_16 elements.  But I think 
the only reasonable approach for now is to have two discriminants.

Incidently I have tripped over this problem in the past, and I think it 
would be wonderful to add three possible uses of discriminants in array 
bounds:  -D, D + n and n * D, where n is an integer literal.  Except for 
the first case, a compiler has to be able to generate these types of 
expressions and evaluate them at run-time.  For example, where does the 
value of B start in the type above?  Probably at 2*D + 4 bytes from the 
start of an object of type R.  (Your milage may vary, I am assuming that 
for this type the bounds of the arrays are implicit, but that D2 is 
stored at the beginning of any objects.)


-- 
                                           Robert I. Eachus

100% Ada, no bugs--the only way to create software.

Re: discriminant in constraint must appear alone

[Dmitry A. Kazakov]

On Tue, 02 Dec 2003 21:15:36 GMT, tmoran@acm.org wrote:

>> > I want to define a discriminated record type with two arrays. One array
>> only half the size
>> > of the other. Below is the type definition that I want to use.
>> >
>> >   type R (D : Positive) is
>> >      record
>> >         A : String (1 .. D);
>> >         B : String (1 .. D / 2);
>> >      end record;
>> >Are there other possiblities?
>
>>    type R (D1, D2 : Positive) is new Ada.Finalization.Controlled with
>
>  If you use Controlled, then this could be one of those occasions where
>access types are really useful.
>
>  type String_Ptr_Type is access String;
>  procedure Free is new Ada.Unchecked_Conversion(String, String_Ptr_Type);
>  type R (D : Positive) is
>     record
>        A : String_Ptr_Type;
>        B : String_Ptr_Type;
>     end record;
>
>Then "R.A" needs to be "R.A.all", but R.A(i) can stay untouched.
>
>   procedure Initialize (Obj : in out R) is
>   begin
>     A := new String(1 .. Obj.D);
>     B := new String(1 .. Obj.D/2);
>   end Initialize;
>   procedure Finalize (Obj : in out R) is
>   begin
>     Free(Obj.B);
>     Free(Obj.A);
>   end Finalize;

Well, if heap allocation comes into play then better:

   type R is new Ada.Finalization.Controlled with private;
   function Create (D : Positive) return R;  -- Constructor
   procedure Adjust (X : in out R);  -- Copying constructor
   procedure Finalize (X : in out R);  -- Destructor
   function A (X : R) return String; -- Getters
   function B (X : R) return String;
   ...
private
   type R_Implementation (D1, D2 : Positive) is record
      A : String (1..D1);
      B : String (1..D2);
   end R_Implementation;
   type R_Implementation_Ptr is access R_Implementation;

   type R is new Ada.Finalization.Controlled with record
      Implementation : R_Implementation_Ptr;
   end record;

Implemented like:

function Create (D : Positive) return R is
begin
   return
   (  Implementation =>
         new R_Implementation (D, D / 2)
   );
end Create;

procedure Adjust (X : in out R) is
begin
  X.Implementation :=
      new R_Implementation'(X.Implementation.all);
end Adjust;

procedure Finalize (X : in out R) is
begin
  Free (X.Implementation);
end Finalize;

---------
But I think it is better to change the standard! (:-))

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

Re: discriminant in constraint must appear alone

[Vincent Smeets]

Thanks for your answers,

After evaluating the possibilities, I wil stick to:
    B : String (1 .. D);
and waist memory and having no constraint check. I am using it in a smal
program which I am writing. I can control my self in not violating the
constraints.

Giving the record two discreminants isn't nice for general use because
there needs to be a lot of comments describing the relation between the
discreminants. The type needs to be controled type to implement the
checking between the discreminants. The checking will be done at
run-time, not at compile-time.

Defining the type as a controlled type and using dynamic allocation for
the arrays is too mush overhead for my problem.

The best solution would be a change in the language. Is there something
foreseen for the new version of Ada?

Thanks,
Vincent Smeets


"Vincent Smeets" <No.Spam@T-Online.de> schrieb im Newsbeitrag
news:bqiq1m$uis$00$1@news.t-online.com...
Hallo,

I want to define a discriminated record type with two arrays. One array
only half the size of the other. Below is the type definition that I
want to use.

   type R (D : Positive) is
      record
         A : String (1 .. D);
         B : String (1 .. D / 2);
      end record;

This type definition can't be compiled by the GNAT compiler. It gives
the error message
    "discriminant in constraint must appear alone"
for the record component B. I know this isn't correct Ada, but how
should I define the type in a correct way?

I have defined B as
    B : String (1 .. D);
and only used the first half of it, but this way I waist memory and
can't have any Ada constraint checks for component B. So this is not the
way I want to do it.

Are there other possiblities?


-- 
Thanks,
Vincent Smeets

Re: discriminant in constraint must appear alone

[Randy Brukardt]

"Vincent Smeets" <No.Spam@T-Online.de> wrote in message
news:bqlj28$erv$07$1@news.t-online.com...
> The best solution would be a change in the language. Is there something
> foreseen for the new version of Ada?

No. This is one the issues that was throughly discussed during the Ada 95
design, and it was decided then that no change was appropriate. (This
restriction comes from Ada 83.) Nothing has changed since then, so there is
no reason to revisit the decision.

                 Randy.

info version of Ada Reference Manual

[Stephen Leake]

In some earlier GNAT distributions (3.15 and earlier? ) there was an
info version of the Ada Reference Manual. However, on the official
website (http://www.adaic.org/standards/ada95.html) for the current
LRM (which has the Technical Corrigendum included), there is no info
version. Info format is good for Emacs; it's close to plain text plus
hyperlinks, and is fully searchable.

The current manual is generated by some Ada code that reads the
vaguely-Scribe like source and generates RTF, HTML, or plain text. I'm
working on adding Texinfo as an output format, which can then generate
info. This will give us a current info version, and any future
versions (Ada 200x).

Does anyone know how the old info version was generated? Maybe I can
just do that again, or get some hints on how they formatted things.

Is anyone else interested in an info version?

-- 
-- Stephe

Re: info version of Ada Reference Manual

[Stephane Richard]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1214 bytes --]

I'm interested :-)....But I don't know how to get it, generate it, read it
from, whichever method is used.

-- 
St�phane Richard
"Ada World" Webmaster
http://www.adaworld.com


"Stephen Leake" <stephen_leake@acm.org> wrote in message
news:mailman.12.1070585826.31149.comp.lang.ada@ada-france.org...
> In some earlier GNAT distributions (3.15 and earlier? ) there was an
> info version of the Ada Reference Manual. However, on the official
> website (http://www.adaic.org/standards/ada95.html) for the current
> LRM (which has the Technical Corrigendum included), there is no info
> version. Info format is good for Emacs; it's close to plain text plus
> hyperlinks, and is fully searchable.
>
> The current manual is generated by some Ada code that reads the
> vaguely-Scribe like source and generates RTF, HTML, or plain text. I'm
> working on adding Texinfo as an output format, which can then generate
> info. This will give us a current info version, and any future
> versions (Ada 200x).
>
> Does anyone know how the old info version was generated? Maybe I can
> just do that again, or get some hints on how they formatted things.
>
> Is anyone else interested in an info version?
>
> -- 
> -- Stephe
>

Re: info version of Ada Reference Manual

[Ludovic Brenta]

Stephen Leake <stephen_leake@acm.org> writes:

> In some earlier GNAT distributions (3.15 and earlier? ) there was an
> info version of the Ada Reference Manual. However, on the official
> website (http://www.adaic.org/standards/ada95.html) for the current
> LRM (which has the Technical Corrigendum included), there is no info
> version. Info format is good for Emacs; it's close to plain text plus
> hyperlinks, and is fully searchable.

Aye.  There Is Only One Editor (but vim is the Other).

> The current manual is generated by some Ada code that reads the
> vaguely-Scribe like source and generates RTF, HTML, or plain text. I'm
> working on adding Texinfo as an output format, which can then generate
> info. This will give us a current info version, and any future
> versions (Ada 200x).
> 
> Does anyone know how the old info version was generated? Maybe I can
> just do that again, or get some hints on how they formatted things.
> 
> Is anyone else interested in an info version?

Yes, I am.  I use the info version of the ARM (without TC1) every day
from within emacs.  BTW, thanks to Florian Weimer for the Debian
package `ada-reference-manual'.

-- 
Ludovic Brenta.

Re: info version of Ada Reference Manual

[Fionn mac Cuimhaill]

On 04 Dec 2003 19:56:43 -0500, Stephen Leake <stephen_leake@acm.org>
wrote:

>In some earlier GNAT distributions (3.15 and earlier? ) there was an
>info version of the Ada Reference Manual. However, on the official
>website (http://www.adaic.org/standards/ada95.html) for the current
>LRM (which has the Technical Corrigendum included), there is no info
>version. Info format is good for Emacs; it's close to plain text plus
>hyperlinks, and is fully searchable.
>
>The current manual is generated by some Ada code that reads the
>vaguely-Scribe like source and generates RTF, HTML, or plain text. I'm
>working on adding Texinfo as an output format, which can then generate
>info. This will give us a current info version, and any future
>versions (Ada 200x).
>
>Does anyone know how the old info version was generated? Maybe I can
>just do that again, or get some hints on how they formatted things.
>
>Is anyone else interested in an info version?

Yes. It would be a good companion to the Ada compiler that is now a
part of GCC.

[Totally OT]

[Nick Roberts]

Fionn mac Cuimhaill wrote ...
^^^^^^^^^^^^^^^^^^^

This is totally off topic, sorry, but I can't help noting that we appear to 
have had a posting from Finn McCool, as in Giant Finn McCool, the biggest 
hero of them all, the granddaddy of all heroes. I mean ... Wow!

:-)

-- 
Nick Roberts

Re: info version of Ada Reference Manual

[Stephen Leake]

Fionn mac Cuimhaill <invisible@hiding.from.spam> writes:

> On 04 Dec 2003 19:56:43 -0500, Stephen Leake <stephen_leake@acm.org>
> wrote:
> 
> >Is anyone else interested in an info version?
> 
> Yes. It would be a good companion to the Ada compiler that is now a
> part of GCC.

Ok. I'll release an info version when it's ready. Or maybe Randy will;
we haven't discussed details yet.

-- 
-- Stephe

Re: info version of Ada Reference Manual

[Arthur Evans Jr]

In article <mailman.12.1070585826.31149.comp.lang.ada@ada-france.org>,
Stephen Leake <stephen_leake@acm.org> wrote:

> The current manual is generated by some Ada code that reads the
> vaguely-Scribe like source
  [snip]

The source for the original Ada-95 manual was not Scribe-like but was
Scribe. Two different header files existed, one to produce the ARM and one
to produce the AARM (Annotated ARM). Scribe supports macros, and these
header files had complex macro definitions to achieve the desired effects.

The last time I checked, maybe six or eight years ago, Cygnet was
supporting Scribe processors on a variety of platforms.

Art Evans

Re: info version of Ada Reference Manual

[Georg Bauhaus]

Stephen Leake <stephen_leake@acm.org> wrote:
: Does anyone know how the old info version was generated? Maybe I can
: just do that again, or get some hints on how they formatted things.

I think Jerry van Dijk mentioned that he had done some manual editing
using Emacs.

-- Georg

Re: info version of Ada Reference Manual

[Stephen Leake]

ev_remove_this_anssl21@earthlink.net (Arthur Evans Jr) writes:

> In article <mailman.12.1070585826.31149.comp.lang.ada@ada-france.org>,
> Stephen Leake <stephen_leake@acm.org> wrote:
> 
> > The current manual is generated by some Ada code that reads the
> > vaguely-Scribe like source
>   [snip]
> 
> The source for the original Ada-95 manual was not Scribe-like but was
> Scribe. Two different header files existed, one to produce the ARM and one
> to produce the AARM (Annotated ARM). Scribe supports macros, and these
> header files had complex macro definitions to achieve the desired effects.
> 
> The last time I checked, maybe six or eight years ago, Cygnet was
> supporting Scribe processors on a variety of platforms.

Ok. Did any of those processors produce info (or Texinfo) format?

I did a quick web search for "cygnet scribe"; found lots of neat
stuff, but not a Scribe processor :). Do you have a URL or more
complete company name?

The current Ada code (see
http://www.ada-auth.org/cgi-bin-acats/cvsweb.cgi/) also outputs both
the ARM and the AARM, and also does various versions (original, with
TC1, with/without changes). So adding the capability to produce
Texinfo to that Ada code is the best approach in the long run, I
believe.

The "changes" are marked with crossouts and underlines (as in MS Word
with Change Tracking turned on). Since info doesn't support that, I'm
not trying to support the "with changes" option in my Ada code. But I
will try outputting the AARM.

-- 
-- Stephe

Re: info version of Ada Reference Manual

[Arthur Evans Jr]

I said

> The source for the original Ada-95 manual was not Scribe-like but was
> Scribe. Two different header files existed, one to produce the ARM and one
> to produce the AARM (Annotated ARM). Scribe supports macros, and these
> header files had complex macro definitions to achieve the desired effects.
> 
> The last time I checked, maybe six or eight years ago, Cygnet was
> supporting Scribe processors on a variety of platforms.

and Stephen Leake <stephen_leake@acm.org> wrote:

> I did a quick web search for "cygnet scribe"; found lots of neat
> stuff, but not a Scribe processor :). Do you have a URL or more
> complete company name?

My latest Scribe manual, copyright 1991, says that the document is
    Distributed exclusively by Cygnet Publishing Technologies, Inc.
and gives an address here in Pittsburgh for Cygnet.

The Pittsburgh telephone book for 2002-03 gives these data:
    355 Fifth Ave   412-471-2070

Good luck!

Art Evans