constraint error question for language lawyers

constraint error question for language lawyers

[Alex Blakemore]

OK, language lawyers of the world.
This one has stumped everyone I've asked locally,  including several 
people who have worked with Ada since there were compilers for it.

Vax Ada 2.1 and two versions of Verdix (5.x and 6.0.3) all behave in the same
(unreasonable) manner - so there must be some obscure rule at work here.
Does anyone
  a. know what that rule might be ?
  b. profess to have a reasonable explanation for its existence.

The Question:
  Why does this procedure raise constraint error?
  It happens on the second assignment to dummy, but
  doesnt happen if dummy.len > 0 and appears to have 
  something to do with the function call "&"

----------------  cut here  -----------------

with text_io;
use text_io;

procedure bozo is
  
  type short is range 0 .. 10;

  type data is array (short range <>) of character;

  type var_text (len : short := 0) is
    record
      text : data (1 .. len);
    end record;

  dummy : var_text; -- unconstrained

  procedure do_nothing (d : data) is 
  begin
    null;
  end do_nothing;

begin

  put_line ("before");
  dummy := (len => 0, text => "");
  put_line ("during");
  dummy := (len  => dummy.len + 1,
            text => dummy.text & 'a');
  put_line ("after");

exception

  when constraint_error =>
    put_line ("constraint_error raised");

end bozo;

---------------- cut here -----------------

Here is the output:

before
during
constraint_error raised

--------------------------------------------------------------------
Alex Blakemore                       CSNET:   blakemore@software.org
Software Productivity Consortium     
2214 Rock Hill Road Herndon, VA 22070 (703) 742-7125

Re: constraint error question for language lawyers

[David Collard]

In article <1802@software.software.org> blakemor@software.org (Alex Blakemore) writes:
> OK, language lawyers of the world.
> This one has stumped everyone I've asked locally,  including several 
> people who have worked with Ada since there were compilers for it.
> 
> Vax Ada 2.1 and two versions of Verdix (5.x and 6.0.3) all behave in the same
> (unreasonable) manner - so there must be some obscure rule at work here.
> Does anyone
>   a. know what that rule might be ?
>   b. profess to have a reasonable explanation for its existence.
> 
> The Question:
>   Why does this procedure raise constraint error?
>   It happens on the second assignment to dummy, but
>   doesnt happen if dummy.len > 0 and appears to have 
>   something to do with the function call "&"
> 
> ----------------  cut here  -----------------
> 
> with text_io;
> use text_io;
> 
> procedure bozo is
>   
>   type short is range 0 .. 10;
> 
>   type data is array (short range <>) of character;
> 
>   type var_text (len : short := 0) is
>     record
>       text : data (1 .. len);
>     end record;
> 
>   dummy : var_text; -- unconstrained
> 
>   procedure do_nothing (d : data) is 
>   begin
>     null;
>   end do_nothing;
> 
> begin
> 
>   put_line ("before");
>   dummy := (len => 0, text => "");
>   put_line ("during");
>   dummy := (len  => dummy.len + 1,
>             text => dummy.text & 'a');
>   put_line ("after");
> 
> exception
> 
>   when constraint_error =>
>     put_line ("constraint_error raised");
> 
> end bozo;
> 
> ---------------- cut here -----------------
> 
> Here is the output:
> 
> before
> during
> constraint_error raised
> 
> --------------------------------------------------------------------
> Alex Blakemore                       CSNET:   blakemore@software.org
> Software Productivity Consortium     
> 2214 Rock Hill Road Herndon, VA 22070 (703) 742-7125

--This is really just another case of another weirdness about ada, which has
--been discussed here before.  It involves the bounds of an array cannot be
--changed during an aggregate assignment, as shown below:

procedure aggassign is
  type short is new integer range 0..100;
  type intarray is array(short range <>) of integer;
  type rec(a:short := 0) is record
    b : intarray(1..a);
  end record;

  x : rec;
  c : intarray(8..8) := (others => 0);  
  d : intarray(1..1) := (others => 0);
begin
  x := (a => 1, b => d);    -- will NOT raise constraint error
  x := (a => 1, b => c);    -- will raise constraint error

end aggassign;


--The reason your program is the same is because of LRM 4.5.3-5 which
--states that during catenation, when one operand is an element rather
--than an array, it is treated as if it were the same as an array with
--its bounds being the lower  bound of the subtype of the index of
--the array.  In your case this is zero. so your assignment is
--equivalent to:
--
--  dummy := (len => dummy.len + 1,
--            text => dummy.text & (0 => 'a'));
--
--which, as shown in the example above, will raise constraint error.
--
--instead, you can do what you want by explicitly stating the bounds
--of the array of one character as:
--
--  dummy := (len => dummy.len + 1,
--            text => dummy.text & (1 => 'a'));
--
--which works just fine:

