Free eiffel software for linux

Eiffel INET provides an Eiffel classes for writing IPV4 (TCP/UDP) servers and clients.

Eiffel INET is a set of Eiffel classes (written to be used with SmallEiffel) which allow writing TCP and UDP clients & servers. Programs written with Eiffel INET run in a single thread-less process that multiplexes several connections without blocking.

Supported compilers

The library has been widely used with SmallEiffel -0.77, SmartEiffel 1.0 y 1.1. It compiles (giving spurious warnings) with SmartEiffel 2.0, but it hasnt been tested in production. However, the demos run fine.

EiffelMedia is a multimedia library for Eiffel. The library allows you to use 2D and 3D graphics, sound, networking, and input via joystick and keyboard. EiffelMedia has many smaller frameworks that make life easier for a multimedia or game programmer.

SmartEiffel is the GNU Eiffel Compiler. SmartEiffel is intended to be a complete, though small and very fast, Eiffel compiler.
The current distribution includes an Eiffel to C compiler, documentation tools, a pretty printer, and various other tools including an Eiffel debugger. It also includes a large library of classes distributed under the terms of the MIT/X Consortium License.
Eiffel is an advanced object-oriented programming language that emphasizes the design and construction of high-quality and reusable software.
Enhancements:
- Some changes for compatibility with 2.2 (especially in the library, and case-sensitivity).
- Changes for compatibility with MSVC++ 2005 as a backend.
- Minor bugfixes.

mico/E provides a CORBA implementation in Eiffel.
mico/E is a complete CORBA implementation in Eiffel that can be used in courses and software labs.
The intention of the mico/E project is to provide a freely available and fully compliant implementation of the CORBA 2.4 standard.
Main features:
- a compiler eifidl that translates the full range of the language IDL into stubs, skeletons and abstract interface classes in Eiffel based on the IDL/Eiffel mapping mentioned in the previous section.
- Dynamic Invocation Interface (DII)
- Dynamic Skeleton Interface (DSI)
- an Interface Repository (IR)
- an Implementation Repository (IMR)
- CORBA Services:
- Naming Service
- Event Service
- Trader Service
- Persistent State Service (PSS)
- IIOP as native protocol (ORB prepared for multiprotocol support)
- Support for using mico/E from within X11 applications (eGTK, VEGTK)
- Interceptors
- Portable Object Adapter (POA) and Basic Object Adapter (BOA)
- Object by Value
- DynAny
- locality contraint objects
- basic Corba Components (CCM) features
mico/E was developed using the compiler from ISE Release 4.5. However, the sources should be compilable by any compiler that
- supports the full language as defined in Eiffel: The Language by Bertrand Meyer (ETL) and
- supports the Kernel Library Standard ELKS released by NICE.
At the moment we have verified that mico/E works with:
- ISE 4.5 (or newer)
*Smalleiffel -0.75b7
Visual Eiffel is in progress!

EDA is an Eiffel implementation of the General Decimal Arithmetic Specification. EDA allows unlimited precision decimal arithmetic.

By implementing the GDA Specification version 1.08, the library conforms to the requirements of the ANSI/IEEE standard 854-1987, while supporting integer and unrounded floating-point arithmetic as a subset. EDA is part of the SAFE project.

Alma is a software with the following functionalities :
- Reads several sources (languages, models, ...),
- Helps to design for object-oriented modeling (definition of classes, relations, patterns, ...)
- Modifies the structure and the code
- Outputs new sources, documentation, diagrams, ...
It is designed for object-oriented modelisation (definition of classes and relations) and for migrating (help to convert) code written in old languages to newer ones. It meets two needs : having a simplified software modeling workshop for small projects and make easier rewritings, ports and encapsulation of non-OO code.
This tool will be usefull for developers who get a code and wish to integrate it in a new project, to rewrite a program in a new language, and for the conceptor/architect who will have the possibilities to declare and manipulate classes.
Alma is able t oread these sources:
- C/C++ (simplified, no preprocessor)
- Class (compiled with jikes)
- Fortran 77 (partial implementation)
- IDL (quite complete implementation, no preprocessor)
- Java (quite complete implementation)
- JavaP (result of javap)
- JSP (Java Server Page)
- MDL (files from Irrational Rose)
- Pascal (partial implementation)
- TLD (Taglib for JSP)
- XMI (XML Metadata Interchange, see the site, partial)
- XSD (XML Schema, see the site, partial)
Alma is able to generate source-code for these languages:
- Autotest (Source code for automatic testing)
- BDL
- C (headers and bodies)
- C++ (headers and bodies)
- Delphi (Object Pascal)
- Eiffel
- Gui (Editing JPanels)
- HTML documentation (similar to the javadoc tool)
- IDL (OMG, see the site)
- Java
- Lisp
- Natural (french)
- ODL (ODMG, see the site)
- Python
- Rebol (see the site)
- Resume
- Ruby (see the site)
- Sql (releases 2 and 3)
- SrcHtml
- Tom (see the site)
- Uml (only inheriting and relations diagrams)
- UXF (UML in a XML format, see the site)
- XMI
- XmlProto (Description of a GUI in XML, should be used with Prototype)
- XSD

