Bind to EXE Library for Delphi

From the developer: “”Bind to EXE library enables your application to bind/extract files to/from an executable file at runtime. It consists of two classes, TBindToEXE and TExtractFromEXE, corresponding to two working stages, i.e. binding and extracting stage. “”In binding stage, TBindToEXE can embed a collection of files in a single executable file dynamically. The embedded files can be compressed to reduce their size, or be encrypted to increase their securities. In extracting stage, TExtractFromEXE can retrieve information about the collection of files embedded in the executable file, or just extract one or more files from the executable file specified by their names or IDs.””The aaxBattery ActiveX Control is a component that gives you the state of the battery on your laptop/notebook computer. With this component, you can:In each case, they serve essentially the same purpose. These are libraries of code which may be loaded at run-time and provide access to some additional functionality.

In most cases to the operating system API will be exposed through these libraries. For example, under MS-Windows we have the Kernel32.dll and User32.dll libraries which provide the bulk of the Win32 api. Similarly under Linux operating systems the libc.so library offers access to operating system API features.

Dynamic Linking

As I said above, external libraries are loaded at run-time. This means that they are not statically linked to your application when it is built, but rather, they are loaded into your applications memory space as it runs. This is achieved by calling the OS API and requesting that it load the library, provide function pointers to the required functions, and ultimately unload the library when the application ends.

The Delphi compiler offers two mechanisms for loading dynamic libraries, each of which does the very same thing under the hood, but which affect the time at which the external library is loaded by your application. In the absence of good descriptive terminology for the two mechanisms, I’ll refer to them as Early Loading and Late Loading.

The first of these mechanisms, Early Loading, is to declare a prototype for the external library function in your code, which I’ll show you how to do shortly. This mechanism causes the compiler to inject the necessary code to load, bind to, and unload the library automatically. This means that the external library function is available from the very moment your application starts up. When using this mechanism, if the OS is unable to find the library, or if the function you are trying to load is not found within that library, an error (exception or otherwise) will be raised as your application starts up.

The second of these mechanisms, Late Loading, is that you declare the function as a function pointer, and manually request that the OS load your library, provide the function pointer, and unload your library when you’re done with it. This gives you more control over when the library is loaded, and can be useful in cases where the path to the library is unknown at the time of writing the application. Many plug-in systems function this way, for example, this is how Microsofts IIS web server loads ISAPI modules, which are simply DLL files.

In this post I’ll be showing you how to translate a function header for the Early Loading mechanism. In a later post I’ll follow up with an example of Late Loading.

As a side note, libraries may also be statically linked to your application using the first of the above mechanisms. When a library is statically linked to your application, that library is essentially copied into the executable file and is therefore always available, and does not require calls to the OS to load it. Static libraries however, are a subject for another blog post, and it is usually not possible to bind a library built for dynamic loading statically. For the remainder of this post, I’ll discard anything pertaining to static linking, and focus only on dynamic linking.

Library Headers

Most C/C++ developers will be familiar with header files. Essentially a header file contains a series of function prototypes for functions which are in external libraries.This is the C/C++ equivalent of the first loading mechanism that I described above. The compiler will load the dynamic library and acquire the function pointers automatically when the application starts up.

Since C/C++ are the languages used to write the majority of popular operating systems, and therefore also their API libraries and the majority of third party libraries, header files are usually provided for these libraries in the C/C++ languages. This poses the first problem for us Delphi developers wanting to use dynamic libraries, we must first obtain or write translations of the header files in pascal.

Often, if the library you’d like to use is very popular, someone else will already have written the header translation and made it available online. This is the case for example with the OpenGL and DirectX libraries. In order to use these libraries, you simply need to download the appropriate header files. In many cases however, such translations aren’t readily available, and you’ll be in the position of writing your own translation.

There are some tools available which can parse C/C++ headers and generate the pascal equivalent for Delphi. These tools however, have varied capabilities, and rarely do a complete or even a ‘good’ job of translating the headers. Instead, though it involves a little more work, it’s usually beneficial to manually port the functions that you need. Though doing so may/will require at least some knowledge of C syntax in order that you can write the equivalent function prototype.

Example translation

In my recent webinar, I manually translated three function prototypes from the libc libarary, on of the Linux API libraries, into pascal. For C&C++ compilers the prototypes for libc are divided among several header files, the functions which I translated are part of the stdio.h header file. In this case however, I did not translate the header it’s self, but rather, I grabbed the function prototypes that I needed from online documentation.

The three functions are popen(), pclose(), and fgets(). The online documentation for these three functions can be found at man7.

The documentation for each of these functions contains the C/C++ function prototype. Lets take a look at the fgets() function first, since it’s actually the simplest to translate. Here are the C and Pascal versions of the function prototype.

• Get the battery life in percent and time;
• Get the charging status of the battery;
• Get the AC Line state.

• Create and validate signatures over PDF, XML, and Office documents
• Manage X.509 certificates easily and transparently on all platforms
• Integrate swiftly to local, national, and international PKI environments