Summary - Ada Tools

Summary - Ada Tools

[Beth Walker]

I recently requested help locating Ada tools for a variety of platforms.
Here is a compendium of the responses I got.  Thanks to all who replied.
Special thanks to Alsys rep Neil Obrien, who spent time tracking down the
answers to my questions.


---------------------------------------------------------------------------
Regarding the reason why ActivAda does not support tasking in a Windows
application
---------------------------------------------------------------------------

Date: Tue, 28 Feb 1995 17:12:36 +0500
From: obrien@east.alsys.com (Neil OBrien)
To: bwalker@nosc.mil
Subject: Windows and Tasking (The final installment!)
Cc: hart@alsys.com
X-Sun-Charset: US-ASCII

Beth,

Hopefully the following is the conclusive answer. Windows 3.1 is DPMI
compliant
in that DPMI compliant DOS extended programs will run under Windows 3.1
enhanced mode in a DOS shell Window. The term DPMI mean DOS protected mode
interface. Windows program calls the Windows API and thus will only run
under
Windows. It is meaningless to ask if a Windows program is DMPI compliant
since
it does not make any DOS calls nor is it a DOS extended program. 

A true DOS environment (ie not DOS shell under Windows) is not a protected 
environment. Thus our Ada runtime can take over timer interrupts, among
other
things, to implement a true pre-emptive tasking. The same DOS program under
Windows DPMI environment cannot get timer interrupts the same way hence the
same DOS Ada tasking program will behave differently because preemptive
task
switching is not possible any more.

Win32s is a subsystem developed by Microsoft that you can install in
Windows 
3.1 to run 32 bit Windows programs. Win32s only supports a subset of Win32
API.
consequently if you write a 32-bit Windows program that uses the Win32s
subset 
only, this program can run on Windows 3.1 (using Win32s), Windows NT and
Windows 
95. ActivAda for Windows can generate Win32s programs or 32-bit DOS
extended
Windows programs.

As for Ada tasking on 32-bit Windows, the best implementation would be to
map Ada tasks to Win32 threads. That's what we have done in our ActivAda
for
Windows NT compiler. Unfortunately Win32s does not support any Win32
multithread
APIs, so we decided not to support Ada tasking in ActivAda for Windows when
genarting Win32s Ada programs. Of course we could have implemented our own
tasking for Win32s but we feel this may not be all that useful. Firstly, it
would be none preemptive because of the Windows 3.1 environment and
secondly, it
would produce different behaviour for a Win32 Ada tasking program built
with the ActivAda for Windows compiler and run under WindowsNT, and the
same
programn builtwith the ActivAda for NT compiler and run under NT. 
Note that our other compilers are also moving in this direction where the
host OS 
is truly multi-threaded (for example Solaris2.3 and Lynx OS).

I checked with the engineer (who confimed the veracity of this infomation),
he
said that our Windows95 product has passed all of the tasking ACVC's with a

couple of minor glitches so we will have a fully multi-threaded tasking
compiler
when that product comes out as the WindowsNT compiler is now. Neither of
these is
released as yet (the NT compiler is Beta testing at the moment) but again
the
sales office will have release schedules.

The content was edited by the engineer in question so it is hopefully the
definitive
answer and hopefully it clarifies the issues you raised. Please contact me
if you do
have any further questions

yours sincerely

Neil O'Brien
Customer Support.


---------------------------------------------------------------------------
Sources for Ada tools.
---------------------------------------------------------------------------