G2F3 project is a generic framework for strategy games.

G2F3 (Generic Game Framework in eiFFel) aims to simplify the development of two player zero sum strategy games by separating game specific code from reusable generic code. So far, abstract board games are best supported.

This software is written using GNU SmartEiffel. The package comes with six example games.

Whats New in This Release:

Dependencies
- A current snapshot of SmartEiffel-2.2 is now required. 2.2-beta and earlier
will not work anymore with this code.

New Features
- Added Tanbo (GTK UI only), an excellent abstract strategy game invented by
Mark Steere (http://www.marksteere.com, http://www.tanbo.com). Thanks to
Mark for sharing his idea under a very clear copyleft license.
At the moment, the computer plays weak, though not absolutely dumb. I think
I already know how to improve the evaluation function. Will try that soon.
- Tanbo and Breakthrough can now be built for different board sizes. Those
game directories have subdirectories for each board size. To compile, cd to
one of these and use the normal build commands (see doc). Currently, the
board size cannot be changed at runtime.

Improvements
- More improvements in the evaluation function in Breakthrough.
- Node explorer: Now using monospace font for the two state views. Game positions
stored in BIT_2_BOARD_STORAGE and decendants are now shown in ASCII art.
- Undo is now unlimited. Modified NODE_HISTORY and UNDO_REDO_BUFFER now
using linear memory instead of circular. This was done in anticipation of REPOSITORY
which will be used for load/save of games. With unlimited undo/redo, games
can be saved by storing moves only (rather than saving moves plus the oldest
game position).
- New class BIT_LARGE in e-lib. Used in the code for Tanbo.

Code Changes and Cleanup
- New feature {GEOMETRY_RECTANGLE}.rook_neighbors.
- Removed special loadpath files that were supposed to trick eiffeldoc into
running without errors. Eiffeldoc assumes no conflicts in the whole type universe.
This is not the case with the current state of this framework...
- Added insert ANY to BIT_2_BOARD_KEY and BIT_1_BOARD_KEY to get
the body of is_equal (now deferred in HASHABLE).
- Added insert PLATFORM to STORAGE_HASHABLE to get Maximum_integer.
- FILE_FINDER now uses {FILE_TOOLS}.is_readable instead of {ANY}.file_exists
which is now obsolete.
- New feature {BOARD_GAME_DISPLAY}.flash_cell and changed
{BOARD_GAME_DISPLAY}.animate_from_to to make use of this.
- New feature {SERVER}.int_move_input to simplify games where move_dim = 1.
Added precondition to incremental_move_input and incremental_set_move_input.
- {ALPHA_BETA_TT}.main_search and {ALPHA_BETA_TT}.alpha_beta_tt: Now using new
local variable dict_key which avoids calling {STORAGE_HASHABLE}.hash_key twice
(which is *not* an attribute). Gives some tiny speed improvement.
- New feature {BIT_BOARD_STORAGE}.occupier (was needed to remove hard coded
board sizes in Breakthrouigh). TODO: remove overlap with display_code.

Bugfixes
- Fixed an embarassing bug in the evaluation function of Breakthrough (forgotten
not in line 220 of STORAGE_BREAKTHROUGH) that caused the AIs to play
very weak moves.
- Fixed a self-made memory leak in {DICTIONARY_MANAGER}.clean_up: collection was
off when full_collect was called. Since collection is always off when the computer
AI is busy, I can hardly blame SmartEiffel for not automatically calling the GC
within the relatively few lines of code when collection was on. Thus, the
programs consumed more and more memory as soon as a TT based algorithm was used.
- Removed usage of twin in {DICTIONARY_MANAGER}.add_useful_to_shadow. I have
no idea why I had used twin there in the first place. This was not really a
bug but it caused unneccessary memory consumption in addition to the collection
bug mentioned above.

Build System
- ACE files and top level makefile moved to the new directory scripts.
- ACE files and the top level makefile now expect a new variable G2F3 which
must point to the root directory of the G2F3 package. This variable is
used to locate non-Eiffel files. Also, all Eiffel files which are
not part of the SE standard library are now always located using loadpath.se
in the current directory. All example programs still compile out of the box
as the application specific makefiles take care of setting the G2F3 variable.
These changes allow for more flexibility in the game directories (which may
now contain subdirectories).
- ACE files: added "${path_lib}/kernel/internal" to cluster sections
(required by SE-2.2).

GNU Sather is an object-oriented programming language designed to be simple, efficient and safe. This application aims to be appropriate for use in teaching, research, and industry.

It was originally based on Eiffel but now incorporates ideas and approaches from several languages. One way of placing it in the "space of languages" is to say that it attempts to be as efficient as C, C++, or Fortran, as elegant and safe as Eiffel or CLU, and to support higher-order functions as well as Common Lisp or Scheme.

GNU Sather is an object-oriented language with garbage collection, statically-checked strong typing, multiple inheritance, separate implementation and type inheritance, parameterized classes, dynamic dispatch, iteration abstraction, higher-order routines and iterators, exception handling, assertions, preconditions, postconditions, and class invariants. Code can be compiled into C code and can link with C object files.