with Text_IO; use Text_IO;
procedure bozo is

  type short is range 0..10;
  type data is array(short range <>) of character;
  type var_test(len : short := 0) is
    record
      text : data(1..len);
    end record;

  dummy : var_test;

begin
  put_line("before");
  dummy := (len => 0, text => "");
  put_line("during");

  dummy := (len => dummy.len + 1,                    -- this WILL work
            text => dummy.text & (1 => 'a'));

--  dummy := (len => dummy.len + 1,                  -- this WILL NOT work!
--            text => dummy.text & 'a');
--
--  dummy := (len => dummy.len + 1,                  -- this is equivalent to the
--            text => dummy.text & (0 => 'a'));      -- last one and WILL NOT work!
--
--  dummy := (len => dummy.len + 1,                  -- this WILL NOT work either!
--            text => dummy.text & (5 => 'a'));

  put_line("after");
end bozo;



--

-----------------------------------------------------------------------
D. Thor Collard                      Internet: collard@software.org
Software Productivity Consortium     UUNET:    ...!uunet!software!collard
2214 Rock Hill Rd, Herndon VA 22070  

Re: constraint error question for language lawyers

[Charles H. Sampson]

In article <1802@software.software.org> blakemor@software.org (Alex Blakemore) writes:
>OK, language lawyers of the world.
>This one has stumped everyone I've asked locally,  including several 
>people who have worked with Ada since there were compilers for it.
>
>Vax Ada 2.1 and two versions of Verdix (5.x and 6.0.3) all behave in the same
>(unreasonable) manner - so there must be some obscure rule at work here.
>Does anyone
>  a. know what that rule might be ?
>  b. profess to have a reasonable explanation for its existence.
>
>  [Using the following declarations, the second assignment raises a
>   constraint error.]
>  
>  type short is range 0 .. 10;
>  type data is array (short range <>) of character;
>  type var_text (len : short := 0) is
>    record
>      text : data (1 .. len);
>    end record;
>  dummy : var_text; -- unconstrained
>
>  dummy := (len => 0, text => "");
>  dummy := (len  => dummy.len + 1,
>            text => dummy.text & 'a');

     O.K., I'll give it a try, but don't expect a dazzling flood of light
on the subject, because there are still some puzzling things around.  To
begin with, I'll obscure the issue even more.  Alsys Ada 4.3 also fails.
However, both Alsys and VAX Ada 2.0 succeed (no constraint error) when
the component text is declared as string(1 .. len)!

     The root problem is the one pointed out by collard@software.org
(David Collard) in article <1809@software.software.org>: "Sliding" is
not allowed when assigning to an array component of an aggregate; the
indexes of the value and the indexes of the component must be equal.
Therefore the indexes of dummy.text & 'a' must be (1 .. 1).  If you
look at section 4.5.3 of the LRM to see what those indexes are, you see
that this case, a null string concatenated with a single component value,
has been omitted.  As Collard pointed out, using

              text => dummy.text & (1 => 'a')

works.  This is because the second component is now an array whose indexes
are (1 .. 1), not a single component value, and 4.5.3 says that the
indexes of the concatenated value are (1 .. 1), as required.  Notice that
this form will always work, because if the left operand of a concatenation
is not null, the indexes of the right operand don't matter.

     After some moderately tricky programming, I was able to verify that
Alsys and VAX Ada both consider the lower bound of

                       dummy.text & 'a'

to be 0.  When the type of text is changed to string(1 .. len), the lower
bound becomes 1.  Why?  I don't know.  Could be an accident.  Could be a
concious decision by the implementors.

     Another question: Why was this case left out of 4.5.3?  Was it an
oversight or was it a concious decision?  It could have been a concious
decision, because any value chosen in this case would be arbitrary, but
if it is I've never heard anybody discuss it.  Then, of course, there is
the underlying question to this whole flail: Why isn't sliding allowed
when assigning a value to a component of an aggregrate (and the other
cases when sliding is not allowed)?

     Now I sit back and wait for the real Ada lawyers to point out that
this problem is clearly and explicitly covered on some page of the LRM
that I would never think to look at.

                              Charlie Sampson

Re: constraint error question for language lawyers

[Jean Pierre Rosen]

In article <1802@software.software.org>, blakemor@software.org (Alex Blakemore) writes:
> OK, language lawyers of the world.
> This one has stumped everyone I've asked locally,  including several 
> people who have worked with Ada since there were compilers for it.
> ... 
>   type short is range 0 .. 10;
> 
>   type data is array (short range <>) of character;
> 
>   type var_text (len : short := 0) is
>     record
>       text : data (1 .. len);
>     end record;
> 
>   dummy := (len  => dummy.len + 1,
>             text => dummy.text & 'a');
> 
OKAY, the question is "what is the subtype (i.e. bounds) of dummy.text?
4.5.3(4) says that if the left-hand part of a catenation operator is a 
null array (as in this case), the lower bound is taken from the right operand
4.5.3(5) says that if the operant is of a component type, its lower bound is
taken from the index subtype. Therefore, 'a' is considered of subtype
data(0..0). BUT TEXT EXPECTS SUBTYPE data(1..1)! And array sliding does
NOT occur within aggregates (sliding occurs only in array assignments, 5.2.1)
=> CONSTRAINT_ERROR.
Clean way of solving the problem:
type extended_index is range 0..10;
subtype index is extended_index range 1..extended_index'LAST;
type data is array(index range <>) of character;
 
