HDTenEightyP/NetNews huggingface dataset:
From: walls@saifr00.cfsat.honeywell.com (Gerald Walls)
Subject: Re: Ada and real-time
Organization: Honeywell Air Transport Systems Division
Date: Wed, 14 Oct 92 14:37:33 GMT

determinism is very important.  we've ditched Ada's nondeterministic
task and have instead implemented our own, deterministic tasking.

Ada's tasking is not suitable for embedded real-time systems.
Newsgroups: comp.lang.ada
From: adainfo@ajpo.sei.cmu.edu (Michele L. Kee (AdaIC))
Subject: 9X documents available
Keywords: Ada 9X, Multiple Inheritance, Coding Guidelines, 9X & C++
Organization: Ada Information Clearinghouse
Date: Thu, 8 Oct 1992 18:52:49 GMT

In a recent post to comp.lang.ada, the Ada 9X Report to the Public
referenced several documents that were not available on the host at
that time.  We apologize for any inconvenience this may have caused
Internet and 9X BBS users.

The documents are available on-line on the AJPO host and 9X BBS.
----------------------------------------------------------------------

AJPO host (ajpo.sei.cmu.edu):

ftp ajpo.sei.cmu.edu; name: anonymous, password: guest

/public/ada9x/ada9x.reports
	mult-inh.lsn	- Language Study Note, Multiple Inheritance in Ada 9X
			  by S. Tucker Taft, Ada 9X Mapping/Revision Team

	9x-guide.txt	- How to Program in Ada 9X, Using Ada 83 by
	9x-guide.ps	  Dr. Erhard Ploedereder, Chairman of the Ada 9X
			  Distinguished Reviewers (paper)

/public/ada-info
	9x&cplus.hlp.08Sep92	- Article by Edmond Schonberg comparing
                                  philosophies of Ada 9X and C++
                                  programming languages.


On the 9X BBS (1/800-Ada9X-25 or 301/459-8939), the files available
are:

	mult-inh.lsn

	9xguidet.exe
	9xguidep.exe

	9x&cplus.hlp
-- 
Ada Information Clearinghouse (AdaIC)		|  IIT Research Institute
703/685-1477, 800/AdaIC-11, FAX 703/685-7019	|  operates the AdaIC for
Internet:  adainfo@ajpo.sei.cmu.edu		|  the Ada Joint Program
CompuServe:  70312,3303				|  Office (AJPO).
Newsgroups: comp.lang.ada
From: dnsurber@lescsse.jsc.nasa.gov (Douglas N. Surber)
Subject: Generic Instantiation as Subprogram Body?
Organization: Lockheed Engineering and Sciences
Date:  8 Oct 92 18:00:47 GMT


The following code is what I want to write.  It doesn't work and I don't 
like that!

    generic
	type T is range <>;
    package P is

	type U is private;
	
	function "<" (l,r : U) return boolean;
	function "<=" (l,r : U) return boolean;
	function ">" (l,r : U) return boolean;
	function ">=" (l,r : U) return boolean;

    private
	
	type U is new T;    -- or whatever
    
    end P;

    package body P is

	generic
	    with function op(l,r : T) return boolean;
	function rel (l,r : U) return boolean;

	-- the following doesn't work. declared function name hides the
	-- generic actual.
	function "<" is new rel("<");
	function "<=" is new rel("<=");
	function ">" is new rel(">");
	function ">=" is new rel(">=");

	function rel (l,r : U) return boolean is
	begin
	    return op(l, r);   -- or whatever
	end rel;

    end P;

Neither of the following kludges works since neither a rename nor a generic 
instantiation is a subprogram body and a package body must have a subprogram
body for every subprogram spec in the package spec. The new function declared
in the second line is a different function from the one with the same name
and signature declared in the spec and so fails.

    function lt (l,r : T) return boolean renames "<";
    function "<" is new rel(lt);


    function lt is new rel("<");
    function "<" (l,r : U) return boolean renames lt;

You can't imagine how irritating it is to be told that there is no body for
function "<" and that function "<" has the same name and the same signature
as the previously declared function. "No kiddin'! You think that's an
accident? Stoopid machine!"

