Alire community index.

The a0b_base crate provides the root package hierarchy and foundational components tailored for embedded, bare-metal, and low-level Ada applications.

Key features include:

• Foundational Types:
  • Integer_* and Unsigned_* types of various sizes (1 to 64 bits) with shift and rotate operations.
  • Unsigned_*_Array types and "Enumerable" modular types (2 to 8 bits).
• Low-Level Utilities:
  • Big-endian formatted types (A0B.Types.Big_Endian) for low-level protocol specifications.
  • Type declarations specifically designed for use with the SVD2Ada code generator.
• Compiler Bindings:
  • Direct bindings to GCC built-ins (such as bswap, clz, ffs) in A0B.Types.GCC_Builtins.

The a0b-sensirion crate provides essential low-level utilities for interfacing with Sensirion sensors, specifically focusing on the data integrity requirements of their communication protocols. It offers specialized routines for CRC calculation and provides automated packet encoding and decoding logic that handles the insertion and deletion of CRC bytes. By abstracting these boilerplate tasks, the crate ensures reliable data transmission and simplifies the implementation of drivers for any Sensirion hardware utilizing checksum-protected packets.

The primary tool in this crate is the a0b-runtime generator. While GNAT provides several standard runtimes (such as light, light-tasking, and embedded), these can be difficult to customize for specific project requirements.

a0b-tools solves this by allowing developers to generate a tailored, project-specific runtime from a single configuration file. It also enables the creation of runtimes for hardware platforms and MCUs that do not have prebuilt GNAT runtimes available, providing full control over startup code, linker scripts, and Ada library components.

Alex's Ada Assortment of Utilities

• Text formatting (paragraphs, tables).
• Indefinite containers.
• Enumeration validity/conversions of string images.
• On-demand stack backtraces.
• String containers and utilities.
• Simple subprocess spawning.
• Write-through minimal cache for objects stored in files

Ada_GUI

An Ada-oriented GUI

Traditionally, GUIs have been implemented by the client registering callback operations, then giving up its thread of control to the GUI. This is a hack to address the inherent parallelism of a GUI in sequential languages. It results in code that is unnecessarily difficult to understand.

In a concurrent language like Ada, a better design for a GUI is for the GUI to have its own task, so it doesn't require that its client give up a thread of control. GUI events are communicated to the client through a protected queue of events. The client software can be written in the clearest way possible, unconstrained by the GUI.

Ada_GUI is such a GUI.

The purpose of Ada_GUI is to provide the specification, in hopes that multiple implementations will be created. Note that some of the comments in the specification are specific to the sample implementation, and should be removed or modified for other implementations. Especially interesting would be an implementation that is not GNAT specific.

Sample Implementation

A sample implementation of Ada_GUI is supplied, derived from Gnoga, but simplified, reorganized, and converted to put events on a protected queue rather than call callbacks. The name Gnoga has been retained for the name of the implementation hierarchy, located at Ada_GUI.Gnoga, in recognition. Those parts of Kazakov's Simple Components used by the implementation are provided as well, with some minor modifications. If you have your own version of the Simple Components, you may use it instead: Delete all Ada source files that do not begin with ada_gui.

The sample implementation is reasonably full-featured and useful. The implementation is more responsive than the former proof-of-concept directly on full Gnoga.

The Test directory contains boot.html, boot.js, and jquery.min.js. These files must be available to every Ada-GUI program. It also contains favicon.ico, an icon of Ada.

Show_All creates at least one of each widget. Visibility, playing audio, and responding to key-press events is demonstrated. Changing this program is the easiest way to experiment with the sample implementation. The audio file glass.ogg and image file rgb.jpg are used by Show_All.

Luhn_Gen calculates Luhn checksum digits. Enter the first 15 digits of your credit-card number and it will generate the 16th.

Random_Int is a Gnoga program that has been revised to use Ada GUI instead. It will generate random integers in a desired range.

Installation of the Sample Implementation

Gnoga and the Simple Components require a recent GNAT compiler, so Ada_GUI cannot be compiled with another compiler. The file gnat.adc is needed to compile the Simple Components extensions to GNAT.Sockets. The use of gnatmake is recommended, as gprbuild is for mixed-language or complicated builds, which this is not. After compiling, it is recommended that you write-protect the .ali files. Typically, you can use a command such as