You might complain about strange language rules, but note that this is
actually a design error: you must express that the 0 is not a suitable value
for indexing your array. Once you express your design carefully, the problem
disappears.

"ADA DOES NOT CREATE PROBLEMS; IT JUST MAKES HIDDEN PROBLEMS APPARENT"

constraint error question for language lawyers

["Norman H. Cohen"]

Alex Blakemore asks why, given the declarations

  type Short is range 0 .. 10;
  type Data is array (Short range <>) of Character;
  type Var_Text (Len : Short := 0) is
    record
      Text : Data (1 .. Len);
    end record;
  Dummy : Var_Text; -- unconstrained

the statements

  Dummy := (Len => 0, Text => "");
  Dummy := (Len  => Dummy.Len + 1,
            Text => Dummy.Text & 'a');

raise Constraint_Error in the second assignment.

The surprise results from the fact that the catenation

   Dummy.Text & 'a'

(where Dummy.Text = "") has bounds of 0 .. 0.  Since the Text component
of type Var_Text has a lower bound of 1, the evaluation of the aggregate

   (Len  => Dummy.Len + 1,
    Text => Dummy.Text & 'a');

raises Constraint_Error.

Now to the legal citations.  RM 4.5.3(4), in discussing the result of a
catenation, states:

     The lower bound of this result is the lower bound of the left
     operand, unless the left operand is a null array, in which case
     the result of the catenation is the right operand.

In this case the left operand IS a null array, so the lower bound must
be that of the right operand.  In this case, however, the right operand
is not an array, but a character, so it has no lower bound.  The next
RM paragraph, 4.5.3(5), provides a rule to cover this case:

     If either operand is of the component type of an array type,
     the result of the catenation is given by the above rules, using
     in place of this operand an array having this operand as its only
     component and having the lower bound of the index subtype of the
     array type as its lower bound.

That is, 'a' is taken to be a shorthand for (Short'First => a).  Since
Short'First, or 0, is lower bound of the right operand, and since the
left operand is null, 0 is the lower bound of the catenation.

The actual raising of Constraint_Error is governed by RM 4.3.1(3),
which discusses the evaluation of record aggregates and states:

     A check is made that the value of each subcomponent of the
     aggregate belongs to the subtype of this subcomponent.
     The exception CONSTRAINT_ERROR is raised if this check fails.

The only questionable rule in all of this is the rule that the value of
L&R, where L is a null array, is the value of R.  This seems natural at
first glance, but since Ada can have null arrays with different bounds
(0 .. -1, 1 .. 0, etc.) this conflicts with the usual rule (for L
nonnull) that the lower bound of the result is that of its left operand.
Alex Blakemore has provided an example where this nonuniform rule leads
to a nasty surprise.

I would modify the program as follows:  Add the subtype declaration

   subtype Positive_Short is Short range 1 .. Short'Last;

and use Positive_Short rather than Short as the index subtype of the
array type Data.  Since the Text component of the record type Var_Text
has a lower bound of one, this is more appropriate.  The Ada rules
tend to work more sensibly when the lower bound of an array is the lower
bound of its index subtype.  (In this case, 'a' would be taken as a
shorthand for (Positive_Short'First => 'a'), which has a lower bound of
1, so the catenation ""&'a' would have a lower bound of 1.)

Re: constraint error question for language lawyers

[James THIELE]

In article <9011091437.AA20896@ajpo.sei.cmu.edu> NCOHEN@IBM.COM ("Norman H. Cohen") writes:
| Alex Blakemore asks why, given the declarations
| 
|   type Short is range 0 .. 10;
|   type Data is array (Short range <>) of Character;
|   type Var_Text (Len : Short := 0) is
|     record
|       Text : Data (1 .. Len);
|     end record;
|   Dummy : Var_Text; -- unconstrained
| 
| the statements
| 
|   Dummy := (Len => 0, Text => "");
|   Dummy := (Len  => Dummy.Len + 1,
|             Text => Dummy.Text & 'a');
| 
| raise Constraint_Error in the second assignment.
| 
[62 lines of "legalese" deleted]

When I worked with Ada, it always seemed that the manual was like the
"Colossal Cave" -- you always had to go several places to get what you needed.

But my favorite comment always was:

	"Ada is PASCAL for lawyers."

James Thiele
microsoft!jamesth