Re: Certified C compilers for safety-critical embedded systems

["Robert I. Eachus" <rieachus@comcast.net>]

Ed Falis wrote:

> This is a matter of language-specific idioms, I'd say.   The exit from 
> the statement list of a loop is the most flexible Ada iteration form, 
> but it isn't used all that often - the other forms are more common since 
> they cover most cases.

Depends on your programming style (and the type of programs you write) 
how often it occurs.  I always use it for "n and a half" type loops, and 
for tasks where the main body is a loop that is only exited in special 
circumstances.  Certainly in Ada, such loop are not discouraged, 
although some people get bent out of shape if you have two exits in a 
loop.  I certainly am not going to get upset, or even be mildly 
concerned about:

loop
   Input := Next_Char;
   exit when Input = 'X';
   exit when Input = 'x';
   Process_Input;
end loop;

vs.

loop
   Input := Next_Char;
   exit when Input = 'X' or else Input = 'x';
   Process_Input;
end loop;

In fact I slightly prefer the first form.

> The empty parens are not allowed in Ada.  Bob Eachus or someone else 
> might be able to give some of the rationale.  It's a case similar to the 
> choice of () for array indexing rather than [].  In Ada, a function 
> result is considered conceptually similar to a constant, as are 
> enumeration literals, and many of the same rules apply to them and their 
> use.  I suspect the syntax is intended to reinforce this.

There was a time when the parenthesis were required.  I think it made it 
from Preliminary Ada into Ada 80, but definitely was gone before Ada 82. 
  The argument against the empty parentheses was mostly stylistic, but 
the equivalence of enumeration and other literals to function calls was 
the real killer.  A rule that determine when the empty parentheses were 
required was considered to be a burden on users, but it also would have 
been a burden on implementors and the ARG. ;-)

Incidently there are a few cases in Ada where a function result is 
equivalent to a variable not a constant.  Read about return by reference 
for more details.  And of course you can have cases where a function 
returns an access value, and can appear in a name on the left hand side 
of an assignment statement:

function Predecessor(Node: Item_Access) return Item_Access;
...
Temp, New_Node: Item_Access;
...
New_Node.Next := Temp;
Predecessor(Temp).Next := New_Node;

Of course, this is a much more common use of functions in variable names 
  than return by reference functions.

-- 
                                           Robert I. Eachus

"The war on terror is a different kind of war, waged capture by capture, 
cell by cell, and victory by victory. Our security is assured by our 
perseverance and by our sure belief in the success of liberty." -- 
George W. Bush