gnatmake -m -j0 -gnat12 -gnatan -gnato2 -O2 -fstack-check Test/show_all.adb

If you keep the Ada-GUI source files in a single directory, including the Simple Components source files, and have the compiler put the object and .ali files in that directory, then you need only add -I/path/to/Ada_GUI/ to your program's gnatmake command to use Ada_GUI.

ada-toml: TOML parser for Ada

ada-toml is a pure Ada library for parsing and creating TOML documents. It conforms to the version 1.0.0 of the format standard.

Quick tutorial

All basic types and subprograms are in the TOML package. All "nodes" in a TOML documents are materialized using the TOML.TOML_Value type. Since TOML values make up a tree, this type has reference semantics. This means that modifying a TOML node does not modify the corresponding TOML_Value value itself, but rather the TOML value that is referenced.

Parsing a TOML file is as easy as using the TOML.File_IO.Load_File function:

declare
   Result : constant TOML.Read_Result :=
      TOML.File_IO.Load_File ("config.toml");
begin
   if Result.Success then
      Ada.Text_IO.Put_Line ("config.toml loaded with success!");
   else
      Ada.Text_IO.Put_Line ("error while loading config.toml:");
      Ada.Text_IO.Put_Line
         (Ada.Strings.Unbounded.To_String (Result.Message));
   end if;
end;

Each TOML value has kind, defining which data it contains (a boolean, an integer, a string, a table, ...). To each kind, one or several primitives are associated to let one process the underlying data:

