Real time environment w/ 300K+ lines?

Real time environment w/ 300K+ lines?

[MFHorn]

[I'm posting this for someone else and I don't read this newsgroup.
So, please mail to me any/all replies.  Don't post.]

Does anyone have a running real time environment using more then
300,000 lines of Ada?  I'd also like to know what the performance
is like versus other languages.

Adthanksvance.

Andy Rosen           | arosen@hawk.ulowell.edu | "I got this guitar and I
ULowell, Box #3031   | ulowell!arosen          |  learned how to make it
Lowell, Ma 01854     |                         |  talk" -Thunder Road
                   RD in '88 - The way it should be

Ada exceptions

[Daniel M Floyd]

This *must* be the right newsgroup.

In discussing the woes of other languages, I posted an
article about excpetion handling. I thought (and still think)
that some way should be available to specify what action
to take when an exception occurs.

For example:

I'd like to say to the compiler

/* exceptions  sqrt(x) */
/*	if -x then do_this_process */
/*	if overflow then scale_routine_error */
/*	if underflow then return 0 */
/* exceptions + */
/*	if overflow ...

I don't care what syntax is used. There are times when a halt
on a fatal error can be ... fatal. I can't tolerate it at times, so
I end up doing alot of firewalling before calling procedures, and
if I do alot of math, it can get ugly fast.

I've had two messages that say "go Ada".

Can Ada really do it? If it can, I'll likely become a devotee, investing
within the month.

Could some Ada-ite post an Ada example like the one above, in Ada.

Thanks.

Re: Ada exceptions

[Robert Eachus]

In article <5701@utah-cs.UUCP> u-dmfloy%sunset.utah.edu.UUCP@utah-cs.UUCP (Daniel M Floyd) writes:
>This *must* be the right newsgroup.

>In discussing the woes of other languages, I posted an
>article about excpetion handling. I thought (and still think)
>that some way should be available to specify what action
>to take when an exception occurs.

>For example:

>I'd like to say to the compiler

>/* exceptions  sqrt(x) */
>/*	if -x then do_this_process */
>/*	if overflow then scale_routine_error */
>/*	if underflow then return 0 */
>/* exceptions + */
>/*	if overflow ...

>I don't care what syntax is used. There are times when a halt
>on a fatal error can be ... fatal. I can't tolerate it at times, so
>I end up doing alot of firewalling before calling procedures, and
>if I do alot of math, it can get ugly fast.

      What  you want can be  done  easily in Ada,   but  it is not the
normal  Ada style.  It is however  very useful as  a means of handling
certain  functions.  For example,  if I  write  a program which  opens
several files, I usually overload the OPEN  call to provide reasonable
handling of the "normal" error conditions.

     The more normal case is to have a handler cover  a region of code
(for  example all  the  statements  of a procedure)   and do something
sensible if an exception occurs in  that  region.  Belt and suspenders
types  (and  that  includes most  Ada   software engineers) also   put
catastropic error handlers on the entire program.

>I've had two messages that say "go Ada".

>Can Ada really do it? If it can, I'll likely become a devotee, investing
>within the month.

     Yes, but you still have to do the hard part... (Ada syntax and
semantics are a big help, but you have to figure out what to do with
the error. :-)

>Could some Ada-ite post an Ada example like the one above, in Ada.

    First you need a square root routine.  Most compilers come with
math packages, but they are not strictly part of the language, and you
can roll your own.  Assume that the package you use says something
like this:


with MATH_EXCEPTIONS;
generic
   type REAL is digits <>; -- some floating point type
package MATHEMATICAL_FUNCTIONS is
   subtype NON_NEGATIVE is REAL range 0.0..REAL'LAST;
   ...
   function SQRT(L: in NON_NEGATIVE) return  NON_NEGATIVE; 
   -- Returns the positive square root of L.  Result is accurate to
   -- within +/- 2.0*REAL'EPSILON times the correct result. Result is
   -- guarenteed to be greater than L for small positive L. SQRT(0.0)
   -- is always exactly 0.0. If 1.0 is a model number of type REAL,
   -- then SQRT(REAL(N*N)) = REAL(N) for any integer N if N*N is a
   -- model number of type REAL.
   ...
end MATHEMATICAL_FUNCTIONS;

-- Now for your program:

with MATHEMATICAL_FUNCTIONS;
with MATH_EXCEPTIONS; use MATH_EXCEPTIONS;
procedure MAIN is
    X, Y, Z: FLOAT;
    package MATH is new MATHMATICAL_FUNCTIONS(FLOAT);
    procedure DO_THIS_PROCESS;
    ...
    function SQRT(X: in FLOAT) is
      begin
        if X < 0.0 then Do_This_Process; else return MATH.SQRT(X); end if;
        -- Your other cases don't arise...
      end SQRT;
    function "+" (L,R: FLOAT) is -- hides STANDARD."+"
      begin
        return STANDARD'"+"(L,R);
      exception
        when others => ...
      end "+";
    ...
    begin
       ...
       Y := sqrt(X); -- Strong typing assures that no other error can
                     -- occur. Even nicer than handling errors is to
                     -- be able to guarentee that they can't happen.
       Z := X + Y;   -- Your "+" which presumably doesn't overflow.
    end MAIN;

    You may think that  the specification of  SQRT is overkill, but it
is "normal" Ada practice to  specify  which exceptions can be  raised,
and under what conditions, by any function in a library package.

					Robert I. Eachus

with STANDARD_DISCLAIMER;
use  STANDARD_DISCLAIMER;
function MESSAGE (TEXT: in CLEVER_IDEAS) return BETTER_IDEAS is...

Re: Ada exceptions

[Carl-Lykke Pedersen]

u-dmfloy%sunset.utah.edu@utah-cs.UUCP (Daniel M Floyd) writes:
>I've had two messages that say "go Ada".

"Go (PL/1), MESA, CLU, ML"

PL/1:
     FACTORIAL: PROCEDURE;
	DECLARE (N, F) FIXED FIN (31) INIT (1);
	ON FINISH BEGIN;
	  PUT LIST (N, "FACTORIAL =", F);
	  PUT SKIP;
	  N = N + 1;
	  F = N * F;
	  STOP;
	  END;
	STOP;
     END FACTORIAL;

Ada:
     function DIVIDE_CHECK(X, Y: REAL) return REAL is
	begin
	  if X = 0 then
		raise SILLY;
	  else X/Y;
	  endif;
	exception
	  when NUMERIC_ERROR => return 0;
	  when SILLY => return -1;
     end;

Sorry if the syntax isn't correct. I do not have an Ada-compiler (or a PL/1-
compiler).

Regards
CLp
.

Re: Ada exceptions

[Robert Eachus]

In article <4055@freja.dk> carllp@freja.dk (Carl-Lykke Pedersen) writes:

>PL/1:
>     FACTORIAL: PROCEDURE;
>	DECLARE (N, F) FIXED FIN (31) INIT (1);
>	ON FINISH BEGIN;
>	  PUT LIST (N, "FACTORIAL =", F);
>	  PUT SKIP;
>	  N = N + 1;
>	  F = N * F;
>	  STOP;
>	  END;
>	STOP;
>     END FACTORIAL;

     I'm not sure what the PL/I example is trying to demonstrate, so I
won't try to rewrite it in PL/I, but it is very simple in Ada:

with TEXT_IO;
procedure FACTORIALS is
  type My_Int is range -2**31..2**31-1;
-- Since the program's behavior depends on 32 bit integers,
-- force a type and subtype with the range expected.
  N, F: My_Int := 1;
begin
  loop
    TEXT_IO.Put_Line(My_Int'IMAGE(N) & "FACTORIAL =" & My_Int'IMAGE(F));
    N := N + 1;
    F := F * N;
  end loop;
exception
  when others => TEXT_IO.Put_line("  That's all folks!");
end FACTORIALS;

>Ada:
>     function DIVIDE_CHECK(X, Y: REAL) return REAL is
>	begin
>	  if X = 0 then
>		raise SILLY;
>	  else X/Y;
>	  endif;
>	exception
>	  when NUMERIC_ERROR => return 0;
>	  when SILLY => return -1;
>     end;

>Sorry if the syntax isn't correct. I do not have an Ada-compiler (or a PL/1-
>compiler).

     There  is a missing  "return"   before  X/Y.   If  REAL is not an
integer type, the constants need to contain  decimal points.  There is
a syntactic problem  is much  more  subtle.  A  compiler is allowed to
generate code which computes  X/Y in a  type with wider range and then
convert the result to REAL. (This is  not  just a theoretical case, it
happens  all the  time with IEEE  floating  point.)   This  results in
CONSTRAINT_ERROR being raised   in some cases,   and NUMERIC_ERROR  in
others. There may also  be a programming mistake.   I assume that  you
want to raise SILLY  when  Y is zero,  but I'm not sure, since raising
SILLY when X is zero is certainly silly. :-)

     There  are also  two   problems of  style.   You surely  want the
function named  "/",  unless it  is generic,   and it is bad   form to
declare an exception like SILLY (you did intend to  declare it, didn't
you?) just to handle it locally. So:

  generic
    type REAL is digits <>;
    DIVIDE_BY_ZERO_RETURN_VALUE: in REAL := -1.0;
    OVERFLOW_RETURN_VALUE: in REAL := 0.0;
  function DIVIDE_WITH_ERROR_HANDLING (X, Y: REAL) return REAL is
  begin
    if Y = 0.0
    then return DIVIDE_BY_ZERO_RETURN_VALUE;
    else return X/Y;
    endif;
  exception
    when CONSTRAINT_ERROR | NUMERIC_ERROR => 
      return OVERFLOW_RETURN_VALUE;
  end DIVIDE_WITH_ERROR_HANDLING;

  -- Now it can be instantiated as follows.  I've changed the overflow
  -- default to show how it's done.

  function "/" is new Divide_with_Error_Handling
                 (Float, Overflow_return_value => Float'LAST);


					Robert I. Eachus

with STANDARD_DISCLAIMER;
use  STANDARD_DISCLAIMER;
function MESSAGE (TEXT: in CLEVER_IDEAS) return BETTER_IDEAS is...