Eiffel/S is the product of SIG Computer. Please ask for the current price list.
Note that Eiffel/S 2.0 is not shareware but a commercial available product.

The shareware version of Eiffel/S is 1.3S. 
==========================================

The commercial release, Eiffel/S 2.0, supports the new Eiffel Standard Kernel, 
Vintage 95. This is probably be the first Eiffel compiler which is compatible 
with the new standard. Eiffel/S 2.0 can be integrated in development 
environments produced by other suppliers. We describe the enhancements in 2.0
at the end of this document.



Eiffel/S is an Eiffel system which has been used in large
projects with great success. It consists of the compiler and the 
Eiffel/S libraries.



The Eiffel/S Compiler
=====================

compiles Eiffel Programs to C. It allows debugging, description of complex
systems, assertions and is available for a large number of platforms.

System description
------------------
The Eiffel/S compiler uses a short program description
to automatically determine which classes will be needed, where they
are to be found and what dependencies hold between these classes.
As you modify the classes in your system the Eiffel/S
compiler continues to keep track of the dependencies and recompiles
only those classes affected by your changes.

Assertions
----------
Eiffel is famous for the possibilities it offers programmers
for ensuring that their code is correct (`Programming by Contract'):
pre- and postconditions, loop invariants, class invariants, etc. Eiffel/S
provides you with optimal control over this powerful mechanism; it
costs only a few seconds to turn some or all of these assertions on
or off. A recompilation of your program is not necessary.

Debugging
---------
Using the same mechanism you can generate a trace file for a program
run. It contains the sequence of routine calls (with argument values)
for all classes in a class list specified by you.

Portability
-----------
Eiffel/S also frees you from all worries about portability.

The Eiffel/S compiler is available for a wide range of platforms including
MS-DOS, Windows, OS/2, Windows/NT and all popular Unix
platforms (Sparc, HP, IBM, Linux and more). Your Eiffel programs can be 
ported to all platforms for which Eiffel/S is available without you having 
to change a single line of your Eiffel sources.

Integration of libraries
------------------------
Eiffel/S compiles your classes to highly optimized C code which is then
automatically compiled by the C compiler of your choice. Additional C code
(e.g. application libraries developed by you or acquired from
third parties) can easily be integrated into Eiffel programs. Eiffel/S
has a very natural and easy-to-use interface between Eiffel and C.
It makes it possible to call C routines from Eiffel classes while
retaining the advantages of Eiffel assertions. And in the reverse
direction you can call Eiffel routines from C in a way that automatically
adapts to polymorphism (the dynamic binding mechanism in Eiffel).

proven history
--------------
For over two years the Eiffel/S (Release 1.2 and 1.3) compiler has been
used by thousands of programmers  worldwide. It is a very mature,
stable software product. A large project (about 35 programmers) was 
started in January 1993 and significant parts were already delivered to 
customers all over the world.

Eiffel/S - The Libraries
------------------------

One of the most important arguments for using OO technology is increased
software reusability. However, if this goal is to be reached, the
foundations have to be carefully laid. For this reason the developers
of Eiffel/S have devoted the greatest care to the design of the basic
class libraries upon which all other classes will build. The goals
followed in designing the Eiffel/S class libraries were the following:

Objectives

* The classes in those libraries should be pure abstract data types hiding
  the implementation details as much as possible.

* These classes should not reflect the underlying operating system.
  Instead they should provide what the programmers who will use them actually
  need and in a form that is simple and intuitive to use.

* They should rigorously apply the priniciples of `Programming by Contract'.

* They should fit cleanly together and make it easy for the application 
  programmer to extend them when necessary.

* Whenever possible they should provide just one good way
  to do each task, thus simplifying the life of the software designer.

* They should employ 'state of the art' algorithms so that programmers 
  will have no hesitation to use them for fear of paying a performance 
  penalty.

The current release of the Eiffel/S library contains classes for handling
the following tasks:


* Basic alphanumeric input/output.
* File handling.
* Container classes providing the data abstractions occuring
  in the daily life of every programmer: stacks, queues, priority queues,
  lists, sorted lists, tables, sorted tables, dictionaries, catalogs.

The following classes are not part of Eiffel/S 1.3S but of Eiffel/S 2.x
-----------------------------------------------------------------------
* Classes for representing graphs and weighted graphs: depth
  first and breadth first search, finding minimal spanning trees and
  shortest paths.
* Classes for searching for strings and patterns (including
  regular expressions) in a text.

These libraries will be extended with further `bread and butter' foundation
classes as soon as the Eiffel/S developers are satisfied that the
new classes fulfill the criteria listed above.

Independent software developers have produced class libraries
for Eiffel/S. These can be delivered to customers in a cryptified
form that only the Eiffel/S compiler can read, thus protecting the
developers investment.

Eiffel/S 2.0
============

precompiled libraries
---------------------
Eiffel/S 2.0 can precompile libraries to be used later by other projects.
These precompiled libraries can even be distributed without giving access
to the Eiffel source text. Precompiled libraries are shared between
projects and thus both the amount of disk space used by Eiffel/S and
the edit-compile cycle time are reduced.

Open system
-----------
The compiler produces a database for each library containing all
information about the library except the source code. For example, 
the inheritance structure, the signatures and assertions of features, 
indexing information and the feature headers header comments are available. 
We also include some "basic" tools like short and flat in source code. 
You can program your own tools by using the class library provided with 
Eiffel/S which allows you to access the information stored in the databases. 
This unique feature makes Eiffel/S 2.0 an open system.

Debugging
---------
Since Eiffel/S is available on many different platforms and for many
different C compilers, it is nearly impossible to support the various 
debuggers coming with these C compilers. Eiffel/S 1.3 has already powerful 
debugging methods. We extended these methods in release 2.0:

* The RTL file, unique for each project, describes which run time checks
  (assertions) should be performed for which classes.
  All these checks can be activated and deactivated without recompilation.

* The feature call trace has been extended. Up to now output was written to a
  file in each case. In release 2.0 this can be redirected to the console. 
  This allows a more "traditional" debugging with single and multiple step, 
  silent procedure execution and detailled parameter inspection.
  So we allow "conventional" debugging on a higher level.

The libraries
-------------
SIG Computer supports the Nice Eiffel Standard Kernel (Vintage 95). This
will make it easy to use software written for other Eiffel systems - and
classes written for the Eiffel/S system can then be used with other
Eiffel systems. Of course we continue to support our 1.3 kernel.

Platforms
---------
Eiffel/S will not support 16 Bit C compilers any more. Since 32 Bit
C compilers are also available as freeware, this should not be a
problem.
Eiffel/S 2.0 will be available for the following platforms:

* MS/DOS, Windows and Windows 95 with following C backends: GCC, Watcom C++,
  Symantec C++, Borland and Microsoft 32 Bit compilers.
* Windows NT: MS/C and Watcom C++
* OS/2: GCC, C/Set, Watcom C++
* Linux
* NeXTStep - Intel & Motorola
* Sparc - SunOS & Solaris
* HP 9000/300 and 700 architecture
* Dec
* IBM PS/6000

SIG Computer GmbH   <info@eiffel.de>    <http://www.wwww.com/sig/>
D 35619 Braunfels        Germany