case Result.Kind is
   when TOML.TOML_Boolean =>
      Ada.Text_IO.Put_Line ("Boolean: " & Result.As_Boolean'Image);

   when TOML.TOML_Integer =>
      Ada.Text_IO.Put_Line ("Boolean: " & Result.As_Integer'Image);

   when TOML.TOML_String =>
      Ada.Text_IO.Put_Line ("Boolean: " & Result.As_String);

   when TOML.TOML_Array =>
      Ada.Text_IO.Put_Line ("Array of " & Result.Length & " elements");

   when others =>
      null;
end case;

There are also primitives to build TOML values:

declare
   Bool : constant TOML.TOML_Value := TOML.Create_Boolean (False);
   Int  : constant TOML.TOML_Value := TOML.Create_Integer (10);
   Str  : constant TOML.TOML_Value := TOML.Create_String ("Hello, world");

   Table : constant TOML.TOML_Value := TOML.Create_Table;
begin
   Table.Set ("bool_field", Bool);
   Table.Set ("int_field", Int);
   Table.Set ("str_field", Str);
end;

And finally one can turn a tree of TOML nodes back in text form:

Ada.Text_IO.Put_Line ("TOML document:");
Ada.Text_IO.Put_Line (Table.Dump_As_String);

Contributing

The development of ada-toml happens on GitHub. Everyone is welcome to contribute to this project: please read our contribution rules if you consider doing so.

A versatile Ada 2022 class library for robust application development.

Features:

• Getopt: Command-line argument parser with wide character support
• Strings: Utilities for String, Wide_String, and Wide_Wide_String
• Calendar: Time and date utilities with wide character support
• Tracing: Diagnostic trace utility with wide character support
• Protected Queue: Supports finish, wait, and abort operations
• Smart Pointers:
  • Reference-counted pointers
  • Unique pointers (C++-style)
  • Shared pointers (C++-style)

Related crates:

• AUnit: AUnit-Compatible Assertions for access, array, discrete, floating-point, fixed-point, decimal, and vector types
• EAStrings: Encoding-aware string utilities
• RegEx: SPITBOL-inspired pattern matching and regular expressions for String, Wide_String, and Wide_Wide_String
• SAR: Text search and replace for String, Wide_String, and Wide_Wide_String

Source: SourceForge Documentation: GNATdoc

A versatile Ada 2022 testing library, enhancing AUnit with readable assertions and parameterised tests.

Features

AUnit-Compatible Assertions

• Generic support for access, array, discrete, floating-point, fixed-point, decimal, vector types, and files.
• Readable Error Messages: Assertions provide detailed feedback.

Example for unbounded strings:

    procedure Equal
       (Actual   : Ada.Strings.Unbounded.Unbounded_String;
        Expected : String;
        Name     : String;
        Source   : String  := GNAT.Source_Info.File;
        Line     : Natural := GNAT.Source_Info.Line)
    is
       use Ada.Strings.Unbounded;
    begin
       if not (Actual = Expected) then
          Report_Assertion
             (Message => "In string «" & Name & "» the " & Actual'Image & " is not equal to " & Expected'Image,
              Source  => Source,
              Line    => Line);
       end if;
    end Equal;

This yields clear, context-rich error messages, surpassing standard AUnit output.

Parameterised Tests

Run the same test with varied inputs and expected values, boosting coverage efficiently.

Example from hp41cx_tools:

overriding procedure Register_Tests (T : in out Test_Case) is
   pragma Debug (AdaCL.Trace.Entering (In_Parameter => T.Name.all'Image));
begin
   T.Parameter.Register_Routine (T, Test_To_HP_Duration_01'Access, "WAKE_UP",      "2024-12-01 08:00:00",   [3, 9, 4, 2, 0, 2, 8, 8, 0, 0, 0], 3942028800.0);
   T.Parameter.Register_Routine (T, Test_To_HP_Duration_01'Access, "^LBLTEST",     "2025-07-22 12:00:00",   [3, 9, 6, 2, 1, 7, 4, 4, 0, 0, 0], 3962174400.0);
   T.Parameter.Register_Routine (T, Test_To_HP_Duration_01'Access, "TONE",         "2025-11-12 09:12:34",   [3, 9, 7, 1, 9, 2, 7, 5, 5, 4, 0], 3971927554.0);
   T.Parameter.Register_Routine (T, Test_To_HP_Duration_01'Access, "FRACTION",     "2025-11-12 09:12:34.5", [3, 9, 7, 1, 9, 2, 7, 5, 5, 4, 5], 3971927554.5);
   T.Parameter.Register_Routine (T, Test_To_HP_Duration_01'Access, "REPEAT24",     "24:00:00",              [0, 0, 0, 0, 0, 8, 6, 4, 0, 0, 0], 0000086400.0);
   T.Parameter.Register_Routine (T, Test_To_HP_Duration_01'Access, "REPEAT'First", "0000:00:01.0",          [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], 0000000010.0);
   T.Parameter.Register_Routine (T, Test_To_HP_Duration_01'Access, "REPEAT'Last",  "9999:59:59.9",          [0, 0, 3, 5, 9, 9, 9, 9, 9, 9, 9], 0035999999.9);
   pragma Debug (AdaCL.Trace.Exiting);
   return;
end Register_Tests;

Registering tests multiple times with different data enhances test coverage without redundant code.

Source: SourceForge Documentation: GNATdoc

Encoding-aware string utilities for Ada 2022, developed by Björn Persson for robust internationalization (i18n).

Supports text processing with the following encodings:

• Universal Character Set 4, Big-Endian (UCS-4 BE)
• Universal Character Set 4, Little-Endian (UCS-4 LE)
• Universal Character Set 2, Big-Endian (UCS-2 BE)
• Universal Character Set 2, Little-Endian (UCS-2 LE)
• Unicode Transformation Format 16, Big-Endian (UTF-16 BE)
• Unicode Transformation Format 16, Little-Endian (UTF-16 LE)
• Unicode Transformation Format 8 (UTF-8)
• American Standard Code for Information Interchange (ASCII)
• ISO/IEC 8859-1 (Latin-1)
• Code Page 850 (DOS Latin-1)
• Windows Code Page 1252

Additional features:

• Text I/O for encoding-aware input/output
• Basic command-line parsing for internationalized text

Licensed under GPL-3.0-or-later. Integrates with the Ada Class Library (AdaCL).

Source: SourceForge Documentation: GNATdoc

AdaCL Embedded - Lightweight Embedded Ada Library

AdaCL-Embedded focuses on embedded and real-time programming on the Raspberry Pi and similar platforms.

It favours predictability, minimal runtime overhead, and static data structures. Object-oriented programming, unbounded strings, and wide strings are avoided or kept to an absolute minimum.

Current Features

• AdaCL.Embedded.Trace - Interrupt-safe, lightweight tracing facility using a ring buffer.
• AdaCL.Embedded.Text_IO - Extended Ada.Text_IO.

Configuration Options

• Variant
  • no_tasking - for the lightest runtimes (no protected objects). Also works well with interrupt-driven runtimes.
  • tasking - for runtimes with tasking support.
• Event_Log_Buffer_Length - maximum length of each trace line (default: 200, min: 1, max: 1024)
• Event_Log_Buffer_Size - number of entries in the ring buffer (default: 0, max: 1024, min: 0 (buffer disabled))

A text length of 200 is the standart minimum used in the Ada Standart (i.E. Ada.Text_IO.Get_Line, exception messages, etc.pp).

Memory needed is approximately (Event_Log_Buffer_Length + 4) * Event_Log_Buffer_Size bytes, plus some overhead for the buffer management. For example: 1024 buffer size with 200 line lenght is about the maximum size that can be used with the static memory of Raspberry Pi Pico. The buffer size can be set to 0 to disable the trace buffer and the related code completely.

Source: SourceForge Documentation: GNATdoc

Regular expression and SPITBOL pattern matching for Ada 2022, with wide character support.

Features:

• Regular Expressions:
  • Generic implementation for any discrete element array
  • Instantiations for String, Wide_String, and Wide_Wide_String
• SPITBOL Patterns:
  • Pattern construction and matching, inspired by Macro-SPITBOL (Robert Dewar)
  • Supports String, Wide_String, and Wide_Wide_String
• Forked from GNAT.Regexp and GNAT.Spitbol with enhanced wide and wide-wide character support

Licensed under GPL-3.0-or-later. Integrates with the Ada Class Library (AdaCL).

Source: SourceForge Documentation: GNATdoc

Powerful search-and-replace library for Ada 2022, developed by Martin Krischik, with wide and wide-wide character support.

Features:

• Load, transform, and store text
• Vector-based text transformations for efficient processing
• Supports standard, wide, and wide-wide characters for internationalisation
• Embedded transformations for internal text processing
• Extensible transformations via tagged types for complex operations
• Integrates with the Ada Class Library (AdaCL) for robust text handling

Licensed under GPL-3.0-or-later. Integrates with the Ada Class Library (AdaCL).

Source: SourceForge Documentation: GNATdoc

Dilithium is a digital signature scheme that is strongly secure under chosen message attacks based on the hardness of lattice problems over module lattices. The security notion means that an adversary having access to a signing oracle cannot produce a signature of a message whose signature he hasn't yet seen, nor produce a different signature of a message that he already saw signed. Dilithium is one of the candidate algorithms submitted to the NIST post-quantum cryptography project.

  Adare_Dilithium5 is a Ada 2012 bind to Dilithium5 C.

  (C version at https://github.com/PQClean/PQClean)

  How a Bonus all Ada packages in this lib is "Ada Pure"! :-)

HQC (Hamming Quasi-Cyclic) is a code-based public key encryption scheme designed to provide security against attacks by both classical and quantum computers. HQC has been submitted to the NIST's Post-Quantum Cryptography Standardization Project.

  Adare_HQC256 is a Ada 2012 bind to HQC-256 C.

  Adare_HQC256 has a 512 bits Shared Secret size.

  (C version at https://github.com/PQClean/PQClean)

  How a Bonus all Ada packages in this lib is "Ada Pure"! :-)

Main features:

• [X] Conflict analysis and backjumping
• [X] Two-watched literals scheme
• [X] Built-in support for At-Most-One constraints
• [X] Custom theories

adl_middleware

Middleware layer of the Ada Drivers Library project.

This crate is a snapshot of the middleware of Ada Drivers Library.

Any bug report, issue, contribution must be adressed to the Ada Drivers Library repo.

Ada Database Objects is an Ada05 library that provides object relational mapping to access a database in Ada05. The library supports Postgresql, MySQL, SQLite as databases. Most of the concepts developped for ADO come from the Java Hibernate ORM.

The ORM uses an YAML, XML mapping file or an UML model, a code generator and a runtime library for the implementation. It provides a database driver for Postgresql, MySQL, SQLite or SQLCipher. The ORM helps your application by providing a mapping of your database tables directly in the target programming language: Ada05 in our case. The development process is the following:

• You design your database model either using a UML tool or by writing a YAML or XML description,
• You generate the Ada05 mapping files by using the Dynamo code generator,
• You generate the SQL database tables by using the same tool,
• You write your application on top of the generated code that gives you direct and simplified access to your database.

You need at least one of these databases (or all of then). The configure script will now fail if no supported database was found. Check the Database Drivers section to install them and run the configure again after the installation.

Documentation

• Ada Database Objects Programmer's Guide
• Persistence with Ada Database Objects FOSDEM 2019

This crate give access to the PostgreSQL, MySQL and SQLite drivers for the Ada Database Objects library.

This is the MySQL driver for the Ada Database Objects library.

This is the PostgreSQL driver for the Ada Database Objects library.

This is the SQLite or SQLCipher driver for the Ada Database Objects library.

The choice between SQLite and SQLCipher is controlled by the ADO_USE_SQLCIPHER gpr external variable. Use -XADO_USE_SQLCIPHER=yes if you want to use the SQLCipher support. The database encryption key is configured by using a pragma key.

aDSA is a Partition Communication Subsystem (PCS) for Ada's Distributed Systems Annex (Annex E), replacing the discontinued PolyORB/GLADE runtime. alr build produces two ordinary tools:

• pcs_gnatdist -- the gnatdist replacement: builds a distributed application from its .cfg, auto-assembling the GARLIC runtime (a --RTS overlay of the toolchain's own runtime) on first use and re-assembling it when the toolchain changes;
• pcs_supervisor -- launches and restarts a built deployment per its .manifest.

System prerequisites beyond the toolchain: libzmq >= 4.x and zlib (pacman -S zeromq, apt install libzmq3-dev, pkg install libzmq4; Windows setup is in the README's Platforms section).

Start with docs/users-guide.md; examples/ holds runnable demos.

Aflex is a lexical analyzer generating tool similar to the Unix tool lex.

The first implementation was written by John Self of the Arcadia project at the University of California, Irvine. The last version that was released appeared to be the aflex 1.4a released in 1994.

Aflex was used and improved by P2Ada, the Pascal to Ada translator. This version of Aflex is derived from the P2Ada aflex implementation released in August 2010.

This version brings a number of improvements:

• Aflex generates the spec and body files as separate files so that there is no need to use gnatchop to split the DFA and IO files.
• Aflex uses the lex file name to generate the package name and it supports child package with the %unit directive.
• Aflex supports reentrant scanner through the use of %option reentrant, %yyvar and %yydecl directives.

This crate provides a library for designing high-quality industrial control widgets for Ada applications. The software is based on GtkAda, Ada bindings to Gtk+, and cairo.

The key features of the library are:

• Widgets composed of transparent layers drawn by cairo
• Fully scalable graphics
• Support of time controlled refresh policy for real-time and heavy-duty applications
• Caching graphical operations
• Stream I/O support for serialization and deserialization
• Ready-to-use gauge, meter, oscilloscope widgets
• Editor widget for WYSIWYG design of complex dashboards

For further information, visit the AICWL website.

Maintainer's note:

This Alire crate is packaged in a rather minimalistic way to keep dependencies on external libraries at a minimum. The crate's definition covers the core functionality of AICWL, though, so it should be sufficient for most needs.

For example, the original distribution has references to Simple Components which are not strictly necessary for the core functionality of the library.

Aion is a structured asynchronous runtime for Ada, built for reliable networking, deterministic concurrency, cancellation-safe tasks, futures, timers, channels, supervision, observability, and production-grade systems software.

Overview

AKT is a tool to store and protect your sensitive information and documents by encrypting them in secure keystore (AES-256, HMAC-256).

Create the keystore and protect it with a gpg public key:

   akt create secure.akt --gpg <keyid> ...

Store a small content:

   akt set secure.akt bank.password 012345

Store files, directory or a tar file:

   akt store secure.akt notes.txt
   akt store secure.akt contract.doc
   akt store secure.akt directory
   tar czf - . | akt store secure.akt -- backup

Edit a content with your $EDITOR:

   akt edit secure.akt bank.password
   akt edit secure.akt notes.txt

Get a content:

   akt get secure.akt bank.password
   akt extract secure.akt contract.doc
   akt extract secure.akt -- backup | tar xzf -

Documents

• Ada Keystore Guide PDF

ALI_Parse is a parser for the .ali files generated by the GNAT Ada compiler. ALI means Ada Library Information. You find the .ali files in the same directories as the object files (.o) containing the machine code produced by GNAT.

Currently, ALI_Parse is focused at cross-references within a set of Ada source files. Two command-line tools using the parser are provided:

• GNATHTML, which generates a set of Web pages from Ada sources
• ALI_Stats, which shows the list of entities, the list of cross-references, the count of references to each entity and the list of files.

ALI_Parse is pure Ada 2012 and doesn't depend on any other resource.

There are two prerequisites for your project to work with this tool:

• It has to be an Alire crate with an executables field. Its first value has to be the main application program. Otherwise, the executable program can be specified on the command line.
• It must be installable using Alire, including all the needed resources.

alr2appimage will use the following command for installing it (this requires Alire 2.0):

alr install

Or it will run gprinstall inside alr exec, if the former fails (Alire 1.x).

If you simply run the tool inside an Alire crate, it will read the metadata from your alire.toml file and create a default AppImage from it.

NOTE: alr2appimage is an independent project; it is not affiliated to, nor supported by, the Alire or AppImage projects.

PDF_Out is an Ada package for producing easily and automatically PDF files, from an Ada program, with text, vector graphics and raster graphics.

• Ideal for the dynamic production of reports, invoices, tickets, labels, delivery notes, charts, maps etc.
• Vector graphics
• Inclusion of JPEG images
• Object oriented
• Task safe
• Endian-neutral
• Multi-platform, but native code build
• Unconditionally portable code: OS-, CPU-, compiler- independent code
• Pure Ada 2012: this package can be used in projects in Ada 2012 and later language versions
• Free, open-source

The creation of a PDF file is as simple as this small procedure:

with PDF_Out;

procedure Small_Demo is
  pdf : PDF_Out.PDF_Out_File;
begin
  pdf.Create ("small.pdf");
  pdf.Put_Line ("This is a very small demo for PDF_Out...");
  pdf.Close;
end Small_Demo;

The resource embedder allows to embed files in binaries by producing C, Ada or Go source files that contain the original files.

To generate a config.ads and config.adb Ada package with the resources, you may use:

are --lang=Ada -o src --resource=config --name-access --fileset='**/*.conf' config

Complex resource integrations are best described with and XML and are generated with:

are --lang=Ada -o src --rule=package.xml --name-access .

For Ada, it generates the following package declaration with the Get_Content function that gives access to the files. The Ada body contains the content of each embedded file.

package Config is
  function Get_Content (Name : in String)
    return access constant String;
end Config;

ASFML is an Ada semi-thick binding to the SFML library. It uses Ada types and portable defined types which eliminates the inclusion of Ada interface libraries, but most of the functions are directly imported.

Documentation

Generated API documentation can be consulted online.

The Ada API follows the CSFML interface, but with some changes and additions for ease of use.

Applicability of the SFML documentation is usually straightforward.

Useful for writing shell-like applications or applications which start, stop and interact with spawned OS programs.

Atari ATR Tools is a versatile, cross-platform utility written in Ada 2022 for managing ATR disk image files used by Atari 8-bit emulators (e.g., Altirra, Atari800) and hardware add-ons like SIO2PC. Unlike most existing tools, which are Windows-only, this tool runs seamlessly on macOS, Linux, and Windows, making it ideal for retro computing enthusiasts across all major platforms.

Key features include:

Header Analysis: Display detailed metadata of ATR files, including sector size, disk density, track count, and boot sector presence.

  > atr_tools-main --print-header test-DD-DS-80.atr
  File name	   : test-DD-DS-80.atr
  Magic		   :	  16#296#
  Paragraphs	   :	    46056
  Sector size	   :	      256
  Flags		   :	     2#1#
  Bad Sectors	   :		0
  Unused	   :	    16#0#
  Sectors	   :	     2880
  Bytes		   :	   736896
  Boot Sectors	   : true
  Floppy disk double density, double sided, 80 track

Floppy Image Creation: Format and create ATR files for various disk configurations (e.g., single-sided, double-density, 80 tracks).

> atr_tools-main --verbose --format-floppy --density=DD --side=SS --track=80 test-DD-SS-80.atr
File created	 : test-DD-SS-80.atr
Sector size	 :	    256
Sector per track :	     18
Tracks per side  :	     80
Sides per disk	 :	      1

The tool includes a comprehensive test suite to ensure reliability across platforms and configurations. Source code and tests are available on SourceForge. Detailed GNATdoc documentation can be found at 6502 Tutorial.

Atari EXE Tools is a robust, cross-platform utility written in Ada 2022 for analysing Atari 8-bit executable (EXE) files, used in Atari 400/800 and XL/XE systems or emulators like Altirra and Atari800. Unlike most existing tools, which are typically Windows-only, this tool operates seamlessly on macOS, Linux, and Windows, making it an essential asset for retro computing enthusiasts and developers working across diverse platforms.

Key features include:

Header Analysis: Extract and display detailed metadata from EXE files, including memory start/end addresses, segment lengths, and init/run vectors.

  > exe_tools-main --print-header ./test/share/atari_check_exe_test/HELLO_C.EXE
  File: ./test/share/atari_check_exe_test/HELLO_C.EXE
  Magic: $FFFF; Start: $2E00; End: $2EF5; Length: 246
  Magic: $0000; Start: $02E2; End: $02E3; Length: 2; Init: $2E47
  Magic: $0000; Start: $2400; End: $28DE; Length: 1247
  Magic: $0000; Start: $02E0; End: $02E1; Length: 2; Run: $2401

Data Dumping: Output hexadecimal data from EXE files for inspection, with ATASCII portions omitted to ensure compatibility with non-UTF-8 environments.

> exe_tools-main --print-data ./test/share/atari_check_exe_test/HELLO_A.EXE
File: ./test/share/atari_check_exe_test/HELLO_A.EXE
2400: 60 60 A2 00 A9 0B 9D 42 03 A9 3F 9D 44 03 A9 24
2410: 9D 45 03 A9 2E 9D 48 03 A9 00 9D 49 03 20 56 E4
2420: A2 00 A9 07 9D 42 03 A9 6D 9D 44 03 A9 24 9D 45
2430: 03 A9 01 9D 48 03 A9 00 9D 49 03 20 56 E4 60 48
2440: 65 6C 6C 6F 20 57 6F 72 6C 64 21 9B 28 75 73 69
2450: 6E 67 20 61 20 65 78 65 63 75 74 61 62 6C 65 20
2460: 69 6E 20 61 73 73 65 6D 62 6C 65 72 29 9B 00
02E0: 02 24
Run: $2402

The tool includes a comprehensive AUnit test suite to ensure reliability across platforms and Atari 8-bit configurations. Source code and tests are available on SourceForge. Detailed GNATdoc documentation can be found at 6502 Tutorial.

Audio Base

This crate contains basic Ada packages for audio applications.

Ada Wavefile Library

This crate contains Ada packages for wavefile I/O.

Ada Web Application is a framework to build a Web Application in Ada 2012. The framework provides several ready to use and extendable modules that are common to many web application. This includes the login, authentication, users, permissions, managing comments, tags, votes, documents, images. It provides a complete blog, question and answers and a wiki module.

AWA simplifies the Web Application development by taking care of user management with Google+, Facebook authentication and by providing the foundations on top of which you can construct your own application. AWA provides a powerful permission management that gives flexibility to applications to grant access and protect your user's resources.

Documentation

The Ada Web Application programmer's guide describes how to setup the framework, how you can setup and design your first web application with it, and it provides detailed description of AWA components:

• Ada Web Application programmer's guide PDF
• Ada Database Objects Programmer's Guide
• Ada Security Programmer's Guide
• Ada Utility Library Programmer's Guide

Ada Web Application is a framework to build a Web Application in Ada 2012. The framework provides several ready to use and extendable modules that are common to many web application. This includes the login, authentication, users, permissions, managing comments, tags, votes, documents, images. It provides a complete blog, question and answers and a wiki module.

This library provides a testing framework on top of AWA top help implementing unit tests for AWA applications.

Documentation

The Ada Web Application programmer's guide describes how to setup the framework, how you can setup and design your first web application with it, and it provides detailed description of AWA components:

• Ada Web Application programmer's guide PDF
• Ada Database Objects Programmer's Guide
• Ada Security Programmer's Guide
• Ada Utility Library Programmer's Guide

Ayacc is an Ada parser generator in the style of yacc(1).

The first implementation was written by David Taback and Deepak Tolani at the University of California, Irvine. The last version that was released appeared to be the Ayacc 1.1 released in 1994.

Ayacc was used and improved by P2Ada, the Pascal to Ada translator. This version of Ayacc is derived from the P2Ada ayacc implementation released in August 2010.

This version brings a number of improvements:

• Ayacc now uses more standard options to configure the code generation
• The parser was improved to configure the parser stack size and support Ada child packages.
• The grammar supports the %unit directive to control the Ada child packages.
• Several options provide a better control of the generated code.
• Ayacc can generate a reentrant parser.

AZip is a free Zip Archive Manager with unique features such as: built-in content Search, smart archive Update, archive Recompression.

Features:

• In addition to usual archive management (Add / Remove / Extract files), AZip provides the following unique functions:
• Super-fast in-archive Search function: content and/or entry name search through a Zip archive. No temp files written!
• Smart archive Updater: changes only new, modified files
• Archive Recompression: makes Zip archives smaller
• Easy toggle from Flat view to Tree view, and back
• Multi-document
• Compression methods supported: Reduce, Shrink, Implode, Deflate, Deflate64, BZip2, LZMA
• Encryption
• Portable (no installation needed, no DLL)
• Can operate with a config file instead of the registry (stealth mode)
• Installable if desired (application is its own installer)
• Compatible with other Zip archivers, regardless of the Operating System
• Free, Open-Source

Some features:

• 1D bar codes supported: Code 128, EAN-13, MSI, UPC-A
• 2D bar codes supported: Data Matrix, QR Codes
• Task safe
• Endian-neutral
• Multi-platform, but native code build
• Standalone (no dependency on other libraires, bindings, etc.; no extra component needed for running)
• Unconditionally portable code: OS-, CPU-, compiler- independent code.
• Pure Ada 2012: this package can be used in projects in Ada 2012 and later versions of the Ada language
• Tests and demos included
• Free, open-source

The creation of a bar code is as simple as this small procedure:

with Ada.Text_IO, Bar_Codes, Bar_Codes_Media;

procedure Small_Demo is
  use Ada.Text_IO;
  svg : File_Type;
begin
  Create (svg, Out_File, "qr_code.svg");
  Put_Line
    (svg,
     Bar_Codes_Media.SVG_Bar_Code
       (Bar_Codes.Code_QR_Low, (5.0, 5.0, 100.0, 100.0), "mm", "Hello"));
  Close (svg);
end Small_Demo;

Usage

First edit you alire.toml file and add the following elements:

• Add bare_runtime in the dependency list:

  [[depends-on]]
  bare_runtime = "*"
  

• Add cross GNAT in the dependency list (e.g. gnat_arm_elf):

  [[depends-on]]
  gnat_arm_elf = "*"
  

• Set the architecture build switches, we use ARM Cortex-M4F as an example here:

  [gpr-set-externals]
  BARE_RUNTIME_SWITCHES = "-mlittle-endian -mthumb -mfloat-abi=hard -mcpu=cortex-m4 -mfpu=fpv4-sp-d16"
  

Then edit your project file to add the following elements:

• "with" the run-time project file. With this, gprbuild will compile the run-time before your application

  with "bare_runtime.gpr";
  

• Specify the Target and Runtime attributes:

     for Target use "arm-eabi";
     for Runtime ("Ada") use Bare_Runtime'Runtime ("Ada");