Free ada software for linux

Niliada is a library of Lisp-like objects in Ada-95.

It features a real time garbage collector. Niliada library is useful for massively multithreaded applications in a mission critical environment.

adanetcdf project is an Ada-95 binding to the netcdf library.
Enhancements:
- added `varead for single call extraction of vectors and matrices from

AdaControl is a free (GMGPL) tool that detects the use of various kinds of constructs in Ada programs. AdaControls first goal is to control proper usage of style or programming rules, but it can also be used as a powerful tool to search for use (or non-use) of various forms of programming styles or design patterns. Searched elements range from very simple, like the occurrence of certaine entities, declarations, or statements, to very sophisticated, like verifying that certain programming patterns are being obeyed..
Which elements or constructs are searched is defined by a set of rules; the following table gives a short summary of rules currently checked by AdaControl. The number in parentheses after the rule name gives the number of subrules, if any. Considering all possible rules and subrules, this makes 216 tests that can be performed currently by AdaControl!
- Abnormal_Function_Return Controls a design pattern that ensures that a function always returns a result .
- Allocators Controls ocurrences of allocators, either all of them, or those targeting specified types.
- Array_Declarations (x2) Controls several metrics in array declarations.
- Barrier_Expressions Controls elements allowed in the expression of protected entries barriers
- Case_Statement (x4) Controls several metrics in case statements.
- Control_Characters Controls occurrences of control characters (like tabs) in the source.
- Declarations (x75) Controls occurrences of certain Ada declarations.
- Default_Parameter Controls subprogram calls and generic instantiations that use (or not) the default value for a given parameter.
- Directly_Accessed_Globals Controls a design pattern that ensures that all global variables are accessed only through dedicated subprograms.
- Entities Controls occurrences of any Ada entity.
- Entity_Inside_Exception Controls occurrences of entities inside exception handlers.
- Exception_Propagation (x4) Controls that certain subprograms (or tasks) cannot propagate exceptions, or that no elaboration can propagate exceptions.
- Expressions (x9) Controls usage of certain forms of expressions
- Global_References Controls unsynchronized accesses to global variables.
- Header_Comments (x2) Controls the presence of comments at the start of each module.
- If_For_Case Controls if statements that could be replaced by case statements.
- Instantiations Controls generic instantiations, either all of them, or those that use specified entities.
- Insufficient_Parameters Controls the use of positional parameters in calls where the value does not provide sufficient information.
- Local_Hiding Controls occurrences of local identifiers that hide an identical outer one.
- Local_Instantiation Controls instantiations in local scopes.
- Max_Blank_Lines Controls the occurrence of more than a specified number of consecutive empty lines.
- Max_Call_Depth Controls the maximum depth of subprogram calls.
- Max_Line_Length Controls maximal length of source lines.
- Max_Nesting Controls scopes nested more deeply than a given limit.
- Max_Parameters (x6) Controls the maximum numbers of parameters in callable entities (procedures, functions and entries)
- Max_Statement_Nesting (x5) Controls composite statements nested more deeply than a given limit.
- Movable_Accept_Statements Controls statements that could be moved outside an accept statement.
- Naming_Convention Controls the form of allowed (or forbidden) names in declarations.
- No_Safe_Initialization Controls a design pattern that ensures that any variable is initialized before being used.
- Non_Static (x3) Controls non static expressions in index or discriminant constraints, or in instantiations.
- Not_Elaboration_Calls Controls subprogram calls performed from places outside package elaboration code.
- Other_Dependencies Controls semantic dependencies to other units than those indicated
- Parameter_Aliasing Controls subprograms and entry calls where a variable is provided to more than one [in] out parameter.
- Potentially_Blocking_Operations Controls the use of potentially blocking operations from within protected operations.
- Pragmas Controls the use of specific pragmas.
- Real_Operators Controls occurrences of = or /= operators on real types.
- Reduceable_Scope Controls declarations that could be move to more deeply nested scopes.
- Representation_Clauses Controls occurrences of representation clauses.
- Return_Type Controls the use of certain kinds of types as return types of functions.
- Side_Effect_Parameters Controls subprogram calls and generic instantiations that call functions with side effect, thus creating a dependance to the order of evaluation.
- Silent_Exceptions Controls exception handlers that do not reraise exceptions nor call indicated subprograms.
- Simplifiable_Expressions (x4) Controls occurrences of various forms of expressions that could be simplified.
- Special_Comments Controls the presence of certain string patterns in comments.
- Statements (x42) Controls occurrences of Ada statements.
- Style (x12) Controls various forms of constructs generally recommended in style rules.
- Terminating_Tasks Controls a design pattern that ensures that tasks never terminate.
- Uncheckable (x3) Controls constructs that are not statically checkable by other rules
- Unnecessary_Use_Clause Controls use clauses on packages, where no element of the package is referred to within the scope of the use clause.
- Unsafe_Paired_Calls Controls a design pattern that ensures that certain calls are allways paired (like P/V procedures).
- Unsafe_Unchecked_Conversion Controls instantiations of Unchecked_Conversion between types of different or unspecified sizes.
- Usage (x5) Controls usage of objects under certain conditions (in package specifications, read, written modified...).
- Use_Clauses Controls occurrences of use clauses, except for indicated packages.
- With_Clauses (x3) Controls proper usage of with clauses.
Enhancements:
- This release adds rules to check that header comments match a given pattern.
- It has indication of possible false positives and false negatives due to non-statically analyzable constructs.
- There is a fine definition of constructs allowed in entry barriers (including the one of the Ravenscar profile).
- There is better integration into GPS, and much more.

AdaSockets is a library that lets you use BSD sockets from Ada (TCP, UDP and multicast).
Installation:
% ./configure --prefix=
% make install
This will build and install this software under /lib/adasockets. The adasockets-config program and its associated man page will be installed respectively under < any directory >/bin and < any directory >/man/
In the examples subdirectory, you will find an example called "tcprelay" which illustrates how this package can be used.
GNU make is not strictly necessary but is recommended. It is needed if you want to rebuild the documentation.
Enhancements:
- Packaging glitch is now fixed, thanks to Dani for reporting it.

Interval arithmetic for Ada is a math library that provides an implementation of intervals for Ada. It includes arithmetic and relational operations.
Examples:
Tri-state logic
The package Intervals serves as a root package and also provides tri-state logic necessary to define relational operations on intervals. The type Logical is defined as:
type Logical is (False, True, Uncertain);
The following operations are defined for Logical:
function "not" (Left : Logical) return Logical;
function "and" (Left, Right : Logical) return Logical;
function "and" (Left : Logical; Right : Boolean)
return Logical;
function "and" (Left : Boolean; Right : Logical)
return Logical;
function "or" (Left, Right : Logical) return Logical;
function "or" (Left : Logical; Right : Boolean)
return Logical;
function "or" (Left : Boolean; Right : Logical)
return Logical;
function "xor" (Left, Right : Logical) return Logical;
function "xor" (Left : Logical; Right : Boolean)
return Logical;
function "xor" (Left : Boolean; Right : Logical)
return Logical;
Enhancements:
- For GNAT users GPS project files were included;
- Based on Measurement units for Ada v 2.4.

LavaPE is a programming environment for the experimental object-oriented programming language Lava. It replaces text editing with structure editing, thereby preventing all syntactic and many semantic errors.
The pure point-and-click nature of Lava programming and the concise representation of programs as declaration trees with small chunks of executable code simplify programming, and ease comprehension.
The new Lava language attempts to combine the advantages of either, and also to propose solutions to a number of fundamental problems that are hard to solve and that have been more or less ignored therefore by other languages so far.
Clearly this cannot be achieved by essentially combining individual features of Java and Visual Basic and by adding further features. A completely new language had to be developed from scratch.
Lava attempts to overcome the "ancient" programming technology that is based on text editors and that requires detailed knowledge and meticulous observation of the syntactic rules of the respective language.
Structure editing has many advantages over text editing and has the potential to considerably increase the programmers productivity.
The conceptual framework of object-orientation can still be improved considerably in several respects:
- Interfaces and implementations should be strictly separated. (Remember Modula-2 and Ada!)
- Two categories of objects, state and value objects, should be distinguished.
- A unified view of object- and component-orientation should be provided.
- "Genericity" and design patterns should be supported properly.
- The necessity of "type-casts" should be overcome.
The general conceptual framework of programming languages calls for additional improvements:
- The data flow of programs can be clarified by "single-assignment" just as the control flow has been clarified by abandoning "go to".
- We need an application-level pointer notion to distinguish "constituents" and "acquaintances" of objects.
- "Embedded SQL" should be finally replaced by seamlessly integrated expressive means for database access,
- Multi-threading, transactions, and synchronization should be treated in a purely declarative way.
- Programming languages should become "organization-aware" and "security-aware".
Enhancements:
- We have completely rewritten the Lava "callback" support, roughly after the model of the "signal/slot" concept of TrollTechs Qt. This is a first step towards an extended Lava GUI builder that will support also mainframe windows, menus, toolbars and callbacks.
- Lava is more portable now. It can be built on the Windows XP, Linux, FreeBSD, Solaris (sparc station and x86, g++), and Mac OS X.2 platforms. It has been tested, so far, on Windows XP, Linux and FreeBSD. Please tell us if it runs also on the other platforms (and also if not).
- You can now benefit from "precompiled headers" if you use the g++ compiler (g++ release 3.4 or higher).
- For the Windows platform we have migrated to the NullSoft Install System (NSIS).
- We have added a method "zombifyRec" (zombify recursively) to class "Object" as a further aid for deactivating whole collections of objects containing circular forward references.

SDL_image is an image file loading library. SDL_image loads images as SDL surfaces, and supports the following formats: BMP, PNM, LBM, PCX, XPM, GIF, JPEG, PNG, TGA.

Unpack and build. Run "showimage imagefile" to display an image using the library.
Note: If you are building on MacOS Classic, you may want the pre-built versions of libpng and libz for PNG support.

Simple DirectMedia Layer is a cross-platform multimedia library designed to provide low level access to audio, keyboard, mouse, joystick, 3D hardware via OpenGL, and 2D video framebuffer. It is used by MPEG playback software, emulators, and many popular games, including the award winning Linux port of "Civilization: Call To Power."

Simple DirectMedia Layer supports Linux, Windows, BeOS, MacOS Classic, MacOS X, FreeBSD, OpenBSD, BSD/OS, Solaris, IRIX, and QNX. There is also code, but no official support, for Windows CE, AmigaOS, Dreamcast, Atari, NetBSD, AIX, OSF/Tru64, RISC OS, and SymbianOS.

SDL is written in C, but works with C++ natively, and has bindings to several other languages, including Ada, Eiffel, Java, Lua, ML, Perl, PHP, Pike, Python, and Ruby.

Simple DirectMedia Layer is a cross-platform multimedia library designed to provide low level access to audio, keyboard, mouse, joystick, 3D hardware via OpenGL, and 2D video framebuffer. SDL is used by MPEG playback software, emulators, and many popular games, including the award winning Linux port of "Civilization: Call To Power."
Simple DirectMedia Layer supports Linux, Windows, BeOS, MacOS Classic, MacOS X, FreeBSD, OpenBSD, BSD/OS, Solaris, IRIX, and QNX. There is also code, but no official support, for Windows CE, AmigaOS, Dreamcast, Atari, NetBSD, AIX, OSF/Tru64, RISC OS, and SymbianOS.
SDL is written in C, but works with C++ natively, and has bindings to several other languages, including Ada, Eiffel, Java, Lua, ML, Perl, PHP, Pike, Python, and Ruby.
Enhancements:
- Dynamic X11 loading is only enabled with gcc 4 supporting -fvisibility=hidden. This fixes crashes related to symbol collisions, and allows building on Solaris and IRIX.
- Fixed building SDL with Xinerama disabled.
- Fixed DRI OpenGL library loading, using RTLD_GLOBAL in dlopen().
- Added pkgconfig configuration support.