One thing that seems to work is to put one of the previous kludges in
the package spec. That sucks!  The fact that the relational operators are
instances of a generic function is strictly an implementation detail.  
What's more, I don't want the generic function rel to be part of the spec.

Of course the following works, but it's an even bigger kludge than the others
and its efficiency depends on the compiler's ability to optimize out a lot of
overhead.

    function lt is new rel("<");
    pragma inline (lt);
    function "<" (l,r : U) return boolean is
    begin
	return lt (l, r);
    end "<";

Three questions:

    1) Is there a better way to accomplish this without changing the
       package spec?

    2) If not, why not?  (What is the rationale, not what does the LRM say.)

    3) Is this fixed in 9X? (hint, hint)

Douglas Surber
Lockheed
Houston, TX

Newsgroups: comp.lang.ada
From: jml@lulea.trab.se (Magnus Lindgren)
Newsgroups: comp.lang.ada
Subject: Re: Good Ada development tools on Sparc?
Date: 12 Oct 92 10:47:38 GMT
Distribution: comp
Organization: Telia Research AB, Aurorum 6, 951 75 Lulea, Sweden
X-Newsreader: Tin 1.1 + PL4

Why not check out the Telesoft RISCAda environment.

It contains most of the things you want (and some more),
the only feature that they don't have (to my knowledge) is the
incremental linker.

I know that the environment is integrated with a special structured
editor as well as GNUEmacs. Both the editors supports some nifty
features as cross-reference, syntactic and semantic checking, semantic
completion, pretty printing and automatic marking of errors.

The environment also consist of a graphical browser of units (Ada or other
kind) and automatic incremental recompilation support (no reason to use Make)
as well as the ordinary library tools.

The environment comes with full graphical interface and the
Telesoft GUI builder TeleUSE is compatible with the RISCAda system.

I found the environment very easy to use and supported most of the
function I needed. I think it's definitely worth the time to have a look
at it, any way.

For more information in Sweden contact somebody at Telesoft Norden,
Nynashamn. (Ask Televerket for the number).

In USA it's something like:

Telesoft Inc.
(619) 457-2700



Magnus Lindgren        		Phone:    +46 920 75425
Telia Research			Telefax:  +46 920 75490
Aurorum 6			E-mail:   jml@lulea.trab.se
S-951 75 Lulea, Sweden
From: bevan@cs.man.ac.uk (Stephen J Bevan)
Newsgroups: comp.lang.ada
Subject: Re: Generic Instantiation as Subprogram Body?
Date: 15 Oct 92 08:50:54 GMT
Organization: Department of Computer Science, University of Manchester
In-reply-to: beidler@guinness.cs.uofs.edu's message of 14 Oct 92 17:03:36 GMT

In article <11225@platypus.uofs.uofs.edu> beidler@guinness.cs.uofs.edu (Jack Beidler) writes:
   Since "<=" is equivalent to "not >" and ">=" is equivalent to "not <"
   the package spec should be

	generic
	   type T is range <>;
	package P is
	   type U is private;
	   function "<" (l,r : U) return boolean;
	   function ">" (l,r : U) return boolean;
	private
	    . . .

   Is it "Stoopid machine!" or  "Stoopid _____!"

If you want to reduce it to its minimum: "a < b" is equivalent to "b >
a" the package spec should be :-

  generic
    type T is range <>;
  package PARTIAL_ORDER
    type U is private;
    function "<" (l,r:U) return boolean;
  private
    ....
  end

As to what/who is stupid, I'll leave that for others to decide :-)

bevan
From: beidler@guinness.cs.uofs.edu (Jack Beidler)
Newsgroups: comp.lang.ada
Subject: Re: Generic Instantiation as Subprogram Body?
Date: 14 Oct 92 17:03:36 GMT
Organization: Department of Computing Sciences

In article <dnsurber.718567247@node_26400>, dnsurber@lescsse.jsc.nasa.gov (Douglas N. Surber) writes:
|> 
|> The following code is what I want to write.  It doesn't work and I don't 
|> like that!
|> 
|>     generic
|> 	type T is range <>;
|>     package P is
|> 
|> 	type U is private;
|> 	
|> 	function "<" (l,r : U) return boolean;
|> 	function "<=" (l,r : U) return boolean;
|> 	function ">" (l,r : U) return boolean;
|> 	function ">=" (l,r : U) return boolean;
|> 
|>     private
|> 	 . . .