Note:  The vendor mentioned (Solana Beach) resells to main compiler
environments:  IntegrAda and ActivAda.  We got copies of each.  The
IntegrAda has tasking, but the GUI builder is not adequate for our needs. 
It has some very strange field entry behavior, does not allow the
specification of both minimum and maximum values for numerical entries, and
doesn't seem to follow the specifications that it does allow you to set. 
We are looking at the ActivAda now.  It doesn't support tasking under
windows, and the GUI builder also doesn't allow you to set min/max values
in the tool.  You have to add your own range-checking code for user
entries.  We are also going to look at AdaSAGE, as it is free off the
internet (Web - http://sageftp.inel.gov/asrp.htm, FTP - sageftp.inel.gov),
has been around a while, looks like it will be more powerful, etc.  They
have both Unix and PC (DOS/UNIX) versions, as well as others.  They don't
have any Windows versions.

---------------------------------------------------------------------------

X-Sender: obrien@manta.nosc.mil
Mime-Version: 1.0
Date: Wed, 1 Mar 1995 13:05:55 -0800
To: bwalker@nosc.mil
From: obrien@nosc.mil (Maureen O'Brien)
Subject: ADA stuff


I called the ADA clearing house 1-800-ada-4211 and they send me 13 24K
messages of stuff.  If you want me to forward it, I will.  Mostly it's a
list of validated compilers.  They also sent me a list of GUI
builders--mostly for other platforms.

Here's one: (PC platform)

AdaSoft, Inc.
Paul Maresca
8750-9 Cherry Lane
Laurel MD 20707
(301) 725-7014
FAX (301) 725-0980
AdaSoft Textual User Interface/Graphics
TUI/G

AdaSoft Textual User Interface/Graphics (TUI/G) deals with graphical
and textual objects and is a system of development tools that
accelerate the development of interactive applications in Ada
requiring drawing and manipulation of graphical objects in windows.
Permits establishing professional-looking application featuring
windows, menus, data-entry forms, drawing, and plotting with a common
and standardized user interface on DOS systems.  Designed for Ada
multi-tasking environment and written in Ada.  Consists of AdaWindows,
AdaMenus, AdaForms, AdaDraw, and AdaPlot.  Facilities of each function
are accessed through its own Application Programming Interface (API).

--------Development Environments--------

He also referred us to the following vendor:

The PC compiler reseller that I mentioned:

        Active Engineering Technology
        249 South Highway 101  Suite 478
        Solama Beach CA  92075

        ada_info@pcada.com
        (619) 793-0245
        FAX (619) 793-5374


                        For Additional Information

Electronic versions of the Validation Procedures are available on the
AdaIC's Internet Host Computer.  The Ada Internet host is available to all
Internet users 24-hours a day to Internet users via the following Internet
access, search, and retrieval utilities:

anonymous file transfer protocol (ftp)
      ftp sw-eng.falls-church.va.us
      login:  anonymous
      password:  <your email address>

ftpmail
      Send Email to: ftpmail@sw-eng.falls-church.va.us with the word
      "help" in the subject line to obtain complete instructions

Gopher
      gopher sw-eng.falls-church.va.us

Wide Area Information Server (WAIS)
      sw-eng.falls-church.va.us

World Wide Web (WWW)
      http://sw-eng.falls-church.va.us/

The AdaIC's Internet host is sw-eng.falls-church.va.us; its IP address is
199.75.54.2.

Direct any questions concerning access to action@sw-eng.falls-church.va.us
or to the AdaIC telephone hotline staff at 1/800-AdaIC-11 (232-4211).


---------------------------------------------------------------------------


Date: Fri, 24 Feb 1995 09:52:39 +0500
From: obrien@east.alsys.com (Neil OBrien)
To: bwalker@nosc.mil (Beth Walker)
Subject: Re: Help finding Ada tools



Beth,

Thomson Software Products (formerly Alsys) provides Ada compilers and a 
GUI builder (TeleUSE) for Unix and we will shortly be providing this for
WindowsNT as well. In regards to ActivAda, windows 3.1 is not DPMI
compliant
and neither will it support tasking which is why ActivAda does not support
tasking. There are a number of Windows features which inhibit ActivAda in
a similar vein.

Which Unix are you considering, ie 386 UNIX such as SCO or on larger 
machines such as Sparc's and HP 9000's. In both cases we do provide the
compilers but we do not have a GUI builder on 386 UNIX as yet.

We no longer offer an OS/2 compiler.

To get more information you can contact any of our sales offices
Boston (617) 270 0030
San Diego (619) 457 2700

I hope this helps in some way

yours sincerely

Neil O'Brien
Customer Support
Thomson Software Products

---------------------------------------------------------------------------
Submissions from folks with arguments for picking Ada over C.
---------------------------------------------------------------------------


: Tasking is one thing that Ada has that C doesn't, and the problem being
: solved is very task-oriented.  The strong typing is another advantage of
: Ada.  However, the C staff feels that they can check out their code using
: lint or some other type of pre-processor, etc. so they don't feel that
the
: strong typing buys them enough to go to the effort of learning Ada.  The
: tasking argument did.  

: There are lots of other issues which complicate the entire selection
: process, which I won't go into.

Regarding Lint, here is some info from the Ada programming FAQ:

Darren Davenport
ddavenpo@redwood.hac.com

9.7: I'm told Ada does all sorts of static type checking, but can't you get
the same effect using a tool like "lint" with C?
 
   No, here are a few reasons why (this list is by no means complete):
 
   (Submitted by Norm Cohen)
     * Running both Lint and a C compiler requires the program text to be
       parsed and semantically analyzed twice. The results of an Ada
       compiler's parse and semantic analysis are used directly in
       performing consistency checks.
 
     * The rules of Ada provide the opportunity for stronger consistency
       checks than are possible with C. For example, an Ada programmer
       can declare distinct integer types to represent distinct
       abstractions. An Ada compiler will catch an inadvertent
       intermixing of these two types, but there is no way a
       corresponding distinction can be made in C, so there is no way for
       Lint to perform a corresponding check. Similarly, in C, a pointer
       to an object of type T is indistinguishable from an array of
       objects of type T.
 
     * The rules of the Ada language ensure that the program text
       provides information allowing PRECISE consistency checks. For
       example, the expression in an Ada case statement can be written to
       have a static subtype, allowing the compiler to ascertain that all
       possible values have been covered without resorting to a default
       (when others) arm.
 
     * With lack of precise information, Lint has no choice but to be
       overly pessimistic or, with different settings for a complicated
       set of options, overly optimistic. When it is overly pessimistic,
       the user sees too many "false alarms" and may end up ignoring
       valid warnings. When it is overly optimistic, Lint overlooks
       certain errors.
 
     * It is impossible to forget to run consistency checks when using an
       Ada compiler. (Of course a C programming environment could be set
       up so that the C compiler could only be invoked from a script that
       also invokes Lint.)
 
     * A compilation that fails Ada consistency checks is rejected. A
       compilation that fails Lint consistency checks may still be
       compiled, and its object file used (intentionally or accidently)
       in building the system. (One cannot automate the rejection of
       programs that fail Lint unless one is certain that there will
       never be any false warnings.)
 
     * Ada enforces consistency among separately compiled units.
 
 
   Of course even stronger arguments can be made about Ada's RUN-TIME
   checks (which can be used with little additional overhead because the
   information contained in an Ada program and the knowledge that the
   program has passed compile-time consistency checks make it possible to
   optimize away the majority of the checks). These checks, which are
   absent in C, tend to smoke out errors early by detecting internal
   inconsistencies that might not otherwise be detected during testing.
   This reduces the likelihood of fielding a system that appears to work
   well during testing but fails in operational use.


---------------------------------------------------------------------------
Operating System considerations
---------------------------------------------------------------------------


From: geert@dialis.xs4all.nl (Geert Bosch)
Date: 25 Feb 95 01:15:02 +0100
Subject: Help finding Ada tools
Organization: Dialis Gateway, Enschede, The Netherlands.
To: bwalker@nosc.mil


* Reply to a message in comp.lang.ada.

bwalker@nosc.mil wrote in a message to All:

 bn> The Ada implementation must support tasking
 bn> (ActivAda does not have tasking with Win32s).

In that case, your choice would be OS/2 with GNAT, since MS Windows 3.1
isn't
suited for tasking. There are some Unix variants that support multiple
threads of control in a process, and for a few there is support in GNAT
(the
things Ada calls tasks, are most often called threads in OS talk). The only
other platform that supports multithreading with GNAT is Windows NT. 

I think the combination of OS/2 with its threading and Ada 95 is great,
since
the language supports the OS features. Programming multithreading apps
using
C/C++ is much harder, since the language doesn't help you specifying
concurrency. Furthermore, the quality of the GNAT compiler is really good
and
it's free and comes with (Ada) source code and it is suited for many
platforms. 

Groetjes, Geert 
--- timEd/2 1.01+

---------------------------------------------------------------------------
-- Thats it.
---------------------------------------------------------------------------