RE: Building under Ubuntu - Coast/Estuary - Delft3D - catchsomeair.us
aclocal -I m4 /bin/bash: aclocal command not found Makefile recipe for target 'aclocal.m4' failed make: *** [aclocal.m4] Error. /comum/workspace/portfwd/config/missing aclocal WARNING: Makefile recipe for target 'aclocal.m4' failed make: *** [aclocal.m4] Error 1 . Node-RED: (used to create component relationship/integration). /bin/sh /home/conrad/src/sh/catchsomeair.us aclocal Makefile recipe for target 'aclocal.m4' failed make: *** [aclocal.m4] Error
An understanding of GNU autotools automake, autoconf etc. Finding and correcting build issues is often easier if the build system is not seen simply as a scary black box.
catchsomeair.us error: 'AM_CONFIG_HEADER': this macro is obsolete. - GNUnet Bugtracking
The autotools input files can help when determining a package's build-time dependencies. The risk of accidentally breaking something by patching the wrong file at the wrong time is greatly reduced if the relationship between the build system files is understood. Major Autotools Components Autotools is a collection of related packages which, when used together, remove much of the difficulty involved in creating portable software.
These tools, together with a few relatively simple upstream-supplied input files, are used to create the build system for a package. A basic overview of how the main autotools components fit together.
In a simple setup: The autoconf program produces a configure script from either configure. The automake program produces a Makefile.
The configure script is run to produce one or more Makefile files from Makefile. The make program uses the Makefile to compile the program. However, the GNU documentation now recommends configure. The files perform the same purpose and have the same format — the only difference is the name. You may see autotools being used in a variety of phase functions. This is now the appropriate place to manipulate the source code prior to configuration and compilation.
The autoreconf tool supposedly runs autoconf and automake, autoheader, aclocal, autopoint and libtoolize as necessary. Some packages ship a shell script named autogen. You must not attempt to modify any of the generated files in between running configure and make. This can lead to autotools trying to be clever and recreate the files, in turn leading to your changes being removed. In some situations this will also result in. The best way to proceed is usually to work with the.
Simple Autotools Patching Example The following snippet illustrates the correct way to proceed after patching either Makefile. However, these steps can sometimes take a while and may produce no output, so it may make sense to let the user know that something is still happening.
It consists of a series of macros which are processed and expanded by autoconf. These macros can check for packages and libraries, handle --enable and --with switches, and generate various files. Basic Format of configure. Indenting and whitespace are largely irrelevant.
Comments are indicated by the string dnl dnl is actually a macro which discards the remainder of the input — it stands for "discard new line".
If the previous sentence made you uneasy, you should probably stop reading this page. It gets far worse. A typical file might start with something like the following: This is useful, because autoconf is not compatible between versions.
Again, there is little chance that an automake Other distributions may handle things differently. Usually, some standard checks will follow: The file will finish with some output functions: The single most significant difference between a successful free software project and one that rarely gets a second glance can be found deep in the heart of project maintenance details.
These details include providing the so-called "standard make targets". Potential users become disgusted with a project fairly easily--especially when certain bits of expected functionality are missing or improperly written. Users have come to expect certain more or less standard make targets. A make target is a goal specified on the make command line: Common make targets include all, clean and install, among others. You'll note that none of these are real targets. A real target is a file produced by the build system.
If you're building an executable called doofabble, then you'd expect to be able to type: But specifying real targets on the make command line is more work than necessary. Each project must be built differently--make doofabble, make foodabble, make abfooble, etc. Why not just type make or make all, if there is more than one binary to be made?
So all has become an expected pseudo-target, but "expected" doesn't mean "automatic". Supporting the expected set of standard targets can be fairly challenging. As with configuration scripts, the most widely used implementation is one written in the late 80's and copied from project to project throughout the internet.
Because writing it yourself is error prone. In fact, copying it is just as error-prone. It's like getting a linked-list implementation right the first time. The process is well-understood by any veteran software engineer, but it still rarely happens. Automake's job is to convert a much simplified specification of your project's build process into standard boilerplate makefile syntax that always works correctly the first time, and provides all the standard functionality expected of a free software project.
The Automake package provides the following tools in the form of perl scripts: One of the most interesting and useful aspects of the way Automake works is that the Makefile. If you put only the few required Automake definitions in a Makefile. But if you add additional makefile syntax to your Makefile. In fact, you can if you wish write pure make syntax in your Makefile.
This pass-through feature gives you the power and flexibility to extend Automake's functionality with your project's own special requirements. Aclocal The aclocal utility is actually documented by the GNU manuals as a temporary work-around for a certain lack of flexibility in Autoconf. Autoconf was designed and written first, and then a few years later, the idea for Automake was conceived as an add-on for Autoconf.
But Autoconf was really not designed to be extensible on the scale required by Automake.
- Posts navigation
Automake adds an extensive set of macros to those provided by Autoconf. The originally documented method for adding user-defined macros to an Autoconf project was to create a file called aclocal. Any user-provided extension macros were to be placed in this file, and Autoconf would automatically read it while processing configure.
From the perspective of the Automake designers, this existing extension mechanism was too good to pass up. Instead, the aclocal utility was designed to create a project's aclocal. Since Automake's aclocal utility basically took over aclocal. Essentially, aclocal's job is to create an aclocal. For the sake of modularity, the Autoconf manual is still unaware of the aclocal utility--for the most part.
The current revision of the manual rants a bit on the subject of where aclocal functionality should actually be. Automake's manual originally suggested that you should rename aclocal. This method is still followed rigorously in new projects. The current recommendation is that you create a directory in your project directory called simply m4 acinclude seems more appropriate to this authorand add macros in the form of individual.
All files in this directory will be gathered into aclocal.
Ultimately, aclocal will be replaced by functionality in Autoconf itself. Given the fairly complex nature of aclocal functionality, and given that most of the other tools are already written in perl, I'm guessing that Autoconf will be rewritten in perl, at this point.
Chapter 1: A brief introduction to the GNU Autotools
Aclocal data flow diagram With aclocal behind us, it should be more apparent now why the aclocal. When used without Automake and Libtool, the aclocal. Libtool How do you build shared libraries on different Unix platforms without adding a lot of very platform-specific conditional code to your build system and source code?
This is the question that the Libtool package tries to address. There's a significant amount of visible functionality in Unix and Unix-like platforms that is the same from one platform to another.
However, one very significant difference is how shared libraries are built, named and managed. Some platforms don't even provide native shared libraries although it's rare these days. Some platforms name their libraries libsomething. Others provide other mechanisms--or none at all. All of these differences have been carefully considered by the authors of the Libtool project.
Dozens of platforms are currently supported by Libtool, and adding support for new platforms is done via the open source way--someone who cares and knows how supplies a patch to the Libtool mailing list, and the maintainers look it over and apply it to the source code for the next release. Libtool not only provides a set of Autoconf macros that hide library naming differences in makefiles, but it also provides an optional library of dynamic loader functionality that can be added to your programs, allowing you to write more portable runtime dynamic shared object management code.
The libool package provides the following programs, libraries and header files: There's nothing specific to a project in this particular copy of libtool. Libtoolize The libtoolize shell script is used to prepare your project to use Libtool. In reality, libtoolize generates a custom version of the libtool script in your project directory. This script is then executed at the appropriate time by Automake-generated makefiles.
The Libtool C API--ltdl The Libtool package also provides the ltdl library and header files, which provide a consistent run-time shared object manager across platforms. The ltdl library may be linked statically or dynamically into your programs, giving them a consistent runtime shared library access interface from one platform to another.
The following data flow diagram illustrates the interaction between Automake and Libtool scripts and input files to create products used by users to configure and build your project: Automake and Libtool data flow diagram Automake and Libtool are both standard pluggable options that can be added to configure.
Building your package While, as maintainer, you probably build your software packages a lot more often than do your users, you also have the advantage of being intimately familiar with your project's components, architecture and build system. That's why you ought to be concerned that your users' build experience is much simpler than yours. And it wouldn't hurt a bit if you got some benefit from this concern, as well.
Running configure Once the Autotools have finished their work, you're left with a shell script called configure, and one or more Makefiles. These product files are intended to be packages with project release distribution packages. Your users download these packages, unpack them, and run configure and make. The configure script generates Makefiles from the Makefile. It also generates a config.
So why didn't the Autotools just generate the makefiles directly to be shipped with your release? One reason is that without makefiles, you can't run make. This means that you're forced to run configure first, after you download and unpack a project distribution package.
And they do a lot more than most people are willing to hand code into a set of makefiles. Another reason is that the configure script may then insert platform-characteristics and user-specified optional features directly into your makefiles, making them more specifically tailored to the platforms on which they are being used.