Since "<=" is equivalent to "not >" and ">=" is equivalent to "not <"

the package spec should be

     generic
 	type T is range <>;
     package P is
 
 	type U is private;
 	
 	function "<" (l,r : U) return boolean;
 	function ">" (l,r : U) return boolean;
 
     private
 	 . . .

Is it "Stoopid machine!" or  "Stoopid _____!"

In the package body

|> 
|> 	generic
|> 	    with function op(l,r : T) return boolean;
|> 	function rel (l,r : U) return boolean;
|> 
|> 	-- the following doesn't work. declared function name hides the
|> 	-- generic actual.
|> 	function "<" is new rel("<");
|> 	function "<=" is new rel("<=");
|> 	function ">" is new rel(">");
|> 	function ">=" is new rel(">=");
|> 
|> 	function rel (l,r : U) return boolean is
|> 	begin
|> 	    return op(l, r);   -- or whatever
|> 	end rel;
|> 
|>     end P;

since you have not shown what type "U" is, I am only guessing,
but if "U" is a record or array, "<", etc. are not defined, 
hence "<" has no meaning for type "U".  Insteaad of the contrived
generic function rel, supply the bodies of the ordering functions
for the type U,

  function "<" (l, r : U) return boolean is

     begin
        . . .

     end "<":

-- 
+------------------------------------------------------------------+
|  John (Jack) Beidler				                   |
|  Prof. of Computer Science Internet: BEIDLER@JAGUAR.UOFS.ED      |
|  University of Scranton              beidler@guinness.cs.uofs.edu|
|  Scranton, PA 18510	      Bitnet : BEIDLER@SCRANTON            |
|                                                                  |
|          Phone: (717) 941-7446	 FAX:   (717) 941-4250     |
+------------------------------------------------------------------+
Newsgroups: comp.lang.ada
From: val@news.ccutah.edu (Val Kartchner)
Subject: Can I overload ":="?
Organization: University of Utah Computer Center
X-Newsreader: Tin 1.1 PL3
Date: Mon, 12 Oct 92 19:47:19 GMT

