Emmanuel Briot

GtkAda: Design and Implementation of a High Level Binding in Ada

The purpose of this paper is to describe the design and implementation choices that were made during the development of an Ada binding to the popular Gtk+ graphical toolkit. We concentrate on the methods used to interface between C and Ada, but many topics described in this paper are not tied to Ada and can be applied to other high level languages that need to interface with existing libraries. We also describe the various mechanisms developed to provide a powerful GUI builder with GtkAda.

Gem #105: lady Ada kisses python -- part 1

The GNAT Components Collection (GNATCOLL) has included, since the beginning, a collection of packages to easily interface your Ada applications with scripting languages. This is the layer used in the GPS IDE to provide extensibility via the GPS shell or Python. The use with the GPS shell is just a toy we initially used to bootstrap the process, and was kept for backward compatibility only. On the other hand, Python is an extensively used object-oriented language that comes with its own run-time library, and can be easily extended in C or Ada.

Gem #114: Logging with GNATCOLL.Traces

When we write applications, we often add Put_Line statements to help debug the initial version of the code. Once that code works, we remove the Put_Line and move on to some other feature of the code. The problem is that when a bug occurs again in that part of the code (and especially when this is reported by a user and you can’t debug on his machine), the output would still be useful, but it’s no longer present in the executable.

Gem #118: File-System Portability Issues and GNATCOLL.VFS

There are several aspects of the handling of file names that vary across file systems. For one, the file system might be case-sensitive or case-insensitive. This refers to whether casing of the name is relevant when accessing a file on the disk. In addition, the file system can be case-preserving or not. On some systems, file names are converted to upper case systematically when they are displayed (MS-DOS and VMS are in that category). Systems that do not preserve casing are always case-insensitive.

Gem #117: Design Pattern: Overridable Class Attributes in Ada 2012

Let’s consider an example where this is useful. For instance, let’s say we want to define the notion of a block of text that is generated by expanding a template (perhaps after we replace some parameters in that template, as can be done with AWS’s templates parser, for instance). Once we have computed those parameters, we might want to generate multiple outputs (for instance HTML and CSV). Only the template needs to change, not the computation of the parameters.

Gem #100: reference counting in Ada -- part 3: weak references

There is one thing that reference-counted types cannot handle as well as a full-scale garbage collector: cycles. If A references B which references A, neither of them will ever get freed. A garbage collector is often able to detect such cycles and deallocate all the objects as appropriate, but such a case cannot be handled automatically through reference counting. However, theres a variant approach that can handle such cases with only minor changes in the code.

Gem #97: reference counting in Ada -- part 1

Memory management is typically a complex issue to address when creating an application, and even more so when creating a library to be reused by third-party applications. It is necessary to document which part of the code allocates memory and which part is supposed to free that memory. As we have seen in a previous Gem, a number of tools exist for detecting memory leaks (gnatmem, GNATCOLL.Memory or valgrind). But of course, it would be more convenient if the memory were automatically managed.

Gem #99: reference counting in Ada -- part 2: task safety

In Part 1, we described a reference-counted type that automatically frees memory when the last reference to it disappears. But this type is not task safe: when we decrement the counter, it might happen that two tasks see it as 0, and thus both will try to free the data. Likewise, the increment of the counter in Adjust is not an atomic operation, so it is possible that we will be missing some references.

Gem #77: where did my memory go? (part 1)

Ada Gem #77 --- A number of tools and libraries exist to monitor memory usage, detect memory leaks, and more generally solve issues with memory management. This Gem, and others to follow, offer an overview of these issues and explain how you can benefit from these tools in your own development.

Gem #65: gprbuild

gprbuild is a new program builder, superseding gnatmake. It supports multiple languages, automatically manages source dependencies, and reduces the need for recompilation. This Gem describes a high-level view of how gprbuild works.