(I happen to have run into a situation where this would be useful.  I've
found a way around it, but I'd like to know if I can do it this way?)

I would like to define what happens when I assign a value of one type (say
complex) to a variable of another type (say real).  Can I change what is
meant in Ada by the operation ":=" like I can do with the other operators,
or am I stuck with assignment of a type to a variable of that type?

--
|===== The previous was my opinion -- val@csulx.weber.edu =====///============|
| "AMIGA: The computer for the creative mind." (tm) Commodore /// Weber State |
| "Macintosh: The computer for the rest of us."(tm) Apple \\\///  University  |
|============== "I think, therefore I AMiga." =============\///=== Ogden, UT =|
From: curtis@dataco.UUCP (Ralph Curtis)
Newsgroups: comp.lang.ada
Subject: Booch Components
Date: 9 Oct 92 15:47:58 GMT
Reply-To: curtis@dataco.UUCP (Ralph Curtis)
Distribution: na
Organization: Canadian Marconi Company (Datacomm), Ottawa, Ontario

Does anyone have experience with the Booch Components for ADA. Are they
distributed in source or object form? Are they worth the money?

TIA.


***--------------------------------------------------------------***
* DISCLAIMER:                                                      *
* ==========:                                                      *
*    The opinions expressed are solely of the author and do not    *
*    necessarily reflect the opinions of Canadian Marconi Company. *
***--------------------------------------------------------------***
Newsgroups: comp.lang.ada
From: dawe@nobeltech.se (Daniel Wengelin)
Subject: Re: Does the LRM permit parameter passing by reference?
Organization: NobelTech AB
Date: Sun, 11 Oct 1992 16:20:45 GMT


Having read the debate on allowed parameter passing mechanisms, I would
like to follow up with a related question.

The LRM does (as far as I've understood) allow for an implementation to
skip the "copy-back" of parameters in case an exception is raised preventing
a normal return. What's the impact of this in the real world? Are any 
compilers using this optimization feature?

I am especially interested in the following construct:

    package Smart_Error_Example

       type Status is (Ok, This_Error, That_Error);

       type Data is record          -- Could also be private (normally)
          Current_Status : Status;
          Other_Stuff : ......
       end record;

       procedure Do_Action ( D :  in out Data);

       Any_Error : exception;
    end Smart_Error_Example;

    
    package body Smart_Error_Example is

       procedure Set_Status (The_Status : Status;On_Data : in out Data) is
       begin On_Data.Current_Status := The_Status; end Set_Status;

       procedure Do_Action (D: in out Data) is
       begin
         -- Do something useful
         if That_Error_Detected then
            Set_Status(That_Error, D); -- Set error info for later use
            raise Any_Error;
         end if;
         :
       end Do_Action;
    end Smart_Error_Example;--Unfortunately "erroneous"

This error signaling scheme would be quite suitable for a lot of
applications. It does probably work for most compilers.


Does anyone know a system that fails on the above example?

Can I prevent an optimizer from eliminating the assignment of the 
Current_Status-field by making Set_Status separate??



Thank you for considering these issues.


           Daniel Wengelin
           Systems Designer, 
           NobelTech Systems,
           Naval Sector. 

Disclaimer: This article is on behalf of myself only.


Newsgroups: comp.lang.ada
From: firth@sei.cmu.edu (Robert Firth)
Subject: Re: Can I overload ":="?
Organization: Software Engineering Institute
Date: Tue, 13 Oct 1992 12:07:15 GMT

In article <1992Oct12.194719.27071@fcom.cc.utah.edu> val@news.ccutah.edu (Val Kartchner) writes:

>I would like to define what happens when I assign a value of one type (say
>complex) to a variable of another type (say real).  Can I change what is
>meant in Ada by the operation ":=" like I can do with the other operators,
>or am I stuck with assignment of a type to a variable of that type?

The direct answer is you can't do it: assignment works only between a
value and a variable of the same type, and you can't redefine or
overload the ":=" operation.

The indirect answer is that you can define a type transfer function
as anything you please, eg

	function Convert (x:Chipmunk) return Integer;

and then say

	line_length := Convert(Dale);

And, of course, you can overload Convert on any parameter and result type,
so need choose only one name for all type conversion functions.  Jean
Ichbiah's suggestion (with which I do not agree!) is that you use the
unary "+" operator for type conversion.
Newsgroups: comp.lang.ada
From: val@news.ccutah.edu (Val Kartchner)
Subject: What is "real-time"?
Organization: University of Utah Computer Center
X-Newsreader: Tin 1.1 PL3
Date: Thu, 15 Oct 92 15:35:19 GMT

Since this subthread doesn't seem to be going away, I decided to at least
rename the subthread from "Ada's (In)visibility in the engineering community."

tlai@cs.toronto.edu (Tony Wen Hsun Lai) writes:
: If you want to see the conventional meaning of "real-time" in computer
: science, try looking at some books on operating systems or comparative
: programming languages.

I've given definitions of "real-time" from three different English language
dictionaries.  Everyone seems to say that these are insufficient in a
computer science context.  However, no one has actually posted an alternate
third-party definition of "real-time".  I'll agree to use a formal definition
as given by the FAQ of the comp.realtime group (sight unseen).

: Consider the following example.  Suppose you are writing software for a
: missile system.  Suppose you have a timing constraint where you must use
: a backup sensor if the main sensor does not respond every 25 msec.  You
: cannot express such a constraint in C without using an OS call or an
: external routine.  The C language has no real-time facilities per se.

Given the real-time definitions given so-far, C has as much (if not more)
of a claim to real-time as Ada.  Until we finish defining the catagory, we
cannot say what does and doesn't fit in a given catagory.  However, an
lengthy (and well done) editorial on the subject is given in the article
(that started the thread) "Ada and realtime".

Until we get a mutually agreeable third-party source (not biased toward
Ada nor C/C++), properly cited for reference purposes (and fairness to the
authors), then let's just "Stop the petty bickering!"*

--------
* - Deanna Troi, "Star Trek: The Next Generation", "Haven".
--
|===== The previous was my opinion -- val@csulx.weber.edu =====///============|
| "AMIGA: The computer for the creative mind." (tm) Commodore /// Weber State |
| "Macintosh: The computer for the rest of us."(tm) Apple \\\///  University  |
|============== "I think, therefore I AMiga." =============\///=== Ogden, UT =|
From: jm59@prism.gatech.EDU (MILLS,JOHN M.)
Newsgroups: comp.lang.ada
Subject: Re: CASE tools
Keywords: CASE CADRE TEAMWORK
Date: 12 Oct 92 13:52:42 GMT
Distribution: na
Organization: Georgia Institute of Technology

In article <1371@fudd.dataco.UUCP> curtis@dataco.UUCP (Ralph Curtis) writes:
 >
 >I'm investigating using CADRE's Teamwork tools for ADA development on a SUN
 >network. I would appreciate hearing from anyone with experience of this
 >product. For example:

I hope you will post a summary of the responses you receive.  I would be
interested.

>TIA.

Me too.

-- 
John M. Mills, SRE; Georgia Tech/GTRI/TSDL, Atlanta, GA 30332
uucp: ...!{decvax,hplabs,ncar,purdue,rutgers}!gatech!prism!jm59
Internet: jm59@prism.gatech.edu
 "f U cn rd dis, U mst uz Unix!!!"  ...jaw
Newsgroups: comp.lang.ada
From: mab@wdl39.wdl.loral.com (Mark A Biggar)
Subject: Re: Can I overload ":="?
Organization: Loral Western Development Labs
Date: Wed, 14 Oct 1992 20:27:30 GMT

In article <mmaccorm.35@fox.nstn.ns.ca> mmaccorm@fox.nstn.ns.ca (Mike Mac Cormack) writes:
>Couldn't you use the type name as type conversion operator?  If you had a 
>type "Complex", and wanted to convert it to a real, couldn't you 
>overload "real" as follows:
>	function real(c :Complex) return real;
>and then use the statement
>	r := real(c);
>to convert it to a real?

This doesn't work because overload resolution only works for subprograms.
The above declaration completely hides the type name "real", it doesn't
overload it.  The above declaration may even be illegal because the function
name "real" arleady hides the type name by the time the complier gets to the 
function return type.  Besides the above functions is better called "real_part"
to distinguish it form the complementary function "imaginary_part", unless
you wanted the modulas in which case overloading "abs" makes more sense.

--
Mark Biggar
mab@wdl1.wdl.loral.com


Newsgroups: comp.lang.ada
From: jones@pyrite.cs.uiowa.edu (Douglas W. Jones,201H MLH,3193350740,3193382879)
Subject: Re: Generic Instantiation as Subprogram Body?
Date: Thu, 8 Oct 1992 19:54:52 GMT
Organization: University of Iowa, Iowa City, IA, USA

From article <dnsurber.718567247@node_26400>,
by dnsurber@lescsse.jsc.nasa.gov (Douglas N. Surber):
> 
>     generic
> 	type T is range <>;
>     package P is
> 	type U is private;
> 	function "<" (l,r : U) return boolean;
>     private
> 	type U is new T;    -- or whatever
>     end P;
> 
>     package body P is
> 
> 	-- the following doesn't work. declared function name hides the
> 	-- generic actual.
> 	function "<" is new ...
> 
>     end P;

I've been bothered by this too.  The only solution I've found that works
is to write some long-winded boilerplate in the package body; specifically,
You have to write it like this:

      package body P is

	function "<" (l,r : U) is
	begin
	    return T'(l) < T'(r)
	end "<";

      end P;

That is, you declare a stubby procedure that explicitly coerces its two
parameters of type U to the base type T, then applies the < operation you
want for that base type.

I run into this most often when I use a generic list type in the
a package that exports list operations.  I'd like to just export the
generic instantiations of the list operations on a specific type, but
I can't do it directly; instead, I have to package the exported operations
with annoying little functions like the one shown above.

Of course, this function can be "inlined", so it should cost nothing at
run-time, but these things make for pages of unnecessary source code!

					Doug Jones
					jones@cs.uiowa.edu

Newsgroups: comp.lang.ada
From: robichau@lambda.msfc.nasa.gov (Paul Robichaux)
Subject: # of ACVC tests?
Reply-To: robichau@lambda.msfc.nasa.gov
Organization: New Technology, Inc.
Date: Thu, 15 Oct 1992 19:53:52 GMT

I'm looking for information on the ACVC test suite currently in use.
The last version I know of was 1.11, which I believe had around 1400
tests.

A pointer to a source of comprehensive information on the tests (i.e.
number in each class, total number, and perhaps even a comparison
between the original 1.0 and the current suite) would be appreciated.

Can anyone tell I'm writing a paper ? :)

TIA,
-Paul

BTW, I have received several copies of the FAQ. Thanks to all who took
the time to respond.

-- 
Paul Robichaux, KD4JZG              | May explode if disposed of improperly.
Mission Operations Support Systems  | Printed on recycled phosphors.
New Technology, Inc.		    | ** PGP 2.0 key available on request **
Newsgroups: comp.lang.ada
From: dl10697@ehsn4.cen.uiuc.edu (Duc Trieu Le)
Subject: Re: Booch Components
Organization: University of Illinois at Urbana
Distribution: na
Date: Sat, 10 Oct 1992 02:41:39 GMT

curtis@dataco.UUCP (Ralph Curtis) writes:

>Does anyone have experience with the Booch Components for ADA. Are they
>distributed in source or object form? Are they worth the money?

>TIA.

I believe our version was in source form. I don't know how much it was,
but it certain has helped our project with memory management tools.

Duc T. Le
led@sunfs1.dsd.northrop.com
From: alabau@firmin.greco-prog.fr (Miguel ALABAU)
Newsgroups: comp.lang.ada
Subject: Ada to C translator ?
Date: 7 Oct 92 22:12:30 GMT
Organization: GRECO Programmation du CNRS - Bordeaux,France

Hello netters,

I am looking for an Ada to C translator ?
Does such a program exist?

Thanks
		miguel,

--
Miguel ALABAU                   alabau@geocub.greco-prog.fr

Universite BORDEAUX I - LaBRI
351, cours de la Liberation   33405 TALENCE CEDEX (FRANCE)      
phone (33) 56-84-69-35 / fax (33) 56-84-66-69
Newsgroups: comp.lang.ada
From: mmaccorm@fox.nstn.ns.ca (Mike Mac Cormack)
Subject: Re: Can I overload ":="?
Organization: Micronav International
Date: Wed, 14 Oct 1992 16:22:58 GMT

In article <1992Oct13.120715.7253@sei.cmu.edu> firth@sei.cmu.edu (Robert Firth) writes:
>In article <1992Oct12.194719.27071@fcom.cc.utah.edu> val@news.ccutah.edu (Val Kartchner) writes:

>>I would like to define what happens when I assign a value of one type (say
>>complex) to a variable of another type (say real).  Can I change what is
>>meant in Ada by the operation ":=" like I can do with the other operators,
>>or am I stuck with assignment of a type to a variable of that type?

>The direct answer is you can't do it: assignment works only between a
>value and a variable of the same type, and you can't redefine or
>overload the ":=" operation.

>The indirect answer is that you can define a type transfer function
>as anything you please, eg

>       function Convert (x:Chipmunk) return Integer;

>and then say

>       line_length := Convert(Dale);

>And, of course, you can overload Convert on any parameter and result type,
>so need choose only one name for all type conversion functions.  Jean
>Ichbiah's suggestion (with which I do not agree!) is that you use the
>unary "+" operator for type conversion.



Couldn't you use the type name as type conversion operator?  If you had a 
type "Complex", and wanted to convert it to a real, couldn't you 
overload "real" as follows:

	function real(c :Complex) return real;

and then use the statement

	r := real(c);

to convert it to a real?


	
Micronav International Inc
P.O.Box 1523 / 104 Marine Drive
Sydport Industrial Park,
Sydney, N.S. Canada B1P 6R7
Tel: 902-564-8833      Fax: 902-564-8764
Newsgroups: comp.lang.ada